8752642977

Committed 19 Apr 2024 11:11AM UTC coverage: 92.11% (-0.6%) from 92.677%

Build # 8752642977

Build Type

Pull #1428

github

Committed by

iamacook

Commit Message

Fix comment

Pull Request Pull Request #1428: Event poisoning filter demo

Run Details

1934 of 2359 branches covered (81.98%)

Branch coverage included in aggregate %.

1 of 27 new or added lines in 1 file covered. (3.7%)

4 existing lines in 2 files now uncovered.

6857 of 7185 relevant lines covered (95.43%)

307.1 hits per line

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

73.98

/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 { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';
import { SwapOrderMapper } from '@/routes/transactions/mappers/common/swap-order.mapper';
import { MultiSendDecoder } from '@/domain/contracts/decoders/multi-send-decoder.helper';
import { isHex } from 'viem';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { SwapOrderTransactionInfo } from '@/routes/transactions/entities/swap-order-info.entity';

@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 setPreSignatureDecoder: SetPreSignatureDecoder,
    private readonly swapOrderMapper: SwapOrderMapper,
    private readonly multiSendDecoder: MultiSendDecoder,
  ) {
    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,
    );
  }

  private isSwapOrder(transaction: { data?: `0x${string}` }): boolean {
    if (!transaction.data) return false;
    return this.setPreSignatureDecoder.isSetPreSignature(transaction.data);
  }

  /**
   * 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.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;
    }
  }

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

safe-global / safe-client-gateway / 8752642977

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