7798909082

Committed 06 Feb 2024 11:24AM UTC coverage: 92.727% (-0.3%) from 92.992%

Build # 7798909082

Build Type

Pull #1112

github

Committed by

iamacook

Commit Message

Add an leverage `isCall` method to `AbiDecoder`

Pull Request Pull Request #1112: Handle `multiSend` relay limiting

Run Details

1505 of 1816 branches covered (0.0%)

Branch coverage included in aggregate %.

9 of 28 new or added lines in 4 files covered. (32.14%)

1 existing line in 1 file now uncovered.

5788 of 6049 relevant lines covered (95.69%)

180.26 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/alerts/contracts/multi-send-decoder.helper';

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

@Injectable()
export class LimitAddressesMapper {
  constructor(
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    private readonly safeContract: SafeContractHelper,
    private readonly erc20Contract: Erc20ContractHelper,
    private readonly multiSendDecoder: MultiSendDecoder,
  ) {}

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

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

    // TODO Handle create proxy with nonce

    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 isMultiSend(data: Hex): boolean {
    return this.multiSendDecoder.isFunctionCall({
      functionName: 'multiSend',
      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;

    // Every transaction is 'self' (the Safe)
    const isSameRecipient = transactions.every((transaction) => {
      return transaction.to === firstRecipient;
    });

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

    return firstRecipient;
  };
}

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/alerts/contracts/multi-send-decoder.helper';	×
7
8	export interface RelayPayload {
9	chainId: string;
10	data: Hex;
11	to: Hex;
12	gasLimit: bigint;
13	}
14
15	@Injectable()
16	export class LimitAddressesMapper {	×
17	constructor(
18	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
19	private readonly safeContract: SafeContractHelper,	×
20	private readonly erc20Contract: Erc20ContractHelper,	×
NEW 21	private readonly multiSendDecoder: MultiSendDecoder,	×
22	) {}
23
24	getLimitAddresses(relayPayload: RelayPayload): Hex[] {
25	if (this.isValidExecTransactionCall(relayPayload.to, relayPayload.data)) {	×
26	return [relayPayload.to];	×
27	}
28
NEW 29	if (this.isMultiSend(relayPayload.data)) {	×
30	// Validity of MultiSend is part of address retrieval
NEW 31	const safeAddress = this.getSafeAddressFromMultiSend(relayPayload.data);	×
NEW 32	return [safeAddress];	×
33	}
34
35	// TODO Handle create proxy with nonce
36
37	throw Error('Cannot get limit addresses – Invalid transfer');	×
38	}
39
40	private isValidExecTransactionCall(to: string, data: Hex): boolean {
41	let execTransaction: { data: Hex; to: Hex; value: bigint };
42	// If transaction is an execTransaction
43	try {	×
44	execTransaction = this.safeContract.decode(	×
45	SafeContractHelper.EXEC_TRANSACTION,
46	data,
47	);
48	} catch (e) {
49	return false;	×
50	}
51
52	// If data of execTransaction is an ERC20 transfer
53	try {	×
54	const erc20DecodedData = this.erc20Contract.decode(	×
55	Erc20ContractHelper.TRANSFER,
56	execTransaction.data,
57	);
58	// If the ERC20 transfer targets 'self' (the Safe), we consider it to be invalid
59	return erc20DecodedData.to !== to;	×
60	} catch {
61	// swallow exception if data is not an ERC20 transfer
62	}
63
64	// If a transaction does not target 'self' consider it valid
65	if (to !== execTransaction.to) {	×
66	return true;	×
67	}
68
69	// Transaction targets 'self'
70	// Block transactions targeting self with a value greater than 0
71	if (execTransaction.value > BigInt(0)) {	×
72	return false;	×
73	}
74
75	const isCancellation = execTransaction.data === '0x';	×
76	return isCancellation \|\| this.safeContract.isCall(execTransaction.data);	×
77	}
78
79	private isMultiSend(data: Hex): boolean {
NEW 80	return this.multiSendDecoder.isFunctionCall({	×
81	functionName: 'multiSend',
82	data,
83	});
84	}
85
NEW 86	private getSafeAddressFromMultiSend = (data: Hex): Hex => {	×
87	// Decode transactions within MultiSend
NEW 88	const transactions = this.multiSendDecoder.mapMultiSendTransactions(data);	×
89
90	// Every transaction is a valid execTransaction
NEW 91	const isEveryValid = transactions.every((transaction) => {	×
NEW 92	return this.isValidExecTransactionCall(transaction.to, transaction.data);	×
93	});
94
NEW 95	if (!isEveryValid) {	×
NEW 96	throw Error('Invalid MultiSend transactions');	×
97	}
98
NEW 99	const firstRecipient = transactions[0].to;	×
100
101	// Every transaction is 'self' (the Safe)
NEW 102	const isSameRecipient = transactions.every((transaction) => {	×
NEW 103	return transaction.to === firstRecipient;	×
104	});
105
NEW 106	if (!isSameRecipient) {	×
NEW 107	throw Error('MultiSend transactions target different addresses');	×
108	}
109
NEW 110	return firstRecipient;	×
111	};
112	}

safe-global / safe-client-gateway / 7798909082

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