11361205200

Committed 16 Oct 2024 07:46AM UTC coverage: 91.824% (+0.004%) from 91.82%

Build # 11361205200

Build Type

Pull #2024

github

Committed by

iamacook

Commit Message

Cleanup testa

Pull Request Pull Request #2024: Flag spoof events with varied value

Run Details

2612 of 3171 branches covered (82.37%)

Branch coverage included in aggregate %.

15 of 15 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

8697 of 9145 relevant lines covered (95.1%)

418.69 hits per line

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

84.04

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

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

type Erc20TransferTransactionInfo = Omit<
  TransferTransactionInfo,
  'transferInfo'
> & {
  transferInfo: Erc20Transfer;
};

export class TransferImitationMapper {
  private static ETH_DECIMALS = 18;

  private readonly lookupDistance: number;
  private readonly prefixLength: number;
  private readonly suffixLength: number;
  private readonly valueTolerance: bigint;

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

  /**
   * Flags or filters (according to {@link args.showImitations}) transactions
   * that are likely imitations, based on the value and vanity of the address of
   * the sender or recipient.
   *
   * Note: does not support batched transactions as we have no transaction data
   * to decode the individual transactions from.
   *
   * @param args.transactions - transactions to map
   * @param args.previousTransaction - first transaction of the next page
   * @param args.showImitations - whether to filter out imitations
   *
   * @returns - mapped transactions
   */
  mapImitations(args: {
    transactions: Array<TransactionItem>;
    previousTransaction: TransactionItem | undefined;
    showImitations: boolean;
  }): Array<TransactionItem> {
    const mappedTransactions: Array<TransactionItem> = [];

    // Iterate in reverse order as transactions are date descending
    for (let i = args.transactions.length - 1; i >= 0; i--) {
      const item = args.transactions[i];

      // Executed by Safe - cannot be imitation
      if (item.transaction.executionInfo) {
        mappedTransactions.unshift(item);
        continue;
      }

      const txInfo = item.transaction.txInfo;
      // Only transfers can be imitated, of which we are only interested in ERC20s
      if (!this.isErc20TransferTransactionInfo(txInfo)) {
        mappedTransactions.unshift(item);
        continue;
      }

      /**
       * Transactions to compare for imitation against, limited by a lookup distance.
       *
       * Concatenation takes preference of already mapped transactions over their
       * original in order to prevent comparison against duplicates.
       * Its length is {@link transactions} + 1 as {@link previousTransaction}
       * is appended to compare {@link transactions.at(-1)} against.
       */
      const prevItems = mappedTransactions
        .concat(args.transactions.slice(i - 1), args.previousTransaction ?? [])
        // Only compare so far back
        .slice(0, this.lookupDistance);

      if (prevItems.length === 0) {
        txInfo.transferInfo.imitation = false;
        mappedTransactions.unshift(item);
        continue;
      }

      const isImitation = prevItems.some((prevItem) => {
        const prevTxInfo = prevItem.transaction.txInfo;
        if (
          !this.isErc20TransferTransactionInfo(prevTxInfo) ||
          // Do not compare against previously identified imitations
          prevTxInfo.transferInfo.imitation
        ) {
          return false;
        }

        return this.isSpoofedEvent(txInfo, prevTxInfo);
      });

      txInfo.transferInfo.imitation = isImitation;

      if (!isImitation || args.showImitations) {
        mappedTransactions.unshift(item);
      }
    }

    return mappedTransactions;
  }

  /**
   * Returns whether {@link txInfo} is fake event imitating {@link prevTxInfo}
   *
   * A tolerant value transfer to a similar vanity address is deemed an imitation.
   *
   * @param {Erc20TransferTransactionInfo} txInfo - transaction info to compare
   * @param {Erc20TransferTransactionInfo} prevTxInfo - previous transaction info
   * @returns {boolean} - whether the transaction is an imitation
   */
  isSpoofedEvent(
    txInfo: Erc20TransferTransactionInfo,
    prevTxInfo: Erc20TransferTransactionInfo,
  ): boolean {
    const value = this.formatValue(txInfo.transferInfo);
    const prevValue = this.formatValue(prevTxInfo.transferInfo);

    // Value can differ by +/- tolerance
    const isTolerant =
      value <= prevValue + this.valueTolerance &&
      value >= prevValue - this.valueTolerance;
    if (!isTolerant) {
      return false;
    }

    const refAddress = this.getReferenceAddress(txInfo);
    const prevRefAddress = this.getReferenceAddress(prevTxInfo);
    return this.isImitatorAddress(refAddress, prevRefAddress);
  }

  /**
   * Returns whether the transaction info is an ERC-20 transfer
   * @param {Erc20TransferTransactionInfo} txInfo - transaction info
   * @returns {boolean} - whether an ERC-20 transfer
   */
  private isErc20TransferTransactionInfo(
    txInfo: TransactionInfo,
  ): txInfo is Erc20TransferTransactionInfo {
    return (
      (isTransferTransactionInfo(txInfo) ||
        isSwapTransferTransactionInfo(txInfo)) &&
      isErc20Transfer(txInfo.transferInfo)
    );
  }

