9479204226

Committed 12 Jun 2024 08:22AM UTC coverage: 92.711% (-0.02%) from 92.734%

Build # 9479204226

Build Type

Pull #1640

github

Committed by

iamacook

Commit Message

Merge branch 'main' into api-manager-interface

Pull Request Pull Request #1640: Standardise API managers, clearing on `CHAIN_UPDATE`

Run Details

2023 of 2485 branches covered (81.41%)

Branch coverage included in aggregate %.

79 of 81 new or added lines in 22 files covered. (97.53%)

1 existing line in 1 file now uncovered.

7236 of 7502 relevant lines covered (96.45%)

327.84 hits per line

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

96.4

/src/domain/safe/safe.repository.ts

import { Inject, Injectable } from '@nestjs/common';
import { isEmpty } from 'lodash';
import { Page } from '@/domain/entities/page.entity';
import { ITransactionApiManager } from '@/domain/interfaces/transaction-api.manager.interface';
import { CreationTransaction } from '@/domain/safe/entities/creation-transaction.entity';
import { ModuleTransaction } from '@/domain/safe/entities/module-transaction.entity';
import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
import { SafeList } from '@/domain/safe/entities/safe-list.entity';
import { Safe } from '@/domain/safe/entities/safe.entity';
import { Transaction } from '@/domain/safe/entities/transaction.entity';
import {
  Transfer,
  TransferPageSchema,
  TransferSchema,
} from '@/domain/safe/entities/transfer.entity';
import {
  ModuleTransactionPageSchema,
  ModuleTransactionSchema,
} from '@/domain/safe/entities/module-transaction.entity';
import {
  MultisigTransactionPageSchema,
  MultisigTransactionSchema,
} from '@/domain/safe/entities/multisig-transaction.entity';
import { SafeListSchema } from '@/domain/safe/entities/schemas/safe-list.schema';
import { ISafeRepository } from '@/domain/safe/safe.repository.interface';
import { TransactionTypePageSchema } from '@/domain/safe/entities/schemas/transaction-type.schema';
import { AddConfirmationDto } from '@/domain/transactions/entities/add-confirmation.dto.entity';
import { ProposeTransactionDto } from '@/domain/transactions/entities/propose-transaction.dto.entity';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { IChainsRepository } from '@/domain/chains/chains.repository.interface';
import { CreationTransactionSchema } from '@/domain/safe/entities/schemas/creation-transaction.schema';
import { SafeSchema } from '@/domain/safe/entities/schemas/safe.schema';
import { z } from 'zod';

@Injectable()
export class SafeRepository implements ISafeRepository {
  constructor(
    @Inject(ITransactionApiManager)
    private readonly transactionApiManager: ITransactionApiManager,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    @Inject(IChainsRepository)
    private readonly chainsRepository: IChainsRepository,
  ) {}

