11051168053

Committed 26 Sep 2024 11:19AM UTC coverage: 90.84% (-0.05%) from 90.893%

Build # 11051168053

Build Type

Pull #1964

github

Committed by

iamacook

Commit Message

Only return deposit validators after they exist

Pull Request Pull Request #1964: Return validator addresses in staking entities

Run Details

2584 of 3217 branches covered (80.32%)

Branch coverage included in aggregate %.

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

1 existing line in 1 file now uncovered.

8424 of 8901 relevant lines covered (94.64%)

444.71 hits per line

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

54.61

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

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

    if (!nativeStakingDepositTransaction) {
      return null;
    }

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

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

    const dataDecoded = transaction?.dataDecoded
      ? transaction.dataDecoded
      : this.kilnDecoder.decodeValidatorsExit(transaction.data);

    if (!dataDecoded) {
      return null;
    }

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

    if (!nativeStakingValidatorsExitTransaction) {
      return null;
    }

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

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

    const dataDecoded = transaction?.dataDecoded
      ? transaction.dataDecoded
      : this.kilnDecoder.decodeBatchWithdrawCLFee(transaction.data);

    if (!dataDecoded) {
      return null;
    }

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

    if (!nativeStakingWithdrawTransaction) {
      return null;
    }

    try {
      return await this.nativeStakingMapper.mapWithdrawInfo({
        chainId,
        safeAddress: transaction.safe,
        to: nativeStakingWithdrawTransaction.to,
        transaction,
        dataDecoded,
      });
    } 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,602✔
