9461883835

Committed 11 Jun 2024 08:06AM UTC coverage: 92.759% (+0.05%) from 92.711%

Build # 9461883835

Build Type

Pull #1637

github

Committed by

hectorgomezv

Commit Message

Add ZerionBalancesSchema tests

Pull Request Pull Request #1637: Add ZerionBalancesSchema tests

Run Details

2006 of 2459 branches covered (81.58%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 2 files covered. (100.0%)

3 existing lines in 3 files now uncovered.

7128 of 7388 relevant lines covered (96.48%)

328.44 hits per line

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

99.05

/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';

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

safe-global / safe-client-gateway / 9461883835

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