2803502482

Committed 05 Aug 2022 12:18PM UTC coverage: 41.604% (-0.01%) from 41.614%

Build Type

github

Committed by GitHub

Commit Message

Merge 449ec7df8 into bd6ea8b70

Pull Request Pull Request #4041: Release 3.29.1

Run Details

1758 of 5117 branches covered (34.36%)

Branch coverage included in aggregate %.

12 of 21 new or added lines in 5 files covered. (57.14%)

1 existing line in 1 file now uncovered.

4585 of 10129 relevant lines covered (45.27%)

38.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

34.88

/src/logic/contracts/safeContracts.ts

import semverSatisfies from 'semver/functions/satisfies'
import {
  getSafeSingletonDeployment,
  getSafeL2SingletonDeployment,
  getProxyFactoryDeployment,
  getFallbackHandlerDeployment,
  getMultiSendCallOnlyDeployment,
  getSignMessageLibDeployment,
  SingletonDeployment,
} from '@gnosis.pm/safe-deployments'
import Web3 from 'web3'
import { AbiItem } from 'web3-utils'

import { LATEST_SAFE_VERSION } from 'src/utils/constants'
import { getChainById, _getChainId } from 'src/config'
import { ChainId } from 'src/config/chain.d'
import { ZERO_ADDRESS } from 'src/logic/wallets/ethAddresses'
import { calculateGasOf, EMPTY_DATA } from 'src/logic/wallets/ethTransactions'
import { getWeb3 } from 'src/logic/wallets/getWeb3'
import { GnosisSafe } from 'src/types/contracts/gnosis_safe.d'
import { ProxyFactory } from 'src/types/contracts/proxy_factory.d'
import { CompatibilityFallbackHandler } from 'src/types/contracts/compatibility_fallback_handler.d'
import { SignMessageLib } from 'src/types/contracts/sign_message_lib.d'
import { MultiSend } from 'src/types/contracts/multi_send.d'
import { getSafeInfo } from 'src/logic/safe/utils/safeInformation'
import { NonPayableTransactionObject } from 'src/types/contracts/types'
import { getMultiSendDeployment } from '@gnosis.pm/safe-deployments/dist/libs'
import { MultiSendCallOnly } from 'src/types/contracts/multi_send_call_only'

export const SENTINEL_ADDRESS = '0x0000000000000000000000000000000000000001'

let proxyFactoryMaster: ProxyFactory
let safeMaster: GnosisSafe
let fallbackHandler: CompatibilityFallbackHandler
let multiSendCallOnly: MultiSendCallOnly
let multiSend: MultiSend

const getSafeContractDeployment = ({ safeVersion }: { safeVersion: string }): SingletonDeployment | undefined => {
  // We check if version is prior to v1.0.0 as they are not supported but still we want to keep a minimum compatibility
  const useOldestContractVersion = semverSatisfies(safeVersion, '<1.0.0')
  // We have to check if network is L2
  const networkId = _getChainId()
  const chainConfig = getChainById(networkId)

  // We had L1 contracts in three L2 networks, xDai, EWC and Volta so even if network is L2 we have to check that safe version is after v1.3.0
  const useL2ContractVersion = chainConfig.l2 && semverSatisfies(safeVersion, '>=1.3.0')
  const getDeployment = useL2ContractVersion ? getSafeL2SingletonDeployment : getSafeSingletonDeployment

  return (
    getDeployment({
      version: safeVersion,
      network: networkId.toString(),
    }) ||
    getDeployment({
      version: safeVersion,
    }) ||
    // In case we couldn't find a valid deployment and it's a version before 1.0.0 we return v1.0.0 to allow a minimum compatibility
    (useOldestContractVersion
      ? getDeployment({
          version: '1.0.0',
        })
      : undefined)
  )
}

/**
 * Creates a Contract instance of the GnosisSafe contract
 * @param {Web3} web3
 * @param {ChainId} chainId
 */
const getGnosisSafeContractInstance = (web3: Web3, chainId: ChainId): GnosisSafe => {
  const safeSingletonDeployment = getSafeContractDeployment({ safeVersion: LATEST_SAFE_VERSION })
  const contractAddress = safeSingletonDeployment?.networkAddresses[chainId]

  if (!contractAddress) {
    throw new Error(`GnosisSafe contract not found for chainId: ${chainId}`)
  }

  return new web3.eth.Contract(safeSingletonDeployment?.abi as AbiItem[], contractAddress) as unknown as GnosisSafe
}

