6083860467

Committed 05 Sep 2023 11:19AM UTC coverage: 91.936% (-0.6%) from 92.5%

Build Type

github

Committed by Usame Algan

Commit Message

fix: Use classes for humanDescription route entities

Pull Request Pull Request #671: feat: Human readable v2

Run Details

1170 of 1392 branches covered (0.0%)

Branch coverage included in aggregate %.

55 of 74 new or added lines in 11 files covered. (74.32%)

6 existing lines in 3 files now uncovered.

4542 of 4821 relevant lines covered (94.21%)

150.28 hits per line

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

91.77

/src/routes/transactions/transactions.service.ts

import { Inject, Injectable } from '@nestjs/common';
import { head, last } from 'lodash';
import { MultisigTransaction as DomainMultisigTransaction } from '../../domain/safe/entities/multisig-transaction.entity';
import { SafeRepository } from '@/domain/safe/safe.repository';
import { ISafeRepository } from '@/domain/safe/safe.repository.interface';
import { AddConfirmationDto } from '@/domain/transactions/entities/add-confirmation.dto.entity';
import { Page } from '../common/entities/page.entity';
import {
  buildNextPageURL,
  buildPreviousPageURL,
  cursorUrlFromLimitAndOffset,
  PaginationData,
} from '../common/pagination/pagination.data';
import { ConflictType } from './entities/conflict-type.entity';
import { IncomingTransfer } from './entities/incoming-transfer.entity';
import { ModuleTransaction } from './entities/module-transaction.entity';
import { MultisigTransaction } from './entities/multisig-transaction.entity';
import { PreviewTransactionDto } from './entities/preview-transaction.dto.entity';
import { QueuedItem } from './entities/queued-item.entity';
import { TransactionItemPage } from './entities/transaction-item-page.entity';
import { TransactionPreview } from './entities/transaction-preview.entity';
import { ModuleTransactionMapper } from './mappers/module-transactions/module-transaction.mapper';
import { MultisigTransactionMapper } from './mappers/multisig-transactions/multisig-transaction.mapper';
import { QueuedItemsMapper } from './mappers/queued-items/queued-items.mapper';
import { TransactionPreviewMapper } from './mappers/transaction-preview.mapper';
import { ProposeTransactionDto } from './entities/propose-transaction.dto.entity';
import { TransactionsHistoryMapper } from './mappers/transactions-history.mapper';
import { IncomingTransferMapper } from './mappers/transfers/transfer.mapper';
import {
  MODULE_TRANSACTION_PREFIX,
  MULTISIG_TRANSACTION_PREFIX,
  TRANSACTION_ID_SEPARATOR,
  TRANSFER_PREFIX,
} from './constants';
import { ModuleTransactionDetailsMapper } from './mappers/module-transactions/module-transaction-details.mapper';
import { TransactionDetails } from './entities/transaction-details/transaction-details.entity';
import { TransferDetailsMapper } from './mappers/transfers/transfer-details.mapper';
import { MultisigTransactionDetailsMapper } from './mappers/multisig-transactions/multisig-transaction-details.mapper';

@Injectable()
export class TransactionsService {
  constructor(
    @Inject(ISafeRepository) private readonly safeRepository: SafeRepository,
    private readonly multisigTransactionMapper: MultisigTransactionMapper,
    private readonly incomingTransferMapper: IncomingTransferMapper,
    private readonly moduleTransactionMapper: ModuleTransactionMapper,
    private readonly queuedItemsMapper: QueuedItemsMapper,
    private readonly transactionsHistoryMapper: TransactionsHistoryMapper,
    private readonly transactionPreviewMapper: TransactionPreviewMapper,
    private readonly moduleTransactionDetailsMapper: ModuleTransactionDetailsMapper,
    private readonly multisigTransactionDetailsMapper: MultisigTransactionDetailsMapper,
    private readonly transferDetailsMapper: TransferDetailsMapper,
  ) {}