37	private readonly TRANSFER_FROM_METHOD = 'transferFrom';	1,602✔
38	private readonly SAFE_TRANSFER_FROM_METHOD = 'safeTransferFrom';	1,602✔
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,602✔
45	this.TRANSFER_METHOD,
46	this.TRANSFER_FROM_METHOD,
47	];
48
49	private readonly ERC721_TRANSFER_METHODS = [	1,602✔
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,602✔
57	@Inject(IConfigurationService)
58	private readonly configurationService: IConfigurationService,	1,602✔
59	@Inject(LoggingService) private readonly loggingService: ILoggingService,	1,602✔
60	private readonly dataDecodedParamHelper: DataDecodedParamHelper,	1,602✔
61	private readonly customTransactionMapper: CustomTransactionMapper,	1,602✔
62	private readonly settingsChangeMapper: SettingsChangeMapper,	1,602✔
63	private readonly nativeCoinTransferMapper: NativeCoinTransferMapper,	1,602✔
64	private readonly erc20TransferMapper: Erc20TransferMapper,	1,602✔
65	private readonly erc721TransferMapper: Erc721TransferMapper,	1,602✔
66	private readonly humanDescriptionMapper: HumanDescriptionMapper,	1,602✔
67	private readonly swapOrderMapper: SwapOrderMapper,	1,602✔
68	private readonly swapOrderHelper: SwapOrderHelper,	1,602✔
69	private readonly twapOrderMapper: TwapOrderMapper,	1,602✔
70	private readonly twapOrderHelper: TwapOrderHelper,	1,602✔
71	private readonly kilnNativeStakingHelper: KilnNativeStakingHelper,	1,602✔
72	private readonly nativeStakingMapper: NativeStakingMapper,	1,602✔
73	private readonly kilnDecoder: KilnDecoder,	1,602✔
74	) {
75	this.isRichFragmentsEnabled = this.configurationService.getOrThrow(	1,602✔
76	'features.richFragments',
77	);
78	this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(	1,602✔
79	'features.swapsDecoding',
80	);
81	this.isTwapsDecodingEnabled = this.configurationService.getOrThrow(	1,602✔
82	'features.twapsDecoding',
83	);
84	this.isNativeStakingDecodingEnabled = this.configurationService.getOrThrow(	1,602✔
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;	108✔
94	const dataByteLength = transaction.data	108✔
95	? Buffer.byteLength(transaction.data)
96	: 0;
97
98	const dataSize =
99	dataByteLength >= 2 ? Math.floor((dataByteLength - 2) / 2) : 0;	108✔
100
101	const richDecodedInfo =
102	await this.humanDescriptionMapper.mapRichDecodedInfo(	108✔
103	transaction,
104	chainId,
105	);
106
107	const humanDescription =
108	this.humanDescriptionMapper.mapHumanDescription(richDecodedInfo);	108✔
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	108!
113	? richDecodedInfo
114	: undefined;
115
116	if (this.isSwapsDecodingEnabled) {	108✔
117	const swapOrder: SwapOrderTransactionInfo \| null =
118	await this.mapSwapOrder(chainId, transaction);	108✔
119	// If the transaction is a swap order, we return it immediately
120	if (swapOrder) return swapOrder;	108!
121	}
122
123	if (this.isTwapsDecodingEnabled) {	108✔
124	// If the transaction is a TWAP order, we return it immediately
125	const twapOrder = await this.mapTwapOrder(chainId, transaction);	108✔
126	if (twapOrder) {	108!
127	return twapOrder;	×
128	}
129	}
130
131	if (this.isNativeStakingDecodingEnabled) {	108!
132	const nativeStakingDeposit = await this.mapNativeStakingDeposit(	×
133	chainId,
134	transaction,
135	);
136	// If the transaction is a native staking deposit, we return it immediately
137	if (nativeStakingDeposit) {	×
138	return nativeStakingDeposit;	×
139	}
140
141	const nativeStakingValidatorsExit =
142	await this.mapNativeStakingValidatorsExit(chainId, transaction);	×
143	// If the transaction is a native staking validators exit, we return it immediately
144	if (nativeStakingValidatorsExit) {	×
145	return nativeStakingValidatorsExit;	×
146	}
147
148	const nativeStakingWithdraw = await this.mapNativeStakingWithdraw(	×
149	chainId,
150	transaction,
151	);
152	// If the transaction is a native staking withdraw, we return it immediately
153	if (nativeStakingWithdraw) {	×
154	return nativeStakingWithdraw;	×
155	}
156	}
157
158	if (this.isCustomTransaction(value, dataSize, transaction.operation)) {	108✔
159	return await this.customTransactionMapper.mapCustomTransaction(	38✔
160	transaction,
161	dataSize,
162	chainId,
163	humanDescription,
164	richDecodedInfoApiProperty,
165	);
166	}
167
168	if (this.isNativeCoinTransfer(value, dataSize)) {	70✔
169	return this.nativeCoinTransferMapper.mapNativeCoinTransfer(	38✔
170	chainId,
171	transaction,
172	humanDescription,
173	richDecodedInfoApiProperty,
174	);
175	}
176
177	if (this.isSettingsChange(transaction, value, dataSize)) {	32!
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)) {	32✔
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
UNCOV 233	return this.customTransactionMapper.mapCustomTransaction(	×
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) {	108!
255	return null;	4✔
256	}
257
258	const orderData: `0x${string}` \| null = this.swapOrderHelper.findSwapOrder(	104✔
259	transaction.data,
260	);
261
262	if (!orderData) {	104✔
263	return null;	104✔
264	}
265
266	try {	×
267	return await this.swapOrderMapper.mapSwapOrder(chainId, {	×
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);	×
273	return null;	×
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) {	108!
290	return null;	4✔
291	}
292
293	const orderData = this.twapOrderHelper.findTwapOrder({	104✔
294	to: transaction.to,
295	data: transaction.data,
296	});
297
298	if (!orderData) {	104✔
299	return null;	104✔
300	}
301
302	try {	×
303	return await this.twapOrderMapper.mapTwapOrder(	×
304	chainId,
305	transaction.safe,
306	{
307	data: orderData,
308	executionDate: transaction.executionDate,
309	},
310	);
311	} catch (error) {
312	this.loggingService.warn(error);	×
313	return null;	×
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) {	×
330	return null;	×
331	}
332
333	const nativeStakingDepositTransaction =
334	await this.kilnNativeStakingHelper.findDepositTransaction({	×
335	chainId,
336	to: transaction.to,
337	data: transaction.data,
338	});
339
340	if (!nativeStakingDepositTransaction) {	×
341	return null;	×
342	}
343
344	try {	×
345	return await this.nativeStakingMapper.mapDepositInfo({	×
346	chainId,
347	to: nativeStakingDepositTransaction.to,
348	value: transaction.value,
349	transaction,
350	});
351	} catch (error) {
352	this.loggingService.warn(error);	×
353	return null;	×
354	}
355	}
356
357	private async mapNativeStakingValidatorsExit(
358	chainId: string,
359	transaction: MultisigTransaction \| ModuleTransaction,
360	): Promise<NativeStakingValidatorsExitTransactionInfo \| null> {
361	if (!transaction?.data) {	×
362	return null;	×
363	}
364
365	const dataDecoded = transaction?.dataDecoded	×
366	? transaction.dataDecoded
367	: this.kilnDecoder.decodeValidatorsExit(transaction.data);
368
369	if (!dataDecoded) {	×
370	return null;	×
371	}
372
373	const nativeStakingValidatorsExitTransaction =
374	await this.kilnNativeStakingHelper.findValidatorsExitTransaction({	×
375	chainId,
376	to: transaction.to,
377	data: transaction.data,
378	});
379
380	if (!nativeStakingValidatorsExitTransaction) {	×
381	return null;	×
382	}
383
384	try {	×
385	return await this.nativeStakingMapper.mapValidatorsExitInfo({	×
386	chainId,
387	safeAddress: transaction.safe,
388	to: nativeStakingValidatorsExitTransaction.to,
389	transaction,
390	dataDecoded,
391	});
392	} catch (error) {
393	this.loggingService.warn(error);	×
394	return null;	×
395	}
396	}
397
398	private async mapNativeStakingWithdraw(
399	chainId: string,
400	transaction: MultisigTransaction \| ModuleTransaction,
401	): Promise<NativeStakingWithdrawTransactionInfo \| null> {
402	if (!transaction?.data) {	×
403	return null;	×
404	}
405
406	const dataDecoded = transaction?.dataDecoded	×
407	? transaction.dataDecoded
408	: this.kilnDecoder.decodeBatchWithdrawCLFee(transaction.data);
409
410	if (!dataDecoded) {	×
411	return null;	×
412	}
413
414	const nativeStakingWithdrawTransaction =
415	await this.kilnNativeStakingHelper.findWithdrawTransaction({	×
416	chainId,
417	to: transaction.to,
418	data: transaction.data,
419	});
420
421	if (!nativeStakingWithdrawTransaction) {	×
422	return null;	×
423	}
424
425	try {	×
426	return await this.nativeStakingMapper.mapWithdrawInfo({	×
427	chainId,
428	safeAddress: transaction.safe,
429	to: nativeStakingWithdrawTransaction.to,
430	transaction,
431	dataDecoded,
432	});
433	} catch (error) {
434	this.loggingService.warn(error);	×
435	return null;	×
436	}
437	}
438
439	private isCustomTransaction(
440	value: number,
441	dataSize: number,
442	operation: Operation,
443	): boolean {
444	return (value > 0 && dataSize > 0) \|\| operation !== Operation.CALL;	108✔
445	}
446
447	private isNativeCoinTransfer(value: number, dataSize: number): boolean {
448	return value > 0 && dataSize === 0;	70✔
449	}
450
451	private isSettingsChange(
452	transaction: MultisigTransaction \| ModuleTransaction,
453	value: number,
454	dataSize: number,
455	): boolean {
456	const isSettingsChangeMethod: boolean = transaction.dataDecoded	32!
457	? SettingsChangeMapper.SETTINGS_CHANGE_METHODS.includes(
458	transaction.dataDecoded.method,
459	)
460	: false;
461
462	return (	32✔
463	value === 0 &&	32!
464	dataSize > 0 &&
465	transaction.safe === transaction.to &&
466	isSettingsChangeMethod
467	);
468	}
469
470	private isValidTokenTransfer(
471	transaction: MultisigTransaction \| ModuleTransaction,
472	): boolean {
473	return (	32✔
474	(this.isErc20Transfer(transaction) \|\|	33✔
475	this.isErc721Transfer(transaction)) &&
476	this.isSafeSenderOrReceiver(transaction)
477	);
478	}
479
480	private isErc20Transfer(
481	transaction: MultisigTransaction \| ModuleTransaction,
482	): boolean {
483	const { dataDecoded } = transaction;	32✔
484	return this.ERC20_TRANSFER_METHODS.some(	32✔
485	(method) => method === dataDecoded?.method,	34!
486	);
487	}
488
489	private isErc721Transfer(
490	transaction: MultisigTransaction \| ModuleTransaction,
491	): boolean {
492	const { dataDecoded } = transaction;	2✔
493	return this.ERC721_TRANSFER_METHODS.some(	2✔
494	(method) => method === dataDecoded?.method,	6!
495	);
496	}
497
498	private isSafeSenderOrReceiver(
499	transaction: MultisigTransaction \| ModuleTransaction,
500	): boolean {
501	const { dataDecoded } = transaction;	32✔
502	if (!dataDecoded) return false;	32!
503	return (	32✔
504	this.TRANSFER_METHOD == dataDecoded.method \|\|	17!
505	this.dataDecodedParamHelper.getFromParam(dataDecoded, '') ===
506	transaction.safe \|\|
507	this.dataDecodedParamHelper.getToParam(dataDecoded, '') ===
508	transaction.safe
509	);
510	}
511	}

safe-global / safe-client-gateway / 11051168053

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