Merge pull request #214 from blockful/refactor/votes_on_chain_route

Refactor/votes on chain route

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.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,9 @@ 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> {
     // 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, vote.transactionHash, String(vote.timestamp));
     const isSubscribed = subscribers.some(sub => sub.id === user.id);
 
     if (!isSubscribed) {
@@ -117,9 +104,9 @@ 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], vote.transactionHash, 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';
     }
 
@@ -133,55 +120,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): 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,
+      vote.transactionHash,
       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! })
     });

apps/integrated-tests/src/fixtures/factories/vote-factory.ts

@@ -1,16 +1,15 @@
 import { v4 as uuidv4 } from 'uuid';
 
 export interface VoteData {
-  id: string;
   proposalId: string;
-  voterAccountId: string;
+  voterAddress: string;
   daoId: string;
-  support: string; // Must be string for Zod validation in AntiCapture client
-  weight: string;
-  reason?: string;
-  timestamp: string;
-  txHash: string;
+  support: number;
+  reason?: string | null;
+  timestamp: number;
+  transactionHash: string;
   votingPower: string;
+  proposalTitle: string;
 }
 
 /**
@@ -19,63 +18,63 @@ export interface VoteData {
 export class VoteFactory {
   /**
    * Creates a vote for testing
-   * @param voterAccountId The address of the voter
+   * @param voterAddress The address of the voter
    * @param proposalId The proposal being voted on
    * @param daoId The DAO identifier
    * @param overrides Optional field overrides
    * @returns Vote data object
    */
   static createVote(
-    voterAccountId: string,
+    voterAddress: string,
     proposalId: string,
     daoId: string,
     overrides: Partial<VoteData> = {}
   ): VoteData {
     return {
-      id: uuidv4(),
       proposalId,
-      voterAccountId,
+      voterAddress,
       daoId,
-      support: '1', // '1' = FOR, '0' = AGAINST, '2' = ABSTAIN (must be string for Zod validation)
-      weight: '1000000000000000000', // 1 token in wei
-      timestamp: new Date().toISOString(),
-      txHash: `0x${uuidv4().replace(/-/g, '')}${uuidv4().replace(/-/g, '').substring(0, 8)}`, // Generate a fake tx hash
-      votingPower: '1000000000000000000', // 1 token in wei
+      support: 1,
+      timestamp: Math.floor(Date.now() / 1000),
+      transactionHash: `0x${uuidv4().replace(/-/g, '')}${uuidv4().replace(/-/g, '').substring(0, 8)}`,
+      votingPower: '1000000000000000000',
+      proposalTitle: 'Test Proposal',
+      reason: null,
       ...overrides
     };
   }
 
   /**
    * Creates multiple votes for different proposals
-   * @param voterAccountId The address of the voter
+   * @param voterAddress The address of the voter
    * @param proposalIds Array of proposal IDs to vote on
    * @param daoId The DAO identifier
    * @returns Array of vote data objects
    */
   static createVotesForProposals(
-    voterAccountId: string,
+    voterAddress: string,
     proposalIds: string[],
     daoId: string
   ): VoteData[] {
-    return proposalIds.map(proposalId => 
-      this.createVote(voterAccountId, proposalId, daoId)
+    return proposalIds.map(proposalId =>
+      this.createVote(voterAddress, proposalId, daoId)
     );
   }
 
   /**
    * Creates votes from multiple voters for a single proposal
-   * @param voterAccountIds Array of voter addresses
+   * @param voterAddresses Array of voter addresses
    * @param proposalId The proposal being voted on
    * @param daoId The DAO identifier
    * @returns Array of vote data objects
    */
   static createVotesFromMultipleVoters(
-    voterAccountIds: string[],
+    voterAddresses: string[],
     proposalId: string,
     daoId: string
   ): VoteData[] {
-    return voterAccountIds.map(voterAccountId =>
-      this.createVote(voterAccountId, proposalId, daoId)
+    return voterAddresses.map(voterAddress =>
+      this.createVote(voterAddress, proposalId, daoId)
     );
   }
 }

apps/integrated-tests/src/mocks/graphql-mock-setup.ts

@@ -89,46 +89,52 @@ export class GraphQLMockSetup {
       }
 
       // Handle votes
-      if (data.query?.includes('ListVotesOnchains')) {
+      if (data.query?.includes('ListVotes')) {
         let filtered = votesData;
-        
-        const daoId = data.variables?.daoId;
-        const proposalIdIn = data.variables?.proposalId_in;
-        const voterAccountIdIn = data.variables?.voterAccountId_in;
-        const timestampGt = data.variables?.timestamp_gt;
-        
-        // Filter by daoId if provided
+
+        const daoId = config?.headers?.['anticapture-dao-id'];
+        const voterAddressIn = data.variables?.voterAddressIn;
+        const fromDate = data.variables?.fromDate;
+        const toDate = data.variables?.toDate;
+
+        // Filter by daoId
         if (daoId) {
           filtered = filtered.filter((v: any) => v.daoId === daoId);
         }
-        
-        // Filter by proposalId_in if provided
-        if (proposalIdIn) {
-          filtered = filtered.filter((v: any) => 
-            proposalIdIn.includes(v.proposalId)
-          );
-        }
-        
-        // Filter by voterAccountId_in if provided
-        // Using case-insensitive comparison (simulates API's internal normalization)
-        if (voterAccountIdIn) {
+
+        // Filter by voterAddressIn if provided
+        if (voterAddressIn && Array.isArray(voterAddressIn)) {
           filtered = filtered.filter((v: any) =>
-            voterAccountIdIn.some((addr: string) =>
-              isAddressEqual(getAddress(v.voterAccountId), getAddress(addr))
+            voterAddressIn.some((addr: string) =>
+              isAddressEqual(getAddress(v.voterAddress), getAddress(addr))
             )
           );
         }
 
-        // Filter by timestamp_gt if provided
-        if (timestampGt) {
-          filtered = filtered.filter((v: any) =>
-            parseInt(v.timestamp || '0') > parseInt(timestampGt)
-          );
+        // Filter by fromDate if provided
+        if (fromDate !== undefined) {
+          filtered = filtered.filter((v: any) => v.timestamp > fromDate);
         }
 
-        // Return votes in original format (checksum) - AnticaptureClient will normalize to lowercase
+        // Filter by toDate if provided
+        if (toDate !== undefined) {
+          filtered = filtered.filter((v: any) => v.timestamp < toDate);
+        }
+
+        // Return items in expected format
+        const items = filtered.map((v: any) => ({
+          transactionHash: v.transactionHash,
+          proposalId: v.proposalId,
+          voterAddress: v.voterAddress,
+          support: v.support,
+          votingPower: v.votingPower,
+          timestamp: v.timestamp,
+          reason: v.reason || null,
+          proposalTitle: v.proposalTitle
+        }));
+
         return Promise.resolve({
-          data: { data: { votesOnchains: { items: filtered, totalCount: filtered.length } } }
+          data: { data: { votes: { items, totalCount: items.length } } }
         });
       }
 
@@ -141,7 +147,7 @@ export class GraphQLMockSetup {
         const votersSet = new Set(
           votesData
             .filter((v: any) => v.proposalId === proposalId)
-            .map((v: any) => getAddress(v.voterAccountId).toLowerCase())
+            .map((v: any) => getAddress(v.voterAddress).toLowerCase())
         );
 
         // Filter to find non-voters from the provided address list
@@ -179,7 +185,7 @@ export class GraphQLMockSetup {
             proposals: { items: [], totalCount: 0 },
             proposal: null,
             daos: { items: [] },
-            votesOnchains: { items: [] }
+            votes: { items: [], totalCount: 0 }
           }
         }
       });