6160520025

Committed 12 Sep 2023 02:01PM UTC coverage: 91.091% (-0.09%) from 91.185%

Build # 6160520025

Build Type

push

github

Committed by fmrsabino

Commit Message

Remove @openzeppelin/contracts dependency

Run Details

1201 of 1444 branches covered (0.0%)

Branch coverage included in aggregate %.

5 of 5 new or added lines in 1 file covered. (100.0%)

2 existing lines in 2 files now uncovered.

4596 of 4920 relevant lines covered (93.41%)

148.46 hits per line

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

77.78

/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 '../../../balances/entities/token-type.entity';
import { SettingsChangeTransaction } from '../../entities/settings-change-transaction.entity';
import { TransactionInfo } from '../../entities/transaction-info.entity';
import { CustomTransactionMapper } from './custom-transaction.mapper';
import { DataDecodedParamHelper } from './data-decoded-param.helper';
import { Erc20TransferMapper } from './erc20-transfer.mapper';
import { Erc721TransferMapper } from './erc721-transfer.mapper';
import { NativeCoinTransferMapper } from './native-coin-transfer.mapper';
import { SettingsChangeMapper } from './settings-change.mapper';
import { DataDecoded } from '../../../data-decode/entities/data-decoded.entity';
import { DataDecodedParameter } from '../../../data-decode/entities/data-decoded-parameter.entity';
import { HumanDescriptionMapper } from './human-description.mapper';
import { IConfigurationService } from '@/config/configuration.service.interface';

@Injectable()
export class MultisigTransactionInfoMapper {
  private readonly TRANSFER_METHOD = 'transfer';
  private readonly TRANSFER_FROM_METHOD = 'transferFrom';
  private readonly SAFE_TRANSFER_FROM_METHOD = 'safeTransferFrom';
  private readonly isHumanDescriptionEnabled: 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,
  ) {
    this.isHumanDescriptionEnabled = this.configurationService.getOrThrow(
      'features.humanDescription',
    );
  }

  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 = this.isHumanDescriptionEnabled
      ? await this.humanDescriptionMapper.mapRichDecodedInfo(
          transaction,
          chainId,
        )
      : null;

    const humanDescription = this.isHumanDescriptionEnabled
      ? this.humanDescriptionMapper.mapHumanDescription(richDecodedInfo)
      : null;

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

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

safe-global / safe-client-gateway / 6160520025

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