  /**
   * Divides the given value by 10 to the power of the decimals
   * @param {string} args.value - value to format
   * @param {number|null} args.decimals - decimals to divide by
   * @returns {bigint} - formatted value
   */
  private formatValue(args: Pick<Erc20Transfer, 'value' | 'decimals'>): bigint {
    const decimals = args.decimals ?? TransferImitationMapper.ETH_DECIMALS;
    return BigInt(args.value) / BigInt(10 ** decimals);
  }

  /**
   * Returns the address of the sender or recipient according to the direction
   * @param txInfo - transaction info
   * @returns - address of sender or recipient
   */
  private getReferenceAddress(txInfo: TransferTransactionInfo): string {
    return txInfo.direction === TransferDirection.Outgoing
      ? txInfo.recipient.value
      : txInfo.sender.value;
  }

  /**
   * Returns whether the two addresses match in vanity
   * @param address1 - address to compare against
   * @param address2  - second address to compare
   * @returns - whether the two addresses are imitators
   */
  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';	106✔
2	import { TransactionInfo } from '@/routes/transactions/entities/transaction-info.entity';
3	import { TransactionItem } from '@/routes/transactions/entities/transaction-item.entity';
4	import {	106✔
5	isTransferTransactionInfo,
6	TransferDirection,
7	TransferTransactionInfo,
8	} from '@/routes/transactions/entities/transfer-transaction-info.entity';
9	import {	106✔
10	Erc20Transfer,
11	isErc20Transfer,
12	} from '@/routes/transactions/entities/transfers/erc20-transfer.entity';
13	import { isSwapTransferTransactionInfo } from '@/routes/transactions/swap-transfer-transaction-info.entity';	106✔
14	import { Inject } from '@nestjs/common';	106✔
15
16	type Erc20TransferTransactionInfo = Omit<
17	TransferTransactionInfo,
18	'transferInfo'
19	> & {
20	transferInfo: Erc20Transfer;
21	};
22
23	export class TransferImitationMapper {	106✔
24	private static ETH_DECIMALS = 18;	106✔
25
26	private readonly lookupDistance: number;
27	private readonly prefixLength: number;
28	private readonly suffixLength: number;
29	private readonly valueTolerance: bigint;
30
31	constructor(
32	@Inject(IConfigurationService)
33	private readonly configurationService: IConfigurationService,	1,232✔
34	) {
35	this.lookupDistance = configurationService.getOrThrow(	1,232✔
36	'mappings.imitation.lookupDistance',
37	);
38	this.prefixLength = configurationService.getOrThrow(	1,232✔
39	'mappings.imitation.prefixLength',
40	);
41	this.suffixLength = configurationService.getOrThrow(	1,232✔
42	'mappings.imitation.suffixLength',
43	);
44	this.valueTolerance = configurationService.getOrThrow(	1,232✔
45	'mappings.imitation.valueTolerance',
46	);
47	}
48
49	/**
50	* Flags or filters (according to {@link args.showImitations}) transactions
51	* that are likely imitations, based on the value and vanity of the address of
52	* the sender or recipient.
53	*
54	* Note: does not support batched transactions as we have no transaction data
55	* to decode the individual transactions from.
56	*
57	* @param args.transactions - transactions to map
58	* @param args.previousTransaction - first transaction of the next page
59	* @param args.showImitations - whether to filter out imitations
60	*
61	* @returns - mapped transactions
62	*/
63	mapImitations(args: {
64	transactions: Array<TransactionItem>;
65	previousTransaction: TransactionItem \| undefined;
66	showImitations: boolean;
67	}): Array<TransactionItem> {
68	const mappedTransactions: Array<TransactionItem> = [];	8✔
69
70	// Iterate in reverse order as transactions are date descending
71	for (let i = args.transactions.length - 1; i >= 0; i--) {	8✔
72	const item = args.transactions[i];	40✔
73
74	// Executed by Safe - cannot be imitation
75	if (item.transaction.executionInfo) {	40✔
76	mappedTransactions.unshift(item);	24✔
77	continue;	24✔
78	}
79
80	const txInfo = item.transaction.txInfo;	16✔
81	// Only transfers can be imitated, of which we are only interested in ERC20s
82	if (!this.isErc20TransferTransactionInfo(txInfo)) {	16!
UNCOV 83	mappedTransactions.unshift(item);	×
84	continue;	×
85	}
86
87	/**
88	* Transactions to compare for imitation against, limited by a lookup distance.
89	*
90	* Concatenation takes preference of already mapped transactions over their
91	* original in order to prevent comparison against duplicates.
92	* Its length is {@link transactions} + 1 as {@link previousTransaction}
93	* is appended to compare {@link transactions.at(-1)} against.
94	*/
95	const prevItems = mappedTransactions	16✔
96	.concat(args.transactions.slice(i - 1), args.previousTransaction ?? [])	24!
97	// Only compare so far back
98	.slice(0, this.lookupDistance);
99
100	if (prevItems.length === 0) {	16!
101	txInfo.transferInfo.imitation = false;	×
102	mappedTransactions.unshift(item);	×
103	continue;	×
104	}
105
106	const isImitation = prevItems.some((prevItem) => {	16✔
107	const prevTxInfo = prevItem.transaction.txInfo;	28✔
108	if (	28!
109	!this.isErc20TransferTransactionInfo(prevTxInfo) \|\|	28✔
110	// Do not compare against previously identified imitations
111	prevTxInfo.transferInfo.imitation
112	) {
113	return false;	×
114	}
115
116	return this.isSpoofedEvent(txInfo, prevTxInfo);	28✔
117	});
118
119	txInfo.transferInfo.imitation = isImitation;	16✔
120
121	if (!isImitation \|\| args.showImitations) {	16✔
122	mappedTransactions.unshift(item);	12✔
123	}
124	}
125
126	return mappedTransactions;	8✔
127	}
128
129	/**
130	* Returns whether {@link txInfo} is fake event imitating {@link prevTxInfo}
131	*
132	* A tolerant value transfer to a similar vanity address is deemed an imitation.
133	*
134	* @param {Erc20TransferTransactionInfo} txInfo - transaction info to compare
135	* @param {Erc20TransferTransactionInfo} prevTxInfo - previous transaction info
136	* @returns {boolean} - whether the transaction is an imitation
137	*/
138	isSpoofedEvent(
139	txInfo: Erc20TransferTransactionInfo,
140	prevTxInfo: Erc20TransferTransactionInfo,
141	): boolean {
142	const value = this.formatValue(txInfo.transferInfo);	28✔
143	const prevValue = this.formatValue(prevTxInfo.transferInfo);	28✔
144
145	// Value can differ by +/- tolerance
146	const isTolerant =
147	value <= prevValue + this.valueTolerance &&	28✔
148	value >= prevValue - this.valueTolerance;
149	if (!isTolerant) {	28✔
150	return false;	16✔
151	}
152
153	const refAddress = this.getReferenceAddress(txInfo);	12✔
154	const prevRefAddress = this.getReferenceAddress(prevTxInfo);	12✔
155	return this.isImitatorAddress(refAddress, prevRefAddress);	12✔
156	}
157
158	/**
159	* Returns whether the transaction info is an ERC-20 transfer
160	* @param {Erc20TransferTransactionInfo} txInfo - transaction info
161	* @returns {boolean} - whether an ERC-20 transfer
162	*/
163	private isErc20TransferTransactionInfo(
164	txInfo: TransactionInfo,
165	): txInfo is Erc20TransferTransactionInfo {
166	return (	44✔
167	(isTransferTransactionInfo(txInfo) \|\|	44!
168	isSwapTransferTransactionInfo(txInfo)) &&
169	isErc20Transfer(txInfo.transferInfo)
170	);
171	}
172
173	/**
174	* Divides the given value by 10 to the power of the decimals
175	* @param {string} args.value - value to format
176	* @param {number\|null} args.decimals - decimals to divide by
177	* @returns {bigint} - formatted value
178	*/
179	private formatValue(args: Pick<Erc20Transfer, 'value' \| 'decimals'>): bigint {
180	const decimals = args.decimals ?? TransferImitationMapper.ETH_DECIMALS;	56!
181	return BigInt(args.value) / BigInt(10 ** decimals);	56✔
182	}
183
184	/**
185	* Returns the address of the sender or recipient according to the direction
186	* @param txInfo - transaction info
187	* @returns - address of sender or recipient
188	*/
189	private getReferenceAddress(txInfo: TransferTransactionInfo): string {
190	return txInfo.direction === TransferDirection.Outgoing	24✔
191	? txInfo.recipient.value
192	: txInfo.sender.value;
193	}
194
195	/**
196	* Returns whether the two addresses match in vanity
197	* @param address1 - address to compare against
198	* @param address2 - second address to compare
199	* @returns - whether the two addresses are imitators
200	*/
201	private isImitatorAddress(address1: string, address2: string): boolean {
202	const a1 = address1.toLowerCase();	12✔
203	const a2 = address2.toLowerCase();	12✔
204
205	// Same address is not an imitation
206	if (a1 === a2) {	12✔
207	return false;	4✔
208	}
209
210	const isSamePrefix =
211	// Ignore `0x` prefix
212	a1.slice(2, 2 + this.prefixLength) === a2.slice(2, 2 + this.prefixLength);	8✔
213	const isSameSuffix =
214	a1.slice(-this.suffixLength) === a2.slice(-this.suffixLength);	8✔
215	return isSamePrefix && isSameSuffix;	8✔
216	}
217	}

safe-global / safe-client-gateway / 11361205200

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