11919262801

Committed 19 Nov 2024 06:20PM UTC coverage: 89.509% (-0.02%) from 89.529%

Build # 11919262801

Build Type

push

github

Committed by

web-flow

Commit Message

Handle `*_DELEGATE` Transaction Service events (#2106)

* Handle `*_DELEGATE` Transaction Service events

* Add E2E tests

* Rename address field

* Rename remaining fields

* Make `safeAddress` optional

* Add payload

Run Details

2732 of 3401 branches covered (80.33%)

Branch coverage included in aggregate %.

21 of 21 new or added lines in 8 files covered. (100.0%)

1 existing line in 1 file now uncovered.

9187 of 9915 relevant lines covered (92.66%)

425.9 hits per line

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

9.15

/src/domain/hooks/helpers/event-notifications.helper.ts

import { Inject, Injectable, Module } from '@nestjs/common';
import {
  IMessagesRepository,
  MessagesRepositoryModule,
} from '@/domain/messages/messages.repository.interface';
import {
  ISafeRepository,
  SafeRepositoryModule,
} from '@/domain/safe/safe.repository.interface';
import {
  TransactionEventType,
  ConfigEventType,
} from '@/routes/hooks/entities/event-type.entity';
import { LoggingService, ILoggingService } from '@/logging/logging.interface';
import { Event } from '@/routes/hooks/entities/event.entity';
import {
  INotificationsRepositoryV2,
  NotificationsRepositoryV2Module,
} from '@/domain/notifications/v2/notifications.repository.interface';
import { DeletedMultisigTransactionEvent } from '@/routes/hooks/entities/schemas/deleted-multisig-transaction.schema';
import { ExecutedTransactionEvent } from '@/routes/hooks/entities/schemas/executed-transaction.schema';
import { IncomingEtherEvent } from '@/routes/hooks/entities/schemas/incoming-ether.schema';
import { IncomingTokenEvent } from '@/routes/hooks/entities/schemas/incoming-token.schema';
import { ModuleTransactionEvent } from '@/routes/hooks/entities/schemas/module-transaction.schema';
import { PendingTransactionEvent } from '@/routes/hooks/entities/schemas/pending-transaction.schema';
import { MessageCreatedEvent } from '@/routes/hooks/entities/schemas/message-created.schema';
import {
  IncomingEtherNotification,
  IncomingTokenNotification,
  ConfirmationRequestNotification,
  MessageConfirmationNotification,
  Notification,
  NotificationType,
} from '@/domain/notifications/v2/entities/notification.entity';
import {
  DelegatesV2RepositoryModule,
  IDelegatesV2Repository,
} from '@/domain/delegate/v2/delegates.v2.repository.interface';
import { UUID } from 'crypto';

type EventToNotify =
  | DeletedMultisigTransactionEvent
  | ExecutedTransactionEvent
  | IncomingEtherEvent
  | IncomingTokenEvent
  | ModuleTransactionEvent
  | MessageCreatedEvent
  | PendingTransactionEvent;

@Injectable()
export class EventNotificationsHelper {
  constructor(
    @Inject(IDelegatesV2Repository)
    private readonly delegatesRepository: IDelegatesV2Repository,
    @Inject(IMessagesRepository)
    private readonly messagesRepository: IMessagesRepository,
    @Inject(ISafeRepository)
    private readonly safeRepository: ISafeRepository,
    @Inject(LoggingService)
    private readonly loggingService: ILoggingService,
    @Inject(INotificationsRepositoryV2)
    private readonly notificationsRepository: INotificationsRepositoryV2,
  ) {}

  /**
   * Enqueues notifications for the relevant events to owners/delegates
   * and non-owners/delegates of a Safe accordingly.
   *
   * @param event - {@link Event} to notify about
   */
  public async onEventEnqueueNotifications(event: Event): Promise<unknown> {
    if (!this.isEventToNotify(event)) {
      return;
    }

    const subscriptions = await this.getRelevantSubscribers(event);

    return await Promise.allSettled(
      subscriptions.map(async (subscription) => {
        const data = await this.mapEventNotification(
          event,
          subscription.subscriber,
        );

        if (!data) {
          return;
        }

        return this.notificationsRepository
          .enqueueNotification({
            token: subscription.cloudMessagingToken,
            deviceUuid: subscription.deviceUuid,
            notification: {
              data,
            },
          })
          .then(() => {
            this.loggingService.info('Notification sent successfully');
          })
          .catch((e) => {
            this.loggingService.error(
              `Failed to send notification: ${e.reason}`,
            );
          });
      }),
    );
  }

  /**
   * Checks if the event is to be notified.
   *
   * @param event - {@link Event} to check
   */
  private isEventToNotify(event: Event): event is EventToNotify {
    // TODO: Simplify this by inverting the logic and/or refactor mapEventNotification to explicitly handle types
    return (
      // Don't notify about Config events
      event.type !== ConfigEventType.CHAIN_UPDATE &&
      event.type !== ConfigEventType.SAFE_APPS_UPDATE &&
      // We otherwise notify about executed transactions
      event.type !== TransactionEventType.OUTGOING_ETHER &&
      event.type !== TransactionEventType.OUTGOING_TOKEN &&
      // We only notify required confirmations on creation - see PENDING_MULTISIG_TRANSACTION
      event.type !== TransactionEventType.NEW_CONFIRMATION &&
      // We only notify required confirmations on required - see MESSAGE_CREATED
      event.type !== TransactionEventType.MESSAGE_CONFIRMATION &&
      // You cannot subscribe to Safes-to-be-created
      event.type !== TransactionEventType.SAFE_CREATED &&
      // We don't notify about reorgs
      event.type !== TransactionEventType.REORG_DETECTED &&
      // We don't notify about delegate events
      event.type !== TransactionEventType.NEW_DELEGATE &&
      event.type !== TransactionEventType.UPDATED_DELEGATE &&
      event.type !== TransactionEventType.DELETED_DELEGATE
    );
  }

  /**
   * Checks if the event an owner/delegate only event.
   * @param event - {@link EventToNotify} to check
   */
  private isOwnerOrDelegateOnlyEventToNotify(
    event: EventToNotify,
  ): event is PendingTransactionEvent | MessageCreatedEvent {
    // We only notify required confirmation events to owners or delegates
    // to prevent other subscribers from receiving "private" events
    return (
      event.type === TransactionEventType.PENDING_MULTISIG_TRANSACTION ||
      event.type === TransactionEventType.MESSAGE_CREATED
    );
  }

  /**
   * Gets subscribers and their device UUID/cloud messaging tokens for the
   * given Safe depending on the event type.
   *
   * @param event - {@link EventToNotify} to get subscribers for
   *
   * @returns - List of subscribers/tokens for given Safe
   */
  private async getRelevantSubscribers(event: EventToNotify): Promise<
    Array<{
      subscriber: `0x${string}` | null;
      deviceUuid: UUID;
      cloudMessagingToken: string;
    }>
  > {
    const subscriptions =
      await this.notificationsRepository.getSubscribersBySafe({
        chainId: event.chainId,
        safeAddress: event.address,
      });

    if (!this.isOwnerOrDelegateOnlyEventToNotify(event)) {
      return subscriptions;
    }

    const ownersAndDelegates = await Promise.allSettled(
      subscriptions.map(async (subscription) => {
        if (!subscription.subscriber) {
          return;
        }

        const isOwnerOrDelegate = await this.isOwnerOrDelegate({
          chainId: event.chainId,
          safeAddress: event.address,
          subscriber: subscription.subscriber,
        });

        if (!isOwnerOrDelegate) {
          return;
        }

        return subscription;
      }),
    );

    return ownersAndDelegates
      .filter(
        <T>(
          item: PromiseSettledResult<T>,
        ): item is PromiseFulfilledResult<NonNullable<T>> => {
          return item.status === 'fulfilled' && !!item.value;
        },
      )
      .map((result) => result.value);
  }

  /**
   * Checks if the subscriber is an owner or delegate of the Safe.
   *
   * @param args.chainId - Chain ID
   * @param args.safeAddress - Safe address
   * @param args.subscriber - Subscriber address
   *
   * @returns - True if the subscriber is an owner or delegate of the Safe, otherwise false
   */
  private async isOwnerOrDelegate(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    subscriber: `0x${string}`;
  }): Promise<boolean> {
    // We don't use Promise.all avoid unnecessary calls for delegates
    const safe = await this.safeRepository.getSafe({
      chainId: args.chainId,
      address: args.safeAddress,
    });
    if (safe?.owners.includes(args.subscriber)) {
      return true;
    }

    const delegates = await this.delegatesRepository.getDelegates(args);
    return !!delegates?.results.some((delegate) => {
      return (
        delegate.safe === args.safeAddress &&
        delegate.delegate === args.subscriber
      );
    });
  }

  /**
   * Maps an {@link EventToNotify} to a notification.
   *
   * @param event - {@link EventToNotify} to map
   * @param subscriber - Subscriber address
   *
   * @returns - The {@link Notification} if the conditions are met, otherwise null
   */
  private async mapEventNotification(
    event: EventToNotify,
    subscriber: `0x${string}` | null,
  ): Promise<Notification | null> {
    if (
      event.type === TransactionEventType.INCOMING_ETHER ||
      event.type === TransactionEventType.INCOMING_TOKEN
    ) {
      return await this.mapIncomingAssetEventNotification(event);
    } else if (
      event.type === TransactionEventType.PENDING_MULTISIG_TRANSACTION
    ) {
      if (!subscriber) {
        return null;
      }
      return await this.mapPendingMultisigTransactionEventNotification(
        event,
        subscriber,
      );
    } else if (event.type === TransactionEventType.MESSAGE_CREATED) {
      if (!subscriber) {
        return null;
      }
      return await this.mapMessageCreatedEventNotification(event, subscriber);
    } else {
      return event;
    }
  }

  /**
   * Maps {@link IncomingEtherEvent} or {@link IncomingTokenEvent} to {@link IncomingEtherNotification} or {@link IncomingTokenNotification} if:
   *
   * - The asset was sent to the Safe by another address.
   *
   * @param event - {@link IncomingEtherEvent} or {@link IncomingTokenEvent} to map
   *
   * @returns - The {@link IncomingEtherNotification} or {@link IncomingTokenNotification} if the conditions are met, otherwise null
   */
  private async mapIncomingAssetEventNotification(
    event: IncomingEtherEvent | IncomingTokenEvent,
  ): Promise<IncomingEtherNotification | IncomingTokenNotification | null> {
    const incomingTransfers = await this.safeRepository
      .getIncomingTransfers({
        chainId: event.chainId,
        safeAddress: event.address,
        txHash: event.txHash,
      })
      .catch(() => null);

    const transfer = incomingTransfers?.results?.find((result) => {
      return result.transactionHash === event.txHash;
    });

    // Asset sent to self - do not notify
    if (transfer?.from === event.address) {
      return null;
    }

    return event;
  }

  /**
   * Maps {@link PendingTransactionEvent} to {@link ConfirmationRequestNotification} if:
   *
   * - The Safe has a threshold > 1.
   * - The subscriber didn't create the transaction.
   *
   * @param event - {@link PendingTransactionEvent} to map
   * @param subscriber - Subscriber address
   *
   * @returns - The {@link ConfirmationRequestNotification} if the conditions are met, otherwise null
   */
  private async mapPendingMultisigTransactionEventNotification(
    event: PendingTransactionEvent,
    subscriber: `0x${string}`,
  ): Promise<ConfirmationRequestNotification | null> {
    const safe = await this.safeRepository.getSafe({
      chainId: event.chainId,
      address: event.address,
    });

    // Transaction is confirmed and awaiting execution - do not notify
    if (safe.threshold === 1) {
      return null;
    }

    const transaction = await this.safeRepository.getMultiSigTransaction({
      chainId: event.chainId,
      safeTransactionHash: event.safeTxHash,
    });

    // Subscriber has already signed - do not notify
    const hasSubscriberSigned = transaction.confirmations?.some(
      (confirmation) => {
        return confirmation.owner === subscriber;
      },
    );
    if (hasSubscriberSigned) {
      return null;
    }

    return {
      type: NotificationType.CONFIRMATION_REQUEST,
      chainId: event.chainId,
      address: event.address,
      safeTxHash: event.safeTxHash,
    };
  }

  /**
   * Maps {@link MessageCreatedEvent} to {@link MessageConfirmationNotification} if:
   *
   * - The Safe has a threshold > 1.
   * - The subscriber didn't create the message.
   *
   * @param event - {@link MessageCreatedEvent} to map
   * @param subscriber - Subscriber address
   *
   * @returns - The {@link MessageConfirmationNotification} if the conditions are met, otherwise null
   */
  private async mapMessageCreatedEventNotification(
    event: MessageCreatedEvent,
    subscriber: `0x${string}`,
  ): Promise<MessageConfirmationNotification | null> {
    const safe = await this.safeRepository.getSafe({
      chainId: event.chainId,
      address: event.address,
    });

    // Message is confirmed - do not notify
    if (safe.threshold === 1) {
      return null;
    }

    const message = await this.messagesRepository.getMessageByHash({
      chainId: event.chainId,
      messageHash: event.messageHash,
    });

    // Subscriber has already signed - do not notify
    const hasSubscriberSigned = message.confirmations.some((confirmation) => {
      return confirmation.owner === subscriber;
    });
    if (hasSubscriberSigned) {
      return null;
    }

    return {
      type: NotificationType.MESSAGE_CONFIRMATION_REQUEST,
      chainId: event.chainId,
      address: event.address,
      messageHash: event.messageHash,
    };
  }
}

