gnosis / contract-proxy-kit / 453

pending completion

Build # 453

Build Type

Pull #126

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/gnosis/contract-proxy-kit/commit/<a class=hub.com/gnosis/contract-proxy-kit/commit/<a class="double-link" href="https://git"><a class=hub.com/gnosis/contract-proxy-kit/commit/<a class="double-link" href="https://git"><a class=hub.com/gnosis/contract-proxy-kit/commit/<a class="double-link" href="https://git"><a class=hub.com/gnosis/contract-proxy-kit/commit/456e8708f68d1c30d434c15684a44b9c7d92b627">456e8708f">&lt;a href=&quot;https://github.com/gnosis/contract-proxy-kit/commit/</a><a class="double-link" href="https://github.com/gnosis/contract-proxy-kit/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/gnosis/contract-proxy-kit/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/gnosis/contract-proxy-kit/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/gnosis/contract-proxy-kit/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/gnosis/contract-proxy-kit/commit/456e8708f68d1c30d434c15684a44b9c7d92b627">456e8708f</a><a href="https://github.com/gnosis/contract-proxy-kit/commit/456e8708f68d1c30d434c15684a44b9c7d92b627">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/gnosis/contract-proxy-kit/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/gnosis/contract-proxy-kit/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/gnosis/contract-proxy-kit/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/gnosis/contract-proxy-kit/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/gnosis/contract-proxy-kit/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/gnosis/contract-proxy-kit/commit/456e8708f68d1c30d434c15684a44b9c7d92b627&quot;&gt;456e8708f&lt;/a&gt;&lt;a href=&quot;https://github.com/gnosis/contract-proxy-kit/commit/456e8708f68d1c30d434c15684a44b9c7d92b627&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/gnosis/contract-proxy-kit/commit/&amp;lt;/a&... (continued)

Pull Request Pull Request #126: Contract v1.2.0

Run Details

241 of 358 branches covered (67.32%)

Branch coverage included in aggregate %.

150 of 150 new or added lines in 13 files covered. (100.0%)

496 of 600 relevant lines covered (82.67%)

140.63 hits per line

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

70.18

/src/CPK.ts

import multiSendAbi from './abis/MultiSendAbi.json'
import {
  defaultNetworks,
  NetworksConfig,
  NormalizedNetworksConfig,
  normalizeNetworksConfig
} from './config/networks'
import ContractManager from './contractManager'
import EthLibAdapter, { Contract } from './ethLibAdapters/EthLibAdapter'
import SafeAppsSdkConnector from './safeAppsSdkConnector'
import CpkTransactionManager from './transactionManagers/CpkTransactionManager'
import TransactionManager from './transactionManagers/TransactionManager'
import { Address } from './utils/basicTypes'
import { predeterminedSaltNonce } from './utils/constants'
import { getHexDataLength, joinHexData } from './utils/hexData'
import {
  ExecOptions,
  normalizeGasLimit,
  OperationType,
  standardizeSafeAppsTransaction,
  standardizeTransaction,
  StandardTransaction,
  Transaction,
  TransactionResult
} from './utils/transactions'
import { checkConnectedToSafe } from './utils/checkConnectedToSafe'

export interface CPKConfig {
  ethLibAdapter: EthLibAdapter
  transactionManager?: TransactionManager
  ownerAccount?: string
  networks?: NetworksConfig
  saltNonce?: string
}

class CPK {
  static Call = OperationType.Call
  static DelegateCall = OperationType.DelegateCall

  #safeAppsSdkConnector: SafeAppsSdkConnector
  #ethLibAdapter?: EthLibAdapter
  #transactionManager?: TransactionManager
  #contractManager?: ContractManager

  #networks: NormalizedNetworksConfig
  #ownerAccount?: Address
  #saltNonce = predeterminedSaltNonce
  #isConnectedToSafe = false

  static async create(opts?: CPKConfig): Promise<CPK> {
    const cpk = new CPK(opts)
    if (opts) {
      await cpk.init()
    }
    return cpk
  }

