11054300850

Committed 26 Sep 2024 02:24PM UTC coverage: 90.857% (-0.04%) from 90.893%

Build # 11054300850

Build Type

Pull #1964

github

Committed by

iamacook

Commit Message

Update tests

Pull Request Pull Request #1964: Return validator addresses in staking entities

Run Details

2586 of 3217 branches covered (80.39%)

Branch coverage included in aggregate %.

11 of 11 new or added lines in 6 files covered. (100.0%)

1 existing line in 1 file now uncovered.

8424 of 8901 relevant lines covered (94.64%)

444.12 hits per line

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

79.35

/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,
  TransferTransactionInfo,
} from '@/routes/transactions/entities/transfer-transaction-info.entity';
import { isErc20Transfer } from '@/routes/transactions/entities/transfers/erc20-transfer.entity';
import { isSwapTransferTransactionInfo } from '@/routes/transactions/swap-transfer-transaction-info.entity';
import { Inject } from '@nestjs/common';
import { formatUnits } from 'viem';

export class TransferImitationMapper {
  private static ETH_DECIMALS = 18;

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

  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',
    );
  }

  /**
   * 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 (
        !(
          isTransferTransactionInfo(txInfo) ||
          isSwapTransferTransactionInfo(txInfo)
        ) ||
        !isErc20Transfer(txInfo.transferInfo)
      ) {
        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;
      }

      // Imitation transfers often employ differing decimals to prevent direct
      // comparison of values. Here we normalize the value
      const formattedValue = this.formatValue(
        txInfo.transferInfo.value,
        txInfo.transferInfo.decimals,
      );
      // Either sender or recipient according to "direction" of transaction
      const refAddress = this.getReferenceAddress(txInfo);

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

        const prevFormattedValue = this.formatValue(
          prevTxInfo.transferInfo.value,
          prevTxInfo.transferInfo.decimals,
        );

        // Imitation transfers match in value
        if (formattedValue !== prevFormattedValue) {
          return false;
        }

        // Imitation transfers match in vanity of address
        const prevRefAddress = this.getReferenceAddress(prevTxInfo);
        return this.isImitatorAddress(refAddress, prevRefAddress);
      });

      txInfo.transferInfo.imitation = isImitation;

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

    return mappedTransactions;
  }

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

safe-global / safe-client-gateway / 11054300850

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