9810313474

Committed 05 Jul 2024 03:07PM UTC coverage: 48.491% (+0.2%) from 48.272%

Build # 9810313474

Build Type

Pull #1734

github

Committed by

web-flow

Commit Message

Merge 22d5f6c2f into f9c567e81

Pull Request Pull Request #1734: Generate specific function/event decoders in `AbiDecoder`

Run Details

416 of 2586 branches covered (16.09%)

Branch coverage included in aggregate %.

32 of 105 new or added lines in 7 files covered. (30.48%)

4 existing lines in 4 files now uncovered.

4245 of 7026 relevant lines covered (60.42%)

15.19 hits per line

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

9.6

/src/domain/relay/limit-addresses.mapper.ts

import { Inject, Injectable } from '@nestjs/common';
import { Erc20Decoder } from '@/domain/relay/contracts/decoders/erc-20-decoder.helper';
import { ISafeRepository } from '@/domain/safe/safe.repository.interface';
import { MultiSendDecoder } from '@/domain/contracts/decoders/multi-send-decoder.helper';
import { ProxyFactoryDecoder } from '@/domain/relay/contracts/decoders/proxy-factory-decoder.helper';
import {
  getSafeSingletonDeployment,
  getSafeL2SingletonDeployment,
  getMultiSendCallOnlyDeployment,
  getMultiSendDeployment,
  getProxyFactoryDeployment,
} from '@safe-global/safe-deployments';
import { SafeDecoder } from '@/domain/contracts/decoders/safe-decoder.helper';
import { UnofficialMasterCopyError } from '@/domain/relay/errors/unofficial-master-copy.error';
import { UnofficialMultiSendError } from '@/domain/relay/errors/unofficial-multisend.error';
import { InvalidTransferError } from '@/domain/relay/errors/invalid-transfer.error';
import { InvalidMultiSendError } from '@/domain/relay/errors/invalid-multisend.error';
import { UnofficialProxyFactoryError } from '@/domain/relay/errors/unofficial-proxy-factory.error';

@Injectable()
export class LimitAddressesMapper {
  constructor(
    @Inject(ISafeRepository)
    private readonly safeRepository: ISafeRepository,
    private readonly erc20Decoder: Erc20Decoder,
    private readonly safeDecoder: SafeDecoder,
    private readonly multiSendDecoder: MultiSendDecoder,
    private readonly proxyFactoryDecoder: ProxyFactoryDecoder,
  ) {}

  async getLimitAddresses(args: {
    version: string;
    chainId: string;
    to: `0x${string}`;
    data: `0x${string}`;
  }): Promise<readonly `0x${string}`[]> {
    // Calldata matches that of execTransaction and meets validity requirements
    if (
      this.isValidExecTransactionCall({
        to: args.to,
        data: args.data,
      })
    ) {
      // Safe attempting to relay is official
      const isOfficial = await this.isOfficialMastercopy({
        chainId: args.chainId,
        address: args.to,
      });

      if (!isOfficial) {
        throw new UnofficialMasterCopyError();
      }

      // Safe targeted by execTransaction will be limited
      return [args.to];
    }

    // Calldata matches that of multiSend and is from an official MultiSend contract
    if (this.multiSendDecoder.helpers.isMultiSend(args.data)) {
      if (
        !this.isOfficialMultiSendDeployment({
          version: args.version,
          chainId: args.chainId,
          address: args.to,
        })
      ) {
        throw new UnofficialMultiSendError();
      }

      // multiSend calldata meets the validity requirements
      const safeAddress = this.getSafeAddressFromMultiSend(args.data);

      // Safe attempting to relay is official
      const isOfficial = await this.isOfficialMastercopy({
        chainId: args.chainId,
        address: safeAddress,
      });

      if (!isOfficial) {
        throw new UnofficialMasterCopyError();
      }

      // Safe targeted in batch will be limited
      return [safeAddress];
    }

    // Calldata matches that of createProxyWithNonce and meets validity requirements
    if (
      this.isValidCreateProxyWithNonceCall({
        version: args.version,
        chainId: args.chainId,
        data: args.data,
      })
    ) {
      if (
        !this.isOfficialProxyFactoryDeployment({
          version: args.version,
          chainId: args.chainId,
          address: args.to,
        })
      ) {
        throw new UnofficialProxyFactoryError();
      }
      // Owners of safe-to-be-created will be limited
      return this.getOwnersFromCreateProxyWithNonce(args.data);
    }

    throw new InvalidTransferError();
  }

