7264075956

Committed 19 Dec 2023 03:37PM UTC coverage: 90.36% (-0.007%) from 90.367%

Build # 7264075956

Build Type

push

github

Committed by

web-flow

Commit Message

feat: add `getSafesByModule` and `clearSafesByModule` to `SafeRepository` (#954)

This adds the following functionality to the `SafeRepository`, as well as integrating within the `CacheHooksService`:

- `getSafesByModule` - fetches and caches endpoint result
- `clearSafesByModule` - clears existing cache of endpoint result

`clearSafesByModule` is called within the `CacheHooksService` whenever a `EventType.MODULE_TRANSACTION` event occurs.

Please note that the cache should also invalidate on an `EXECUTED_MULTISIG_TRANSACTION` event but as this is primarily focused on recovery (for the time being) this should not be an issue due to the specificity of recovery modules to individual Safes.

* feat: implement `IModulesRepository` + cache clearing

* fix: use static method

* fix: migrate to `SafeRepository`, add validation + remove network mock

* feat: add Safes by module

* fix: add `TODO` for future PR

* fix: update comment

Run Details

1427 of 1702 branches covered (0.0%)

Branch coverage included in aggregate %.

1 of 6 new or added lines in 2 files covered. (16.67%)

1 existing line in 1 file now uncovered.

5350 of 5798 relevant lines covered (92.27%)

147.46 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
      // - the list of Safes for the module
      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.safeRepository.clearSafesByModule({
            chainId: event.chainId,
            moduleAddress: event.module,
          }),
        );
        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:
        // Important: we should be clearing Safes by module here but we don't have module address
        // As this is only being used for recovery, whereby our UI deploys new module per Safe
        // we can assume that the Safes-module relationship does not change for said module

        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,	520✔
