11516512574

Committed 25 Oct 2024 10:28AM UTC coverage: 88.975% (+0.05%) from 88.929%

Build # 11516512574

Build Type

Pull #2061

github

Committed by

iamacook

Commit Message

Remove feature flag for rich fragments

Pull Request Pull Request #2061: Remove feature flag for rich fragments

Run Details

2595 of 3271 branches covered (79.33%)

Branch coverage included in aggregate %.

16 of 16 new or added lines in 8 files covered. (100.0%)

27 existing lines in 4 files now uncovered.

8873 of 9618 relevant lines covered (92.25%)

398.17 hits per line

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

87.37

/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 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.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);

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

    if (this.isNativeCoinTransfer(value, dataSize)) {
      return this.nativeCoinTransferMapper.mapNativeCoinTransfer(
        chainId,
        transaction,
        humanDescription,
        richDecodedInfo,
      );
    }

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

    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,
            richDecodedInfo,
          );
        case TokenType.Erc721:
          return this.erc721TransferMapper.mapErc721Transfer(
            token,
            chainId,
            transaction,
            humanDescription,
            richDecodedInfo,
          );
      }
    }

    return this.customTransactionMapper.mapCustomTransaction(
      transaction,
      dataSize,
      chainId,
      humanDescription,
      richDecodedInfo,
    );
  }

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

safe-global / safe-client-gateway / 11516512574

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