9079488815

Committed 14 May 2024 12:39PM UTC coverage: 93.14% (+0.4%) from 92.775%

Build # 9079488815

Build Type

Pull #1542

github

Committed by

web-flow

Commit Message

Merge b21d7519d into 3f5226c37

Pull Request Pull Request #1542: Add flagging (alongside filtering) of imitation transfers

Run Details

2005 of 2426 branches covered (82.65%)

Branch coverage included in aggregate %.

25 of 26 new or added lines in 4 files covered. (96.15%)

3 existing lines in 3 files now uncovered.

6997 of 7239 relevant lines covered (96.66%)

325.42 hits per line

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

90.0

/src/routes/transactions/mappers/transfers/transfer-imitation.mapper.ts

import { IConfigurationService } from '@/config/configuration.service.interface';
import { TransactionItem } from '@/routes/transactions/entities/transaction-item.entity';
import {
  isTransferTransactionInfo,
  TransferDirection,
} from '@/routes/transactions/entities/transfer-transaction-info.entity';
import { isErc20Transfer } from '@/routes/transactions/entities/transfers/erc20-transfer.entity';
import { Inject } from '@nestjs/common';

export class TransferImitationMapper {
  private readonly prefixLength: number;
  private readonly suffixLength: number;

  constructor(
    @Inject(IConfigurationService) configurationService: IConfigurationService,
  ) {
    this.prefixLength = configurationService.getOrThrow(
      'mappings.imitation.prefixLength',
    );
    this.suffixLength = configurationService.getOrThrow(
      'mappings.imitation.suffixLength',
    );
  }

  mapImitations(args: {
    transactions: Array<TransactionItem>;
    previousTransaction: TransactionItem | undefined;
    showImitations: boolean;
  }): Array<TransactionItem> {
    const transactions = this.mapTransferInfoImitation(
      args.transactions,
      args.previousTransaction,
    );

    if (args.showImitations) {
      return transactions;
    }

    return transactions.filter(({ transaction }) => {
      const { txInfo } = transaction;
      return (
        !isTransferTransactionInfo(txInfo) ||
        !isErc20Transfer(txInfo.transferInfo) ||
        // null by default or explicitly false if not imitation
        txInfo.transferInfo?.imitation !== true
      );
    });
  }

  /**
   * Flags outgoing ERC20 transfers that imitate their direct predecessor in value
   * and have a recipient address that is not the same but matches in vanity.
   *
   * @param transactions - list of transactions to map
   * @param previousTransaction - transaction to compare last {@link transactions} against
   *
   * Note: this only handles singular imitation transfers. It does not handle multiple
   * imitation transfers in a row, nor does it compare batched multiSend transactions
   * as the "distance" between those batched and their imitation may not be immediate.
   */
  private mapTransferInfoImitation(
    transactions: Array<TransactionItem>,
    previousTransaction?: TransactionItem,
  ): Array<TransactionItem> {
    return transactions.map((item, i, arr) => {
      // Executed by Safe - cannot be imitation
      if (item.transaction.executionInfo) {
        return item;
      }

      // Transaction list is in date-descending order. We compare each transaction with the next
      // unless we are comparing the last transaction, in which case we compare it with the
      // "previous transaction" (the first transaction of the subsequent page).
      const prevItem = i === arr.length - 1 ? previousTransaction : arr[i + 1];

      // No reference transaction to filter against
      if (!prevItem) {
        return item;
      }

      if (
        // Only consider transfers...
        !isTransferTransactionInfo(item.transaction.txInfo) ||
        !isTransferTransactionInfo(prevItem.transaction.txInfo) ||
        // ...of ERC20s...
        !isErc20Transfer(item.transaction.txInfo.transferInfo) ||
        !isErc20Transfer(prevItem.transaction.txInfo.transferInfo)
      ) {
        return item;
      }

      // ...that are outgoing
      const isOutgoing =
        item.transaction.txInfo.direction === TransferDirection.Outgoing;
      const isPrevOutgoing =
        prevItem.transaction.txInfo.direction === TransferDirection.Outgoing;
      if (!isOutgoing || !isPrevOutgoing) {
        return item;
      }

      // Imitation transfers are of the same value...
      const isSameValue =
        item.transaction.txInfo.transferInfo.value ===
        prevItem.transaction.txInfo.transferInfo.value;
      if (!isSameValue) {
        return item;
      }

      item.transaction.txInfo.transferInfo.imitation = this.isImitatorAddress(
        item.transaction.txInfo.recipient.value,
        prevItem.transaction.txInfo.recipient.value,
      );

      return item;
    });
  }

