10794345697

Committed 10 Sep 2024 02:14PM UTC coverage: 91.109%. Remained the same

Build # 10794345697

Build Type

Pull #1911

github

Committed by

web-flow

Commit Message

Merge 4624c7aef into c24effc41

Pull Request Pull Request #1911: Add client timezone to transaction history

Run Details

2615 of 3217 branches covered (81.29%)

Branch coverage included in aggregate %.

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

1 existing line in 1 file now uncovered.

8237 of 8694 relevant lines covered (94.74%)

443.25 hits per line

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

86.61

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

import { Inject, Injectable } from '@nestjs/common';
import { groupBy } from 'lodash';
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 isImitationMappingEnabled: boolean;
  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.isImitationMappingEnabled = this.configurationService.getOrThrow(
      'features.imitationMapping',
    );
    this.maxNestedTransfers = this.configurationService.getOrThrow(
      'mappings.history.maxNestedTransfers',
    );
  }

  async mapTransactionsHistory(
    chainId: string,
    transactionsDomain: TransactionDomain[],
    safe: Safe,
    offset: number,
    timezoneOffset: number,
    onlyTrusted: boolean,
    showImitations: boolean,
    timezoneId?: string,
  ): Promise<Array<TransactionItem | DateLabel>> {
    if (transactionsDomain.length == 0) {
      return [];
    }
    // Must be retrieved before mapping others as we remove it from transactionsDomain
    const previousTransaction = await this.getPreviousTransaction({
      offset,
      transactionsDomain,
      chainId,
      safe,
      onlyTrusted,
    });

    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,
      timezoneId,
    );
    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: {
    offset: number;
    transactionsDomain: TransactionDomain[];
    chainId: string;
    safe: Safe;
    onlyTrusted: boolean;
  }): Promise<TransactionItem | undefined> {
    // More than 1 element is required to get the previous transaction
    if (args.offset <= 0 || args.transactionsDomain.length <= 1) {
      return;
    }
    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,
    );
    // Remove first transaction that was requested to get previous day timestamp
    args.transactionsDomain = args.transactionsDomain.slice(1);

    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();

    if (!this.isImitationMappingEnabled) {
      return transactionItems;
    }

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

  private groupByDay(
    transactions: TransactionItem[],
    timezoneOffset: number,
    timezoneId?: 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,
        timezoneId,
      ).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} timezoneId - If timezone id is passed, timezoneOffset will be ignored
   */
  private getDayStartForDate(
    timestamp: Date,
    timezoneOffset: number,
    timezoneId?: string,
  ): Date {
    if (timezoneId) {
      // The following check is there to make sure we do not get undefined if the timezoneId is invalid
      // but it should never happen as we are already validating the timestamp
      return convertToTimezone(timestamp, timezoneId) ?? timestamp;
    }

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

safe-global / safe-client-gateway / 10794345697

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