8633304095

Committed 10 Apr 2024 02:48PM UTC coverage: 92.668% (+0.04%) from 92.633%

Build # 8633304095

Build Type

Pull #1382

github

Committed by

hectorgomezv

Commit Message

Refactor modules architecture, add e2e test

Pull Request Pull Request #1382: [WIP] PoC: consume events from TXS queue

Run Details

1901 of 2300 branches covered (82.65%)

Branch coverage included in aggregate %.

94 of 100 new or added lines in 12 files covered. (94.0%)

1 existing line in 1 file now uncovered.

6693 of 6974 relevant lines covered (95.97%)

353.98 hits per line

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

98.88

/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 { ConsumeMessage } from 'amqplib';
import { IQueueConsumerService } from '@/datasources/queues/queue-consumer.service.interface';
import { IConfigurationService } from '@/config/configuration.service.interface';
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 queue: 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(IQueueConsumerService)
    private readonly queueConsumerService: IQueueConsumerService,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
  ) {
    this.queue = this.configurationService.getOrThrow<string>('amqp.queue');
  }

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

safe-global / safe-client-gateway / 8633304095

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