7277983248

Committed 20 Dec 2023 04:13PM UTC coverage: 90.342% (-0.009%) from 90.351%

Build # 7277983248

Build Type

push

github

Committed by

web-flow

Commit Message

fix: remove Safes by modules caching (#964)

This removes caching of Safes by modules, opting to fetch when necessary instead.

* fix: remove Safes by modules caching

* fix: remove log + keep tests

* Mock as `NetworkResponse` and only cache value of `data`

* Fix `getSafesByModules` test

Run Details

1422 of 1702 branches covered (0.0%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

4 existing lines in 2 files now uncovered.

5350 of 5794 relevant lines covered (92.34%)

148.18 hits per line

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

24.32

/src/routes/cache-hooks/cache-hooks.service.ts

import { Inject, Injectable } 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 { ChainUpdate } from '@/routes/cache-hooks/entities/chain-update.entity';
import { EventType } from '@/routes/cache-hooks/entities/event-payload.entity';
import { ExecutedTransaction } from '@/routes/cache-hooks/entities/executed-transaction.entity';
import { IncomingEther } from '@/routes/cache-hooks/entities/incoming-ether.entity';
import { IncomingToken } from '@/routes/cache-hooks/entities/incoming-token.entity';
import { MessageCreated } from '@/routes/cache-hooks/entities/message-created.entity';
import { NewConfirmation } from '@/routes/cache-hooks/entities/new-confirmation.entity';
import { NewMessageConfirmation } from '@/routes/cache-hooks/entities/new-message-confirmation.entity';
import { OutgoingEther } from '@/routes/cache-hooks/entities/outgoing-ether.entity';
import { OutgoingToken } from '@/routes/cache-hooks/entities/outgoing-token.entity';
import { PendingTransaction } from '@/routes/cache-hooks/entities/pending-transaction.entity';
import { SafeAppsUpdate } from '@/routes/cache-hooks/entities/safe-apps-update.entity';
import { ModuleTransaction } from '@/routes/cache-hooks/entities/module-transaction.entity';
import { LoggingService, ILoggingService } from '@/logging/logging.interface';

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

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

  async onEvent(
    event:
      | ChainUpdate
      | ExecutedTransaction
      | IncomingEther
      | IncomingToken
      | MessageCreated
      | ModuleTransaction
      | NewMessageConfirmation
      | NewConfirmation
      | OutgoingToken
      | OutgoingEther
      | PendingTransaction
      | SafeAppsUpdate,
  ): 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;
      // 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.clearLocalBalances({
            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.clearLocalBalances({
            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.clearLocalBalances({
            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.clearLocalBalances({
            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: ExecutedTransaction | NewConfirmation | PendingTransaction,
  ): void {
    this.loggingService.info({
      type: CacheHooksService.HOOK_TYPE,
      eventType: event.type,
      address: event.address,
      chainId: event.chainId,
      safeTxHash: event.safeTxHash,
    });
  }

  private _logTxEvent(
    event:
      | IncomingEther
      | IncomingToken
      | ModuleTransaction
      | OutgoingEther
      | OutgoingToken,
  ): void {
    this.loggingService.info({
      type: CacheHooksService.HOOK_TYPE,
      eventType: event.type,
      address: event.address,
      chainId: event.chainId,
      txHash: event.txHash,
    });
  }

  private _logMessageEvent(
    event: MessageCreated | NewMessageConfirmation,
  ): void {
    this.loggingService.info({
      type: CacheHooksService.HOOK_TYPE,
      eventType: event.type,
      address: event.address,
      chainId: event.chainId,
      messageHash: event.messageHash,
    });
  }

  private _logEvent(event: ChainUpdate | SafeAppsUpdate): void {
    this.loggingService.info({
      type: CacheHooksService.HOOK_TYPE,
      eventType: event.type,
      chainId: event.chainId,
    });
  }
}

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

safe-global / safe-client-gateway / 7277983248

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