8284406372

Committed 14 Mar 2024 04:40PM UTC coverage: 93.618% (-0.01%) from 93.631%

Build # 8284406372

Build Type

Pull #1290

github

Committed by

iamacook

Commit Message

Merge branch 'main' into zod-preview-transaction-dto-validation

Pull Request Pull Request #1290: Migrate `PreviewTransactionDto` to `zod`

Run Details

1838 of 2198 branches covered (83.62%)

Branch coverage included in aggregate %.

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

1 existing line in 1 file now uncovered.

6479 of 6686 relevant lines covered (96.9%)

368.81 hits per line

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

90.91

/src/routes/transactions/mappers/common/transaction-data.mapper.ts

import { Inject, Injectable } from '@nestjs/common';
import { isEmpty } from 'lodash';
import { ContractsRepository } from '@/domain/contracts/contracts.repository';
import { IContractsRepository } from '@/domain/contracts/contracts.repository.interface';
import { Operation } from '@/domain/safe/entities/operation.entity';
import { Contract } from '@/domain/contracts/entities/contract.entity';
import { DataDecoded } from '@/domain/data-decoder/entities/data-decoded.entity';
import { AddressInfoHelper } from '@/routes/common/address-info/address-info.helper';
import { NULL_ADDRESS } from '@/routes/common/constants';
import {
  MULTI_SEND_METHOD_NAME,
  TRANSACTIONS_PARAMETER_NAME,
  ADDRESS_PARAMETER_TYPE,
} from '@/routes/transactions/constants';
import { PreviewTransactionDto } from '@/routes/transactions/entities/preview-transaction.dto.entity';
import { TransactionData } from '@/routes/transactions/entities/transaction-data.entity';
import { DataDecodedParamHelper } from '@/routes/transactions/mappers/common/data-decoded-param.helper';
import { AddressInfo } from '@/routes/common/entities/address-info.entity';

@Injectable()
export class TransactionDataMapper {
  constructor(
    private readonly addressInfoHelper: AddressInfoHelper,
    @Inject(IContractsRepository)
    private readonly contractRepository: ContractsRepository,
    private readonly dataDecodedParamHelper: DataDecodedParamHelper,
  ) {}

  async mapTransactionData(
    chainId: string,
    previewTransactionDto: PreviewTransactionDto,
    dataDecoded: DataDecoded | null,
  ): Promise<TransactionData> {
    const toAddress = await this.addressInfoHelper.getOrDefault(
      chainId,
      previewTransactionDto.to,
      ['CONTRACT'],
    );
    const isTrustedDelegateCall = await this.isTrustedDelegateCall(
      chainId,
      previewTransactionDto.operation,
      previewTransactionDto.to,
      dataDecoded,
    );
    const addressInfoIndex = await this.buildAddressInfoIndex(
      chainId,
      dataDecoded,
    );

    return new TransactionData(
      previewTransactionDto.data,
      dataDecoded,
      toAddress,
      previewTransactionDto.value,
      previewTransactionDto.operation,
      isTrustedDelegateCall ?? null,
      isEmpty(addressInfoIndex) ? null : addressInfoIndex,
    );
  }

  /**
   * Determines if the transaction is a trusted DELEGATE call.
   * @param chainId chain id
   * @param operation transaction operation
   * @param to transaction target address
   * @param dataDecoded data decoded to check
   * @returns null if the transaction operation is not DELEGATE.
   * If the transaction operation is DELEGATE, and the target {@link Contract}
   * is trusted, and the {@link DataDecoded} received does not contain
   * a nested DELEGATE operation, then true is returned.
   * Otherwise, the function will return false.
   */
  async isTrustedDelegateCall(
    chainId: string,
    operation: Operation,
    to: string,
    dataDecoded: DataDecoded | null,
  ): Promise<boolean | null> {
    if (operation !== Operation.DELEGATE) return null;

    let contract: Contract;
    try {
      contract = await this.contractRepository.getContract({
        chainId,
        contractAddress: to,
      });
    } catch (err) {
      return false;
    }

    const hasNestedDelegate = dataDecoded
      ? this.dataDecodedParamHelper.hasNestedDelegate(dataDecoded)
      : false;

    return contract.trustedForDelegateCall && !hasNestedDelegate;
  }

  /**
   * Builds a {@link Record<string, AddressInfo>} which contains all the addresses
   * extracted from {@link DataDecoded} as keys, and their related {@link AddressInfo}
   * as value.
   * @param chainId - chain id to use
   * @param dataDecoded data decoded to use
   * @returns {@link Record<string, AddressInfo>}
   */
  async buildAddressInfoIndex(
    chainId: string,
    dataDecoded: DataDecoded | null,
  ): Promise<Record<string, AddressInfo>> {
    if (dataDecoded === null || !Array.isArray(dataDecoded.parameters))
      return {};
    const { method, parameters } = dataDecoded;
    const promises: Promise<(AddressInfo | null)[] | AddressInfo | null>[] = [];

    for (const parameter of parameters) {
      if (
        method === MULTI_SEND_METHOD_NAME &&
        parameter.name === TRANSACTIONS_PARAMETER_NAME &&
        parameter.valueDecoded
      ) {
        promises.push(
          this._getFromValueDecoded(chainId, parameter.valueDecoded),
        );
      } else if (parameter.type === ADDRESS_PARAMETER_TYPE) {
        promises.push(this._getIfValid(chainId, parameter.value));
      }
    }

    const addressInfos = (await Promise.all(promises))
      .flat()
      .filter((i): i is AddressInfo => i !== null);

    return Object.fromEntries(addressInfos.map((i) => [i.value, i]));
  }