  async getById(args: {
    chainId: string;
    txId: string;
  }): Promise<TransactionDetails> {
    const [txType, safeAddress, id] = args.txId.split(TRANSACTION_ID_SEPARATOR);

    switch (txType) {
      case MODULE_TRANSACTION_PREFIX: {
        const [tx] = await Promise.all([
          this.safeRepository.getModuleTransaction({
            chainId: args.chainId,
            moduleTransactionId: id,
          }),
        ]);
        return this.moduleTransactionDetailsMapper.mapDetails(args.chainId, tx);
      }

      case TRANSFER_PREFIX: {
        const [transfer, safe] = await Promise.all([
          this.safeRepository.getTransfer({
            chainId: args.chainId,
            transferId: id,
          }),
          this.safeRepository.getSafe({
            chainId: args.chainId,
            address: safeAddress,
          }),
        ]);
        return this.transferDetailsMapper.mapDetails(
          args.chainId,
          transfer,
          safe,
        );
      }

      case MULTISIG_TRANSACTION_PREFIX: {
        const [tx, safe] = await Promise.all([
          this.safeRepository.getMultiSigTransaction({
            chainId: args.chainId,
            safeTransactionHash: id,
          }),
          this.safeRepository.getSafe({
            chainId: args.chainId,
            address: safeAddress,
          }),
        ]);
        return this.multisigTransactionDetailsMapper.mapDetails(
          args.chainId,
          tx,
          safe,
        );
      }

      // txId is safeTxHash
      default: {
        const tx = await this.safeRepository.getMultiSigTransaction({
          chainId: args.chainId,
          safeTransactionHash: args.txId,
        });
        const safe = await this.safeRepository.getSafe({
          chainId: args.chainId,
          address: tx.safe,
        });
        return this.multisigTransactionDetailsMapper.mapDetails(
          args.chainId,
          tx,
          safe,
        );
      }
    }
  }

  async getMultisigTransactions(args: {
    chainId: string;
    routeUrl: Readonly<URL>;
    paginationData: PaginationData;
    safeAddress: string;
    executionDateGte?: string;
    executionDateLte?: string;
    to?: string;
    value?: string;
    nonce?: string;
    executed?: boolean;
  }): Promise<Partial<Page<MultisigTransaction>>> {
    const domainTransactions =
      await this.safeRepository.getMultisigTransactions({
        ...args,
        limit: args.paginationData.limit,
        offset: args.paginationData.offset,
      });

    const safeInfo = await this.safeRepository.getSafe({
      chainId: args.chainId,
      address: args.safeAddress,
    });
    const results = await Promise.all(
      domainTransactions.results.map(
        async (domainTransaction) =>
          new MultisigTransaction(
            await this.multisigTransactionMapper.mapTransaction(
              args.chainId,
              domainTransaction,
              safeInfo,
            ),
            ConflictType.None,
          ),
      ),
    );
    const nextURL = cursorUrlFromLimitAndOffset(
      args.routeUrl,
      domainTransactions.next,
    );
    const previousURL = cursorUrlFromLimitAndOffset(
      args.routeUrl,
      domainTransactions.previous,
    );

    return {
      next: nextURL?.toString() ?? null,
      previous: previousURL?.toString() ?? null,
      results,
    };
  }

  async addConfirmation(args: {
    chainId: string;
    safeTxHash: string;
    addConfirmationDto: AddConfirmationDto;
  }): Promise<TransactionDetails> {
    await this.safeRepository.addConfirmation(args);
    const transaction = await this.safeRepository.getMultiSigTransaction({
      chainId: args.chainId,
      safeTransactionHash: args.safeTxHash,
    });
    const safe = await this.safeRepository.getSafe({
      chainId: args.chainId,
      address: transaction.safe,
    });

    return this.multisigTransactionDetailsMapper.mapDetails(
      args.chainId,
      transaction,
      safe,
    );
  }

  async getModuleTransactions(args: {
    chainId: string;
    routeUrl: Readonly<URL>;
    safeAddress: string;
    to?: string;
    module?: string;
    paginationData?: PaginationData;
  }): Promise<Page<ModuleTransaction>> {
    const domainTransactions = await this.safeRepository.getModuleTransactions({
      ...args,
      limit: args.paginationData?.limit,
      offset: args.paginationData?.offset,
    });

    const results = await Promise.all(
      domainTransactions.results.map(
        async (domainTransaction) =>
          new ModuleTransaction(
            await this.moduleTransactionMapper.mapTransaction(
              args.chainId,
              domainTransaction,
            ),
          ),
      ),
    );
    const nextURL = cursorUrlFromLimitAndOffset(
      args.routeUrl,
      domainTransactions.next,
    );
    const previousURL = cursorUrlFromLimitAndOffset(
      args.routeUrl,
      domainTransactions.previous,
    );

    return <Page<ModuleTransaction>>{
      next: nextURL?.toString() ?? null,
      previous: previousURL?.toString() ?? null,
      results,
    };
  }

