8390537987

Committed 22 Mar 2024 12:45PM UTC coverage: 93.255% (-0.07%) from 93.322%

Build # 8390537987

Build Type

Pull #1338

github

Committed by

fmrsabino

Commit Message

PR comments

Pull Request Pull Request #1338: Add filledPercentage to SwapOrderTransactionInfo

Run Details

1827 of 2206 branches covered (82.82%)

Branch coverage included in aggregate %.

9 of 10 new or added lines in 2 files covered. (90.0%)

2 existing lines in 2 files now uncovered.

6441 of 6660 relevant lines covered (96.71%)

358.51 hits per line

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

78.98

/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 '@/routes/balances/entities/token-type.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 { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';
import { SwapOrderMapper } from '@/routes/transactions/mappers/common/swap-order.mapper';

@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 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,
    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 setPreSignatureDecoder: SetPreSignatureDecoder,
    private readonly swapOrderMapper: SwapOrderMapper,
  ) {
    this.isRichFragmentsEnabled = this.configurationService.getOrThrow(
      'features.richFragments',
    );
    this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(
      'features.swapsDecoding',
    );
  }

  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 && this.isCoWSwapOrder(transaction)) {
      return await this.swapOrderMapper.mapSwapOrder(
        chainId,
        transaction,
        dataSize,
      );
    }

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

  private isCoWSwapOrder(
    transaction: MultisigTransaction | ModuleTransaction,
  ): boolean {
    if (!transaction.data) return false;
    return this.setPreSignatureDecoder.isSetPreSignature(transaction.data);
  }

  private isCustomTransaction(
    value: number,
    dataSize: number,
    operation: Operation,
  ): boolean {
    return (value > 0 && dataSize > 0) || operation !== 0;
  }

  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';	96✔
