Send notification only to subscribed accounts (safe-global#1152)

With the introduction of subscriptions, we should send email notifications only to verified accounts which are subscribed to the `account_recovery` category.

src/domain/account/entities/__tests__/subscription.builder.ts

@@ -0,0 +1,9 @@
+import { Builder, IBuilder } from '@/__tests__/builder';
+import { Subscription } from '@/domain/account/entities/subscription.entity';
+import { faker } from '@faker-js/faker';
+
+export function subscriptionBuilder(): IBuilder<Subscription> {
+  return new Builder<Subscription>()
+    .with('key', faker.word.sample())
+    .with('name', faker.word.words());
+}

src/domain/alerts/alerts.domain.module.ts

@@ -6,13 +6,15 @@ import { AlertsDecodersModule } from '@/domain/alerts/alerts-decoders.module';
 import { EmailApiModule } from '@/datasources/email-api/email-api.module';
 import { AccountDomainModule } from '@/domain/account/account.domain.module';
 import { UrlGeneratorModule } from '@/domain/alerts/urls/url-generator.module';
+import { SubscriptionDomainModule } from '@/domain/subscriptions/subscription.domain.module';
 
 @Module({
   imports: [
     AccountDomainModule,
     AlertsApiModule,
     AlertsDecodersModule,
     EmailApiModule,
+    SubscriptionDomainModule,
     UrlGeneratorModule,
   ],
   providers: [{ provide: IAlertsRepository, useClass: AlertsRepository }],

src/domain/alerts/alerts.repository.ts

@@ -15,6 +15,9 @@ import { ISafeRepository } from '@/domain/safe/safe.repository.interface';
 import { Safe } from '@/domain/safe/entities/safe.entity';
 import { UrlGeneratorHelper } from '@/domain/alerts/urls/url-generator.helper';
 import { IChainsRepository } from '@/domain/chains/chains.repository.interface';
+import { ISubscriptionRepository } from '@/domain/subscriptions/subscription.repository.interface';
+import { SubscriptionRepository } from '@/domain/subscriptions/subscription.repository';
+import { Account } from '@/domain/account/entities/account.entity';
 
 @Injectable()
 export class AlertsRepository implements IAlertsRepository {
@@ -40,6 +43,8 @@ export class AlertsRepository implements IAlertsRepository {
     private readonly safeRepository: ISafeRepository,
     @Inject(IChainsRepository)
     private readonly chainRepository: IChainsRepository,
+    @Inject(ISubscriptionRepository)
+    private readonly subscriptionRepository: ISubscriptionRepository,
   ) {}
 
   async addContracts(contracts: Array<AlertsRegistration>): Promise<void> {
@@ -63,14 +68,11 @@ export class AlertsRepository implements IAlertsRepository {
 
     // Recovery module is deployed per Safe so we can assume that it is only enabled on one
     const safeAddress = safes[0];
-
-    const verifiedAccounts = await this.accountRepository.getAccounts({
+    const subscribedAccounts = await this._getSubscribedAccounts({
       chainId,
       safeAddress,
-      onlyVerified: true,
     });
-
-    if (verifiedAccounts.length === 0) {
+    if (subscribedAccounts.length === 0) {
       this.loggingService.debug(
         `An alert for a Safe with no associated emails was received. moduleAddress=${moduleAddress}, safeAddress=${safeAddress}`,
       );
@@ -99,19 +101,55 @@ export class AlertsRepository implements IAlertsRepository {
       await this._notifySafeSetup({
         chainId,
         newSafeState,
+        accountsToNotify: subscribedAccounts,
       });
     } catch {
-      const emails = verifiedAccounts.map(
-        (account) => account.emailAddress.value,
-      );
       await this._notifyUnknownTransaction({
         chainId,
         safeAddress,
-        emails,
+        accountsToNotify: subscribedAccounts,
       });
     }
   }
 
+  /**
+   * Gets all the subscribed accounts to CATEGORY_ACCOUNT_RECOVERY for a given safe
+   *
+   * @param args.chainId - the chain id where the safe is deployed
+   * @param args.safeAddress - the safe address to which the accounts should be retrieved
+   *
+   * @private
+   */
+  private async _getSubscribedAccounts(args: {
+    chainId: string;
+    safeAddress: string;
+  }): Promise<Account[]> {
+    const accounts = await this.accountRepository.getAccounts({
+      chainId: args.chainId,
+      safeAddress: args.safeAddress,
+      onlyVerified: true,
+    });
+
+    const subscribedAccounts = accounts.map(async (account) => {
+      const accountSubscriptions =
+        await this.subscriptionRepository.getSubscriptions({
+          chainId: account.chainId,
+          safeAddress: account.safeAddress,
+          signer: account.signer,
+        });
+      return accountSubscriptions.some(
+        (subscription) =>
+          subscription.key === SubscriptionRepository.CATEGORY_ACCOUNT_RECOVERY,
+      )
+        ? account
+        : null;
+    });
+
+    return (await Promise.all(subscribedAccounts)).filter(
+      (account): account is Account => account !== null,
+    );
+  }
+
   private _decodeTransactionAdded(
     data: Hex,
   ): Array<ReturnType<typeof this._decodeRecoveryTransaction>> {
@@ -197,7 +235,7 @@ export class AlertsRepository implements IAlertsRepository {
   private async _notifyUnknownTransaction(args: {
     safeAddress: string;
     chainId: string;
-    emails: string[];
+    accountsToNotify: Account[];
   }): Promise<void> {
     const chain = await this.chainRepository.getChain(args.chainId);
 
@@ -206,8 +244,11 @@ export class AlertsRepository implements IAlertsRepository {
       safeAddress: args.safeAddress,
     });
 
+    const emails = args.accountsToNotify.map(
+      (account) => account.emailAddress.value,
+    );
     return this.emailApi.createMessage({
-      to: args.emails,
+      to: emails,
       template: this.configurationService.getOrThrow<string>(
         'email.templates.unknownRecoveryTx',
       ),
@@ -221,20 +262,8 @@ export class AlertsRepository implements IAlertsRepository {
   private async _notifySafeSetup(args: {
     chainId: string;
     newSafeState: Safe;
+    accountsToNotify: Account[];
   }): Promise<void> {
-    const verifiedAccounts = await this.accountRepository.getAccounts({
-      chainId: args.chainId,
-      safeAddress: args.newSafeState.address,
-      onlyVerified: true,
-    });
-
-    if (!verifiedAccounts.length) {
-      this.loggingService.debug(
-        `An alert log for an transaction with no verified emails associated was thrown for Safe ${args.newSafeState.address}`,
-      );
-      return;
-    }
-
     const chain = await this.chainRepository.getChain(args.chainId);
 
     const webAppUrl = this.urlGenerator.addressToSafeWebAppUrl({
@@ -251,7 +280,7 @@ export class AlertsRepository implements IAlertsRepository {
       };
     });
 
-    const emails = verifiedAccounts.map(
+    const emails = args.accountsToNotify.map(
       (account) => account.emailAddress.value,
     );
     return this.emailApi.createMessage({

src/domain/subscriptions/subscription.repository.interface.ts

@@ -3,6 +3,12 @@ import { Subscription } from '@/domain/account/entities/subscription.entity';
 export const ISubscriptionRepository = Symbol('ISubscriptionRepository');
 
 export interface ISubscriptionRepository {
+  getSubscriptions(args: {
+    chainId: string;
+    safeAddress: string;
+    signer: string;
+  }): Promise<Subscription[]>;
+
   subscribe(args: {
     chainId: string;
     safeAddress: string;

src/domain/subscriptions/subscription.repository.ts

@@ -12,6 +12,14 @@ export class SubscriptionRepository implements ISubscriptionRepository {
     private readonly accountDataSource: IAccountDataSource,
   ) {}
 
+  getSubscriptions(args: {
+    chainId: string;
+    safeAddress: string;
+    signer: string;
+  }): Promise<Subscription[]> {
+    return this.accountDataSource.getSubscriptions(args);
+  }
+
   subscribe(args: {
     chainId: string;
     safeAddress: string;