7903099633

Committed 14 Feb 2024 02:58PM UTC coverage: 93.386% (+1.2%) from 92.228%

Build # 7903099633

Build Type

Pull #1144

github

Committed by

iamacook

Commit Message

Fix test

Pull Request Pull Request #1144: Add officiality check for Safe and MultiSend contracts in `LimitAddressesMapper`

Run Details

1555 of 1860 branches covered (83.6%)

Branch coverage included in aggregate %.

58 of 59 new or added lines in 4 files covered. (98.31%)

3 existing lines in 1 file now uncovered.

5942 of 6168 relevant lines covered (96.34%)

179.9 hits per line

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

90.91

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

import { Inject, Injectable } from '@nestjs/common';
import { Hex } from 'viem/types/misc';
import { Erc20ContractHelper } from '@/domain/relay/contracts/erc20-contract.helper';
import { SafeContractHelper } from '@/domain/relay/contracts/safe-contract.helper';
import { ISafeRepository } from '@/domain/safe/safe.repository.interface';
import { MultiSendDecoder } from '@/domain/contracts/contracts/multi-send-decoder.helper';
import { ProxyFactoryDecoder } from '@/domain/relay/contracts/proxy-factory-decoder.helper';
import {
  getSafeSingletonDeployment,
  getSafeL2SingletonDeployment,
  getMultiSendCallOnlyDeployment,
} from '@safe-global/safe-deployments';
import { SafeDecoder } from '@/domain/contracts/contracts/safe-decoder.helper';

export interface RelayPayload {
  chainId: string;
  data: Hex;
  to: Hex;
  gasLimit?: bigint;
}

@Injectable()
export class LimitAddressesMapper {
  // TODO: Abstract with that from SafeContractHelper
  private static SUPPORTED_SAFE_VERSION = '1.3.0';

  constructor(
    @Inject(ISafeRepository)
    private readonly safeRepository: ISafeRepository,
    private readonly safeContract: SafeContractHelper,
    private readonly erc20Contract: Erc20ContractHelper,
    private readonly safeDecoder: SafeDecoder,
    private readonly multiSendDecoder: MultiSendDecoder,
    private readonly proxyFactoryDecoder: ProxyFactoryDecoder,
  ) {}

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

      if (!isOfficial) {
        throw Error('Invalid Safe contract');
      }

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

    // Calldata matches that of multiSend and is from an official MultiSend contract
    if (
      this.multiSendDecoder.isMultiSend(args.data) &&
      this.isOfficialMultiSendDeployment({
        chainId: args.chainId,
        address: args.to,
      })
    ) {
      // 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 Error('Invalid Safe contract');
      }

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

    // Calldata matches that of createProxyWithNonce and meets validity requirements
    if (this.isValidCreateProxyWithNonceCall(args)) {
      // Owners of safe-to-be-created will be limited
      return this.getOwnersFromCreateProxyWithNonce(args.data);
    }