@Module({
  imports: [
    DelegatesV2RepositoryModule,
    MessagesRepositoryModule,
    SafeRepositoryModule,
    NotificationsRepositoryV2Module,
  ],
  providers: [EventNotificationsHelper],
  exports: [EventNotificationsHelper],
})
export class EventNotificationsHelperModule {}

1	import { Inject, Injectable, Module } from '@nestjs/common';	108✔
2	import {	108✔
3	IMessagesRepository,
4	MessagesRepositoryModule,
5	} from '@/domain/messages/messages.repository.interface';
6	import {	108✔
7	ISafeRepository,
8	SafeRepositoryModule,
9	} from '@/domain/safe/safe.repository.interface';
10	import {	108✔
11	TransactionEventType,
12	ConfigEventType,
13	} from '@/routes/hooks/entities/event-type.entity';
14	import { LoggingService, ILoggingService } from '@/logging/logging.interface';	108✔
15	import { Event } from '@/routes/hooks/entities/event.entity';
16	import {	108✔
17	INotificationsRepositoryV2,
18	NotificationsRepositoryV2Module,
19	} from '@/domain/notifications/v2/notifications.repository.interface';
20	import { DeletedMultisigTransactionEvent } from '@/routes/hooks/entities/schemas/deleted-multisig-transaction.schema';
21	import { ExecutedTransactionEvent } from '@/routes/hooks/entities/schemas/executed-transaction.schema';
22	import { IncomingEtherEvent } from '@/routes/hooks/entities/schemas/incoming-ether.schema';
23	import { IncomingTokenEvent } from '@/routes/hooks/entities/schemas/incoming-token.schema';
24	import { ModuleTransactionEvent } from '@/routes/hooks/entities/schemas/module-transaction.schema';
25	import { PendingTransactionEvent } from '@/routes/hooks/entities/schemas/pending-transaction.schema';
26	import { MessageCreatedEvent } from '@/routes/hooks/entities/schemas/message-created.schema';
27	import {	108✔
28	IncomingEtherNotification,
29	IncomingTokenNotification,
30	ConfirmationRequestNotification,
31	MessageConfirmationNotification,
32	Notification,
33	NotificationType,
34	} from '@/domain/notifications/v2/entities/notification.entity';
35	import {	108✔
36	DelegatesV2RepositoryModule,
37	IDelegatesV2Repository,
38	} from '@/domain/delegate/v2/delegates.v2.repository.interface';
39	import { UUID } from 'crypto';
40
41	type EventToNotify =
42	\| DeletedMultisigTransactionEvent
43	\| ExecutedTransactionEvent
44	\| IncomingEtherEvent
45	\| IncomingTokenEvent
46	\| ModuleTransactionEvent
47	\| MessageCreatedEvent
48	\| PendingTransactionEvent;
49
50	@Injectable()
51	export class EventNotificationsHelper {	108✔
52	constructor(
53	@Inject(IDelegatesV2Repository)
54	private readonly delegatesRepository: IDelegatesV2Repository,	66✔
55	@Inject(IMessagesRepository)
56	private readonly messagesRepository: IMessagesRepository,	66✔
57	@Inject(ISafeRepository)
58	private readonly safeRepository: ISafeRepository,	66✔
59	@Inject(LoggingService)
60	private readonly loggingService: ILoggingService,	66✔
61	@Inject(INotificationsRepositoryV2)
62	private readonly notificationsRepository: INotificationsRepositoryV2,	66✔
63	) {}
64
65	/**
66	* Enqueues notifications for the relevant events to owners/delegates
67	* and non-owners/delegates of a Safe accordingly.
68	*
69	* @param event - {@link Event} to notify about
70	*/
71	public async onEventEnqueueNotifications(event: Event): Promise<unknown> {
72	if (!this.isEventToNotify(event)) {	×
73	return;	×
74	}
75
76	const subscriptions = await this.getRelevantSubscribers(event);	×
77
78	return await Promise.allSettled(	×
79	subscriptions.map(async (subscription) => {
80	const data = await this.mapEventNotification(	×
81	event,
82	subscription.subscriber,
83	);
84
85	if (!data) {	×
86	return;	×
87	}
88
89	return this.notificationsRepository	×
90	.enqueueNotification({
91	token: subscription.cloudMessagingToken,
92	deviceUuid: subscription.deviceUuid,
93	notification: {
94	data,
95	},
96	})
97	.then(() => {
98	this.loggingService.info('Notification sent successfully');	×
99	})
100	.catch((e) => {
101	this.loggingService.error(	×
102	`Failed to send notification: ${e.reason}`,
103	);
104	});
105	}),
106	);
107	}
108
109	/**
110	* Checks if the event is to be notified.
111	*
112	* @param event - {@link Event} to check
113	*/
114	private isEventToNotify(event: Event): event is EventToNotify {
115	// TODO: Simplify this by inverting the logic and/or refactor mapEventNotification to explicitly handle types
UNCOV 116	return (	×
117	// Don't notify about Config events
118	event.type !== ConfigEventType.CHAIN_UPDATE &&	×
119	event.type !== ConfigEventType.SAFE_APPS_UPDATE &&
120	// We otherwise notify about executed transactions
121	event.type !== TransactionEventType.OUTGOING_ETHER &&
122	event.type !== TransactionEventType.OUTGOING_TOKEN &&
123	// We only notify required confirmations on creation - see PENDING_MULTISIG_TRANSACTION
124	event.type !== TransactionEventType.NEW_CONFIRMATION &&
125	// We only notify required confirmations on required - see MESSAGE_CREATED
126	event.type !== TransactionEventType.MESSAGE_CONFIRMATION &&
127	// You cannot subscribe to Safes-to-be-created
128	event.type !== TransactionEventType.SAFE_CREATED &&
129	// We don't notify about reorgs
130	event.type !== TransactionEventType.REORG_DETECTED &&
131	// We don't notify about delegate events
132	event.type !== TransactionEventType.NEW_DELEGATE &&
133	event.type !== TransactionEventType.UPDATED_DELEGATE &&
134	event.type !== TransactionEventType.DELETED_DELEGATE
135	);
136	}
137
138	/**
139	* Checks if the event an owner/delegate only event.
140	* @param event - {@link EventToNotify} to check
141	*/
142	private isOwnerOrDelegateOnlyEventToNotify(
143	event: EventToNotify,
144	): event is PendingTransactionEvent \| MessageCreatedEvent {
145	// We only notify required confirmation events to owners or delegates
146	// to prevent other subscribers from receiving "private" events
147	return (	×
148	event.type === TransactionEventType.PENDING_MULTISIG_TRANSACTION \|\|	×
149	event.type === TransactionEventType.MESSAGE_CREATED
150	);
151	}
152
153	/**
154	* Gets subscribers and their device UUID/cloud messaging tokens for the
155	* given Safe depending on the event type.
156	*
157	* @param event - {@link EventToNotify} to get subscribers for
158	*
159	* @returns - List of subscribers/tokens for given Safe
160	*/
161	private async getRelevantSubscribers(event: EventToNotify): Promise<
162	Array<{
163	subscriber: `0x${string}` \| null;
164	deviceUuid: UUID;
165	cloudMessagingToken: string;
166	}>
167	> {
168	const subscriptions =
169	await this.notificationsRepository.getSubscribersBySafe({	×
170	chainId: event.chainId,
171	safeAddress: event.address,
172	});
173
174	if (!this.isOwnerOrDelegateOnlyEventToNotify(event)) {	×
175	return subscriptions;	×
176	}
177
178	const ownersAndDelegates = await Promise.allSettled(	×
179	subscriptions.map(async (subscription) => {
180	if (!subscription.subscriber) {	×
181	return;	×
182	}
183
184	const isOwnerOrDelegate = await this.isOwnerOrDelegate({	×
185	chainId: event.chainId,
186	safeAddress: event.address,
187	subscriber: subscription.subscriber,
188	});
189
190	if (!isOwnerOrDelegate) {	×
191	return;	×
192	}
193
194	return subscription;	×
195	}),
196	);
197
198	return ownersAndDelegates	×
199	.filter(
200	<T>(
201	item: PromiseSettledResult<T>,
202	): item is PromiseFulfilledResult<NonNullable<T>> => {
203	return item.status === 'fulfilled' && !!item.value;	×
204	},
205	)
206	.map((result) => result.value);	×
207	}
208
209	/**
210	* Checks if the subscriber is an owner or delegate of the Safe.
211	*
212	* @param args.chainId - Chain ID
213	* @param args.safeAddress - Safe address
214	* @param args.subscriber - Subscriber address
215	*
216	* @returns - True if the subscriber is an owner or delegate of the Safe, otherwise false
217	*/
218	private async isOwnerOrDelegate(args: {
219	chainId: string;
220	safeAddress: `0x${string}`;
221	subscriber: `0x${string}`;
222	}): Promise<boolean> {
223	// We don't use Promise.all avoid unnecessary calls for delegates
224	const safe = await this.safeRepository.getSafe({	×
225	chainId: args.chainId,
226	address: args.safeAddress,
227	});
228	if (safe?.owners.includes(args.subscriber)) {	×
229	return true;	×
230	}
231
232	const delegates = await this.delegatesRepository.getDelegates(args);	×
233	return !!delegates?.results.some((delegate) => {	×
234	return (	×
235	delegate.safe === args.safeAddress &&	×
236	delegate.delegate === args.subscriber
237	);
238	});
239	}
240
241	/**
242	* Maps an {@link EventToNotify} to a notification.
243	*
244	* @param event - {@link EventToNotify} to map
245	* @param subscriber - Subscriber address
246	*
247	* @returns - The {@link Notification} if the conditions are met, otherwise null
248	*/
249	private async mapEventNotification(
250	event: EventToNotify,
251	subscriber: `0x${string}` \| null,
252	): Promise<Notification \| null> {
253	if (	×
254	event.type === TransactionEventType.INCOMING_ETHER \|\|	×
255	event.type === TransactionEventType.INCOMING_TOKEN
256	) {
257	return await this.mapIncomingAssetEventNotification(event);	×
258	} else if (	×
259	event.type === TransactionEventType.PENDING_MULTISIG_TRANSACTION
260	) {
261	if (!subscriber) {	×
262	return null;	×
263	}
264	return await this.mapPendingMultisigTransactionEventNotification(	×
265	event,
266	subscriber,
267	);
268	} else if (event.type === TransactionEventType.MESSAGE_CREATED) {	×
269	if (!subscriber) {	×
270	return null;	×
271	}
272	return await this.mapMessageCreatedEventNotification(event, subscriber);	×
273	} else {
274	return event;	×
275	}
276	}
277
278	/**
279	* Maps {@link IncomingEtherEvent} or {@link IncomingTokenEvent} to {@link IncomingEtherNotification} or {@link IncomingTokenNotification} if:
280	*
281	* - The asset was sent to the Safe by another address.
282	*
283	* @param event - {@link IncomingEtherEvent} or {@link IncomingTokenEvent} to map
284	*
285	* @returns - The {@link IncomingEtherNotification} or {@link IncomingTokenNotification} if the conditions are met, otherwise null
286	*/
287	private async mapIncomingAssetEventNotification(
288	event: IncomingEtherEvent \| IncomingTokenEvent,
289	): Promise<IncomingEtherNotification \| IncomingTokenNotification \| null> {
290	const incomingTransfers = await this.safeRepository	×
291	.getIncomingTransfers({
292	chainId: event.chainId,
293	safeAddress: event.address,
294	txHash: event.txHash,
295	})
296	.catch(() => null);	×
297
298	const transfer = incomingTransfers?.results?.find((result) => {	×
299	return result.transactionHash === event.txHash;	×
300	});
301
302	// Asset sent to self - do not notify
303	if (transfer?.from === event.address) {	×
304	return null;	×
305	}
306
307	return event;	×
308	}
309
310	/**
311	* Maps {@link PendingTransactionEvent} to {@link ConfirmationRequestNotification} if:
312	*
313	* - The Safe has a threshold > 1.
314	* - The subscriber didn't create the transaction.
315	*
316	* @param event - {@link PendingTransactionEvent} to map
317	* @param subscriber - Subscriber address
318	*
319	* @returns - The {@link ConfirmationRequestNotification} if the conditions are met, otherwise null
320	*/
321	private async mapPendingMultisigTransactionEventNotification(
322	event: PendingTransactionEvent,
323	subscriber: `0x${string}`,
324	): Promise<ConfirmationRequestNotification \| null> {
325	const safe = await this.safeRepository.getSafe({	×
326	chainId: event.chainId,
327	address: event.address,
328	});
329
330	// Transaction is confirmed and awaiting execution - do not notify
331	if (safe.threshold === 1) {	×
332	return null;	×
333	}
334
335	const transaction = await this.safeRepository.getMultiSigTransaction({	×
336	chainId: event.chainId,
337	safeTransactionHash: event.safeTxHash,
338	});
339
340	// Subscriber has already signed - do not notify
341	const hasSubscriberSigned = transaction.confirmations?.some(	×
342	(confirmation) => {
343	return confirmation.owner === subscriber;	×
344	},
345	);
346	if (hasSubscriberSigned) {	×
347	return null;	×
348	}
349
350	return {	×
351	type: NotificationType.CONFIRMATION_REQUEST,
352	chainId: event.chainId,
353	address: event.address,
354	safeTxHash: event.safeTxHash,
355	};
356	}
357
358	/**
359	* Maps {@link MessageCreatedEvent} to {@link MessageConfirmationNotification} if:
360	*
361	* - The Safe has a threshold > 1.
362	* - The subscriber didn't create the message.
363	*
364	* @param event - {@link MessageCreatedEvent} to map
365	* @param subscriber - Subscriber address
366	*
367	* @returns - The {@link MessageConfirmationNotification} if the conditions are met, otherwise null
368	*/
369	private async mapMessageCreatedEventNotification(
370	event: MessageCreatedEvent,
371	subscriber: `0x${string}`,
372	): Promise<MessageConfirmationNotification \| null> {
373	const safe = await this.safeRepository.getSafe({	×
374	chainId: event.chainId,
375	address: event.address,
376	});
377
378	// Message is confirmed - do not notify
379	if (safe.threshold === 1) {	×
380	return null;	×
381	}
382
383	const message = await this.messagesRepository.getMessageByHash({	×
384	chainId: event.chainId,
385	messageHash: event.messageHash,
386	});
387
388	// Subscriber has already signed - do not notify
389	const hasSubscriberSigned = message.confirmations.some((confirmation) => {	×
390	return confirmation.owner === subscriber;	×
391	});
392	if (hasSubscriberSigned) {	×
393	return null;	×
394	}
395
396	return {	×
397	type: NotificationType.MESSAGE_CONFIRMATION_REQUEST,
398	chainId: event.chainId,
399	address: event.address,
400	messageHash: event.messageHash,
401	};
402	}
403	}
404
405	@Module({
406	imports: [
407	DelegatesV2RepositoryModule,
408	MessagesRepositoryModule,
409	SafeRepositoryModule,
410	NotificationsRepositoryV2Module,
411	],
412	providers: [EventNotificationsHelper],
413	exports: [EventNotificationsHelper],
414	})
415	export class EventNotificationsHelperModule {}	108✔

safe-global / safe-client-gateway / 11919262801

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