2	import { IConfigurationService } from '@/config/configuration.service.interface';	96✔
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';
6	import { TokenRepository } from '@/domain/tokens/token.repository';	96✔
7	import { ITokenRepository } from '@/domain/tokens/token.repository.interface';	96✔
8	import { TokenType } from '@/routes/balances/entities/token-type.entity';	96✔
9	import { DataDecodedParameter } from '@/routes/data-decode/entities/data-decoded-parameter.entity';	96✔
10	import { DataDecoded } from '@/routes/data-decode/entities/data-decoded.entity';	96✔
11	import { SettingsChangeTransaction } from '@/routes/transactions/entities/settings-change-transaction.entity';	96✔
12	import { TransactionInfo } from '@/routes/transactions/entities/transaction-info.entity';
13	import { CustomTransactionMapper } from '@/routes/transactions/mappers/common/custom-transaction.mapper';	96✔
14	import { DataDecodedParamHelper } from '@/routes/transactions/mappers/common/data-decoded-param.helper';	96✔
15	import { Erc20TransferMapper } from '@/routes/transactions/mappers/common/erc20-transfer.mapper';	96✔
16	import { Erc721TransferMapper } from '@/routes/transactions/mappers/common/erc721-transfer.mapper';	96✔
17	import { HumanDescriptionMapper } from '@/routes/transactions/mappers/common/human-description.mapper';	96✔
18	import { NativeCoinTransferMapper } from '@/routes/transactions/mappers/common/native-coin-transfer.mapper';	96✔
19	import { SettingsChangeMapper } from '@/routes/transactions/mappers/common/settings-change.mapper';	96✔
20	import { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';	96✔
21	import { SwapOrderMapper } from '@/routes/transactions/mappers/common/swap-order.mapper';	96✔
22
23	@Injectable()
24	export class MultisigTransactionInfoMapper {	96✔
25	private readonly TRANSFER_METHOD = 'transfer';	1,188✔
26	private readonly TRANSFER_FROM_METHOD = 'transferFrom';	1,188✔
27	private readonly SAFE_TRANSFER_FROM_METHOD = 'safeTransferFrom';	1,188✔
28	private readonly isRichFragmentsEnabled: boolean;
29	private readonly isSwapsDecodingEnabled: boolean;
30
31	private readonly ERC20_TRANSFER_METHODS = [	1,188✔
32	this.TRANSFER_METHOD,
33	this.TRANSFER_FROM_METHOD,
34	];
35
36	private readonly ERC721_TRANSFER_METHODS = [	1,188✔
37	this.TRANSFER_METHOD,
38	this.TRANSFER_FROM_METHOD,
39	this.SAFE_TRANSFER_FROM_METHOD,
40	];
41
42	constructor(
43	@Inject(ITokenRepository) private readonly tokenRepository: TokenRepository,	1,188✔
44	@Inject(IConfigurationService)
45	private readonly configurationService: IConfigurationService,	1,188✔
46	private readonly dataDecodedParamHelper: DataDecodedParamHelper,	1,188✔
47	private readonly customTransactionMapper: CustomTransactionMapper,	1,188✔
48	private readonly settingsChangeMapper: SettingsChangeMapper,	1,188✔
49	private readonly nativeCoinTransferMapper: NativeCoinTransferMapper,	1,188✔
50	private readonly erc20TransferMapper: Erc20TransferMapper,	1,188✔
51	private readonly erc721TransferMapper: Erc721TransferMapper,	1,188✔
52	private readonly humanDescriptionMapper: HumanDescriptionMapper,	1,188✔
53	private readonly setPreSignatureDecoder: SetPreSignatureDecoder,	1,188✔
54	private readonly swapOrderMapper: SwapOrderMapper,	1,188✔
55	) {
56	this.isRichFragmentsEnabled = this.configurationService.getOrThrow(	1,188✔
57	'features.richFragments',
58	);
59	this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(	1,188✔
60	'features.swapsDecoding',
61	);
62	}
63
64	async mapTransactionInfo(
65	chainId: string,
66	transaction: MultisigTransaction \| ModuleTransaction,
67	): Promise<TransactionInfo> {
68	const value = Number(transaction?.value) \|\| 0;	78✔
69	const dataByteLength = transaction.data	78✔
70	? Buffer.byteLength(transaction.data)
71	: 0;
72
73	const dataSize =
74	dataByteLength >= 2 ? Math.floor((dataByteLength - 2) / 2) : 0;	78✔
75
76	const richDecodedInfo =
77	await this.humanDescriptionMapper.mapRichDecodedInfo(	78✔
78	transaction,
79	chainId,
80	);
81
82	const humanDescription =
83	this.humanDescriptionMapper.mapHumanDescription(richDecodedInfo);	78✔
84
85	// If the rich fragment feature is disabled, we set it as undefined.
86	// Undefined properties are not rendered on the response
87	const richDecodedInfoApiProperty = this.isRichFragmentsEnabled	78!
88	? richDecodedInfo
89	: undefined;
90
91	if (this.isSwapsDecodingEnabled && this.isCoWSwapOrder(transaction)) {	78!
92	return await this.swapOrderMapper.mapSwapOrder(	×
93	chainId,
94	transaction,
95	dataSize,
96	);
97	}
98
99	if (this.isCustomTransaction(value, dataSize, transaction.operation)) {	78✔
100	return await this.customTransactionMapper.mapCustomTransaction(	42✔
101	transaction,
102	dataSize,
103	chainId,
104	humanDescription,
105	richDecodedInfoApiProperty,
106	);
107	}
108
109	if (this.isNativeCoinTransfer(value, dataSize)) {	36✔
110	return this.nativeCoinTransferMapper.mapNativeCoinTransfer(	30✔
111	chainId,
112	transaction,
113	humanDescription,
114	richDecodedInfoApiProperty,
115	);
116	}
117
118	if (this.isSettingsChange(transaction, value, dataSize)) {	6!
119	const settingsInfo = await this.settingsChangeMapper.mapSettingsChange(	×
120	chainId,
121	transaction,
122	);
123
124	if (!transaction.dataDecoded) {	×
125	throw new Error(	×
126	`Data decoded is null. txHash=${transaction.transactionHash}`,
127	);
128	}
129
130	const dataDecodedParameters: DataDecodedParameter[] \| null =
131	transaction.dataDecoded.parameters?.map(	×
132	(parameter) =>
133	new DataDecodedParameter(	×
134	parameter.name,
135	parameter.type,
136	parameter.value,
137	parameter.valueDecoded,
138	),
139	) ?? null;
140
141	return new SettingsChangeTransaction(	×
142	new DataDecoded(transaction.dataDecoded.method, dataDecodedParameters),
143	settingsInfo,
144	humanDescription,
145	richDecodedInfoApiProperty,
146	);
147	}
148
149	if (this.isValidTokenTransfer(transaction)) {	6✔
150	const token = await this.tokenRepository	6✔
151	.getToken({ chainId, address: transaction.to })
152	.catch(() => null);	×
153
154	switch (token?.type) {	6!
155	case TokenType.Erc20:
156	return this.erc20TransferMapper.mapErc20Transfer(	4✔
157	token,
158	chainId,
159	transaction,
160	humanDescription,
161	richDecodedInfoApiProperty,
162	);
163	case TokenType.Erc721:
164	return this.erc721TransferMapper.mapErc721Transfer(	2✔
165	token,
166	chainId,
167	transaction,
168	humanDescription,
169	richDecodedInfoApiProperty,
170	);
171	}
172	}
173
UNCOV 174	return this.customTransactionMapper.mapCustomTransaction(	×
175	transaction,
176	dataSize,
177	chainId,
178	humanDescription,
179	richDecodedInfoApiProperty,
180	);
181	}
182
183	private isCoWSwapOrder(
184	transaction: MultisigTransaction \| ModuleTransaction,
185	): boolean {
186	if (!transaction.data) return false;	78✔
187	return this.setPreSignatureDecoder.isSetPreSignature(transaction.data);	74✔
188	}
189
190	private isCustomTransaction(
191	value: number,
192	dataSize: number,
193	operation: Operation,
194	): boolean {
195	return (value > 0 && dataSize > 0) \|\| operation !== 0;	78✔
196	}
197
198	private isNativeCoinTransfer(value: number, dataSize: number): boolean {
199	return value > 0 && dataSize === 0;	36✔
200	}
201
202	private isSettingsChange(
203	transaction: MultisigTransaction \| ModuleTransaction,
204	value: number,
205	dataSize: number,
206	): boolean {
207	const isSettingsChangeMethod: boolean = transaction.dataDecoded	6!
208	? SettingsChangeMapper.SETTINGS_CHANGE_METHODS.includes(
209	transaction.dataDecoded.method,
210	)
211	: false;
212
213	return (	6✔
214	value === 0 &&	6!
215	dataSize > 0 &&
216	transaction.safe === transaction.to &&
217	isSettingsChangeMethod
218	);
219	}
220
221	private isValidTokenTransfer(
222	transaction: MultisigTransaction \| ModuleTransaction,
223	): boolean {
224	return (	6✔
225	(this.isErc20Transfer(transaction) \|\|	7✔
226	this.isErc721Transfer(transaction)) &&
227	this.isSafeSenderOrReceiver(transaction)
228	);
229	}
230
231	private isErc20Transfer(
232	transaction: MultisigTransaction \| ModuleTransaction,
233	): boolean {
234	const { dataDecoded } = transaction;	6✔
235	return this.ERC20_TRANSFER_METHODS.some(	6✔
236	(method) => method === dataDecoded?.method,	8!
237	);
238	}
239
240	private isErc721Transfer(
241	transaction: MultisigTransaction \| ModuleTransaction,
242	): boolean {
243	const { dataDecoded } = transaction;	2✔
244	return this.ERC721_TRANSFER_METHODS.some(	2✔
245	(method) => method === dataDecoded?.method,	6!
246	);
247	}
248
249	private isSafeSenderOrReceiver(
250	transaction: MultisigTransaction \| ModuleTransaction,
251	): boolean {
252	const { dataDecoded } = transaction;	6✔
253	if (!dataDecoded) return false;	6!
254	return (	6✔
255	this.TRANSFER_METHOD == dataDecoded.method \|\|	4!
256	this.dataDecodedParamHelper.getFromParam(dataDecoded, '') ===
257	transaction.safe \|\|
258	this.dataDecodedParamHelper.getToParam(dataDecoded, '') ===
259	transaction.safe
260	);
261	}
262	}

safe-global / safe-client-gateway / 8390537987

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