    throw Error('Cannot get limit addresses – Invalid transfer');
  }

  private isValidExecTransactionCall(args: { to: string; data: Hex }): boolean {
    let execTransaction: { data: Hex; to: Hex; value: bigint };
    // If transaction is an execTransaction
    try {
      execTransaction = this.safeContract.decode(
        SafeContractHelper.EXEC_TRANSACTION,
        args.data,
      );
    } catch (e) {
      return false;
    }

    // If data of execTransaction is an ERC20 transfer
    try {
      const erc20DecodedData = this.erc20Contract.decode(
        Erc20ContractHelper.TRANSFER,
        execTransaction.data,
      );
      // If the ERC20 transfer targets 'self' (the Safe), we consider it to be invalid
      return erc20DecodedData.to !== args.to;
    } catch {
      // swallow exception if data is not an ERC20 transfer
    }

    // If a transaction does not target 'self' consider it valid
    if (args.to !== execTransaction.to) {
      return true;
    }

    // Transaction targets 'self'
    // Block transactions targeting self with a value greater than 0
    if (execTransaction.value > BigInt(0)) {
      return false;
    }

    const isCancellation = execTransaction.data === '0x';
    return isCancellation || this.safeContract.isCall(execTransaction.data);
  }

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

  private isOfficialMultiSendDeployment(args: {
    chainId: string;
    address: string;
  }): boolean {
    const multiSendDeployment = getMultiSendCallOnlyDeployment({
      version: LimitAddressesMapper.SUPPORTED_SAFE_VERSION,
      network: args.chainId,
    });
    return (
      multiSendDeployment?.networkAddresses[args.chainId] === args.address ||
      multiSendDeployment?.defaultAddress === args.address
    );
  }

  private getSafeAddressFromMultiSend = (data: Hex): Hex => {
    // 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 Error('Invalid MultiSend transactions');
    }

    const firstRecipient = transactions[0].to;

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

    if (!isSameRecipient) {
      throw Error('MultiSend transactions target different addresses');
    }

    return firstRecipient;
  };

  private isValidCreateProxyWithNonceCall(args: {
    chainId: string;
    data: Hex;
  }): boolean {
    let singleton: string | null = null;

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

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

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

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

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

    return isL1Singleton || isL2Singleton;
  }

  private getOwnersFromCreateProxyWithNonce(data: Hex): readonly Hex[] {
    const decodedProxyFactory = this.proxyFactoryDecoder.decodeFunctionData({
      data,
    });

    if (decodedProxyFactory.functionName !== 'createProxyWithNonce') {
      throw Error('Not a createProxyWithNonce call');
    }

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

    if (decodedSafe.functionName !== 'setup') {
      throw Error('Not a setup call');
    }

    return decodedSafe.args[0];
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	2✔
2	import { Hex } from 'viem/types/misc';
3	import { Erc20ContractHelper } from '@/domain/relay/contracts/erc20-contract.helper';	2✔
4	import { SafeContractHelper } from '@/domain/relay/contracts/safe-contract.helper';	2✔
5	import { ISafeRepository } from '@/domain/safe/safe.repository.interface';	2✔
6	import { MultiSendDecoder } from '@/domain/contracts/contracts/multi-send-decoder.helper';	2✔
7	import { ProxyFactoryDecoder } from '@/domain/relay/contracts/proxy-factory-decoder.helper';	2✔
8	import {	2✔
9	getSafeSingletonDeployment,
10	getSafeL2SingletonDeployment,
11	getMultiSendCallOnlyDeployment,
12	} from '@safe-global/safe-deployments';
13	import { SafeDecoder } from '@/domain/contracts/contracts/safe-decoder.helper';	2✔
14
15	export interface RelayPayload {
16	chainId: string;
17	data: Hex;
18	to: Hex;
19	gasLimit?: bigint;
20	}
21
22	@Injectable()
23	export class LimitAddressesMapper {	2✔
24	// TODO: Abstract with that from SafeContractHelper
25	private static SUPPORTED_SAFE_VERSION = '1.3.0';	2✔
26
27	constructor(
28	@Inject(ISafeRepository)
29	private readonly safeRepository: ISafeRepository,	50✔
30	private readonly safeContract: SafeContractHelper,	50✔
31	private readonly erc20Contract: Erc20ContractHelper,	50✔
32	private readonly safeDecoder: SafeDecoder,	50✔
33	private readonly multiSendDecoder: MultiSendDecoder,	50✔
34	private readonly proxyFactoryDecoder: ProxyFactoryDecoder,	50✔
35	) {}
36
37	async getLimitAddresses(args: RelayPayload): Promise<readonly Hex[]> {
38	// Calldata matches that of execTransaction and meets validity requirements
39	if (this.isValidExecTransactionCall(args)) {	50✔
40	// Safe attempting to relay is official
41	const isOfficial = await this.isOfficialMastercopy({	28✔
42	chainId: args.chainId,
43	address: args.to,
44	});
45
46	if (!isOfficial) {	28✔
47	throw Error('Invalid Safe contract');	4✔
48	}
49
50	// Safe targetted by execTransaction will be limited
51	return [args.to];	24✔
52	}
53
54	// Calldata matches that of multiSend and is from an official MultiSend contract
55	if (	22✔
56	this.multiSendDecoder.isMultiSend(args.data) &&	17✔
57	this.isOfficialMultiSendDeployment({
58	chainId: args.chainId,
59	address: args.to,
60	})
61	) {
62	// multiSend calldata meets the validity requirements
63	const safeAddress = this.getSafeAddressFromMultiSend(args.data);	8✔
64
65	// Safe attempting to relay is official
66	const isOfficial = await this.isOfficialMastercopy({	4✔
67	chainId: args.chainId,
68	address: safeAddress,
69	});
70
71	if (!isOfficial) {	4✔
72	throw Error('Invalid Safe contract');	2✔
73	}
74
75	// Safe targetted in batch will be limited
76	return [safeAddress];	2✔
77	}
78
79	// Calldata matches that of createProxyWithNonce and meets validity requirements
80	if (this.isValidCreateProxyWithNonceCall(args)) {	14✔
81	// Owners of safe-to-be-created will be limited
82	return this.getOwnersFromCreateProxyWithNonce(args.data);	4✔
83	}
84
85	throw Error('Cannot get limit addresses – Invalid transfer');	10✔
86	}
87
88	private isValidExecTransactionCall(args: { to: string; data: Hex }): boolean {
89	let execTransaction: { data: Hex; to: Hex; value: bigint };
90	// If transaction is an execTransaction
91	try {	66✔
92	execTransaction = this.safeContract.decode(	66✔
93	SafeContractHelper.EXEC_TRANSACTION,
94	args.data,
95	);
96	} catch (e) {
97	return false;	22✔
98	}
99
100	// If data of execTransaction is an ERC20 transfer
101	try {	44✔
102	const erc20DecodedData = this.erc20Contract.decode(	44✔
103	Erc20ContractHelper.TRANSFER,
104	execTransaction.data,
105	);
106	// If the ERC20 transfer targets 'self' (the Safe), we consider it to be invalid
107	return erc20DecodedData.to !== args.to;	4✔
108	} catch {
109	// swallow exception if data is not an ERC20 transfer
110	}
111
112	// If a transaction does not target 'self' consider it valid
113	if (args.to !== execTransaction.to) {	40✔
114	return true;	14✔
115	}
116
117	// Transaction targets 'self'
118	// Block transactions targeting self with a value greater than 0
119	if (execTransaction.value > BigInt(0)) {	26!
UNCOV 120	return false;	×
121	}
122
123	const isCancellation = execTransaction.data === '0x';	26✔
124	return isCancellation \|\| this.safeContract.isCall(execTransaction.data);	26✔
125	}
126
127	private async isOfficialMastercopy(args: {
128	chainId: string;
129	address: string;
130	}): Promise<boolean> {
131	try {	32✔
132	await this.safeRepository.getSafe(args);	32✔
133	return true;	26✔
134	} catch {
135	return false;	6✔
136	}
137	}
138
139	private isOfficialMultiSendDeployment(args: {
140	chainId: string;
141	address: string;
142	}): boolean {
143	const multiSendDeployment = getMultiSendCallOnlyDeployment({	12✔
144	version: LimitAddressesMapper.SUPPORTED_SAFE_VERSION,
145	network: args.chainId,
146	});
147	return (	12✔
148	multiSendDeployment?.networkAddresses[args.chainId] === args.address \|\|	26✔
149	multiSendDeployment?.defaultAddress === args.address	6✔
150	);
151	}
152
153	private getSafeAddressFromMultiSend = (data: Hex): Hex => {	50✔
154	// Decode transactions within MultiSend
155	const transactions = this.multiSendDecoder.mapMultiSendTransactions(data);	8✔
156
157	// Every transaction is a valid execTransaction
158	const isEveryValid = transactions.every((transaction) => {	8✔
159	return this.isValidExecTransactionCall(transaction);	16✔
160	});
161
162	if (!isEveryValid) {	8✔
163	throw Error('Invalid MultiSend transactions');	2✔
164	}
165
166	const firstRecipient = transactions[0].to;	6✔
167
168	const isSameRecipient = transactions.every((transaction) => {	6✔
169	return transaction.to === firstRecipient;	12✔
170	});
171
172	if (!isSameRecipient) {	6✔
173	throw Error('MultiSend transactions target different addresses');	2✔
174	}
175
176	return firstRecipient;	4✔
177	};
178
179	private isValidCreateProxyWithNonceCall(args: {
180	chainId: string;
181	data: Hex;
182	}): boolean {
183	let singleton: string \| null = null;	14✔
184
185	try {	14✔
186	const decoded = this.proxyFactoryDecoder.decodeFunctionData({	14✔
187	data: args.data,
188	});
189
190	if (decoded.functionName !== 'createProxyWithNonce') {	6!
UNCOV 191	return false;	×
192	}
193
194	singleton = decoded.args[0];	6✔
195	} catch (e) {
196	return false;	8✔
197	}
198
199	const safeL1Deployment = getSafeSingletonDeployment({	6✔
200	version: LimitAddressesMapper.SUPPORTED_SAFE_VERSION,
201	network: args.chainId,
202	});
203	const safeL2Deployment = getSafeL2SingletonDeployment({	6✔
204	version: LimitAddressesMapper.SUPPORTED_SAFE_VERSION,
205	network: args.chainId,
206	});
207
208	const isL1Singleton =
209	safeL1Deployment?.networkAddresses[args.chainId] === singleton;	6✔
210	const isL2Singleton =
211	safeL2Deployment?.networkAddresses[args.chainId] === singleton;	6✔
212
213	return isL1Singleton \|\| isL2Singleton;	6✔
214	}
215
216	private getOwnersFromCreateProxyWithNonce(data: Hex): readonly Hex[] {
217	const decodedProxyFactory = this.proxyFactoryDecoder.decodeFunctionData({	4✔
218	data,
219	});
220
221	if (decodedProxyFactory.functionName !== 'createProxyWithNonce') {	4!
222	throw Error('Not a createProxyWithNonce call');	×
223	}
224
225	const initializer = decodedProxyFactory.args[1];	4✔
226	const decodedSafe = this.safeDecoder.decodeFunctionData({	4✔
227	data: initializer,
228	});
229
230	if (decodedSafe.functionName !== 'setup') {	4!
UNCOV 231	throw Error('Not a setup call');	×
232	}
233
234	return decodedSafe.args[0];	4✔
235	}
236	}

safe-global / safe-client-gateway / 7903099633

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