  private isValidExecTransactionCall(args: {
    to: `0x${string}`;
    data: `0x${string}`;
  }): boolean {
    const execTransactionArgs = this.getExecTransactionArgs(args.data);
    // Not a valid execTransaction call
    if (!execTransactionArgs) {
      return false;
    }

    // Only ERC-20 transfer to other party is valid
    if (this.erc20Decoder.helpers.isTransfer(execTransactionArgs.data)) {
      return this.isValidErc20Transfer({
        to: args.to,
        data: execTransactionArgs.data,
      });
    }

    // Only ERC-20 transferFrom to other party is valid
    if (this.erc20Decoder.helpers.isTransferFrom(execTransactionArgs.data)) {
      return this.isValidErc20TransferFrom({
        to: args.to,
        data: execTransactionArgs.data,
      });
    }

    // Only transaction to other party is valid
    const toSelf = execTransactionArgs.to === args.to;
    if (!toSelf) {
      return true;
    }

    // Only transaction with no value is valid
    const hasValue = execTransactionArgs.value > BigInt(0);
    if (hasValue) {
      return false;
    }

    // Cancellations and Safe calls (e.g. owner management) are valid
    const isCancellation = execTransactionArgs.data === '0x';
    return isCancellation || this.safeDecoder.isCall(execTransactionArgs.data);
  }

  private getExecTransactionArgs(data: `0x${string}`): {
    to: `0x${string}`;
    value: bigint;
    data: `0x${string}`;
  } | null {
    const safeDecodedData =
      this.safeDecoder.decodeFunctionData.execTransaction(data);

    if (!safeDecodedData) {
      return null;
    }

    return {
      to: safeDecodedData[0],
      value: safeDecodedData[1],
      data: safeDecodedData[2],
    };
  }

  private isValidErc20Transfer(args: {
    to: `0x${string}`;
    data: `0x${string}`;
  }): boolean {
    const erc20DecodedData = this.erc20Decoder.decodeFunctionData.transfer(
      args.data,
    );

    if (!erc20DecodedData) {
      return false;
    }

    const [to] = erc20DecodedData;
    // to 'self' (the Safe) is not allowed
    return to !== args.to;
  }

  private isValidErc20TransferFrom(args: {
    to: `0x${string}`;
    data: `0x${string}`;
  }): boolean {
    const erc20DecodedData = this.erc20Decoder.decodeFunctionData.transferFrom(
      args.data,
    );

    if (!erc20DecodedData) {
      return false;
    }

    const [sender, recipient] = erc20DecodedData;
    // to 'self' (the Safe) or from sender to sender as recipient is not allowed
    return sender !== recipient && recipient !== args.to;
  }

  private async isOfficialMastercopy(args: {
    chainId: string;
    address: `0x${string}`;
  }): Promise<boolean> {
    try {
      await this.safeRepository.getSafe(args);
      return true;
    } catch {
      return false;
    }
  }