  /**
   * Gets an array of {@link AddressInfo} for the passed valueDecoded, by iterating
   * through its operations. For each operation, both its 'to' address and the addresses
   * contained in its dataDecoded parameters are collected.
   *
   * Null values are added to the result array for each invalid value encountered.
   * @param chainId - chain id to use
   * @param valueDecoded - valueDecoded to use
   */
  private async _getFromValueDecoded(
    chainId: string,
    valueDecoded: unknown,
  ): Promise<(AddressInfo | null)[]> {
    if (!Array.isArray(valueDecoded)) return [];
    const promises: Promise<AddressInfo | null>[] = [];

    for (const transaction of valueDecoded) {
      promises.push(this._getIfValid(chainId, transaction.to));
      if (transaction?.dataDecoded?.parameters) {
        for (const param of transaction?.dataDecoded?.parameters) {
          if (param.type === ADDRESS_PARAMETER_TYPE) {
            promises.push(this._getIfValid(chainId, param.value));
          }
        }
      }
    }
    return Promise.all(promises);
  }

  /**
   * Gets an {@link AddressInfo} for the passed value, if it is valid.
   * @param chainId - chain id to use
   * @param value - value to use
   */
  private async _getIfValid(
    chainId: string,
    value: unknown,
  ): Promise<AddressInfo | null> {
    if (typeof value === 'string' && value !== NULL_ADDRESS) {
      const addressInfo = await this.addressInfoHelper
        .get(chainId, value, ['TOKEN', 'CONTRACT'])
        .catch(() => null);
      return addressInfo?.name ? addressInfo : null;
    }
    return null;
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	98✔
2	import { isEmpty } from 'lodash';	98✔
3	import { ContractsRepository } from '@/domain/contracts/contracts.repository';	98✔
4	import { IContractsRepository } from '@/domain/contracts/contracts.repository.interface';	98✔
5	import { Operation } from '@/domain/safe/entities/operation.entity';	98✔
6	import { Contract } from '@/domain/contracts/entities/contract.entity';
7	import { DataDecoded } from '@/domain/data-decoder/entities/data-decoded.entity';
8	import { AddressInfoHelper } from '@/routes/common/address-info/address-info.helper';	98✔
9	import { NULL_ADDRESS } from '@/routes/common/constants';	98✔
10	import {	98✔
11	MULTI_SEND_METHOD_NAME,
12	TRANSACTIONS_PARAMETER_NAME,
13	ADDRESS_PARAMETER_TYPE,
14	} from '@/routes/transactions/constants';
15	import { PreviewTransactionDto } from '@/routes/transactions/entities/preview-transaction.dto.entity';
16	import { TransactionData } from '@/routes/transactions/entities/transaction-data.entity';	98✔
17	import { DataDecodedParamHelper } from '@/routes/transactions/mappers/common/data-decoded-param.helper';	98✔
18	import { AddressInfo } from '@/routes/common/entities/address-info.entity';
19
20	@Injectable()
21	export class TransactionDataMapper {	98✔
22	constructor(
23	private readonly addressInfoHelper: AddressInfoHelper,	1,206✔
24	@Inject(IContractsRepository)
25	private readonly contractRepository: ContractsRepository,	1,206✔
26	private readonly dataDecodedParamHelper: DataDecodedParamHelper,	1,206✔
27	) {}
28
29	async mapTransactionData(
30	chainId: string,
31	previewTransactionDto: PreviewTransactionDto,
32	dataDecoded: DataDecoded \| null,
33	): Promise<TransactionData> {
34	const toAddress = await this.addressInfoHelper.getOrDefault(	8✔
35	chainId,
36	previewTransactionDto.to,
37	['CONTRACT'],
38	);
39	const isTrustedDelegateCall = await this.isTrustedDelegateCall(	8✔
40	chainId,
41	previewTransactionDto.operation,
42	previewTransactionDto.to,
43	dataDecoded,
44	);
45	const addressInfoIndex = await this.buildAddressInfoIndex(	8✔
46	chainId,
47	dataDecoded,
48	);
49
50	return new TransactionData(	8✔
51	previewTransactionDto.data,
52	dataDecoded,
53	toAddress,
54	previewTransactionDto.value,
55	previewTransactionDto.operation,
56	isTrustedDelegateCall ?? null,	9✔
57	isEmpty(addressInfoIndex) ? null : addressInfoIndex,	4!
58	);
59	}
60
61	/**
62	* Determines if the transaction is a trusted DELEGATE call.
63	* @param chainId chain id
64	* @param operation transaction operation
65	* @param to transaction target address
66	* @param dataDecoded data decoded to check
67	* @returns null if the transaction operation is not DELEGATE.
68	* If the transaction operation is DELEGATE, and the target {@link Contract}
69	* is trusted, and the {@link DataDecoded} received does not contain
70	* a nested DELEGATE operation, then true is returned.
71	* Otherwise, the function will return false.
72	*/
73	async isTrustedDelegateCall(
74	chainId: string,
75	operation: Operation,
76	to: string,
77	dataDecoded: DataDecoded \| null,
78	): Promise<boolean \| null> {
79	if (operation !== Operation.DELEGATE) return null;	32✔
80
81	let contract: Contract;
82	try {	14✔
83	contract = await this.contractRepository.getContract({	14✔
84	chainId,
85	contractAddress: to,
86	});
87	} catch (err) {
88	return false;	2✔
89	}
90
91	const hasNestedDelegate = dataDecoded	12✔
92	? this.dataDecodedParamHelper.hasNestedDelegate(dataDecoded)
93	: false;
94
95	return contract.trustedForDelegateCall && !hasNestedDelegate;	12✔
96	}
97
98	/**
99	* Builds a {@link Record<string, AddressInfo>} which contains all the addresses
100	* extracted from {@link DataDecoded} as keys, and their related {@link AddressInfo}
101	* as value.
102	* @param chainId - chain id to use
103	* @param dataDecoded data decoded to use
104	* @returns {@link Record<string, AddressInfo>}
105	*/
106	async buildAddressInfoIndex(
107	chainId: string,
108	dataDecoded: DataDecoded \| null,
109	): Promise<Record<string, AddressInfo>> {
110	if (dataDecoded === null \|\| !Array.isArray(dataDecoded.parameters))	32✔
111	return {};	4✔
112	const { method, parameters } = dataDecoded;	28✔
113	const promises: Promise<(AddressInfo \| null)[] \| AddressInfo \| null>[] = [];	28✔
114
115	for (const parameter of parameters) {	28✔
116	if (	84✔
117	method === MULTI_SEND_METHOD_NAME &&	46✔
118	parameter.name === TRANSACTIONS_PARAMETER_NAME &&
119	parameter.valueDecoded
120	) {
121	promises.push(	4✔
122	this._getFromValueDecoded(chainId, parameter.valueDecoded),
123	);
124	} else if (parameter.type === ADDRESS_PARAMETER_TYPE) {	80✔
125	promises.push(this._getIfValid(chainId, parameter.value));	10✔
126	}
127	}
128
129	const addressInfos = (await Promise.all(promises))	28✔
130	.flat()
131	.filter((i): i is AddressInfo => i !== null);	26✔
132
133	return Object.fromEntries(addressInfos.map((i) => [i.value, i]));	28✔
134	}
135
136	/**
137	* Gets an array of {@link AddressInfo} for the passed valueDecoded, by iterating
138	* through its operations. For each operation, both its 'to' address and the addresses
139	* contained in its dataDecoded parameters are collected.
140	*
141	* Null values are added to the result array for each invalid value encountered.
142	* @param chainId - chain id to use
143	* @param valueDecoded - valueDecoded to use
144	*/
145	private async _getFromValueDecoded(
146	chainId: string,
147	valueDecoded: unknown,
148	): Promise<(AddressInfo \| null)[]> {
149	if (!Array.isArray(valueDecoded)) return [];	4!
150	const promises: Promise<AddressInfo \| null>[] = [];	4✔
151
152	for (const transaction of valueDecoded) {	4✔
153	promises.push(this._getIfValid(chainId, transaction.to));	8✔
154	if (transaction?.dataDecoded?.parameters) {	8!
155	for (const param of transaction?.dataDecoded?.parameters) {	8!
156	if (param.type === ADDRESS_PARAMETER_TYPE) {	24✔
157	promises.push(this._getIfValid(chainId, param.value));	8✔
158	}
159	}
160	}
161	}
162	return Promise.all(promises);	4✔
163	}
164
165	/**
166	* Gets an {@link AddressInfo} for the passed value, if it is valid.
167	* @param chainId - chain id to use
168	* @param value - value to use
169	*/
170	private async _getIfValid(
171	chainId: string,
172	value: unknown,
173	): Promise<AddressInfo \| null> {
174	if (typeof value === 'string' && value !== NULL_ADDRESS) {	26✔
175	const addressInfo = await this.addressInfoHelper	26✔
176	.get(chainId, value, ['TOKEN', 'CONTRACT'])
UNCOV 177	.catch(() => null);	×
178	return addressInfo?.name ? addressInfo : null;	26!
179	}
180	return null;	×
181	}
182	}

safe-global / safe-client-gateway / 8284406372

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