Feat/settings flow

.gitignore

@@ -178,3 +178,4 @@ out
 .yarn/build-state.yml
 .yarn/install-state.gz
 .pnp.*
+.worktrees/

apps/consumers/src/app.ts

@@ -6,8 +6,10 @@ import { WebhookController } from './services/webhook/webhook.controller';
 import { WebhookServer } from './services/webhook/webhook-server';
 import { SlackDAOService } from './services/dao/slack-dao.service';
 import { SlackWalletService } from './services/wallet/slack-wallet.service';
+import { SlackSettingsService } from './services/settings/slack-settings.service';
 import { TelegramDAOService } from './services/dao/telegram-dao.service';
 import { TelegramWalletService } from './services/wallet/telegram-wallet.service';
+import { TelegramSettingsService } from './services/settings/telegram-settings.service';
 import { ExplorerService } from '@notification-system/messages';
 import { EnsResolverService } from './services/ens-resolver.service';
 import { AnticaptureClient } from '@notification-system/anticapture-client';
@@ -42,23 +44,27 @@ export class App {
     // Telegram services
     const telegramDaoService = new TelegramDAOService(anticaptureClient, subscriptionApi);
     const telegramWalletService = new TelegramWalletService(subscriptionApi, ensResolver);
+    const telegramSettingsService = new TelegramSettingsService(subscriptionApi);
 
     this.telegramBotService = new TelegramBotService(
       telegramClient,
       telegramDaoService,
       telegramWalletService,
+      telegramSettingsService,
       explorerService,
       ensResolver
     );
 
     const slackDaoService = new SlackDAOService(anticaptureClient, subscriptionApi);
     const slackWalletService = new SlackWalletService(subscriptionApi, ensResolver);
+    const slackSettingsService = new SlackSettingsService(subscriptionApi);
 
     this.slackBotService = new SlackBotService(
       slackClient,
       ensResolver,
       slackDaoService,
-      slackWalletService
+      slackWalletService,
+      slackSettingsService
     );
 
     this.webhookService = new WebhookService(anticaptureClient, subscriptionApi);

apps/consumers/src/config/knownCommands.ts

@@ -9,5 +9,6 @@
 export const knownCommands = [
     { command: '/start', description: 'Start the bot' },
     { command: '/daos', description: 'Manage your DAO notifications' },
-    { command: '/learn_more', description: 'Learn more about Anticapture' }
+    { command: '/learn_more', description: 'Learn more about Anticapture' },
+    { command: '/settings', description: 'Manage your notification preferences' }
   ];

apps/consumers/src/interfaces/bot.interface.ts

@@ -11,6 +11,7 @@ export interface ContextWithSession extends Context {
         walletsToRemove?: Set<string>;
         awaitingWalletInput?: boolean;
         fromStart?: boolean;
+        notificationSelections?: Record<string, boolean>;
     };
 }
 

apps/consumers/src/interfaces/slack-context.interface.ts

@@ -58,6 +58,7 @@ export interface SlackSession {
     action: 'add' | 'remove';
   };
   fromStart?: boolean;
