9420615232

Committed 07 Jun 2024 04:50PM UTC coverage: 92.771% (-0.03%) from 92.796%

Build # 9420615232

Build Type

push

github

Committed by

web-flow

Commit Message

Fix getAddress unhandled error in TransactionsService (#1621)

Fix viem getAddress unhandled error

Run Details

1997 of 2451 branches covered (81.48%)

Branch coverage included in aggregate %.

4 of 6 new or added lines in 1 file covered. (66.67%)

1 existing line in 1 file now uncovered.

7128 of 7385 relevant lines covered (96.52%)

334.66 hits per line

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

88.1

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

import { BadRequestException, Inject, Injectable } from '@nestjs/common';
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 { ProposeTransactionDto } from '@/domain/transactions/entities/propose-transaction.dto.entity';
import { Page } from '@/routes/common/entities/page.entity';
import {
  buildNextPageURL,
  buildPreviousPageURL,
  cursorUrlFromLimitAndOffset,
  PaginationData,
} from '@/routes/common/pagination/pagination.data';
import {
  MODULE_TRANSACTION_PREFIX,
  MULTISIG_TRANSACTION_PREFIX,
  TRANSACTION_ID_SEPARATOR,
  TRANSFER_PREFIX,
} from '@/routes/transactions/constants';
import { ConflictType } from '@/routes/transactions/entities/conflict-type.entity';
import { IncomingTransfer } from '@/routes/transactions/entities/incoming-transfer.entity';
import { ModuleTransaction } from '@/routes/transactions/entities/module-transaction.entity';
import { MultisigTransaction } from '@/routes/transactions/entities/multisig-transaction.entity';
import { PreviewTransactionDto } from '@/routes/transactions/entities/preview-transaction.dto.entity';
import { QueuedItem } from '@/routes/transactions/entities/queued-item.entity';
import { TransactionDetails } from '@/routes/transactions/entities/transaction-details/transaction-details.entity';
import { TransactionItemPage } from '@/routes/transactions/entities/transaction-item-page.entity';
import { TransactionPreview } from '@/routes/transactions/entities/transaction-preview.entity';
import { ModuleTransactionDetailsMapper } from '@/routes/transactions/mappers/module-transactions/module-transaction-details.mapper';
import { ModuleTransactionMapper } from '@/routes/transactions/mappers/module-transactions/module-transaction.mapper';
import { MultisigTransactionDetailsMapper } from '@/routes/transactions/mappers/multisig-transactions/multisig-transaction-details.mapper';
import { MultisigTransactionMapper } from '@/routes/transactions/mappers/multisig-transactions/multisig-transaction.mapper';
import { QueuedItemsMapper } from '@/routes/transactions/mappers/queued-items/queued-items.mapper';
import { TransactionPreviewMapper } from '@/routes/transactions/mappers/transaction-preview.mapper';
import { TransactionsHistoryMapper } from '@/routes/transactions/mappers/transactions-history.mapper';
import { TransferDetailsMapper } from '@/routes/transactions/mappers/transfers/transfer-details.mapper';
import { TransferMapper } from '@/routes/transactions/mappers/transfers/transfer.mapper';
import { getAddress, isAddress } from 'viem';

@Injectable()
export class TransactionsService {
  constructor(
    @Inject(ISafeRepository) private readonly safeRepository: SafeRepository,
    private readonly multisigTransactionMapper: MultisigTransactionMapper,
    private readonly transferMapper: TransferMapper,
    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: {
        if (!isAddress(safeAddress)) {
          throw new BadRequestException('Invalid transaction ID');
        }

        const [transfer, safe] = await Promise.all([
          this.safeRepository.getTransfer({
            chainId: args.chainId,
            transferId: id,
          }),
          this.safeRepository.getSafe({
            chainId: args.chainId,
            // We can't checksum outside of case as some IDs don't contain addresses
            address: getAddress(safeAddress),
          }),
        ]);
        return this.transferDetailsMapper.mapDetails(
          args.chainId,
          transfer,
          safe,
        );
      }

      case MULTISIG_TRANSACTION_PREFIX: {
        if (!isAddress(safeAddress)) {
          throw new BadRequestException('Invalid transaction ID');
        }

        const [tx, safe] = await Promise.all([
          this.safeRepository.getMultiSigTransaction({
            chainId: args.chainId,
            safeTransactionHash: id,
          }),
          this.safeRepository.getSafe({
            chainId: args.chainId,
            // We can't checksum outside of case as some IDs don't contain addresses
            address: getAddress(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: `0x${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 deleteTransaction(args: {
    chainId: string;
    safeTxHash: string;
    signature: string;
  }): Promise<void> {
    return await this.safeRepository.deleteTransaction(args);
  }

  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: `0x${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 {
      count: domainTransactions.count,
      next: nextURL?.toString() ?? null,
      previous: previousURL?.toString() ?? null,
      results,
    };
  }

  async getIncomingTransfers(args: {
    chainId: string;
    routeUrl: Readonly<URL>;
    safeAddress: `0x${string}`;
    executionDateGte?: string;
    executionDateLte?: string;
    to?: string;
    value?: string;
    tokenAddress?: string;
    paginationData?: PaginationData;
    onlyTrusted: boolean;
  }): 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 this.transferMapper.mapTransfers({
        chainId: args.chainId,
        transfers: transfers.results,
        safe: safeInfo,
        onlyTrusted: args.onlyTrusted,
      })
    ).map((incomingTransfer) => new IncomingTransfer(incomingTransfer));

    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: `0x${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: `0x${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: `0x${string}`;
    paginationData: PaginationData;
    timezoneOffsetMs: number;
    onlyTrusted: boolean;
    showImitations: boolean;
  }): 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.timezoneOffsetMs,
      args.onlyTrusted,
      args.showImitations,
    );

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

  async proposeTransaction(args: {
    chainId: string;
    safeAddress: `0x${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 page.results[0]?.nonce ?? null;
  }

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

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

safe-global / safe-client-gateway / 9420615232

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