@gzeoneth/gov-tracker 0.2.1-beta.b2eeb41 → 0.2.1-beta.c266765

package/dist/election.js

@@ -13,8 +13,19 @@ exports.prepareElectionCreation = prepareElectionCreation;
 exports.hasVettingPeriod = hasVettingPeriod;
 exports.trackElectionProposal = trackElectionProposal;
 exports.getElectionProposalId = getElectionProposalId;
+exports.getMemberElectionProposalId = getMemberElectionProposalId;
 exports.getElectionProposalParams = getElectionProposalParams;
 exports.prepareMemberElectionTrigger = prepareMemberElectionTrigger;
+exports.getMemberElectionProposalParams = getMemberElectionProposalParams;
+exports.prepareMemberElectionExecution = prepareMemberElectionExecution;
+exports.getElectionIndexForProposalId = getElectionIndexForProposalId;
+exports.trackAllElections = trackAllElections;
+exports.trackIncompleteElections = trackIncompleteElections;
+exports.getContenders = getContenders;
+exports.getNomineesWithVotes = getNomineesWithVotes;
+exports.getExcludedNominees = getExcludedNominees;
+exports.getNomineeElectionDetails = getNomineeElectionDetails;
+exports.getMemberElectionDetails = getMemberElectionDetails;
 const ethers_1 = require("ethers");
 const constants_1 = require("./constants");
 const rpc_utils_1 = require("./utils/rpc-utils");
@@ -32,6 +43,19 @@ function getNomineeGovernor(address = constants_1.ADDRESSES.ELECTION_NOMINEE_GOV
 function getMemberGovernor(address = constants_1.ADDRESSES.ELECTION_MEMBER_GOVERNOR, provider) {
     return new ethers_1.ethers.Contract(address, abis_1.MEMBER_ELECTION_GOVERNOR_ABI, provider);
 }
+/** Get block range for log queries based on proposal snapshot */
+async function getLogQueryBlockRange(governor, proposalId, provider, offsetFromSnapshot = 1000, fallbackRange = 100000) {
+    const toBlock = await provider.getBlockNumber();
+    let fromBlock;
+    try {
+        const snapshot = await governor.proposalSnapshot(proposalId);
+        fromBlock = Math.max(0, snapshot.toNumber() - offsetFromSnapshot);
+    }
+    catch {
+        fromBlock = Math.max(0, toBlock - fallbackRange);
+    }
+    return { fromBlock, toBlock };
+}
 // Core Functions
 /**
  * Check the status of the Security Council election
@@ -168,26 +192,47 @@ function formatDuration(seconds) {
         parts.push(`${secs}s`);
     return parts.join(" ") || "0s";
 }
-/**
- * Convert numeric proposal state to string
- */
+const PROPOSAL_STATES = [
+    "Pending",
+    "Active",
+    "Canceled",
+    "Defeated",
+    "Succeeded",
+    "Queued",
+    "Expired",
+    "Executed",
+];
 function stateToString(state) {
-    const states = [
-        "Pending",
-        "Active",
-        "Canceled",
-        "Defeated",
-        "Succeeded",
-        "Queued",
-        "Expired",
-        "Executed",
-    ];
-    const result = states[state];
+    const result = PROPOSAL_STATES[state];
     if (!result) {
         throw new Error(`Unknown proposal state number: ${state}`);
     }
     return result;
 }
+function determineElectionPhase(nomineeProposalState, memberProposalId, memberProposalState, isInVettingPeriod) {
+    if (memberProposalState === "Executed") {
+        return "COMPLETED";
+    }
+    if (memberProposalId) {
+        if (memberProposalState === "Succeeded" || memberProposalState === "Queued") {
+            return "PENDING_EXECUTION";
+        }
+        return "MEMBER_ELECTION";
+    }
+    if (nomineeProposalState === "Executed") {
+        return "PENDING_EXECUTION";
+    }
+    if (isInVettingPeriod) {
+        return "VETTING_PERIOD";
+    }
+    if (nomineeProposalState === "Active" || nomineeProposalState === "Pending") {
+        return "NOMINEE_SELECTION";
+    }
+    if (nomineeProposalState === "Succeeded") {
+        return "PENDING_EXECUTION";
+    }
+    return "NOT_STARTED";
+}
 // Election Proposal Tracking
 /**
  * Track the status of a Security Council election by its index
@@ -239,6 +284,7 @@ async function trackElectionProposal(electionIndex, l2Provider, _l1Provider, opt
             vettingDeadline: null,
             isInVettingPeriod: false,
             canProceedToMemberPhase: false,
+            canExecuteMember: false,
         };
     }
     // Get nominee proposal state
@@ -260,51 +306,27 @@ async function trackElectionProposal(electionIndex, l2Provider, _l1Provider, opt
     catch {
         // May fail if no nominees yet
     }
-    // Check for member proposal
+    // Check for member proposal using computed proposal ID (same scheme as nominee governor)
     let memberProposalId = null;
     let memberProposalState = null;
+    // Compute member proposal ID using getProposeArgs + hashProposal (same as nominee)
+    const computedMemberProposalId = await computeElectionProposalId(electionIndex, memberGovernor);
     try {
-        const memberPropId = await (0, rpc_utils_1.queryWithRetry)(() => memberGovernor.electionIndexToProposalId(electionIndex));
-        if (!memberPropId.isZero()) {
-            memberProposalId = memberPropId.toString();
-            const memberState = await (0, rpc_utils_1.queryWithRetry)(() => memberGovernor.state(memberProposalId));
-            memberProposalState = stateToString(memberState);
-        }
+        // Don't use queryWithRetry - we expect this to revert for non-existent proposals
+        const memberState = await memberGovernor.state(computedMemberProposalId);
+        // If we get here without reverting, the proposal exists
+        memberProposalId = computedMemberProposalId;
+        memberProposalState = stateToString(memberState);
     }
     catch {
-        // Member election not yet created
-    }
-    // Determine phase
-    let phase;
-    if (memberProposalState === "Executed") {
-        phase = "COMPLETED";
-    }
-    else if (memberProposalId) {
-        if (memberProposalState === "Succeeded" || memberProposalState === "Queued") {
-            phase = "PENDING_EXECUTION";
-        }
-        else {
-            phase = "MEMBER_ELECTION";
-        }
-    }
-    else if (isInVettingPeriod) {
-        phase = "VETTING_PERIOD";
-    }
-    else if (nomineeProposalState === "Active" || nomineeProposalState === "Pending") {
-        phase = "NOMINEE_SELECTION";
-    }
-    else if (nomineeProposalState === "Succeeded") {
-        // Past vetting, waiting for member election creation
-        phase = "PENDING_EXECUTION";
+        // Member election not yet created (state() reverts for non-existent proposals)
     }
-    else {
-        phase = "NOT_STARTED";
-    }
-    // Can proceed if vetting ended and has enough compliant nominees
+    const phase = determineElectionPhase(nomineeProposalState, memberProposalId, memberProposalState, isInVettingPeriod);
     const canProceedToMemberPhase = nomineeProposalState === "Succeeded" &&
         !isInVettingPeriod &&
         compliantNomineeCount >= constants_1.TIMING.SECURITY_COUNCIL_TARGET_NOMINEES &&
         !memberProposalId;
+    const canExecuteMember = memberProposalState === "Succeeded";
     return {
         electionIndex,
         phase,
@@ -318,21 +340,20 @@ async function trackElectionProposal(electionIndex, l2Provider, _l1Provider, opt
         vettingDeadline,
         isInVettingPeriod,
         canProceedToMemberPhase,
+        canExecuteMember,
     };
 }
 /**
- * Get the proposal ID for a given election index
+ * Get the proposal ID for a given election index from any election governor
  *
  * Uses getProposeArgs to get proposal parameters and hashProposal to calculate the proposal ID.
+ * Both nominee and member governors use the same proposal ID scheme via ElectionGovernor base.
  *
  * @param electionIndex - Election index
- * @param provider - L2 provider
- * @param nomineeGovernorAddress - Optional governor address override
- * @returns Proposal ID or null if election not yet created
+ * @param governor - Election governor contract instance
+ * @returns Proposal ID as string
  */
-async function getElectionProposalId(electionIndex, provider, nomineeGovernorAddress = constants_1.ADDRESSES.ELECTION_NOMINEE_GOVERNOR) {
-    const governor = getNomineeGovernor(nomineeGovernorAddress, provider);
-    // Get proposal arguments for this election
+async function computeElectionProposalId(electionIndex, governor) {
     // getProposeArgs returns: [targets, values, calldatas, description]
     const proposeArgs = (await (0, rpc_utils_1.queryWithRetry)(() => governor.getProposeArgs(electionIndex)));
     const [targets, values, calldatas, description] = proposeArgs;
@@ -340,55 +361,71 @@ async function getElectionProposalId(electionIndex, provider, nomineeGovernorAdd
     const descriptionHash = (0, salt_computation_1.saltFromDescription)(description);
     // Calculate proposal ID using hashProposal
     const proposalId = await (0, rpc_utils_1.queryWithRetry)(() => governor.hashProposal(targets, values, calldatas, descriptionHash));
-    // Convert bytes32 to decimal string
     return ethers_1.BigNumber.from(proposalId).toString();
 }
-// Member Election Trigger Functions
 /**
- * Get the proposal parameters for an election proposal
+ * Get the proposal ID for a given election index
  *
- * Searches for the ProposalCreated event to extract targets, values, calldatas,
- * and description needed for execute() call.
+ * Uses getProposeArgs to get proposal parameters and hashProposal to calculate the proposal ID.
+ * Verifies the proposal exists by checking state() - returns null if proposal doesn't exist.
  *
  * @param electionIndex - Election index
  * @param provider - L2 provider
  * @param nomineeGovernorAddress - Optional governor address override
- * @returns Election proposal params or null if not found
+ * @returns Proposal ID or null if election not yet created
  */
-async function getElectionProposalParams(electionIndex, provider, nomineeGovernorAddress = constants_1.ADDRESSES.ELECTION_NOMINEE_GOVERNOR) {
-    log("getElectionProposalParams for index %d", electionIndex);
-    const proposalId = await getElectionProposalId(electionIndex, provider, nomineeGovernorAddress);
-    if (!proposalId) {
-        log("No proposal ID found for election %d", electionIndex);
+async function getElectionProposalId(electionIndex, provider, nomineeGovernorAddress = constants_1.ADDRESSES.ELECTION_NOMINEE_GOVERNOR) {
+    const governor = getNomineeGovernor(nomineeGovernorAddress, provider);
+    const proposalId = await computeElectionProposalId(electionIndex, governor);
+    // Verify the proposal exists by checking state() - reverts for non-existent proposals
+    try {
+        await governor.state(proposalId);
+        return proposalId;
+    }
+    catch {
+        // Proposal doesn't exist (state() reverts for unknown proposal IDs)
         return null;
     }
-    // Search for ProposalCreated event
+}
+/**
+ * Get the member election proposal ID for a given election index
+ *
+ * @param electionIndex - Election index
+ * @param provider - L2 provider
+ * @param memberGovernorAddress - Optional governor address override
+ * @returns Member proposal ID as string
+ */
+async function getMemberElectionProposalId(electionIndex, provider, memberGovernorAddress = constants_1.ADDRESSES.ELECTION_MEMBER_GOVERNOR) {
+    const governor = getMemberGovernor(memberGovernorAddress, provider);
+    return computeElectionProposalId(electionIndex, governor);
+}
+// Member Election Trigger Functions
+/**
+ * Search for ProposalCreated event and extract proposal parameters
+ *
+ * Common helper used by both nominee and member election param lookups.
+ */
+async function findProposalCreatedParams(proposalId, governorAddress, governor, provider) {
     const topic = abis_1.proposalCreatedInterface.getEventTopic("ProposalCreated");
-    // Get proposal snapshot to narrow search range
-    const governor = getNomineeGovernor(nomineeGovernorAddress, provider);
     let startBlock;
     try {
         const snapshot = await governor.proposalSnapshot(proposalId);
-        // Search from ~1000 blocks before snapshot (proposal is created before snapshot)
         startBlock = Math.max(0, snapshot.toNumber() - 1000);
     }
     catch {
-        // Fallback: search last 10000 blocks
         const currentBlock = await provider.getBlockNumber();
         startBlock = Math.max(0, currentBlock - 10000);
     }
     const currentBlock = await provider.getBlockNumber();
     const logs = await (0, rpc_utils_1.queryWithRetry)(() => provider.getLogs({
-        address: nomineeGovernorAddress,
+        address: governorAddress,
         topics: [topic],
         fromBlock: startBlock,
         toBlock: currentBlock,
     }));
-    // Find the log matching our proposal ID
     for (const eventLog of logs) {
         try {
             const parsed = abis_1.proposalCreatedInterface.parseLog(eventLog);
-            // Cast through unknown required due to ethers' Result type structure
             const args = parsed.args;
             if (args.proposalId.toString() === proposalId) {
                 log("Found ProposalCreated event for proposal %s", proposalId);
@@ -408,6 +445,46 @@ async function getElectionProposalParams(electionIndex, provider, nomineeGoverno
     log("ProposalCreated event not found for proposal %s", proposalId);
     return null;
 }
+/**
+ * Build a prepared execute() transaction from proposal params
+ */
+function buildExecuteTransaction(params, governorAddress, description) {
+    const calldata = abis_1.governorInterface.encodeFunctionData("execute", [
+        params.targets,
+        params.values,
+        params.calldatas,
+        params.descriptionHash,
+    ]);
+    return {
+        to: governorAddress,
+        data: calldata,
+        value: "0",
+        chain: "arb1",
+        chainId: 42161,
+        description,
+    };
+}
+/**
+ * Get the proposal parameters for an election proposal
+ *
+ * Searches for the ProposalCreated event to extract targets, values, calldatas,
+ * and description needed for execute() call.
+ *
+ * @param electionIndex - Election index
+ * @param provider - L2 provider
+ * @param nomineeGovernorAddress - Optional governor address override
+ * @returns Election proposal params or null if not found
+ */
+async function getElectionProposalParams(electionIndex, provider, nomineeGovernorAddress = constants_1.ADDRESSES.ELECTION_NOMINEE_GOVERNOR) {
+    log("getElectionProposalParams for index %d", electionIndex);
+    const proposalId = await getElectionProposalId(electionIndex, provider, nomineeGovernorAddress);
+    if (!proposalId) {
+        log("No proposal ID found for election %d", electionIndex);
+        return null;
+    }
+    const governor = getNomineeGovernor(nomineeGovernorAddress, provider);
+    return findProposalCreatedParams(proposalId, nomineeGovernorAddress, governor, provider);
+}
 /**
  * Prepare a transaction to trigger member election creation
  *
@@ -442,26 +519,366 @@ async function prepareMemberElectionTrigger(electionStatus, provider, nomineeGov
         log("Cannot proceed to member phase - not ready");
         return null;
     }
-    // Get proposal params
     const params = await getElectionProposalParams(electionStatus.electionIndex, provider, nomineeGovernorAddress);
     if (!params) {
         log("Could not find proposal params for election %d", electionStatus.electionIndex);
         return null;
     }
-    // Build execute calldata using governor interface
-    const calldata = abis_1.governorInterface.encodeFunctionData("execute", [
-        params.targets,
-        params.values,
-        params.calldatas,
-        params.descriptionHash,
+    return buildExecuteTransaction(params, nomineeGovernorAddress, `execute() on NomineeElectionGovernor to trigger member election #${electionStatus.electionIndex}`);
+}
+/**
+ * Get proposal parameters for a member election
+ *
+ * Retrieves the targets, values, calldatas, and description hash needed to
+ * execute a member election proposal.
+ *
+ * @param electionIndex - Election index
+ * @param provider - L2 provider
+ * @param memberGovernorAddress - Optional governor address override
+ * @returns Proposal parameters or null if not found
+ */
+async function getMemberElectionProposalParams(electionIndex, provider, memberGovernorAddress = constants_1.ADDRESSES.ELECTION_MEMBER_GOVERNOR) {
+    log("getMemberElectionProposalParams for index %d", electionIndex);
+    const memberGovernor = getMemberGovernor(memberGovernorAddress, provider);
+    // Compute proposal ID using getProposeArgs + hashProposal
+    const memberProposalId = await computeElectionProposalId(electionIndex, memberGovernor);
+    // Verify proposal exists by checking state
+    try {
+        await (0, rpc_utils_1.queryWithRetry)(() => memberGovernor.state(memberProposalId));
+    }
+    catch {
+        log("No member proposal found for election %d", electionIndex);
+        return null;
+    }
+    return findProposalCreatedParams(memberProposalId, memberGovernorAddress, memberGovernor, provider);
+}
+/**
+ * Prepare a transaction to execute member election result
+ *
+ * After member voting succeeds, calling execute() on the MemberElectionGovernor
+ * installs the new Security Council members.
+ *
+ * @param electionStatus - Status from trackElectionProposal (must have canExecuteMember=true)
+ * @param provider - L2 provider
+ * @param memberGovernorAddress - Optional governor address override
+ * @returns Prepared transaction or null if not ready
+ *
+ * @example
+ * ```typescript
+ * const status = await trackElectionProposal(5, l2Provider, l1Provider);
+ *
+ * if (status.canExecuteMember) {
+ *   const prepared = await prepareMemberElectionExecution(status, l2Provider);
+ *   if (prepared) {
+ *     const tx = await signer.sendTransaction({
+ *       to: prepared.to,
+ *       data: prepared.data,
+ *     });
+ *     await tx.wait();
+ *     console.log("New Security Council members installed!");
+ *   }
+ * }
+ * ```
+ */
+async function prepareMemberElectionExecution(electionStatus, provider, memberGovernorAddress = constants_1.ADDRESSES.ELECTION_MEMBER_GOVERNOR) {
+    log("prepareMemberElectionExecution for election %d", electionStatus.electionIndex);
+    if (!electionStatus.canExecuteMember) {
+        log("Cannot execute member election - not ready");
+        return null;
+    }
+    const params = await getMemberElectionProposalParams(electionStatus.electionIndex, provider, memberGovernorAddress);
+    if (!params) {
+        log("Could not find proposal params for member election %d", electionStatus.electionIndex);
+        return null;
+    }
+    return buildExecuteTransaction(params, memberGovernorAddress, `execute() on MemberElectionGovernor to install new Security Council members for election #${electionStatus.electionIndex}`);
+}
+// Election Discovery & Batch Tracking
+/**
+ * Find the election index for a given proposal ID
+ *
+ * Searches through elections to find which one contains the given proposal ID
+ * (either as nominee or member proposal).
+ *
+ * @param proposalId - The proposal ID to find
+ * @param l2Provider - L2 provider
+ * @param l1Provider - L1 provider (needed for trackElectionProposal)
+ * @returns Election index or null if not found
+ */
+async function getElectionIndexForProposalId(proposalId, l2Provider, l1Provider) {
+    log("getElectionIndexForProposalId: searching for proposal %s", proposalId);
+    // Get current election count
+    const status = await checkElectionStatus(l2Provider, l1Provider);
+    const electionCount = status.electionCount;
+    // Search through elections (most recent first for efficiency)
+    for (let i = electionCount - 1; i >= 0; i--) {
+        try {
+            const electionStatus = await trackElectionProposal(i, l2Provider, l1Provider);
+            if (electionStatus.nomineeProposalId === proposalId) {
+                log("Found proposal %s as nominee proposal for election %d", proposalId, i);
+                return i;
+            }
+            if (electionStatus.memberProposalId === proposalId) {
+                log("Found proposal %s as member proposal for election %d", proposalId, i);
+                return i;
+            }
+        }
+        catch {
+            // Skip elections that fail to track
+            continue;
+        }
+    }
+    log("Proposal %s not found in any election", proposalId);
+    return null;
+}
+/**
+ * Track all active elections (not yet completed)
+ *
+ * Returns election statuses for all elections that are still in progress.
+ *
+ * @param l2Provider - L2 provider
+ * @param l1Provider - L1 provider
+ * @returns Array of election statuses for active elections
+ */
+async function trackAllElections(l2Provider, l1Provider) {
+    log("trackAllElections: fetching all active elections");
+    const status = await checkElectionStatus(l2Provider, l1Provider);
+    const electionCount = status.electionCount;
+    const results = [];
+    // Track all elections (including completed for history)
+    for (let i = 0; i < electionCount; i++) {
+        try {
+            const electionStatus = await trackElectionProposal(i, l2Provider, l1Provider);
+            results.push(electionStatus);
+        }
+        catch (err) {
+            log("Failed to track election %d: %s", i, err);
+            // Skip failed elections
+        }
+    }
+    log("Tracked %d elections", results.length);
+    return results;
+}
+/**
+ * Track only incomplete elections (not yet completed)
+ *
+ * Returns election statuses for elections that are still in progress.
+ * Completed elections are excluded.
+ *
+ * @param l2Provider - L2 provider
+ * @param l1Provider - L1 provider
+ * @returns Array of election statuses for incomplete elections
+ */
+async function trackIncompleteElections(l2Provider, l1Provider) {
+    const all = await trackAllElections(l2Provider, l1Provider);
+    return all.filter((e) => e.phase !== "COMPLETED");
+}
+// ============================================================================
+// Detailed Election Tracking
+// ============================================================================
+/**
+ * Get all contenders who registered for a nominee election
+ *
+ * Fetches ContenderAdded events to build the list of registered contenders.
+ *
+ * @param proposalId - Nominee election proposal ID
+ * @param provider - L2 provider
+ * @param nomineeGovernorAddress - Optional governor address override
+ * @returns Array of contenders with registration info
+ */
+async function getContenders(proposalId, provider, nomineeGovernorAddress = constants_1.ADDRESSES.ELECTION_NOMINEE_GOVERNOR) {
+    log("getContenders for proposal %s", proposalId);
+    const governor = getNomineeGovernor(nomineeGovernorAddress, provider);
+    const iface = new ethers_1.ethers.utils.Interface(abis_1.NOMINEE_ELECTION_GOVERNOR_ABI);
+    const { fromBlock, toBlock } = await getLogQueryBlockRange(governor, proposalId, provider);
+    const logs = await (0, rpc_utils_1.queryWithRetry)(() => provider.getLogs({
+        address: nomineeGovernorAddress,
+        topics: [
+            iface.getEventTopic("ContenderAdded"),
+            ethers_1.ethers.utils.hexZeroPad(ethers_1.BigNumber.from(proposalId).toHexString(), 32),
+        ],
+        fromBlock,
+        toBlock,
+    }));
+    const contenders = logs.flatMap((eventLog) => {
+        try {
+            const parsed = iface.parseLog(eventLog);
+            return [
+                {
+                    address: parsed.args.contender,
+                    registeredAtBlock: eventLog.blockNumber,
+                    registrationTxHash: eventLog.transactionHash,
+                },
+            ];
+        }
+        catch {
+            return [];
+        }
+    });
+    log("Found %d contenders for proposal %s", contenders.length, proposalId);
+    return contenders;
+}
+/**
+ * Get all nominees for a nominee election with their vote counts
+ *
+ * Fetches nominee list from contract and enriches with vote data.
+ *
+ * @param proposalId - Nominee election proposal ID
+ * @param provider - L2 provider
+ * @param nomineeGovernorAddress - Optional governor address override
+ * @returns Array of nominees with vote and exclusion data
+ */
+async function getNomineesWithVotes(proposalId, provider, nomineeGovernorAddress = constants_1.ADDRESSES.ELECTION_NOMINEE_GOVERNOR) {
+    log("getNomineesWithVotes for proposal %s", proposalId);
+    const governor = getNomineeGovernor(nomineeGovernorAddress, provider);
+    const nomineeAddresses = await (0, rpc_utils_1.queryWithRetry)(() => governor.nominees(proposalId));
+    const nominees = await Promise.all(nomineeAddresses.map(async (addr) => {
+        const [votesReceived, isExcluded] = await Promise.all([
+            (0, rpc_utils_1.queryWithRetry)(() => governor.votesReceived(proposalId, addr)),
+            (0, rpc_utils_1.queryWithRetry)(() => governor.isExcluded(proposalId, addr)),
+        ]);
+        return { address: addr, votesReceived, isExcluded };
+    }));
+    log("Found %d nominees for proposal %s", nominees.length, proposalId);
+    return nominees;
+}
+/**
+ * Get excluded nominees with exclusion details
+ *
+ * Fetches NomineeExcluded events to get exclusion information.
+ *
+ * @param proposalId - Nominee election proposal ID
+ * @param provider - L2 provider
+ * @param nomineeGovernorAddress - Optional governor address override
+ * @returns Array of excluded nominees with exclusion tx info
+ */
+async function getExcludedNominees(proposalId, provider, nomineeGovernorAddress = constants_1.ADDRESSES.ELECTION_NOMINEE_GOVERNOR) {
+    log("getExcludedNominees for proposal %s", proposalId);
+    const governor = getNomineeGovernor(nomineeGovernorAddress, provider);
+    const iface = new ethers_1.ethers.utils.Interface(abis_1.NOMINEE_ELECTION_GOVERNOR_ABI);
+    const { fromBlock, toBlock } = await getLogQueryBlockRange(governor, proposalId, provider, 0);
+    const logs = await (0, rpc_utils_1.queryWithRetry)(() => provider.getLogs({
+        address: nomineeGovernorAddress,
+        topics: [
+            iface.getEventTopic("NomineeExcluded"),
+            ethers_1.ethers.utils.hexZeroPad(ethers_1.BigNumber.from(proposalId).toHexString(), 32),
+        ],
+        fromBlock,
+        toBlock,
+    }));
+    const parsedLogs = logs.flatMap((eventLog) => {
+        try {
+            const parsed = iface.parseLog(eventLog);
+            return [{ eventLog, nominee: parsed.args.nominee }];
+        }
+        catch {
+            return [];
+        }
+    });
+    const excluded = await Promise.all(parsedLogs.map(async ({ eventLog, nominee }) => {
+        const votesReceived = await (0, rpc_utils_1.queryWithRetry)(() => governor.votesReceived(proposalId, nominee));
+        return {
+            address: nominee,
+            votesReceived,
+            isExcluded: true,
+            excludedAtBlock: eventLog.blockNumber,
+            exclusionTxHash: eventLog.transactionHash,
+        };
+    }));
+    log("Found %d excluded nominees for proposal %s", excluded.length, proposalId);
+    return excluded;
+}
+/**
+ * Get detailed nominee election information
+ *
+ * Aggregates contenders, nominees, excluded nominees, and voting data.
+ *
+ * @param electionIndex - Election index
+ * @param provider - L2 provider
+ * @param nomineeGovernorAddress - Optional governor address override
+ * @returns Detailed nominee election data or null if not found
+ */
+async function getNomineeElectionDetails(electionIndex, provider, nomineeGovernorAddress = constants_1.ADDRESSES.ELECTION_NOMINEE_GOVERNOR) {
+    log("getNomineeElectionDetails for election %d", electionIndex);
+    const proposalId = await getElectionProposalId(electionIndex, provider, nomineeGovernorAddress);
+    if (!proposalId) {
+        log("No proposal found for election %d", electionIndex);
+        return null;
+    }
+    const governor = getNomineeGovernor(nomineeGovernorAddress, provider);
+    const [contenders, nominees, snapshotBlock] = await Promise.all([
+        getContenders(proposalId, provider, nomineeGovernorAddress),
+        getNomineesWithVotes(proposalId, provider, nomineeGovernorAddress),
+        (0, rpc_utils_1.queryWithRetry)(() => governor.proposalSnapshot(proposalId)),
     ]);
+    const quorumThreshold = await (0, rpc_utils_1.queryWithRetry)(() => governor.quorum(snapshotBlock.toNumber()));
+    const compliantNominees = nominees.filter((n) => !n.isExcluded);
+    const excludedNominees = nominees.filter((n) => n.isExcluded);
     return {
-        to: nomineeGovernorAddress,
-        data: calldata,
-        value: "0",
-        chain: "arb1",
-        chainId: 42161,
-        description: `execute() on NomineeElectionGovernor to trigger member election #${electionStatus.electionIndex}`,
+        proposalId,
+        electionIndex,
+        contenders,
+        nominees,
+        compliantNominees,
+        excludedNominees,
+        quorumThreshold,
+        targetNomineeCount: constants_1.TIMING.SECURITY_COUNCIL_TARGET_NOMINEES,
+    };
+}
+/**
+ * Get member election results with weighted votes
+ *
+ * Fetches top nominees (winners) and their weighted vote totals.
+ *
+ * @param electionIndex - Election index
+ * @param provider - L2 provider
+ * @param memberGovernorAddress - Optional governor address override
+ * @param nomineeGovernorAddress - Optional nominee governor address override
+ * @returns Detailed member election data or null if not found
+ */
+async function getMemberElectionDetails(electionIndex, provider, memberGovernorAddress = constants_1.ADDRESSES.ELECTION_MEMBER_GOVERNOR, nomineeGovernorAddress = constants_1.ADDRESSES.ELECTION_NOMINEE_GOVERNOR) {
+    log("getMemberElectionDetails for election %d", electionIndex);
+    const memberGovernor = getMemberGovernor(memberGovernorAddress, provider);
+    const nomineeGovernor = getNomineeGovernor(nomineeGovernorAddress, provider);
+    // Compute proposal ID using getProposeArgs + hashProposal (same scheme as nominee governor)
+    const memberProposalId = await computeElectionProposalId(electionIndex, memberGovernor);
+    // Verify proposal exists by checking state (reverts for non-existent proposals)
+    try {
+        await (0, rpc_utils_1.queryWithRetry)(() => memberGovernor.state(memberProposalId));
+    }
+    catch {
+        log("No member proposal found for election %d", electionIndex);
+        return null;
+    }
+    const [winners, deadline, fullWeightDeadline, nomineeProposalId] = await Promise.all([
+        (0, rpc_utils_1.queryWithRetry)(() => memberGovernor.topNominees(memberProposalId)).catch(() => []),
+        (0, rpc_utils_1.queryWithRetry)(() => memberGovernor.proposalDeadline(memberProposalId)),
+        (0, rpc_utils_1.queryWithRetry)(() => memberGovernor.fullWeightVotingDeadline(memberProposalId)),
+        getElectionProposalId(electionIndex, provider, nomineeGovernorAddress),
+    ]);
+    const allNominees = nomineeProposalId
+        ? await (0, rpc_utils_1.queryWithRetry)(() => nomineeGovernor.compliantNominees(nomineeProposalId))
+        : [];
+    const winnersSet = new Set(winners.map((w) => w.toLowerCase()));
+    const nomineeWeights = await Promise.all(allNominees.map(async (addr) => ({
+        addr,
+        weight: await (0, rpc_utils_1.queryWithRetry)(() => memberGovernor.weightReceived(memberProposalId, addr)),
+    })));
+    const nomineeDetails = nomineeWeights
+        .sort((a, b) => (b.weight.gt(a.weight) ? 1 : -1))
+        .map((n, i) => ({
+        address: n.addr,
+        weightReceived: n.weight,
+        isWinner: winnersSet.has(n.addr.toLowerCase()),
+        rank: i + 1,
+    }));
+    return {
+        proposalId: memberProposalId,
+        electionIndex,
+        nominees: nomineeDetails,
+        winners,
+        fullWeightDeadline: fullWeightDeadline.toNumber(),
+        proposalDeadline: deadline.toNumber(),
     };
 }
 //# sourceMappingURL=election.js.map