30	@Inject(IChainsRepository)
31	private readonly chainsRepository: IChainsRepository,	520✔
32	@Inject(ICollectiblesRepository)
33	private readonly collectiblesRepository: ICollectiblesRepository,	520✔
34	@Inject(IMessagesRepository)
35	private readonly messagesRepository: IMessagesRepository,	520✔
36	@Inject(ISafeAppsRepository)
37	private readonly safeAppsRepository: ISafeAppsRepository,	520✔
38	@Inject(ISafeRepository)
39	private readonly safeRepository: ISafeRepository,	520✔
40	@Inject(LoggingService)
41	private readonly loggingService: ILoggingService,	520✔
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	// - the list of Safes for the module
82	case EventType.MODULE_TRANSACTION:
83	promises.push(	×
84	this.safeRepository.clearAllExecutedTransactions({
85	chainId: event.chainId,
86	safeAddress: event.address,
87	}),
88	this.safeRepository.clearModuleTransactions({
89	chainId: event.chainId,
90	safeAddress: event.address,
91	}),
92	this.safeRepository.clearSafe({
93	chainId: event.chainId,
94	address: event.address,
95	}),
96	this.safeRepository.clearSafesByModule({
97	chainId: event.chainId,
98	moduleAddress: event.module,
99	}),
100	);
101	this._logTxEvent(event);	×
102	break;	×
103	// A new executed multisig transaction affects:
104	// - the collectibles that the safe has
105	// - the list of all executed transactions for the safe
106	// - the transfers for that safe
107	// - queued transactions and history – clear multisig transactions
108	// - the transaction executed – clear multisig transaction
109	// - the safe configuration - clear safe info
110	case EventType.EXECUTED_MULTISIG_TRANSACTION:
111	// Important: we should be clearing Safes by module here but we don't have module address
112	// As this is only being used for recovery, whereby our UI deploys new module per Safe
113	// we can assume that the Safes-module relationship does not change for said module
114
UNCOV 115	promises.push(	×
116	this.collectiblesRepository.clearCollectibles({
117	chainId: event.chainId,
118	safeAddress: event.address,
119	}),
120	this.safeRepository.clearAllExecutedTransactions({
121	chainId: event.chainId,
122	safeAddress: event.address,
123	}),
124	this.safeRepository.clearTransfers({
125	chainId: event.chainId,
126	safeAddress: event.address,
127	}),
128	this.safeRepository.clearMultisigTransactions({
129	chainId: event.chainId,
130	safeAddress: event.address,
131	}),
132	this.safeRepository.clearMultisigTransaction({
133	chainId: event.chainId,
134	safeTransactionHash: event.safeTxHash,
135	}),
136	this.safeRepository.clearSafe({
137	chainId: event.chainId,
138	address: event.address,
139	}),
140	);
141	this._logSafeTxEvent(event);	×
142	break;	×
143	// A new confirmation for a pending transaction affects:
144	// - queued transactions – clear multisig transactions
145	// - the pending transaction – clear multisig transaction
146	case EventType.NEW_CONFIRMATION:
147	promises.push(	×
148	this.safeRepository.clearMultisigTransactions({
149	chainId: event.chainId,
150	safeAddress: event.address,
151	}),
152	this.safeRepository.clearMultisigTransaction({
153	chainId: event.chainId,
154	safeTransactionHash: event.safeTxHash,
155	}),
156	);
157	this._logSafeTxEvent(event);	×
158	break;	×
159	// Incoming ether affects:
160	// - the balance of the safe - clear safe balance
161	// - the list of all executed transactions (including transfers) for the safe
162	// - the incoming transfers for that safe
163	case EventType.INCOMING_ETHER:
164	promises.push(	×
165	this.balancesRepository.clearLocalBalances({
166	chainId: event.chainId,
167	safeAddress: event.address,
168	}),
169	this.safeRepository.clearAllExecutedTransactions({
170	chainId: event.chainId,
171	safeAddress: event.address,
172	}),
173	this.safeRepository.clearMultisigTransactions({
174	chainId: event.chainId,
175	safeAddress: event.address,
176	}),
177	this.safeRepository.clearTransfers({
178	chainId: event.chainId,
179	safeAddress: event.address,
180	}),
181	this.safeRepository.clearIncomingTransfers({
182	chainId: event.chainId,
183	safeAddress: event.address,
184	}),
185	);
186	this._logTxEvent(event);	×
187	break;	×
188	// Outgoing ether affects:
189	// - the balance of the safe - clear safe balance
190	// - the list of all executed transactions for the safe
191	// - queued transactions and history – clear multisig transactions
192	// - the transfers for that safe
193	case EventType.OUTGOING_ETHER:
194	promises.push(	×
195	this.balancesRepository.clearLocalBalances({
196	chainId: event.chainId,
197	safeAddress: event.address,
198	}),
199	this.safeRepository.clearAllExecutedTransactions({
200	chainId: event.chainId,
201	safeAddress: event.address,
202	}),
203	this.safeRepository.clearMultisigTransactions({
204	chainId: event.chainId,
205	safeAddress: event.address,
206	}),
207	this.safeRepository.clearTransfers({
208	chainId: event.chainId,
209	safeAddress: event.address,
210	}),
211	);
212	this._logTxEvent(event);	×
213	break;	×
214	// An incoming token affects:
215	// - the balance of the safe - clear safe balance
216	// - the collectibles that the safe has
217	// - the list of all executed transactions (including transfers) for the safe
218	// - queued transactions and history – clear multisig transactions
219	// - the transfers for that safe
220	// - the incoming transfers for that safe
221	case EventType.INCOMING_TOKEN:
222	promises.push(	×
223	this.balancesRepository.clearLocalBalances({
224	chainId: event.chainId,
225	safeAddress: event.address,
226	}),
227	this.collectiblesRepository.clearCollectibles({
228	chainId: event.chainId,
229	safeAddress: event.address,
230	}),
231	this.safeRepository.clearAllExecutedTransactions({
232	chainId: event.chainId,
233	safeAddress: event.address,
234	}),
235	this.safeRepository.clearMultisigTransactions({
236	chainId: event.chainId,
237	safeAddress: event.address,
238	}),
239	this.safeRepository.clearTransfers({
240	chainId: event.chainId,
241	safeAddress: event.address,
242	}),
243	this.safeRepository.clearIncomingTransfers({
244	chainId: event.chainId,
245	safeAddress: event.address,
246	}),
247	);
248	this._logTxEvent(event);	×
249	break;	×
250	// An outgoing token affects:
251	// - the balance of the safe - clear safe balance
252	// - the collectibles that the safe has
253	// - the list of all executed transactions (including transfers) for the safe
254	// - queued transactions and history – clear multisig transactions
255	// - the transfers for that safe
256	case EventType.OUTGOING_TOKEN:
257	promises.push(	×
258	this.balancesRepository.clearLocalBalances({
259	chainId: event.chainId,
260	safeAddress: event.address,
261	}),
262	this.collectiblesRepository.clearCollectibles({
263	chainId: event.chainId,
264	safeAddress: event.address,
265	}),
266	this.safeRepository.clearAllExecutedTransactions({
267	chainId: event.chainId,
268	safeAddress: event.address,
269	}),
270	this.safeRepository.clearMultisigTransactions({
271	chainId: event.chainId,
272	safeAddress: event.address,
273	}),
274	this.safeRepository.clearTransfers({
275	chainId: event.chainId,
276	safeAddress: event.address,
277	}),
278	);
279	this._logTxEvent(event);	×
280	break;	×
281	// A message created affects:
282	// - the messages associated to the Safe
283	case EventType.MESSAGE_CREATED:
284	promises.push(	×
285	this.messagesRepository.clearMessagesBySafe({
286	chainId: event.chainId,
287	safeAddress: event.address,
288	}),
289	);
290	this._logMessageEvent(event);	×
291	break;	×
292	// A new message confirmation affects:
293	// - the message itself
294	// - the messages associated to the Safe
295	case EventType.MESSAGE_CONFIRMATION:
296	promises.push(	×
297	this.messagesRepository.clearMessagesByHash({
298	chainId: event.chainId,
299	messageHash: event.messageHash,
300	}),
301	this.messagesRepository.clearMessagesBySafe({
302	chainId: event.chainId,
303	safeAddress: event.address,
304	}),
305	);
306	this._logMessageEvent(event);	×
307	break;	×
308	case EventType.CHAIN_UPDATE:
309	promises.push(this.chainsRepository.clearChain(event.chainId));	×
310	this._logEvent(event);	×
311	break;	×
312	case EventType.SAFE_APPS_UPDATE:
313	promises.push(this.safeAppsRepository.clearSafeApps(event.chainId));	×
314	this._logEvent(event);	×
315	break;	×
316	}
317	return Promise.all(promises);	×
318	}
319
320	private _logSafeTxEvent(
321	event: ExecutedTransaction \| NewConfirmation \| PendingTransaction,
322	): void {
323	this.loggingService.info({	×
324	type: CacheHooksService.HOOK_TYPE,
325	eventType: event.type,
326	address: event.address,
327	chainId: event.chainId,
328	safeTxHash: event.safeTxHash,
329	});
330	}
331
332	private _logTxEvent(
333	event:
334	\| IncomingEther
335	\| IncomingToken
336	\| ModuleTransaction
337	\| OutgoingEther
338	\| OutgoingToken,
339	): void {
340	this.loggingService.info({	×
341	type: CacheHooksService.HOOK_TYPE,
342	eventType: event.type,
343	address: event.address,
344	chainId: event.chainId,
345	txHash: event.txHash,
346	});
347	}
348
349	private _logMessageEvent(
350	event: MessageCreated \| NewMessageConfirmation,
351	): void {
352	this.loggingService.info({	×
353	type: CacheHooksService.HOOK_TYPE,
354	eventType: event.type,
355	address: event.address,
356	chainId: event.chainId,
357	messageHash: event.messageHash,
358	});
359	}
360
361	private _logEvent(event: ChainUpdate \| SafeAppsUpdate): void {
362	this.loggingService.info({	×
363	type: CacheHooksService.HOOK_TYPE,
364	eventType: event.type,
365	chainId: event.chainId,
366	});
367	}
368	}

safe-global / safe-client-gateway / 7264075956

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