8113430747

Committed 01 Mar 2024 03:35PM UTC coverage: 93.898% (+0.2%) from 93.694%

Build # 8113430747

Build Type

Pull #1203

github

Committed by

web-flow

Commit Message

Merge 63a842fe6 into cf6873490

Pull Request Pull Request #1203: Validate `RelayDto` using `zod`

Run Details

1692 of 2016 branches covered (83.93%)

Branch coverage included in aggregate %.

29 of 29 new or added lines in 6 files covered. (100.0%)

36 existing lines in 10 files now uncovered.

6217 of 6407 relevant lines covered (97.03%)

351.51 hits per line

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

86.09

/src/routes/transactions/mappers/transactions-history.mapper.ts

import { Inject, Injectable } from '@nestjs/common';
import { groupBy } from 'lodash';
import { CreationTransaction } from '@/domain/safe/entities/creation-transaction.entity';
import { EthereumTransaction } from '@/domain/safe/entities/ethereum-transaction.entity';
import { ModuleTransaction } from '@/domain/safe/entities/module-transaction.entity';
import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
import { Safe } from '@/domain/safe/entities/safe.entity';
import {
  isCreationTransaction,
  isEthereumTransaction,
  isModuleTransaction,
  isMultisigTransaction,
  Transaction as TransactionDomain,
} from '@/domain/safe/entities/transaction.entity';
import { Transfer } from '@/domain/safe/entities/transfer.entity';
import { DateLabel } from '@/routes/common/entities/date-label.entity';
import { TransactionItem } from '@/routes/transactions/entities/transaction-item.entity';
import { CreationTransactionMapper } from '@/routes/transactions/mappers/creation-transaction/creation-transaction.mapper';
import { ModuleTransactionMapper } from '@/routes/transactions/mappers/module-transactions/module-transaction.mapper';
import { MultisigTransactionMapper } from '@/routes/transactions/mappers/multisig-transactions/multisig-transaction.mapper';
import { TransferMapper } from '@/routes/transactions/mappers/transfers/transfer.mapper';
import { IConfigurationService } from '@/config/configuration.service.interface';

class TransactionDomainGroup {
  timestamp!: number;
  transactions!: (
    | MultisigTransaction
    | ModuleTransaction
    | EthereumTransaction
    | CreationTransaction
  )[];
}

@Injectable()
export class TransactionsHistoryMapper {
  private readonly maxNestedTransfers: number;

  constructor(
    @Inject(IConfigurationService) configurationService: IConfigurationService,
    private readonly multisigTransactionMapper: MultisigTransactionMapper,
    private readonly moduleTransactionMapper: ModuleTransactionMapper,
    private readonly transferMapper: TransferMapper,
    private readonly creationTransactionMapper: CreationTransactionMapper,
  ) {
    this.maxNestedTransfers = configurationService.getOrThrow(
      'mappings.history.maxNestedTransfers',
    );
  }

  async mapTransactionsHistory(
    chainId: string,
    transactionsDomain: TransactionDomain[],
    safe: Safe,
    offset: number,
    timezoneOffset: number,
    onlyTrusted: boolean,
  ): Promise<Array<TransactionItem | DateLabel>> {
    if (transactionsDomain.length == 0) {
      return [];
    }
    const previousTransaction = this.getPreviousItem(
      offset,
      transactionsDomain,
    );
    let prevPageTimestamp = 0;
    if (previousTransaction !== null) {
      prevPageTimestamp = this.getDayFromTransactionDate(
        previousTransaction,
        timezoneOffset,
      ).getTime();
      // Remove first transaction that was requested to get previous day timestamp
      transactionsDomain = transactionsDomain.slice(1);
    }

    const transactionsDomainGroups = this.groupByDay(
      transactionsDomain,
      timezoneOffset,
    );

    const transactionList = await Promise.all(
      transactionsDomainGroups.map(async (transactionGroup) => {
        const items: (TransactionItem | DateLabel)[] = [];
        const groupTransactions = (
          await this.mapGroupTransactions(
            transactionGroup,
            chainId,
            safe,
            onlyTrusted,
          )
        )
          .filter(<T>(x: T | undefined): x is T => x != null)
          .flat();

        // If the current group is a follow-up from the previous page,
        // or the group is empty, the date label shouldn't be added.
        const isFollowUp = transactionGroup.timestamp == prevPageTimestamp;
        if (!isFollowUp && groupTransactions.length) {
          items.push(new DateLabel(transactionGroup.timestamp));
        }
        items.push(...groupTransactions);
        return items;
      }),
    );

    return transactionList.flat();
  }

