@poa-box/core 0.1.0 → 1.0.0

package/dist/reads/user.d.ts

@@ -1,21 +1,4 @@
-/**
- * User & account reads — typed wrappers over graph/documents/user.
- *
- * Serves the read paths of `pop user whoami` (src/commands/user/whoami.ts),
- * `pop user profile` (src/commands/user/profile.ts), and the pre-write reads
- * of `pop user join` / `pop user claim-hats` / `pop user update-profile`.
- *
- * Usernames and profile metadata are HOME-CHAIN account-registry state
- * (that's where `pop user register` writes and `pop user profile` reads), so
- * the account-scoped helpers default to HOME_CHAIN_ID rather than the
- * client's default chain. An explicit chainId always wins.
- *
- * A null row from any of these means NOT-INDEXED, not nonexistent — the CLI
- * keeps live RPC fallbacks (getUsername, balanceOf, Hats.balanceOf) for every
- * decision where that difference matters, and `isAccountAuthoritative`
- * (re-exported below) is the guard that says when an indexed account may
- * stand in for a live registry read.
- */
+/** Account/token history is retained; current organization membership comes from MembershipAuthority. */
 import type { GraphClient } from '../graph/client';
 import { IndexedAccount, IndexedQuickJoin } from '../graph/documents/user';
 export { isAccountAuthoritative } from '../graph/documents/user';
@@ -73,13 +56,7 @@ export declare function getQuickJoinAccount(client: GraphClient, quickJoinAddres
     quickJoinContract: IndexedQuickJoin | null;
     account: IndexedAccount | null;
 }>;
