11349309010

Committed 15 Oct 2024 03:26PM UTC coverage: 91.002% (+0.8%) from 90.21%

Build # 11349309010

Build Type

Pull #1988

github

Committed by

PooyaRaki

Commit Message

Add unit tests

Pull Request Pull Request #1988: OrmMigrationAndLogger

Run Details

2656 of 3255 branches covered (81.6%)

Branch coverage included in aggregate %.

91 of 126 new or added lines in 12 files covered. (72.22%)

43 existing lines in 16 files now uncovered.

8803 of 9337 relevant lines covered (94.28%)

411.21 hits per line

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

88.74

/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 {
  getSafeSingletonDeployments,
  getSafeL2SingletonDeployments,
  getMultiSendCallOnlyDeployments,
  getMultiSendDeployments,
  getProxyFactoryDeployments,
} from '@/domain/common/utils/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 {
    try {
      const safeDecodedData = this.safeDecoder.decodeFunctionData({
        data,
      });

      if (safeDecodedData.functionName !== 'execTransaction') {
        return null;
      }

      return {
        to: safeDecodedData.args[0],
        value: safeDecodedData.args[1],
        data: safeDecodedData.args[2],
      };
    } catch {
      return null;
    }
  }

  private isValidErc20Transfer(args: {
    to: `0x${string}`;
    data: `0x${string}`;
  }): boolean {
    // Can throw but called after this.erc20Decoder.helpers.isTransfer
    const erc20DecodedData = this.erc20Decoder.decodeFunctionData({
      data: args.data,
    });

    if (erc20DecodedData.functionName !== 'transfer') {
      return false;
    }

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

  private isValidErc20TransferFrom(args: {
    to: `0x${string}`;
    data: `0x${string}`;
  }): boolean {
    // Can throw but called after this.erc20Decoder.helpers.isTransferFrom
    const erc20DecodedData = this.erc20Decoder.decodeFunctionData({
      data: args.data,
    });

    if (erc20DecodedData.functionName !== 'transferFrom') {
      return false;
    }

    const [sender, recipient] = erc20DecodedData.args;
    // 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 {
    return (
      getMultiSendCallOnlyDeployments(args).includes(args.address) ||
      getMultiSendDeployments(args).includes(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 proxyFactoryDeployments = getProxyFactoryDeployments(args);
    return proxyFactoryDeployments.includes(args.address);
  }

  private isValidCreateProxyWithNonceCall(args: {
    version: string;
    chainId: string;
    data: `0x${string}`;
  }): boolean {
    let singleton: `0x${string}` | null = null;

    try {
      const decoded = this.proxyFactoryDecoder.decodeFunctionData({
        data: args.data,
      });

      if (decoded.functionName !== 'createProxyWithNonce') {
        return false;
      }

      singleton = decoded.args[0];
    } catch {
      return false;
    }

    return (
      getSafeSingletonDeployments(args).includes(singleton) ||
      getSafeL2SingletonDeployments(args).includes(singleton)
    );
  }

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

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

    const initializer = decodedProxyFactory.args[1];
    const decodedSafe = this.safeDecoder.decodeFunctionData({
      data: initializer,
    });

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

    return decodedSafe.args[0];
  }
}

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

safe-global / safe-client-gateway / 11349309010

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