9660619570

Committed 25 Jun 2024 10:15AM UTC coverage: 49.271% (+0.6%) from 48.707%

Build # 9660619570

Build Type

Pull #1689

github

Committed by

hectorgomezv

Commit Message

Fix bad jwtConfiguration import

Pull Request Pull Request #1689: Implement POST /v1/accounts

Run Details

415 of 2460 branches covered (16.87%)

Branch coverage included in aggregate %.

35 of 53 new or added lines in 9 files covered. (66.04%)

163 existing lines in 10 files now uncovered.

4112 of 6728 relevant lines covered (61.12%)

12.74 hits per line

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

21.13

/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 { isHex } from 'viem';
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';

@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 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,
  ) {
    this.isRichFragmentsEnabled = this.configurationService.getOrThrow(
      'features.richFragments',
    );
    this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(
      'features.swapsDecoding',
    );
    this.isTwapsDecodingEnabled = this.configurationService.getOrThrow(
      'features.twapsDecoding',
    );
  }

  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.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 || !isHex(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 || !transaction?.executionDate) {
      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;
    }
  }

  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 { isHex } from 'viem';	16✔
22	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
23	import { SwapOrderTransactionInfo } from '@/routes/transactions/entities/swaps/swap-order-info.entity';
24	import { SwapOrderHelper } from '@/routes/transactions/helpers/swap-order.helper';	16✔
25	import { TwapOrderMapper } from '@/routes/transactions/mappers/common/twap-order.mapper';	16✔
26	import { TwapOrderHelper } from '@/routes/transactions/helpers/twap-order.helper';	16✔
27	import { TwapOrderTransactionInfo } from '@/routes/transactions/entities/swaps/twap-order-info.entity';
28
29	@Injectable()
30	export class MultisigTransactionInfoMapper {	16✔
31	private readonly TRANSFER_METHOD = 'transfer';	16✔
32	private readonly TRANSFER_FROM_METHOD = 'transferFrom';	16✔
33	private readonly SAFE_TRANSFER_FROM_METHOD = 'safeTransferFrom';	16✔
34	private readonly isRichFragmentsEnabled: boolean;
35	private readonly isSwapsDecodingEnabled: boolean;
36	private readonly isTwapsDecodingEnabled: boolean;
37
38	private readonly ERC20_TRANSFER_METHODS = [	16✔
39	this.TRANSFER_METHOD,
40	this.TRANSFER_FROM_METHOD,
41	];
42
43	private readonly ERC721_TRANSFER_METHODS = [	16✔
44	this.TRANSFER_METHOD,
45	this.TRANSFER_FROM_METHOD,
46	this.SAFE_TRANSFER_FROM_METHOD,
47	];
48
49	constructor(
50	@Inject(ITokenRepository) private readonly tokenRepository: TokenRepository,	16✔
51	@Inject(IConfigurationService)
52	private readonly configurationService: IConfigurationService,	16✔
53	@Inject(LoggingService) private readonly loggingService: ILoggingService,	16✔
54	private readonly dataDecodedParamHelper: DataDecodedParamHelper,	16✔
55	private readonly customTransactionMapper: CustomTransactionMapper,	16✔
56	private readonly settingsChangeMapper: SettingsChangeMapper,	16✔
57	private readonly nativeCoinTransferMapper: NativeCoinTransferMapper,	16✔
58	private readonly erc20TransferMapper: Erc20TransferMapper,	16✔
59	private readonly erc721TransferMapper: Erc721TransferMapper,	16✔
60	private readonly humanDescriptionMapper: HumanDescriptionMapper,	16✔
61	private readonly swapOrderMapper: SwapOrderMapper,	16✔
62	private readonly swapOrderHelper: SwapOrderHelper,	16✔
63	private readonly twapOrderMapper: TwapOrderMapper,	16✔
64	private readonly twapOrderHelper: TwapOrderHelper,	16✔
65	) {
66	this.isRichFragmentsEnabled = this.configurationService.getOrThrow(	16✔
67	'features.richFragments',
68	);
69	this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(	16✔
70	'features.swapsDecoding',
71	);
72	this.isTwapsDecodingEnabled = this.configurationService.getOrThrow(	16✔
73	'features.twapsDecoding',
74	);
75	}
76
77	async mapTransactionInfo(
78	chainId: string,
79	transaction: MultisigTransaction \| ModuleTransaction,
80	): Promise<TransactionInfo> {
81	const value = Number(transaction?.value) \|\| 0;	×
UNCOV 82	const dataByteLength = transaction.data	×
83	? Buffer.byteLength(transaction.data)
84	: 0;
85
86	const dataSize =
UNCOV 87	dataByteLength >= 2 ? Math.floor((dataByteLength - 2) / 2) : 0;	×
88
89	const richDecodedInfo =
UNCOV 90	await this.humanDescriptionMapper.mapRichDecodedInfo(	×
91	transaction,
92	chainId,
93	);
94
95	const humanDescription =
UNCOV 96	this.humanDescriptionMapper.mapHumanDescription(richDecodedInfo);	×
97
98	// If the rich fragment feature is disabled, we set it as undefined.
99	// Undefined properties are not rendered on the response
UNCOV 100	const richDecodedInfoApiProperty = this.isRichFragmentsEnabled	×
101	? richDecodedInfo
102	: undefined;
103
UNCOV 104	if (this.isSwapsDecodingEnabled) {	×
105	const swapOrder: SwapOrderTransactionInfo \| null =
UNCOV 106	await this.mapSwapOrder(chainId, transaction);	×
107	// If the transaction is a swap order, we return it immediately
UNCOV 108	if (swapOrder) return swapOrder;	×
109	}
110
UNCOV 111	if (this.isTwapsDecodingEnabled) {	×
112	// If the transaction is a TWAP order, we return it immediately
113	const twapOrder = await this.mapTwapOrder(chainId, transaction);	×
114	if (twapOrder) {	×
UNCOV 115	return twapOrder;	×
116	}
117	}
118
119	if (this.isCustomTransaction(value, dataSize, transaction.operation)) {	×
120	return await this.customTransactionMapper.mapCustomTransaction(	×
121	transaction,
122	dataSize,
123	chainId,
124	humanDescription,
125	richDecodedInfoApiProperty,
126	);
127	}
128
UNCOV 129	if (this.isNativeCoinTransfer(value, dataSize)) {	×
UNCOV 130	return this.nativeCoinTransferMapper.mapNativeCoinTransfer(	×
131	chainId,
132	transaction,
133	humanDescription,
134	richDecodedInfoApiProperty,
135	);
136	}
137
UNCOV 138	if (this.isSettingsChange(transaction, value, dataSize)) {	×
UNCOV 139	const settingsInfo = await this.settingsChangeMapper.mapSettingsChange(	×
140	chainId,
141	transaction,
142	);
143
144	if (!transaction.dataDecoded) {	×
UNCOV 145	throw new Error(	×
146	`Data decoded is null. txHash=${transaction.transactionHash}`,
147	);
148	}
149
150	const dataDecodedParameters: DataDecodedParameter[] \| null =
UNCOV 151	transaction.dataDecoded.parameters?.map(	×
152	(parameter) =>
UNCOV 153	new DataDecodedParameter(	×
154	parameter.name,
155	parameter.type,
156	parameter.value,
157	parameter.valueDecoded,
158	),
159	) ?? null;
160
UNCOV 161	return new SettingsChangeTransaction(	×
162	new DataDecoded(transaction.dataDecoded.method, dataDecodedParameters),
163	settingsInfo,
164	humanDescription,
165	richDecodedInfoApiProperty,
166	);
167	}
168
UNCOV 169	if (this.isValidTokenTransfer(transaction)) {	×
UNCOV 170	const token = await this.tokenRepository	×
171	.getToken({ chainId, address: transaction.to })
UNCOV 172	.catch(() => null);	×
173
174	switch (token?.type) {	×
175	case TokenType.Erc20:
UNCOV 176	return this.erc20TransferMapper.mapErc20Transfer(	×
177	token,
178	chainId,
179	transaction,
180	humanDescription,
181	richDecodedInfoApiProperty,
182	);
183	case TokenType.Erc721:
UNCOV 184	return this.erc721TransferMapper.mapErc721Transfer(	×
185	token,
186	chainId,
187	transaction,
188	humanDescription,
189	richDecodedInfoApiProperty,
190	);
191	}
192	}
193
UNCOV 194	return this.customTransactionMapper.mapCustomTransaction(	×
195	transaction,
196	dataSize,
197	chainId,
198	humanDescription,
199	richDecodedInfoApiProperty,
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> {
UNCOV 215	if (!transaction?.data \|\| !isHex(transaction.data)) {	×
UNCOV 216	return null;	×
217	}
218
UNCOV 219	const orderData: `0x${string}` \| null = this.swapOrderHelper.findSwapOrder(	×
220	transaction.data,
221	);
222
223	if (!orderData) {	×
UNCOV 224	return null;	×
225	}
226
UNCOV 227	try {	×
UNCOV 228	return await this.swapOrderMapper.mapSwapOrder(chainId, {	×
229	data: orderData,
230	});
231	} catch (error) {
232	// The transaction is a swap order, but we couldn't decode it successfully.
UNCOV 233	this.loggingService.warn(error);	×
234	return null;	×
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> {
UNCOV 250	if (!transaction?.data \|\| !transaction?.executionDate) {	×
UNCOV 251	return null;	×
252	}
253
UNCOV 254	const orderData = this.twapOrderHelper.findTwapOrder({	×
255	to: transaction.to,
256	data: transaction.data,
257	});
258
UNCOV 259	if (!orderData) {	×
UNCOV 260	return null;	×
261	}
262
UNCOV 263	try {	×
UNCOV 264	return await this.twapOrderMapper.mapTwapOrder(	×
265	chainId,
266	transaction.safe,
267	{
268	data: orderData,
269	executionDate: transaction.executionDate,
270	},
271	);
272	} catch (error) {
UNCOV 273	this.loggingService.warn(error);	×
UNCOV 274	return null;	×
275	}
276	}
277
278	private isCustomTransaction(
279	value: number,
280	dataSize: number,
281	operation: Operation,
282	): boolean {
UNCOV 283	return (value > 0 && dataSize > 0) \|\| operation !== Operation.CALL;	×
284	}
285
286	private isNativeCoinTransfer(value: number, dataSize: number): boolean {
UNCOV 287	return value > 0 && dataSize === 0;	×
288	}
289
290	private isSettingsChange(
291	transaction: MultisigTransaction \| ModuleTransaction,
292	value: number,
293	dataSize: number,
294	): boolean {
295	const isSettingsChangeMethod: boolean = transaction.dataDecoded	×
296	? SettingsChangeMapper.SETTINGS_CHANGE_METHODS.includes(
297	transaction.dataDecoded.method,
298	)
299	: false;
300
UNCOV 301	return (	×
302	value === 0 &&	×
303	dataSize > 0 &&
304	transaction.safe === transaction.to &&
305	isSettingsChangeMethod
306	);
307	}
308
309	private isValidTokenTransfer(
310	transaction: MultisigTransaction \| ModuleTransaction,
311	): boolean {
UNCOV 312	return (	×
313	(this.isErc20Transfer(transaction) \|\|	×
314	this.isErc721Transfer(transaction)) &&
315	this.isSafeSenderOrReceiver(transaction)
316	);
317	}
318
319	private isErc20Transfer(
320	transaction: MultisigTransaction \| ModuleTransaction,
321	): boolean {
322	const { dataDecoded } = transaction;	×
UNCOV 323	return this.ERC20_TRANSFER_METHODS.some(	×
UNCOV 324	(method) => method === dataDecoded?.method,	×
325	);
326	}
327
328	private isErc721Transfer(
329	transaction: MultisigTransaction \| ModuleTransaction,
330	): boolean {
UNCOV 331	const { dataDecoded } = transaction;	×
UNCOV 332	return this.ERC721_TRANSFER_METHODS.some(	×
UNCOV 333	(method) => method === dataDecoded?.method,	×
334	);
335	}
336
337	private isSafeSenderOrReceiver(
338	transaction: MultisigTransaction \| ModuleTransaction,
339	): boolean {
UNCOV 340	const { dataDecoded } = transaction;	×
UNCOV 341	if (!dataDecoded) return false;	×
UNCOV 342	return (	×
343	this.TRANSFER_METHOD == dataDecoded.method \|\|	×
344	this.dataDecodedParamHelper.getFromParam(dataDecoded, '') ===
345	transaction.safe \|\|
346	this.dataDecodedParamHelper.getToParam(dataDecoded, '') ===
347	transaction.safe
348	);
349	}
350	}

safe-global / safe-client-gateway / 9660619570

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