@gzeoneth/gov-tracker 0.3.0 → 0.4.0-alpha.addr-feedback.e1dac80

package/dist/tracker.js

@@ -27,74 +27,85 @@ const governor_discovery_1 = require("./discovery/governor-discovery");
 const timelock_discovery_1 = require("./discovery/timelock-discovery");
 const utils_1 = require("./stages/utils");
 const { tracker: logTracker, discovery: logDiscovery } = logger_1.loggers;
-/**
- * Build a TrackingContext with current block numbers and timestamp.
- * Called once at the start of a tracking session for consistent state.
- */
-async function buildTrackingContext(options) {
-    const { l2Provider, l1Provider, novaProvider, chunkSize, skipCache } = options;
-    const l2BlockInfo = await (0, timing_1.getCurrentBlockInfo)(l2Provider);
-    const context = {
-        l2BlockNumber: l2BlockInfo.blockNumber,
-        timestamp: l2BlockInfo.timestamp,
-        chunkSize,
-        skipCache,
-    };
-    logTracker("buildTrackingContext: l2Block=%d timestamp=%d", context.l2BlockNumber, context.timestamp);
-    if (l1Provider) {
-        try {
-            const l1Block = await (0, timing_1.getL1BlockNumberFromL2)(l2Provider);
-            context.l1BlockNumber = l1Block.toNumber();
-            logTracker("buildTrackingContext: l1Block=%d", context.l1BlockNumber);
-        }
-        catch (err) {
-            logTracker("buildTrackingContext: failed to get L1 block: %s", err.message);
-        }
-    }
-    if (novaProvider) {
-        try {
-            const novaBlockInfo = await (0, timing_1.getCurrentBlockInfo)(novaProvider);
-            context.novaBlockNumber = novaBlockInfo.blockNumber;
-            logTracker("buildTrackingContext: novaBlock=%d", context.novaBlockNumber);
-        }
-        catch (err) {
-            logTracker("buildTrackingContext: failed to get Nova block: %s", err.message);
-        }
-    }
-    return context;
-}
 // Import context and pipeline from tracker modules
 const state_1 = require("./tracker/state");
 const pipeline_1 = require("./tracker/pipeline");
+const status_1 = require("./election/status");
+const constants_2 = require("./constants");
 // Import from focused modules
 const cache_1 = require("./tracker/cache");
 const discovery_1 = require("./tracker/discovery");
 const discovery_2 = require("./tracker/discovery");
 const query_1 = require("./tracker/query");
 const execute_1 = require("./tracker/execute");