  async getIncomingTransfers(args: {
    chainId: string;
    routeUrl: Readonly<URL>;
    safeAddress: string;
    executionDateGte?: string;
    executionDateLte?: string;
    to?: string;
    value?: string;
    tokenAddress?: string;
    paginationData?: PaginationData;
  }): Promise<Partial<Page<IncomingTransfer>>> {
    const transfers = await this.safeRepository.getIncomingTransfers({
      ...args,
      limit: args.paginationData?.limit,
      offset: args.paginationData?.offset,
    });

    const safeInfo = await this.safeRepository.getSafe({
      chainId: args.chainId,
      address: args.safeAddress,
    });
    const results = await Promise.all(
      transfers.results.map(
        async (transfer) =>
          new IncomingTransfer(
            await this.incomingTransferMapper.mapTransfer(
              args.chainId,
              transfer,
              safeInfo,
            ),
          ),
      ),
    );

    const nextURL = cursorUrlFromLimitAndOffset(args.routeUrl, transfers.next);
    const previousURL = cursorUrlFromLimitAndOffset(
      args.routeUrl,
      transfers.previous,
    );

    return {
      next: nextURL?.toString() ?? null,
      previous: previousURL?.toString() ?? null,
      results,
    };
  }

  async previewTransaction(args: {
    chainId: string;
    safeAddress: string;
    previewTransactionDto: PreviewTransactionDto;
  }): Promise<TransactionPreview> {
    const safe = await this.safeRepository.getSafe({
      chainId: args.chainId,
      address: args.safeAddress,
    });
    return this.transactionPreviewMapper.mapTransactionPreview(
      args.chainId,
      safe,
      args.previewTransactionDto,
    );
  }

  async getTransactionQueue(args: {
    chainId: string;
    routeUrl: Readonly<URL>;
    safeAddress: string;
    paginationData: PaginationData;
    trusted?: boolean;
  }): Promise<Page<QueuedItem>> {
    const pagination = this.getAdjustedPaginationForQueue(args.paginationData);
    const safeInfo = await this.safeRepository.getSafe({
      chainId: args.chainId,
      address: args.safeAddress,
    });
    const transactions = await this.safeRepository.getTransactionQueue({
      chainId: args.chainId,
      safe: safeInfo,
      limit: pagination.limit,
      offset: pagination.offset,
      trusted: args.trusted,
    });

    const nextURL = buildNextPageURL(args.routeUrl, transactions.count);
    const previousURL = buildPreviousPageURL(args.routeUrl);
    const results = await this.queuedItemsMapper.getQueuedItems(
      this.adjustTransactionsPage(transactions),
      safeInfo,
      args.chainId,
      this.getPreviousPageLastNonce(transactions, args.paginationData),
      this.getNextPageFirstNonce(transactions),
    );

    return {
      count: results.length,
      next: nextURL?.toString() ?? null,
      previous: previousURL?.toString() ?? null,
      results,
    };
  }

  private getAdjustedPaginationForHistory(
    paginationData: PaginationData,
  ): PaginationData {
    if (paginationData.offset > 0) {
      return new PaginationData(
        paginationData.limit + 1,
        paginationData.offset - 1,
      );
    }
    return paginationData;
  }

  async getTransactionHistory(args: {
    chainId: string;
    routeUrl: Readonly<URL>;
    safeAddress: string;
    paginationData: PaginationData;
    timezoneOffset: number;
  }): Promise<TransactionItemPage> {
    const paginationDataAdjusted = this.getAdjustedPaginationForHistory(
      args.paginationData,
    );
    const domainTransactions = await this.safeRepository.getTransactionHistory({
      chainId: args.chainId,
      safeAddress: args.safeAddress,
      limit: paginationDataAdjusted.limit,
      offset: paginationDataAdjusted.offset,
    });
    const nextURL = buildNextPageURL(args.routeUrl, domainTransactions.count);
    const previousURL = buildPreviousPageURL(args.routeUrl);
    if (nextURL == null) {
      const creationTransaction =
        await this.safeRepository.getCreationTransaction({
          chainId: args.chainId,
          safeAddress: args.safeAddress,
        });
      domainTransactions.results.push(creationTransaction);
    }
    const safeInfo = await this.safeRepository.getSafe({
      chainId: args.chainId,
      address: args.safeAddress,
    });
    const results = await this.transactionsHistoryMapper.mapTransactionsHistory(
      args.chainId,
      domainTransactions.results,
      safeInfo,
      args.paginationData.offset,
      args.timezoneOffset,
    );

    return {
      count: domainTransactions.count,
      next: nextURL?.toString() ?? null,
      previous: previousURL?.toString() ?? null,
      results,
    };
  }

