@poa-box/core 0.1.0 → 1.0.0

package/dist/tx/eligibility.js

@@ -1,818 +0,0 @@
-"use strict";
-/**
- * EligibilityModuleNew transaction builders — the vouch/* and role/* write
- * surface (both CLI domains write to the same module).
- *
- * Level 1 (`build*`): pure, synchronous — resolved module address + prepared
- * values in, TxIntent out. ALL argument encoding lives here and matches the
- * CLI's executeTx calls byte-for-byte.
- *
- * Level 2 (`*Intent`): async — resolve the org's eligibility module via the
- * subgraph, replicate the CLI's derivations (role-name→hatId, single-vs-batch
- * method choice, metadata pinning for role applications, the audit-M-03
- * vouch/default-eligibility conflict guard), then delegate to Level 1.
- *
- * NOT ported into builders (host concerns, run them via reads/eligibility +
- * preflight.ts exactly as the CLI does): requireSuperAdmin, the vouch-for /
- * claim / revoke revert-prediction gates, gas-balance checks, idempotency,
- * and confirmation prompts. The ONE preflight that IS ported is the M-03
- * conflict guard in configureVouchingIntent / setDefaultEligibilityIntent,
- * because its state check + callStatic simulation is the only version-proof
- * predictor of the DefaultEligibilityConflictsWithVouch revert and the CLI
- * enforces it inline (src/commands/vouch/config.ts,
- * src/commands/role/eligibility.ts).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildVouchFor = buildVouchFor;
-exports.buildClaimVouchedHat = buildClaimVouchedHat;
-exports.buildRevokeVouch = buildRevokeVouch;
-exports.buildResetVouches = buildResetVouches;
-exports.buildClearWearerVouches = buildClearWearerVouches;
-exports.buildConfigureVouching = buildConfigureVouching;
-exports.buildApplyForRole = buildApplyForRole;
-exports.buildWithdrawApplication = buildWithdrawApplication;
-exports.buildCreateHatWithEligibility = buildCreateHatWithEligibility;
-exports.buildSetWearerEligibility = buildSetWearerEligibility;
-exports.buildBatchSetWearerEligibility = buildBatchSetWearerEligibility;
-exports.buildClearWearerEligibility = buildClearWearerEligibility;
-exports.buildSetDefaultEligibility = buildSetDefaultEligibility;
-exports.buildTransferSuperAdmin = buildTransferSuperAdmin;
-exports.buildMintHatToAddress = buildMintHatToAddress;
-exports.buildBatchMintHats = buildBatchMintHats;
-exports.buildPause = buildPause;
-exports.buildUnpause = buildUnpause;
-exports.buildSetUserJoinTime = buildSetUserJoinTime;
-exports.buildSetUserJoinTimeNow = buildSetUserJoinTimeNow;
-exports.vouchForIntent = vouchForIntent;
-exports.claimVouchedHatIntent = claimVouchedHatIntent;
-exports.revokeVouchIntent = revokeVouchIntent;
-exports.resetVouchesIntent = resetVouchesIntent;
-exports.configureVouchingIntent = configureVouchingIntent;
-exports.applyForRoleIntent = applyForRoleIntent;
-exports.withdrawApplicationIntent = withdrawApplicationIntent;
-exports.parseMintTo = parseMintTo;
-exports.createHatWithEligibilityIntent = createHatWithEligibilityIntent;
-exports.setWearerEligibilityIntent = setWearerEligibilityIntent;
-exports.batchSetWearerEligibilityIntent = batchSetWearerEligibilityIntent;
-exports.clearWearerEligibilityIntent = clearWearerEligibilityIntent;
-exports.setDefaultEligibilityIntent = setDefaultEligibilityIntent;
-exports.transferSuperAdminIntent = transferSuperAdminIntent;
-exports.mintHatsIntent = mintHatsIntent;
-exports.pauseIntent = pauseIntent;
-exports.unpauseIntent = unpauseIntent;
-exports.setUserJoinTimeIntent = setUserJoinTimeIntent;
-const contracts_1 = require("../contracts");
-const errors_1 = require("../errors");
-const exit_codes_1 = require("../exit-codes");
-const ipfs_1 = require("../ipfs");
-const encoding_1 = require("../encoding");
-const validation_1 = require("../validation");
-const perms_1 = require("../perms");
-const role_1 = require("../metadata/role");
-const eligibility_1 = require("../reads/eligibility");
-const ABI_NAME = 'EligibilityModuleNew';
-/** Port of `pop vouch for` — src/commands/vouch/for.ts: vouchFor(wearer, hatId). */
-function buildVouchFor(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'vouchFor',
-        args: [a.wearer, a.hatId],
-        meta: {
-            domain: 'vouch',
-            action: 'for',
-            orgId: a.orgId,
-            summary: { wearer: a.wearer, hat: String(a.hatId) },
-        },
-    };
-}
-/**
- * Port of `pop vouch claim` — src/commands/vouch/claim.ts:
- * claimVouchedHat(hatId). Claim-based pattern — quorum never auto-mints.
- */
-function buildClaimVouchedHat(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'claimVouchedHat',
-        args: [a.hatId],
-        meta: {
-            domain: 'vouch',
-            action: 'claim',
-            orgId: a.orgId,
-            summary: { hat: String(a.hatId) },
-        },
-    };
-}
-/** Port of `pop vouch revoke` — src/commands/vouch/revoke.ts: revokeVouch(wearer, hatId). */
-function buildRevokeVouch(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'revokeVouch',
-        args: [a.wearer, a.hatId],
-        meta: {
-            domain: 'vouch',
-            action: 'revoke',
-            orgId: a.orgId,
-            summary: { wearer: a.wearer, hat: String(a.hatId) },
-        },
-    };
-}
-/**
- * Port of `pop vouch reset` (no --wearer) — src/commands/vouch/reset.ts:
- * resetVouches(hatId). DESTRUCTIVE, superAdmin-only: DELETES the hat's
- * VouchConfig (vouching becomes disabled) and bumps the vouch epoch so every
- * existing vouch for the hat is invalidated.
- */
-function buildResetVouches(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'resetVouches',
-        args: [a.hatId],
-        meta: {
-            domain: 'vouch',
-            action: 'reset',
-            orgId: a.orgId,
-            summary: { hat: String(a.hatId), scope: 'whole-hat' },
-        },
-    };
-}
-/**
- * Port of `pop vouch reset --wearer` — src/commands/vouch/reset.ts:
- * clearWearerVouches(wearer, hatId). Surgical per-wearer invalidation
- * (sentinel epoch + count wipe); other wearers' vouches and the hat's config
- * are untouched. superAdmin-only.
- */
-function buildClearWearerVouches(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'clearWearerVouches',
-        args: [a.wearer, a.hatId],
-        meta: {
-            domain: 'vouch',
-            action: 'clear-wearer',
-            orgId: a.orgId,
-            summary: { hat: String(a.hatId), wearer: a.wearer, scope: 'single-wearer' },
-        },
-    };
-}
-/**
- * Port of `pop vouch config set` — src/commands/vouch/config.ts:
- * configureVouching(hatId, quorum, membershipHatId, combineWithHierarchy).
- * superAdmin-only; configuring bumps the hat's vouch epoch, invalidating all
- * existing vouches.
- */
-function buildConfigureVouching(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'configureVouching',
-        args: [a.hatId, a.quorum, a.membershipHatId, a.combineWithHierarchy],
-        meta: {
-            domain: 'vouch',
-            action: 'config-set',
-            orgId: a.orgId,
-            summary: {
-                hat: String(a.hatId),
-                quorum: a.quorum,
-                membershipHat: String(a.membershipHatId),
-                combineWithHierarchy: a.combineWithHierarchy,
-            },
-        },
-    };
-}
-/**
- * Port of `pop role apply` — src/commands/role/apply.ts:
- * applyForRole(hatId, applicationHash). Signaling only — grants no
- * eligibility.
- */
-function buildApplyForRole(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'applyForRole',
-        args: [a.hatId, a.applicationHash],
-        meta: {
-            domain: 'role',
-            action: 'apply',
-            orgId: a.orgId,
-            summary: { hat: String(a.hatId) },
-        },
-    };
-}
-/**
- * Port of `pop role withdraw-application` —
- * src/commands/role/withdraw-application.ts: withdrawApplication(hatId).
- */
-function buildWithdrawApplication(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'withdrawApplication',
-        args: [a.hatId],
-        meta: {
-            domain: 'role',
-            action: 'withdraw-application',
-            orgId: a.orgId,
-            summary: { hat: String(a.hatId) },
-        },
-    };
-}
-/**
- * Port of `pop role create` — src/commands/role/create.ts:
- * createHatWithEligibility(CreateHatParams). The tuple is built in EXACT ABI
- * order (verified in abi CreateHatParams components):
- *   (uint256 parentHatId, string details, uint32 maxSupply, bool _mutable,
- *    string imageURI, bool defaultEligible, bool defaultStanding,
- *    address[] mintToAddresses, bool[] wearerEligibleFlags,
- *    bool[] wearerStandingFlags)
- * superAdmin-only.
- */
-function buildCreateHatWithEligibility(a) {
-    const mintTo = a.mintTo ?? [];
-    const eligibleFlags = a.wearerEligibleFlags ?? mintTo.map(() => true);
-    const standingFlags = a.wearerStandingFlags ?? mintTo.map(() => true);
-    if (eligibleFlags.length !== mintTo.length || standingFlags.length !== mintTo.length) {
-        throw new errors_1.CliError('wearerEligibleFlags/wearerStandingFlags must match mintTo length.', exit_codes_1.EXIT.USAGE);
-    }
-    // CreateHatParams tuple — MUST match ABI component order (see doc comment).
-    const params = [
-        a.parentHatId, // parentHatId (uint256)
-        a.details, // details (string)
-        a.maxSupply, // maxSupply (uint32)
-        a.mutable, // _mutable (bool)
-        a.imageURI ?? '', // imageURI (string)
-        a.defaultEligible, // defaultEligible (bool)
-        a.defaultStanding, // defaultStanding (bool)
-        mintTo, // mintToAddresses (address[])
-        eligibleFlags, // wearerEligibleFlags (bool[])
-        standingFlags, // wearerStandingFlags (bool[])
-    ];
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'createHatWithEligibility',
-        args: [params],
-        meta: {
-            domain: 'role',
-            action: 'create',
-            orgId: a.orgId,
-            summary: {
-                name: a.details,
-                parentHat: String(a.parentHatId),
-                maxSupply: a.maxSupply,
-                mintTo: mintTo.length,
-            },
-        },
-    };
-}
-/**
- * Port of `pop role eligibility set` (single-wearer) —
- * src/commands/role/eligibility.ts:
- * setWearerEligibility(wearer, hatId, eligible, standing). superAdmin-only.
- */
-function buildSetWearerEligibility(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'setWearerEligibility',
-        args: [a.wearer, a.hatId, a.eligible, a.standing],
-        meta: {
-            domain: 'role',
-            action: 'eligibility-set',
-            orgId: a.orgId,
-            summary: { hat: String(a.hatId), wearer: a.wearer, eligible: a.eligible, standing: a.standing },
-        },
-    };
-}
-/**
- * Port of `pop role eligibility set --file` (batch) —
- * src/commands/role/eligibility.ts:
- * batchSetWearerEligibility(hatId, wearers[], eligibleFlags[], standingFlags[]).
- * superAdmin-only.
- */
-function buildBatchSetWearerEligibility(a) {
-    if (a.eligibleFlags.length !== a.wearers.length || a.standingFlags.length !== a.wearers.length) {
-        throw new errors_1.CliError('eligibleFlags/standingFlags must match wearers length.', exit_codes_1.EXIT.USAGE);
-    }
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'batchSetWearerEligibility',
-        args: [a.hatId, a.wearers, a.eligibleFlags, a.standingFlags],
-        meta: {
-            domain: 'role',
-            action: 'eligibility-set-batch',
-            orgId: a.orgId,
-            summary: { hat: String(a.hatId), count: a.wearers.length },
-        },
-    };
-}
-/**
- * Port of `pop role eligibility clear` — src/commands/role/eligibility.ts:
- * clearWearerEligibility(wearer, hatId) — removes the wearer-specific rule so
- * the hat DEFAULTS apply again. superAdmin-only.
- */
-function buildClearWearerEligibility(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'clearWearerEligibility',
-        args: [a.wearer, a.hatId],
-        meta: {
-            domain: 'role',
-            action: 'eligibility-clear',
-            orgId: a.orgId,
-            summary: { hat: String(a.hatId), wearer: a.wearer },
-        },
-    };
-}
-/**
- * Port of `pop role eligibility set-default` —
- * src/commands/role/eligibility.ts:
- * setDefaultEligibility(hatId, eligible, standing). superAdmin-only. See
- * setDefaultEligibilityIntent for the audit-M-03 conflict guard the CLI runs
- * before this write.
- */
-function buildSetDefaultEligibility(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'setDefaultEligibility',
-        args: [a.hatId, a.eligible, a.standing],
-        meta: {
-            domain: 'role',
-            action: 'eligibility-set-default',
-            orgId: a.orgId,
-            summary: { hat: String(a.hatId), eligible: a.eligible, standing: a.standing },
-        },
-    };
-}
-/**
- * Port of `pop role admin transfer` — src/commands/role/admin.ts:
- * transferSuperAdmin(newSuperAdmin). DESTRUCTIVE — hands over the ENTIRE
- * module (roles, eligibility, vouching, pause). superAdmin-only.
- */
-function buildTransferSuperAdmin(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'transferSuperAdmin',
-        args: [a.newSuperAdmin],
-        meta: {
-            domain: 'role',
-            action: 'admin-transfer',
-            orgId: a.orgId,
-            summary: { newSuperAdmin: a.newSuperAdmin },
-        },
-    };
-}
-/**
- * Port of `pop role admin mint` (single wearer) — src/commands/role/admin.ts:
- * mintHatToAddress(hatId, wearer). superAdmin-only.
- */
-function buildMintHatToAddress(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'mintHatToAddress',
-        args: [a.hatId, a.wearer],
-        meta: {
-            domain: 'role',
-            action: 'admin-mint',
-            orgId: a.orgId,
-            summary: { hat: String(a.hatId), wearer: a.wearer },
-        },
-    };
-}
-/**
- * Port of `pop role admin mint` (comma-separated wearers) —
- * src/commands/role/admin.ts: batchMintHats(hatIds[], wearers[]). The CLI
- * replicates ONE hat per wearer (`wearers.map(() => hatId)`); mintHatsIntent
- * derives that. superAdmin-only.
- */
-function buildBatchMintHats(a) {
-    if (a.hatIds.length !== a.wearers.length) {
-        throw new errors_1.CliError('hatIds must match wearers length.', exit_codes_1.EXIT.USAGE);
-    }
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'batchMintHats',
-        args: [a.hatIds, a.wearers],
-        meta: {
-            domain: 'role',
-            action: 'admin-mint-batch',
-            orgId: a.orgId,
-            summary: { count: a.wearers.length },
-        },
-    };
-}
-/** Port of `pop role admin pause` — src/commands/role/admin.ts: pause(). superAdmin-only. */
-function buildPause(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'pause',
-        args: [],
-        meta: {
-            domain: 'role',
-            action: 'admin-pause',
-            orgId: a.orgId,
-            summary: { module: a.eligibilityModuleAddress },
-        },
-    };
-}
-/** Port of `pop role admin unpause` — src/commands/role/admin.ts: unpause(). superAdmin-only. */
-function buildUnpause(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'unpause',
-        args: [],
-        meta: {
-            domain: 'role',
-            action: 'admin-unpause',
-            orgId: a.orgId,
-            summary: { module: a.eligibilityModuleAddress },
-        },
-    };
-}
-/**
- * Port of `pop role admin set-join-time --timestamp` —
- * src/commands/role/admin.ts: setUserJoinTime(user, joinTime). Governs the
- * new-account vouching grace. superAdmin-only.
- */
-function buildSetUserJoinTime(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'setUserJoinTime',
-        args: [a.user, a.joinTime],
-        meta: {
-            domain: 'role',
-            action: 'admin-set-join-time',
-            orgId: a.orgId,
-            summary: { user: a.user, timestamp: String(a.joinTime) },
-        },
-    };
-}
-/**
- * Port of `pop role admin set-join-time` (no --timestamp) —
- * src/commands/role/admin.ts: setUserJoinTimeNow(user) — uses the current
- * block time. superAdmin-only.
- */
-function buildSetUserJoinTimeNow(a) {
-    return {
-        to: a.eligibilityModuleAddress,
-        abi: (0, contracts_1.getAbi)(ABI_NAME),
-        method: 'setUserJoinTimeNow',
-        args: [a.user],
-        meta: {
-            domain: 'role',
-            action: 'admin-set-join-time',
-            orgId: a.orgId,
-            summary: { user: a.user, timestamp: 'now' },
-        },
-    };
-}
-/** Port of `pop vouch for` — src/commands/vouch/for.ts (org + role-name resolution). */
-async function vouchForIntent(ctx, params) {
-    const wearer = (0, validation_1.requireAddress)(params.wearer, 'address');
-    let hatId = params.hat !== undefined ? String(params.hat) : undefined;
-    if (!hatId && params.role) {
-        hatId = await (0, eligibility_1.resolveRoleNameToHatId)(ctx.client, params.org, params.role, ctx.chainId);
-    }
-    if (!hatId) {
-        throw new errors_1.CliError('Either --hat or --role is required', exit_codes_1.EXIT.USAGE);
-    }
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    if (params.voucher && wearer.toLowerCase() === params.voucher.toLowerCase()) {
-        throw new errors_1.PreconditionError('You cannot vouch for yourself.', 'Ask another member holding the membership hat to vouch for you.');
-    }
-    return buildVouchFor({ eligibilityModuleAddress, wearer, hatId, orgId });
-}
-/** Port of `pop vouch claim` — src/commands/vouch/claim.ts (org resolution). */
-async function claimVouchedHatIntent(ctx, params) {
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    return buildClaimVouchedHat({ eligibilityModuleAddress, hatId: String(params.hat), orgId });
-}
-/** Port of `pop vouch revoke` — src/commands/vouch/revoke.ts (org resolution). */
-async function revokeVouchIntent(ctx, params) {
-    const wearer = (0, validation_1.requireAddress)(params.wearer, 'address');
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    return buildRevokeVouch({ eligibilityModuleAddress, wearer, hatId: String(params.hat), orgId });
-}
-/**
- * Port of `pop vouch reset` — src/commands/vouch/reset.ts. Derives the method
- * exactly as the CLI does: --wearer → clearWearerVouches (surgical), no
- * --wearer → resetVouches (deletes the VouchConfig + bumps the epoch).
- * DESTRUCTIVE, superAdmin-only.
- */
-async function resetVouchesIntent(ctx, params) {
-    const hatId = (0, eligibility_1.parseHatId)(params.hat);
-    const wearer = params.wearer ? (0, validation_1.requireAddress)(params.wearer, 'wearer') : undefined;
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    return wearer
-        ? buildClearWearerVouches({ eligibilityModuleAddress, wearer, hatId, orgId })
-        : buildResetVouches({ eligibilityModuleAddress, hatId, orgId });
-}
-/**
- * Port of `pop vouch config set` — src/commands/vouch/config.ts, including the
- * audit-M-03 reverse-direction guard: enabling vouching WITH combine-hierarchy
- * on a hat that is already default-eligible reverts
- * DefaultEligibilityConflictsWithVouch on modules that implement the check —
- * everyone is eligible anyway, so the quorum would be a no-op. The state is
- * detected via getDefaultRules, then the exact call is simulated from `from`
- * (state alone is version-ambiguous — deployed v6 modules accept it). Only a
- * contract revert blocks; transport failures degrade and let gas estimation be
- * the real gate. Requires ctx.provider + params.from to run.
- */
-async function configureVouchingIntent(ctx, params) {
-    const hatId = (0, eligibility_1.parseHatId)(params.hat);
-    const membershipHatId = (0, eligibility_1.parseHatId)(params.membershipHat);
-    const quorum = params.quorum;
-    if (!Number.isInteger(quorum) || quorum < 0 || quorum > 0xffffffff) {
-        throw new errors_1.CliError(`Invalid --quorum ${quorum}.`, exit_codes_1.EXIT.USAGE, 'Pass a non-negative integer (uint32).');
-    }
-    const combine = Boolean(params.combineHierarchy);
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    const needsDefaultRules = combine && quorum > 0;
-    if (params.preflight !== false && needsDefaultRules && ctx.provider && params.from) {
-        const [rulesResult] = await (0, eligibility_1.batchEligibilityReadsSettled)(ctx.provider, eligibilityModuleAddress, [
-            { fn: 'getDefaultRules', args: [hatId] },
-        ]);
-        // A failed read (older module without the getter) downgrades to a skipped
-        // soft check rather than blocking the write — same as the CLI.
-        const rules = rulesResult.status === 'fulfilled' ? rulesResult.value : null;
-        if (rules !== null && Boolean(rules.eligible ?? rules[0])) {
-            // The STATE conflicts, but only a module implementing the M-03 revert rejects the
-            // write — the deployed v6 modules do NOT. Simulate the exact call instead — the
-            // only version-proof revert predictor.
-            const sim = (0, contracts_1.createReadContract)(eligibilityModuleAddress, ABI_NAME, ctx.provider);
-            try {
-                await sim.callStatic.configureVouching(hatId, quorum, membershipHatId, combine, { from: params.from });
-                // Module accepts the write anyway (the CLI warns and proceeds).
-            }
-            catch (simErr) {
-                // Only a CONTRACT revert proves the module enforces M-03; a transport
-                // failure proves nothing and must not block a valid write.
-                if (simErr?.code === 'CALL_EXCEPTION' || simErr?.code === 'UNPREDICTABLE_GAS_LIMIT') {
-                    throw new errors_1.PreconditionError(`Hat ${hatId} is default-eligible — everyone already qualifies — so a vouch quorum `
-                        + 'combined with the hat hierarchy would have no effect, and the module rejects it.', `Close the hat first: pop role eligibility set-default --hat ${hatId} --no-eligible, `
-                        + 'or re-run without --combine-hierarchy.');
-                }
-            }
-        }
-    }
-    return buildConfigureVouching({
-        eligibilityModuleAddress,
-        hatId,
-        quorum,
-        membershipHatId,
-        combineWithHierarchy: combine,
-        orgId,
-    });
-}
-/**
- * Port of `pop role apply` — src/commands/role/apply.ts. Pins the
- * {notes, experience, appliedAt} application metadata (metadata/role.ts —
- * key order preserved for frontend/subgraph parity), converts the CID to
- * bytes32, then delegates to buildApplyForRole. The pinned document rides in
- * meta.ipfs.
- */
-async function applyForRoleIntent(ctx, params) {
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    const metadata = (0, role_1.buildRoleApplicationMetadata)({
-        notes: params.notes,
-        experience: params.experience,
-        appliedAt: params.appliedAt,
-    });
-    const cid = await (0, ipfs_1.pinJson)((0, role_1.serializeRoleApplicationMetadata)(metadata), ctx.ipfs);
-    const applicationHash = (0, encoding_1.ipfsCidToBytes32)(cid);
-    const intent = buildApplyForRole({
-        eligibilityModuleAddress,
-        hatId: String(params.hat),
-        applicationHash,
-        orgId,
-    });
-    intent.meta.ipfs = { cid, metadata };
-    return intent;
-}
-/**
- * Port of `pop role withdraw-application` —
- * src/commands/role/withdraw-application.ts (org resolution).
- */
-async function withdrawApplicationIntent(ctx, params) {
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    return buildWithdrawApplication({ eligibilityModuleAddress, hatId: String(params.hat), orgId });
-}
-/** Parse "--mint-to a,b,c" into checksummed addresses (empty when omitted). */
-function parseMintTo(input) {
-    if (!input)
-        return [];
-    return input
-        .split(',')
-        .map(s => s.trim())
-        .filter(s => s.length > 0)
-        .map(addr => (0, validation_1.requireAddress)(addr, 'mint-to'));
-}
-/**
- * Port of `pop role create` — src/commands/role/create.ts: validates
- * max-supply (uint32), parses/checksums --mint-to, forces the per-mint-to
- * eligible/standing flags TRUE, then delegates to
- * buildCreateHatWithEligibility. superAdmin-only.
- */
-async function createHatWithEligibilityIntent(ctx, params) {
-    const parentHatId = (0, eligibility_1.parseHatId)(params.parentHat);
-    const maxSupply = params.maxSupply ?? 1000;
-    if (!Number.isInteger(maxSupply) || maxSupply <= 0 || maxSupply > 0xffffffff) {
-        throw new errors_1.CliError(`Invalid --max-supply ${maxSupply}.`, exit_codes_1.EXIT.USAGE, 'Pass a positive integer that fits uint32.');
-    }
-    const mintTo = Array.isArray(params.mintTo)
-        ? params.mintTo.map(addr => (0, validation_1.requireAddress)(addr, 'mint-to'))
-        : parseMintTo(params.mintTo);
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    return buildCreateHatWithEligibility({
-        eligibilityModuleAddress,
-        parentHatId,
-        details: params.name,
-        maxSupply,
-        mutable: Boolean(params.mutable),
-        imageURI: params.image ?? '',
-        defaultEligible: Boolean(params.defaultEligible),
-        defaultStanding: Boolean(params.defaultStanding),
-        mintTo,
-        orgId,
-    });
-}
-/**
- * Port of `pop role eligibility set` (single wearer) —
- * src/commands/role/eligibility.ts. superAdmin-only.
- */
-async function setWearerEligibilityIntent(ctx, params) {
-    const hatId = (0, eligibility_1.parseHatId)(params.hat);
-    const wearer = (0, validation_1.requireAddress)(params.wearer, 'wearer');
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    return buildSetWearerEligibility({
-        eligibilityModuleAddress,
-        wearer,
-        hatId,
-        eligible: params.eligible !== false,
-        standing: params.standing !== false,
-        orgId,
-    });
-}
-/**
- * Port of `pop role eligibility set --file` —
- * src/commands/role/eligibility.ts: validates the entries (the CLI's batch
- * JSON shape, minus the fs read — the host loads the file), defaults
- * eligible/standing to true, and encodes
- * batchSetWearerEligibility(hatId, wearers[], eligibles[], standings[]).
- * superAdmin-only.
- */
-async function batchSetWearerEligibilityIntent(ctx, params) {
-    const hatId = (0, eligibility_1.parseHatId)(params.hat);
-    if (!Array.isArray(params.entries) || params.entries.length === 0) {
-        throw new errors_1.CliError('Batch file must be a non-empty JSON array.', exit_codes_1.EXIT.USAGE, 'Expected: [{"wearer": "0x…", "eligible": true, "standing": true}, …]');
-    }
-    const batch = params.entries.map((entry, i) => {
-        if (!entry || typeof entry !== 'object' || !entry.wearer) {
-            throw new errors_1.CliError(`Batch entry ${i} is missing "wearer".`, exit_codes_1.EXIT.USAGE);
-        }
-        return {
-            wearer: (0, validation_1.requireAddress)(String(entry.wearer), `file entry ${i} wearer`),
-            eligible: entry.eligible === undefined ? true : Boolean(entry.eligible),
-            standing: entry.standing === undefined ? true : Boolean(entry.standing),
-        };
-    });
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    return buildBatchSetWearerEligibility({
-        eligibilityModuleAddress,
-        hatId,
-        wearers: batch.map(b => b.wearer),
-        eligibleFlags: batch.map(b => b.eligible),
-        standingFlags: batch.map(b => b.standing),
-        orgId,
-    });
-}
-/**
- * Port of `pop role eligibility clear` — src/commands/role/eligibility.ts.
- * superAdmin-only.
- */
-async function clearWearerEligibilityIntent(ctx, params) {
-    const hatId = (0, eligibility_1.parseHatId)(params.hat);
-    const wearer = (0, validation_1.requireAddress)(params.wearer, 'wearer');
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    return buildClearWearerEligibility({ eligibilityModuleAddress, wearer, hatId, orgId });
-}
-/**
- * Port of `pop role eligibility set-default` —
- * src/commands/role/eligibility.ts, including the audit-M-03 guard: making a
- * hat default-eligible while it uses vouching WITH combineWithHierarchy
- * reverts DefaultEligibilityConflictsWithVouch — an open hat makes the vouch
- * quorum meaningless. The state is detected via getVouchConfig +
- * vouchConflictsWithDefaultEligibility (../perms — the browser-pure rule the
- * CLI uses), then the exact call is simulated from `from`, because the state
- * check alone is version-ambiguous: the deployed v6 modules ACCEPT the write
- * (verified live — 17/19 live VouchConfig rows are in the "conflicting"
- * state, so blocking on state alone would refuse a valid write on nearly
- * every hat). Only a contract revert blocks; transport failures degrade and
- * let gas estimation be the real gate. Requires ctx.provider + params.from.
- * superAdmin-only.
- */
-async function setDefaultEligibilityIntent(ctx, params) {
-    const hatId = (0, eligibility_1.parseHatId)(params.hat);
-    const eligible = params.eligible !== false;
-    const standing = params.standing !== false;
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    if (params.preflight !== false && eligible && ctx.provider && params.from) {
-        const [configResult] = await (0, eligibility_1.batchEligibilityReadsSettled)(ctx.provider, eligibilityModuleAddress, [
-            { fn: 'getVouchConfig', args: [hatId] },
-        ]);
-        // A failed read downgrades to a skipped soft check rather than blocking
-        // the write — same as the CLI.
-        const vc = configResult.status === 'fulfilled' ? configResult.value : null;
-        if (vc !== null && (0, perms_1.vouchConflictsWithDefaultEligibility)(Number(vc.flags), Number(vc.quorum), true)) {
-            // The STATE conflicts, but only a module that implements the M-03 revert
-            // actually rejects the write. Simulate the exact call instead — the only
-            // version-proof revert predictor.
-            const sim = (0, contracts_1.createReadContract)(eligibilityModuleAddress, ABI_NAME, ctx.provider);
-            try {
-                await sim.callStatic.setDefaultEligibility(hatId, eligible, standing, { from: params.from });
-                // Module accepts the write anyway (the CLI warns and proceeds).
-            }
-            catch (simErr) {
-                // Only a CONTRACT revert proves the module enforces M-03; a transport
-                // failure proves nothing and must not block a valid write.
-                if (simErr?.code === 'CALL_EXCEPTION' || simErr?.code === 'UNPREDICTABLE_GAS_LIMIT') {
-                    throw new errors_1.PreconditionError(`Hat ${hatId} uses vouching with combine-hierarchy (quorum ${vc.quorum}). Making it `
-                        + 'default-eligible would make that quorum a no-op, so the module rejects it.', 'Drop combine-hierarchy or disable vouching first: '
-                        + `pop vouch config set --hat ${hatId} --quorum 0`);
-                }
-            }
-        }
-    }
-    return buildSetDefaultEligibility({ eligibilityModuleAddress, hatId, eligible, standing, orgId });
-}
-/**
- * Port of `pop role admin transfer` — src/commands/role/admin.ts.
- * DESTRUCTIVE, superAdmin-only.
- */
-async function transferSuperAdminIntent(ctx, params) {
-    const to = (0, validation_1.requireAddress)(params.to, 'to');
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    if (params.from && to.toLowerCase() === params.from.toLowerCase()) {
-        throw new errors_1.PreconditionError('The target is already the superAdmin (you).', 'Pass a different --to address.');
-    }
-    return buildTransferSuperAdmin({ eligibilityModuleAddress, newSuperAdmin: to, orgId });
-}
-/**
- * Port of `pop role admin mint` — src/commands/role/admin.ts. Derives the
- * method exactly as the CLI does: one wearer → mintHatToAddress(hat, wearer);
- * several → batchMintHats(hat replicated per wearer, wearers).
- * superAdmin-only.
- */
-async function mintHatsIntent(ctx, params) {
-    const hatId = (0, eligibility_1.parseHatId)(params.hat);
-    const wearers = (Array.isArray(params.wearer) ? params.wearer : String(params.wearer).split(','))
-        .map(s => s.trim())
-        .filter(s => s.length > 0)
-        .map(addr => (0, validation_1.requireAddress)(addr, 'wearer'));
-    if (wearers.length === 0) {
-        throw new errors_1.CliError('No valid --wearer addresses provided.', exit_codes_1.EXIT.USAGE);
-    }
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    return wearers.length === 1
-        ? buildMintHatToAddress({ eligibilityModuleAddress, hatId, wearer: wearers[0], orgId })
-        : buildBatchMintHats({ eligibilityModuleAddress, hatIds: wearers.map(() => hatId), wearers, orgId });
-}
-/** Port of `pop role admin pause` — src/commands/role/admin.ts. superAdmin-only. */
-async function pauseIntent(ctx, params) {
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    return buildPause({ eligibilityModuleAddress, orgId });
-}
-/** Port of `pop role admin unpause` — src/commands/role/admin.ts. superAdmin-only. */
-async function unpauseIntent(ctx, params) {
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    return buildUnpause({ eligibilityModuleAddress, orgId });
-}
-/**
- * Port of `pop role admin set-join-time` — src/commands/role/admin.ts.
- * Derives the method exactly as the CLI does: --timestamp →
- * setUserJoinTime(user, ts); omitted → setUserJoinTimeNow(user).
- * superAdmin-only.
- */
-async function setUserJoinTimeIntent(ctx, params) {
-    const user = (0, validation_1.requireAddress)(params.user, 'user');
-    if (params.timestamp !== undefined && (!Number.isInteger(params.timestamp) || params.timestamp < 0)) {
-        throw new errors_1.CliError(`Invalid --timestamp ${params.timestamp}.`, exit_codes_1.EXIT.USAGE, 'Pass unix seconds, or omit to use the current block time.');
-    }
-    const { orgId, eligibilityModuleAddress } = await (0, eligibility_1.resolveEligibilityModule)(ctx.client, params.org, ctx.chainId);
-    return params.timestamp !== undefined
-        ? buildSetUserJoinTime({ eligibilityModuleAddress, user, joinTime: params.timestamp, orgId })
-        : buildSetUserJoinTimeNow({ eligibilityModuleAddress, user, orgId });
-}