9991347181

Committed 18 Jul 2024 12:18PM UTC coverage: 48.26% (+0.03%) from 48.233%

Build # 9991347181

Build Type

Pull #1774

github

Committed by

iamacook

Commit Message

Don't throw if a listener throws

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

Run Details

415 of 2591 branches covered (16.02%)

Branch coverage included in aggregate %.

17 of 18 new or added lines in 3 files covered. (94.44%)

3 existing lines in 2 files now uncovered.

4285 of 7148 relevant lines covered (59.95%)

13.05 hits per line

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

96.67

/src/routes/cache-hooks/cache-hooks.service.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 { IQueuesRepository } from '@/domain/queues/queues-repository.interface';
import { IBlockchainRepository } from '@/domain/blockchain/blockchain.repository.interface';

@Injectable()
export class CacheHooksService implements OnModuleInit {
  private static readonly HOOK_TYPE = 'hook';

  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,
  ) {}

  onModuleInit(): void {
    this.queuesRepository.onEvent((event) => this.onEvent(event));
  }

  async onEvent(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,
          }),
        );
        this._logSafeTxEvent(event);
        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,
          }),
        );
        this._logSafeTxEvent(event);
        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,
          }),
        );
        this._logTxEvent(event);
        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,
          }),
        );
        this._logSafeTxEvent(event);
        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,
          }),
        );
        this._logSafeTxEvent(event);
        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,
          }),
        );
        this._logTxEvent(event);
        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,
          }),
        );
        this._logTxEvent(event);
        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,
          }),
        );
        this._logTxEvent(event);
        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,
          }),
        );
        this._logTxEvent(event);
        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,
          }),
        );
        this._logMessageEvent(event);
        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,
          }),
        );
        this._logMessageEvent(event);
        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);
          }),
        );
        this._logEvent(event);
        break;
      case EventType.SAFE_APPS_UPDATE:
        promises.push(this.safeAppsRepository.clearSafeApps(event.chainId));
        this._logEvent(event);
        break;
      case EventType.SAFE_CREATED:
        promises.push(this.safeRepository.clearIsSafe(event));
        break;
    }
    return Promise.all(promises);
  }

  private _logSafeTxEvent(
    event: Event & { address: string; safeTxHash: string },
  ): void {
    this.loggingService.info({
      type: CacheHooksService.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: CacheHooksService.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: CacheHooksService.HOOK_TYPE,
      eventType: event.type,
      address: event.address,
      chainId: event.chainId,
      messageHash: event.messageHash,
    });
  }

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

safe-global / safe-client-gateway / 9991347181

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