+  notificationSelections?: Record<string, boolean>;
 }
 
 /**

apps/consumers/src/services/bot/slack-bot.service.ts

@@ -12,24 +12,28 @@ import { slackMessages, convertMarkdownToSlack, appendUtmParams } from '@notific
 import { EnsResolverService } from '../ens-resolver.service';
 import { SlackDAOService } from '../dao/slack-dao.service';
 import { SlackWalletService } from '../wallet/slack-wallet.service';
+import { SlackSettingsService } from '../settings/slack-settings.service';
 import { SlackCommandContext } from '../../interfaces/slack-context.interface';
 
 export class SlackBotService implements BotServiceInterface {
   private slackClient: SlackClientInterface;
   private ensResolver: EnsResolverService;
   private daoService?: SlackDAOService;
   private walletService?: SlackWalletService;
+  private settingsService?: SlackSettingsService;
 
   constructor(
     slackClient: SlackClientInterface,
     ensResolver: EnsResolverService,
     daoService?: SlackDAOService,
-    walletService?: SlackWalletService
+    walletService?: SlackWalletService,
+    settingsService?: SlackSettingsService
   ) {
     this.slackClient = slackClient;
     this.ensResolver = ensResolver;
     this.daoService = daoService;
     this.walletService = walletService;
+    this.settingsService = settingsService;
 
     this.setupCommands();
   }
@@ -124,6 +128,23 @@ export class SlackBotService implements BotServiceInterface {
           await this.walletService.processWalletSubmission(ctx);
         }
       });
+
+      // Settings actions
+      handlers.action('settings_open', async (ctx) => {
+        if (this.settingsService) {
+          await this.settingsService.initialize(ctx);
+        }
+      });
+
+      handlers.action('settings_checkboxes', async (ctx) => {
+        await ctx.ack();
+      });
+
+      handlers.action('settings_confirm', async (ctx) => {
+        if (this.settingsService) {
+          await this.settingsService.confirm(ctx);
+        }
+      });
     });
   }
 

apps/consumers/src/services/bot/telegram-bot.service.ts

@@ -8,6 +8,7 @@ import { Markup } from 'telegraf';
 import { telegramMessages, uiMessages, ExplorerService, appendUtmParams } from '@notification-system/messages';
 import { TelegramDAOService } from '../dao/telegram-dao.service';
 import { TelegramWalletService } from '../wallet/telegram-wallet.service';
+import { TelegramSettingsService } from '../settings/telegram-settings.service';
 import { EnsResolverService } from '../ens-resolver.service';
 import { ContextWithSession, MatchedContext } from '../../interfaces/bot.interface';
 import { NotificationPayload } from '../../interfaces/notification.interface';
@@ -18,19 +19,22 @@ export class TelegramBotService implements BotServiceInterface {
   private telegramClient: TelegramClientInterface;
   private daoService: TelegramDAOService;
   private walletService: TelegramWalletService;
+  private settingsService: TelegramSettingsService;
   private explorerService: ExplorerService;
   private ensResolver: EnsResolverService;
 
   constructor(
     telegramClient: TelegramClientInterface,
     daoService: TelegramDAOService,
     walletService: TelegramWalletService,
+    settingsService: TelegramSettingsService,
     explorerService: ExplorerService,
     ensResolver: EnsResolverService
   ) {
     this.telegramClient = telegramClient;
     this.daoService = daoService;
     this.walletService = walletService;
+    this.settingsService = settingsService;
     this.explorerService = explorerService;
     this.ensResolver = ensResolver;
     this.setupCommands();
@@ -42,7 +46,7 @@ export class TelegramBotService implements BotServiceInterface {
   private createPersistentKeyboard() {
     return Markup.keyboard([
       [uiMessages.buttons.daos, uiMessages.buttons.myWallets],
-      [uiMessages.buttons.learnMore]
+      [uiMessages.buttons.settings, uiMessages.buttons.learnMore]
     ])
     .resize()
     .persistent();
@@ -78,6 +82,14 @@ export class TelegramBotService implements BotServiceInterface {
         await this.replyLearnMore(ctx);
       });
 
+      handlers.command(/^settings$/i, async (ctx) => {
+        await this.settingsService.initialize(ctx);
+      });
+
+      handlers.hears(uiMessages.buttons.settings, async (ctx) => {
+        await this.settingsService.initialize(ctx);
+      });
+
       handlers.action(/^start$/, async (ctx) => {
         await ctx.answerCbQuery();
         if (ctx.session) ctx.session.fromStart = true;
@@ -145,8 +157,20 @@ export class TelegramBotService implements BotServiceInterface {
         await this.walletService.initialize(ctx);
       });
 
+      handlers.action(/^settings_toggle_(.+)$/, async (ctx) => {
+        await ctx.answerCbQuery();
+        const matchedCtx = ctx as MatchedContext;
+        await this.settingsService.toggle(ctx, matchedCtx.match[1]);
+      });
+
+      handlers.action(/^settings_confirm$/, async (ctx) => {
+        await ctx.answerCbQuery();
+        await this.settingsService.confirm(ctx);
+      });
+
       handlers.action(/^learn_more_settings$/, async (ctx) => {
-        await ctx.answerCbQuery(uiMessages.buttons.settingsComingSoon);
+        await ctx.answerCbQuery();
+        await this.settingsService.initialize(ctx);
       });
 
       handlers.on('message', async (ctx, next) => {

apps/consumers/src/services/settings/base-settings.service.ts

@@ -0,0 +1,41 @@
+import { NotificationTypeId } from '@notification-system/messages';
+import { SubscriptionAPIService } from '../subscription-api.service';
+
+export abstract class BaseSettingsService {
+  constructor(
+    protected subscriptionApi: SubscriptionAPIService,
+    protected platform: string
+  ) {}
+
+  protected async loadPreferences(channelUserId: string): Promise<Record<NotificationTypeId, boolean>> {
+    const stored = await this.subscriptionApi.getNotificationPreferences(
+      this.platform,
+      channelUserId
+    );
+    const result = {} as Record<NotificationTypeId, boolean>;
+    for (const id of Object.values(NotificationTypeId)) {
+      result[id] = true; // default: enabled
+    }
+    for (const pref of stored) {
+      if (pref.trigger_type in result) {
+        result[pref.trigger_type] = pref.is_active;
+      }
+    }
+    return result;
+  }
+
+  protected async savePreferences(
+    channelUserId: string,
+    selections: Record<NotificationTypeId, boolean>
+  ): Promise<void> {
+    const preferences = Object.values(NotificationTypeId).map(id => ({
+      trigger_type: id,
+      is_active: selections[id] ?? true,
+    }));
+    await this.subscriptionApi.saveNotificationPreferences(
+      this.platform,
+      channelUserId,
+      preferences
+    );
+  }
+}

apps/consumers/src/services/settings/slack-settings.service.ts

@@ -0,0 +1,133 @@
+import { NOTIFICATION_TYPES, NotificationTypeId } from '@notification-system/messages';
+import { BaseSettingsService } from './base-settings.service';
+import { SubscriptionAPIService } from '../subscription-api.service';
+import { SlackActionContext } from '../../interfaces/slack-context.interface';
+
+export class SlackSettingsService extends BaseSettingsService {
+  constructor(subscriptionApi: SubscriptionAPIService) {
+    super(subscriptionApi, 'slack');
+  }
+
+  async initialize(ctx: SlackActionContext): Promise<void> {
+    const channelId = ctx.body.channel?.id || ctx.body.channel_id;
+    const workspaceId = ctx.body.team?.id || ctx.body.team_id || ctx.body.user?.team_id;
+    const fullUserId = `${workspaceId}:${channelId}`;
+
+    try {
+      await ctx.ack();
+
+      const preferences = await this.loadPreferences(fullUserId);
+      ctx.session.notificationSelections = preferences;
+
+      const notificationTypeIds = Object.values(NotificationTypeId);
+      const options = notificationTypeIds.map(id => ({
+        text: { type: 'plain_text' as const, text: NOTIFICATION_TYPES[id] },
+        value: id,
+      }));
+
+      const initialOptions = notificationTypeIds
+        .filter(id => preferences[id])
+        .map(id => ({
+          text: { type: 'plain_text' as const, text: NOTIFICATION_TYPES[id] },
+          value: id,
+        }));
+
+      const blocks = [
+        {
+          type: 'header' as const,
+          text: { type: 'plain_text' as const, text: '⚙️ Notification Settings' }
+        },
+        {
+          type: 'section' as const,
+          text: { type: 'mrkdwn' as const, text: 'Choose which notifications you want to receive:' }
+        },
+        {
+          type: 'actions' as const,
+          block_id: 'settings_checkboxes_block',
+          elements: [{
+            type: 'checkboxes' as const,
+            action_id: 'settings_checkboxes',
+            options,
+            ...(initialOptions.length > 0 ? { initial_options: initialOptions } : {})
+          }]
+        },
+        {
+          type: 'actions' as const,
+          elements: [{
+            type: 'button' as const,
+            text: { type: 'plain_text' as const, text: '✅ Save Settings' },
+            action_id: 'settings_confirm',
+            style: 'primary' as const
+          }]
+        }
+      ];
+
+      if (ctx.respond) {
+        await ctx.respond({
+          blocks,
+          text: 'Notification Settings',
+          response_type: 'in_channel',
+          replace_original: false
+        });
+      }
+    } catch (error) {
+      console.error('Error loading notification settings:', error);
+      if (ctx.respond) {
+        await ctx.respond({
+          text: 'Sorry, there was an error loading your settings. Please try again later.',
+          response_type: 'ephemeral'
+        });
+      }
+    }
+  }
+
+  async confirm(ctx: SlackActionContext): Promise<void> {
+    const channelId = ctx.body.channel?.id || ctx.body.channel_id;
+    const workspaceId = ctx.body.team?.id || ctx.body.team_id || ctx.body.user?.team_id;
+    const fullUserId = `${workspaceId}:${channelId}`;
+
+    try {
+      await ctx.ack();
+
+      // Extract selected checkbox values from state
+      const stateValues = typeof ctx.body.state === 'object' ? ctx.body.state?.values : undefined;
+      const selectedValues = new Set<string>();
+
+      if (stateValues) {
+        const checkboxBlock = stateValues['settings_checkboxes_block'];
+        if (checkboxBlock?.['settings_checkboxes']) {
+          const selectedOptions = checkboxBlock['settings_checkboxes'].selected_options || [];
+          for (const option of selectedOptions) {
+            if (option.value) {
+              selectedValues.add(option.value);
+            }
+          }
+        }
+      }
+
+      // Build selections record: selected = true, unselected = false
+      const selections = {} as Record<NotificationTypeId, boolean>;
+      for (const id of Object.values(NotificationTypeId)) {
+        selections[id] = selectedValues.has(id);
+      }
+
+      await this.savePreferences(fullUserId, selections);
+
+      if (ctx.respond) {
+        await ctx.respond({
+          text: '✅ Your notification preferences have been saved!',
+          response_type: 'in_channel',
+          replace_original: false
+        });
+      }
+    } catch (error) {
+      console.error('Error saving notification settings:', error);
+      if (ctx.respond) {
+        await ctx.respond({
+          text: '❌ Failed to save your preferences. Please try again.',
+          response_type: 'ephemeral'
+        });
+      }
+    }
+  }
+}