9644786118

Committed 24 Jun 2024 11:49AM UTC coverage: 48.739% (+0.005%) from 48.734%

Build # 9644786118

Build Type

Pull #1683

github

Committed by

web-flow

Commit Message

Merge f0bf9dbfd into aa50a4f05

Pull Request Pull Request #1683: Map TWAP orders in the queue

Run Details

415 of 2479 branches covered (16.74%)

Branch coverage included in aggregate %.

0 of 13 new or added lines in 4 files covered. (0.0%)

4 existing lines in 4 files now uncovered.

4107 of 6799 relevant lines covered (60.41%)

13.27 hits per line

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

19.47

/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 '@/domain/tokens/entities/token.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 { 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';
import { TwapOrderMapper } from '@/routes/transactions/mappers/common/twap-order.mapper';
import { TwapOrderHelper } from '@/routes/transactions/helpers/twap-order.helper';
import { TwapOrderTransactionInfo } from '@/routes/transactions/entities/swaps/twap-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 isTwapsDecodingEnabled: 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,
    private readonly twapOrderMapper: TwapOrderMapper,
    private readonly twapOrderHelper: TwapOrderHelper,
  ) {
    this.isRichFragmentsEnabled = this.configurationService.getOrThrow(
      'features.richFragments',
    );
    this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(
      'features.swapsDecoding',
    );
    this.isTwapsDecodingEnabled = this.configurationService.getOrThrow(
      'features.twapsDecoding',
    );
  }

  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.isTwapsDecodingEnabled) {
      // If the transaction is a TWAP order, we return it immediately
      const twapOrder = await this.mapTwapOrder(chainId, transaction);
      if (twapOrder) {
        return twapOrder;
      }

      // If the transaction is a TWAP-based swap order, we return it immediately
      const twapSwapOrder = await this.mapTwapSwapOrder(chainId, transaction);
      if (twapSwapOrder) {
        return twapSwapOrder;
      }
    }

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

  // TODO: Refactor mapSwapOrder, mapTwapOrder and mapTwapSwapOrder as they follow the same pattern

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

  /**
   * Maps a TWAP order transaction.
   * If the transaction is not a TWAP order, it returns null.
   *
   * @param chainId - chain ID of the transaction
   * @param transaction - transaction to map
   * @returns mapped {@link TwapOrderTransactionInfo} or null if none found
   */
  private async mapTwapOrder(
    chainId: string,
    transaction: MultisigTransaction | ModuleTransaction,
  ): Promise<TwapOrderTransactionInfo | null> {
    if (!transaction?.data) {
      return null;
    }

    const orderData = this.twapOrderHelper.findTwapOrder({
      to: transaction.to,
      data: transaction.data,
    });

    if (!orderData) {
      return null;
    }

    try {
      return await this.twapOrderMapper.mapTwapOrder(
        chainId,
        transaction.safe,
        {
          data: orderData,
          executionDate: transaction.executionDate,
        },
      );
    } catch (error) {
      this.loggingService.warn(error);
      return null;
    }
  }

  private async mapTwapSwapOrder(
    chainId: string,
    transaction: MultisigTransaction | ModuleTransaction,
  ): Promise<SwapOrderTransactionInfo | null> {
    if (!transaction?.data) {
      return null;
    }

    const orderData = this.swapOrderHelper.findTwapSwapOrder(transaction.data);

    if (!orderData) {
      return null;
    }

    try {
      return await this.swapOrderMapper.mapTwapSwapOrder(
        chainId,
        transaction.safe,
        {
          data: orderData,
        },
      );
    } catch (error) {
      this.loggingService.warn(error);
      return null;
    }
  }

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

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

safe-global / safe-client-gateway / 9644786118

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