  async getSafe(args: {
    chainId: string;
    address: `0x${string}`;
  }): Promise<Safe> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const safe = await transactionService.getSafe(args.address);
    return SafeSchema.parse(safe);
  }

  async isSafe(args: {
    chainId: string;
    address: `0x${string}`;
  }): Promise<boolean> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const isSafe = await transactionService.isSafe(args.address);
    return z.boolean().parse(isSafe);
  }

  async clearIsSafe(args: {
    chainId: string;
    address: `0x${string}`;
  }): Promise<void> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    return transactionService.clearIsSafe(args.address);
  }

  async clearSafe(args: {
    chainId: string;
    address: `0x${string}`;
  }): Promise<void> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    return transactionService.clearSafe(args.address);
  }

  async isOwner(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    address: `0x${string}`;
  }): Promise<boolean> {
    const safe = await this.getSafe({
      chainId: args.chainId,
      address: args.safeAddress,
    });
    return safe.owners.includes(args.address);
  }

  async getCollectibleTransfers(args: {
    chainId: string;
    safeAddress: string;
    limit?: number;
    offset?: number;
  }): Promise<Page<Transfer>> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );

    const page = await transactionService.getTransfers({
      ...args,
      onlyErc721: true,
    });
    return TransferPageSchema.parse(page);
  }

  async clearTransfers(args: {
    chainId: string;
    safeAddress: string;
  }): Promise<void> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );

    return transactionService.clearTransfers(args.safeAddress);
  }

  async getIncomingTransfers(args: {
    chainId: string;
    safeAddress: string;
    executionDateGte?: string;
    executionDateLte?: string;
    to?: string;
    value?: string;
    tokenAddress?: string;
    limit?: number;
    offset?: number;
  }): Promise<Page<Transfer>> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const page = await transactionService.getIncomingTransfers(args);
    return TransferPageSchema.parse(page);
  }

  async clearIncomingTransfers(args: {
    chainId: string;
    safeAddress: string;
  }): Promise<void> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );

    return transactionService.clearIncomingTransfers(args.safeAddress);
  }

  async addConfirmation(args: {
    chainId: string;
    safeTxHash: string;
    addConfirmationDto: AddConfirmationDto;
  }): Promise<void> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    await transactionService.postConfirmation(args);
  }

  async getModuleTransaction(args: {
    chainId: string;
    moduleTransactionId: string;
  }): Promise<ModuleTransaction> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const moduleTransaction = await transactionService.getModuleTransaction(
      args.moduleTransactionId,
    );
    return ModuleTransactionSchema.parse(moduleTransaction);
  }

  async getModuleTransactions(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    to?: string;
    txHash?: string;
    module?: string;
    limit?: number;
    offset?: number;
  }): Promise<Page<ModuleTransaction>> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const page = await transactionService.getModuleTransactions(args);
    return ModuleTransactionPageSchema.parse(page);
  }

  async clearModuleTransactions(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<void> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );

    return transactionService.clearModuleTransactions(args.safeAddress);
  }

  async getTransactionQueue(args: {
    chainId: string;
    safe: Safe;
    limit?: number;
    offset?: number;
    trusted?: boolean;
  }): Promise<Page<MultisigTransaction>> {
    return this._getTransactionQueue({
      ...args,
      ordering: 'nonce,submissionDate',
    });
  }

  async getTransactionQueueByModified(args: {
    chainId: string;
    safe: Safe;
    limit?: number;
    offset?: number;
  }): Promise<Page<MultisigTransaction>> {
    return this._getTransactionQueue({
      ...args,
      ordering: '-modified',
    });
  }

  private async _getTransactionQueue(args: {
    chainId: string;
    safe: Safe;
    ordering: string;
    limit?: number;
    offset?: number;
    trusted?: boolean;
  }): Promise<Page<MultisigTransaction>> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const page: Page<MultisigTransaction> =
      await transactionService.getMultisigTransactions({
        ...args,
        safeAddress: args.safe.address,
        executed: false,
        nonceGte: args.safe.nonce,
      });
    return MultisigTransactionPageSchema.parse(page);
  }

  async getCreationTransaction(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<CreationTransaction> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const createTransaction = await transactionService.getCreationTransaction(
      args.safeAddress,
    );
    return CreationTransactionSchema.parse(createTransaction);
  }

  async getTransactionHistory(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    limit?: number;
    offset?: number;
  }): Promise<Page<Transaction>> {
    return this.getAllExecutedTransactions(args);
  }

  private async getAllExecutedTransactions(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    ordering?: string;
    limit?: number;
    offset?: number;
  }): Promise<Page<Transaction>> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const page: Page<Transaction> = await transactionService.getAllTransactions(
      {
        ...args,
        executed: true,
        queued: false,
      },
    );
    return TransactionTypePageSchema.parse(page);
  }

  async clearAllExecutedTransactions(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<void> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );

    return transactionService.clearAllTransactions(args.safeAddress);
  }

  async clearMultisigTransaction(args: {
    chainId: string;
    safeTransactionHash: string;
  }): Promise<void> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    return transactionService.clearMultisigTransaction(
      args.safeTransactionHash,
    );
  }

  async getMultiSigTransaction(args: {
    chainId: string;
    safeTransactionHash: string;
  }): Promise<MultisigTransaction> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const multiSigTransaction = await transactionService.getMultisigTransaction(
      args.safeTransactionHash,
    );

    return MultisigTransactionSchema.parse(multiSigTransaction);
  }

  async deleteTransaction(args: {
    chainId: string;
    safeTxHash: string;
    signature: string;
  }): Promise<void> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const { safe } = await transactionService.getMultisigTransaction(
      args.safeTxHash,
    );
    await transactionService.deleteTransaction(args);

    // Ensure transaction is removed from cache in case event is not received
    Promise.all([
      transactionService.clearMultisigTransaction(args.safeTxHash),
      transactionService.clearMultisigTransactions(safe),
    ]).catch(() => {
      this.loggingService.warn(
        'Failed to immediately clear deleted transaction from cache',
      );
    });
  }

  async clearMultisigTransactions(args: {
    chainId: string;
    safeAddress: string;
  }): Promise<void> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    return transactionService.clearMultisigTransactions(args.safeAddress);
  }

  async getMultisigTransactions(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    executed?: boolean;
    executionDateGte?: string;
    executionDateLte?: string;
    to?: string;
    value?: string;
    nonce?: string;
    nonceGte?: number;
    limit?: number;
    offset?: number;
  }): Promise<Page<MultisigTransaction>> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const page = await transactionService.getMultisigTransactions({
      ...args,
      ordering: '-nonce',
      trusted: true,
    });
    return MultisigTransactionPageSchema.parse(page);
  }

  async getTransfer(args: {
    chainId: string;
    transferId: string;
  }): Promise<Transfer> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const transfer = await transactionService.getTransfer(args.transferId);
    return TransferSchema.parse(transfer);
  }

  async getTransfers(args: {
    chainId: string;
    safeAddress: string;
    limit?: number | undefined;
  }): Promise<Page<Transfer>> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const page = await transactionService.getTransfers(args);
    return TransferPageSchema.parse(page);
  }

  async getSafesByOwner(args: {
    chainId: string;
    ownerAddress: `0x${string}`;
  }): Promise<SafeList> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const safeList = await transactionService.getSafesByOwner(
      args.ownerAddress,
    );

    return SafeListSchema.parse(safeList);
  }

  async getAllSafesByOwner(args: {
    ownerAddress: `0x${string}`;
  }): Promise<{ [chainId: string]: Array<string> }> {
    // Note: does not take pagination into account but we do not support
    // enough chains for it to be an issue
    const { results } = await this.chainsRepository.getChains();
    const allSafeLists = await Promise.all(
      results.map(async ({ chainId }) => {
        const safeList = await this.getSafesByOwner({
          chainId,
          ownerAddress: args.ownerAddress,
        });

        return {
          chainId,
          safeList,
        };
      }),
    );

    return allSafeLists.reduce((acc, { chainId, safeList }) => {
      return {
        ...acc,
        [chainId]: safeList.safes,
      };
    }, {});
  }

  async getLastTransactionSortedByNonce(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<MultisigTransaction | null> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const page: Page<Transaction> =
      await transactionService.getMultisigTransactions({
        ...args,
        ordering: '-nonce',
        trusted: true,
        limit: 1,
      });

    return isEmpty(page.results)
      ? null
      : MultisigTransactionSchema.parse(page.results[0]);
  }

  async proposeTransaction(args: {
    chainId: string;
    safeAddress: string;
    proposeTransactionDto: ProposeTransactionDto;
  }): Promise<unknown> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );

    return transactionService.postMultisigTransaction({
      address: args.safeAddress,
      data: args.proposeTransactionDto,
    });
  }

  async getNonces(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<{ currentNonce: number; recommendedNonce: number }> {
    const safe = await this.getSafe({
      chainId: args.chainId,
      address: args.safeAddress,
    });

    const lastTransaction = await this.getLastTransactionSortedByNonce({
      chainId: args.chainId,
      safeAddress: args.safeAddress,
    });

    const recommendedNonce = lastTransaction
      ? Math.max(safe.nonce, lastTransaction.nonce + 1)
      : safe.nonce;

    return {
      currentNonce: safe.nonce,
      recommendedNonce: recommendedNonce,
    };
  }

  async getSafesByModule(args: {
    chainId: string;
    moduleAddress: string;
  }): Promise<SafeList> {
    const transactionService = await this.transactionApiManager.getApi(
      args.chainId,
    );
    const safesByModule = await transactionService.getSafesByModule(
      args.moduleAddress,
    );

    return SafeListSchema.parse(safesByModule);
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	108✔
2	import { isEmpty } from 'lodash';	108✔
3	import { Page } from '@/domain/entities/page.entity';
4	import { ITransactionApiManager } from '@/domain/interfaces/transaction-api.manager.interface';	108✔
5	import { CreationTransaction } from '@/domain/safe/entities/creation-transaction.entity';
6	import { ModuleTransaction } from '@/domain/safe/entities/module-transaction.entity';
7	import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
8	import { SafeList } from '@/domain/safe/entities/safe-list.entity';
9	import { Safe } from '@/domain/safe/entities/safe.entity';
10	import { Transaction } from '@/domain/safe/entities/transaction.entity';
11	import {	108✔
12	Transfer,
13	TransferPageSchema,
14	TransferSchema,
15	} from '@/domain/safe/entities/transfer.entity';
16	import {	108✔
17	ModuleTransactionPageSchema,
18	ModuleTransactionSchema,
19	} from '@/domain/safe/entities/module-transaction.entity';
20	import {	108✔
21	MultisigTransactionPageSchema,
22	MultisigTransactionSchema,
23	} from '@/domain/safe/entities/multisig-transaction.entity';
24	import { SafeListSchema } from '@/domain/safe/entities/schemas/safe-list.schema';	108✔
25	import { ISafeRepository } from '@/domain/safe/safe.repository.interface';
26	import { TransactionTypePageSchema } from '@/domain/safe/entities/schemas/transaction-type.schema';	108✔
27	import { AddConfirmationDto } from '@/domain/transactions/entities/add-confirmation.dto.entity';
28	import { ProposeTransactionDto } from '@/domain/transactions/entities/propose-transaction.dto.entity';
29	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	108✔
30	import { IChainsRepository } from '@/domain/chains/chains.repository.interface';	108✔
31	import { CreationTransactionSchema } from '@/domain/safe/entities/schemas/creation-transaction.schema';	108✔
32	import { SafeSchema } from '@/domain/safe/entities/schemas/safe.schema';	108✔
33	import { z } from 'zod';	108✔
34
35	@Injectable()
36	export class SafeRepository implements ISafeRepository {	108✔
37	constructor(
38	@Inject(ITransactionApiManager)
39	private readonly transactionApiManager: ITransactionApiManager,	1,386✔
40	@Inject(LoggingService) private readonly loggingService: ILoggingService,	1,386✔
41	@Inject(IChainsRepository)
42	private readonly chainsRepository: IChainsRepository,	1,386✔
43	) {}
44
45	async getSafe(args: {
46	chainId: string;
47	address: `0x${string}`;
48	}): Promise<Safe> {
49	const transactionService = await this.transactionApiManager.getApi(	594✔
50	args.chainId,
51	);
52	const safe = await transactionService.getSafe(args.address);	594✔
53	return SafeSchema.parse(safe);	570✔
54	}
55
56	async isSafe(args: {
57	chainId: string;
58	address: `0x${string}`;
59	}): Promise<boolean> {
NEW 60	const transactionService = await this.transactionApiManager.getApi(	×
61	args.chainId,
62	);
63	const isSafe = await transactionService.isSafe(args.address);	×
64	return z.boolean().parse(isSafe);	×
65	}
66
67	async clearIsSafe(args: {
68	chainId: string;
69	address: `0x${string}`;
70	}): Promise<void> {
71	const transactionService = await this.transactionApiManager.getApi(	4✔
72	args.chainId,
73	);
74	return transactionService.clearIsSafe(args.address);	4✔
75	}
76
77	async clearSafe(args: {
78	chainId: string;
79	address: `0x${string}`;
80	}): Promise<void> {
81	const transactionService = await this.transactionApiManager.getApi(	40✔
82	args.chainId,
83	);
84	return transactionService.clearSafe(args.address);	40✔
85	}
86
87	async isOwner(args: {
88	chainId: string;
89	safeAddress: `0x${string}`;
90	address: `0x${string}`;
91	}): Promise<boolean> {
92	const safe = await this.getSafe({	18✔
93	chainId: args.chainId,
94	address: args.safeAddress,
95	});
96	return safe.owners.includes(args.address);	18✔
97	}
98
99	async getCollectibleTransfers(args: {
100	chainId: string;
101	safeAddress: string;
102	limit?: number;
103	offset?: number;
104	}): Promise<Page<Transfer>> {
105	const transactionService = await this.transactionApiManager.getApi(	56✔
106	args.chainId,
107	);
108
109	const page = await transactionService.getTransfers({	56✔
110	...args,
111	onlyErc721: true,
112	});
113	return TransferPageSchema.parse(page);	50✔
114	}
115
116	async clearTransfers(args: {
117	chainId: string;
118	safeAddress: string;
119	}): Promise<void> {
120	const transactionService = await this.transactionApiManager.getApi(	90✔
121	args.chainId,
122	);
123
124	return transactionService.clearTransfers(args.safeAddress);	90✔
125	}
126
127	async getIncomingTransfers(args: {
128	chainId: string;
129	safeAddress: string;
130	executionDateGte?: string;
131	executionDateLte?: string;
132	to?: string;
133	value?: string;
134	tokenAddress?: string;
135	limit?: number;
136	offset?: number;
137	}): Promise<Page<Transfer>> {
138	const transactionService = await this.transactionApiManager.getApi(	18✔
139	args.chainId,
140	);
141	const page = await transactionService.getIncomingTransfers(args);	16✔
142	return TransferPageSchema.parse(page);	14✔
143	}
144
145	async clearIncomingTransfers(args: {
146	chainId: string;
147	safeAddress: string;
148	}): Promise<void> {
149	const transactionService = await this.transactionApiManager.getApi(	36✔
150	args.chainId,
151	);
152
153	return transactionService.clearIncomingTransfers(args.safeAddress);	36✔
154	}
155
156	async addConfirmation(args: {
157	chainId: string;
158	safeTxHash: string;
159	addConfirmationDto: AddConfirmationDto;
160	}): Promise<void> {
161	const transactionService = await this.transactionApiManager.getApi(	2✔
162	args.chainId,
163	);
164	await transactionService.postConfirmation(args);	2✔
165	}
166
167	async getModuleTransaction(args: {
168	chainId: string;
169	moduleTransactionId: string;
170	}): Promise<ModuleTransaction> {
171	const transactionService = await this.transactionApiManager.getApi(	8✔
172	args.chainId,
173	);
174	const moduleTransaction = await transactionService.getModuleTransaction(	6✔
175	args.moduleTransactionId,
176	);
177	return ModuleTransactionSchema.parse(moduleTransaction);	2✔
178	}
179
180	async getModuleTransactions(args: {
181	chainId: string;
182	safeAddress: `0x${string}`;
183	to?: string;
184	txHash?: string;
185	module?: string;
186	limit?: number;
187	offset?: number;
188	}): Promise<Page<ModuleTransaction>> {
189	const transactionService = await this.transactionApiManager.getApi(	66✔
190	args.chainId,
191	);
192	const page = await transactionService.getModuleTransactions(args);	64✔
193	return ModuleTransactionPageSchema.parse(page);	58✔
194	}
195
196	async clearModuleTransactions(args: {
197	chainId: string;
198	safeAddress: `0x${string}`;
199	}): Promise<void> {
200	const transactionService = await this.transactionApiManager.getApi(	14✔
201	args.chainId,
202	);
203
204	return transactionService.clearModuleTransactions(args.safeAddress);	14✔
205	}
206
207	async getTransactionQueue(args: {
208	chainId: string;
209	safe: Safe;
210	limit?: number;
211	offset?: number;
212	trusted?: boolean;
213	}): Promise<Page<MultisigTransaction>> {
214	return this._getTransactionQueue({	42✔
215	...args,
216	ordering: 'nonce,submissionDate',
217	});
218	}
219
220	async getTransactionQueueByModified(args: {
221	chainId: string;
222	safe: Safe;
223	limit?: number;
224	offset?: number;
225	}): Promise<Page<MultisigTransaction>> {
226	return this._getTransactionQueue({	56✔
227	...args,
228	ordering: '-modified',
229	});
230	}
231
232	private async _getTransactionQueue(args: {
233	chainId: string;
234	safe: Safe;
235	ordering: string;
236	limit?: number;
237	offset?: number;
238	trusted?: boolean;
239	}): Promise<Page<MultisigTransaction>> {
240	const transactionService = await this.transactionApiManager.getApi(	98✔
241	args.chainId,
242	);
243	const page: Page<MultisigTransaction> =
244	await transactionService.getMultisigTransactions({	98✔
245	...args,
246	safeAddress: args.safe.address,
247	executed: false,
248	nonceGte: args.safe.nonce,
249	});
250	return MultisigTransactionPageSchema.parse(page);	90✔
251	}
252
253	async getCreationTransaction(args: {
254	chainId: string;
255	safeAddress: `0x${string}`;
256	}): Promise<CreationTransaction> {
257	const transactionService = await this.transactionApiManager.getApi(	4✔
258	args.chainId,
259	);
260	const createTransaction = await transactionService.getCreationTransaction(	4✔
261	args.safeAddress,
262	);
263	return CreationTransactionSchema.parse(createTransaction);	4✔
264	}
265
266	async getTransactionHistory(args: {
267	chainId: string;
268	safeAddress: `0x${string}`;
269	limit?: number;
270	offset?: number;
271	}): Promise<Page<Transaction>> {
272	return this.getAllExecutedTransactions(args);	44✔
273	}
274
275	private async getAllExecutedTransactions(args: {
276	chainId: string;
277	safeAddress: `0x${string}`;
278	ordering?: string;
279	limit?: number;
280	offset?: number;
281	}): Promise<Page<Transaction>> {
282	const transactionService = await this.transactionApiManager.getApi(	44✔
283	args.chainId,
284	);
285	const page: Page<Transaction> = await transactionService.getAllTransactions(	42✔
286	{
287	...args,
288	executed: true,
289	queued: false,
290	},
291	);
292	return TransactionTypePageSchema.parse(page);	40✔
293	}
294
295	async clearAllExecutedTransactions(args: {
296	chainId: string;
297	safeAddress: `0x${string}`;
298	}): Promise<void> {
299	const transactionService = await this.transactionApiManager.getApi(	104✔
300	args.chainId,
301	);
302
303	return transactionService.clearAllTransactions(args.safeAddress);	104✔
304	}
305
306	async clearMultisigTransaction(args: {
307	chainId: string;
308	safeTransactionHash: string;
309	}): Promise<void> {
310	const transactionService = await this.transactionApiManager.getApi(	56✔
311	args.chainId,
312	);
313	return transactionService.clearMultisigTransaction(	56✔
314	args.safeTransactionHash,
315	);
316	}
317
318	async getMultiSigTransaction(args: {
319	chainId: string;
320	safeTransactionHash: string;
321	}): Promise<MultisigTransaction> {
322	const transactionService = await this.transactionApiManager.getApi(	12✔
323	args.chainId,
324	);
325	const multiSigTransaction = await transactionService.getMultisigTransaction(	12✔
326	args.safeTransactionHash,
327	);
328
329	return MultisigTransactionSchema.parse(multiSigTransaction);	10✔
330	}
331
332	async deleteTransaction(args: {
333	chainId: string;
334	safeTxHash: string;
335	signature: string;
336	}): Promise<void> {
337	const transactionService = await this.transactionApiManager.getApi(	6✔
338	args.chainId,
339	);
340	const { safe } = await transactionService.getMultisigTransaction(	6✔
341	args.safeTxHash,
342	);
343	await transactionService.deleteTransaction(args);	6✔
344
345	// Ensure transaction is removed from cache in case event is not received
346	Promise.all([	4✔
347	transactionService.clearMultisigTransaction(args.safeTxHash),
348	transactionService.clearMultisigTransactions(safe),
349	]).catch(() => {
350	this.loggingService.warn(	×
351	'Failed to immediately clear deleted transaction from cache',
352	);
353	});
354	}
355
356	async clearMultisigTransactions(args: {
357	chainId: string;
358	safeAddress: string;
359	}): Promise<void> {
360	const transactionService = await this.transactionApiManager.getApi(	120✔
361	args.chainId,
362	);
363	return transactionService.clearMultisigTransactions(args.safeAddress);	120✔
364	}
365
366	async getMultisigTransactions(args: {
367	chainId: string;
368	safeAddress: `0x${string}`;
369	executed?: boolean;
370	executionDateGte?: string;
371	executionDateLte?: string;
372	to?: string;
373	value?: string;
374	nonce?: string;
375	nonceGte?: number;
376	limit?: number;
377	offset?: number;
378	}): Promise<Page<MultisigTransaction>> {
379	const transactionService = await this.transactionApiManager.getApi(	80✔
380	args.chainId,
381	);
382	const page = await transactionService.getMultisigTransactions({	78✔
383	...args,
384	ordering: '-nonce',
385	trusted: true,
386	});
387	return MultisigTransactionPageSchema.parse(page);	68✔
388	}
389
390	async getTransfer(args: {
391	chainId: string;
392	transferId: string;
393	}): Promise<Transfer> {
394	const transactionService = await this.transactionApiManager.getApi(	4✔
395	args.chainId,
396	);
397	const transfer = await transactionService.getTransfer(args.transferId);	4✔
398	return TransferSchema.parse(transfer);	2✔
399	}
400
401	async getTransfers(args: {
402	chainId: string;
403	safeAddress: string;
404	limit?: number \| undefined;
405	}): Promise<Page<Transfer>> {
406	const transactionService = await this.transactionApiManager.getApi(	56✔
407	args.chainId,
408	);
409	const page = await transactionService.getTransfers(args);	56✔
410	return TransferPageSchema.parse(page);	50✔
411	}
412
413	async getSafesByOwner(args: {
414	chainId: string;
415	ownerAddress: `0x${string}`;
416	}): Promise<SafeList> {
417	const transactionService = await this.transactionApiManager.getApi(	14✔
418	args.chainId,
419	);
420	const safeList = await transactionService.getSafesByOwner(	12✔
421	args.ownerAddress,
422	);
423
424	return SafeListSchema.parse(safeList);	10✔
425	}
426
427	async getAllSafesByOwner(args: {
428	ownerAddress: `0x${string}`;
429	}): Promise<{ [chainId: string]: Array<string> }> {
430	// Note: does not take pagination into account but we do not support
431	// enough chains for it to be an issue
432	const { results } = await this.chainsRepository.getChains();	6✔
433	const allSafeLists = await Promise.all(	2✔
434	results.map(async ({ chainId }) => {
435	const safeList = await this.getSafesByOwner({	4✔
436	chainId,
437	ownerAddress: args.ownerAddress,
438	});
439
440	return {	4✔
441	chainId,
442	safeList,
443	};
444	}),
445	);
446
447	return allSafeLists.reduce((acc, { chainId, safeList }) => {	2✔
448	return {	4✔
449	...acc,
450	[chainId]: safeList.safes,
451	};
452	}, {});
453	}
454
455	async getLastTransactionSortedByNonce(args: {
456	chainId: string;
457	safeAddress: `0x${string}`;
458	}): Promise<MultisigTransaction \| null> {
459	const transactionService = await this.transactionApiManager.getApi(	14✔
460	args.chainId,
461	);
462	const page: Page<Transaction> =
463	await transactionService.getMultisigTransactions({	14✔
464	...args,
465	ordering: '-nonce',
466	trusted: true,
467	limit: 1,
468	});
469
470	return isEmpty(page.results)	14✔
471	? null
472	: MultisigTransactionSchema.parse(page.results[0]);
473	}
474
475	async proposeTransaction(args: {
476	chainId: string;
477	safeAddress: string;
478	proposeTransactionDto: ProposeTransactionDto;
479	}): Promise<unknown> {
480	const transactionService = await this.transactionApiManager.getApi(	2✔
481	args.chainId,
482	);
483
484	return transactionService.postMultisigTransaction({	2✔
485	address: args.safeAddress,
486	data: args.proposeTransactionDto,
487	});
488	}
489
490	async getNonces(args: {
491	chainId: string;
492	safeAddress: `0x${string}`;
493	}): Promise<{ currentNonce: number; recommendedNonce: number }> {
494	const safe = await this.getSafe({	14✔
495	chainId: args.chainId,
496	address: args.safeAddress,
497	});
498
499	const lastTransaction = await this.getLastTransactionSortedByNonce({	14✔
500	chainId: args.chainId,
501	safeAddress: args.safeAddress,
502	});
503
504	const recommendedNonce = lastTransaction	14✔
505	? Math.max(safe.nonce, lastTransaction.nonce + 1)
506	: safe.nonce;
507
508	return {	14✔
509	currentNonce: safe.nonce,
510	recommendedNonce: recommendedNonce,
511	};
512	}
513
514	async getSafesByModule(args: {
515	chainId: string;
516	moduleAddress: string;
517	}): Promise<SafeList> {
518	const transactionService = await this.transactionApiManager.getApi(	46✔
519	args.chainId,
520	);
521	const safesByModule = await transactionService.getSafesByModule(	36✔
522	args.moduleAddress,
523	);
524
525	return SafeListSchema.parse(safesByModule);	36✔
526	}
527	}

safe-global / safe-client-gateway / 9479204226

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