5875772533

Canceled at 27 May 2024 03:47AM UTC via web

Build Type

push

github

Committed by GitHub

Commit Message

feat: add notification device unregistration route (#636)

Run Details

928 of 1107 branches covered (83.83%)

Branch coverage included in aggregate %.

11 of 11 new or added lines in 4 files covered. (100.0%)

1 existing line in 1 file now uncovered.

4372 of 4625 relevant lines covered (94.53%)

70.38 hits per line

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

76.72

/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';

@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,
    private readonly dataDecodedParamHelper: DataDecodedParamHelper,
    private readonly customTransactionMapper: CustomTransactionMapper,
    private readonly settingsChangeMapper: SettingsChangeMapper,
    private readonly nativeCoinTransferMapper: NativeCoinTransferMapper,
    private readonly erc20TransferMapper: Erc20TransferMapper,
    private readonly erc721TransferMapper: Erc721TransferMapper,
  ) {}

  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;

    if (this.isCustomTransaction(value, dataSize, transaction.operation)) {
      return await this.customTransactionMapper.mapCustomTransaction(
        transaction,
        dataSize,
        chainId,
      );
    }

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

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

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

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

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

safe-global / safe-client-gateway-nest / 5875772533

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