/**
 * Creates a Contract instance of the GnosisSafeProxyFactory contract
 * @param {Web3} web3
 * @param {ChainId} chainId
 */
const getProxyFactoryContractInstance = (web3: Web3, chainId: ChainId): ProxyFactory => {
  const proxyFactoryDeployment =
    getProxyFactoryDeployment({
      version: LATEST_SAFE_VERSION,
      network: chainId.toString(),
    }) ||
    getProxyFactoryDeployment({
      version: LATEST_SAFE_VERSION,
    })
  const contractAddress = proxyFactoryDeployment?.networkAddresses[chainId]

  if (!contractAddress) {
    throw new Error(`GnosisSafeProxyFactory contract not found for chainId: ${chainId}`)
  }

  return new web3.eth.Contract(proxyFactoryDeployment?.abi as AbiItem[], contractAddress) as unknown as ProxyFactory
}

/**
 * Creates a Contract instance of the FallbackHandler contract
 * @param {Web3} web3
 * @param {ChainId} chainId
 */
const getFallbackHandlerContractInstance = (web3: Web3, chainId: ChainId): CompatibilityFallbackHandler => {
  const fallbackHandlerDeployment =
    getFallbackHandlerDeployment({
      version: LATEST_SAFE_VERSION,
      network: chainId.toString(),
    }) ||
    getFallbackHandlerDeployment({
      version: LATEST_SAFE_VERSION,
    })
  const contractAddress = fallbackHandlerDeployment?.networkAddresses[chainId]

  if (!contractAddress) {
    throw new Error(`FallbackHandler contract not found for chainId: ${chainId}`)
  }

  return new web3.eth.Contract(
    fallbackHandlerDeployment?.abi as AbiItem[],
    contractAddress,
  ) as unknown as CompatibilityFallbackHandler
}

/**
 * Creates a Contract instance of the MultiSend contract
 * @param {Web3} web3
 * @param {ChainId} chainId
 */
const getMultiSendCallOnlyContractInstance = (web3: Web3, chainId: ChainId): MultiSendCallOnly => {
  const multiSendDeployment =
    getMultiSendCallOnlyDeployment({
      network: chainId.toString(),
    }) || getMultiSendCallOnlyDeployment()
  const contractAddress = multiSendDeployment?.networkAddresses[chainId]

  if (!contractAddress) {
    throw new Error(`MultiSendCallOnly contract not found for chainId: ${chainId}`)
  }

  return new web3.eth.Contract(multiSendDeployment?.abi as AbiItem[], contractAddress) as unknown as MultiSendCallOnly
}

/**
 * Creates a Contract instance of the MultiSend contract
 * @param {Web3} web3
 * @param {ChainId} chainId
 */
const getMultiSendContractInstance = (web3: Web3, chainId: ChainId): MultiSend => {
  const multiSendDeployment =
    getMultiSendDeployment({
      network: chainId.toString(),
    }) || getMultiSendDeployment()
  const contractAddress = multiSendDeployment?.networkAddresses[chainId]

  if (!contractAddress) {
    throw new Error(`MultiSend contract not found for chainId: ${chainId}`)
  }

  return new web3.eth.Contract(multiSendDeployment?.abi as AbiItem[], contractAddress) as unknown as MultiSend
}

/**
 * Returns an address of SignMessageLib for passed chainId
 * @param {ChainId} chainId
 * @returns {string}
 */
export const getSignMessageLibAddress = (chainId: ChainId): string | undefined => {
  const signMessageLibDeployment =
    getSignMessageLibDeployment({
      network: chainId.toString(),
    }) || getSignMessageLibDeployment()
  const contractAddress = signMessageLibDeployment?.networkAddresses[chainId]

  if (!contractAddress) {
    throw new Error(`SignMessageLib contract not found for chainId: ${chainId}`)
  }

  return contractAddress
}

/**
 * Returns a Web3 Contract instance of the SignMessageLib contract
 * @param {Web3} web3
 * @param {ChainId} chainId
 * @returns {SignMessageLib}
 */
