Merge pull request #207 from blockful/feat/cursor_refactor

Feat/cursor refactor

Author: LeonardoVieira1630

apps/logic-system/src/app.ts

@@ -139,15 +139,6 @@ export class App {
     if (this.voteConfirmationTrigger) {
       this.voteConfirmationTrigger.reset(initialTimestamp);
     }
-    if (this.votingReminderTrigger30) {
-      this.votingReminderTrigger30.reset(initialTimestamp);
-    }
-    if (this.votingReminderTrigger60) {
-      this.votingReminderTrigger60.reset(initialTimestamp);
-    }
-    if (this.votingReminderTrigger90) {
-      this.votingReminderTrigger90.reset(initialTimestamp);
-    }
   }
 
   async stop(): Promise<void> {

apps/logic-system/src/triggers/voting-reminder-trigger.ts

@@ -5,7 +5,7 @@
  */
 
 import { Trigger } from './base-trigger';
-import { ProposalOnChain, ListProposalsOptions, ProposalDataSource } from '../interfaces/proposal.interface';
+import { ProposalOnChain, ProposalDataSource } from '../interfaces/proposal.interface';
 import { DispatcherService, DispatcherMessage } from '../interfaces/dispatcher.interface';
 
 /**
@@ -27,7 +27,6 @@ const TRIGGER_ID_PREFIX = 'voting-reminder';
 const DEFAULT_WINDOW_SIZE = 5; 
 
 export class VotingReminderTrigger extends Trigger<ProposalOnChain> {
-  private timestampCursor: number;
   private thresholdPercentage: number;
   private windowSize: number;
 
@@ -36,31 +35,11 @@ export class VotingReminderTrigger extends Trigger<ProposalOnChain> {
     private readonly proposalRepository: ProposalDataSource,
     interval: number,
     thresholdPercentage: number = 75,
-    windowSize: number = DEFAULT_WINDOW_SIZE,
-    initialTimestamp?: string
+    windowSize: number = DEFAULT_WINDOW_SIZE
   ) {
     super(TRIGGER_ID_PREFIX, interval);
     this.thresholdPercentage = thresholdPercentage;
     this.windowSize = windowSize;
-    
-    // Initialize timestamp - look back 24 hours by default
-    if (initialTimestamp) {
-      this.timestampCursor = parseInt(initialTimestamp, 10);
-    } else {
-      this.timestampCursor = Math.floor((Date.now() - 24 * 60 * 60 * 1000) / 1000); // 24 hours ago
-    }
-  }
-
-  /**
-   * Resets the trigger state to initial timestamp
-   * @param timestamp Optional timestamp to reset to, defaults to 24 hours ago
-   */
-  public reset(timestamp?: string): void {
-    if (timestamp) {
-      this.timestampCursor = parseInt(timestamp, 10);
-    } else {
-      this.timestampCursor = Math.floor((Date.now() - 24 * 60 * 60 * 1000) / 1000); // 24 hours ago
-    }
   }
 
   /**
@@ -87,13 +66,6 @@ export class VotingReminderTrigger extends Trigger<ProposalOnChain> {
     };
 
     await this.dispatcherService.sendMessage(message);
-
-    // Update timestamp to the most recent proposal's timestamp + 1
-    // Since data comes ordered by timestamp desc, the first item has the latest timestamp
-    if (proposals[0]?.timestamp) {
-      this.timestampCursor = parseInt(proposals[0].timestamp, 10) + 1;
-    }
-
   }
 
   /**
@@ -182,7 +154,6 @@ export class VotingReminderTrigger extends Trigger<ProposalOnChain> {
   protected async fetchData(): Promise<ProposalOnChain[]> {
     return await this.proposalRepository.listAll({
       status: 'ACTIVE',
-      fromDate: this.timestampCursor,
       includeOptimisticProposals: false
     });
   }

apps/logic-system/tests/voting-reminder-trigger.test.ts

@@ -5,7 +5,7 @@
 import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
 import { VotingReminderTrigger } from '../src/triggers/voting-reminder-trigger';
 import { ProposalOnChain } from '../src/interfaces/proposal.interface';
-import { DispatcherService, DispatcherMessage } from '../src/interfaces/dispatcher.interface';
+import { DispatcherService } from '../src/interfaces/dispatcher.interface';
 import { MockedFunction } from 'jest-mock';
 
 describe('VotingReminderTrigger', () => {
@@ -111,30 +111,6 @@ describe('VotingReminderTrigger', () => {
       expect(mockDispatcherService.sendMessage).not.toHaveBeenCalled();
     });
 
-    it('should update timestampCursor after processing', async () => {
-      const proposalStart = baseTime - 3600;
-      const proposalEnd = baseTime + 300; // within 90-95% window
-      
-      const proposal: ProposalOnChain = {
-        id: 'proposal-123',
-        daoId: 'test-dao',
-        description: 'Test proposal',
-        timestamp: proposalStart.toString(),
-        endTimestamp: proposalEnd.toString(),
-        status: 'ACTIVE'
-      } as ProposalOnChain;
-
-      // Process proposal
-      await trigger.process([proposal]);
-
-      // Check that timestampCursor was updated to the proposal's timestamp + 1
-      // +1 to avoid duplicates since API uses >= comparison
-      const updatedTimestamp = (trigger as any).timestampCursor;
-      expect(updatedTimestamp).toBe(proposalStart + 1);
-      
-      expect(mockDispatcherService.sendMessage).toHaveBeenCalledTimes(1);
-    });
-
     it('should skip proposals without required timestamps', async () => {
       const proposal: ProposalOnChain = {
         id: 'proposal-123',
@@ -187,7 +163,7 @@ describe('VotingReminderTrigger', () => {
   });
 
   describe('fetchData', () => {
-    it('should fetch active proposals with fromDate filter', async () => {
+    it('should fetch active proposals without timestamp filter', async () => {
       const proposals = [
         { id: 'prop-1', status: 'ACTIVE' },
         { id: 'prop-2', status: 'ACTIVE' }
@@ -197,46 +173,15 @@ describe('VotingReminderTrigger', () => {
 
       const result = await trigger['fetchData']();
 
-      // Should include fromDate filter with timestampCursor and exclude optimistic proposals
+      // Should only filter by status ACTIVE, no fromDate
       expect(mockProposalRepository.listAll).toHaveBeenCalledWith({
         status: 'ACTIVE',
-        fromDate: expect.any(Number),
         includeOptimisticProposals: false
       });
       expect(result).toEqual(proposals);
     });
   });
 
-  describe('reset', () => {
-    it('should reset the timestampCursor', () => {
-      // Create trigger with initial timestamp
-      const initialTimestamp = '1000000';
-      const triggerWithTimestamp = new VotingReminderTrigger(
-        mockDispatcherService,
-        mockProposalRepository,
-        30000,
-        90,
-        5,
-        initialTimestamp
-      );
-
-      // Reset without timestamp - should default to 24 hours ago
-      triggerWithTimestamp.reset();
-      
-      // Access private property for testing
-      const resetTimestamp = (triggerWithTimestamp as any).timestampCursor;
-      const twentyFourHoursAgo = Math.floor((Date.now() - 24 * 60 * 60 * 1000) / 1000);
-      
-      // Should be around 24 hours ago (within 1 second tolerance)
-      expect(Math.abs(resetTimestamp - twentyFourHoursAgo)).toBeLessThanOrEqual(1);
-
-      // Reset with specific timestamp
-      triggerWithTimestamp.reset('2000000');
-      const specificTimestamp = (triggerWithTimestamp as any).timestampCursor;
-      expect(specificTimestamp).toBe(2000000);
-    });
-  });
-
   describe('time calculation', () => {
     it('should calculate time elapsed percentage correctly', () => {
       const startTime = 1000;

packages/anticapture-client/dist/anticapture-client.js

@@ -121,6 +121,13 @@ class AnticaptureClient {
                     console.warn(`Skipping ${dao.id} due to API error: ${error instanceof Error ? error.message : error}`);
                 }
             }
+            // Sort globally by timestamp desc (most recent first)
+            if (variables?.fromEndDate) {
+                allProposals.sort((a, b) => parseInt(b?.endTimestamp || '0') - parseInt(a?.endTimestamp || '0'));
+            }
+            else {
+                allProposals.sort((a, b) => parseInt(b?.timestamp || '0') - parseInt(a?.timestamp || '0') || 0);
+            }
             return allProposals;
         }
         try {

packages/anticapture-client/package.json

@@ -35,6 +35,7 @@
   "dependencies": {
     "@graphql-typed-document-node/core": "^3.2.0",
     "axios": "^1.7.2",
+    "axios-retry": "^4.5.0",
     "graphql": "^16.11.0",
     "viem": "^2.34.0",
     "zod": "^3.22.4"

packages/anticapture-client/src/anticapture-client.ts

@@ -1,4 +1,5 @@
 import { AxiosInstance } from 'axios';
+import axiosRetry, { exponentialDelay, isNetworkOrIdempotentRequestError } from 'axios-retry';
 import { print } from 'graphql';
 import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
 import { z } from 'zod';
@@ -24,8 +25,23 @@ type ProposalNonVoter = z.infer<typeof SafeProposalNonVotersResponseSchema>['pro
 export class AnticaptureClient {
   private readonly httpClient: AxiosInstance;
 
-  constructor(httpClient: AxiosInstance) {
+  constructor(httpClient: AxiosInstance, maxRetries: number = 4, timeout: number = 15000) {
     this.httpClient = httpClient;
+    this.httpClient.defaults.timeout = timeout;
+
+    axiosRetry(this.httpClient, {
+      retries: maxRetries,
+      retryDelay: exponentialDelay, // 1s, 2s, 4s, 8s
+      retryCondition: (error) => {
+        return isNetworkOrIdempotentRequestError(error) ||
+               (error.response?.status !== undefined && error.response.status >= 500);
+      },
+      onRetry: (retryCount, error, requestConfig) => {
+        console.warn(
+          `[AnticaptureClient] Retry ${retryCount}/${maxRetries} for ${requestConfig.url || 'request'}: ${error.message}`
+        );
+      },
+    });
   }
 
   /**
@@ -165,6 +181,13 @@ export class AnticaptureClient {
         }
       }
 
+      // Sort globally by timestamp desc (most recent first)
+      if (variables?.fromEndDate) {
+        allProposals.sort((a, b) => parseInt(b?.endTimestamp || '0') - parseInt(a?.endTimestamp || '0'));
+      } else {
+        allProposals.sort((a, b) => parseInt(b?.timestamp || '0') - parseInt(a?.timestamp || '0') || 0);
+      }
+
       return allProposals;
     }
 

packages/anticapture-client/tests/anticapture-client.test.ts

@@ -102,6 +102,40 @@ describe('AnticaptureClient', () => {
           { id: 'p3', description: 'Proposal 3', title: null, daoId: 'DAO3' }
         ]);
       });
+
+      it('sorts proposals globally by timestamp DESC regardless of DAO order', async () => {
+        // Simulate proposals from different DAOs with unsorted timestamps
+        mockQuery
+          .mockResolvedValueOnce({
+            proposals: {
+              items: [{ id: 'dao1-old', description: 'Old from DAO1', title: null, timestamp: '1000' }],
+              totalCount: 1
+            }
+          })
+          .mockResolvedValueOnce({
+            proposals: {
+              items: [{ id: 'dao2-newest', description: 'Newest from DAO2', title: null, timestamp: '3000' }],
+              totalCount: 1
+            }
+          })
+          .mockResolvedValueOnce({
+            proposals: {
+              items: [{ id: 'dao3-middle', description: 'Middle from DAO3', title: null, timestamp: '2000' }],
+              totalCount: 1
+            }
+          });
+
+        const result = await client.listProposals();
+
+        // Should be sorted by timestamp DESC (newest first)
+        expect(result).toHaveLength(3);
+        expect(result[0]!.id).toBe('dao2-newest');
+        expect(result[0]!.timestamp).toBe('3000');
+        expect(result[1]!.id).toBe('dao3-middle');
+        expect(result[1]!.timestamp).toBe('2000');
+        expect(result[2]!.id).toBe('dao1-old');
+        expect(result[2]!.timestamp).toBe('1000');
+      });
     });
   });