7959227486

Committed 19 Feb 2024 12:05PM UTC coverage: 93.98% (+0.08%) from 93.902%

Build # 7959227486

Build Type

Pull #1154

github

Committed by

iamacook

Commit Message

Improve batch error messages

Pull Request Pull Request #1154: Throw custom errors from relayer

Run Details

1643 of 1954 branches covered (84.08%)

Branch coverage included in aggregate %.

46 of 46 new or added lines in 10 files covered. (100.0%)

3 existing lines in 2 files now uncovered.

6163 of 6352 relevant lines covered (97.02%)

193.14 hits per line

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

94.51

/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,
  getMultiSendDeployment,
} from '@safe-global/safe-deployments';
import { SafeDecoder } from '@/domain/contracts/contracts/safe-decoder.helper';
import { isAddress, isHex } from 'viem';
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';

@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: {
    chainId: string;
    to: string;
    data: string;
  }): Promise<readonly Hex[]> {
    if (!isAddress(args.to)) {
      throw Error('Invalid to provided');
    }

    if (!isHex(args.data)) {
      throw Error('Invalid data provided');
    }

    // 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.isMultiSend(args.data)) {
      if (
        !this.isOfficialMultiSendDeployment({
          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({
        chainId: args.chainId,
        data: args.data,
      })
    ) {
      // Owners of safe-to-be-created will be limited
      return this.getOwnersFromCreateProxyWithNonce(args.data);
    }

    throw new InvalidTransferError();
  }

  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 multiSendCallOnlyDeployment = getMultiSendCallOnlyDeployment({
      version: LimitAddressesMapper.SUPPORTED_SAFE_VERSION,
      network: args.chainId,
    });

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

    if (isCallOnly) {
      return true;
    }

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

safe-global / safe-client-gateway / 7959227486

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