  private isImitatorAddress(address1: string, address2: string): boolean {
    const a1 = address1.toLowerCase();
    const a2 = address2.toLowerCase();

    // Same address is not an imitation
    if (a1 === a2) {
      return false;
    }

    const isSamePrefix =
      // Ignore `0x` prefix
      a1.slice(2, 2 + this.prefixLength) === a2.slice(2, 2 + this.prefixLength);
    const isSameSuffix =
      a1.slice(-this.suffixLength) === a2.slice(-this.suffixLength);
    return isSamePrefix && isSameSuffix;
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	100✔
2	import { TransactionItem } from '@/routes/transactions/entities/transaction-item.entity';
3	import {	100✔
4	isTransferTransactionInfo,
5	TransferDirection,
6	} from '@/routes/transactions/entities/transfer-transaction-info.entity';
7	import { isErc20Transfer } from '@/routes/transactions/entities/transfers/erc20-transfer.entity';	100✔
8	import { Inject } from '@nestjs/common';	100✔
9
10	export class TransferImitationMapper {	100✔
11	private readonly prefixLength: number;
12	private readonly suffixLength: number;
13
14	constructor(
15	@Inject(IConfigurationService) configurationService: IConfigurationService,
16	) {
17	this.prefixLength = configurationService.getOrThrow(	1,342✔
18	'mappings.imitation.prefixLength',
19	);
20	this.suffixLength = configurationService.getOrThrow(	1,342✔
21	'mappings.imitation.suffixLength',
22	);
23	}
24
25	mapImitations(args: {
26	transactions: Array<TransactionItem>;
27	previousTransaction: TransactionItem \| undefined;
28	showImitations: boolean;
29	}): Array<TransactionItem> {
30	const transactions = this.mapTransferInfoImitation(	36✔
31	args.transactions,
32	args.previousTransaction,
33	);
34
35	if (args.showImitations) {	36✔
36	return transactions;	4✔
37	}
38
39	return transactions.filter(({ transaction }) => {	32✔
40	const { txInfo } = transaction;	60✔
41	return (	60✔
42	!isTransferTransactionInfo(txInfo) \|\|	65✔
43	!isErc20Transfer(txInfo.transferInfo) \|\|
44	// null by default or explicitly false if not imitation
45	txInfo.transferInfo?.imitation !== true	33!
46	);
47	});
48	}
49
50	/**
51	* Flags outgoing ERC20 transfers that imitate their direct predecessor in value
52	* and have a recipient address that is not the same but matches in vanity.
53	*
54	* @param transactions - list of transactions to map
55	* @param previousTransaction - transaction to compare last {@link transactions} against
56	*
57	* Note: this only handles singular imitation transfers. It does not handle multiple
58	* imitation transfers in a row, nor does it compare batched multiSend transactions
59	* as the "distance" between those batched and their imitation may not be immediate.
60	*/
61	private mapTransferInfoImitation(
62	transactions: Array<TransactionItem>,
63	previousTransaction?: TransactionItem,
64	): Array<TransactionItem> {
65	return transactions.map((item, i, arr) => {	36✔
66	// Executed by Safe - cannot be imitation
67	if (item.transaction.executionInfo) {	68✔
68	return item;	26✔
69	}
70
71	// Transaction list is in date-descending order. We compare each transaction with the next
72	// unless we are comparing the last transaction, in which case we compare it with the
73	// "previous transaction" (the first transaction of the subsequent page).
74	const prevItem = i === arr.length - 1 ? previousTransaction : arr[i + 1];	42✔
75
76	// No reference transaction to filter against
77	if (!prevItem) {	42✔
78	return item;	20✔
79	}
80
81	if (	22✔
82	// Only consider transfers...
83	!isTransferTransactionInfo(item.transaction.txInfo) \|\|	39✔
84	!isTransferTransactionInfo(prevItem.transaction.txInfo) \|\|
85	// ...of ERC20s...
86	!isErc20Transfer(item.transaction.txInfo.transferInfo) \|\|
87	!isErc20Transfer(prevItem.transaction.txInfo.transferInfo)
88	) {
89	return item;	10✔
90	}
91
92	// ...that are outgoing
93	const isOutgoing =
94	item.transaction.txInfo.direction === TransferDirection.Outgoing;	12✔
95	const isPrevOutgoing =
96	prevItem.transaction.txInfo.direction === TransferDirection.Outgoing;	12✔
97	if (!isOutgoing \|\| !isPrevOutgoing) {	12✔
98	return item;	4✔
99	}
100
101	// Imitation transfers are of the same value...
102	const isSameValue =
103	item.transaction.txInfo.transferInfo.value ===	8✔
104	prevItem.transaction.txInfo.transferInfo.value;
105	if (!isSameValue) {	8!
NEW 106	return item;	×
107	}
108
109	item.transaction.txInfo.transferInfo.imitation = this.isImitatorAddress(	8✔
110	item.transaction.txInfo.recipient.value,
111	prevItem.transaction.txInfo.recipient.value,
112	);
113
114	return item;	8✔
115	});
116	}
117
118	private isImitatorAddress(address1: string, address2: string): boolean {
119	const a1 = address1.toLowerCase();	8✔
120	const a2 = address2.toLowerCase();	8✔
121
122	// Same address is not an imitation
123	if (a1 === a2) {	8!
124	return false;	×
125	}
126
127	const isSamePrefix =
128	// Ignore `0x` prefix
129	a1.slice(2, 2 + this.prefixLength) === a2.slice(2, 2 + this.prefixLength);	8✔
130	const isSameSuffix =
131	a1.slice(-this.suffixLength) === a2.slice(-this.suffixLength);	8✔
132	return isSamePrefix && isSameSuffix;	8✔
133	}
134	}

safe-global / safe-client-gateway / 9079488815

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