10004471012

Committed 19 Jul 2024 07:43AM UTC coverage: 48.387% (+0.1%) from 48.244%

Build # 10004471012

Build Type

Pull #1774

github

Committed by

iamacook

Commit Message

Move `CacheHooksService` logic to domain

Pull Request Pull Request #1774: Accept multiple listeners for the same queue subscription

Run Details

433 of 2608 branches covered (16.6%)

Branch coverage included in aggregate %.

98 of 103 new or added lines in 4 files covered. (95.15%)

1 existing line in 1 file now uncovered.

4291 of 7155 relevant lines covered (59.97%)

13.02 hits per line

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

94.69

/src/domain/hooks/hooks.repository.ts

import { Inject, Injectable, OnModuleInit } from '@nestjs/common';
import { IBalancesRepository } from '@/domain/balances/balances.repository.interface';
import { IChainsRepository } from '@/domain/chains/chains.repository.interface';
import { ICollectiblesRepository } from '@/domain/collectibles/collectibles.repository.interface';
import { IMessagesRepository } from '@/domain/messages/messages.repository.interface';
import { ISafeAppsRepository } from '@/domain/safe-apps/safe-apps.repository.interface';
import { ISafeRepository } from '@/domain/safe/safe.repository.interface';
import { ITransactionsRepository } from '@/domain/transactions/transactions.repository.interface';
import { EventType } from '@/routes/cache-hooks/entities/event-type.entity';
import { LoggingService, ILoggingService } from '@/logging/logging.interface';
import { Event } from '@/routes/cache-hooks/entities/event.entity';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { IQueuesRepository } from '@/domain/queues/queues-repository.interface';
import { ConsumeMessage } from 'amqplib';
import { WebHookSchema } from '@/routes/cache-hooks/entities/schemas/web-hook.schema';
import { IBlockchainRepository } from '@/domain/blockchain/blockchain.repository.interface';

@Injectable()
export class HooksRepository implements OnModuleInit {
  private static readonly HOOK_TYPE = 'hook';
  private readonly queueName: string;

  constructor(
    @Inject(IBalancesRepository)
    private readonly balancesRepository: IBalancesRepository,
    @Inject(IBlockchainRepository)
    private readonly blockchainRepository: IBlockchainRepository,
    @Inject(IChainsRepository)
    private readonly chainsRepository: IChainsRepository,
    @Inject(ICollectiblesRepository)
    private readonly collectiblesRepository: ICollectiblesRepository,
    @Inject(IMessagesRepository)
    private readonly messagesRepository: IMessagesRepository,
    @Inject(ISafeAppsRepository)
    private readonly safeAppsRepository: ISafeAppsRepository,
    @Inject(ISafeRepository)
    private readonly safeRepository: ISafeRepository,
    @Inject(ITransactionsRepository)
    private readonly transactionsRepository: ITransactionsRepository,
    @Inject(LoggingService)
    private readonly loggingService: ILoggingService,
    @Inject(IQueuesRepository)
    private readonly queuesRepository: IQueuesRepository,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
  ) {
    this.queueName = this.configurationService.getOrThrow<string>('amqp.queue');
  }

  onModuleInit(): Promise<void> {
    return this.queuesRepository.subscribe(
      this.queueName,
      async (msg: ConsumeMessage) => {
        try {
          const content = JSON.parse(msg.content.toString());
          const event: Event = WebHookSchema.parse(content);
          await this.onEvent(event);
        } catch (err) {
          this.loggingService.error(err);
        }
      },
    );
  }

  async onEvent(event: Event): Promise<unknown> {
    return this.onEventClearCache(event).finally(() => {
      this.onEventLog(event);
    });
  }

