@gzeoneth/gov-tracker 0.3.0 → 0.4.0-beta.18db0de

package/dist/tracker/pipeline.js

@@ -1,15 +1,26 @@
 "use strict";
 /**
- * Pipeline Stage Functions
+ * Pipeline Stage Tracking
  *
- * Pure functions that track stages and return updated state.
- * Each function reads from state, performs tracking, and returns new state.
+ * Declarative pipelines for tracking governance proposals and elections.
+ * Each stage is a config object with type and track function.
+ * The stage runner handles caching automatically.
+ *
+ * Three tracking paths:
+ * - Governor: PROPOSAL_CREATED → VOTING_ACTIVE → PROPOSAL_QUEUED → timelock
+ * - Timelock: L2_TIMELOCK → L2_TO_L1_MESSAGE → L1_TIMELOCK → RETRYABLE_EXECUTED
+ * - Election: CREATE_ELECTION → NOMINEE_ELECTION → NOMINEE_VETTING → MEMBER_ELECTION → timelock
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getElectionContext = getElectionContext;
+exports.proposalStateToStageStatus = proposalStateToStageStatus;
 exports.trackGovernorPipeline = trackGovernorPipeline;
 exports.trackTimelockPipeline = trackTimelockPipeline;
+exports.trackElectionPipeline = trackElectionPipeline;
+const ethers_1 = require("ethers");
 const logger_1 = require("../utils/logger");
 const state_1 = require("./state");
+const stage_runner_1 = require("./stage-runner");
 const utils_1 = require("../stages/utils");
 const proposal_created_1 = require("../stages/proposal-created");
 const voting_1 = require("../stages/voting");
@@ -20,171 +31,148 @@ const l2_to_l1_message_1 = require("../stages/l2-to-l1-message");
 const retryables_1 = require("../stages/retryables");
 const constants_1 = require("../constants");
 const timing_2 = require("../utils/timing");
-// Logging
+const builder_1 = require("../stages/builder");
+const rpc_utils_1 = require("../utils/rpc-utils");
+const multicall_1 = require("../utils/multicall");
+const abis_1 = require("../abis");
+const contracts_1 = require("../election/contracts");
+const proposal_ids_1 = require("../election/proposal-ids");
+const timelock_discovery_1 = require("../discovery/timelock-discovery");
+const governor_discovery_1 = require("../discovery/governor-discovery");
+const log_search_1 = require("../utils/log-search");
 const { pipeline: log, tracker: logTracker } = logger_1.loggers;
-// Stage chain mapping for L1 stages
-// L1_TIMELOCK is the only L1 stage; RETRYABLE_EXECUTED runs on L2 (Arb1/Nova)
-const L1_STAGES = new Set(["L1_TIMELOCK"]);
-// Helper: create placeholder stage
-const placeholder = (type, status, reason) => 
-// Assertion needed: placeholder stages have partial data that gets filled later
-({
-    type,
-    status,
-    chain: L1_STAGES.has(type) ? "ethereum" : "arb1",
-    chainId: L1_STAGES.has(type) ? 1 : 42161,
-    transactions: [],
-    data: { reason },
-});
-// Helper: track with cache check
-async function withCache(state, stageType, key, onCached, onTrack) {
-    const cached = (0, state_1.getCompletedStage)(state, stageType);
-    if (cached) {
-        log("%s: using cached stage", stageType);
-        return { state: await (0, state_1.addStage)(state, cached), [key]: onCached(cached) };
-    }
-    return onTrack();
+/** Guard for election stages - returns election index and nominee proposal ID if available */
+function getElectionContext(state) {
+    const electionIndex = (0, state_1.getElectionIndex)(state);
+    const nomineeProposalId = (0, state_1.getNomineeProposalId)(state);
+    return electionIndex !== undefined && nomineeProposalId
+        ? { electionIndex, nomineeProposalId }
+        : null;
 }
-// Helper: track stage with error handling
-async function track(state, stageType, key, tracker) {
-    try {
-        const { stage, result } = await tracker();
-        return { state: await (0, state_1.addStage)(state, stage), [key]: result };
+/** Map proposal state string to stage status */
+function proposalStateToStageStatus(proposalState) {
+    if (proposalState === "Active" || proposalState === "Pending") {
+        return { status: "PENDING", complete: false };
     }
-    catch (error) {
-        throw new Error(`Failed to track ${stageType}: ${error instanceof Error ? error.message : String(error)}`);
+    if (proposalState === "Defeated" || proposalState === "Canceled") {
+        return { status: "FAILED", complete: false };
     }
+    return { status: "COMPLETED", complete: true };
 }
-// Governor Stages (1-3)
-async function pipelineTrackProposalCreated(state) {
+// ============================================================================
+// Governor Stage Trackers
+// ============================================================================
+async function trackProposalCreatedStage(state) {
     const governorAddress = (0, state_1.getGovernorAddress)(state);
     const proposalId = (0, state_1.getProposalId)(state);
     if (!governorAddress || !proposalId)
-        return { state, found: false };
+        return { state, continue: false };
     if ((0, state_1.getIsElection)(state))
-        return { state, found: false };
-    return withCache(state, "PROPOSAL_CREATED", "found", () => true, async () => {
-        log("PROPOSAL_CREATED: tracking");
-        const creationTxHash = state.input.type === "governor" ? state.input.creationTxHash : undefined;
-        return track(state, "PROPOSAL_CREATED", "found", async () => {
-            const r = await (0, proposal_created_1.trackProposalCreated)(governorAddress, proposalId, state.providers.l2, {
-                creationTxHash,
-                chunkSize: state.chunkingConfig.l2ChunkSize,
-            });
-            return { stage: r.stage, result: r.proposalData !== null };
-        });
+        return { state, continue: false };
+    log("PROPOSAL_CREATED: tracking");
+    const creationTxHash = state.input.type === "governor" ? state.input.creationTxHash : undefined;
+    const result = await (0, proposal_created_1.trackProposalCreated)(governorAddress, proposalId, state.providers.l2, {
+        creationTxHash,
+        chunkSize: state.chunkingConfig.l2ChunkSize,
     });
+    return {
+        state: await (0, state_1.addStage)(state, result.stage),
+        continue: result.proposalData !== null,
+    };
 }
-async function pipelineTrackVoting(state) {
+async function trackVotingStage_(state) {
     const governorAddress = (0, state_1.getGovernorAddress)(state);
     const proposalId = (0, state_1.getProposalId)(state);
     const proposalData = (0, state_1.getProposalData)(state);
     if (!governorAddress || !proposalId || !proposalData)
-        return { state, complete: false };
-    return withCache(state, "VOTING_ACTIVE", "complete", (c) => c.status === "COMPLETED", async () => {
-        log("VOTING_ACTIVE: tracking");
-        return track(state, "VOTING_ACTIVE", "complete", async () => {
-            const r = await (0, voting_1.trackVotingStage)(governorAddress, proposalId, proposalData, state.providers.l2);
-            return { stage: r.stage, result: r.stage.status === "COMPLETED" };
-        });
-    });
+        return { state, continue: false };
+    log("VOTING_ACTIVE: tracking");
+    const result = await (0, voting_1.trackVotingStage)(governorAddress, proposalId, proposalData, state.providers.l2);
+    return {
+        state: await (0, state_1.addStage)(state, result.stage),
+        continue: result.stage.status === "COMPLETED",
+    };
 }
-async function pipelineTrackProposalQueued(state) {
+async function trackProposalQueuedStage(state) {
     const governorAddress = (0, state_1.getGovernorAddress)(state);
     const proposalId = (0, state_1.getProposalId)(state);
     const proposalData = (0, state_1.getProposalData)(state);
     if (!governorAddress || !proposalId)
-        return { state, queued: false };
-    return withCache(state, "PROPOSAL_QUEUED", "queued", () => true, async () => {
-        log("PROPOSAL_QUEUED: tracking");
-        return track(state, "PROPOSAL_QUEUED", "queued", async () => {
-            // Voting deadline is L1 block number - convert to L2 for searching
-            // Use bounds to speed up binary search: min=creation block, max=creation+7M (~20 days)
-            const votingDeadlineL1 = (0, state_1.getVotingEndBlock)(state);
-            let votingEndBlock;
-            if (votingDeadlineL1) {
-                const creationBlock = proposalData?.creationBlock ?? 0;
-                const { blockNumber: currentL2Block } = await (0, timing_2.getCurrentBlockInfo)(state.providers.l2);
-                const maxL2Block = Math.min(creationBlock + 7000000, currentL2Block);
-                votingEndBlock = await (0, timing_1.getFirstL2BlockForL1Block)(state.providers.l2, votingDeadlineL1, {
-                    minL2Block: creationBlock,
-                    maxL2Block,
-                });
-            }
-            const r = await (0, proposal_queued_1.trackProposalQueued)(governorAddress, proposalId, state.providers.l2, proposalData?.creationBlock ?? 0, { votingEndBlock, chunkSize: state.chunkingConfig.l2ChunkSize });
-            let stage = r.stage;
-            if (stage.type === "PROPOSAL_QUEUED" && stage.status === "READY" && proposalData) {
-                // Enrich stage data with proposal info for READY state
-                stage = {
-                    ...stage,
-                    data: {
-                        ...stage.data,
-                        targets: proposalData.targets,
-                        values: Array.from(proposalData.values).map((v) => v.toString()),
-                        calldatas: proposalData.calldatas,
-                        description: proposalData.description,
-                    },
-                };
-            }
-            return { stage, result: r.operationId !== null && r.timelockAddress !== null };
+        return { state, continue: false };
+    log("PROPOSAL_QUEUED: tracking");
+    // Convert L1 voting deadline to L2 block for searching
+    const votingDeadlineL1 = (0, state_1.getVotingEndBlock)(state);
+    let votingEndBlock;
+    if (votingDeadlineL1) {
+        const creationBlock = proposalData?.creationBlock ?? 0;
+        const { blockNumber: currentL2Block } = await (0, timing_2.getCurrentBlockInfo)(state.providers.l2);
+        const maxL2Block = Math.min(creationBlock + 7000000, currentL2Block);
+        votingEndBlock = await (0, timing_1.getFirstL2BlockForL1Block)(state.providers.l2, votingDeadlineL1, {
+            minL2Block: creationBlock,
+            maxL2Block,
         });
-    });
+    }
+    const result = await (0, proposal_queued_1.trackProposalQueued)(governorAddress, proposalId, state.providers.l2, proposalData?.creationBlock ?? 0, { votingEndBlock, chunkSize: state.chunkingConfig.l2ChunkSize });
+    let stage = result.stage;
+    // Enrich stage data with proposal info for READY state
+    if (stage.type === "PROPOSAL_QUEUED" && stage.status === "READY" && proposalData) {
+        stage = {
+            ...stage,
+            data: {
+                ...stage.data,
+                targets: proposalData.targets,
+                values: Array.from(proposalData.values).map((v) => v.toString()),
+                calldatas: proposalData.calldatas,
+                description: proposalData.description,
+            },
+        };
+    }
+    return {
+        state: await (0, state_1.addStage)(state, stage),
+        continue: result.operationId !== null && result.timelockAddress !== null,
+    };
 }
-// Timelock Stage (4)
-async function pipelineTrackL2Timelock(state) {
+// ============================================================================
+// Timelock Stage Trackers
+// ============================================================================
+async function trackL2TimelockStage(state) {
     const timelockAddress = (0, state_1.getTimelockAddress)(state);
     const operationId = (0, state_1.getOperationId)(state);
-    // timelockAddress and operationId are needed for both cached and fresh tracking
+    const firstCallScheduledData = (0, state_1.getFirstCallScheduledData)(state);
     if (!timelockAddress || !operationId)
-        return { state, executed: false };
-    // Check for completed cached stage first (zero-RPC resume path)
-    const cached = (0, state_1.getCompletedStage)(state, "L2_TIMELOCK");
-    if (cached) {
-        log("L2_TIMELOCK: using cached stage");
-        return { state: await (0, state_1.addStage)(state, cached), executed: cached.status === "COMPLETED" };
-    }
+        return { state, continue: false };
     // Fresh tracking requires callScheduledData
-    const firstCallScheduledData = (0, state_1.getFirstCallScheduledData)(state);
     if (!firstCallScheduledData) {
         log("L2_TIMELOCK: missing callScheduledData for fresh tracking");
-        return { state, executed: false };
+        return { state, continue: false };
     }
     log("L2_TIMELOCK: tracking");
-    return track(state, "L2_TIMELOCK", "executed", async () => {
-        const r = await (0, timelock_1.trackL2Timelock)(timelockAddress, operationId, state.providers.l2, (0, state_1.getQueueBlockNumber)(state) ?? 0, firstCallScheduledData, {
-            cachedExecutionTxHash: (0, state_1.getL2ExecutionTxHash)(state),
-            allStages: state.stages,
-            chunkSize: state.chunkingConfig.l2ChunkSize,
-        });
-        return { stage: r.stage, result: r.executionTxHash !== null };
+    const result = await (0, timelock_1.trackL2Timelock)(timelockAddress, operationId, state.providers.l2, (0, state_1.getQueueBlockNumber)(state) ?? 0, firstCallScheduledData, {
+        cachedExecutionTxHash: (0, state_1.getL2ExecutionTxHash)(state),
+        allStages: state.stages,
+        proposalType: (0, state_1.getProposalType)(state),
+        chunkSize: state.chunkingConfig.l2ChunkSize,
     });
+    return {
+        state: await (0, state_1.addStage)(state, result.stage),
+        continue: result.executionTxHash !== null,
+    };
 }
-// L2→L1 Message Stage (5) - Unified
 const L1_ROUNDTRIP_STAGES = ["L2_TO_L1_MESSAGE", "L1_TIMELOCK", "RETRYABLE_EXECUTED"];
-async function addSkippedL1Stages(state) {
-    let s = state;
-    for (const type of L1_ROUNDTRIP_STAGES)
-        s = await (0, state_1.addStage)(s, placeholder(type, "SKIPPED", "L2-only path"));
-    return s;
-}
-async function pipelineTrackL2ToL1Message(state) {
+async function trackL2ToL1MessageStage(state) {
     const l2ExecutionTxHash = (0, state_1.getL2ExecutionTxHash)(state);
     const addressForPath = (0, state_1.getGovernorAddress)(state) ?? (0, state_1.getTimelockAddress)(state);
     const needsL1 = addressForPath ? (0, utils_1.isConstitutional)(addressForPath) : true;
+    // L2-only path: skip all L1 stages
     if (!needsL1) {
         log("L2_TO_L1_MESSAGE: L2-only path, skipping L1 stages");
-        return { state: await addSkippedL1Stages(state), executed: false, needsL1: false };
+        const newState = await (0, stage_runner_1.addPlaceholders)(state, L1_ROUNDTRIP_STAGES, "SKIPPED", "L2-only path");
+        return { state: newState, continue: false };
     }
     if (!l2ExecutionTxHash)
-        return { state, executed: false, needsL1: true };
-    // Check completed cache
-    const cached = (0, state_1.getCompletedStage)(state, "L2_TO_L1_MESSAGE");
-    if (cached) {
-        log("L2_TO_L1_MESSAGE: using cached stage");
-        return { state: await (0, state_1.addStage)(state, cached), executed: true, needsL1: true };
-    }
+        return { state, continue: false };
     // Fast-path for pending (still in challenge period)
-    const pending = (0, state_1.getCachedStage)(state, "L2_TO_L1_MESSAGE");
+    const pending = (0, stage_runner_1.getCachedStage)(state, "L2_TO_L1_MESSAGE");
     if (pending?.type === "L2_TO_L1_MESSAGE" && pending.status === "PENDING") {
         const firstExec = pending.data.firstExecutableBlock;
         if (firstExec) {
@@ -200,112 +188,341 @@ async function pipelineTrackL2ToL1Message(state) {
                         delaySeconds: remainingSeconds,
                     },
                 };
-                return { state: await (0, state_1.addStage)(state, updated), executed: false, needsL1: true };
+                return { state: await (0, state_1.addStage)(state, updated), continue: false };
             }
         }
     }
     // Full tracking
     log("L2_TO_L1_MESSAGE: tracking");
-    const { state: newState, executed } = await track(state, "L2_TO_L1_MESSAGE", "executed", async () => {
-        const r = await (0, l2_to_l1_message_1.trackL2ToL1Message)(l2ExecutionTxHash, state.providers.l2, state.providers.l1, {
-            chunkSize: state.chunkingConfig.l1ChunkSize,
-        });
-        return { stage: r.stage, result: r.isExecuted };
-    });
-    return { state: newState, executed, needsL1: true };
+    const result = await (0, l2_to_l1_message_1.trackL2ToL1Message)(l2ExecutionTxHash, state.providers.l2, state.providers.l1, { chunkSize: state.chunkingConfig.l1ChunkSize });
+    return {
+        state: await (0, state_1.addStage)(state, result.stage),
+        continue: result.isExecuted,
+    };
 }
-// L1 Timelock Stage (6)
-async function pipelineTrackL1Timelock(state) {
-    return withCache(state, "L1_TIMELOCK", "executed", (c) => c.status === "COMPLETED", async () => {
-        log("L1_TIMELOCK: tracking");
-        return track(state, "L1_TIMELOCK", "executed", async () => {
-            const r = await (0, timelock_1.trackL1Timelock)(state.providers.l1, {
-                outboxExecutionTx: (0, state_1.getOutboxExecutionTx)(state),
-                fromBlock: (0, state_1.getFirstExecutableBlock)(state),
-                allStages: state.stages,
-                chunkSize: state.chunkingConfig.l1ChunkSize,
-            });
-            return { stage: r.stage, result: r.executionTxHash !== null };
-        });
+async function trackL1TimelockStage(state) {
+    log("L1_TIMELOCK: tracking");
+    const result = await (0, timelock_1.trackL1Timelock)(state.providers.l1, {
+        outboxExecutionTx: (0, state_1.getOutboxExecutionTx)(state),
+        fromBlock: (0, state_1.getFirstExecutableBlock)(state),
+        allStages: state.stages,
+        chunkSize: state.chunkingConfig.l1ChunkSize,
     });
+    return {
+        state: await (0, state_1.addStage)(state, result.stage),
+        continue: result.executionTxHash !== null,
+    };
 }
-// Retryable Stage (7)
-async function pipelineTrackRetryables(state) {
+async function trackRetryablesStage(state) {
     const l1ExecutionTxHash = (0, state_1.getL1ExecutionTxHash)(state);
     if (!l1ExecutionTxHash)
-        return { state, redeemed: false };
-    return withCache(state, "RETRYABLE_EXECUTED", "redeemed", (c) => c.status === "COMPLETED", async () => {
-        log("RETRYABLE_EXECUTED: tracking");
-        return track(state, "RETRYABLE_EXECUTED", "redeemed", async () => {
-            const r = await (0, retryables_1.trackRetryables)(l1ExecutionTxHash, state.providers.l1, {
-                l2Provider: state.providers.l2,
-                novaProvider: state.providers.nova,
-            });
-            return { stage: r.stage, result: r.stage.status === "COMPLETED" };
-        });
+        return { state, continue: false };
+    log("RETRYABLE_EXECUTED: tracking");
+    const result = await (0, retryables_1.trackRetryables)(l1ExecutionTxHash, state.providers.l1, {
+        l2Provider: state.providers.l2,
+        novaProvider: state.providers.nova,
     });
+    return {
+        state: await (0, state_1.addStage)(state, result.stage),
+        continue: result.stage.status === "COMPLETED",
+    };
+}
+// ============================================================================
+// Election Stage Trackers
+// ============================================================================
+async function findElectionExecuteTxHash(proposalId, governorAddress, provider, l2ChunkSize = 100000) {
+    const governor = (0, contracts_1.getNomineeGovernor)(governorAddress, provider);
+    const topic = abis_1.proposalExecutedInterface.getEventTopic("ProposalExecuted");
+    const snapshotL1 = await (0, rpc_utils_1.queryWithRetry)(() => governor.proposalSnapshot(proposalId));
+    const snapshotL2 = await (0, timing_1.getFirstL2BlockForL1Block)(provider, snapshotL1.toNumber());
+    if (!snapshotL2)
+        return null;
+    const currentBlock = await (0, rpc_utils_1.queryWithRetry)(() => provider.getBlockNumber());
+    const matchingLog = await (0, log_search_1.findLog)(provider, { address: governorAddress, topics: [topic], fromBlock: snapshotL2, toBlock: currentBlock }, (eventLog) => {
+        try {
+            const parsed = abis_1.proposalExecutedInterface.parseLog(eventLog);
+            return parsed.args.proposalId.toString() === proposalId;
+        }
+        catch {
+            return false;
+        }
+    }, { chunkSize: l2ChunkSize });
+    return matchingLog
+        ? { txHash: matchingLog.transactionHash, blockNumber: matchingLog.blockNumber }
+        : null;
 }
-// Full Pipelines
-async function addPlaceholders(state, types, reason) {
-    let s = state;
-    for (const type of types)
-        s = await (0, state_1.addStage)(s, placeholder(type, "NOT_STARTED", reason));
-    return s;
+async function trackCreateElectionStage(state) {
+    const electionIndex = (0, state_1.getElectionIndex)(state);
+    if (electionIndex === undefined)
+        return { state, continue: false };
+    log("CREATE_ELECTION: tracking election %d", electionIndex);
+    const nomineeGovernorAddress = constants_1.ADDRESSES.ELECTION_NOMINEE_GOVERNOR;
+    const nomineeGovernor = (0, contracts_1.getNomineeGovernor)(nomineeGovernorAddress, state.providers.l2);
+    const cohort = (await (0, rpc_utils_1.queryWithRetry)(() => nomineeGovernor.electionIndexToCohort(electionIndex)));
+    const nomineeProposalId = await (0, proposal_ids_1.getElectionProposalId)(electionIndex, state.providers.l2, nomineeGovernorAddress);
+    if (!nomineeProposalId) {
+        const notStartedStage = new builder_1.StageBuilder("CREATE_ELECTION", "arb1")
+            .status("NOT_STARTED")
+            .data({ electionIndex, cohort, startTimestamp: 0, reason: "Election not yet created" })
+            .build();
+        return { state: await (0, state_1.addStage)(state, notStartedStage), continue: false };
+    }
+    const stageBuilder = new builder_1.StageBuilder("CREATE_ELECTION", "arb1")
+        .status("COMPLETED")
+        .data({ electionIndex, cohort, startTimestamp: 0, nomineeProposalId });
+    // Find creation tx hash for the election proposal
+    try {
+        const creationEvent = await (0, governor_discovery_1.findProposalCreatedEvent)(nomineeGovernorAddress, nomineeProposalId, state.providers.l2);
+        if (creationEvent) {
+            stageBuilder.tx(creationEvent.creationTxHash, creationEvent.creationBlock, "arb1", 42161);
+        }
+    }
+    catch {
+        // Creation tx discovery failed silently - stage still valid
+    }
+    return { state: await (0, state_1.addStage)(state, stageBuilder.build()), continue: true };
 }
-const RETRYABLE_STAGES = ["RETRYABLE_EXECUTED"];
+async function trackNomineeElectionStage(state) {
+    const ctx = getElectionContext(state);
+    if (!ctx)
+        return { state, continue: false };
+    log("NOMINEE_ELECTION: tracking");
+    const nomineeGovernorAddress = constants_1.ADDRESSES.ELECTION_NOMINEE_GOVERNOR;
+    const nomineeResults = await (0, multicall_1.multicall)(state.providers.l2, [
+        (0, multicall_1.buildCallInput)(nomineeGovernorAddress, abis_1.nomineeElectionGovernorInterface, "state", [
+            ctx.nomineeProposalId,
+        ]),
+        (0, multicall_1.buildCallInput)(nomineeGovernorAddress, abis_1.nomineeElectionGovernorInterface, "compliantNomineeCount", [ctx.nomineeProposalId]),
+    ]);
+    const nomineeState = nomineeResults[0];
+    const nomineeProposalState = (0, constants_1.proposalStateToString)(nomineeState);
+    const compliantNomineeCount = (nomineeResults[1] ?? ethers_1.BigNumber.from(0)).toNumber();
+    const { status, complete } = proposalStateToStageStatus(nomineeProposalState);
+    const stageBuilder = new builder_1.StageBuilder("NOMINEE_ELECTION", "arb1").status(status).data({
+        nomineeProposalId: ctx.nomineeProposalId,
+        proposalState: nomineeProposalState,
+        contenderCount: 0,
+        compliantNomineeCount,
+        targetNomineeCount: constants_1.TIMING.SECURITY_COUNCIL_TARGET_NOMINEES,
+    });
+    return { state: await (0, state_1.addStage)(state, stageBuilder.build()), continue: complete };
+}
+async function trackNomineeVettingStage(state) {
+    const ctx = getElectionContext(state);
+    if (!ctx)
+        return { state, continue: false };
+    log("NOMINEE_VETTING: tracking");
+    const nomineeGovernorAddress = constants_1.ADDRESSES.ELECTION_NOMINEE_GOVERNOR;
+    const memberGovernorAddress = constants_1.ADDRESSES.ELECTION_MEMBER_GOVERNOR;
+    const memberGovernor = (0, contracts_1.getMemberGovernor)(memberGovernorAddress, state.providers.l2);
+    const [vettingResults, currentL1Block] = await Promise.all([
+        (0, multicall_1.multicall)(state.providers.l2, [
+            (0, multicall_1.buildCallInput)(nomineeGovernorAddress, abis_1.nomineeElectionGovernorInterface, "proposalVettingDeadline", [ctx.nomineeProposalId]),
+            (0, multicall_1.buildCallInput)(nomineeGovernorAddress, abis_1.nomineeElectionGovernorInterface, "compliantNomineeCount", [ctx.nomineeProposalId]),
+            (0, multicall_1.buildCallInput)(nomineeGovernorAddress, abis_1.nomineeElectionGovernorInterface, "state", [
+                ctx.nomineeProposalId,
+            ]),
+        ]),
+        (0, timing_1.getL1BlockNumberFromL2)(state.providers.l2),
+    ]);
+    const vettingDeadlineBN = vettingResults[0] ?? ethers_1.BigNumber.from(0);
+    const vettingDeadline = vettingDeadlineBN.toNumber();
+    const compliantNomineeCount = (vettingResults[1] ?? ethers_1.BigNumber.from(0)).toNumber();
+    const nomineeState = vettingResults[2];
+    const nomineeProposalState = (0, constants_1.proposalStateToString)(nomineeState);
+    const isInVettingPeriod = nomineeProposalState === "Succeeded" && currentL1Block.lte(vettingDeadlineBN);
+    // Check if member proposal exists
+    let memberProposalId = null;
+    const computedMemberProposalId = await (0, proposal_ids_1.computeElectionProposalId)(ctx.electionIndex, memberGovernor);
+    try {
+        await (0, rpc_utils_1.queryWithRetry)(() => memberGovernor.state(computedMemberProposalId));
+        memberProposalId = computedMemberProposalId;
+    }
+    catch {
+        // Member election not yet created
+    }
+    const stageBuilder = new builder_1.StageBuilder("NOMINEE_VETTING", "arb1").data({
+        nomineeProposalId: ctx.nomineeProposalId,
+        vettingDeadline,
+        currentL1Block: currentL1Block.toNumber(),
+        compliantNomineeCount,
+        memberProposalId: memberProposalId ?? undefined,
+    });
+    const canProceedToMemberPhase = nomineeProposalState === "Succeeded" &&
+        !isInVettingPeriod &&
+        compliantNomineeCount >= constants_1.TIMING.SECURITY_COUNCIL_TARGET_NOMINEES &&
+        !memberProposalId;
+    let complete = false;
+    if (nomineeProposalState === "Executed" || memberProposalId) {
+        stageBuilder.status("COMPLETED");
+        complete = true;
+        try {
+            const executeEvent = await findElectionExecuteTxHash(ctx.nomineeProposalId, nomineeGovernorAddress, state.providers.l2, state.chunkingConfig.l2ChunkSize);
+            if (executeEvent) {
+                stageBuilder.tx(executeEvent.txHash, executeEvent.blockNumber, "arb1", 42161);
+            }
+        }
+        catch {
+            // TX hash discovery failed
+        }
+    }
+    else if (canProceedToMemberPhase) {
+        stageBuilder.status("READY").executable(true);
+    }
+    else if (isInVettingPeriod) {
+        stageBuilder.status("PENDING");
+    }
+    else if (compliantNomineeCount < constants_1.TIMING.SECURITY_COUNCIL_TARGET_NOMINEES) {
+        stageBuilder.status("FAILED");
+    }
+    return {
+        state: await (0, state_1.addStage)(state, stageBuilder.build()),
+        continue: complete && memberProposalId !== null,
+    };
+}
+async function trackMemberElectionStage(state) {
+    const electionIndex = (0, state_1.getElectionIndex)(state);
+    const memberProposalId = (0, state_1.getMemberProposalId)(state);
+    if (electionIndex === undefined || !memberProposalId)
+        return { state, continue: false };
+    log("MEMBER_ELECTION: tracking");
+    const memberGovernorAddress = constants_1.ADDRESSES.ELECTION_MEMBER_GOVERNOR;
+    const memberGovernor = (0, contracts_1.getMemberGovernor)(memberGovernorAddress, state.providers.l2);
+    const memberState = await (0, rpc_utils_1.queryWithRetry)(() => memberGovernor.state(memberProposalId));
+    const memberProposalState = (0, constants_1.proposalStateToString)(memberState);
+    const stageBuilder = new builder_1.StageBuilder("MEMBER_ELECTION", "arb1").data({
+        memberProposalId,
+        proposalState: memberProposalState,
+        winnersCount: 0,
+    });
+    let executed = false;
+    let newState = state;
+    if (memberProposalState === "Active" || memberProposalState === "Pending") {
+        stageBuilder.status("PENDING");
+    }
+    else if (memberProposalState === "Succeeded") {
+        stageBuilder.status("READY").executable(true);
+    }
+    else if (memberProposalState === "Executed") {
+        stageBuilder.status("COMPLETED");
+        executed = true;
+        try {
+            const executeEvent = await findElectionExecuteTxHash(memberProposalId, memberGovernorAddress, state.providers.l2, state.chunkingConfig.l2ChunkSize);
+            if (executeEvent) {
+                stageBuilder.tx(executeEvent.txHash, executeEvent.blockNumber, "arb1", 42161, {
+                    description: "executed",
+                });
+                // Find CallScheduled events and inject into state for timelock pipeline
+                const callScheduledEvents = await (0, timelock_discovery_1.findCallScheduledByTxHash)(executeEvent.txHash, state.providers.l2);
+                if (callScheduledEvents?.length) {
+                    const firstEvent = callScheduledEvents[0];
+                    stageBuilder.data({
+                        memberProposalId,
+                        proposalState: memberProposalState,
+                        winnersCount: 0,
+                        operationId: firstEvent.operationId,
+                        timelockAddress: firstEvent.timelockAddress,
+                    });
+                    // Inject callScheduledData for timelock pipeline
+                    newState = { ...state, callScheduledData: callScheduledEvents };
+                }
+            }
+        }
+        catch {
+            // TX hash discovery failed
+        }
+    }
+    else if (memberProposalState === "Defeated" || memberProposalState === "Canceled") {
+        stageBuilder.status("FAILED");
+    }
+    return {
+        state: await (0, state_1.addStage)(newState, stageBuilder.build()),
+        continue: executed,
+    };
+}
+// ============================================================================
+// Stage Configurations
+// ============================================================================
+const GOVERNOR_STAGES = [
+    { type: "PROPOSAL_CREATED", track: trackProposalCreatedStage },
+    { type: "VOTING_ACTIVE", track: trackVotingStage_ },
+    { type: "PROPOSAL_QUEUED", track: trackProposalQueuedStage },
+];
+const TIMELOCK_STAGES = [
+    {
+        type: "L2_TIMELOCK",
+        track: trackL2TimelockStage,
+        // Custom cache: also check if we have callScheduledData
+        checkCache: async (state) => {
+            const timelockAddress = (0, state_1.getTimelockAddress)(state);
+            const operationId = (0, state_1.getOperationId)(state);
+            if (!timelockAddress || !operationId)
+                return { state, continue: false };
+            const cached = (0, stage_runner_1.getCachedStage)(state, "L2_TIMELOCK");
+            if (cached && (0, utils_1.isStageSuccess)(cached.status)) {
+                log("L2_TIMELOCK: cached");
+                return { state: await (0, state_1.addStage)(state, cached), continue: true };
+            }
+            return undefined; // Fall through to track
+        },
+    },
+    {
+        type: "L2_TO_L1_MESSAGE",
+        track: trackL2ToL1MessageStage,
+        // Custom cache: handle pending fast-path in track function
+        checkCache: async (state) => {
+            const cached = (0, stage_runner_1.getCachedStage)(state, "L2_TO_L1_MESSAGE");
+            if (cached && (0, utils_1.isStageSuccess)(cached.status)) {
+                log("L2_TO_L1_MESSAGE: cached");
+                return { state: await (0, state_1.addStage)(state, cached), continue: true };
+            }
+            return undefined;
+        },
+    },
+    { type: "L1_TIMELOCK", track: trackL1TimelockStage },
+    { type: "RETRYABLE_EXECUTED", track: trackRetryablesStage },
+];
+const ELECTION_STAGES = [
+    { type: "CREATE_ELECTION", track: trackCreateElectionStage },
+    { type: "NOMINEE_ELECTION", track: trackNomineeElectionStage },
+    { type: "NOMINEE_VETTING", track: trackNomineeVettingStage },
+    { type: "MEMBER_ELECTION", track: trackMemberElectionStage },
+];
+// ============================================================================
+// Pipeline Exports
+// ============================================================================
 /**
- * Track full governor proposal pipeline.
- * Returns final state after tracking all stages.
+ * Track governor proposal pipeline (stages 1-7).
  */
 async function trackGovernorPipeline(state) {
-    // Stage 1: Proposal Created
-    const { state: state1, found } = await pipelineTrackProposalCreated(state);
-    if (!found) {
-        logTracker("proposal not found, stopping");
-        return state1;
-    }
-    // Stage 2: Voting
-    const { state: state2, complete: votingComplete } = await pipelineTrackVoting(state1);
-    if (!votingComplete) {
-        logTracker("voting not complete, stopping");
-        return state2;
+    logTracker("running governor pipeline");
+    state = await (0, stage_runner_1.runPipeline)(state, GOVERNOR_STAGES);
+    // Continue with timelock if proposal was queued
+    const queued = state.stages.find((s) => s.type === "PROPOSAL_QUEUED");
+    if (queued?.status === "COMPLETED") {
+        return (0, stage_runner_1.runPipeline)(state, TIMELOCK_STAGES);
     }
-    // Stage 3: Proposal Queued
-    const { state: state3, queued } = await pipelineTrackProposalQueued(state2);
-    if (!queued) {
-        logTracker("proposal not queued, stopping");
-        return state3;
-    }
-    // Continue with timelock pipeline
-    return trackTimelockPipeline(state3);
+    return state;
 }
 /**
  * Track timelock pipeline (stages 4-7).
- * Used by governor pipeline and direct timelock tracking.
+ * Used by governor pipeline, election pipeline, and direct timelock tracking.
  */
 async function trackTimelockPipeline(state) {
-    // Stage 4: L2 Timelock (unified)
-    const { state: state1, executed: l2Executed } = await pipelineTrackL2Timelock(state);
-    if (!l2Executed) {
-        logTracker("L2 timelock not executed, stopping");
-        return addPlaceholders(state1, L1_ROUNDTRIP_STAGES, "L2 timelock not executed");
-    }
-    // Stage 5: L2→L1 Message (unified)
-    const { state: state2, executed: msgExecuted, needsL1, } = await pipelineTrackL2ToL1Message(state1);
-    if (!needsL1)
-        return state2; // L2-only path, already added SKIPPED stages
-    if (!msgExecuted) {
-        logTracker("L2→L1 message not executed, stopping");
-        return addPlaceholders(state2, L1_ROUNDTRIP_STAGES.slice(1), "Waiting for L2→L1 message");
-    }
-    // Stage 6: L1 Timelock (unified)
-    const { state: state3, executed: l1Executed } = await pipelineTrackL1Timelock(state2);
-    if (!l1Executed) {
-        logTracker("L1 timelock not executed, stopping");
-        return addPlaceholders(state3, RETRYABLE_STAGES, "L1 timelock not executed");
+    logTracker("running timelock pipeline");
+    return (0, stage_runner_1.runPipeline)(state, TIMELOCK_STAGES);
+}
+/**
+ * Track election pipeline (stages 1-8).
+ */
+async function trackElectionPipeline(state) {
+    logTracker("running election pipeline");
+    state = await (0, stage_runner_1.runPipeline)(state, ELECTION_STAGES);
+    // Continue with timelock if member election was executed
+    const memberStage = state.stages.find((s) => s.type === "MEMBER_ELECTION");
+    if (memberStage?.status === "COMPLETED") {
+        return (0, stage_runner_1.runPipeline)(state, TIMELOCK_STAGES);
     }
-    // Stage 7: Retryables
-    const { state: finalState } = await pipelineTrackRetryables(state3);
-    return finalState;
+    return state;
 }
 //# sourceMappingURL=pipeline.js.map