  async proposeTransaction(args: {
    chainId: string;
    safeAddress: string;
    proposeTransactionDto: ProposeTransactionDto;
  }): Promise<TransactionDetails> {
    await this.safeRepository.proposeTransaction(args);

    const safe = await this.safeRepository.getSafe({
      chainId: args.chainId,
      address: args.safeAddress,
    });
    const domainTransaction = await this.safeRepository.getMultiSigTransaction({
      chainId: args.chainId,
      safeTransactionHash: args.proposeTransactionDto.safeTxHash,
    });

    return this.multisigTransactionDetailsMapper.mapDetails(
      args.chainId,
      domainTransaction,
      safe,
    );
  }

  /**
   * Adjusts the pagination data to return extra items in both "edges" of the current page:
   * - If no pagination data info, then return the original pagination data.
   * - If it is the first page (offset 0), then return offset: 0, limit: limit + 1.
   * - If it is not the first page, then return offset: offset - 1, limit: limit + 2.
   * @param paginationData pagination data to adjust.
   * @returns pagination data adjusted.
   */
  private getAdjustedPaginationForQueue(
    paginationData: PaginationData,
  ): PaginationData {
    if (!paginationData.limit || !paginationData.offset) {
      return paginationData;
    }
    if (paginationData.offset === 0) {
      return new PaginationData(
        paginationData.limit + 1,
        paginationData.offset,
      );
    } else {
      return new PaginationData(
        paginationData.limit + 2,
        paginationData.offset - 1,
      );
    }
  }

  private getNextPageFirstNonce(
    page: Page<DomainMultisigTransaction>,
  ): number | null {
    return this.hasNextPage(page) ? this.getLastTransactionNonce(page) : null;
  }

  private getPreviousPageLastNonce(
    page: Page<DomainMultisigTransaction>,
    paginationData?: PaginationData,
  ): number | null {
    return paginationData && paginationData.offset
      ? this.getFirstTransactionNonce(page)
      : null;
  }

  /**
   * If the page has next page, returns a copy of the original transactions page without its last element.
   * Otherwise the original page of transactions is returned.
   *
   * @param page page of Transactions.
   * @returns transactions array without its first element if there is next page.
   */
  private adjustTransactionsPage(
    page: Page<DomainMultisigTransaction>,
  ): Page<DomainMultisigTransaction> {
    return this.hasNextPage(page)
      ? { ...page, results: page.results.slice(0, -1) }
      : page;
  }

  /**
   * Checks the if page contains a next cursor.
   */
  private hasNextPage(page: Page<DomainMultisigTransaction>): boolean {
    return page.next !== null;
  }

  private getFirstTransactionNonce(
    page: Page<DomainMultisigTransaction>,
  ): number | null {
    return head(page.results)?.nonce ?? null;
  }