export const getSignMessageLibContractInstance = (web3: Web3, chainId: ChainId): SignMessageLib => {
  const signMessageLibDeployment =
    getSignMessageLibDeployment({
      network: chainId.toString(),
    }) || getSignMessageLibDeployment()
  const contractAddress = signMessageLibDeployment?.networkAddresses[chainId]

  if (!contractAddress) {
    throw new Error(`SignMessageLib contract not found for chainId: ${chainId}`)
  }

  return new web3.eth.Contract(signMessageLibDeployment?.abi as AbiItem[], contractAddress) as unknown as SignMessageLib
}

export const getMasterCopyAddressFromProxyAddress = async (proxyAddress: string): Promise<string | undefined> => {
  let masterCopyAddress: string | undefined
  try {
    const res = await getSafeInfo(proxyAddress)
    masterCopyAddress = res.implementation.value
    if (!masterCopyAddress) {
      console.error(`There was not possible to get masterCopy address from proxy ${proxyAddress}.`)
    }
  } catch (e) {
    e.log()
  }
  return masterCopyAddress
}

export const instantiateSafeContracts = (): void => {
  const web3 = getWeb3()
  const chainId = _getChainId()

  // Create ProxyFactory Master Copy
  proxyFactoryMaster = getProxyFactoryContractInstance(web3, chainId)

  // Create Safe Master copy
  safeMaster = getGnosisSafeContractInstance(web3, chainId)

  // Create Fallback Handler
  fallbackHandler = getFallbackHandlerContractInstance(web3, chainId)

  // Create MultiSend contract
  multiSend = getMultiSendContractInstance(web3, chainId)

  // Create MultiSendCallOnly contract
  multiSendCallOnly = getMultiSendCallOnlyContractInstance(web3, chainId)
}

export const getSafeMasterContract = (): GnosisSafe => {
  instantiateSafeContracts()
  return safeMaster
}

export const getSafeMasterContractAddress = (): string => {
  return safeMaster.options.address
}

export const getFallbackHandlerContractAddress = (): string => {
  return fallbackHandler.options.address
}

export const getMultiSendCallOnlyContract = (): MultiSendCallOnly => {
  return multiSendCallOnly
}

export const getMultiSendCallOnlyContractAddress = (): string => {
  return multiSendCallOnly.options.address
}

export const getMultiSendContract = (): MultiSend => {
  return multiSend
}

export const getMultiSendContractAddress = (): string => {
  return multiSend.options.address
}

export const getSafeDeploymentTransaction = (
  safeAccounts: string[],
  numConfirmations: number,
  safeCreationSalt: number,
): NonPayableTransactionObject<string> => {
  const gnosisSafeData = safeMaster.methods
    .setup(
      safeAccounts,
      numConfirmations,
      ZERO_ADDRESS,
      EMPTY_DATA,
      fallbackHandler.options.address,
      ZERO_ADDRESS,
      0,
      ZERO_ADDRESS,
    )
    .encodeABI()
  return proxyFactoryMaster.methods.createProxyWithNonce(safeMaster.options.address, gnosisSafeData, safeCreationSalt)
}

export const estimateGasForDeployingSafe = async (
  safeAccounts: string[],
  numConfirmations: number,
  userAccount: string,
  safeCreationSalt: number,
): Promise<number> => {
  const proxyFactoryData = getSafeDeploymentTransaction(safeAccounts, numConfirmations, safeCreationSalt).encodeABI()

  return calculateGasOf({
    data: proxyFactoryData,
    from: userAccount,
    to: proxyFactoryMaster.options.address,
  }).then((value) => value * 2)
}

export const getGnosisSafeInstanceAt = (safeAddress: string, safeVersion: string): GnosisSafe => {
  const safeSingletonDeployment = getSafeContractDeployment({ safeVersion })

  const web3 = getWeb3()
  return new web3.eth.Contract(safeSingletonDeployment?.abi as AbiItem[], safeAddress) as unknown as GnosisSafe
}

