7885742236

Committed 13 Feb 2024 11:23AM UTC coverage: 92.155% (+0.05%) from 92.105%

Build # 7885742236

Build Type

Pull #1138

github

Committed by

iamacook

Commit Message

Remove proxy factory tests

Pull Request Pull Request #1138: Reorganise contract decoders

Run Details

1514 of 1842 branches covered (82.19%)

Branch coverage included in aggregate %.

7 of 11 new or added lines in 8 files covered. (63.64%)

1 existing line in 1 file now uncovered.

5816 of 6112 relevant lines covered (95.16%)

179.86 hits per line

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

0.0

/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 { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { MultiSendDecoder } from '@/domain/contracts/contracts/multi-send-decoder.helper';
import { ProxyFactoryDecoder } from '@/domain/relay/contracts/proxy-factory-decoder.helper';
import {
  getSafeSingletonDeployment,
  getSafeL2SingletonDeployment,
} 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(LoggingService) private readonly loggingService: ILoggingService,
    private readonly safeContract: SafeContractHelper,
    private readonly erc20Contract: Erc20ContractHelper,
    private readonly safeDecoder: SafeDecoder,
    private readonly multiSendDecoder: MultiSendDecoder,
    private readonly proxyFactoryDecoder: ProxyFactoryDecoder,
  ) {}

  getLimitAddresses(relayPayload: RelayPayload): readonly Hex[] {
    if (this.isValidExecTransactionCall(relayPayload.to, relayPayload.data)) {
      return [relayPayload.to];
    }

    if (this.multiSendDecoder.isMultiSend(relayPayload.data)) {
      // Validity of MultiSend is part of address retrieval
      const safeAddress = this.getSafeAddressFromMultiSend(relayPayload.data);
      return [safeAddress];
    }

    if (
      this.isValidCreateProxyWithNonce(relayPayload.chainId, relayPayload.data)
    ) {
      return this.getOwnersFromCreateProxyWithNonce(relayPayload.data);
    }

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

  private isValidExecTransactionCall(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,
        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 !== to;
    } catch {
      // swallow exception if data is not an ERC20 transfer
    }

    // If a transaction does not target 'self' consider it valid
    if (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 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.to, transaction.data);
    });

    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 isValidCreateProxyWithNonce(chainId: string, data: Hex): boolean {
    let singleton: string | null = null;

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

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

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

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

    const isL1Singleton =
      safeL1Deployment?.networkAddresses[chainId] === singleton;
    const isL2Singleton =
      safeL2Deployment?.networkAddresses[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	import { Hex } from 'viem/types/misc';
3	import { Erc20ContractHelper } from '@/domain/relay/contracts/erc20-contract.helper';	×
4	import { SafeContractHelper } from '@/domain/relay/contracts/safe-contract.helper';	×
5	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	×
NEW 6	import { MultiSendDecoder } from '@/domain/contracts/contracts/multi-send-decoder.helper';	×
7	import { ProxyFactoryDecoder } from '@/domain/relay/contracts/proxy-factory-decoder.helper';	×
8	import {	×
9	getSafeSingletonDeployment,
10	getSafeL2SingletonDeployment,
11	} from '@safe-global/safe-deployments';
NEW 12	import { SafeDecoder } from '@/domain/contracts/contracts/safe-decoder.helper';	×
13
14	export interface RelayPayload {
15	chainId: string;
16	data: Hex;
17	to: Hex;
18	gasLimit: bigint;
19	}
20
21	@Injectable()
22	export class LimitAddressesMapper {	×
23	// TODO: Abstract with that from SafeContractHelper
24	private static SUPPORTED_SAFE_VERSION = '1.3.0';	×
25
26	constructor(
27	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
28	private readonly safeContract: SafeContractHelper,	×
29	private readonly erc20Contract: Erc20ContractHelper,	×
30	private readonly safeDecoder: SafeDecoder,	×
31	private readonly multiSendDecoder: MultiSendDecoder,	×
32	private readonly proxyFactoryDecoder: ProxyFactoryDecoder,	×
33	) {}
34
35	getLimitAddresses(relayPayload: RelayPayload): readonly Hex[] {
36	if (this.isValidExecTransactionCall(relayPayload.to, relayPayload.data)) {	×
37	return [relayPayload.to];	×
38	}
39
40	if (this.multiSendDecoder.isMultiSend(relayPayload.data)) {	×
41	// Validity of MultiSend is part of address retrieval
42	const safeAddress = this.getSafeAddressFromMultiSend(relayPayload.data);	×
43	return [safeAddress];	×
44	}
45
46	if (	×
47	this.isValidCreateProxyWithNonce(relayPayload.chainId, relayPayload.data)
48	) {
49	return this.getOwnersFromCreateProxyWithNonce(relayPayload.data);	×
50	}
51
52	throw Error('Cannot get limit addresses – Invalid transfer');	×
53	}
54
55	private isValidExecTransactionCall(to: string, data: Hex): boolean {
56	let execTransaction: { data: Hex; to: Hex; value: bigint };
57	// If transaction is an execTransaction
58	try {	×
59	execTransaction = this.safeContract.decode(	×
60	SafeContractHelper.EXEC_TRANSACTION,
61	data,
62	);
63	} catch (e) {
64	return false;	×
65	}
66
67	// If data of execTransaction is an ERC20 transfer
68	try {	×
69	const erc20DecodedData = this.erc20Contract.decode(	×
70	Erc20ContractHelper.TRANSFER,
71	execTransaction.data,
72	);
73	// If the ERC20 transfer targets 'self' (the Safe), we consider it to be invalid
74	return erc20DecodedData.to !== to;	×
75	} catch {
76	// swallow exception if data is not an ERC20 transfer
77	}
78
79	// If a transaction does not target 'self' consider it valid
80	if (to !== execTransaction.to) {	×
81	return true;	×
82	}
83
84	// Transaction targets 'self'
85	// Block transactions targeting self with a value greater than 0
86	if (execTransaction.value > BigInt(0)) {	×
87	return false;	×
88	}
89
90	const isCancellation = execTransaction.data === '0x';	×
91	return isCancellation \|\| this.safeContract.isCall(execTransaction.data);	×
92	}
93
94	private getSafeAddressFromMultiSend = (data: Hex): Hex => {	×
95	// Decode transactions within MultiSend
96	const transactions = this.multiSendDecoder.mapMultiSendTransactions(data);	×
97
98	// Every transaction is a valid execTransaction
99	const isEveryValid = transactions.every((transaction) => {	×
100	return this.isValidExecTransactionCall(transaction.to, transaction.data);	×
101	});
102
103	if (!isEveryValid) {	×
104	throw Error('Invalid MultiSend transactions');	×
105	}
106
107	const firstRecipient = transactions[0].to;	×
108
109	const isSameRecipient = transactions.every((transaction) => {	×
110	return transaction.to === firstRecipient;	×
111	});
112
113	if (!isSameRecipient) {	×
114	throw Error('MultiSend transactions target different addresses');	×
115	}
116
117	return firstRecipient;	×
118	};
119
120	private isValidCreateProxyWithNonce(chainId: string, data: Hex): boolean {
121	let singleton: string \| null = null;	×
122
123	try {	×
124	const decoded = this.proxyFactoryDecoder.decodeFunctionData({	×
125	data,
126	});
127
128	if (decoded.functionName !== 'createProxyWithNonce') {	×
129	return false;	×
130	}
131
132	singleton = decoded.args[0];	×
133	} catch (e) {
134	return false;	×
135	}
136
137	const safeL1Deployment = getSafeSingletonDeployment({	×
138	version: LimitAddressesMapper.SUPPORTED_SAFE_VERSION,
139	network: chainId,
140	});
141	const safeL2Deployment = getSafeL2SingletonDeployment({	×
142	version: LimitAddressesMapper.SUPPORTED_SAFE_VERSION,
143	network: chainId,
144	});
145
146	const isL1Singleton =
147	safeL1Deployment?.networkAddresses[chainId] === singleton;	×
148	const isL2Singleton =
149	safeL2Deployment?.networkAddresses[chainId] === singleton;	×
150
151	return isL1Singleton \|\| isL2Singleton;	×
152	}
153
154	private getOwnersFromCreateProxyWithNonce(data: Hex): readonly Hex[] {
155	const decodedProxyFactory = this.proxyFactoryDecoder.decodeFunctionData({	×
156	data,
157	});
158
159	if (decodedProxyFactory.functionName !== 'createProxyWithNonce') {	×
160	throw Error('Not a createProxyWithNonce call');	×
161	}
162
163	const initializer = decodedProxyFactory.args[1];	×
164	const decodedSafe = this.safeDecoder.decodeFunctionData({	×
165	data: initializer,
166	});
167
168	if (decodedSafe.functionName !== 'setup') {	×
169	throw Error('Not a setup call');	×
170	}
171
172	return decodedSafe.args[0];	×
173	}
174	}

safe-global / safe-client-gateway / 7885742236

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