  private getLastTransactionNonce(
    page: Page<DomainMultisigTransaction>,
  ): number | null {
    return last(page.results)?.nonce ?? null;
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	60✔
2	import { head, last } from 'lodash';	60✔
3	import { MultisigTransaction as DomainMultisigTransaction } from '../../domain/safe/entities/multisig-transaction.entity';
4	import { SafeRepository } from '@/domain/safe/safe.repository';	60✔
5	import { ISafeRepository } from '@/domain/safe/safe.repository.interface';	60✔
6	import { AddConfirmationDto } from '@/domain/transactions/entities/add-confirmation.dto.entity';
7	import { Page } from '../common/entities/page.entity';
8	import {	60✔
9	buildNextPageURL,
10	buildPreviousPageURL,
11	cursorUrlFromLimitAndOffset,
12	PaginationData,
13	} from '../common/pagination/pagination.data';
14	import { ConflictType } from './entities/conflict-type.entity';	60✔
15	import { IncomingTransfer } from './entities/incoming-transfer.entity';	60✔
16	import { ModuleTransaction } from './entities/module-transaction.entity';	60✔
17	import { MultisigTransaction } from './entities/multisig-transaction.entity';	60✔
18	import { PreviewTransactionDto } from './entities/preview-transaction.dto.entity';
19	import { QueuedItem } from './entities/queued-item.entity';
20	import { TransactionItemPage } from './entities/transaction-item-page.entity';
21	import { TransactionPreview } from './entities/transaction-preview.entity';
22	import { ModuleTransactionMapper } from './mappers/module-transactions/module-transaction.mapper';	60✔
23	import { MultisigTransactionMapper } from './mappers/multisig-transactions/multisig-transaction.mapper';	60✔
24	import { QueuedItemsMapper } from './mappers/queued-items/queued-items.mapper';	60✔
25	import { TransactionPreviewMapper } from './mappers/transaction-preview.mapper';	60✔
26	import { ProposeTransactionDto } from './entities/propose-transaction.dto.entity';
27	import { TransactionsHistoryMapper } from './mappers/transactions-history.mapper';	60✔
28	import { IncomingTransferMapper } from './mappers/transfers/transfer.mapper';	60✔
29	import {	60✔
30	MODULE_TRANSACTION_PREFIX,
31	MULTISIG_TRANSACTION_PREFIX,
32	TRANSACTION_ID_SEPARATOR,
33	TRANSFER_PREFIX,
34	} from './constants';
35	import { ModuleTransactionDetailsMapper } from './mappers/module-transactions/module-transaction-details.mapper';	60✔
36	import { TransactionDetails } from './entities/transaction-details/transaction-details.entity';
37	import { TransferDetailsMapper } from './mappers/transfers/transfer-details.mapper';	60✔
38	import { MultisigTransactionDetailsMapper } from './mappers/multisig-transactions/multisig-transaction-details.mapper';	60✔
39
40	@Injectable()
41	export class TransactionsService {	60✔
42	constructor(
43	@Inject(ISafeRepository) private readonly safeRepository: SafeRepository,	428✔
44	private readonly multisigTransactionMapper: MultisigTransactionMapper,	428✔
45	private readonly incomingTransferMapper: IncomingTransferMapper,	428✔
46	private readonly moduleTransactionMapper: ModuleTransactionMapper,	428✔
47	private readonly queuedItemsMapper: QueuedItemsMapper,	428✔
48	private readonly transactionsHistoryMapper: TransactionsHistoryMapper,	428✔
49	private readonly transactionPreviewMapper: TransactionPreviewMapper,	428✔
50	private readonly moduleTransactionDetailsMapper: ModuleTransactionDetailsMapper,	428✔
51	private readonly multisigTransactionDetailsMapper: MultisigTransactionDetailsMapper,	428✔
52	private readonly transferDetailsMapper: TransferDetailsMapper,	428✔
53	) {}
54
55	async getById(args: {
56	chainId: string;
57	txId: string;
58	}): Promise<TransactionDetails> {
59	const [txType, safeAddress, id] = args.txId.split(TRANSACTION_ID_SEPARATOR);	20✔
60
61	switch (txType) {	20✔
62	case MODULE_TRANSACTION_PREFIX: {
63	const [tx] = await Promise.all([	8✔
64	this.safeRepository.getModuleTransaction({
65	chainId: args.chainId,
66	moduleTransactionId: id,
67	}),
68	]);
69	return this.moduleTransactionDetailsMapper.mapDetails(args.chainId, tx);	2✔
70	}
71
72	case TRANSFER_PREFIX: {
73	const [transfer, safe] = await Promise.all([	4✔
74	this.safeRepository.getTransfer({
75	chainId: args.chainId,
76	transferId: id,
77	}),
78	this.safeRepository.getSafe({
79	chainId: args.chainId,
80	address: safeAddress,
81	}),
82	]);
83	return this.transferDetailsMapper.mapDetails(	2✔
84	args.chainId,
85	transfer,
86	safe,
87	);
88	}
89
90	case MULTISIG_TRANSACTION_PREFIX: {
91	const [tx, safe] = await Promise.all([	6✔
92	this.safeRepository.getMultiSigTransaction({
93	chainId: args.chainId,
94	safeTransactionHash: id,
95	}),
96	this.safeRepository.getSafe({
97	chainId: args.chainId,
98	address: safeAddress,
99	}),
100	]);
101	return this.multisigTransactionDetailsMapper.mapDetails(	4✔
102	args.chainId,
103	tx,
104	safe,
105	);
106	}
107
108	// txId is safeTxHash
109	default: {
110	const tx = await this.safeRepository.getMultiSigTransaction({	2✔
111	chainId: args.chainId,
112	safeTransactionHash: args.txId,
113	});
114	const safe = await this.safeRepository.getSafe({	2✔
115	chainId: args.chainId,
116	address: tx.safe,
117	});
118	return this.multisigTransactionDetailsMapper.mapDetails(	2✔
119	args.chainId,
120	tx,
121	safe,
122	);
123	}
124	}
125	}
126
127	async getMultisigTransactions(args: {
128	chainId: string;
129	routeUrl: Readonly<URL>;
130	paginationData: PaginationData;
131	safeAddress: string;
132	executionDateGte?: string;
133	executionDateLte?: string;
134	to?: string;
135	value?: string;
136	nonce?: string;
137	executed?: boolean;
138	}): Promise<Partial<Page<MultisigTransaction>>> {
139	const domainTransactions =
140	await this.safeRepository.getMultisigTransactions({	14✔
141	...args,
142	limit: args.paginationData.limit,
143	offset: args.paginationData.offset,
144	});
145
146	const safeInfo = await this.safeRepository.getSafe({	6✔
147	chainId: args.chainId,
148	address: args.safeAddress,
149	});
150	const results = await Promise.all(	6✔
151	domainTransactions.results.map(
152	async (domainTransaction) =>
153	new MultisigTransaction(	6✔
154	await this.multisigTransactionMapper.mapTransaction(
155	args.chainId,
156	domainTransaction,
157	safeInfo,
158	),
159	ConflictType.None,
160	),
161	),
162	);
163	const nextURL = cursorUrlFromLimitAndOffset(	6✔
164	args.routeUrl,
165	domainTransactions.next,
166	);
167	const previousURL = cursorUrlFromLimitAndOffset(	6✔
168	args.routeUrl,
169	domainTransactions.previous,
170	);
171
172	return {	6✔
173	next: nextURL?.toString() ?? null,	17✔
174	previous: previousURL?.toString() ?? null,	17✔
175	results,
176	};
177	}
178
179	async addConfirmation(args: {
180	chainId: string;
181	safeTxHash: string;
182	addConfirmationDto: AddConfirmationDto;
183	}): Promise<TransactionDetails> {
184	await this.safeRepository.addConfirmation(args);	2✔
185	const transaction = await this.safeRepository.getMultiSigTransaction({	2✔
186	chainId: args.chainId,
187	safeTransactionHash: args.safeTxHash,
188	});
189	const safe = await this.safeRepository.getSafe({	2✔
190	chainId: args.chainId,
191	address: transaction.safe,
192	});
193
194	return this.multisigTransactionDetailsMapper.mapDetails(	2✔
195	args.chainId,
196	transaction,
197	safe,
198	);
199	}
200
201	async getModuleTransactions(args: {
202	chainId: string;
203	routeUrl: Readonly<URL>;
204	safeAddress: string;
205	to?: string;
206	module?: string;
207	paginationData?: PaginationData;
208	}): Promise<Page<ModuleTransaction>> {
209	const domainTransactions = await this.safeRepository.getModuleTransactions({	10✔
210	...args,
211	limit: args.paginationData?.limit,	15!
212	offset: args.paginationData?.offset,	15!
213	});
214
215	const results = await Promise.all(	2✔
216	domainTransactions.results.map(
217	async (domainTransaction) =>
218	new ModuleTransaction(	4✔
219	await this.moduleTransactionMapper.mapTransaction(
220	args.chainId,
221	domainTransaction,
222	),
223	),
224	),
225	);
226	const nextURL = cursorUrlFromLimitAndOffset(	2✔
227	args.routeUrl,
228	domainTransactions.next,
229	);
230	const previousURL = cursorUrlFromLimitAndOffset(	2✔
231	args.routeUrl,
232	domainTransactions.previous,
233	);
234
235	return <Page<ModuleTransaction>>{	2✔
236	next: nextURL?.toString() ?? null,	5!
237	previous: previousURL?.toString() ?? null,	5!
238	results,
239	};
240	}
241
242	async getIncomingTransfers(args: {
243	chainId: string;
244	routeUrl: Readonly<URL>;
245	safeAddress: string;
246	executionDateGte?: string;
247	executionDateLte?: string;
248	to?: string;
249	value?: string;
250	tokenAddress?: string;
251	paginationData?: PaginationData;
252	}): Promise<Partial<Page<IncomingTransfer>>> {
253	const transfers = await this.safeRepository.getIncomingTransfers({	14✔
254	...args,
255	limit: args.paginationData?.limit,	21!
256	offset: args.paginationData?.offset,	21!
257	});
258
259	const safeInfo = await this.safeRepository.getSafe({	6✔
260	chainId: args.chainId,
261	address: args.safeAddress,
262	});
263	const results = await Promise.all(	6✔
264	transfers.results.map(
265	async (transfer) =>
266	new IncomingTransfer(	6✔
267	await this.incomingTransferMapper.mapTransfer(
268	args.chainId,
269	transfer,
270	safeInfo,
271	),
272	),
273	),
274	);
275
276	const nextURL = cursorUrlFromLimitAndOffset(args.routeUrl, transfers.next);	6✔
277	const previousURL = cursorUrlFromLimitAndOffset(	6✔
278	args.routeUrl,
279	transfers.previous,
280	);
281
282	return {	6✔
283	next: nextURL?.toString() ?? null,	18!
284	previous: previousURL?.toString() ?? null,	18!
285	results,
286	};
287	}
288
289	async previewTransaction(args: {
290	chainId: string;
291	safeAddress: string;
292	previewTransactionDto: PreviewTransactionDto;
293	}): Promise<TransactionPreview> {
294	const safe = await this.safeRepository.getSafe({	8✔
295	chainId: args.chainId,
296	address: args.safeAddress,
297	});
298	return this.transactionPreviewMapper.mapTransactionPreview(	8✔
299	args.chainId,
300	safe,
301	args.previewTransactionDto,
302	);
303	}
304
305	async getTransactionQueue(args: {
306	chainId: string;
307	routeUrl: Readonly<URL>;
308	safeAddress: string;
309	paginationData: PaginationData;
310	trusted?: boolean;
311	}): Promise<Page<QueuedItem>> {
312	const pagination = this.getAdjustedPaginationForQueue(args.paginationData);	8✔
313	const safeInfo = await this.safeRepository.getSafe({	8✔
314	chainId: args.chainId,
315	address: args.safeAddress,
316	});
317	const transactions = await this.safeRepository.getTransactionQueue({	8✔
318	chainId: args.chainId,
319	safe: safeInfo,
320	limit: pagination.limit,
321	offset: pagination.offset,
322	trusted: args.trusted,
323	});
324
325	const nextURL = buildNextPageURL(args.routeUrl, transactions.count);	6✔
326	const previousURL = buildPreviousPageURL(args.routeUrl);	6✔
327	const results = await this.queuedItemsMapper.getQueuedItems(	6✔
328	this.adjustTransactionsPage(transactions),
329	safeInfo,
330	args.chainId,
331	this.getPreviousPageLastNonce(transactions, args.paginationData),
332	this.getNextPageFirstNonce(transactions),
333	);
334
335	return {	6✔
336	count: results.length,
337	next: nextURL?.toString() ?? null,	16✔
338	previous: previousURL?.toString() ?? null,	16✔
339	results,
340	};
341	}
342
343	private getAdjustedPaginationForHistory(
344	paginationData: PaginationData,
345	): PaginationData {
346	if (paginationData.offset > 0) {	18✔
347	return new PaginationData(	2✔
348	paginationData.limit + 1,
349	paginationData.offset - 1,
350	);
351	}
352	return paginationData;	16✔
353	}
354
355	async getTransactionHistory(args: {
356	chainId: string;
357	routeUrl: Readonly<URL>;
358	safeAddress: string;
359	paginationData: PaginationData;
360	timezoneOffset: number;
361	}): Promise<TransactionItemPage> {
362	const paginationDataAdjusted = this.getAdjustedPaginationForHistory(	18✔
363	args.paginationData,
364	);
365	const domainTransactions = await this.safeRepository.getTransactionHistory({	18✔
366	chainId: args.chainId,
367	safeAddress: args.safeAddress,
368	limit: paginationDataAdjusted.limit,
369	offset: paginationDataAdjusted.offset,
370	});
371	const nextURL = buildNextPageURL(args.routeUrl, domainTransactions.count);	12✔
372	const previousURL = buildPreviousPageURL(args.routeUrl);	12✔
373	if (nextURL == null) {	12✔
374	const creationTransaction =
375	await this.safeRepository.getCreationTransaction({	4✔
376	chainId: args.chainId,
377	safeAddress: args.safeAddress,
378	});
379	domainTransactions.results.push(creationTransaction);	4✔
380	}
381	const safeInfo = await this.safeRepository.getSafe({	12✔
382	chainId: args.chainId,
383	address: args.safeAddress,
384	});
385	const results = await this.transactionsHistoryMapper.mapTransactionsHistory(	12✔
386	args.chainId,
387	domainTransactions.results,
388	safeInfo,
389	args.paginationData.offset,
390	args.timezoneOffset,
391	);
392
393	return {	12✔
394	count: domainTransactions.count,
395	next: nextURL?.toString() ?? null,	34✔
396	previous: previousURL?.toString() ?? null,	31✔
397	results,
398	};
399	}
400
401	async proposeTransaction(args: {
402	chainId: string;
403	safeAddress: string;
404	proposeTransactionDto: ProposeTransactionDto;
405	}): Promise<TransactionDetails> {
406	await this.safeRepository.proposeTransaction(args);	2✔
407
408	const safe = await this.safeRepository.getSafe({	2✔
409	chainId: args.chainId,
410	address: args.safeAddress,
411	});
412	const domainTransaction = await this.safeRepository.getMultiSigTransaction({	2✔
413	chainId: args.chainId,
414	safeTransactionHash: args.proposeTransactionDto.safeTxHash,
415	});
416
417	return this.multisigTransactionDetailsMapper.mapDetails(	2✔
418	args.chainId,
419	domainTransaction,
420	safe,
421	);
422	}
423
424	/**
425	* Adjusts the pagination data to return extra items in both "edges" of the current page:
426	* - If no pagination data info, then return the original pagination data.
427	* - If it is the first page (offset 0), then return offset: 0, limit: limit + 1.
428	* - If it is not the first page, then return offset: offset - 1, limit: limit + 2.
429	* @param paginationData pagination data to adjust.
430	* @returns pagination data adjusted.
431	*/
432	private getAdjustedPaginationForQueue(
433	paginationData: PaginationData,
434	): PaginationData {
435	if (!paginationData.limit \|\| !paginationData.offset) {	8✔
436	return paginationData;	6✔
437	}
438	if (paginationData.offset === 0) {	2!
UNCOV 439	return new PaginationData(	×
440	paginationData.limit + 1,
441	paginationData.offset,
442	);
443	} else {
444	return new PaginationData(	2✔
445	paginationData.limit + 2,
446	paginationData.offset - 1,
447	);
448	}
449	}
450
451	private getNextPageFirstNonce(
452	page: Page<DomainMultisigTransaction>,
453	): number \| null {
454	return this.hasNextPage(page) ? this.getLastTransactionNonce(page) : null;	6✔
455	}
456
457	private getPreviousPageLastNonce(
458	page: Page<DomainMultisigTransaction>,
459	paginationData?: PaginationData,
460	): number \| null {
461	return paginationData && paginationData.offset	6✔
462	? this.getFirstTransactionNonce(page)
463	: null;
464	}
465
466	/**
467	* If the page has next page, returns a copy of the original transactions page without its last element.
468	* Otherwise the original page of transactions is returned.
469	*
470	* @param page page of Transactions.
471	* @returns transactions array without its first element if there is next page.
472	*/
473	private adjustTransactionsPage(
474	page: Page<DomainMultisigTransaction>,
475	): Page<DomainMultisigTransaction> {
476	return this.hasNextPage(page)	6✔
477	? { ...page, results: page.results.slice(0, -1) }
478	: page;
479	}
480
481	/**
482	* Checks the if page contains a next cursor.
483	*/
484	private hasNextPage(page: Page<DomainMultisigTransaction>): boolean {
485	return page.next !== null;	12✔
486	}
487
488	private getFirstTransactionNonce(
489	page: Page<DomainMultisigTransaction>,
490	): number \| null {
491	return head(page.results)?.nonce ?? null;	2!
492	}
493
494	private getLastTransactionNonce(
495	page: Page<DomainMultisigTransaction>,
496	): number \| null {
497	return last(page.results)?.nonce ?? null;	2!
498	}
499	}

safe-global / safe-client-gateway / 6083860467

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