-/**
- * Just the QuickJoin module pointers (accountRegistry / hatsContract /
- * memberHatIds) — the address read of `pop user claim-hats`
- * (src/commands/user/claim-hats.ts). The pointers are static deploy-time
- * values, byte-verified against the live eth_calls on Gnosis and Arbitrum;
- * the claim pre-flight probes themselves stay on-chain in the CLI.
- */
+/** Read the indexed account registry pointer for QuickJoin. */
 export declare function getQuickJoinModules(client: GraphClient, quickJoinAddress: string, chainId?: number): Promise<IndexedQuickJoin | null>;
 /** Account row served by FETCH_REGISTRY_AND_ACCOUNT (profile-merge shape). */
 export interface RegistryAccount {
@@ -110,6 +87,8 @@ export interface OrgUser {
     id: string;
     address: string;
     participationTokenBalance: string | null;
+    /** False when authority membership exists but its historical User is not indexed. */
+    historyIndexed?: boolean;
     membershipStatus: string | null;
     currentHatIds: string[] | null;
     joinMethod: string | null;
@@ -179,10 +158,8 @@ export interface WhoamiOrgData {
         name: string | null;
         roles: Array<{
             hatId: string;
+            subjectId: string;
             name: string | null;
-            hat: {
-                active: boolean;
-            } | null;
         }>;
     } | null;
     quickJoinContract: IndexedQuickJoin | null;
@@ -196,27 +173,15 @@ export interface WhoamiOrgData {
         membershipStatus: string | null;
         participationTokenBalance: string | null;
         currentHatIds: string[] | null;
+        /** False when current membership is indexed before its historical User row. */
+        historyIndexed?: boolean;
     } | null;
     /** Pending requests by this user — the CLI reports `tokenRequests.length`. */
     tokenRequests: Array<{
         id: string;
     }>;
 }
-/**
- * One-round-trip org snapshot for `pop user whoami`
- * (src/commands/user/whoami.ts): org name + role hats (with the Hats toggle
- * flag), QuickJoin pointers, the caller's account/PT balance/org-user row,
- * and their pending token requests. Variables are composed exactly as the
- * CLI does — AddressZero placeholders keep the document valid when a module
- * is missing (those selections then simply return null).
- *
- * Interpretation stays with the caller (the CLI keeps RPC fallbacks for
- * username/PT/membership): gate `account.username` with
- * isAccountAuthoritative(account, quickJoinContract?.accountRegistry), AND
- * membership derived from currentHatIds with the role's `hat.active` flag —
- * a toggled-off hat still appears in currentHatIds because Hats does not
- * burn the token.
- */
+/** Account/token history merged with current authority roles and membership. */
 export declare function getWhoamiOrgData(client: GraphClient, params: {
     /** Org hex ID (as returned by resolveOrgId / OrgModules.orgId). */
     orgId: string;

package/dist/reads/user.js

@@ -1,22 +1,5 @@
 "use strict";
-/**
- * User & account reads — typed wrappers over graph/documents/user.
- *
- * Serves the read paths of `pop user whoami` (src/commands/user/whoami.ts),
- * `pop user profile` (src/commands/user/profile.ts), and the pre-write reads
- * of `pop user join` / `pop user claim-hats` / `pop user update-profile`.
- *
- * Usernames and profile metadata are HOME-CHAIN account-registry state
- * (that's where `pop user register` writes and `pop user profile` reads), so
- * the account-scoped helpers default to HOME_CHAIN_ID rather than the
- * client's default chain. An explicit chainId always wins.
- *
- * A null row from any of these means NOT-INDEXED, not nonexistent — the CLI
- * keeps live RPC fallbacks (getUsername, balanceOf, Hats.balanceOf) for every
- * decision where that difference matters, and `isAccountAuthoritative`
- * (re-exported below) is the guard that says when an indexed account may
- * stand in for a live registry read.
- */
+/** Account/token history is retained; current organization membership comes from MembershipAuthority. */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAccountAuthoritative = void 0;
 exports.getAccountByUsername = getAccountByUsername;
@@ -31,6 +14,7 @@ const ethers_1 = require("ethers");
 const user_1 = require("../graph/documents/user");
 const chains_1 = require("../chains");
 const resolve_1 = require("./resolve");
+const authority_1 = require("./authority");
 // Pure selection helpers live in the documents module — re-exported here so
 // read-layer consumers get the guard next to the reads it guards.
 var user_2 = require("../graph/documents/user");
@@ -80,13 +64,7 @@ async function getQuickJoinAccount(client, quickJoinAddress, accountAddress, cha
         account: result?.account ?? null,
     };
 }
-/**
- * Just the QuickJoin module pointers (accountRegistry / hatsContract /
- * memberHatIds) — the address read of `pop user claim-hats`
- * (src/commands/user/claim-hats.ts). The pointers are static deploy-time
- * values, byte-verified against the live eth_calls on Gnosis and Arbitrum;
- * the claim pre-flight probes themselves stay on-chain in the CLI.
- */
+/** Read the indexed account registry pointer for QuickJoin. */
 async function getQuickJoinModules(client, quickJoinAddress, chainId) {
     const result = await client.query(user_1.FETCH_QUICKJOIN_MODULES, { quickJoinAddress: quickJoinAddress.toLowerCase() }, chainId);
     return result?.quickJoinContract ?? null;
@@ -117,39 +95,44 @@ async function getOrgUserProfile(client, orgIdOrName, address, chainId) {
     const orgId = await (0, resolve_1.resolveOrgId)(client, orgIdOrName, chainId);
     const orgUserID = `${orgId.toLowerCase()}-${address.toLowerCase()}`;
     const { data, tierIndex } = await client.queryWithFieldFallback((0, user_1.userDataTiers)(orgUserID, address.toLowerCase()), { chainId });
+    const users = await (0, authority_1.readAuthorityUsers)(client, orgId, data.user ? [data.user] : [], chainId);
+    const currentUser = users.find(user => user.address.toLowerCase() === address.toLowerCase());
     return {
-        user: data.user ?? null,
+        user: currentUser ?? null,
         account: data.account ?? null,
         hasChurnCounters: tierIndex === 0,
     };
 }
-/**
- * One-round-trip org snapshot for `pop user whoami`
- * (src/commands/user/whoami.ts): org name + role hats (with the Hats toggle
- * flag), QuickJoin pointers, the caller's account/PT balance/org-user row,
- * and their pending token requests. Variables are composed exactly as the
- * CLI does — AddressZero placeholders keep the document valid when a module
- * is missing (those selections then simply return null).
- *
- * Interpretation stays with the caller (the CLI keeps RPC fallbacks for
- * username/PT/membership): gate `account.username` with
- * isAccountAuthoritative(account, quickJoinContract?.accountRegistry), AND
- * membership derived from currentHatIds with the role's `hat.active` flag —
- * a toggled-off hat still appears in currentHatIds because Hats does not
- * burn the token.
- */
+/** Account/token history merged with current authority roles and membership. */
 async function getWhoamiOrgData(client, params, chainId) {
+    const orgId = await (0, resolve_1.resolveOrgId)(client, params.orgId, chainId);
     const address = params.address.toLowerCase();
     const tokenAddress = params.participationTokenAddress || ethers_1.ethers.constants.AddressZero;
     const quickJoinAddress = (params.quickJoinAddress || ethers_1.ethers.constants.AddressZero).toLowerCase();
     const result = await client.query(user_1.FETCH_WHOAMI_ORG_DATA, {
-        orgId: params.orgId,
-        orgUserID: `${params.orgId}-${address}`,
+        orgId,
+        orgUserID: `${orgId}-${address}`,
         tokenAddress,
         userAddress: address,
         quickJoinAddress,
         accountID: address,
         tokenBalanceID: `${tokenAddress.toLowerCase()}-${address}`,
     }, chainId);
-    return result ?? null;
+    if (!result)
+        return null;
+    const [subjects, memberships] = await Promise.all([
+        (0, authority_1.readAuthorityRows)(client, orgId, authority_1.FETCH_AUTHORITY_SUBJECTS, 'subjects', chainId),
+        (0, authority_1.readAuthorityMemberships)(client, orgId, chainId),
+    ]);
+    const current = memberships.filter(row => row.user.toLowerCase() === address && row.isMember && row.subject.kind === 'Role');
+    if (result.organization)
+        result.organization.roles = subjects.filter(subject => subject.kind === 'Role').map(subject => ({ hatId: subject.subjectId, subjectId: subject.subjectId, name: subject.name }));
+    if (result.user || current.length)
+        result.user = {
+            id: `${orgId}-${address}`, participationTokenBalance: null,
+            ...result.user, historyIndexed: result.user != null,
+            membershipStatus: current.length ? 'Active' : 'Inactive',
+            currentHatIds: [...new Set(current.map(row => row.subject.subjectId))],
+        };
+    return result;
 }

package/dist/reads/vote.d.ts

@@ -11,6 +11,7 @@ import type { GraphClient } from '../graph/client';
 import { SubgraphVotingClass } from '../graph/documents/voting-classes';
 /** One ballot as indexed by the subgraph (FETCH_VOTING_DATA field set). */
 export interface SubgraphProposalVote {
+    id?: string;
     voter: string;
     voterUsername?: string | null;
     optionIndexes: string[];
@@ -216,9 +217,19 @@ export interface ProposalResults {
     totalVoters: number;
     supportThresholdPct?: number;
     quorumVoterCount?: number;
+    /** Compatibility quorumVoterCount is the live global config, not a restricted poll's override. */
+    quorumSource: 'current-global-config';
+    /** Null when the subgraph cannot identify the proposal's per-poll override. */
+    effectiveQuorumVoterCount: number | null;
     ranking: ProposalResultsRankEntry[];
     voters: ProposalResultsVoter[];
-    winner?: ProposalResultsRankEntry;
+    /** Raw ballot allocation leader; this is not the class-weighted on-chain winner. */
+    allocationLeader: ProposalResultsRankEntry | null;
+    rankingBasis: 'sum-of-ballot-allocations';
+    winnerSource: 'announced' | 'unannounced' | 'invalid';
+    announcedWinningOption: number | null;
+    announcedValid: boolean | null;
+    winner: ProposalResultsRankEntry | null;
 }
 /**
  * The `pop vote results` proposal document (src/commands/vote/results.ts).
@@ -228,7 +239,7 @@ export interface ProposalResults {
  * this read exists to serve. The legacy tier is spelled out rather than
  * derived so a reformat cannot silently turn it into a copy of the modern one.
  */
-export declare function buildProposalResultsQuery(orgId: string, proposalId: number, modern: boolean): string;
+export declare function buildProposalResultsQuery(orgId: string, proposalId: number, modern: boolean, after?: string): string;
 /**
  * Pure port of the `pop vote results` tally/ranking/attribution computation
  * (src/commands/vote/results.ts) over the fetched hybridVoting row.
@@ -262,6 +273,15 @@ export declare function computeProposalResults(hybridVoting: {
  * the proposal is not indexed.
  */
 export declare function fetchProposalResults(client: GraphClient, orgIdOrName: string, proposalId: number, chainId?: number): Promise<ProposalResults>;
+/** Shared CLI/SDK read after organization resolution; cursor-pagination prevents truncated tallies. */
+export declare function fetchProposalResultsByOrgId(client: Pick<GraphClient, 'queryWithFieldFallback'>, orgId: string, proposalId: number, chainId?: number): Promise<ProposalResults>;
+/** Full indexed ballot history plus exact class-emission pointers, with legacy schema fallback. */
+export declare function fetchProposalVoteAnalysis(client: Pick<GraphClient, 'queryWithFieldFallback'>, hybridVotingAddress: string, proposalId: number, chainId?: number): Promise<any>;
+/** Reproduce HybridVotingCore vote rounding and VotingMath.pickWinnerNSlices scores. */
+export declare function computeClassWeightedScores(ballots: Array<{
+    weights: number[];
+    classRawPowers: bigint[];
+}>, slices: number[], numOptions: number): number[];
 /** Normalized class row — identical shape from the subgraph and the contract. */
 export interface NormalizedClass {
     classIndex: number;
@@ -271,11 +291,15 @@ export interface NormalizedClass {
     minBalance: string;
     asset: string;
     hatIds: string[];
+    /** On-chain stable authority binding is not indexed; hatIds are only its fallback list. */
+    subjectId: string | null;
+    subjectBindingKnown: boolean;
 }
 export interface ClassConfigSnapshot {
     classes: NormalizedClass[];
     supportThresholdPct: number;
     quorumVoterCount: number;
+    effectiveQuorumVoterCount: number | null;
 }
 /**
  * Subgraph rows → the exact shape the contract path produces. `asset` is

package/dist/reads/vote.js

@@ -19,6 +19,9 @@ exports.evaluateExecuteGate = evaluateExecuteGate;
 exports.buildProposalResultsQuery = buildProposalResultsQuery;
 exports.computeProposalResults = computeProposalResults;
 exports.fetchProposalResults = fetchProposalResults;
+exports.fetchProposalResultsByOrgId = fetchProposalResultsByOrgId;
+exports.fetchProposalVoteAnalysis = fetchProposalVoteAnalysis;
+exports.computeClassWeightedScores = computeClassWeightedScores;
 exports.normalizeSubgraphClasses = normalizeSubgraphClasses;
 exports.fetchClassConfig = fetchClassConfig;
 const ethers_1 = require("ethers");
@@ -210,8 +213,8 @@ function evaluateExecuteGate(proposal) {
  * this read exists to serve. The legacy tier is spelled out rather than
  * derived so a reformat cannot silently turn it into a copy of the modern one.
  */
-function buildProposalResultsQuery(orgId, proposalId, modern) {
-    const proposalCore = 'proposalId title status';
+function buildProposalResultsQuery(orgId, proposalId, modern, after = '') {
+    const proposalCore = 'proposalId title status numOptions isHatRestricted winningOption isValid';
     return `{
     organization(id: "${orgId}") {
       hybridVoting {
@@ -223,7 +226,9 @@ function buildProposalResultsQuery(orgId, proposalId, modern) {
           ${modern ? 'proposer proposerUsername creatorUsername' : ''}
           ${modern ? 'classesVersion winnerAnnouncedAt executedAt executedCallsCount' : ''}
           metadata { description optionNames${modern ? ' actionSummaries promotedFrom' : ''} }
-          votes { voterUsername optionIndexes optionWeights }
+          votes(first: 1000, orderBy: id, orderDirection: asc, where: { id_gt: ${JSON.stringify(after)} }) {
+            id voter voterUsername optionIndexes optionWeights
+          }
         }
       }
     }
@@ -246,17 +251,19 @@ function computeProposalResults(hybridVoting) {
         return null;
     // Two DISTINCT validity parameters — threshold is a % of weighted power,
     // quorum is a raw voter count. Never conflate them.
-    const supportThresholdPct = hybridVoting.thresholdPct !== undefined ? Number(hybridVoting.thresholdPct) : undefined;
-    const quorumVoterCount = hybridVoting.quorum !== undefined ? Number(hybridVoting.quorum) : undefined;
-    const optionNames = proposal.metadata?.optionNames || [];
+    const supportThresholdPct = hybridVoting.thresholdPct != null ? Number(hybridVoting.thresholdPct) : undefined;
+    const quorumVoterCount = hybridVoting.quorum != null ? Number(hybridVoting.quorum) : undefined;
+    const namedOptions = proposal.metadata?.optionNames ?? [];
+    const optionCount = Number(proposal.numOptions ?? namedOptions.length);
+    const optionNames = Array.from({ length: optionCount }, (_, i) => namedOptions[i] || `Option ${i}`);
     const votes = proposal.votes || [];
-    // Tally weighted votes per option
+    // Compatibility ranking sums ballot percentages; it does not apply class power.
     const tallies = new Array(Math.max(optionNames.length, 1)).fill(0);
     for (const v of votes) {
         for (let i = 0; i < (v.optionIndexes || []).length; i++) {
             const idx = parseInt(v.optionIndexes[i]);
             const weight = parseInt(v.optionWeights[i]);
-            if (idx < tallies.length)
+            if (idx >= 0 && idx < tallies.length)
                 tallies[idx] += weight;
         }
     }
@@ -273,12 +280,10 @@ function computeProposalResults(hybridVoting) {
             const name = optionNames[idx] || `Option ${idx}`;
             allocations[name] = parseInt(v.optionWeights[i]);
         }
-        return { voter: v.voterUsername || 'unknown', allocations };
+        return { voter: v.voterUsername || v.voter || 'unknown', allocations };
     });
     const proposedBy = proposal.proposerUsername || proposal.creatorUsername || null;
-    // A proposal is tallied against the voting-class config in force when it was
-    // CREATED, so a live config change mid-flight makes the org-level
-    // threshold/quorum shown here stale.
+    // Class membership and slices are snapshotted; threshold and global quorum remain live.
     const classVersionAtCreation = proposal.classesVersion != null ? String(proposal.classesVersion) : null;
     const liveClassVersion = hybridVoting.classVersion != null ? String(hybridVoting.classVersion) : null;
     const classConfigDrifted = Boolean(classVersionAtCreation && liveClassVersion && classVersionAtCreation !== liveClassVersion);
@@ -299,9 +304,17 @@ function computeProposalResults(hybridVoting) {
         totalVoters: votes.length,
         supportThresholdPct,
         quorumVoterCount,
+        quorumSource: 'current-global-config',
+        effectiveQuorumVoterCount: proposal.isHatRestricted === false ? quorumVoterCount ?? null : null,
         ranking: ranked,
         voters: voterBreakdown,
-        winner: ranked[0],
+        rankingBasis: 'sum-of-ballot-allocations',
+        allocationLeader: ranked[0] ?? null,
+        announcedWinningOption: proposal.winningOption != null ? Number(proposal.winningOption) : null,
+        announcedValid: proposal.isValid ?? null,
+        winnerSource: proposal.winningOption == null ? 'unannounced' : proposal.isValid === true ? 'announced' : 'invalid',
+        winner: proposal.winningOption != null && proposal.isValid === true
+            ? ranked.find(r => r.option === Number(proposal.winningOption)) ?? null : null,
     };
 }
 /**
@@ -311,15 +324,73 @@ function computeProposalResults(hybridVoting) {
  */
 async function fetchProposalResults(client, orgIdOrName, proposalId, chainId) {
     const orgId = await (0, resolve_1.resolveOrgId)(client, orgIdOrName, chainId);
-    const { data } = await client.queryWithFieldFallback([
-        { query: buildProposalResultsQuery(orgId, proposalId, true) },
-        { query: buildProposalResultsQuery(orgId, proposalId, false) },
-    ], { chainId });
-    const hybridVoting = data.organization?.hybridVoting;
-    const report = hybridVoting ? computeProposalResults(hybridVoting) : null;
-    if (!report)
-        throw new errors_1.CliError(`Proposal #${proposalId} not found`, exit_codes_1.EXIT.USAGE);
-    return report;
+    return fetchProposalResultsByOrgId(client, orgId, proposalId, chainId);
+}
+/** Shared CLI/SDK read after organization resolution; cursor-pagination prevents truncated tallies. */
+async function fetchProposalResultsByOrgId(client, orgId, proposalId, chainId) {
+    let after = '';
+    let hybridVoting;
+    const votes = [];
+    for (;;) {
+        const { data } = await client.queryWithFieldFallback([
+            { query: buildProposalResultsQuery(orgId, proposalId, true, after) },
+            { query: buildProposalResultsQuery(orgId, proposalId, false, after) },
+        ], { chainId });
+        const row = data.organization?.hybridVoting;
+        if (!row?.proposals?.[0])
+            throw new errors_1.CliError(`Proposal #${proposalId} not found`, exit_codes_1.EXIT.USAGE);
+        hybridVoting ??= row;
+        const page = row.proposals[0].votes ?? [];
+        votes.push(...page);
+        if (page.length < 1000)
+            break;
+        const next = page[page.length - 1].id;
+        if (!next || next <= after)
+            throw new errors_1.CliError('Cannot paginate proposal votes without an advancing vote ID.', exit_codes_1.EXIT.PRECONDITION);
+        after = next;
+    }
+    hybridVoting.proposals[0].votes = votes;
+    return computeProposalResults(hybridVoting);
+}
+/** Full indexed ballot history plus exact class-emission pointers, with legacy schema fallback. */
+async function fetchProposalVoteAnalysis(client, hybridVotingAddress, proposalId, chainId) {
+    let after = '';
+    let first;
+    const votes = [];
+    for (;;) {
+        const variables = { hybridVoting: hybridVotingAddress.toLowerCase(), proposalId: String(proposalId), after };
+        const { data } = await client.queryWithFieldFallback([
+            { query: voting_classes_1.FETCH_PROPOSAL_VOTE_ANALYSIS_EXACT, variables },
+            { query: voting_classes_1.FETCH_PROPOSAL_VOTE_ANALYSIS, variables },
+        ], { chainId });
+        first ??= data;
+        const page = data.hybridVotingContract?.proposals?.[0]?.votes ?? [];
+        votes.push(...page);
+        if (page.length < 1000)
+            break;
+        const next = page[page.length - 1].id;
+        if (!next || next <= after)
+            throw new errors_1.CliError('Cannot paginate proposal votes without an advancing vote ID.', exit_codes_1.EXIT.PRECONDITION);
+        after = next;
+    }
+    if (first.hybridVotingContract?.proposals?.[0])
+        first.hybridVotingContract.proposals[0].votes = votes;
+    return first;
+}
+/** Reproduce HybridVotingCore vote rounding and VotingMath.pickWinnerNSlices scores. */
+function computeClassWeightedScores(ballots, slices, numOptions) {
+    const totals = slices.map((_, cls) => ballots.reduce((sum, v) => sum + (v.classRawPowers[cls] ?? 0n), 0n));
+    return Array.from({ length: numOptions }, (_, option) => {
+        let score = 0n;
+        for (let cls = 0; cls < slices.length; cls++) {
+            if (totals[cls] === 0n)
+                continue;
+            const optionRaw = ballots.reduce((sum, v) => sum + (v.classRawPowers[cls] ?? 0n) * BigInt(v.weights[option] ?? 0) / 100n, 0n);
+            score += optionRaw * BigInt(slices[cls]) * 10000n / totals[cls];
+        }
+        // Scores are bounded by 100 * 10000, so this conversion is exact.
+        return Number(score) / 10000;
+    });
 }
 /**
  * Subgraph rows → the exact shape the contract path produces. `asset` is
@@ -336,6 +407,8 @@ function normalizeSubgraphClasses(rows) {
         minBalance: ethers_1.ethers.BigNumber.from(String(c.minBalance ?? '0')).toString(),
         asset: ethers_1.ethers.utils.getAddress(String(c.asset)),
         hatIds: (c.hatIds ?? []).map(h => String(h)),
+        subjectId: null,
+        subjectBindingKnown: false,
     }));
 }
 /**
@@ -355,23 +428,30 @@ async function fetchClassConfig(client, hybridVotingAddress, proposalId, chainId
         // guessing the newest version would silently misreport an old proposal.
         const tiers = proposalId === undefined
             ? [
+                { query: voting_classes_1.FETCH_VOTING_CLASS_CONFIG_EXACT, variables: { hybridVoting } },
                 { query: voting_classes_1.FETCH_VOTING_CLASS_CONFIG, variables: { hybridVoting } },
                 { query: voting_classes_1.FETCH_VOTING_CLASS_CONFIG_LEGACY, variables: { hybridVoting } },
             ]
             : [
+                { query: voting_classes_1.FETCH_PROPOSAL_VOTING_CLASSES_EXACT, variables: { hybridVoting, proposalId: String(proposalId) } },
                 { query: voting_classes_1.FETCH_PROPOSAL_VOTING_CLASSES, variables: { hybridVoting, proposalId: String(proposalId) } },
             ];
         const { data } = await client.queryWithFieldFallback(tiers, { chainId });
         const contract = data?.hybridVotingContract;
         if (!contract)
             return null;
+        // createProposalV2 may snapshot a synthetic equal-weight class for a restricted poll.
+        // The index has no ProposalConfigV2/synthetic snapshot fields; its ordinary class version
+        // cannot distinguish those proposals. Unknown restriction metadata is equally untrusted.
+        if (proposalId !== undefined && contract.proposals?.[0]?.isHatRestricted !== false)
+            return null;
         const version = proposalId === undefined
             ? contract.classVersion
             : contract.proposals?.[0]?.classesVersion;
         // For a proposal we must know its frozen version — no version, no answer.
         if (proposalId !== undefined && (version === null || version === undefined))
             return null;
-        const rows = (0, voting_classes_1.selectClassSnapshot)(contract.votingClasses, version);
+        const rows = (0, voting_classes_1.selectIndexedClassSnapshot)(contract, proposalId);
         if (rows.length === 0)
             return null;
         if (contract.thresholdPct === null || contract.thresholdPct === undefined)
@@ -382,6 +462,7 @@ async function fetchClassConfig(client, hybridVotingAddress, proposalId, chainId
             classes: normalizeSubgraphClasses(rows),
             supportThresholdPct: Number(contract.thresholdPct),
             quorumVoterCount: Number(contract.quorum),
+            effectiveQuorumVoterCount: proposalId === undefined || contract.proposals?.[0]?.isHatRestricted === false ? Number(contract.quorum) : null,
         };
     }
     catch {

package/dist/tx/authority.d.ts

@@ -0,0 +1,33 @@
+/** MembershipAuthority intent builders. No legacy Hats/EligibilityModule write surface. */
+import { ethers } from 'ethers';
+import type { TxIntent } from './intent';
+/** The high byte selects the fold; the remaining 248 bits are the label hash shifted right. */
+export declare function permissionKey(label: string, foldTag?: number): string;
+export declare const AUTHORITY_KEYS: {
+    DD_VOTE: string;
+    DD_CREATE: string;
+    HV_CREATE: string;
+    TM_PERMS: string;
+    PT_MEMBER: string;
+    PT_APPROVE: string;
+    EDU_CREATE: string;
+    EDU_MEMBER: string;
+    QJ_AUTOJOIN: string;
+    PAY_CREATE: string;
+    SUBJECT_RENAME: string;
+};
+export declare const EXISTS_BIT: ethers.BigNumber;
+export declare const INHERIT_GLOBAL_BIT: ethers.BigNumber;
+export declare const VALUE_MASK: ethers.BigNumber;
+export declare function permissionWord(value: ethers.BigNumberish, inheritGlobal?: boolean): ethers.BigNumber;
+/** Project zero must not collide with the global context. */
+export declare function projectContext(projectId: ethers.BigNumberish): string;
+/** Explicit allowlist excludes initialization, migration seeds and compatibility mint selectors. */
+export declare const AUTHORITY_METHODS: readonly ["claim", "renounce", "reconcile(uint256,address)", "reconcile(uint256,address[])", "grant", "offer", "withdrawOffer", "remove", "unremove", "setRule", "clearRule", "delegatedGrant", "delegatedOffer", "delegatedRemove", "delegatedUnremove", "finalize", "cancel", "setManagerConfig", "createRole", "createGroup", "addRoleToGroup", "removeRoleFromGroup", "renameSubject", "setMaxMembers", "setSubjectDefault", "configureVouchAttestor", "resetVouchEpoch", "clearUserVouches", "setMaxDailyVouches", "vouch", "revokeVouch", "setPerm", "clearPerm", "setPaused"];
+export type AuthorityMethod = typeof AUTHORITY_METHODS[number];
+export declare function buildAuthorityAction(a: {
+    authorityAddress: string;
+    method: AuthorityMethod;
+    args: unknown[];
+    orgId?: string;
+}): TxIntent;

package/dist/tx/authority.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTHORITY_METHODS = exports.VALUE_MASK = exports.INHERIT_GLOBAL_BIT = exports.EXISTS_BIT = exports.AUTHORITY_KEYS = void 0;
+exports.permissionKey = permissionKey;
+exports.permissionWord = permissionWord;
+exports.projectContext = projectContext;
+exports.buildAuthorityAction = buildAuthorityAction;
+/** MembershipAuthority intent builders. No legacy Hats/EligibilityModule write surface. */
+const ethers_1 = require("ethers");
+const contracts_1 = require("../contracts");
+/** The high byte selects the fold; the remaining 248 bits are the label hash shifted right. */
+function permissionKey(label, foldTag = 0) {
+    if (!Number.isInteger(foldTag) || foldTag < 0 || foldTag > 2)
+        throw new Error('Invalid permission fold tag');
+    return ethers_1.ethers.utils.hexZeroPad(ethers_1.ethers.BigNumber.from(ethers_1.ethers.utils.id(label)).shr(8)
+        .or(ethers_1.ethers.BigNumber.from(foldTag).shl(248)).toHexString(), 32);
+}
+exports.AUTHORITY_KEYS = {
+    DD_VOTE: permissionKey('poa.perm.dd.vote'), DD_CREATE: permissionKey('poa.perm.dd.create'),
+    HV_CREATE: permissionKey('poa.perm.hv.create'), TM_PERMS: permissionKey('poa.perm.tm.perms', 1),
+    PT_MEMBER: permissionKey('poa.perm.pt.member'), PT_APPROVE: permissionKey('poa.perm.pt.approve'),
+    EDU_CREATE: permissionKey('poa.perm.edu.create'), EDU_MEMBER: permissionKey('poa.perm.edu.member'),
+    QJ_AUTOJOIN: permissionKey('poa.perm.qj.autojoin'), PAY_CREATE: permissionKey('poa.perm.pay.create'),
+    SUBJECT_RENAME: permissionKey('poa.perm.subject.rename'),
+};
+exports.EXISTS_BIT = ethers_1.ethers.BigNumber.from(1).shl(255);
+exports.INHERIT_GLOBAL_BIT = ethers_1.ethers.BigNumber.from(1).shl(254);
+exports.VALUE_MASK = exports.INHERIT_GLOBAL_BIT.sub(1);
+function permissionWord(value, inheritGlobal = false) {
+    const word = ethers_1.ethers.BigNumber.from(value);
+    if (word.lt(0) || word.gt(exports.VALUE_MASK))
+        throw new Error('Permission value must fit in 254 bits');
+    return word.or(exports.EXISTS_BIT).or(inheritGlobal ? exports.INHERIT_GLOBAL_BIT : 0);
+}
+/** Project zero must not collide with the global context. */
+function projectContext(projectId) {
+    const id = ethers_1.ethers.BigNumber.from(projectId);
+    if (id.lt(0) || id.gte(ethers_1.ethers.constants.MaxUint256))
+        throw new Error('Project ID cannot be encoded as projectId + 1');
+    return ethers_1.ethers.utils.hexZeroPad(id.add(1).toHexString(), 32);
+}
+/** Explicit allowlist excludes initialization, migration seeds and compatibility mint selectors. */
+exports.AUTHORITY_METHODS = [
+    'claim', 'renounce', 'reconcile(uint256,address)', 'reconcile(uint256,address[])',
+    'grant', 'offer', 'withdrawOffer', 'remove', 'unremove', 'setRule', 'clearRule',
+    'delegatedGrant', 'delegatedOffer', 'delegatedRemove', 'delegatedUnremove', 'finalize', 'cancel',
+    'setManagerConfig', 'createRole', 'createGroup', 'addRoleToGroup', 'removeRoleFromGroup',
+    'renameSubject', 'setMaxMembers', 'setSubjectDefault', 'configureVouchAttestor',
+    'resetVouchEpoch', 'clearUserVouches', 'setMaxDailyVouches', 'vouch', 'revokeVouch',
+    'setPerm', 'clearPerm', 'setPaused',
+];
+function buildAuthorityAction(a) {
+    if (!exports.AUTHORITY_METHODS.includes(a.method))
+        throw new Error('Unsupported authority action');
+    if (!ethers_1.ethers.utils.isAddress(a.authorityAddress) || a.authorityAddress === ethers_1.ethers.constants.AddressZero) {
+        throw new Error('A nonzero MembershipAuthority address is required');
+    }
+    const abi = (0, contracts_1.getAbi)('MembershipAuthority');
+    new ethers_1.ethers.utils.Interface(abi).encodeFunctionData(a.method, a.args);
+    return { to: a.authorityAddress, abi, method: a.method, args: a.args,
+        meta: { domain: 'role', action: a.method, orgId: a.orgId, summary: { authority: a.authorityAddress } } };
+}

package/dist/tx/governance.d.ts

@@ -47,6 +47,12 @@ export interface GovernanceWrapParams {
     batches: ExecutionCall[][];
     /** Restricted-voting hats; [] default. */
     hatIds?: ethers.BigNumberish[];
+    /** Native MembershipAuthority subjects restricting voting; preferred over the legacy hatIds name. */
+    subjectIds?: ethers.BigNumberish[];
+    /** Restricted polls only. Executable polls use max(global quorum, override). */
+    quorumOverride?: number;
+    /** Hybrid restricted polls only: count each eligible voter once. */
+    equalWeight?: boolean;
     orgId?: string;
     /** meta.action override (default 'create'). */
     action?: string;

package/dist/tx/governance.js

@@ -39,11 +39,28 @@ function buildGovernanceProposal(p) {
     // [target, BigNumber(value), data] — same tuple construction as the CLI
     // (`c.value || '0'` handles undefined/empty values as zero).
     const batchTuples = p.batches.map(batch => batch.map(call => [call.target, ethers_1.ethers.BigNumber.from(call.value || 0), call.calldata]));
-    const hatIds = p.hatIds ?? [];
+    if (p.subjectIds !== undefined && p.hatIds !== undefined)
+        throw new Error('Specify subjectIds or hatIds, not both.');
+    const hatIds = (p.subjectIds ?? p.hatIds ?? []).map(id => {
+        const value = ethers_1.ethers.BigNumber.from(id);
+        if (value.lt(0) || value.gt(ethers_1.ethers.constants.MaxUint256))
+            throw new Error('Subject IDs must fit uint256.');
+        return value;
+    });
+    const quorum = p.quorumOverride ?? 0;
+    if (!Number.isInteger(quorum) || quorum < 0 || quorum > 4294967295)
+        throw new Error('quorumOverride must be a uint32 voter count.');
+    if (p.equalWeight !== undefined && typeof p.equalWeight !== 'boolean')
+        throw new Error('equalWeight must be a boolean.');
+    if (p.equalWeight && p.votingAbiName !== 'HybridVotingNew')
+        throw new Error('Equal-weight voting is supported only by HybridVoting.');
+    if ((quorum !== 0 || p.equalWeight) && hatIds.length === 0)
+        throw new Error('Quorum overrides and equal-weight voting require restricted subject IDs.');
+    const v2 = p.quorumOverride !== undefined || p.equalWeight === true;
     return {
         to: p.votingAddress,
         abi: (0, contracts_1.getAbi)(p.votingAbiName),
-        method: 'createProposal',
+        method: v2 ? 'createProposalV2' : 'createProposal',
         args: [
             (0, encoding_1.stringToBytes)(p.title),
             p.descriptionHash,
@@ -51,6 +68,7 @@ function buildGovernanceProposal(p) {
             p.numOptions,
             batchTuples,
             hatIds,
+            ...(v2 ? [quorum, ...(p.votingAbiName === 'HybridVotingNew' ? [p.equalWeight ?? false] : [])] : []),
         ],
         meta: {
             domain: p.domain ?? 'vote',

package/dist/tx/index.d.ts

@@ -4,7 +4,6 @@
  */
 export * from './intent';
 export * as education from './education';
-export * as eligibility from './eligibility';
 export * as governance from './governance';
 export * as org from './org';
 export * as paymaster from './paymaster';
@@ -15,3 +14,4 @@ export * as treasury from './treasury';
 export * as user from './user';
 export * as vote from './vote';
 export * as zkemail from './zkemail';
+export * as authority from './authority';