10685222397

Committed 03 Sep 2024 02:42PM UTC coverage: 45.992% (-0.3%) from 46.336%

Build # 10685222397

Build Type

Pull #1882

github

Committed by

web-flow

Commit Message

Merge 6e5fea07e into 474b5df96

Pull Request Pull Request #1882: Add Native Staking Withdraw transaction mappings

Run Details

499 of 3160 branches covered (15.79%)

Branch coverage included in aggregate %.

25 of 79 new or added lines in 11 files covered. (31.65%)

1 existing line in 1 file now uncovered.

4837 of 8442 relevant lines covered (57.3%)

12.16 hits per line

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

17.31

/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';

@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;
      }

      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.findDeposit({
        chainId,
        to: transaction.to,
        data: transaction.data,
      });

    if (!nativeStakingDepositTransaction) {
      return null;
    }

    try {
      const isConfirmed =
        'confirmations' in transaction &&
        !!transaction.confirmations &&
        transaction.confirmations.length >= transaction.confirmationsRequired;

      return await this.nativeStakingMapper.mapDepositInfo({
        chainId,
        to: nativeStakingDepositTransaction.to,
        value: transaction.value,
        isConfirmed,
        depositExecutionDate: transaction.executionDate,
      });
    } 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 nativeStakingValidatorsExitTransaction =
      await this.kilnNativeStakingHelper.findValidatorsExit({
        chainId,
        to: transaction.to,
        data: transaction.data,
      });

    if (!nativeStakingValidatorsExitTransaction) {
      return null;
    }

    try {
      return await this.nativeStakingMapper.mapValidatorsExitInfo({
        chainId,
        to: nativeStakingValidatorsExitTransaction.to,
        value: transaction.value,
        transaction,
      });
    } 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 nativeStakingWithdrawTransaction =
      await this.kilnNativeStakingHelper.findWithdraw({
        chainId,
        to: transaction.to,
        data: transaction.data,
      });

    if (!nativeStakingWithdrawTransaction) {
      return null;
    }

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

safe-global / safe-client-gateway / 10685222397

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