  private isOfficialMultiSendDeployment(args: {
    version: string;
    chainId: string;
    address: `0x${string}`;
  }): boolean {
    const multiSendCallOnlyDeployment = getMultiSendCallOnlyDeployment({
      version: args.version,
      network: args.chainId,
    });

    const isCallOnly =
      multiSendCallOnlyDeployment?.networkAddresses[args.chainId] ===
        args.address ||
      multiSendCallOnlyDeployment?.defaultAddress === args.address;

    if (isCallOnly) {
      return true;
    }

    const multiSendCallDeployment = getMultiSendDeployment({
      version: args.version,
      network: args.chainId,
    });
    return (
      multiSendCallDeployment?.networkAddresses[args.chainId] ===
        args.address || multiSendCallDeployment?.defaultAddress === args.address
    );
  }

  private getSafeAddressFromMultiSend = (
    data: `0x${string}`,
  ): `0x${string}` => {
    // Decode transactions within MultiSend
    const transactions = this.multiSendDecoder.mapMultiSendTransactions(data);

    // Every transaction is a valid execTransaction
    const isEveryValid = transactions.every((transaction) => {
      return this.isValidExecTransactionCall(transaction);
    });

    if (!isEveryValid) {
      throw new InvalidMultiSendError();
    }

    const firstRecipient = transactions[0].to;

    const isSameRecipient = transactions.every((transaction) => {
      return transaction.to === firstRecipient;
    });

    // Transactions calls execTransaction on varying addresses
    if (!isSameRecipient) {
      throw new InvalidMultiSendError();
    }

    return firstRecipient;
  };

  private isOfficialProxyFactoryDeployment(args: {
    version: string;
    chainId: string;
    address: `0x${string}`;
  }): boolean {
    const proxyFactoryDeployment = getProxyFactoryDeployment({
      version: args.version,
      network: args.chainId,
    });

    return (
      proxyFactoryDeployment?.networkAddresses[args.chainId] === args.address ||
      proxyFactoryDeployment?.defaultAddress === args.address
    );
  }

  private isValidCreateProxyWithNonceCall(args: {
    version: string;
    chainId: string;
    data: `0x${string}`;
  }): boolean {
    const decoded =
      this.proxyFactoryDecoder.decodeFunctionData.createProxyWithNonce(
        args.data,
      );

    if (!decoded) {
      return false;
    }

    const singleton = decoded[0];

    const safeL1Deployment = getSafeSingletonDeployment({
      version: args.version,
      network: args.chainId,
    });
    const safeL2Deployment = getSafeL2SingletonDeployment({
      version: args.version,
      network: args.chainId,
    });

    const isL1Singleton =
      safeL1Deployment?.networkAddresses[args.chainId] === singleton;
    const isL2Singleton =
      safeL2Deployment?.networkAddresses[args.chainId] === singleton;

    return isL1Singleton || isL2Singleton;
  }

