Merge pull request #215 from blockful/dev

v1.0.1

Author: LeonardoVieira1630

apps/dispatcher/src/services/triggers/new-proposal-trigger.service.test.ts

@@ -80,7 +80,7 @@ describe('NewProposalTriggerHandler', () => {
       getProposalById: jest.fn(),
       listProposals: jest.fn(),
       listVotingPowerHistory: jest.fn(),
-      listVotesOnchains: jest.fn(),
+      listVotes: jest.fn(),
       listRecentVotesFromAllDaos: jest.fn()
     } as unknown as jest.Mocked<AnticaptureClient>;
 

apps/dispatcher/src/services/triggers/non-voting-handler.test-factory.ts

@@ -53,9 +53,9 @@ export function createUser(overrides: Partial<User> = {}): User {
   };
 }
 
-export function createVote(voterAccountId: string, proposalId: string) {
+export function createVote(voterAddress: string, proposalId: string) {
   return {
-    voterAccountId,
+    voterAddress,
     proposalId
   };
 }

apps/dispatcher/src/services/triggers/vote-confirmation-trigger.service.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from '@jest/globals';
+import { VoteConfirmationTriggerHandler } from './vote-confirmation-trigger.service';
+import { NotificationClientFactory } from '../notification/notification-factory.service';
+import { AnticaptureClient } from '@notification-system/anticapture-client';
+import { NotificationPayload } from '../../interfaces/notification-client.interface';
+
+function createHandler() {
+  const sentNotifications: NotificationPayload[] = [];
+  const sentEventIds = new Set<string>();
+  const stubUser = { id: '1', channel: 'telegram', channel_user_id: '123', created_at: new Date() };
+
+  const handler = new VoteConfirmationTriggerHandler(
+    {
+      getDaoSubscribers: async () => [stubUser],
+      shouldSend: async (users, eventId) => {
+        if (sentEventIds.has(eventId)) return [];
+        return users.map(u => ({ user_id: u.id, event_id: eventId, dao_id: 'test-dao' }));
+      },
+      shouldSendBatch: async () => [],
+      markAsSent: async (notifications) => {
+        notifications.forEach(n => sentEventIds.add(n.event_id));
+      },
+      getWalletOwners: async () => [],
+      getWalletOwnersBatch: async () => ({ '0xVoter123': [stubUser] }),
+      getFollowedAddresses: async () => []
+    },
+    {
+      getClient: () => ({ sendNotification: async (n: NotificationPayload) => { sentNotifications.push(n); } }),
+      supportsChannel: () => true
+    } as unknown as NotificationClientFactory,
+    {
+      getDAOs: async () => [{ id: 'test-dao', chainId: 1, blockTime: 12, votingDelay: '0' }]
+    } as AnticaptureClient
+  );
+
+  return { handler, sentNotifications };
+}
+
+describe('VoteConfirmationTriggerHandler', () => {
+  it('should send one notification per vote in batch voting (same tx, multiple proposals)', async () => {
+    const { handler, sentNotifications } = createHandler();
+
+    await handler.handleMessage({
+      triggerId: 'vote-confirmation',
+      events: [
+        { daoId: 'test-dao', proposalId: 'proposal-1', voterAddress: '0xVoter123', support: 1, votingPower: '1000000000000000000', timestamp: 1767225600, transactionHash: '0xSameTxHash', proposalTitle: 'Proposal 1' },
+        { daoId: 'test-dao', proposalId: 'proposal-2', voterAddress: '0xVoter123', support: 0, votingPower: '1000000000000000000', timestamp: 1767225600, transactionHash: '0xSameTxHash', proposalTitle: 'Proposal 2' },
+        { daoId: 'test-dao', proposalId: 'proposal-3', voterAddress: '0xVoter123', support: 2, votingPower: '1000000000000000000', timestamp: 1767225600, transactionHash: '0xSameTxHash', proposalTitle: 'Proposal 3' },
+      ]
+    });
+
+    expect(sentNotifications).toHaveLength(3);
+  });
+});

apps/dispatcher/src/services/triggers/vote-confirmation-trigger.service.ts

@@ -2,26 +2,13 @@ import { BaseTriggerHandler } from './base-trigger.service';
 import { DispatcherMessage, MessageProcessingResult } from '../../interfaces/dispatcher-message.interface';
 import { NotificationClientFactory } from '../notification/notification-factory.service';
 import { ISubscriptionClient } from '../../interfaces/subscription-client.interface';
-import { AnticaptureClient } from '@notification-system/anticapture-client';
+import { AnticaptureClient, VoteWithDaoId } from '@notification-system/anticapture-client';
 import { formatTokenAmount } from '../../lib/number-formatter';
 import { voteConfirmationMessages, replacePlaceholders, buildButtons } from '@notification-system/messages';
-import { FormattingService } from '../formatting.service';
-
-interface VoteEvent {
-  daoId: string;
-  proposalId: string;
-  voterAccountId: string;
-  support: string;
-  votingPower: string;
-  timestamp: string;
-  txHash: string;
-  reason?: string | null;
-  proposalDescription?: string | null;
-}
 
 interface UserVoteCombination {
   user: any;
-  vote: VoteEvent;
+  vote: VoteWithDaoId;
 }
 
 interface ProcessingResult {
@@ -33,7 +20,7 @@ interface ProcessingResult {
 type ProcessingStatus = 'sent' | 'skipped';
 
 
-export class VoteConfirmationTriggerHandler extends BaseTriggerHandler<VoteEvent> {
+export class VoteConfirmationTriggerHandler extends BaseTriggerHandler<VoteWithDaoId> {
   constructor(
     protected readonly subscriptionClient: ISubscriptionClient,
     protected readonly notificationFactory: NotificationClientFactory,
@@ -42,7 +29,7 @@ export class VoteConfirmationTriggerHandler extends BaseTriggerHandler<VoteEvent
     super(subscriptionClient, notificationFactory, anticaptureClient);
   }
 
-  async handleMessage(message: DispatcherMessage<VoteEvent>): Promise<MessageProcessingResult> {
+  async handleMessage(message: DispatcherMessage<VoteWithDaoId>): Promise<MessageProcessingResult> {
     const events = message.events;
 
     if (!events || events.length === 0) {
@@ -54,7 +41,7 @@ export class VoteConfirmationTriggerHandler extends BaseTriggerHandler<VoteEvent
     }
 
     // Extract unique voter addresses and batch fetch wallet owners
-    const voterAddresses = [...new Set(events.map(event => event.voterAccountId))];
+    const voterAddresses = [...new Set(events.map(event => event.voterAddress))];
     const walletOwners = await this.subscriptionClient.getWalletOwnersBatch(voterAddresses);
 
     // Create all user-vote combinations
@@ -75,11 +62,11 @@ export class VoteConfirmationTriggerHandler extends BaseTriggerHandler<VoteEvent
    * Creates combinations of users and votes for processing
    */
   private createUserVoteCombinations(
-    events: VoteEvent[],
+    events: VoteWithDaoId[],
     walletOwners: Record<string, any[]>
   ): UserVoteCombination[] {
     return events.flatMap(voteEvent => {
-      const usersForWallet = walletOwners[voteEvent.voterAccountId] || [];
+      const usersForWallet = walletOwners[voteEvent.voterAddress] || [];
       return usersForWallet.map(user => ({ user, vote: voteEvent }));
     });
   }
@@ -106,9 +93,11 @@ export class VoteConfirmationTriggerHandler extends BaseTriggerHandler<VoteEvent
   /**
    * Processes a single user-vote combination
    */
-  private async processUserVote(user: any, vote: VoteEvent): Promise<ProcessingStatus> {
+  private async processUserVote(user: any, vote: VoteWithDaoId): Promise<ProcessingStatus> {
+    const eventId = `${vote.transactionHash}-${vote.proposalId}-${vote.voterAddress}-vote`;
+
     // Check if user is subscribed to the DAO
-    const subscribers = await this.getSubscribers(vote.daoId, vote.txHash, vote.timestamp);
+    const subscribers = await this.getSubscribers(vote.daoId, eventId, String(vote.timestamp));
     const isSubscribed = subscribers.some(sub => sub.id === user.id);
 
     if (!isSubscribed) {
@@ -117,14 +106,14 @@ export class VoteConfirmationTriggerHandler extends BaseTriggerHandler<VoteEvent
     }
 
     // Check deduplication
-    const notifications = await this.subscriptionClient.shouldSend([user], vote.txHash, vote.daoId);
+    const notifications = await this.subscriptionClient.shouldSend([user], eventId, vote.daoId);
     if (notifications.length === 0) {
-      console.log(`[VoteConfirmationHandler] Notification already sent for vote ${vote.txHash}`);
+      console.log(`[VoteConfirmationHandler] Notification already sent for vote ${vote.transactionHash}`);
       return 'skipped';
     }
 
     // Send notification
-    await this.sendVoteNotification(user, vote);
+    await this.sendVoteNotification(user, vote, eventId);
     console.log(`[VoteConfirmationHandler] Sent vote notification to user ${user.id}`);
 
     return 'sent';
@@ -133,55 +122,51 @@ export class VoteConfirmationTriggerHandler extends BaseTriggerHandler<VoteEvent
   /**
    * Sends notification for a single vote
    */
-  private async sendVoteNotification(user: any, vote: VoteEvent): Promise<void> {
+  private async sendVoteNotification(user: any, vote: VoteWithDaoId, eventId: string): Promise<void> {
     const message = this.formatVoteMessage(vote);
     const chainId = await this.getChainIdForDao(vote.daoId);
 
     // Build buttons
     const buttons = buildButtons({
       triggerType: 'voteConfirmation',
-      txHash: vote.txHash,
+      txHash: vote.transactionHash,
       chainId
     });
 
     await this.sendNotificationsToSubscribers(
       [user],
       message,
-      vote.txHash,
+      eventId,
       vote.daoId,
       {
         transaction: {
-          hash: vote.txHash,
+          hash: vote.transactionHash,
           chainId
         },
         addresses: {
-          address: vote.voterAccountId
+          address: vote.voterAddress
         },
         proposalId: vote.proposalId,
-        support: vote.support,
+        support: String(vote.support),
         votingPower: vote.votingPower,
         reason: vote.reason
       },
       buttons
     );
   }
 
-  private formatVoteMessage(vote: VoteEvent): string {
-    const supportKey = voteConfirmationMessages.getSupportKey(vote.support);
+  private formatVoteMessage(vote: VoteWithDaoId): string {
+    const supportKey = voteConfirmationMessages.getSupportKey(String(vote.support));
     const votingPower = formatTokenAmount(vote.votingPower, 18);
     const hasReason = vote.reason && vote.reason.trim();
-    const proposalTitle = FormattingService.extractTitle(
-      vote.proposalDescription || '',
-      vote.proposalId
-    );
 
     const messageTemplate = hasReason
       ? voteConfirmationMessages.withReason[supportKey]
       : voteConfirmationMessages.withoutReason[supportKey];
 
     return replacePlaceholders(messageTemplate, {
       daoId: vote.daoId,
-      proposalTitle,
+      proposalTitle: vote.proposalTitle,
       votingPower,
       ...(hasReason && { reason: vote.reason! })
     });