11101264981

Committed 30 Sep 2024 07:17AM UTC coverage: 91.939% (+1.1%) from 90.875%

Build # 11101264981

Build Type

Pull #1973

github

Committed by

iamacook

Commit Message

Add full test coverage for staking

Pull Request Pull Request #1973: Add swap and staking tests to preview endpoint

Run Details

2615 of 3184 branches covered (82.13%)

Branch coverage included in aggregate %.

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

8 existing lines in 2 files now uncovered.

8482 of 8886 relevant lines covered (95.45%)

463.05 hits per line

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

86.58

/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-deposit-info.entity';
import { NativeStakingMapper } from '@/routes/transactions/mappers/common/native-staking.mapper';
import { KilnNativeStakingHelper } from '@/routes/transactions/helpers/kiln-native-staking.helper';
import { NativeStakingValidatorsExitTransactionInfo } from '@/routes/transactions/entities/staking/native-staking-validators-exit-info.entity';
import { NativeStakingWithdrawTransactionInfo } from '@/routes/transactions/entities/staking/native-staking-withdraw-info.entity';
import { KilnDecoder } from '@/domain/staking/contracts/decoders/kiln-decoder.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,
    private readonly kilnDecoder: KilnDecoder,
  ) {
    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;
      }

      const nativeStakingValidatorsExit =
        await this.mapNativeStakingValidatorsExit(chainId, transaction);
      // If the transaction is a native staking validators exit, we return it immediately
      if (nativeStakingValidatorsExit) {
        return nativeStakingValidatorsExit;
      }

      const nativeStakingWithdraw = await this.mapNativeStakingWithdraw(
        chainId,
        transaction,
      );
      // If the transaction is a native staking withdraw, we return it immediately
      if (nativeStakingWithdraw) {
        return nativeStakingWithdraw;
      }
    }

    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 || !transaction.value) {
      return null;
    }

    const nativeStakingDepositTransaction =
      this.kilnNativeStakingHelper.findDepositTransaction({
        chainId,
        to: transaction.to,
        data: transaction.data,
        value: transaction.value,
      });

    if (!nativeStakingDepositTransaction?.to) {
      return null;
    }

    try {
      return await this.nativeStakingMapper.mapDepositInfo({
        chainId,
        to: nativeStakingDepositTransaction.to,
        value: nativeStakingDepositTransaction.value,
        txHash: transaction.transactionHash,
      });
    } catch (error) {
      this.loggingService.warn(error);
      return null;
    }
  }

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

    const nativeStakingValidatorsExitTransaction =
      this.kilnNativeStakingHelper.findValidatorsExitTransaction({
        chainId,
        to: transaction.to,
        data: transaction.data,
        value: transaction.value,
      });

    if (!nativeStakingValidatorsExitTransaction?.to) {
      return null;
    }

    try {
      return await this.nativeStakingMapper.mapValidatorsExitInfo({
        chainId,
        safeAddress: transaction.safe,
        to: nativeStakingValidatorsExitTransaction.to,
        data: nativeStakingValidatorsExitTransaction.data,
      });
    } catch (error) {
      this.loggingService.warn(error);
      return null;
    }
  }

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

    const nativeStakingWithdrawTransaction =
      this.kilnNativeStakingHelper.findWithdrawTransaction({
        chainId,
        to: transaction.to,
        data: transaction.data,
        value: transaction.value,
      });

    if (!nativeStakingWithdrawTransaction?.to) {
      return null;
    }

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

safe-global / safe-client-gateway / 11101264981

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