9448341807

Committed 10 Jun 2024 12:29PM UTC coverage: 92.718% (-0.009%) from 92.727%

Build # 9448341807

Build Type

Pull #1626

github

Committed by

iamacook

Commit Message

Fix lint

Pull Request Pull Request #1626: Cache Safe existence check for counterfactual balances

Run Details

2007 of 2465 branches covered (81.42%)

Branch coverage included in aggregate %.

37 of 41 new or added lines in 8 files covered. (90.24%)

1 existing line in 1 file now uncovered.

7160 of 7422 relevant lines covered (96.47%)

327.76 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.getTransactionApi(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.getTransactionApi(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.getTransactionApi(args.chainId);
    return transactionService.clearIsSafe(args.address);
  }

  async clearSafe(args: {
    chainId: string;
    address: `0x${string}`;
  }): Promise<void> {
    const transactionService =
      await this.transactionApiManager.getTransactionApi(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.getTransactionApi(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.getTransactionApi(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.getTransactionApi(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.getTransactionApi(args.chainId);

    return transactionService.clearIncomingTransfers(args.safeAddress);
  }

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

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

  async getModuleTransactions(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    to?: string;
    module?: string;
    limit?: number;
    offset?: number;
  }): Promise<Page<ModuleTransaction>> {
    const transactionService =
      await this.transactionApiManager.getTransactionApi(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.getTransactionApi(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.getTransactionApi(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.getTransactionApi(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.getTransactionApi(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.getTransactionApi(args.chainId);

    return transactionService.clearAllTransactions(args.safeAddress);
  }

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

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

safe-global / safe-client-gateway / 9448341807

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