+/**
+ * Build ElectionProposalStatus from TrackingState.
+ * This bridges the unified pipeline approach with the existing election API.
+ */
+function buildElectionStatusFromState(state) {
+    // Extract basic state with defaults
+    const electionIndex = (0, state_1.getElectionIndex)(state) ?? 0;
+    const nomineeProposalId = (0, state_1.getNomineeProposalId)(state) ?? null;
+    const memberProposalId = (0, state_1.getMemberProposalId)(state) ?? null;
+    const cohort = (0, state_1.getElectionCohort)(state) ?? 0;
+    const compliantNomineeCount = (0, state_1.getCompliantNomineeCount)(state) ?? 0;
+    const targetNomineeCount = (0, state_1.getTargetNomineeCount)(state) ?? constants_2.TIMING.SECURITY_COUNCIL_TARGET_NOMINEES;
+    const vettingDeadline = (0, state_1.getVettingDeadline)(state) ?? null;
+    // Stage lookups (typed for data access)
+    const createStage = (0, utils_1.findStage)(state.stages, "CREATE_ELECTION");
+    const nomineeStage = (0, utils_1.findStage)(state.stages, "NOMINEE_ELECTION");
+    const vettingStage = (0, utils_1.findStage)(state.stages, "NOMINEE_VETTING");
+    const memberStage = (0, utils_1.findStage)(state.stages, "MEMBER_ELECTION");
+    // Extract proposal states from typed stages
+    const nomineeProposalState = nomineeStage?.data
+        ?.proposalState ?? null;
+    const memberProposalState = memberStage?.data
+        ?.proposalState ?? null;
+    const isInVettingPeriod = vettingStage?.status === "PENDING";
+    // Determine failure from any failed stage using Map for O(1) lookup
+    const stageFailureReasons = new Map([
+        [nomineeStage, "Nominee election failed"],
+        [vettingStage, "Not enough compliant nominees"],
+        [memberStage, "Member election failed"],
+    ]);
+    const failedStage = [nomineeStage, vettingStage, memberStage].find((s) => s?.status === "FAILED");
+    const failureReason = failedStage ? stageFailureReasons.get(failedStage) : undefined;
+    return {
+        electionIndex,
+        phase: (0, status_1.determineElectionPhase)(nomineeProposalState, memberProposalId, memberProposalState, isInVettingPeriod),
+        cohort,
+        nomineeProposalId,
+        memberProposalId,
+        nomineeProposalState,
+        memberProposalState,
+        compliantNomineeCount,
+        targetNomineeCount,
+        vettingDeadline,
+        isInVettingPeriod,
+        canProceedToMemberPhase: vettingStage?.status === "READY",
+        canExecuteMember: memberStage?.status === "READY",
+        stages: state.stages,
+        isFailed: failedStage ? true : undefined,
+        failureReason,
+        timelockOperationId: (0, state_1.getElectionTimelockOperationId)(state),
+        creationTxHash: createStage?.transactions?.[0]?.hash,
+        nomineeExecuteTxHash: vettingStage?.transactions?.[0]?.hash,
+        memberExecuteTxHash: memberStage?.transactions?.find((t) => t.description === "executed")?.hash,
+    };
+}
 /**
  * Extract TimelockLink from stages if PROPOSAL_QUEUED is completed
  */
 function extractTimelockLink(stages) {
     const queuedStage = (0, utils_1.findStage)(stages, "PROPOSAL_QUEUED");
-    if (!queuedStage ||
-        queuedStage.type !== "PROPOSAL_QUEUED" ||
-        queuedStage.status !== "COMPLETED") {
-        return undefined;
-    }
-    const txHash = queuedStage.transactions[0]?.hash;
-    const operationId = queuedStage.data.operationId;
-    const timelockAddress = queuedStage.data.timelockAddress;
-    const queueBlockNumber = queuedStage.transactions[0]?.blockNumber;
-    if (!txHash || !operationId || !timelockAddress || !queueBlockNumber) {
+    if (queuedStage?.status !== "COMPLETED" || queuedStage.type !== "PROPOSAL_QUEUED") {
         return undefined;
     }
-    return {
-        txHash,
-        operationId,
-        timelockAddress,
-        queueBlockNumber,
-    };
+    const tx = queuedStage.transactions[0];
+    const { operationId, timelockAddress } = queuedStage.data;
+    return tx?.hash && operationId && timelockAddress && tx.blockNumber
+        ? { txHash: tx.hash, operationId, timelockAddress, queueBlockNumber: tx.blockNumber }
+        : undefined;
 }
 /**
  * Main proposal stage tracker class
@@ -182,16 +193,15 @@ class ProposalStageTracker {
             logTracker("cleared cache entry: %s", baseCacheKey);
             cleared++;
         }
-        // Clear all operation-specific keys for this tx
+        // Clear all operation-specific keys for this tx in parallel
         const allKeys = await this.cache.keys(prefix);
         const keys = Array.isArray(allKeys) ? allKeys : Array.from(allKeys);
-        for (const key of keys) {
-            if (key.startsWith(prefix)) {
-                await this.cache.delete(key);
-                logTracker("cleared cache entry: %s", key);
-                cleared++;
-            }
-        }
+        const keysToDelete = keys.filter((key) => key.startsWith(prefix));
+        await Promise.all(keysToDelete.map(async (key) => {
+            await this.cache.delete(key);
+            logTracker("cleared cache entry: %s", key);
+        }));
+        cleared += keysToDelete.length;
         return cleared;
     }
     // Watermark Management
@@ -221,7 +231,7 @@ class ProposalStageTracker {
      * For COMPLETED elections, automatically fetches and caches nominee/member
      * election details to enable zero-RPC reads for historical elections.
      *
-     * @param electionStatus - Election status from trackElectionProposal
+     * @param electionStatus - Election status from trackElection()
      * @param options.nomineeDetails - Pre-fetched nominee details (skips RPC fetch)
      * @param options.memberDetails - Pre-fetched member details (skips RPC fetch)
      */
@@ -369,6 +379,17 @@ class ProposalStageTracker {
     async getStats(maxErrorCount = 5) {
         return (0, query_1.getStats)(this.cache, maxErrorCount);
     }
+    /**
+     * Get the highest Security Council nonce from incomplete checkpoints.
+     *
+     * Used to determine if lower-nonce SC operations should be skipped
+     * (superseded by higher nonce operations).
+     *
+     * @returns The highest SC nonce found, or null if no SC operations exist
+     */
+    async getHighestScNonce() {
+        return (0, query_1.getHighestScNonceFromCheckpoints)(this.cache);
+    }
     // Main Tracking Entry Points
     /**
      * Track from transaction hash (primary tracking entry point)
@@ -412,7 +433,7 @@ class ProposalStageTracker {
                     logTracker("loaded checkpoint from cache: %s", opCacheKey);
                 }
             }
-            // Fall back to base cache key (for governor proposals or legacy checkpoints)
+            // Fall back to base cache key (governor proposals or pre-modular cache entries)
             if (!checkpoint) {
                 checkpoint = (await this.cache.get(baseCacheKey)) ?? undefined;
                 if (checkpoint) {
@@ -516,31 +537,85 @@ class ProposalStageTracker {
         logTracker("no proposal or timelock operations found in tx");
         return [];
     }
+    // ============================================================================
+    // Unified Pipeline Tracking
+    // ============================================================================
     /**
-     * Track governor proposal using TrackingState (stateful tracking)
+     * Unified pipeline tracking method.
+     * Handles all common tracking patterns: state creation, pipeline execution,
+     * checkpoint management, and timelockOpKey derivation.
      */
-    async trackGovernorWithPipeline(governorAddress, proposalId, creationTxHash, checkpoint, cacheKey) {
-        const input = {
-            type: "governor",
-            governorAddress,
-            proposalId,
-            creationTxHash,
-        };
-        // Create tracking context
+    async runTrackingPipeline(config) {
+        // Load linked timelock checkpoint if configured and available
+        let linkedTimelockCheckpoint;
+        if (config.loadLinkedTimelock && this.cache && config.checkpoint?.metadata?.timelockOpKey) {
+            linkedTimelockCheckpoint =
+                (await this.cache.get(config.checkpoint.metadata.timelockOpKey)) ??
+                    undefined;
+            if (linkedTimelockCheckpoint) {
+                logTracker("loaded linked timelock checkpoint: %s", config.checkpoint.metadata.timelockOpKey);
+            }
+        }
+        // Create tracking state
         const initialState = (0, state_1.createTrackingState)({
             providers: {
                 l2: this.l2Provider,
                 l1: this.l1Provider,
                 nova: this.novaProvider,
             },
-            input,
+            input: config.input,
             onProgress: this.onProgress,
             chunkingConfig: this.chunkingConfig,
+            checkpoint: config.checkpoint,
+            linkedTimelockCheckpoint,
+            cacheKey: config.cacheKey,
+            callScheduledData: config.callScheduledData,
+        });
+        // Run the pipeline
+        let finalState = await config.pipeline(initialState);
+        // Derive and set timelockOpKey if configured
+        if (config.timelockKeySource && !finalState.timelockOpKey) {
+            const { stageType, txDescription } = config.timelockKeySource;
+            const operationId = stageType === "MEMBER_ELECTION"
+                ? (0, state_1.getElectionTimelockOperationId)(finalState)
+                : (0, state_1.getOperationId)(finalState);
+            const stage = finalState.stages.find((s) => s.type === stageType);
+            const txHash = stage?.transactions?.find((t) => t.description === txDescription)?.hash;
+            if (operationId && txHash) {
+                const timelockOpKey = (0, checkpoint_helpers_1.timelockOpCacheKey)(txHash, operationId);
+                finalState = (0, state_1.setTimelockOpKey)(finalState, timelockOpKey);
+            }
+        }
+        // Save checkpoints (unless caller handles caching)
+        if (!config.skipCaching && this.cache && config.cacheKey) {
+            if (config.modularCaching) {
+                await this.saveModularCheckpoints(finalState, config.cacheKey);
+            }
+            else {
+                const checkpoint = (0, state_1.createCheckpoint)(finalState);
+                checkpoint.metadata = { errorCount: 0, lastTrackedAt: Date.now() };
+                await this.cache.set(config.cacheKey, checkpoint);
+                logTracker("saved checkpoint to cache: %s", config.cacheKey);
+            }
+        }
+        return finalState;
+    }
+    /**
+     * Track governor proposal using TrackingState (stateful tracking)
+     * Uses modular caching: parent stages saved separately from timelock stages.
+     */
+    async trackGovernorWithPipeline(governorAddress, proposalId, creationTxHash, checkpoint, cacheKey) {
+        // Run unified pipeline (with skipCaching - we handle election case specially)
+        const finalState = await this.runTrackingPipeline({
+            input: { type: "governor", governorAddress, proposalId, creationTxHash },
             checkpoint,
             cacheKey,
+            pipeline: pipeline_1.trackGovernorPipeline,
+            loadLinkedTimelock: true,
+            modularCaching: true,
+            skipCaching: true,
+            timelockKeySource: { stageType: "PROPOSAL_QUEUED", txDescription: "queued" },
         });
-        // Run the governor pipeline (stages 1-7)
-        const finalState = await (0, pipeline_1.trackGovernorPipeline)(initialState);
         // Build result from state
         const result = this.buildResultFromState(finalState);
         // Track election status if this is an election governor proposal
@@ -556,14 +631,11 @@ class ProposalStageTracker {
                 }
                 return result;
             }
-            // If election tracking failed, fall through to save tx:* checkpoint for retry
             logTracker("election tracking failed, saving tx:* checkpoint for retry");
         }
-        // Save checkpoint to cache (non-elections and failed election tracking)
+        // Save checkpoints using modular caching
         if (this.cache && cacheKey) {
-            result.checkpoint.metadata = { errorCount: 0, lastTrackedAt: Date.now() };
-            await this.cache.set(cacheKey, result.checkpoint);
-            logTracker("saved checkpoint to cache: %s", cacheKey);
+            await this.saveModularCheckpoints(finalState, cacheKey);
         }
         return result;
     }
@@ -571,37 +643,55 @@ class ProposalStageTracker {
      * Track timelock operation using TrackingState (stateful tracking)
      */
     async trackTimelockWithPipeline(timelockAddress, operationId, scheduledTxHash, checkpoint, cacheKey, callScheduledEvent) {
-        const input = {
-            type: "timelock",
-            timelockAddress,
-            operationId,
-            scheduledTxHash,
-        };
-        // Create tracking context with bootstrap data
-        const initialState = (0, state_1.createTrackingState)({
-            providers: {
-                l2: this.l2Provider,
-                l1: this.l1Provider,
-                nova: this.novaProvider,
-            },
-            input,
-            onProgress: this.onProgress,
-            chunkingConfig: this.chunkingConfig,
+        // Run unified pipeline
+        const finalState = await this.runTrackingPipeline({
+            input: { type: "timelock", timelockAddress, operationId, scheduledTxHash },
             checkpoint,
             cacheKey,
+            pipeline: pipeline_1.trackTimelockPipeline,
+            loadLinkedTimelock: false,
+            modularCaching: false,
             callScheduledData: callScheduledEvent ? [callScheduledEvent] : undefined,
         });
-        // Run the timelock pipeline (stages 4-7)
-        const finalState = await (0, pipeline_1.trackTimelockPipeline)(initialState);
-        // Build result from state
-        const result = this.buildResultFromState(finalState);
-        // Save checkpoint to cache
-        if (this.cache && cacheKey) {
-            result.checkpoint.metadata = { errorCount: 0, lastTrackedAt: Date.now() };
-            await this.cache.set(cacheKey, result.checkpoint);
-            logTracker("saved checkpoint to cache: %s", cacheKey);
+        return this.buildResultFromState(finalState);
+    }
+    /**
+     * Track election using TrackingState (stateful tracking)
+     *
+     * This is the unified pipeline version that tracks elections through the
+     * same stage-based approach as proposals and timelock operations.
+     * Uses modular caching: election stages saved separately from timelock stages.
+     */
+    async trackElectionWithPipeline(electionIndex, checkpoint, cacheKey) {
+        // Run unified pipeline (caller handles caching)
+        const finalState = await this.runTrackingPipeline({
+            input: { type: "election", electionIndex },
+            checkpoint,
+            cacheKey,
+            pipeline: pipeline_1.trackElectionPipeline,
+            loadLinkedTimelock: true,
+            modularCaching: true,
+            skipCaching: true,
+            timelockKeySource: { stageType: "MEMBER_ELECTION", txDescription: "executed" },
+        });
+        return { status: buildElectionStatusFromState(finalState), finalState };
+    }
+    /**
+     * Save checkpoints using modular caching.
+     * Saves parent stages and timelock stages in separate checkpoints.
+     */
+    async saveModularCheckpoints(state, parentCacheKey) {
+        if (!this.cache)
+            return;
+        const { parentCheckpoint, timelockCheckpoint, timelockOpKey } = (0, state_1.createModularCheckpoints)(state, parentCacheKey);
+        // Save parent checkpoint
+        await this.cache.set(parentCacheKey, parentCheckpoint);
+        logTracker("saved parent checkpoint: %s", parentCacheKey);
+        // Save timelock checkpoint if we have one
+        if (timelockCheckpoint && timelockOpKey) {
+            await this.cache.set(timelockOpKey, timelockCheckpoint);
+            logTracker("saved linked timelock checkpoint: %s", timelockOpKey);
         }
-        return result;
     }
     /**
      * Build TrackingResult from TrackingState
@@ -639,38 +729,29 @@ class ProposalStageTracker {
      * ```
      */
     async trackFromCheckpoint(checkpoint) {
-        const input = checkpoint.input;
-        if (input.type === "governor") {
-            if (!input.creationTxHash) {
-                throw new Error("Governor checkpoint missing creationTxHash");
-            }
-            const results = await this.trackByTxHash(input.creationTxHash);
+        const { input } = checkpoint;
+        const trackAndWarn = async (txHash, entityType) => {
+            const results = await this.trackByTxHash(txHash);
             if (results.length === 0) {
-                throw new Error(`No proposal found in tx ${input.creationTxHash}`);
+                throw new Error(`No ${entityType} found in tx ${txHash}`);
             }
             if (results.length > 1) {
                 logTracker("WARNING: trackFromCheckpoint found %d results in tx %s, returning first only. " +
-                    "Use trackByTxHash() to get all results.", results.length, input.creationTxHash);
+                    "Use trackByTxHash() to get all results.", results.length, txHash);
             }
             return results[0];
+        };
+        if (input.type === "governor") {
+            if (!input.creationTxHash)
+                throw new Error("Governor checkpoint missing creationTxHash");
+            return trackAndWarn(input.creationTxHash, "proposal");
         }
-        else if (input.type === "timelock") {
-            if (!input.scheduledTxHash) {
+        if (input.type === "timelock") {
+            if (!input.scheduledTxHash)
                 throw new Error("Timelock checkpoint missing scheduledTxHash");
-            }
-            const results = await this.trackByTxHash(input.scheduledTxHash);
-            if (results.length === 0) {
-                throw new Error(`No timelock operation found in tx ${input.scheduledTxHash}`);
-            }
-            if (results.length > 1) {
-                logTracker("WARNING: trackFromCheckpoint found %d results in tx %s, returning first only. " +
-                    "Use trackByTxHash() to get all results.", results.length, input.scheduledTxHash);
-            }
-            return results[0];
-        }
-        else {
-            throw new Error(`Unsupported checkpoint input type: ${input.type}`);
+            return trackAndWarn(input.scheduledTxHash, "timelock operation");
         }
+        throw new Error(`Unsupported checkpoint input type: ${input.type}`);
     }
     // Transaction Preparation
     /**
@@ -728,7 +809,7 @@ class ProposalStageTracker {
      * Track election status for a given proposal ID.
      *
      * Searches through elections to find the one containing this proposal,
-     * then tracks the full election lifecycle.
+     * then tracks the full election lifecycle using the unified pipeline.
      */
     async trackElectionStatus(proposalId) {
         logTracker("trackElectionStatus for proposal %s", proposalId);
@@ -741,9 +822,8 @@ class ProposalStageTracker {
                 return null;
             }
             logTracker("found election index %d for proposal %s", electionIndex, proposalId);
-            return (0, election_1.trackElectionProposal)(electionIndex, this.l2Provider, this.l1Provider, {
-                novaProvider: this.novaProvider,
-            });
+            // Use unified pipeline via trackElection
+            return this.trackElection(electionIndex);
         }
         catch (error) {
             // Election tracking is non-critical - log and return null
@@ -763,35 +843,36 @@ class ProposalStageTracker {
      * - Incomplete elections: Makes fresh RPC calls and updates cache
      * - No cache: Always makes fresh RPC calls
      *
+     * To force fresh tracking, clear the cache before calling this method.
+     *
      * @param electionIndex - Election index (0-based)
-     * @param options.force - Force fresh tracking even for completed elections
      * @returns Election status
      */
-    async trackElection(electionIndex, options = {}) {
-        logTracker("trackElection for index %d (force=%s)", electionIndex, options.force ?? false);
+    async trackElection(electionIndex) {
+        logTracker("trackElection for index %d", electionIndex);
+        const cacheKey = `election:${electionIndex}`;
         // Check cache first for completed elections (skip RPC calls)
-        if (this.cache && !options.force) {
+        if (this.cache) {
             const cached = await this.getElectionCheckpoint(electionIndex);
             if (cached && cached.status.phase === "COMPLETED") {
                 logTracker("returning cached COMPLETED election %d (0 RPC calls)", electionIndex);
                 return cached.status;
             }
         }
-        // Build full tracking context for consistent state across all calls
-        const context = await buildTrackingContext({
-            l2Provider: this.l2Provider,
-            l1Provider: this.l1Provider,
-            novaProvider: this.novaProvider,
-            skipCache: options.force,
-        });
-        // Track fresh for incomplete elections or cache miss
-        const status = await (0, election_1.trackElectionProposal)(electionIndex, this.l2Provider, this.l1Provider, {
-            novaProvider: this.novaProvider,
-            l2BlockNumber: context.l2BlockNumber,
-            timestamp: context.timestamp,
-            skipCache: context.skipCache,
-        });
+        // Load checkpoint from cache for resume
+        let checkpoint;
         if (this.cache) {
+            checkpoint = (await this.cache.get(cacheKey)) ?? undefined;
+            if (checkpoint) {
+                logTracker("loaded election checkpoint from cache: %s", cacheKey);
+            }
+        }
+        // Track using the unified pipeline
+        const { status, finalState } = await this.trackElectionWithPipeline(electionIndex, checkpoint, cacheKey);
+        // Save checkpoints using modular caching
+        if (this.cache) {
+            await this.saveModularCheckpoints(finalState, cacheKey);
+            // Also save election-specific data
             await this.saveElectionCheckpoint(status);
         }
         return status;
@@ -803,59 +884,31 @@ class ProposalStageTracker {
      * - COMPLETED elections: Returns cached data immediately (0 RPC calls)
      * - Incomplete elections: Makes fresh RPC calls and updates cache
      *
+     * To force fresh tracking, clear the cache before calling this method.
+     *
      * @param options.includeNext - Include the "next" election slot (default: true)
-     * @param options.force - Force fresh tracking for all elections
      * @returns Array of election statuses
      */
     async trackAllElections(options = {}) {
-        logTracker("trackAllElections (includeNext=%s, force=%s)", options.includeNext ?? true, options.force ?? false);
-        // Build context once at the start for consistent state across all elections
-        const context = await buildTrackingContext({
-            l2Provider: this.l2Provider,
-            l1Provider: this.l1Provider,
-            novaProvider: this.novaProvider,
-            skipCache: options.force,
-        });
+        logTracker("trackAllElections (includeNext=%s)", options.includeNext ?? true);
         const status = await (0, election_1.checkElectionStatus)(this.l2Provider, this.l1Provider);
         const electionCount = status.electionCount;
         const results = [];
-        // Track existing elections (indices 0 to electionCount-1)
-        for (let i = 0; i < electionCount; i++) {
-            try {
-                // Check cache first for completed elections (skip RPC calls)
-                if (this.cache && !options.force) {
-                    const cached = await this.getElectionCheckpoint(i);
-                    if (cached && cached.status.phase === "COMPLETED") {
-                        logTracker("returning cached COMPLETED election %d (0 RPC calls)", i);
-                        results.push(cached.status);
-                        continue;
-                    }
-                }
-                // Track with shared context
-                const electionStatus = await (0, election_1.trackElectionProposal)(i, this.l2Provider, this.l1Provider, {
-                    novaProvider: this.novaProvider,
-                    l2BlockNumber: context.l2BlockNumber,
-                    timestamp: context.timestamp,
-                    skipCache: context.skipCache,
-                });
-                results.push(electionStatus);
-                if (this.cache) {
-                    await this.saveElectionCheckpoint(electionStatus);
-                }
-            }
-            catch (err) {
-                logTracker("Failed to track election %d: %s", i, err);
-            }
+        // Track existing elections in parallel (indices 0 to electionCount-1)
+        const electionPromises = Array.from({ length: electionCount }, (_, i) => this.trackElection(i).catch((err) => {
+            logTracker("Failed to track election %d: %s", i, (0, rpc_utils_1.getErrorMessage)(err));
+            return null;
+        }));
+        const electionResults = await Promise.all(electionPromises);
+        for (const result of electionResults) {
+            if (result)
+                results.push(result);
         }
         // Optionally track the next election (not yet created) for createElection preparation
         if (options.includeNext ?? true) {
             try {
-                // Next election always needs fresh RPC calls since it doesn't exist yet
-                const nextElectionStatus = await (0, election_1.trackElectionProposal)(electionCount, this.l2Provider, this.l1Provider, {
-                    novaProvider: this.novaProvider,
-                    l2BlockNumber: context.l2BlockNumber,
-                    timestamp: context.timestamp,
-                });
+                // Next election won't have cache data since it doesn't exist yet
+                const nextElectionStatus = await this.trackElection(electionCount);
                 results.push({
                     ...nextElectionStatus,
                     canCreateElection: status.canCreateElection,
@@ -865,7 +918,7 @@ class ProposalStageTracker {
                 // Don't cache the "next" election since it doesn't exist yet
             }
             catch (err) {
-                logTracker("Failed to track next election %d: %s", electionCount, err);
+                logTracker("Failed to track next election %d: %s", electionCount, (0, rpc_utils_1.getErrorMessage)(err));
             }
         }
         logTracker("Tracked %d elections", results.length);