  private getOwnersFromCreateProxyWithNonce(
    data: `0x${string}`,
  ): readonly `0x${string}`[] {
    const decodedProxyFactory =
      this.proxyFactoryDecoder.decodeFunctionData.createProxyWithNonce(data);

    if (!decodedProxyFactory) {
      // Should never happen but check is needed to satisfy TypeScript
      throw Error('Not a createProxyWithNonce call');
    }

    const initializer = decodedProxyFactory[1];
    const decodedSafe = this.safeDecoder.decodeFunctionData.setup(initializer);

    if (!decodedSafe) {
      // No custom error thrown, as caller subsequently throws InvalidTransferError
      throw Error('Not a setup call');
    }

    return decodedSafe[0];
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	16✔
2	import { Erc20Decoder } from '@/domain/relay/contracts/decoders/erc-20-decoder.helper';	16✔
3	import { ISafeRepository } from '@/domain/safe/safe.repository.interface';	16✔
4	import { MultiSendDecoder } from '@/domain/contracts/decoders/multi-send-decoder.helper';	16✔
5	import { ProxyFactoryDecoder } from '@/domain/relay/contracts/decoders/proxy-factory-decoder.helper';	16✔
6	import {	16✔
7	getSafeSingletonDeployment,
8	getSafeL2SingletonDeployment,
9	getMultiSendCallOnlyDeployment,
10	getMultiSendDeployment,
11	getProxyFactoryDeployment,
12	} from '@safe-global/safe-deployments';
13	import { SafeDecoder } from '@/domain/contracts/decoders/safe-decoder.helper';	16✔
14	import { UnofficialMasterCopyError } from '@/domain/relay/errors/unofficial-master-copy.error';	16✔
15	import { UnofficialMultiSendError } from '@/domain/relay/errors/unofficial-multisend.error';	16✔
16	import { InvalidTransferError } from '@/domain/relay/errors/invalid-transfer.error';	16✔
17	import { InvalidMultiSendError } from '@/domain/relay/errors/invalid-multisend.error';	16✔
18	import { UnofficialProxyFactoryError } from '@/domain/relay/errors/unofficial-proxy-factory.error';	16✔
19
20	@Injectable()
21	export class LimitAddressesMapper {	16✔
22	constructor(
23	@Inject(ISafeRepository)
24	private readonly safeRepository: ISafeRepository,	16✔
25	private readonly erc20Decoder: Erc20Decoder,	16✔
26	private readonly safeDecoder: SafeDecoder,	16✔
27	private readonly multiSendDecoder: MultiSendDecoder,	16✔
28	private readonly proxyFactoryDecoder: ProxyFactoryDecoder,	16✔
29	) {}
30
31	async getLimitAddresses(args: {
32	version: string;
33	chainId: string;
34	to: `0x${string}`;
35	data: `0x${string}`;
36	}): Promise<readonly `0x${string}`[]> {
37	// Calldata matches that of execTransaction and meets validity requirements
38	if (	×
39	this.isValidExecTransactionCall({
40	to: args.to,
41	data: args.data,
42	})
43	) {
44	// Safe attempting to relay is official
45	const isOfficial = await this.isOfficialMastercopy({	×
46	chainId: args.chainId,
47	address: args.to,
48	});
49
50	if (!isOfficial) {	×
51	throw new UnofficialMasterCopyError();	×
52	}
53
54	// Safe targeted by execTransaction will be limited
55	return [args.to];	×
56	}
57
58	// Calldata matches that of multiSend and is from an official MultiSend contract
59	if (this.multiSendDecoder.helpers.isMultiSend(args.data)) {	×
60	if (	×
61	!this.isOfficialMultiSendDeployment({
62	version: args.version,
63	chainId: args.chainId,
64	address: args.to,
65	})
66	) {
67	throw new UnofficialMultiSendError();	×
68	}
69
70	// multiSend calldata meets the validity requirements
71	const safeAddress = this.getSafeAddressFromMultiSend(args.data);	×
72
73	// Safe attempting to relay is official
74	const isOfficial = await this.isOfficialMastercopy({	×
75	chainId: args.chainId,
76	address: safeAddress,
77	});
78
79	if (!isOfficial) {	×
80	throw new UnofficialMasterCopyError();	×
81	}
82
83	// Safe targeted in batch will be limited
84	return [safeAddress];	×
85	}
86
87	// Calldata matches that of createProxyWithNonce and meets validity requirements
88	if (	×
89	this.isValidCreateProxyWithNonceCall({
90	version: args.version,
91	chainId: args.chainId,
92	data: args.data,
93	})
94	) {
95	if (	×
96	!this.isOfficialProxyFactoryDeployment({
97	version: args.version,
98	chainId: args.chainId,
99	address: args.to,
100	})
101	) {
102	throw new UnofficialProxyFactoryError();	×
103	}
104	// Owners of safe-to-be-created will be limited
105	return this.getOwnersFromCreateProxyWithNonce(args.data);	×
106	}
107
108	throw new InvalidTransferError();	×
109	}
110
111	private isValidExecTransactionCall(args: {
112	to: `0x${string}`;
113	data: `0x${string}`;
114	}): boolean {
115	const execTransactionArgs = this.getExecTransactionArgs(args.data);	×
116	// Not a valid execTransaction call
117	if (!execTransactionArgs) {	×
118	return false;	×
119	}
120
121	// Only ERC-20 transfer to other party is valid
122	if (this.erc20Decoder.helpers.isTransfer(execTransactionArgs.data)) {	×
123	return this.isValidErc20Transfer({	×
124	to: args.to,
125	data: execTransactionArgs.data,
126	});
127	}
128
129	// Only ERC-20 transferFrom to other party is valid
130	if (this.erc20Decoder.helpers.isTransferFrom(execTransactionArgs.data)) {	×
131	return this.isValidErc20TransferFrom({	×
132	to: args.to,
133	data: execTransactionArgs.data,
134	});
135	}
136
137	// Only transaction to other party is valid
138	const toSelf = execTransactionArgs.to === args.to;	×
139	if (!toSelf) {	×
140	return true;	×
141	}
142
143	// Only transaction with no value is valid
144	const hasValue = execTransactionArgs.value > BigInt(0);	×
145	if (hasValue) {	×
146	return false;	×
147	}
148
149	// Cancellations and Safe calls (e.g. owner management) are valid
150	const isCancellation = execTransactionArgs.data === '0x';	×
151	return isCancellation \|\| this.safeDecoder.isCall(execTransactionArgs.data);	×
152	}
153
154	private getExecTransactionArgs(data: `0x${string}`): {
155	to: `0x${string}`;
156	value: bigint;
157	data: `0x${string}`;
158	} \| null {
159	const safeDecodedData =
NEW 160	this.safeDecoder.decodeFunctionData.execTransaction(data);	×
161
NEW 162	if (!safeDecodedData) {	×
163	return null;	×
164	}
165
NEW 166	return {	×
167	to: safeDecodedData[0],
168	value: safeDecodedData[1],
169	data: safeDecodedData[2],
170	};
171	}
172
173	private isValidErc20Transfer(args: {
174	to: `0x${string}`;
175	data: `0x${string}`;
176	}): boolean {
NEW 177	const erc20DecodedData = this.erc20Decoder.decodeFunctionData.transfer(	×
178	args.data,
179	);
180
NEW 181	if (!erc20DecodedData) {	×
182	return false;	×
183	}
184
NEW 185	const [to] = erc20DecodedData;	×
186	// to 'self' (the Safe) is not allowed
187	return to !== args.to;	×
188	}
189
190	private isValidErc20TransferFrom(args: {
191	to: `0x${string}`;
192	data: `0x${string}`;
193	}): boolean {
NEW 194	const erc20DecodedData = this.erc20Decoder.decodeFunctionData.transferFrom(	×
195	args.data,
196	);
197
NEW 198	if (!erc20DecodedData) {	×
199	return false;	×
200	}
201
NEW 202	const [sender, recipient] = erc20DecodedData;	×
203	// to 'self' (the Safe) or from sender to sender as recipient is not allowed
204	return sender !== recipient && recipient !== args.to;	×
205	}
206
207	private async isOfficialMastercopy(args: {
208	chainId: string;
209	address: `0x${string}`;
210	}): Promise<boolean> {
211	try {	×
212	await this.safeRepository.getSafe(args);	×
213	return true;	×
214	} catch {
215	return false;	×
216	}
217	}
218
219	private isOfficialMultiSendDeployment(args: {
220	version: string;
221	chainId: string;
222	address: `0x${string}`;
223	}): boolean {
224	const multiSendCallOnlyDeployment = getMultiSendCallOnlyDeployment({	×
225	version: args.version,
226	network: args.chainId,
227	});
228
229	const isCallOnly =
230	multiSendCallOnlyDeployment?.networkAddresses[args.chainId] ===	×
231	args.address \|\|
232	multiSendCallOnlyDeployment?.defaultAddress === args.address;	×
233
234	if (isCallOnly) {	×
235	return true;	×
236	}
237
238	const multiSendCallDeployment = getMultiSendDeployment({	×
239	version: args.version,
240	network: args.chainId,
241	});
242	return (	×
243	multiSendCallDeployment?.networkAddresses[args.chainId] ===	×
244	args.address \|\| multiSendCallDeployment?.defaultAddress === args.address	×
245	);
246	}
247
248	private getSafeAddressFromMultiSend = (	16✔
249	data: `0x${string}`,
250	): `0x${string}` => {
251	// Decode transactions within MultiSend
252	const transactions = this.multiSendDecoder.mapMultiSendTransactions(data);	×
253
254	// Every transaction is a valid execTransaction
255	const isEveryValid = transactions.every((transaction) => {	×
256	return this.isValidExecTransactionCall(transaction);	×
257	});
258
259	if (!isEveryValid) {	×
260	throw new InvalidMultiSendError();	×
261	}
262
263	const firstRecipient = transactions[0].to;	×
264
265	const isSameRecipient = transactions.every((transaction) => {	×
266	return transaction.to === firstRecipient;	×
267	});
268
269	// Transactions calls execTransaction on varying addresses
270	if (!isSameRecipient) {	×
271	throw new InvalidMultiSendError();	×
272	}
273
274	return firstRecipient;	×
275	};
276
277	private isOfficialProxyFactoryDeployment(args: {
278	version: string;
279	chainId: string;
280	address: `0x${string}`;
281	}): boolean {
282	const proxyFactoryDeployment = getProxyFactoryDeployment({	×
283	version: args.version,
284	network: args.chainId,
285	});
286
287	return (	×
288	proxyFactoryDeployment?.networkAddresses[args.chainId] === args.address \|\|	×
289	proxyFactoryDeployment?.defaultAddress === args.address	×
290	);
291	}
292
293	private isValidCreateProxyWithNonceCall(args: {
294	version: string;
295	chainId: string;
296	data: `0x${string}`;
297	}): boolean {
298	const decoded =
NEW 299	this.proxyFactoryDecoder.decodeFunctionData.createProxyWithNonce(	×
300	args.data,
301	);
302
NEW 303	if (!decoded) {	×
304	return false;	×
305	}
306
NEW 307	const singleton = decoded[0];	×
308
UNCOV 309	const safeL1Deployment = getSafeSingletonDeployment({	×
310	version: args.version,
311	network: args.chainId,
312	});
313	const safeL2Deployment = getSafeL2SingletonDeployment({	×
314	version: args.version,
315	network: args.chainId,
316	});
317
318	const isL1Singleton =
319	safeL1Deployment?.networkAddresses[args.chainId] === singleton;	×
320	const isL2Singleton =
321	safeL2Deployment?.networkAddresses[args.chainId] === singleton;	×
322
323	return isL1Singleton \|\| isL2Singleton;	×
324	}
325
326	private getOwnersFromCreateProxyWithNonce(
327	data: `0x${string}`,
328	): readonly `0x${string}`[] {
329	const decodedProxyFactory =
NEW 330	this.proxyFactoryDecoder.decodeFunctionData.createProxyWithNonce(data);	×
331
NEW 332	if (!decodedProxyFactory) {	×
333	// Should never happen but check is needed to satisfy TypeScript
334	throw Error('Not a createProxyWithNonce call');	×
335	}
336
NEW 337	const initializer = decodedProxyFactory[1];	×
NEW 338	const decodedSafe = this.safeDecoder.decodeFunctionData.setup(initializer);	×
339
NEW 340	if (!decodedSafe) {	×
341	// No custom error thrown, as caller subsequently throws InvalidTransferError
342	throw Error('Not a setup call');	×
343	}
344
NEW 345	return decodedSafe[0];	×
346	}
347	}

safe-global / safe-client-gateway / 9810313474

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