1	import semverSatisfies from 'semver/functions/satisfies'
2	import {
3	getSafeSingletonDeployment,
4	getSafeL2SingletonDeployment,
5	getProxyFactoryDeployment,
6	getFallbackHandlerDeployment,
7	getMultiSendCallOnlyDeployment,
8	getSignMessageLibDeployment,
9	SingletonDeployment,
10	} from '@gnosis.pm/safe-deployments'
11	import Web3 from 'web3'
12	import { AbiItem } from 'web3-utils'
13
14	import { LATEST_SAFE_VERSION } from 'src/utils/constants'
15	import { getChainById, _getChainId } from 'src/config'
16	import { ChainId } from 'src/config/chain.d'
17	import { ZERO_ADDRESS } from 'src/logic/wallets/ethAddresses'
18	import { calculateGasOf, EMPTY_DATA } from 'src/logic/wallets/ethTransactions'
19	import { getWeb3 } from 'src/logic/wallets/getWeb3'
20	import { GnosisSafe } from 'src/types/contracts/gnosis_safe.d'
21	import { ProxyFactory } from 'src/types/contracts/proxy_factory.d'
22	import { CompatibilityFallbackHandler } from 'src/types/contracts/compatibility_fallback_handler.d'
23	import { SignMessageLib } from 'src/types/contracts/sign_message_lib.d'
24	import { MultiSend } from 'src/types/contracts/multi_send.d'
25	import { getSafeInfo } from 'src/logic/safe/utils/safeInformation'
26	import { NonPayableTransactionObject } from 'src/types/contracts/types'
27	import { getMultiSendDeployment } from '@gnosis.pm/safe-deployments/dist/libs'
28	import { MultiSendCallOnly } from 'src/types/contracts/multi_send_call_only'
29
30	export const SENTINEL_ADDRESS = '0x0000000000000000000000000000000000000001'	103✔
31
32	let proxyFactoryMaster: ProxyFactory
33	let safeMaster: GnosisSafe
34	let fallbackHandler: CompatibilityFallbackHandler
35	let multiSendCallOnly: MultiSendCallOnly
36	let multiSend: MultiSend
37
38	const getSafeContractDeployment = ({ safeVersion }: { safeVersion: string }): SingletonDeployment \| undefined => {	103✔
39	// We check if version is prior to v1.0.0 as they are not supported but still we want to keep a minimum compatibility
40	const useOldestContractVersion = semverSatisfies(safeVersion, '<1.0.0')	14✔
41	// We have to check if network is L2
42	const networkId = _getChainId()	14✔
43	const chainConfig = getChainById(networkId)	14✔
44
45	// We had L1 contracts in three L2 networks, xDai, EWC and Volta so even if network is L2 we have to check that safe version is after v1.3.0
46	const useL2ContractVersion = chainConfig.l2 && semverSatisfies(safeVersion, '>=1.3.0')	14!
47	const getDeployment = useL2ContractVersion ? getSafeL2SingletonDeployment : getSafeSingletonDeployment	14!
48
49	return (	14✔
50	getDeployment({	14!
51	version: safeVersion,
52	network: networkId.toString(),
53	}) \|\|
54	getDeployment({
55	version: safeVersion,
56	}) \|\|
57	// In case we couldn't find a valid deployment and it's a version before 1.0.0 we return v1.0.0 to allow a minimum compatibility
58	(useOldestContractVersion	×
59	? getDeployment({
60	version: '1.0.0',
61	})
62	: undefined)
63	)
64	}
65
66	/**
67	* Creates a Contract instance of the GnosisSafe contract
68	* @param {Web3} web3
69	* @param {ChainId} chainId
70	*/
71	const getGnosisSafeContractInstance = (web3: Web3, chainId: ChainId): GnosisSafe => {	103✔
72	const safeSingletonDeployment = getSafeContractDeployment({ safeVersion: LATEST_SAFE_VERSION })	×
73	const contractAddress = safeSingletonDeployment?.networkAddresses[chainId]	×
74
75	if (!contractAddress) {	×
76	throw new Error(`GnosisSafe contract not found for chainId: ${chainId}`)	×
77	}
78
79	return new web3.eth.Contract(safeSingletonDeployment?.abi as AbiItem[], contractAddress) as unknown as GnosisSafe	×
80	}
81
82	/**
83	* Creates a Contract instance of the GnosisSafeProxyFactory contract
84	* @param {Web3} web3
85	* @param {ChainId} chainId
86	*/
87	const getProxyFactoryContractInstance = (web3: Web3, chainId: ChainId): ProxyFactory => {	103✔
88	const proxyFactoryDeployment =
89	getProxyFactoryDeployment({	×
90	version: LATEST_SAFE_VERSION,
91	network: chainId.toString(),
92	}) \|\|
93	getProxyFactoryDeployment({
94	version: LATEST_SAFE_VERSION,
95	})
96	const contractAddress = proxyFactoryDeployment?.networkAddresses[chainId]	×
97
98	if (!contractAddress) {	×
99	throw new Error(`GnosisSafeProxyFactory contract not found for chainId: ${chainId}`)	×
100	}
101
102	return new web3.eth.Contract(proxyFactoryDeployment?.abi as AbiItem[], contractAddress) as unknown as ProxyFactory	×
103	}
104
105	/**
106	* Creates a Contract instance of the FallbackHandler contract
107	* @param {Web3} web3
108	* @param {ChainId} chainId
109	*/
110	const getFallbackHandlerContractInstance = (web3: Web3, chainId: ChainId): CompatibilityFallbackHandler => {	103✔
111	const fallbackHandlerDeployment =
112	getFallbackHandlerDeployment({	×
113	version: LATEST_SAFE_VERSION,
114	network: chainId.toString(),
115	}) \|\|
116	getFallbackHandlerDeployment({
117	version: LATEST_SAFE_VERSION,
118	})
119	const contractAddress = fallbackHandlerDeployment?.networkAddresses[chainId]	×
120
121	if (!contractAddress) {	×
122	throw new Error(`FallbackHandler contract not found for chainId: ${chainId}`)	×
123	}
124
125	return new web3.eth.Contract(	×
126	fallbackHandlerDeployment?.abi as AbiItem[],
127	contractAddress,
128	) as unknown as CompatibilityFallbackHandler
129	}
130
131	/**
132	* Creates a Contract instance of the MultiSend contract
133	* @param {Web3} web3
134	* @param {ChainId} chainId
135	*/
136	const getMultiSendCallOnlyContractInstance = (web3: Web3, chainId: ChainId): MultiSendCallOnly => {	103✔
137	const multiSendDeployment =
138	getMultiSendCallOnlyDeployment({	×
139	network: chainId.toString(),
140	}) \|\| getMultiSendCallOnlyDeployment()
141	const contractAddress = multiSendDeployment?.networkAddresses[chainId]	×
142
NEW 143	if (!contractAddress) {	×
NEW 144	throw new Error(`MultiSendCallOnly contract not found for chainId: ${chainId}`)	×
145	}
146
NEW 147	return new web3.eth.Contract(multiSendDeployment?.abi as AbiItem[], contractAddress) as unknown as MultiSendCallOnly	×
148	}
149
150	/**
151	* Creates a Contract instance of the MultiSend contract
152	* @param {Web3} web3
153	* @param {ChainId} chainId
154	*/
155	const getMultiSendContractInstance = (web3: Web3, chainId: ChainId): MultiSend => {	103✔
156	const multiSendDeployment =
NEW 157	getMultiSendDeployment({	×
158	network: chainId.toString(),
159	}) \|\| getMultiSendDeployment()
NEW 160	const contractAddress = multiSendDeployment?.networkAddresses[chainId]	×
161
162	if (!contractAddress) {	×
163	throw new Error(`MultiSend contract not found for chainId: ${chainId}`)	×
164	}
165
166	return new web3.eth.Contract(multiSendDeployment?.abi as AbiItem[], contractAddress) as unknown as MultiSend	×
167	}
168
169	/**
170	* Returns an address of SignMessageLib for passed chainId
171	* @param {ChainId} chainId
172	* @returns {string}
173	*/
174	export const getSignMessageLibAddress = (chainId: ChainId): string \| undefined => {	103✔
175	const signMessageLibDeployment =
176	getSignMessageLibDeployment({	4!
177	network: chainId.toString(),
178	}) \|\| getSignMessageLibDeployment()
179	const contractAddress = signMessageLibDeployment?.networkAddresses[chainId]	4✔
180
181	if (!contractAddress) {	4!
182	throw new Error(`SignMessageLib contract not found for chainId: ${chainId}`)	×
183	}
184
185	return contractAddress	4✔
186	}
187
188	/**
189	* Returns a Web3 Contract instance of the SignMessageLib contract
190	* @param {Web3} web3
191	* @param {ChainId} chainId
192	* @returns {SignMessageLib}
193	*/
194	export const getSignMessageLibContractInstance = (web3: Web3, chainId: ChainId): SignMessageLib => {	103✔
195	const signMessageLibDeployment =
196	getSignMessageLibDeployment({	4!
197	network: chainId.toString(),
198	}) \|\| getSignMessageLibDeployment()
199	const contractAddress = signMessageLibDeployment?.networkAddresses[chainId]	4✔
200
201	if (!contractAddress) {	4!
202	throw new Error(`SignMessageLib contract not found for chainId: ${chainId}`)	×
203	}
204
205	return new web3.eth.Contract(signMessageLibDeployment?.abi as AbiItem[], contractAddress) as unknown as SignMessageLib	4✔
206	}
207
208	export const getMasterCopyAddressFromProxyAddress = async (proxyAddress: string): Promise<string \| undefined> => {	103✔
209	let masterCopyAddress: string \| undefined
210	try {	×
211	const res = await getSafeInfo(proxyAddress)	×
212	masterCopyAddress = res.implementation.value	×
213	if (!masterCopyAddress) {	×
214	console.error(`There was not possible to get masterCopy address from proxy ${proxyAddress}.`)	×
215	}
216	} catch (e) {
217	e.log()	×
218	}
219	return masterCopyAddress	×
220	}
221
222	export const instantiateSafeContracts = (): void => {	103✔
223	const web3 = getWeb3()	×
224	const chainId = _getChainId()	×
225
226	// Create ProxyFactory Master Copy
227	proxyFactoryMaster = getProxyFactoryContractInstance(web3, chainId)	×
228
229	// Create Safe Master copy
230	safeMaster = getGnosisSafeContractInstance(web3, chainId)	×
231
232	// Create Fallback Handler
233	fallbackHandler = getFallbackHandlerContractInstance(web3, chainId)	×
234
235	// Create MultiSend contract
236	multiSend = getMultiSendContractInstance(web3, chainId)	×
237
238	// Create MultiSendCallOnly contract
NEW 239	multiSendCallOnly = getMultiSendCallOnlyContractInstance(web3, chainId)	×
240	}
241
242	export const getSafeMasterContract = (): GnosisSafe => {	103✔
243	instantiateSafeContracts()	×
244	return safeMaster	×
245	}
246
247	export const getSafeMasterContractAddress = (): string => {	103✔
248	return safeMaster.options.address	×
249	}
250
251	export const getFallbackHandlerContractAddress = (): string => {	103✔
252	return fallbackHandler.options.address	×
253	}
254
255	export const getMultiSendCallOnlyContract = (): MultiSendCallOnly => {	103✔
NEW 256	return multiSendCallOnly	×
257	}
258
259	export const getMultiSendCallOnlyContractAddress = (): string => {	103✔
NEW 260	return multiSendCallOnly.options.address	×
261	}
262
263	export const getMultiSendContract = (): MultiSend => {	103✔
UNCOV 264	return multiSend	×
265	}
266
267	export const getMultiSendContractAddress = (): string => {	103✔
268	return multiSend.options.address	×
269	}
270
271	export const getSafeDeploymentTransaction = (	103✔
272	safeAccounts: string[],
273	numConfirmations: number,
274	safeCreationSalt: number,
275	): NonPayableTransactionObject<string> => {
276	const gnosisSafeData = safeMaster.methods	×
277	.setup(
278	safeAccounts,
279	numConfirmations,
280	ZERO_ADDRESS,
281	EMPTY_DATA,
282	fallbackHandler.options.address,
283	ZERO_ADDRESS,
284	0,
285	ZERO_ADDRESS,
286	)
287	.encodeABI()
288	return proxyFactoryMaster.methods.createProxyWithNonce(safeMaster.options.address, gnosisSafeData, safeCreationSalt)	×
289	}
290
291	export const estimateGasForDeployingSafe = async (	103✔
292	safeAccounts: string[],
293	numConfirmations: number,
294	userAccount: string,
295	safeCreationSalt: number,
296	): Promise<number> => {
297	const proxyFactoryData = getSafeDeploymentTransaction(safeAccounts, numConfirmations, safeCreationSalt).encodeABI()	×
298
299	return calculateGasOf({	×
300	data: proxyFactoryData,
301	from: userAccount,
302	to: proxyFactoryMaster.options.address,
303	}).then((value) => value * 2)	×
304	}
305
306	export const getGnosisSafeInstanceAt = (safeAddress: string, safeVersion: string): GnosisSafe => {	103✔
307	const safeSingletonDeployment = getSafeContractDeployment({ safeVersion })	14✔
308
309	const web3 = getWeb3()	14✔
310	return new web3.eth.Contract(safeSingletonDeployment?.abi as AbiItem[], safeAddress) as unknown as GnosisSafe	14✔
311	}

safe-global / safe-react / 2803502482

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous