@gzeoneth/gov-tracker 0.2.1 → 0.3.0-beta.3e02aff

package/dist/tracker.js

@@ -19,12 +19,50 @@ exports.createTracker = createTracker;
 const ethers_1 = require("ethers");
 const logger_1 = require("./utils/logger");
 const rpc_utils_1 = require("./utils/rpc-utils");
+const timing_1 = require("./utils/timing");
+const checkpoint_helpers_1 = require("./tracker/checkpoint-helpers");
 const constants_1 = require("./constants");
 const election_1 = require("./election");
 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");
@@ -118,6 +156,44 @@ class ProposalStageTracker {
     static async readCacheStatus(cachePath) {
         return (0, cache_1.readCacheStatus)(cachePath);
     }
+    /**
+     * Clear a specific cache entry. Used by --force to ensure fresh tracking.
+     */
+    async clearCacheEntry(key) {
+        if (this.cache) {
+            await this.cache.delete(key);
+            logTracker("cleared cache entry: %s", key);
+        }
+    }
+    /**
+     * Clear all cache entries for a transaction.
+     * This clears both the base tx key and any operation-specific keys (tx:{hash}:op:{opId}).
+     * Used by CLI --force to ensure fresh tracking of all operations in a tx.
+     */
+    async clearTxCacheEntries(txHash) {
+        if (!this.cache)
+            return 0;
+        const baseCacheKey = (0, checkpoint_helpers_1.txHashCacheKey)(txHash);
+        const prefix = `${baseCacheKey}:op:`;
+        let cleared = 0;
+        // Clear the base tx key
+        if (await this.cache.has(baseCacheKey)) {
+            await this.cache.delete(baseCacheKey);
+            logTracker("cleared cache entry: %s", baseCacheKey);
+            cleared++;
+        }
+        // Clear all operation-specific keys for this tx
+        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++;
+            }
+        }
+        return cleared;
+    }
     // Watermark Management
     /**
      * Load discovery watermarks from cache.
@@ -131,9 +207,84 @@ class ProposalStageTracker {
      * Save discovery watermarks to cache.
      * Watermarks are stored as TrackingCheckpoint with proper metadata,
      * following the same pattern as proposal/timelock checkpoints.
+     *
+     * @param watermarks - Block numbers per discovery key
+     * @param hashes - Block hashes per discovery key (for reorg detection)
      */
