9130188919

Committed 17 May 2024 02:55PM UTC coverage: 92.799% (-0.05%) from 92.846%

Build # 9130188919

Build Type

Pull #1564

github

Committed by

web-flow

Commit Message

Merge 56064ca09 into 9384e7eab

Pull Request Pull Request #1564: Improve imitation detection to cover multiple and incoming transfers

Run Details

2027 of 2481 branches covered (81.7%)

Branch coverage included in aggregate %.

29 of 34 new or added lines in 1 file covered. (85.29%)

2 existing lines in 2 files now uncovered.

7123 of 7379 relevant lines covered (96.53%)

328.65 hits per line

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

78.41

/src/routes/transactions/mappers/common/transaction-info.mapper.ts

import { Inject, Injectable } from '@nestjs/common';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { ModuleTransaction } from '@/domain/safe/entities/module-transaction.entity';
import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
import { Operation } from '@/domain/safe/entities/operation.entity';
import { TokenRepository } from '@/domain/tokens/token.repository';
import { ITokenRepository } from '@/domain/tokens/token.repository.interface';
import { TokenType } from '@/routes/balances/entities/token-type.entity';
import { DataDecodedParameter } from '@/routes/data-decode/entities/data-decoded-parameter.entity';
import { DataDecoded } from '@/routes/data-decode/entities/data-decoded.entity';
import { SettingsChangeTransaction } from '@/routes/transactions/entities/settings-change-transaction.entity';
import { TransactionInfo } from '@/routes/transactions/entities/transaction-info.entity';
import { CustomTransactionMapper } from '@/routes/transactions/mappers/common/custom-transaction.mapper';
import { DataDecodedParamHelper } from '@/routes/transactions/mappers/common/data-decoded-param.helper';
import { Erc20TransferMapper } from '@/routes/transactions/mappers/common/erc20-transfer.mapper';
import { Erc721TransferMapper } from '@/routes/transactions/mappers/common/erc721-transfer.mapper';
import { HumanDescriptionMapper } from '@/routes/transactions/mappers/common/human-description.mapper';
import { NativeCoinTransferMapper } from '@/routes/transactions/mappers/common/native-coin-transfer.mapper';
import { SettingsChangeMapper } from '@/routes/transactions/mappers/common/settings-change.mapper';
import { SwapOrderMapper } from '@/routes/transactions/mappers/common/swap-order.mapper';
import { isHex } from 'viem';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { SwapOrderTransactionInfo } from '@/routes/transactions/entities/swaps/swap-order-info.entity';
import { SwapOrderHelper } from '@/routes/transactions/helpers/swap-order.helper';

@Injectable()
export class MultisigTransactionInfoMapper {
  private readonly TRANSFER_METHOD = 'transfer';
  private readonly TRANSFER_FROM_METHOD = 'transferFrom';
  private readonly SAFE_TRANSFER_FROM_METHOD = 'safeTransferFrom';
  private readonly isRichFragmentsEnabled: boolean;
  private readonly isSwapsDecodingEnabled: boolean;

  private readonly ERC20_TRANSFER_METHODS = [
    this.TRANSFER_METHOD,
    this.TRANSFER_FROM_METHOD,
  ];

  private readonly ERC721_TRANSFER_METHODS = [
    this.TRANSFER_METHOD,
    this.TRANSFER_FROM_METHOD,
    this.SAFE_TRANSFER_FROM_METHOD,
  ];

  constructor(
    @Inject(ITokenRepository) private readonly tokenRepository: TokenRepository,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    private readonly dataDecodedParamHelper: DataDecodedParamHelper,
    private readonly customTransactionMapper: CustomTransactionMapper,
    private readonly settingsChangeMapper: SettingsChangeMapper,
    private readonly nativeCoinTransferMapper: NativeCoinTransferMapper,
    private readonly erc20TransferMapper: Erc20TransferMapper,
    private readonly erc721TransferMapper: Erc721TransferMapper,
    private readonly humanDescriptionMapper: HumanDescriptionMapper,
    private readonly swapOrderMapper: SwapOrderMapper,
    private readonly swapOrderHelper: SwapOrderHelper,
  ) {
    this.isRichFragmentsEnabled = this.configurationService.getOrThrow(
      'features.richFragments',
    );
    this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(
      'features.swapsDecoding',
    );
  }

