10523134579

Committed 23 Aug 2024 09:11AM UTC coverage: 46.656% (-0.04%) from 46.695%

Build # 10523134579

Build Type

Pull #1842

github

Committed by

hectorgomezv

Commit Message

Adjust unit tests

Pull Request Pull Request #1842: Add StakingStatus to native staking deposit transactions

Run Details

496 of 3005 branches covered (16.51%)

Branch coverage included in aggregate %.

6 of 15 new or added lines in 4 files covered. (40.0%)

2 existing lines in 2 files now uncovered.

4729 of 8194 relevant lines covered (57.71%)

12.33 hits per line

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

20.5

/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';
import { NativeStakingDepositTransactionInfo } from '@/routes/transactions/entities/staking/native-staking-info.entity';
import { NativeStakingMapper } from '@/routes/transactions/mappers/common/native-staking.mapper';
import { KilnNativeStakingHelper } from '@/routes/transactions/helpers/kiln-native-staking.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 isTwapsDecodingEnabled: boolean;
  private readonly isNativeStakingDecodingEnabled: 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,
    private readonly kilnNativeStakingHelper: KilnNativeStakingHelper,
    private readonly nativeStakingMapper: NativeStakingMapper,
  ) {
    this.isRichFragmentsEnabled = this.configurationService.getOrThrow(
      'features.richFragments',
    );
    this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(
      'features.swapsDecoding',
    );
    this.isTwapsDecodingEnabled = this.configurationService.getOrThrow(
      'features.twapsDecoding',
    );
    this.isNativeStakingDecodingEnabled = this.configurationService.getOrThrow(
      'features.nativeStakingDecoding',
    );
  }

  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 (this.isNativeStakingDecodingEnabled) {
      const nativeStakingDeposit = await this.mapNativeStakingDeposit(
        chainId,
        transaction,
      );
      // If the transaction is a native staking deposit, we return it immediately
      if (nativeStakingDeposit) {
        return nativeStakingDeposit;
      }
    }

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

  /**
   * Maps a native staking `deposit` transaction.
   * If the transaction is not to an official deployment, it returns null.
   *
   * @param chainId - chain ID of the transaction
   * @param transaction - transaction to map
   * @returns mapped {@link NativeStakingDepositTransactionInfo} or null if none found
   */
  private async mapNativeStakingDeposit(
    chainId: string,
    transaction: MultisigTransaction | ModuleTransaction,
  ): Promise<NativeStakingDepositTransactionInfo | null> {
    if (!transaction?.data) {
      return null;
    }

    const nativeStakingTransaction =
      await this.kilnNativeStakingHelper.findDeposit({
        chainId,
        to: transaction.to,
        data: transaction.data,
      });

    if (!nativeStakingTransaction) {
      return null;
    }

    try {
      const tx = transaction as MultisigTransaction;
      const isConfirmed =
        !!tx.confirmations &&
        tx.confirmations.length >= tx.confirmationsRequired;

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

safe-global / safe-client-gateway / 10523134579

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