9403128733

Committed 06 Jun 2024 02:54PM UTC coverage: 92.792% (-0.1%) from 92.917%

Build # 9403128733

Build Type

Pull #1618

github

Committed by

web-flow

Commit Message

Merge a1c52b17a into 7af88b309

Pull Request Pull Request #1618: Refactor SiWe-related logic to use viem

Run Details

1992 of 2445 branches covered (81.47%)

Branch coverage included in aggregate %.

36 of 37 new or added lines in 4 files covered. (97.3%)

3 existing lines in 2 files now uncovered.

7109 of 7363 relevant lines covered (96.55%)

329.14 hits per line

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

98.9

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

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

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

safe-global / safe-client-gateway / 9403128733

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