11957887529

Committed 21 Nov 2024 04:51PM UTC coverage: 89.474% (-0.02%) from 89.494%

Build # 11957887529

Build Type

Pull #2148

github

Committed by

hectorgomezv

Commit Message

Merge branch 'main' into delete-address-book-items

Pull Request Pull Request #2148: Delete address book items

Run Details

2756 of 3428 branches covered (80.4%)

Branch coverage included in aggregate %.

19 of 19 new or added lines in 3 files covered. (100.0%)

1 existing line in 1 file now uncovered.

9383 of 10139 relevant lines covered (92.54%)

426.17 hits per line

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

87.41

/src/routes/transactions/mappers/common/transaction-info.mapper.ts

import { Inject, Injectable } from '@nestjs/common';
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 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(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,
  ) {}

  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 humanDescription =
      await this.humanDescriptionMapper.mapHumanDescription(
        transaction,
        chainId,
      );

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

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

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

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

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

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

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

safe-global / safe-client-gateway / 11957887529

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