  private getTransactionTimestamp(transaction: TransactionDomain): Date {
    let timestamp: Date | null;
    if (isMultisigTransaction(transaction)) {
      const executionDate = transaction.executionDate;
      timestamp = executionDate ?? transaction.submissionDate;
    } else if (isEthereumTransaction(transaction)) {
      timestamp = transaction.executionDate;
    } else if (isModuleTransaction(transaction)) {
      timestamp = transaction.executionDate;
    } else if (isCreationTransaction(transaction)) {
      timestamp = transaction.created;
    } else {
      throw Error('Unknown transaction type');
    }
    if (timestamp == null) {
      throw Error('ExecutionDate cannot be null');
    }
    return timestamp;
  }

  private getPreviousItem(
    offset: number,
    transactions: TransactionDomain[],
  ): TransactionDomain | null {
    // More than 1 element is required to get the previous page date
    if (offset <= 0 || transactions.length <= 1) return null;
    return transactions[0];
  }

  private getDayFromTransactionDate(
    transaction: TransactionDomain,
    timezoneOffset: number,
  ): Date {
    const timestamp = this.getTransactionTimestamp(transaction);
    return this.getDayStartForDate(timestamp, timezoneOffset);
  }

  private groupByDay(
    transactions: TransactionDomain[],
    timezoneOffset: number,
  ): TransactionDomainGroup[] {
    return Object.entries(
      groupBy(transactions, (transaction) => {
        return this.getDayFromTransactionDate(
          transaction,
          timezoneOffset,
        ).getTime();
      }),
    ).map(([, transactions]): TransactionDomainGroup => {
      // The groups respect the timezone offset – this was done for grouping only.
      // The actual value of the group should be in the UTC timezone instead
      // A group should always have at least one transaction.
      return {
        timestamp: this.getTransactionTimestamp(transactions[0]).getTime(),
        transactions: transactions,
      };
    });
  }