  constructor(opts?: CPKConfig) {
    this.#safeAppsSdkConnector = new SafeAppsSdkConnector()
    this.#networks = {
      ...defaultNetworks
    }
    if (!opts) {
      return
    }
    const { ethLibAdapter, transactionManager, ownerAccount, networks, saltNonce } = opts
    if (!ethLibAdapter) {
      throw new Error('ethLibAdapter property missing from options')
    }
    this.#ethLibAdapter = ethLibAdapter
    this.#transactionManager = transactionManager ?? new CpkTransactionManager()
    this.#ownerAccount = ownerAccount
    this.#networks = normalizeNetworksConfig(defaultNetworks, networks)
    if (saltNonce) {
      this.#saltNonce = saltNonce
    }
  }

  async init(): Promise<void> {
    if (!this.#ethLibAdapter) {
      throw new Error('CPK uninitialized ethLibAdapter')
    }

    const networkId = await this.#ethLibAdapter.getNetworkId()
    const network = this.#networks[networkId]
    if (!network) {
      throw new Error(`Unrecognized network ID ${networkId}`)
    }

    const ownerAccount = await this.getOwnerAccount()

    this.#isConnectedToSafe = await checkConnectedToSafe(this.#ethLibAdapter.getProvider())

    this.#contractManager = await ContractManager.create({
      ethLibAdapter: this.#ethLibAdapter,
      network,
      ownerAccount,
      saltNonce: this.#saltNonce,
      isSafeApp: this.isSafeApp(),
      isConnectedToSafe: this.#isConnectedToSafe
    })
  }

  async isProxyDeployed(): Promise<boolean> {
    if (!this.address) {
      throw new Error('CPK address uninitialized')
    }
    if (!this.ethLibAdapter) {
      throw new Error('CPK ethLibAdapter uninitialized')
    }
    const codeAtAddress = await this.ethLibAdapter.getCode(this.address)
    const isDeployed = codeAtAddress !== '0x'
    return isDeployed
  }

  isSafeApp(): boolean {
    return this.#safeAppsSdkConnector.isSafeApp()
  }

  async getOwnerAccount(): Promise<Address | undefined> {
    if (this.isSafeApp()) {
      return this.#safeAppsSdkConnector.safeAppInfo?.safeAddress
    }
    if (this.#ownerAccount) {
      return this.#ownerAccount
    }
    if (!this.#ethLibAdapter) {
      throw new Error('CPK uninitialized ethLibAdapter')
    }
    return this.#ethLibAdapter?.getAccount()
  }

  get ethLibAdapter(): EthLibAdapter | undefined {
    return this.#ethLibAdapter
  }

  get networks(): NormalizedNetworksConfig {
    return this.#networks
  }

  get isConnectedToSafe(): boolean {
    return this.#isConnectedToSafe
  }

  get contract(): Contract | undefined {
    return this.#contractManager?.contract
  }

  get multiSend(): Contract | undefined {
    return this.#contractManager?.multiSend
  }

  get proxyFactory(): Contract | undefined {
    return this.#contractManager?.proxyFactory
  }

  get masterCopyAddress(): Address | undefined {
    return this.#contractManager?.masterCopyAddress
  }

  get fallbackHandlerAddress(): Address | undefined {
    return this.#contractManager?.fallbackHandlerAddress
  }

  get saltNonce(): string {
    return this.#saltNonce
  }

  get address(): Address | undefined {
    if (this.isSafeApp()) {
      return this.#safeAppsSdkConnector.safeAppInfo?.safeAddress
    }
    return this.#contractManager?.contract?.address
  }

  setEthLibAdapter(ethLibAdapter: EthLibAdapter): void {
    this.#ethLibAdapter = ethLibAdapter
  }

  setTransactionManager(transactionManager: TransactionManager): void {
    if (this.isSafeApp()) {
      throw new Error('TransactionManagers are not allowed when the app is running as a Safe App')
    }
    this.#transactionManager = transactionManager
  }

  setNetworks(networks: NetworksConfig): void {
    this.#networks = normalizeNetworksConfig(defaultNetworks, networks)
  }

  encodeMultiSendCallData(transactions: Transaction[]): string {
    if (!this.#ethLibAdapter) {
      throw new Error('CPK ethLibAdapter uninitialized')
    }

    const multiSend =
      this.#contractManager?.multiSend || this.#ethLibAdapter.getContract(multiSendAbi)
    const standardizedTxs = transactions.map(standardizeTransaction)

    const ethLibAdapter = this.#ethLibAdapter
    return multiSend.encode('multiSend', [
      joinHexData(
        standardizedTxs.map((tx) =>
          ethLibAdapter.abiEncodePacked(
            { type: 'uint8', value: tx.operation },
            { type: 'address', value: tx.to },
            { type: 'uint256', value: tx.value },
            { type: 'uint256', value: getHexDataLength(tx.data) },
            { type: 'bytes', value: tx.data }
          )
        )
      )
    ])
  }

  async execTransactions(
    transactions: Transaction[],
    options?: ExecOptions
  ): Promise<TransactionResult> {
    if (this.isSafeApp() && transactions.length >= 1) {
      const standardizedTxs = transactions.map(standardizeSafeAppsTransaction)
      return this.#safeAppsSdkConnector.sendTransactions(standardizedTxs)
    }

    if (!this.address) {
      throw new Error('CPK address uninitialized')
    }
    if (!this.#contractManager) {
      throw new Error('CPK contractManager uninitialized')
    }
    if (!this.#ethLibAdapter) {
      throw new Error('CPK ethLibAdapter uninitialized')
    }
    if (!this.#transactionManager) {
      throw new Error('CPK transactionManager uninitialized')
    }

    const ownerAccount = await this.getOwnerAccount()
    if (!ownerAccount) {
      throw new Error('CPK ownerAccount uninitialized')
    }

    const safeExecTxParams = this.getSafeExecTxParams(transactions)
    const sendOptions = normalizeGasLimit({ ...options, from: ownerAccount })

    const codeAtAddress = await this.#ethLibAdapter.getCode(this.address)
    const isDeployed = codeAtAddress !== '0x'
    const txManager = !isDeployed ? new CpkTransactionManager() : this.#transactionManager

    return txManager.execTransactions({
      ownerAccount,
      safeExecTxParams,
      transactions,
      ethLibAdapter: this.#ethLibAdapter,
      contractManager: this.#contractManager,
      saltNonce: this.#saltNonce,
      isDeployed,
      isConnectedToSafe: this.#isConnectedToSafe,
      sendOptions
    })
  }

  async getModules(): Promise<Address[]> {
    const isProxyDeployed = await this.isProxyDeployed()
    if (!isProxyDeployed) {
      throw new Error('CPK Proxy contract is not deployed')
    }
    if (!this.#contractManager?.versionUtils) {
      throw new Error('CPK contractManager uninitialized')
    }
    return await this.#contractManager.versionUtils.getModules()
  }

  async isModuleEnabled(moduleAddress: Address): Promise<boolean> {
    const isProxyDeployed = await this.isProxyDeployed()
    if (!isProxyDeployed) {
      throw new Error('CPK Proxy contract is not deployed')
    }
    if (!this.#contractManager?.versionUtils) {
      throw new Error('CPK contractManager uninitialized')
    }
    return await this.#contractManager.versionUtils.isModuleEnabled(moduleAddress)
  }

  async enableModule(moduleAddress: Address): Promise<TransactionResult> {
    if (!this.#contractManager?.versionUtils) {
      throw new Error('CPK contractManager uninitialized')
    }
    if (!this.address) {
      throw new Error('CPK address uninitialized')
    }
    return await this.execTransactions([
      {
        to: this.address,
        data: await this.#contractManager.versionUtils.encodeEnableModule(moduleAddress),
        operation: CPK.Call
      }
    ])
  }

  async disableModule(moduleAddress: Address): Promise<TransactionResult> {
    const isProxyDeployed = await this.isProxyDeployed()
    if (!isProxyDeployed) {
      throw new Error('CPK Proxy contract is not deployed')
    }
    if (!this.#contractManager?.versionUtils) {
      throw new Error('CPK contractManager uninitialized')
    }
    if (!this.address) {
      throw new Error('CPK address uninitialized')
    }
    return await this.execTransactions([
      {
        to: this.address,
        data: await this.#contractManager.versionUtils.encodeDisableModule(moduleAddress),
        operation: CPK.Call
      }
    ])
  }

  private getSafeExecTxParams(transactions: Transaction[]): StandardTransaction {
    if (transactions.length === 1) {
      return standardizeTransaction(transactions[0])
    }

    if (!this.#contractManager?.multiSend) {
      throw new Error('CPK MultiSend uninitialized')
    }

    return {
      to: this.#contractManager?.multiSend.address,
      value: 0,
      data: this.encodeMultiSendCallData(transactions),
      operation: CPK.DelegateCall
    }
  }
}

