6338398204

Committed 28 Sep 2023 11:43AM UTC coverage: 91.085% (-0.08%) from 91.169%

Build # 6338398204

Build Type

push

github

Committed by

web-flow

Commit Message

Log Safe-App-User-Agent header (#714)

- Adds support to log the value of the header `Safe-App-User-Agent`.
- This header can be used for analytics regarding the source of the request.
- Considerations regarding where the header should be set and by whom are not specified, and we leave that recommendation for the users running this service.

Run Details

1206 of 1449 branches covered (0.0%)

Branch coverage included in aggregate %.

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

3 existing lines in 2 files now uncovered.

4597 of 4922 relevant lines covered (93.4%)

148.61 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(	40✔
81	transaction,
82	dataSize,
83	chainId,
84	humanDescription,
85	richDecodedInfo,
86	);
87	}
88
89	if (this.isNativeCoinTransfer(value, dataSize)) {	38✔
90	return this.nativeCoinTransferMapper.mapNativeCoinTransfer(	32✔
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;	38✔
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 / 6338398204

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