  /**
   * Returns a day {@link Date } at 00:00:00 from the input timestamp.
   *
   * @param timestamp - date to convert
   * @param timezoneOffset - Offset of time zone in milliseconds
   */
  private getDayStartForDate(timestamp: Date, timezoneOffset: number): Date {
    const date = structuredClone(timestamp);
    date.setTime(date.getTime() + timezoneOffset);
    return new Date(
      Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()),
    );
  }

  private async mapTransfers(
    transfers: Transfer[],
    chainId: string,
    safe: Safe,
    onlyTrusted: boolean,
  ): Promise<TransactionItem[]> {
    const limitedTransfers = transfers.slice(0, this.maxNestedTransfers);

    const nestedTransactions = await this.transferMapper.mapTransfers({
      chainId,
      transfers: limitedTransfers,
      safe,
      onlyTrusted,
    });

    return nestedTransactions.map(
      (nestedTransaction) => new TransactionItem(nestedTransaction),
    );
  }

  private mapGroupTransactions(
    transactionGroup: TransactionDomainGroup,
    chainId: string,
    safe: Safe,
    onlyTrusted: boolean,
  ): Promise<(TransactionItem | TransactionItem[] | undefined)[]> {
    return Promise.all(
      transactionGroup.transactions.map(async (transaction) => {
        if (isMultisigTransaction(transaction)) {
          return new TransactionItem(
            await this.multisigTransactionMapper.mapTransaction(
              chainId,
              transaction,
              safe,
            ),
          );
        } else if (isModuleTransaction(transaction)) {
          return new TransactionItem(
            await this.moduleTransactionMapper.mapTransaction(
              chainId,
              transaction,
            ),
          );
        } else if (isEthereumTransaction(transaction)) {
          const transfers = transaction.transfers;
          if (transfers != null) {
            return await this.mapTransfers(
              transfers,
              chainId,
              safe,
              onlyTrusted,
            );
          }
        } else if (isCreationTransaction(transaction)) {
          return new TransactionItem(
            await this.creationTransactionMapper.mapTransaction(
              chainId,
              transaction,
              safe,
            ),
          );
        } else {
          // This should never happen as AJV would not allow an unknown transaction to get to this stage
          throw Error('Unrecognized transaction type');
        }
      }),
    );
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	90✔
2	import { groupBy } from 'lodash';	90✔
3	import { CreationTransaction } from '@/domain/safe/entities/creation-transaction.entity';
4	import { EthereumTransaction } from '@/domain/safe/entities/ethereum-transaction.entity';
5	import { ModuleTransaction } from '@/domain/safe/entities/module-transaction.entity';
6	import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
7	import { Safe } from '@/domain/safe/entities/safe.entity';
8	import {	90✔
9	isCreationTransaction,
10	isEthereumTransaction,
11	isModuleTransaction,
12	isMultisigTransaction,
13	Transaction as TransactionDomain,
14	} from '@/domain/safe/entities/transaction.entity';
15	import { Transfer } from '@/domain/safe/entities/transfer.entity';
16	import { DateLabel } from '@/routes/common/entities/date-label.entity';	90✔
17	import { TransactionItem } from '@/routes/transactions/entities/transaction-item.entity';	90✔
18	import { CreationTransactionMapper } from '@/routes/transactions/mappers/creation-transaction/creation-transaction.mapper';	90✔
19	import { ModuleTransactionMapper } from '@/routes/transactions/mappers/module-transactions/module-transaction.mapper';	90✔
20	import { MultisigTransactionMapper } from '@/routes/transactions/mappers/multisig-transactions/multisig-transaction.mapper';	90✔
21	import { TransferMapper } from '@/routes/transactions/mappers/transfers/transfer.mapper';	90✔
22	import { IConfigurationService } from '@/config/configuration.service.interface';	90✔
23
24	class TransactionDomainGroup {
25	timestamp!: number;
26	transactions!: (
27	\| MultisigTransaction
28	\| ModuleTransaction
29	\| EthereumTransaction
30	\| CreationTransaction
31	)[];
32	}
33
34	@Injectable()
35	export class TransactionsHistoryMapper {	90✔
36	private readonly maxNestedTransfers: number;
37
38	constructor(
39	@Inject(IConfigurationService) configurationService: IConfigurationService,
40	private readonly multisigTransactionMapper: MultisigTransactionMapper,	1,070✔
41	private readonly moduleTransactionMapper: ModuleTransactionMapper,	1,070✔
42	private readonly transferMapper: TransferMapper,	1,070✔
43	private readonly creationTransactionMapper: CreationTransactionMapper,	1,070✔
44	) {
45	this.maxNestedTransfers = configurationService.getOrThrow(	1,070✔
46	'mappings.history.maxNestedTransfers',
47	);
48	}
49
50	async mapTransactionsHistory(
51	chainId: string,
52	transactionsDomain: TransactionDomain[],
53	safe: Safe,
54	offset: number,
55	timezoneOffset: number,
56	onlyTrusted: boolean,
57	): Promise<Array<TransactionItem \| DateLabel>> {
58	if (transactionsDomain.length == 0) {	28!
UNCOV 59	return [];	×
60	}
61	const previousTransaction = this.getPreviousItem(	28✔
62	offset,
63	transactionsDomain,
64	);
65	let prevPageTimestamp = 0;	28✔
66	if (previousTransaction !== null) {	28!
UNCOV 67	prevPageTimestamp = this.getDayFromTransactionDate(	×
68	previousTransaction,
69	timezoneOffset,
70	).getTime();
71	// Remove first transaction that was requested to get previous day timestamp
UNCOV 72	transactionsDomain = transactionsDomain.slice(1);	×
73	}
74
75	const transactionsDomainGroups = this.groupByDay(	28✔
76	transactionsDomain,
77	timezoneOffset,
78	);
79
80	const transactionList = await Promise.all(	28✔
81	transactionsDomainGroups.map(async (transactionGroup) => {
82	const items: (TransactionItem \| DateLabel)[] = [];	44✔
83	const groupTransactions = (	44✔
84	await this.mapGroupTransactions(
85	transactionGroup,
86	chainId,
87	safe,
88	onlyTrusted,
89	)
90	)
91	.filter(<T>(x: T \| undefined): x is T => x != null)	46✔
92	.flat();
93
94	// If the current group is a follow-up from the previous page,
95	// or the group is empty, the date label shouldn't be added.
96	const isFollowUp = transactionGroup.timestamp == prevPageTimestamp;	44✔
97	if (!isFollowUp && groupTransactions.length) {	44✔
98	items.push(new DateLabel(transactionGroup.timestamp));	38✔
99	}
100	items.push(...groupTransactions);	44✔
101	return items;	44✔
102	}),
103	);
104
105	return transactionList.flat();	28✔
106	}
107
108	private getTransactionTimestamp(transaction: TransactionDomain): Date {
109	let timestamp: Date \| null;
110	if (isMultisigTransaction(transaction)) {	90✔
111	const executionDate = transaction.executionDate;	8✔
112	timestamp = executionDate ?? transaction.submissionDate;	8!
113	} else if (isEthereumTransaction(transaction)) {	82✔
114	timestamp = transaction.executionDate;	48✔
115	} else if (isModuleTransaction(transaction)) {	34✔
116	timestamp = transaction.executionDate;	28✔
117	} else if (isCreationTransaction(transaction)) {	6!
118	timestamp = transaction.created;	6✔
119	} else {
UNCOV 120	throw Error('Unknown transaction type');	×
121	}
122	if (timestamp == null) {	90!
123	throw Error('ExecutionDate cannot be null');	×
124	}
125	return timestamp;	90✔
126	}
127
128	private getPreviousItem(
129	offset: number,
130	transactions: TransactionDomain[],
131	): TransactionDomain \| null {
132	// More than 1 element is required to get the previous page date
133	if (offset <= 0 \|\| transactions.length <= 1) return null;	28✔
UNCOV 134	return transactions[0];	×
135	}
136
137	private getDayFromTransactionDate(
138	transaction: TransactionDomain,
139	timezoneOffset: number,
140	): Date {
141	const timestamp = this.getTransactionTimestamp(transaction);	46✔
142	return this.getDayStartForDate(timestamp, timezoneOffset);	46✔
143	}
144
145	private groupByDay(
146	transactions: TransactionDomain[],
147	timezoneOffset: number,
148	): TransactionDomainGroup[] {
149	return Object.entries(	28✔
150	groupBy(transactions, (transaction) => {
151	return this.getDayFromTransactionDate(	46✔
152	transaction,
153	timezoneOffset,
154	).getTime();
155	}),
156	).map(([, transactions]): TransactionDomainGroup => {
157	// The groups respect the timezone offset – this was done for grouping only.
158	// The actual value of the group should be in the UTC timezone instead
159	// A group should always have at least one transaction.
160	return {	44✔
161	timestamp: this.getTransactionTimestamp(transactions[0]).getTime(),
162	transactions: transactions,
163	};
164	});
165	}
166
167	/**
168	* Returns a day {@link Date } at 00:00:00 from the input timestamp.
169	*
170	* @param timestamp - date to convert
171	* @param timezoneOffset - Offset of time zone in milliseconds
172	*/
173	private getDayStartForDate(timestamp: Date, timezoneOffset: number): Date {
174	const date = structuredClone(timestamp);	46✔
175	date.setTime(date.getTime() + timezoneOffset);	46✔
176	return new Date(	46✔
177	Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()),
178	);
179	}
180
181	private async mapTransfers(
182	transfers: Transfer[],
183	chainId: string,
184	safe: Safe,
185	onlyTrusted: boolean,
186	): Promise<TransactionItem[]> {
187	const limitedTransfers = transfers.slice(0, this.maxNestedTransfers);	24✔
188
189	const nestedTransactions = await this.transferMapper.mapTransfers({	24✔
190	chainId,
191	transfers: limitedTransfers,
192	safe,
193	onlyTrusted,
194	});
195
196	return nestedTransactions.map(	24✔
197	(nestedTransaction) => new TransactionItem(nestedTransaction),	30✔
198	);
199	}
200
201	private mapGroupTransactions(
202	transactionGroup: TransactionDomainGroup,
203	chainId: string,
204	safe: Safe,
205	onlyTrusted: boolean,
206	): Promise<(TransactionItem \| TransactionItem[] \| undefined)[]> {
207	return Promise.all(	44✔
208	transactionGroup.transactions.map(async (transaction) => {
209	if (isMultisigTransaction(transaction)) {	46✔
210	return new TransactionItem(	4✔
211	await this.multisigTransactionMapper.mapTransaction(
212	chainId,
213	transaction,
214	safe,
215	),
216	);
217	} else if (isModuleTransaction(transaction)) {	42✔
218	return new TransactionItem(	14✔
219	await this.moduleTransactionMapper.mapTransaction(
220	chainId,
221	transaction,
222	),
223	);
224	} else if (isEthereumTransaction(transaction)) {	28✔
225	const transfers = transaction.transfers;	24✔
226	if (transfers != null) {	24✔
227	return await this.mapTransfers(	24✔
228	transfers,
229	chainId,
230	safe,
231	onlyTrusted,
232	);
233	}
234	} else if (isCreationTransaction(transaction)) {	4!
235	return new TransactionItem(	4✔
236	await this.creationTransactionMapper.mapTransaction(
237	chainId,
238	transaction,
239	safe,
240	),
241	);
242	} else {
243	// This should never happen as AJV would not allow an unknown transaction to get to this stage
UNCOV 244	throw Error('Unrecognized transaction type');	×
245	}
246	}),
247	);
248	}
249	}

safe-global / safe-client-gateway / 8113430747

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