  async mapTransactionInfo(
    chainId: string,
    transaction: MultisigTransaction | ModuleTransaction,
  ): Promise<TransactionInfo> {
    const value = Number(transaction?.value) || 0;
    const dataByteLength = transaction.data
      ? Buffer.byteLength(transaction.data)
      : 0;

    const dataSize =
      dataByteLength >= 2 ? Math.floor((dataByteLength - 2) / 2) : 0;

    const richDecodedInfo =
      await this.humanDescriptionMapper.mapRichDecodedInfo(
        transaction,
        chainId,
      );

    const humanDescription =
      this.humanDescriptionMapper.mapHumanDescription(richDecodedInfo);

    // If the rich fragment feature is disabled, we set it as undefined.
    // Undefined properties are not rendered on the response
    const richDecodedInfoApiProperty = this.isRichFragmentsEnabled
      ? richDecodedInfo
      : undefined;

    if (this.isSwapsDecodingEnabled) {
      const swapOrder: SwapOrderTransactionInfo | null =
        await this.mapSwapOrder(chainId, transaction);
      // If the transaction is a swap order, we return it immediately
      if (swapOrder) return swapOrder;
    }

    if (this.isCustomTransaction(value, dataSize, transaction.operation)) {
      return await this.customTransactionMapper.mapCustomTransaction(
        transaction,
        dataSize,
        chainId,
        humanDescription,
        richDecodedInfoApiProperty,
      );
    }

    if (this.isNativeCoinTransfer(value, dataSize)) {
      return this.nativeCoinTransferMapper.mapNativeCoinTransfer(
        chainId,
        transaction,
        humanDescription,
        richDecodedInfoApiProperty,
      );
    }

    if (this.isSettingsChange(transaction, value, dataSize)) {
      const settingsInfo = await this.settingsChangeMapper.mapSettingsChange(
        chainId,
        transaction,
      );

      if (!transaction.dataDecoded) {
        throw new Error(
          `Data decoded is null. txHash=${transaction.transactionHash}`,
        );
      }

      const dataDecodedParameters: DataDecodedParameter[] | null =
        transaction.dataDecoded.parameters?.map(
          (parameter) =>
            new DataDecodedParameter(
              parameter.name,
              parameter.type,
              parameter.value,
              parameter.valueDecoded,
            ),
        ) ?? null;

      return new SettingsChangeTransaction(
        new DataDecoded(transaction.dataDecoded.method, dataDecodedParameters),
        settingsInfo,
        humanDescription,
        richDecodedInfoApiProperty,
      );
    }

    if (this.isValidTokenTransfer(transaction)) {
      const token = await this.tokenRepository
        .getToken({ chainId, address: transaction.to })
        .catch(() => null);

      switch (token?.type) {
        case TokenType.Erc20:
          return this.erc20TransferMapper.mapErc20Transfer(
            token,
            chainId,
            transaction,
            humanDescription,
            richDecodedInfoApiProperty,
          );
        case TokenType.Erc721:
          return this.erc721TransferMapper.mapErc721Transfer(
            token,
            chainId,
            transaction,
            humanDescription,
            richDecodedInfoApiProperty,
          );
      }
    }

    return this.customTransactionMapper.mapCustomTransaction(
      transaction,
      dataSize,
      chainId,
      humanDescription,
      richDecodedInfoApiProperty,
    );
  }

  /**
   * Maps a swap order transaction.
   * If the transaction is not a swap order, it returns null.
   *
   * @param chainId
   * @param transaction
   * @private
   */
  private async mapSwapOrder(
    chainId: string,
    transaction: MultisigTransaction | ModuleTransaction,
  ): Promise<SwapOrderTransactionInfo | null> {
    if (!transaction?.data || !isHex(transaction.data)) {
      return null;
    }

    const orderData: `0x${string}` | null = this.swapOrderHelper.findSwapOrder(
      transaction.data,
    );

    if (!orderData) {
      return null;
    }

    try {
      return await this.swapOrderMapper.mapSwapOrder(chainId, {
        data: orderData,
      });
    } catch (error) {
      // The transaction is a swap order, but we couldn't decode it successfully.
      this.loggingService.warn(error);
      return null;
    }
  }

  private isCustomTransaction(
    value: number,
    dataSize: number,
    operation: Operation,
  ): boolean {
    return (value > 0 && dataSize > 0) || operation !== 0;
  }

  private isNativeCoinTransfer(value: number, dataSize: number): boolean {
    return value > 0 && dataSize === 0;
  }

  private isSettingsChange(
    transaction: MultisigTransaction | ModuleTransaction,
    value: number,
    dataSize: number,
  ): boolean {
    const isSettingsChangeMethod: boolean = transaction.dataDecoded
      ? SettingsChangeMapper.SETTINGS_CHANGE_METHODS.includes(
          transaction.dataDecoded.method,
        )
      : false;

    return (
      value === 0 &&
      dataSize > 0 &&
      transaction.safe === transaction.to &&
      isSettingsChangeMethod
    );
  }