-    async saveWatermarks(watermarks) {
-        return (0, discovery_1.saveWatermarks)(watermarks, this.cache);
+    async saveWatermarks(watermarks, hashes = {}) {
+        return (0, discovery_1.saveWatermarks)(watermarks, hashes, this.cache);
+    }
+    /**
+     * Save an election checkpoint to cache.
+     * Elections are stored with key format: `election:{electionIndex}`
+     *
+     * 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 options.nomineeDetails - Pre-fetched nominee details (skips RPC fetch)
+     * @param options.memberDetails - Pre-fetched member details (skips RPC fetch)
+     */
+    async saveElectionCheckpoint(electionStatus, options = {}) {
+        if (!this.cache)
+            return;
+        const key = `election:${electionStatus.electionIndex}`;
+        const now = Date.now();
+        let nomineeDetails = options.nomineeDetails;
+        let memberDetails = options.memberDetails;
+        // For COMPLETED elections, fetch details if not provided
+        if (electionStatus.phase === "COMPLETED" && !nomineeDetails && !memberDetails) {
+            try {
+                const [rawNomineeDetails, rawMemberDetails] = await Promise.all([
+                    (0, election_1.getNomineeElectionDetails)(electionStatus.electionIndex, this.l2Provider),
+                    (0, election_1.getMemberElectionDetails)(electionStatus.electionIndex, this.l2Provider),
+                ]);
+                if (rawNomineeDetails) {
+                    nomineeDetails = (0, election_1.serializeNomineeDetails)(rawNomineeDetails);
+                }
+                if (rawMemberDetails) {
+                    memberDetails = (0, election_1.serializeMemberDetails)(rawMemberDetails);
+                }
+                logTracker("fetched election %d details: nominees=%d, members=%d", electionStatus.electionIndex, nomineeDetails?.nominees?.length ?? 0, memberDetails?.nominees?.length ?? 0);
+            }
+            catch (err) {
+                logTracker("failed to fetch election %d details (non-fatal): %s", electionStatus.electionIndex, err.message);
+            }
+        }
+        await this.cache.set(key, {
+            version: 1,
+            createdAt: now,
+            input: { type: "election", electionIndex: electionStatus.electionIndex },
+            lastProcessedStage: null,
+            lastProcessedBlock: { l1: 0, l2: 0 },
+            cachedData: { electionStatus, nomineeDetails, memberDetails },
+            metadata: { errorCount: 0, lastTrackedAt: now },
+        });
+        logTracker("saved election checkpoint: %s (phase: %s)", key, electionStatus.phase);
+    }
+    /**
+     * Get an election checkpoint from cache.
+     *
+     * For COMPLETED elections, includes cached nominee/member details:
+     * - nomineeDetails: Contenders, nominees, excluded nominees, quorum threshold
+     * - memberDetails: Final nominee rankings, winners, voting deadlines
+     *
+     * @param electionIndex - Election index
+     * @returns Election data or null if not cached
+     */
+    async getElectionCheckpoint(electionIndex) {
+        if (!this.cache)
+            return null;
+        const key = `election:${electionIndex}`;
+        const checkpoint = await this.cache.get(key);
+        if (!checkpoint?.cachedData?.electionStatus) {
+            return null;
+        }
+        return {
+            status: checkpoint.cachedData.electionStatus,
+            nomineeDetails: checkpoint.cachedData.nomineeDetails ?? null,
+            memberDetails: checkpoint.cachedData.memberDetails ?? null,
+        };
     }
     // Discovery API
     /**
@@ -162,9 +313,10 @@ class ProposalStageTracker {
      * Discover all proposals and timelock operations with auto-watermark management.
      *
      * This is the unified discovery API that handles everything internally:
+     * - Verifies watermark hashes to detect chain reorgs (rolls back if mismatch)
      * - Loads watermarks from cache (or uses provided fromWatermarks)
      * - Discovers from all enabled targets in parallel
-     * - Auto-saves updated watermarks to cache
+     * - Auto-saves updated watermarks and hashes to cache
      *
      * @param targets - Which governors/timelocks to scan
      * @param toBlock - End block for discovery
@@ -172,11 +324,13 @@ class ProposalStageTracker {
      * @returns Discovered proposals, timelock ops, and updated watermarks
      */
     async discoverAll(targets, toBlock, fromWatermarks) {
-        // Load watermarks from cache (or use provided override)
-        const watermarks = fromWatermarks ?? (await this.loadWatermarks());
-        const result = await (0, discovery_2.discoverAll)(targets, toBlock, this.l2Provider, this.cache, watermarks, { chunkSize: this.chunkingConfig.l2ChunkSize });
-        // Auto-save updated watermarks
-        await this.saveWatermarks(result.watermarks);
+        // Load watermarks and hashes from cache (or use provided override)
+        const loaded = await this.loadWatermarks();
+        const watermarks = fromWatermarks ?? loaded.watermarks;
+        const hashes = fromWatermarks ? {} : loaded.hashes; // Only use cached hashes if using cached watermarks
+        const result = await (0, discovery_2.discoverAll)(targets, toBlock, this.l2Provider, this.cache, watermarks, hashes, { chunkSize: this.chunkingConfig.l2ChunkSize });
+        // Auto-save updated watermarks and hashes
+        await this.saveWatermarks(result.watermarks, result.hashes);
         return result;
     }
     // Checkpoint Query API
@@ -229,42 +383,58 @@ class ProposalStageTracker {
      * - Automatically loads existing checkpoint from cache (zero-RPC resume)
      * - Automatically saves checkpoint to cache after tracking
      *
+     * @param txHash - Transaction hash to track
+     * @param operationId - Optional: track only this specific timelock operation
+     *
      * @example
      * ```typescript
+     * // Track all operations in a transaction
      * const results = await tracker.trackByTxHash("0x...");
-     * for (const result of results) {
-     *   console.log(`Found ${result.stages.length} stages`);
-     * }
+     *
+     * // Track a specific operation
+     * const results = await tracker.trackByTxHash("0x...", "0xoperationId...");
      * ```
      */
-    async trackByTxHash(txHash) {
-        logTracker("trackByTxHash %s", txHash);
-        // Cache key for this transaction
-        const cacheKey = (0, cache_1.txHashCacheKey)(txHash);
+    async trackByTxHash(txHash, operationId) {
+        logTracker("trackByTxHash %s%s", txHash, operationId ? ` operationId=${operationId}` : "");
+        // Determine cache key based on whether operationId is provided
+        // - Governor proposals and timelock discovery: tx:{txHash}
+        // - Specific timelock operation: tx:{txHash}:op:{operationId}
+        const baseCacheKey = (0, checkpoint_helpers_1.txHashCacheKey)(txHash);
         // Load checkpoint from cache for resume
         let checkpoint;
         if (this.cache) {
-            checkpoint = (await this.cache.get(cacheKey)) ?? undefined;
-            if (checkpoint) {
-                logTracker("loaded checkpoint from cache: %s", cacheKey);
+            // If operationId provided, try operation-specific key first
+            if (operationId) {
+                const opCacheKey = (0, checkpoint_helpers_1.timelockOpCacheKey)(txHash, operationId);
+                checkpoint = (await this.cache.get(opCacheKey)) ?? undefined;
+                if (checkpoint) {
+                    logTracker("loaded checkpoint from cache: %s", opCacheKey);
+                }
+            }
+            // Fall back to base cache key (for governor proposals or legacy checkpoints)
+            if (!checkpoint) {
+                checkpoint = (await this.cache.get(baseCacheKey)) ?? undefined;
+                if (checkpoint) {
+                    logTracker("loaded checkpoint from cache: %s", baseCacheKey);
+                }
             }
         }
         try {
-            return await this.trackByTxHashInternal(txHash, cacheKey, checkpoint);
+            return await this.trackByTxHashInternal(txHash, baseCacheKey, checkpoint, operationId);
         }
         catch (error) {
             // Save checkpoint on error with incremented error count
             // Gas estimation errors don't count against consecutive errors
             if (this.cache) {
-                const input = {
-                    type: "governor",
-                    governorAddress: "",
-                    proposalId: "",
-                    creationTxHash: txHash,
-                };
                 const prevErrorCount = checkpoint?.metadata?.errorCount ?? 0;
+                const newErrorCount = (0, checkpoint_helpers_1.incrementErrorCount)(prevErrorCount, error);
                 const isGasError = (0, rpc_utils_1.isGasEstimationError)(error);
-                const newErrorCount = isGasError ? prevErrorCount : prevErrorCount + 1;
+                // Use operation-specific key for timelock errors if operationId is known
+                const errorCacheKey = operationId ? (0, checkpoint_helpers_1.timelockOpCacheKey)(txHash, operationId) : baseCacheKey;
+                const input = operationId
+                    ? { type: "timelock", timelockAddress: "", operationId, scheduledTxHash: txHash }
+                    : { type: "governor", governorAddress: "", proposalId: "", creationTxHash: txHash };
                 const errorCheckpoint = checkpoint ?? {
                     version: 1,
                     createdAt: Date.now(),
@@ -273,9 +443,9 @@ class ProposalStageTracker {
                     lastProcessedBlock: { l1: 0, l2: 0 },
                     cachedData: {},
                 };
-                errorCheckpoint.metadata = { errorCount: newErrorCount, lastTrackedAt: Date.now() };
-                await this.cache.set(cacheKey, errorCheckpoint);
-                logTracker("saved checkpoint on error: %s (errorCount=%d%s)", cacheKey, newErrorCount, isGasError ? " - gas error, not incrementing" : "");
+                errorCheckpoint.metadata = (0, checkpoint_helpers_1.createCheckpointMetadata)(newErrorCount);
+                await this.cache.set(errorCacheKey, errorCheckpoint);
+                logTracker("saved checkpoint on error: %s (errorCount=%d%s)", errorCacheKey, newErrorCount, isGasError ? " - gas error, not incrementing" : "");
             }
             throw error;
         }
@@ -285,29 +455,32 @@ class ProposalStageTracker {
      *
      * Uses PipelineContext for stateful tracking - no parameter passing between stages.
      */
-    async trackByTxHashInternal(txHash, cacheKey, checkpoint) {
+    async trackByTxHashInternal(txHash, baseCacheKey, checkpoint, operationId) {
         // RESUME PATH: If we have a checkpoint, check what type it is
         if (checkpoint && checkpoint.input.type !== "discovery") {
             logTracker("RESUME: found checkpoint for tx, type=%s", checkpoint.input.type);
             if (checkpoint.input.type === "governor") {
                 const input = checkpoint.input;
-                const result = await this.trackGovernorWithPipeline(input.governorAddress, input.proposalId, input.creationTxHash, checkpoint, cacheKey);
+                const result = await this.trackGovernorWithPipeline(input.governorAddress, input.proposalId, input.creationTxHash, checkpoint, baseCacheKey);
                 return [result];
             }
             else if (checkpoint.input.type === "timelock") {
                 const input = checkpoint.input;
-                const result = await this.trackTimelockWithPipeline(input.timelockAddress, input.operationId, input.scheduledTxHash, checkpoint, cacheKey);
+                const opCacheKey = (0, checkpoint_helpers_1.timelockOpCacheKey)(txHash, input.operationId);
+                const result = await this.trackTimelockWithPipeline(input.timelockAddress, input.operationId, input.scheduledTxHash, checkpoint, opCacheKey);
                 return [result];
             }
         }
-        // Try as proposal first
-        const proposal = await (0, governor_discovery_1.discoverProposalByTxHash)(txHash, this.l2Provider);
-        if (proposal) {
-            logDiscovery("found proposal in tx, proposalId=%s", proposal.proposalId);
-            const result = await this.trackGovernorWithPipeline(proposal.governorAddress, proposal.proposalId, proposal.creationTxHash, checkpoint, cacheKey);
-            return [result];
+        // Try as proposal first (only if no operationId specified)
+        if (!operationId) {
+            const proposal = await (0, governor_discovery_1.discoverProposalByTxHash)(txHash, this.l2Provider);
+            if (proposal) {
+                logDiscovery("found proposal in tx, proposalId=%s", proposal.proposalId);
+                const result = await this.trackGovernorWithPipeline(proposal.governorAddress, proposal.proposalId, proposal.creationTxHash, checkpoint, baseCacheKey);
+                return [result];
+            }
         }
-        // Try as timelock operations (may be batch with multiple ops)
+        // Try as timelock operations
         const callScheduledEvents = await (0, timelock_discovery_1.findCallScheduledByTxHash)(txHash, this.l2Provider);
         if (callScheduledEvents && callScheduledEvents.length > 0) {
             logDiscovery("found %d timelock operation(s) in tx", callScheduledEvents.length);
@@ -315,11 +488,28 @@ class ProposalStageTracker {
             const seenOperationIds = new Set();
             const results = [];
             for (const event of callScheduledEvents) {
+                // Skip if we've already seen this operationId (batch deduplication)
                 if (seenOperationIds.has(event.operationId))
                     continue;
                 seenOperationIds.add(event.operationId);
-                const result = await this.trackTimelockWithPipeline(event.timelockAddress, event.operationId, txHash, checkpoint, cacheKey, event);
+                // If specific operationId requested, skip non-matching operations
+                if (operationId && event.operationId.toLowerCase() !== operationId.toLowerCase())
+                    continue;
+                // Use operation-specific cache key for each timelock operation
+                const opCacheKey = (0, checkpoint_helpers_1.timelockOpCacheKey)(txHash, event.operationId);
+                // Load operation-specific checkpoint if not already loaded
+                let opCheckpoint = checkpoint;
+                if (this.cache && !opCheckpoint) {
+                    opCheckpoint = (await this.cache.get(opCacheKey)) ?? undefined;
+                    if (opCheckpoint) {
+                        logTracker("loaded operation checkpoint from cache: %s", opCacheKey);
+                    }
+                }
+                const result = await this.trackTimelockWithPipeline(event.timelockAddress, event.operationId, txHash, opCheckpoint, opCacheKey, event);
                 results.push(result);
+                // If specific operationId requested and found, we're done
+                if (operationId)
+                    break;
             }
             return results;
         }
@@ -353,7 +543,23 @@ class ProposalStageTracker {
         const finalState = await (0, pipeline_1.trackGovernorPipeline)(initialState);
         // Build result from state
         const result = this.buildResultFromState(finalState);
-        // Save checkpoint to cache
+        // Track election status if this is an election governor proposal
+        if (result.isElection) {
+            const electionStatus = await this.trackElectionStatus(proposalId);
+            if (electionStatus) {
+                result.electionStatus = electionStatus;
+                await this.saveElectionCheckpoint(electionStatus);
+                // Elections are fully tracked via election checkpoints, remove tx:* checkpoint
+                if (this.cache && cacheKey) {
+                    await this.cache.delete(cacheKey);
+                    logTracker("election tracked via election checkpoint, removed tx:* checkpoint: %s", cacheKey);
+                }
+                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)
         if (this.cache && cacheKey) {
             result.checkpoint.metadata = { errorCount: 0, lastTrackedAt: Date.now() };
             await this.cache.set(cacheKey, result.checkpoint);
@@ -517,6 +723,154 @@ class ProposalStageTracker {
             nova: this.novaProvider,
         };
     }
+    // Election Tracking
+    /**
+     * Track election status for a given proposal ID.
+     *
+     * Searches through elections to find the one containing this proposal,
+     * then tracks the full election lifecycle.
+     */
+    async trackElectionStatus(proposalId) {
+        logTracker("trackElectionStatus for proposal %s", proposalId);
+        try {
+            // Get current L2 block for block-scoped caching
+            const { blockNumber: l2BlockNumber } = await (0, timing_1.getCurrentBlockInfo)(this.l2Provider);
+            const electionIndex = await (0, election_1.getElectionIndexForProposalId)(proposalId, this.l2Provider, this.l1Provider, { novaProvider: this.novaProvider, blockNumber: l2BlockNumber });
+            if (electionIndex === null) {
+                logTracker("no election found for proposal %s", proposalId);
+                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,
+            });
+        }
+        catch (error) {
+            // Election tracking is non-critical - log and return null
+            // The proposal stages are already tracked successfully
+            logTracker("election tracking failed for proposal %s: %O", proposalId, error);
+            return null;
+        }
+    }
+    /**
+     * Track an election by its index.
+     *
+     * This method provides direct election tracking when you have the election index.
+     * For tracking via tx hash, use trackByTxHash() which auto-detects elections.
+     *
+     * Caching behavior:
+     * - COMPLETED elections: Returns cached data immediately (0 RPC calls)
+     * - Incomplete elections: Makes fresh RPC calls and updates cache
+     * - No cache: Always makes fresh RPC calls
+     *
+     * @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);
+        // Check cache first for completed elections (skip RPC calls)
+        if (this.cache && !options.force) {
+            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,
+        });
+        if (this.cache) {
+            await this.saveElectionCheckpoint(status);
+        }
+        return status;
+    }
+    /**
+     * Track all elections with caching.
+     *
+     * Caching behavior:
+     * - COMPLETED elections: Returns cached data immediately (0 RPC calls)
+     * - Incomplete elections: Makes fresh RPC calls and updates cache
+     *
+     * @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,
+        });
+        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);
+            }
+        }
+        // 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,
+                });
+                results.push({
+                    ...nextElectionStatus,
+                    canCreateElection: status.canCreateElection,
+                    secondsUntilElection: status.secondsUntilElection,
+                    timeUntilElection: status.timeUntilElection,
+                });
+                // 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("Tracked %d elections", results.length);
+        return results;
+    }
     // Election Support
     /**
      * Check Security Council election status and prepare available actions
@@ -532,6 +886,7 @@ class ProposalStageTracker {
             status,
             canCreate: status.canCreateElection,
             canTriggerMember: false,
+            canExecuteMember: false,
             prepared: {},
         };
         if (status.canCreateElection) {
@@ -540,15 +895,23 @@ class ProposalStageTracker {
         }
         if (status.electionCount > 0) {
             const currentElectionIndex = status.electionCount - 1;
-            const electionStatus = await (0, election_1.trackElectionProposal)(currentElectionIndex, this.l2Provider, this.l1Provider);
+            // Use cached tracking for the current election
+            const electionStatus = await this.trackElection(currentElectionIndex);
             result.currentElection = electionStatus;
             result.canTriggerMember = electionStatus.canProceedToMemberPhase;
+            result.canExecuteMember = electionStatus.canExecuteMember;
             if (electionStatus.canProceedToMemberPhase) {
                 const memberTx = await (0, election_1.prepareMemberElectionTrigger)(electionStatus, this.l2Provider);
                 if (memberTx) {
                     result.prepared.triggerMember = memberTx;
                 }
             }
+            if (electionStatus.canExecuteMember) {
+                const executeTx = await (0, election_1.prepareMemberElectionExecution)(electionStatus, this.l2Provider);
+                if (executeTx) {
+                    result.prepared.executeMember = executeTx;
+                }
+            }
         }
         return result;
     }