export default CPK

1	import multiSendAbi from './abis/MultiSendAbi.json'	1✔
2	import {	1✔
3	defaultNetworks,
4	NetworksConfig,
5	NormalizedNetworksConfig,
6	normalizeNetworksConfig
7	} from './config/networks'
8	import ContractManager from './contractManager'	1✔
9	import EthLibAdapter, { Contract } from './ethLibAdapters/EthLibAdapter'
10	import SafeAppsSdkConnector from './safeAppsSdkConnector'	1✔
11	import CpkTransactionManager from './transactionManagers/CpkTransactionManager'	1✔
12	import TransactionManager from './transactionManagers/TransactionManager'
13	import { Address } from './utils/basicTypes'
14	import { predeterminedSaltNonce } from './utils/constants'	1✔
15	import { getHexDataLength, joinHexData } from './utils/hexData'	1✔
16	import {	1✔
17	ExecOptions,
18	normalizeGasLimit,
19	OperationType,
20	standardizeSafeAppsTransaction,
21	standardizeTransaction,
22	StandardTransaction,
23	Transaction,
24	TransactionResult
25	} from './utils/transactions'
26	import { checkConnectedToSafe } from './utils/checkConnectedToSafe'	1✔
27
28	export interface CPKConfig {
29	ethLibAdapter: EthLibAdapter
30	transactionManager?: TransactionManager
31	ownerAccount?: string
32	networks?: NetworksConfig
33	saltNonce?: string
34	}
35
36	class CPK {
37	static Call = OperationType.Call	1✔
38	static DelegateCall = OperationType.DelegateCall	1✔
39
40	#safeAppsSdkConnector: SafeAppsSdkConnector	146✔
41	#ethLibAdapter?: EthLibAdapter	146✔
42	#transactionManager?: TransactionManager	146✔
43	#contractManager?: ContractManager	146✔
44
45	#networks: NormalizedNetworksConfig	146✔
46	#ownerAccount?: Address	146✔
47	#saltNonce = predeterminedSaltNonce	146✔
48	#isConnectedToSafe = false	146✔
49
50	static async create(opts?: CPKConfig): Promise<CPK> {
51	const cpk = new CPK(opts)	138✔
52	if (opts) {	137✔
53	await cpk.init()	136✔
54	}
55	return cpk	129✔
56	}
57
58	constructor(opts?: CPKConfig) {
59	this.#safeAppsSdkConnector = new SafeAppsSdkConnector()	146✔
60	this.#networks = {	146✔
61	...defaultNetworks
62	}
63	if (!opts) {	146✔
64	return	1✔
65	}
66	const { ethLibAdapter, transactionManager, ownerAccount, networks, saltNonce } = opts	145✔
67	if (!ethLibAdapter) {	145✔
68	throw new Error('ethLibAdapter property missing from options')	1✔
69	}
70	this.#ethLibAdapter = ethLibAdapter	144✔
71	this.#transactionManager = transactionManager ?? new CpkTransactionManager()	144✔
72	this.#ownerAccount = ownerAccount	144✔
73	this.#networks = normalizeNetworksConfig(defaultNetworks, networks)	144✔
74	if (saltNonce) {	144!
75	this.#saltNonce = saltNonce	×
76	}
77	}
78
79	async init(): Promise<void> {
80	if (!this.#ethLibAdapter) {	136!
81	throw new Error('CPK uninitialized ethLibAdapter')	×
82	}
83
84	const networkId = await this.#ethLibAdapter.getNetworkId()	136✔
85	const network = this.#networks[networkId]	136✔
86	if (!network) {	136✔
87	throw new Error(`Unrecognized network ID ${networkId}`)	8✔
88	}
89
90	const ownerAccount = await this.getOwnerAccount()	128✔
91
92	this.#isConnectedToSafe = await checkConnectedToSafe(this.#ethLibAdapter.getProvider())	128✔
93
94	this.#contractManager = await ContractManager.create({	128✔
95	ethLibAdapter: this.#ethLibAdapter,
96	network,
97	ownerAccount,
98	saltNonce: this.#saltNonce,
99	isSafeApp: this.isSafeApp(),
100	isConnectedToSafe: this.#isConnectedToSafe
101	})
102	}
103
104	async isProxyDeployed(): Promise<boolean> {
105	if (!this.address) {	124!
106	throw new Error('CPK address uninitialized')	×
107	}
108	if (!this.ethLibAdapter) {	124!
109	throw new Error('CPK ethLibAdapter uninitialized')	×
110	}
111	const codeAtAddress = await this.ethLibAdapter.getCode(this.address)	124✔
112	const isDeployed = codeAtAddress !== '0x'	124✔
113	return isDeployed	124✔
114	}
115
116	isSafeApp(): boolean {
117	return this.#safeAppsSdkConnector.isSafeApp()	2,541✔
118	}
119
120	async getOwnerAccount(): Promise<Address \| undefined> {
121	if (this.isSafeApp()) {	608!
122	return this.#safeAppsSdkConnector.safeAppInfo?.safeAddress	×
123	}
124	if (this.#ownerAccount) {	608✔
125	return this.#ownerAccount	232✔
126	}
127	if (!this.#ethLibAdapter) {	376!
128	throw new Error('CPK uninitialized ethLibAdapter')	×
129	}
130	return this.#ethLibAdapter?.getAccount()	376!
131	}
132
133	get ethLibAdapter(): EthLibAdapter \| undefined {
134	return this.#ethLibAdapter	249✔
135	}
136
137	get networks(): NormalizedNetworksConfig {
138	return this.#networks	×
139	}
140
141	get isConnectedToSafe(): boolean {
142	return this.#isConnectedToSafe	×
143	}
144
145	get contract(): Contract \| undefined {
146	return this.#contractManager?.contract	1!
147	}
148
149	get multiSend(): Contract \| undefined {
150	return this.#contractManager?.multiSend	1!
151	}
152
153	get proxyFactory(): Contract \| undefined {
154	return this.#contractManager?.proxyFactory	1!
155	}
156
157	get masterCopyAddress(): Address \| undefined {
158	return this.#contractManager?.masterCopyAddress	1!
159	}
160
161	get fallbackHandlerAddress(): Address \| undefined {
162	return this.#contractManager?.fallbackHandlerAddress	1!
163	}
164
165	get saltNonce(): string {
166	return this.#saltNonce	×
167	}
168
169	get address(): Address \| undefined {
170	if (this.isSafeApp()) {	1,568!
171	return this.#safeAppsSdkConnector.safeAppInfo?.safeAddress	×
172	}
173	return this.#contractManager?.contract?.address	1,568!
174	}
175
176	setEthLibAdapter(ethLibAdapter: EthLibAdapter): void {
177	this.#ethLibAdapter = ethLibAdapter	×
178	}
179
180	setTransactionManager(transactionManager: TransactionManager): void {
181	if (this.isSafeApp()) {	×
182	throw new Error('TransactionManagers are not allowed when the app is running as a Safe App')	×
183	}
184	this.#transactionManager = transactionManager	×
185	}
186
187	setNetworks(networks: NetworksConfig): void {
188	this.#networks = normalizeNetworksConfig(defaultNetworks, networks)	×
189	}
190
191	encodeMultiSendCallData(transactions: Transaction[]): string {
192	if (!this.#ethLibAdapter) {	104!
193	throw new Error('CPK ethLibAdapter uninitialized')	×
194	}
195
196	const multiSend =
197	this.#contractManager?.multiSend \|\| this.#ethLibAdapter.getContract(multiSendAbi)	104✔
198	const standardizedTxs = transactions.map(standardizeTransaction)	104✔
199
200	const ethLibAdapter = this.#ethLibAdapter	104✔
201	return multiSend.encode('multiSend', [	104✔
202	joinHexData(
203	standardizedTxs.map((tx) =>
204	ethLibAdapter.abiEncodePacked(	304✔
205	{ type: 'uint8', value: tx.operation },
206	{ type: 'address', value: tx.to },
207	{ type: 'uint256', value: tx.value },
208	{ type: 'uint256', value: getHexDataLength(tx.data) },
209	{ type: 'bytes', value: tx.data }
210	)
211	)
212	)
213	])
214	}
215
216	async execTransactions(
217	transactions: Transaction[],
218	options?: ExecOptions
219	): Promise<TransactionResult> {
220	if (this.isSafeApp() && transactions.length >= 1) {	236!
221	const standardizedTxs = transactions.map(standardizeSafeAppsTransaction)	×
222	return this.#safeAppsSdkConnector.sendTransactions(standardizedTxs)	×
223	}
224
225	if (!this.address) {	236!
226	throw new Error('CPK address uninitialized')	×
227	}
228	if (!this.#contractManager) {	236!
229	throw new Error('CPK contractManager uninitialized')	×
230	}
231	if (!this.#ethLibAdapter) {	236!
232	throw new Error('CPK ethLibAdapter uninitialized')	×
233	}
234	if (!this.#transactionManager) {	236!
235	throw new Error('CPK transactionManager uninitialized')	×
236	}
237
238	const ownerAccount = await this.getOwnerAccount()	236✔
239	if (!ownerAccount) {	236!
240	throw new Error('CPK ownerAccount uninitialized')	×
241	}
242
243	const safeExecTxParams = this.getSafeExecTxParams(transactions)	236✔
244	const sendOptions = normalizeGasLimit({ ...options, from: ownerAccount })	236✔
245
246	const codeAtAddress = await this.#ethLibAdapter.getCode(this.address)	236✔
247	const isDeployed = codeAtAddress !== '0x'	236✔
248	const txManager = !isDeployed ? new CpkTransactionManager() : this.#transactionManager	236✔
249
250	return txManager.execTransactions({	236✔
251	ownerAccount,
252	safeExecTxParams,
253	transactions,
254	ethLibAdapter: this.#ethLibAdapter,
255	contractManager: this.#contractManager,
256	saltNonce: this.#saltNonce,
257	isDeployed,
258	isConnectedToSafe: this.#isConnectedToSafe,
259	sendOptions
260	})
261	}
262
263	async getModules(): Promise<Address[]> {
264	const isProxyDeployed = await this.isProxyDeployed()	56✔
265	if (!isProxyDeployed) {	56!
266	throw new Error('CPK Proxy contract is not deployed')	×
267	}
268	if (!this.#contractManager?.versionUtils) {	56!
269	throw new Error('CPK contractManager uninitialized')	×
270	}
271	return await this.#contractManager.versionUtils.getModules()	56✔
272	}
273
274	async isModuleEnabled(moduleAddress: Address): Promise<boolean> {
275	const isProxyDeployed = await this.isProxyDeployed()	56✔
276	if (!isProxyDeployed) {	56!
277	throw new Error('CPK Proxy contract is not deployed')	×
278	}
279	if (!this.#contractManager?.versionUtils) {	56!
280	throw new Error('CPK contractManager uninitialized')	×
281	}
282	return await this.#contractManager.versionUtils.isModuleEnabled(moduleAddress)	56✔
283	}
284
285	async enableModule(moduleAddress: Address): Promise<TransactionResult> {
286	if (!this.#contractManager?.versionUtils) {	20!
287	throw new Error('CPK contractManager uninitialized')	×
288	}
289	if (!this.address) {	20!
290	throw new Error('CPK address uninitialized')	×
291	}
292	return await this.execTransactions([	20✔
293	{
294	to: this.address,
295	data: await this.#contractManager.versionUtils.encodeEnableModule(moduleAddress),
296	operation: CPK.Call
297	}
298	])
299	}
300
301	async disableModule(moduleAddress: Address): Promise<TransactionResult> {
302	const isProxyDeployed = await this.isProxyDeployed()	12✔
303	if (!isProxyDeployed) {	12!
304	throw new Error('CPK Proxy contract is not deployed')	×
305	}
306	if (!this.#contractManager?.versionUtils) {	12!
307	throw new Error('CPK contractManager uninitialized')	×
308	}
309	if (!this.address) {	12!
310	throw new Error('CPK address uninitialized')	×
311	}
312	return await this.execTransactions([	12✔
313	{
314	to: this.address,
315	data: await this.#contractManager.versionUtils.encodeDisableModule(moduleAddress),
316	operation: CPK.Call
317	}
318	])
319	}
320
321	private getSafeExecTxParams(transactions: Transaction[]): StandardTransaction {
322	if (transactions.length === 1) {	236✔
323	return standardizeTransaction(transactions[0])	140✔
324	}
325
326	if (!this.#contractManager?.multiSend) {	96!
327	throw new Error('CPK MultiSend uninitialized')	×
328	}
329
330	return {	96✔
331	to: this.#contractManager?.multiSend.address,	288!
332	value: 0,
333	data: this.encodeMultiSendCallData(transactions),
334	operation: CPK.DelegateCall
335	}
336	}
337	}
338
339	export default CPK	1✔

gnosis / contract-proxy-kit / 453

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