  private isValidTokenTransfer(
    transaction: MultisigTransaction | ModuleTransaction,
  ): boolean {
    return (
      (this.isErc20Transfer(transaction) ||
        this.isErc721Transfer(transaction)) &&
      this.isSafeSenderOrReceiver(transaction)
    );
  }

  private isErc20Transfer(
    transaction: MultisigTransaction | ModuleTransaction,
  ): boolean {
    const { dataDecoded } = transaction;
    return this.ERC20_TRANSFER_METHODS.some(
      (method) => method === dataDecoded?.method,
    );
  }

  private isErc721Transfer(
    transaction: MultisigTransaction | ModuleTransaction,
  ): boolean {
    const { dataDecoded } = transaction;
    return this.ERC721_TRANSFER_METHODS.some(
      (method) => method === dataDecoded?.method,
    );
  }

  private isSafeSenderOrReceiver(
    transaction: MultisigTransaction | ModuleTransaction,
  ): boolean {
    const { dataDecoded } = transaction;
    if (!dataDecoded) return false;
    return (
      this.TRANSFER_METHOD == dataDecoded.method ||
      this.dataDecodedParamHelper.getFromParam(dataDecoded, '') ===
        transaction.safe ||
      this.dataDecodedParamHelper.getToParam(dataDecoded, '') ===
        transaction.safe
    );
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	108✔
2	import { IConfigurationService } from '@/config/configuration.service.interface';	108✔
3	import { ModuleTransaction } from '@/domain/safe/entities/module-transaction.entity';
4	import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
5	import { Operation } from '@/domain/safe/entities/operation.entity';
6	import { TokenRepository } from '@/domain/tokens/token.repository';	108✔
7	import { ITokenRepository } from '@/domain/tokens/token.repository.interface';	108✔
8	import { TokenType } from '@/routes/balances/entities/token-type.entity';	108✔
9	import { DataDecodedParameter } from '@/routes/data-decode/entities/data-decoded-parameter.entity';	108✔
10	import { DataDecoded } from '@/routes/data-decode/entities/data-decoded.entity';	108✔
11	import { SettingsChangeTransaction } from '@/routes/transactions/entities/settings-change-transaction.entity';	108✔
12	import { TransactionInfo } from '@/routes/transactions/entities/transaction-info.entity';
13	import { CustomTransactionMapper } from '@/routes/transactions/mappers/common/custom-transaction.mapper';	108✔
14	import { DataDecodedParamHelper } from '@/routes/transactions/mappers/common/data-decoded-param.helper';	108✔
15	import { Erc20TransferMapper } from '@/routes/transactions/mappers/common/erc20-transfer.mapper';	108✔
16	import { Erc721TransferMapper } from '@/routes/transactions/mappers/common/erc721-transfer.mapper';	108✔
17	import { HumanDescriptionMapper } from '@/routes/transactions/mappers/common/human-description.mapper';	108✔
18	import { NativeCoinTransferMapper } from '@/routes/transactions/mappers/common/native-coin-transfer.mapper';	108✔
19	import { SettingsChangeMapper } from '@/routes/transactions/mappers/common/settings-change.mapper';	108✔
20	import { SwapOrderMapper } from '@/routes/transactions/mappers/common/swap-order.mapper';	108✔
21	import { isHex } from 'viem';	108✔
22	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	108✔
23	import { SwapOrderTransactionInfo } from '@/routes/transactions/entities/swaps/swap-order-info.entity';
24	import { SwapOrderHelper } from '@/routes/transactions/helpers/swap-order.helper';	108✔
25
26	@Injectable()
27	export class MultisigTransactionInfoMapper {	108✔
28	private readonly TRANSFER_METHOD = 'transfer';	1,376✔
29	private readonly TRANSFER_FROM_METHOD = 'transferFrom';	1,376✔
30	private readonly SAFE_TRANSFER_FROM_METHOD = 'safeTransferFrom';	1,376✔
31	private readonly isRichFragmentsEnabled: boolean;
32	private readonly isSwapsDecodingEnabled: boolean;
33
34	private readonly ERC20_TRANSFER_METHODS = [	1,376✔
35	this.TRANSFER_METHOD,
36	this.TRANSFER_FROM_METHOD,
37	];
38
39	private readonly ERC721_TRANSFER_METHODS = [	1,376✔
40	this.TRANSFER_METHOD,
41	this.TRANSFER_FROM_METHOD,
42	this.SAFE_TRANSFER_FROM_METHOD,
43	];
44
45	constructor(
46	@Inject(ITokenRepository) private readonly tokenRepository: TokenRepository,	1,376✔
47	@Inject(IConfigurationService)
48	private readonly configurationService: IConfigurationService,	1,376✔
49	@Inject(LoggingService) private readonly loggingService: ILoggingService,	1,376✔
50	private readonly dataDecodedParamHelper: DataDecodedParamHelper,	1,376✔
51	private readonly customTransactionMapper: CustomTransactionMapper,	1,376✔
52	private readonly settingsChangeMapper: SettingsChangeMapper,	1,376✔
53	private readonly nativeCoinTransferMapper: NativeCoinTransferMapper,	1,376✔
54	private readonly erc20TransferMapper: Erc20TransferMapper,	1,376✔
55	private readonly erc721TransferMapper: Erc721TransferMapper,	1,376✔
56	private readonly humanDescriptionMapper: HumanDescriptionMapper,	1,376✔
57	private readonly swapOrderMapper: SwapOrderMapper,	1,376✔
58	private readonly swapOrderHelper: SwapOrderHelper,	1,376✔
59	) {
60	this.isRichFragmentsEnabled = this.configurationService.getOrThrow(	1,376✔
61	'features.richFragments',
62	);
63	this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(	1,376✔
64	'features.swapsDecoding',
65	);
66	}
67
68	async mapTransactionInfo(
69	chainId: string,
70	transaction: MultisigTransaction \| ModuleTransaction,
71	): Promise<TransactionInfo> {
72	const value = Number(transaction?.value) \|\| 0;	104✔
73	const dataByteLength = transaction.data	104✔
74	? Buffer.byteLength(transaction.data)
75	: 0;
76
77	const dataSize =
78	dataByteLength >= 2 ? Math.floor((dataByteLength - 2) / 2) : 0;	104✔
79
80	const richDecodedInfo =
81	await this.humanDescriptionMapper.mapRichDecodedInfo(	104✔
82	transaction,
83	chainId,
84	);
85
86	const humanDescription =
87	this.humanDescriptionMapper.mapHumanDescription(richDecodedInfo);	104✔
88
89	// If the rich fragment feature is disabled, we set it as undefined.
90	// Undefined properties are not rendered on the response
91	const richDecodedInfoApiProperty = this.isRichFragmentsEnabled	104!
92	? richDecodedInfo
93	: undefined;
94
95	if (this.isSwapsDecodingEnabled) {	104✔
96	const swapOrder: SwapOrderTransactionInfo \| null =
97	await this.mapSwapOrder(chainId, transaction);	104✔
98	// If the transaction is a swap order, we return it immediately
99	if (swapOrder) return swapOrder;	104!
100	}
101
102	if (this.isCustomTransaction(value, dataSize, transaction.operation)) {	104✔
103	return await this.customTransactionMapper.mapCustomTransaction(	42✔
104	transaction,
105	dataSize,
106	chainId,
107	humanDescription,
108	richDecodedInfoApiProperty,
109	);
110	}
111
112	if (this.isNativeCoinTransfer(value, dataSize)) {	62✔
113	return this.nativeCoinTransferMapper.mapNativeCoinTransfer(	30✔
114	chainId,
115	transaction,
116	humanDescription,
117	richDecodedInfoApiProperty,
118	);
119	}
120
121	if (this.isSettingsChange(transaction, value, dataSize)) {	32!
122	const settingsInfo = await this.settingsChangeMapper.mapSettingsChange(	×
123	chainId,
124	transaction,
125	);
126
127	if (!transaction.dataDecoded) {	×
128	throw new Error(	×
129	`Data decoded is null. txHash=${transaction.transactionHash}`,
130	);
131	}
132
133	const dataDecodedParameters: DataDecodedParameter[] \| null =
134	transaction.dataDecoded.parameters?.map(	×
135	(parameter) =>
136	new DataDecodedParameter(	×
137	parameter.name,
138	parameter.type,
139	parameter.value,
140	parameter.valueDecoded,
141	),
142	) ?? null;
143
144	return new SettingsChangeTransaction(	×
145	new DataDecoded(transaction.dataDecoded.method, dataDecodedParameters),
146	settingsInfo,
147	humanDescription,
148	richDecodedInfoApiProperty,
149	);
150	}
151
152	if (this.isValidTokenTransfer(transaction)) {	32✔
153	const token = await this.tokenRepository	32✔
154	.getToken({ chainId, address: transaction.to })
155	.catch(() => null);	×
156
157	switch (token?.type) {	32!
158	case TokenType.Erc20:
159	return this.erc20TransferMapper.mapErc20Transfer(	30✔
160	token,
161	chainId,
162	transaction,
163	humanDescription,
164	richDecodedInfoApiProperty,
165	);
166	case TokenType.Erc721:
167	return this.erc721TransferMapper.mapErc721Transfer(	2✔
168	token,
169	chainId,
170	transaction,
171	humanDescription,
172	richDecodedInfoApiProperty,
173	);
174	}
175	}
176
UNCOV 177	return this.customTransactionMapper.mapCustomTransaction(	×
178	transaction,
179	dataSize,
180	chainId,
181	humanDescription,
182	richDecodedInfoApiProperty,
183	);
184	}
185
186	/**
187	* Maps a swap order transaction.
188	* If the transaction is not a swap order, it returns null.
189	*
190	* @param chainId
191	* @param transaction
192	* @private
193	*/
194	private async mapSwapOrder(
195	chainId: string,
196	transaction: MultisigTransaction \| ModuleTransaction,
197	): Promise<SwapOrderTransactionInfo \| null> {
198	if (!transaction?.data \|\| !isHex(transaction.data)) {	104!
199	return null;	4✔
200	}
201
202	const orderData: `0x${string}` \| null = this.swapOrderHelper.findSwapOrder(	100✔
203	transaction.data,
204	);
205
206	if (!orderData) {	100✔
207	return null;	100✔
208	}
209
210	try {	×
211	return await this.swapOrderMapper.mapSwapOrder(chainId, {	×
212	data: orderData,
213	});
214	} catch (error) {
215	// The transaction is a swap order, but we couldn't decode it successfully.
216	this.loggingService.warn(error);	×
217	return null;	×
218	}
219	}
220
221	private isCustomTransaction(
222	value: number,
223	dataSize: number,
224	operation: Operation,
225	): boolean {
226	return (value > 0 && dataSize > 0) \|\| operation !== 0;	104✔
227	}
228
229	private isNativeCoinTransfer(value: number, dataSize: number): boolean {
230	return value > 0 && dataSize === 0;	62✔
231	}
232
233	private isSettingsChange(
234	transaction: MultisigTransaction \| ModuleTransaction,
235	value: number,
236	dataSize: number,
237	): boolean {
238	const isSettingsChangeMethod: boolean = transaction.dataDecoded	32!
239	? SettingsChangeMapper.SETTINGS_CHANGE_METHODS.includes(
240	transaction.dataDecoded.method,
241	)
242	: false;
243
244	return (	32✔
245	value === 0 &&	32!
246	dataSize > 0 &&
247	transaction.safe === transaction.to &&
248	isSettingsChangeMethod
249	);
250	}
251
252	private isValidTokenTransfer(
253	transaction: MultisigTransaction \| ModuleTransaction,
254	): boolean {
255	return (	32✔
256	(this.isErc20Transfer(transaction) \|\|	33✔
257	this.isErc721Transfer(transaction)) &&
258	this.isSafeSenderOrReceiver(transaction)
259	);
260	}
261
262	private isErc20Transfer(
263	transaction: MultisigTransaction \| ModuleTransaction,
264	): boolean {
265	const { dataDecoded } = transaction;	32✔
266	return this.ERC20_TRANSFER_METHODS.some(	32✔
267	(method) => method === dataDecoded?.method,	34!
268	);
269	}
270
271	private isErc721Transfer(
272	transaction: MultisigTransaction \| ModuleTransaction,
273	): boolean {
274	const { dataDecoded } = transaction;	2✔
275	return this.ERC721_TRANSFER_METHODS.some(	2✔
276	(method) => method === dataDecoded?.method,	6!
277	);
278	}
279
280	private isSafeSenderOrReceiver(
281	transaction: MultisigTransaction \| ModuleTransaction,
282	): boolean {
283	const { dataDecoded } = transaction;	32✔
284	if (!dataDecoded) return false;	32!
285	return (	32✔
286	this.TRANSFER_METHOD == dataDecoded.method \|\|	17!
287	this.dataDecodedParamHelper.getFromParam(dataDecoded, '') ===
288	transaction.safe \|\|
289	this.dataDecodedParamHelper.getToParam(dataDecoded, '') ===
290	transaction.safe
291	);
292	}
293	}

safe-global / safe-client-gateway / 9130188919

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