  private async onEventClearCache(event: Event): Promise<void[]> {
    const promises: Promise<void>[] = [];
    switch (event.type) {
      // A new pending multisig transaction affects:
      // queued transactions – clear multisig transactions
      // the pending transaction – clear multisig transaction
      case EventType.PENDING_MULTISIG_TRANSACTION:
        promises.push(
          this.safeRepository.clearMultisigTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearMultisigTransaction({
            chainId: event.chainId,
            safeTransactionHash: event.safeTxHash,
          }),
        );
        break;
      // A deleted multisig transaction affects:
      // queued transactions – clear multisig transactions
      // the pending transaction – clear multisig transaction
      case EventType.DELETED_MULTISIG_TRANSACTION:
        promises.push(
          this.safeRepository.clearMultisigTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearMultisigTransaction({
            chainId: event.chainId,
            safeTransactionHash: event.safeTxHash,
          }),
        );
        break;
      // An executed module transaction might affect:
      // - the list of all executed transactions for the safe
      // - the list of module transactions for the safe
      // - the safe configuration
      case EventType.MODULE_TRANSACTION:
        promises.push(
          this.safeRepository.clearAllExecutedTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearModuleTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearSafe({
            chainId: event.chainId,
            address: event.address,
          }),
        );
        break;
      // A new executed multisig transaction affects:
      // - the collectibles that the safe has
      // - the list of all executed transactions for the safe
      // - the transfers for that safe
      // - queued transactions and history – clear multisig transactions
      // - the transaction executed – clear multisig transaction
      // - the safe configuration - clear safe info
      case EventType.EXECUTED_MULTISIG_TRANSACTION:
        promises.push(
          this.collectiblesRepository.clearCollectibles({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearAllExecutedTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearTransfers({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearMultisigTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearMultisigTransaction({
            chainId: event.chainId,
            safeTransactionHash: event.safeTxHash,
          }),
          this.safeRepository.clearSafe({
            chainId: event.chainId,
            address: event.address,
          }),
        );
        break;
      // A new confirmation for a pending transaction affects:
      // - queued transactions – clear multisig transactions
      // - the pending transaction – clear multisig transaction
      case EventType.NEW_CONFIRMATION:
        promises.push(
          this.safeRepository.clearMultisigTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearMultisigTransaction({
            chainId: event.chainId,
            safeTransactionHash: event.safeTxHash,
          }),
        );
        break;
      // Incoming ether affects:
      // - the balance of the safe - clear safe balance
      // - the list of all executed transactions (including transfers) for the safe
      // - the incoming transfers for that safe
      case EventType.INCOMING_ETHER:
        promises.push(
          this.balancesRepository.clearBalances({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearAllExecutedTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearMultisigTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearTransfers({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearIncomingTransfers({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
        );
        break;
      // Outgoing ether affects:
      // - the balance of the safe - clear safe balance
      // - the list of all executed transactions for the safe
      // - queued transactions and history – clear multisig transactions
      // - the transfers for that safe
      case EventType.OUTGOING_ETHER:
        promises.push(
          this.balancesRepository.clearBalances({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearAllExecutedTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearMultisigTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearTransfers({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
        );
        break;
      // An incoming token affects:
      // - the balance of the safe - clear safe balance
      // - the collectibles that the safe has
      // - the list of all executed transactions (including transfers) for the safe
      // - queued transactions and history – clear multisig transactions
      // - the transfers for that safe
      // - the incoming transfers for that safe
      case EventType.INCOMING_TOKEN:
        promises.push(
          this.balancesRepository.clearBalances({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.collectiblesRepository.clearCollectibles({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearAllExecutedTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearMultisigTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearTransfers({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearIncomingTransfers({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
        );
        break;
      // An outgoing token affects:
      // - the balance of the safe - clear safe balance
      // - the collectibles that the safe has
      // - the list of all executed transactions (including transfers) for the safe
      // - queued transactions and history – clear multisig transactions
      // - the transfers for that safe
      case EventType.OUTGOING_TOKEN:
        promises.push(
          this.balancesRepository.clearBalances({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.collectiblesRepository.clearCollectibles({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearAllExecutedTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearMultisigTransactions({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
          this.safeRepository.clearTransfers({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
        );
        break;
      // A message created affects:
      // - the messages associated to the Safe
      case EventType.MESSAGE_CREATED:
        promises.push(
          this.messagesRepository.clearMessagesBySafe({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
        );
        break;
      // A new message confirmation affects:
      // - the message itself
      // - the messages associated to the Safe
      case EventType.MESSAGE_CONFIRMATION:
        promises.push(
          this.messagesRepository.clearMessagesByHash({
            chainId: event.chainId,
            messageHash: event.messageHash,
          }),
          this.messagesRepository.clearMessagesBySafe({
            chainId: event.chainId,
            safeAddress: event.address,
          }),
        );
        break;
      case EventType.CHAIN_UPDATE:
        promises.push(
          this.chainsRepository.clearChain(event.chainId).then(() => {
            // RPC may have changed
            this.blockchainRepository.clearApi(event.chainId);
            // Transaction Service may have changed
            this.transactionsRepository.clearApi(event.chainId);
            this.balancesRepository.clearApi(event.chainId);
          }),
        );
        break;
      case EventType.SAFE_APPS_UPDATE:
        promises.push(this.safeAppsRepository.clearSafeApps(event.chainId));
        break;
      case EventType.SAFE_CREATED:
        promises.push(this.safeRepository.clearIsSafe(event));
        break;
    }
    return Promise.all(promises);
  }

  private onEventLog(event: Event): void {
    switch (event.type) {
      case EventType.PENDING_MULTISIG_TRANSACTION:
      case EventType.DELETED_MULTISIG_TRANSACTION:
      case EventType.EXECUTED_MULTISIG_TRANSACTION:
      case EventType.NEW_CONFIRMATION:
        this._logSafeTxEvent(event);
        break;
      case EventType.MODULE_TRANSACTION:
      case EventType.INCOMING_ETHER:
      case EventType.OUTGOING_ETHER:
      case EventType.INCOMING_TOKEN:
      case EventType.OUTGOING_TOKEN:
        this._logTxEvent(event);
        break;
      case EventType.MESSAGE_CREATED:
      case EventType.MESSAGE_CONFIRMATION:
        this._logMessageEvent(event);
        break;
      case EventType.CHAIN_UPDATE:
      case EventType.SAFE_APPS_UPDATE:
        this._logEvent(event);
        break;
      case EventType.SAFE_CREATED:
        break;
    }
  }

  private _logSafeTxEvent(
    event: Event & { address: string; safeTxHash: string },
  ): void {
    this.loggingService.info({
      type: HooksRepository.HOOK_TYPE,
      eventType: event.type,
      address: event.address,
      chainId: event.chainId,
      safeTxHash: event.safeTxHash,
    });
  }

  private _logTxEvent(
    event: Event & { address: string; txHash: string },
  ): void {
    this.loggingService.info({
      type: HooksRepository.HOOK_TYPE,
      eventType: event.type,
      address: event.address,
      chainId: event.chainId,
      txHash: event.txHash,
    });
  }

  private _logMessageEvent(
    event: Event & { address: string; messageHash: string },
  ): void {
    this.loggingService.info({
      type: HooksRepository.HOOK_TYPE,
      eventType: event.type,
      address: event.address,
      chainId: event.chainId,
      messageHash: event.messageHash,
    });
  }

  private _logEvent(event: Event): void {
    this.loggingService.info({
      type: HooksRepository.HOOK_TYPE,
      eventType: event.type,
      chainId: event.chainId,
    });
  }
}

1	import { Inject, Injectable, OnModuleInit } from '@nestjs/common';	16✔
2	import { IBalancesRepository } from '@/domain/balances/balances.repository.interface';	16✔
3	import { IChainsRepository } from '@/domain/chains/chains.repository.interface';	16✔
4	import { ICollectiblesRepository } from '@/domain/collectibles/collectibles.repository.interface';	16✔
5	import { IMessagesRepository } from '@/domain/messages/messages.repository.interface';	16✔
6	import { ISafeAppsRepository } from '@/domain/safe-apps/safe-apps.repository.interface';	16✔
7	import { ISafeRepository } from '@/domain/safe/safe.repository.interface';	16✔
8	import { ITransactionsRepository } from '@/domain/transactions/transactions.repository.interface';	16✔
9	import { EventType } from '@/routes/cache-hooks/entities/event-type.entity';
10	import { LoggingService, ILoggingService } from '@/logging/logging.interface';	16✔
11	import { Event } from '@/routes/cache-hooks/entities/event.entity';
12	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
13	import { IQueuesRepository } from '@/domain/queues/queues-repository.interface';	16✔
14	import { ConsumeMessage } from 'amqplib';
15	import { WebHookSchema } from '@/routes/cache-hooks/entities/schemas/web-hook.schema';	16✔
16	import { IBlockchainRepository } from '@/domain/blockchain/blockchain.repository.interface';	16✔
17
18	@Injectable()
19	export class HooksRepository implements OnModuleInit {	16✔
20	private static readonly HOOK_TYPE = 'hook';	16✔
21	private readonly queueName: string;
22
23	constructor(
24	@Inject(IBalancesRepository)
25	private readonly balancesRepository: IBalancesRepository,	16✔
26	@Inject(IBlockchainRepository)
27	private readonly blockchainRepository: IBlockchainRepository,	16✔
28	@Inject(IChainsRepository)
29	private readonly chainsRepository: IChainsRepository,	16✔
30	@Inject(ICollectiblesRepository)
31	private readonly collectiblesRepository: ICollectiblesRepository,	16✔
32	@Inject(IMessagesRepository)
33	private readonly messagesRepository: IMessagesRepository,	16✔
34	@Inject(ISafeAppsRepository)
35	private readonly safeAppsRepository: ISafeAppsRepository,	16✔
36	@Inject(ISafeRepository)
37	private readonly safeRepository: ISafeRepository,	16✔
38	@Inject(ITransactionsRepository)
39	private readonly transactionsRepository: ITransactionsRepository,	16✔
40	@Inject(LoggingService)
41	private readonly loggingService: ILoggingService,	16✔
42	@Inject(IQueuesRepository)
43	private readonly queuesRepository: IQueuesRepository,	16✔
44	@Inject(IConfigurationService)
45	private readonly configurationService: IConfigurationService,	16✔
46	) {
47	this.queueName = this.configurationService.getOrThrow<string>('amqp.queue');	16✔
48	}
49
50	onModuleInit(): Promise<void> {
51	return this.queuesRepository.subscribe(	16✔
52	this.queueName,
53	async (msg: ConsumeMessage) => {
54	try {	66✔
55	const content = JSON.parse(msg.content.toString());	66✔
56	const event: Event = WebHookSchema.parse(content);	66✔
57	await this.onEvent(event);	66✔
58	} catch (err) {
NEW 59	this.loggingService.error(err);	×
60	}
61	},
62	);
63	}
64
65	async onEvent(event: Event): Promise<unknown> {
66	return this.onEventClearCache(event).finally(() => {	66✔
67	this.onEventLog(event);	66✔
68	});
69	}
70
71	private async onEventClearCache(event: Event): Promise<void[]> {
72	const promises: Promise<void>[] = [];	66✔
73	switch (event.type) {	66!
74	// A new pending multisig transaction affects:
75	// queued transactions – clear multisig transactions
76	// the pending transaction – clear multisig transaction
77	case EventType.PENDING_MULTISIG_TRANSACTION:
78	promises.push(	4✔
79	this.safeRepository.clearMultisigTransactions({
80	chainId: event.chainId,
81	safeAddress: event.address,
82	}),
83	this.safeRepository.clearMultisigTransaction({
84	chainId: event.chainId,
85	safeTransactionHash: event.safeTxHash,
86	}),
87	);
88	break;	4✔
89	// A deleted multisig transaction affects:
90	// queued transactions – clear multisig transactions
91	// the pending transaction – clear multisig transaction
92	case EventType.DELETED_MULTISIG_TRANSACTION:
93	promises.push(	4✔
94	this.safeRepository.clearMultisigTransactions({
95	chainId: event.chainId,
96	safeAddress: event.address,
97	}),
98	this.safeRepository.clearMultisigTransaction({
99	chainId: event.chainId,
100	safeTransactionHash: event.safeTxHash,
101	}),
102	);
103	break;	4✔
104	// An executed module transaction might affect:
105	// - the list of all executed transactions for the safe
106	// - the list of module transactions for the safe
107	// - the safe configuration
108	case EventType.MODULE_TRANSACTION:
109	promises.push(	6✔
110	this.safeRepository.clearAllExecutedTransactions({
111	chainId: event.chainId,
112	safeAddress: event.address,
113	}),
114	this.safeRepository.clearModuleTransactions({
115	chainId: event.chainId,
116	safeAddress: event.address,
117	}),
118	this.safeRepository.clearSafe({
119	chainId: event.chainId,
120	address: event.address,
121	}),
122	);
123	break;	6✔
124	// A new executed multisig transaction affects:
125	// - the collectibles that the safe has
126	// - the list of all executed transactions for the safe
127	// - the transfers for that safe
128	// - queued transactions and history – clear multisig transactions
129	// - the transaction executed – clear multisig transaction
130	// - the safe configuration - clear safe info
131	case EventType.EXECUTED_MULTISIG_TRANSACTION:
132	promises.push(	12✔
133	this.collectiblesRepository.clearCollectibles({
134	chainId: event.chainId,
135	safeAddress: event.address,
136	}),
137	this.safeRepository.clearAllExecutedTransactions({
138	chainId: event.chainId,
139	safeAddress: event.address,
140	}),
141	this.safeRepository.clearTransfers({
142	chainId: event.chainId,
143	safeAddress: event.address,
144	}),
145	this.safeRepository.clearMultisigTransactions({
146	chainId: event.chainId,
147	safeAddress: event.address,
148	}),
149	this.safeRepository.clearMultisigTransaction({
150	chainId: event.chainId,
151	safeTransactionHash: event.safeTxHash,
152	}),
153	this.safeRepository.clearSafe({
154	chainId: event.chainId,
155	address: event.address,
156	}),
157	);
158	break;	12✔
159	// A new confirmation for a pending transaction affects:
160	// - queued transactions – clear multisig transactions
161	// - the pending transaction – clear multisig transaction
162	case EventType.NEW_CONFIRMATION:
163	promises.push(	4✔
164	this.safeRepository.clearMultisigTransactions({
165	chainId: event.chainId,
166	safeAddress: event.address,
167	}),
168	this.safeRepository.clearMultisigTransaction({
169	chainId: event.chainId,
170	safeTransactionHash: event.safeTxHash,
171	}),
172	);
173	break;	4✔
174	// Incoming ether affects:
175	// - the balance of the safe - clear safe balance
176	// - the list of all executed transactions (including transfers) for the safe
177	// - the incoming transfers for that safe
178	case EventType.INCOMING_ETHER:
179	promises.push(	6✔
180	this.balancesRepository.clearBalances({
181	chainId: event.chainId,
182	safeAddress: event.address,
183	}),
184	this.safeRepository.clearAllExecutedTransactions({
185	chainId: event.chainId,
186	safeAddress: event.address,
187	}),
188	this.safeRepository.clearMultisigTransactions({
189	chainId: event.chainId,
190	safeAddress: event.address,
191	}),
192	this.safeRepository.clearTransfers({
193	chainId: event.chainId,
194	safeAddress: event.address,
195	}),
196	this.safeRepository.clearIncomingTransfers({
197	chainId: event.chainId,
198	safeAddress: event.address,
199	}),
200	);
201	break;	6✔
202	// Outgoing ether affects:
203	// - the balance of the safe - clear safe balance
204	// - the list of all executed transactions for the safe
205	// - queued transactions and history – clear multisig transactions
206	// - the transfers for that safe
207	case EventType.OUTGOING_ETHER:
208	promises.push(	4✔
209	this.balancesRepository.clearBalances({
210	chainId: event.chainId,
211	safeAddress: event.address,
212	}),
213	this.safeRepository.clearAllExecutedTransactions({
214	chainId: event.chainId,
215	safeAddress: event.address,
216	}),
217	this.safeRepository.clearMultisigTransactions({
218	chainId: event.chainId,
219	safeAddress: event.address,
220	}),
221	this.safeRepository.clearTransfers({
222	chainId: event.chainId,
223	safeAddress: event.address,
224	}),
225	);
226	break;	4✔
227	// An incoming token affects:
228	// - the balance of the safe - clear safe balance
229	// - the collectibles that the safe has
230	// - the list of all executed transactions (including transfers) for the safe
231	// - queued transactions and history – clear multisig transactions
232	// - the transfers for that safe
233	// - the incoming transfers for that safe
234	case EventType.INCOMING_TOKEN:
235	promises.push(	10✔
236	this.balancesRepository.clearBalances({
237	chainId: event.chainId,
238	safeAddress: event.address,
239	}),
240	this.collectiblesRepository.clearCollectibles({
241	chainId: event.chainId,
242	safeAddress: event.address,
243	}),
244	this.safeRepository.clearAllExecutedTransactions({
245	chainId: event.chainId,
246	safeAddress: event.address,
247	}),
248	this.safeRepository.clearMultisigTransactions({
249	chainId: event.chainId,
250	safeAddress: event.address,
251	}),
252	this.safeRepository.clearTransfers({
253	chainId: event.chainId,
254	safeAddress: event.address,
255	}),
256	this.safeRepository.clearIncomingTransfers({
257	chainId: event.chainId,
258	safeAddress: event.address,
259	}),
260	);
261	break;	10✔
262	// An outgoing token affects:
263	// - the balance of the safe - clear safe balance
264	// - the collectibles that the safe has
265	// - the list of all executed transactions (including transfers) for the safe
266	// - queued transactions and history – clear multisig transactions
267	// - the transfers for that safe
268	case EventType.OUTGOING_TOKEN:
269	promises.push(	8✔
270	this.balancesRepository.clearBalances({
271	chainId: event.chainId,
272	safeAddress: event.address,
273	}),
274	this.collectiblesRepository.clearCollectibles({
275	chainId: event.chainId,
276	safeAddress: event.address,
277	}),
278	this.safeRepository.clearAllExecutedTransactions({
279	chainId: event.chainId,
280	safeAddress: event.address,
281	}),
282	this.safeRepository.clearMultisigTransactions({
283	chainId: event.chainId,
284	safeAddress: event.address,
285	}),
286	this.safeRepository.clearTransfers({
287	chainId: event.chainId,
288	safeAddress: event.address,
289	}),
290	);
291	break;	8✔
292	// A message created affects:
293	// - the messages associated to the Safe
294	case EventType.MESSAGE_CREATED:
295	promises.push(	2✔
296	this.messagesRepository.clearMessagesBySafe({
297	chainId: event.chainId,
298	safeAddress: event.address,
299	}),
300	);
301	break;	2✔
302	// A new message confirmation affects:
303	// - the message itself
304	// - the messages associated to the Safe
305	case EventType.MESSAGE_CONFIRMATION:
306	promises.push(	2✔
307	this.messagesRepository.clearMessagesByHash({
308	chainId: event.chainId,
309	messageHash: event.messageHash,
310	}),
311	this.messagesRepository.clearMessagesBySafe({
312	chainId: event.chainId,
313	safeAddress: event.address,
314	}),
315	);
316	break;	2✔
317	case EventType.CHAIN_UPDATE:
318	promises.push(	2✔
319	this.chainsRepository.clearChain(event.chainId).then(() => {
320	// RPC may have changed
321	this.blockchainRepository.clearApi(event.chainId);	2✔
322	// Transaction Service may have changed
323	this.transactionsRepository.clearApi(event.chainId);	2✔
324	this.balancesRepository.clearApi(event.chainId);	2✔
325	}),
326	);
327	break;	2✔
328	case EventType.SAFE_APPS_UPDATE:
329	promises.push(this.safeAppsRepository.clearSafeApps(event.chainId));	2✔
330	break;	2✔
331	case EventType.SAFE_CREATED:
NEW 332	promises.push(this.safeRepository.clearIsSafe(event));	×
NEW 333	break;	×
334	}
335	return Promise.all(promises);	66✔
336	}
337
338	private onEventLog(event: Event): void {
339	switch (event.type) {	66!
340	case EventType.PENDING_MULTISIG_TRANSACTION:
341	case EventType.DELETED_MULTISIG_TRANSACTION:
342	case EventType.EXECUTED_MULTISIG_TRANSACTION:
343	case EventType.NEW_CONFIRMATION:
344	this._logSafeTxEvent(event);	24✔
345	break;	24✔
346	case EventType.MODULE_TRANSACTION:
347	case EventType.INCOMING_ETHER:
348	case EventType.OUTGOING_ETHER:
349	case EventType.INCOMING_TOKEN:
350	case EventType.OUTGOING_TOKEN:
351	this._logTxEvent(event);	34✔
352	break;	34✔
353	case EventType.MESSAGE_CREATED:
354	case EventType.MESSAGE_CONFIRMATION:
355	this._logMessageEvent(event);	4✔
356	break;	4✔
357	case EventType.CHAIN_UPDATE:
358	case EventType.SAFE_APPS_UPDATE:
359	this._logEvent(event);	4✔
360	break;	4✔
361	case EventType.SAFE_CREATED:
NEW 362	break;	×
363	}
364	}
365
366	private _logSafeTxEvent(
367	event: Event & { address: string; safeTxHash: string },
368	): void {
369	this.loggingService.info({	24✔
370	type: HooksRepository.HOOK_TYPE,
371	eventType: event.type,
372	address: event.address,
373	chainId: event.chainId,
374	safeTxHash: event.safeTxHash,
375	});
376	}
377
378	private _logTxEvent(
379	event: Event & { address: string; txHash: string },
380	): void {
381	this.loggingService.info({	34✔
382	type: HooksRepository.HOOK_TYPE,
383	eventType: event.type,
384	address: event.address,
385	chainId: event.chainId,
386	txHash: event.txHash,
387	});
388	}
389
390	private _logMessageEvent(
391	event: Event & { address: string; messageHash: string },
392	): void {
393	this.loggingService.info({	4✔
394	type: HooksRepository.HOOK_TYPE,
395	eventType: event.type,
396	address: event.address,
397	chainId: event.chainId,
398	messageHash: event.messageHash,
399	});
400	}
401
402	private _logEvent(event: Event): void {
403	this.loggingService.info({	4✔
404	type: HooksRepository.HOOK_TYPE,
405	eventType: event.type,
406	chainId: event.chainId,
407	});
408	}
409	}

safe-global / safe-client-gateway / 10004471012

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