12259560673

Committed 10 Dec 2024 03:38PM UTC coverage: 90.096% (-0.04%) from 90.133%

Build # 12259560673

Build Type

push

github

Committed by

iamacook

Commit Message

Remove timestamp-reference transaction from start of page

Run Details

2808 of 3500 branches covered (80.23%)

Branch coverage included in aggregate %.

1 of 3 new or added lines in 1 file covered. (33.33%)

1 existing line in 1 file now uncovered.

9610 of 10283 relevant lines covered (93.46%)

435.6 hits per line

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

84.0

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

import { Inject, Injectable } from '@nestjs/common';
import groupBy from 'lodash/groupBy';
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';
import { TransferImitationMapper } from '@/routes/transactions/mappers/transfers/transfer-imitation.mapper';
import {
  calculateTimezoneOffset,
  convertToTimezone,
} from '@/routes/transactions/helpers/timezone.helper';

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

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

  async mapTransactionsHistory(
    chainId: string,
    transactionsDomain: TransactionDomain[],
    safe: Safe,
    offset: number,
    timezoneOffset: number,
    onlyTrusted: boolean,
    showImitations: boolean,
    timezone?: string,
  ): Promise<Array<TransactionItem | DateLabel>> {
    if (transactionsDomain.length == 0) {
      return [];
    }

    let previousTransaction: TransactionItem | undefined;

    /**
     * We insert a {@link DateLabel} between transactions on different days.
     * On subsequent pages (offset > 0), we fetch the last transaction of previous page
     * to determine if the first transaction of the current page is on the same day.
     */
    if (offset > 0 && transactionsDomain.length > 1) {
      previousTransaction = await this.getPreviousTransaction({
        transactionsDomain,
        chainId,
        safe,
        onlyTrusted,
      });

      // Remove first transaction that was requested to get previous day timestamp
      transactionsDomain = transactionsDomain.slice(1);
    }

    const mappedTransactions = await this.getMappedTransactions({
      transactionsDomain,
      chainId,
      safe,
      previousTransaction,
      onlyTrusted,
      showImitations,
    });

    // The groups respect timezone offset – this was done for grouping only.
    const transactionsByDay = this.groupByDay(
      mappedTransactions,
      timezoneOffset,
      timezone,
    );
    return transactionsByDay.reduce<Array<TransactionItem | DateLabel>>(
      (transactionList, transactionsOnDay) => {
        // The actual value of the group should be in the UTC timezone instead
        // A group should always have at least one transaction.
        const { timestamp } = transactionsOnDay[0].transaction;

        // 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 =
          timestamp == previousTransaction?.transaction.timestamp;
        if (!isFollowUp && transactionsOnDay.length > 0 && timestamp) {
          transactionList.push(new DateLabel(timestamp));
        }
        return transactionList.concat(transactionsOnDay);
      },
      [],
    );
  }

  private async getPreviousTransaction(args: {
    transactionsDomain: TransactionDomain[];
    chainId: string;
    safe: Safe;
    onlyTrusted: boolean;
  }): Promise<TransactionItem | undefined> {
    const prevDomainTransaction = args.transactionsDomain[0];
    // We map in order to filter last list item against it
    const mappedPreviousTransaction = await this.mapTransaction(
      prevDomainTransaction,
      args.chainId,
      args.safe,
      args.onlyTrusted,
    );

    return Array.isArray(mappedPreviousTransaction)
      ? // All transfers should have same execution date but the last is "true" previous
        mappedPreviousTransaction.at(-1)
      : mappedPreviousTransaction;
  }

  private async getMappedTransactions(args: {
    transactionsDomain: TransactionDomain[];
    chainId: string;
    safe: Safe;
    previousTransaction: TransactionItem | undefined;
    onlyTrusted: boolean;
    showImitations: boolean;
  }): Promise<TransactionItem[]> {
    const mappedTransactions = await Promise.all(
      args.transactionsDomain.map((transaction) => {
        return this.mapTransaction(
          transaction,
          args.chainId,
          args.safe,
          args.onlyTrusted,
        );
      }),
    );
    const transactionItems = mappedTransactions
      .filter(<T>(x: T): x is NonNullable<T> => x != null)
      .flat();

    return this.transferImitationMapper.mapImitations({
      transactions: transactionItems,
      previousTransaction: args.previousTransaction,
      showImitations: args.showImitations,
    });
  }

  private groupByDay(
    transactions: TransactionItem[],
    timezoneOffset: number,
    timezone?: string,
  ): TransactionItem[][] {
    const grouped = groupBy(transactions, ({ transaction }) => {
      // timestamp will always be defined for historical transactions
      const date = new Date(transaction.timestamp ?? 0);
      return this.getDayStartForDate(date, timezoneOffset, timezone).getTime();
    });
    return Object.values(grouped);
  }

  /**
   * 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
   * @param {string} timezone - If timezone id is passed, timezoneOffset will be ignored
   */
  private getDayStartForDate(
    timestamp: Date,
    timezoneOffset: number,
    timezone?: string,
  ): Date {
    return timezone
      ? convertToTimezone(timestamp, timezone)
      : calculateTimezoneOffset(timestamp, timezoneOffset);
  }

  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 async mapTransaction(
    transaction: TransactionDomain,
    chainId: string,
    safe: Safe,
    onlyTrusted: boolean,
  ): Promise<TransactionItem | TransactionItem[] | undefined> {
    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 Zod would not allow an unknown transaction to get to this stage
      throw Error('Unrecognized transaction type');
    }
  }
}

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

safe-global / safe-client-gateway / 12259560673

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