@poa-box/core 0.1.0

package/dist/tx/governance.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Governance wraps — the shared createProposal builder.
+ *
+ * Every governance-side change in POP (~10 CLI commands) broadcasts the SAME
+ * method: `createProposal(titleBytes, descriptionHash, durationMinutes,
+ * numOptions, batches, hatIds)` on a HybridVoting or DirectDemocracyVoting
+ * module, where option 0's batch carries `[target, value, calldata][]` triples
+ * that the Executor runs if option 0 wins.
+ *
+ * Encoding parity notes (verified against src/commands/vote/create.ts and
+ * src/commands/vote/propose-quorum.ts):
+ *   - title is encoded with stringToBytes (UTF-8 Uint8Array), NOT bytes32
+ *   - each batch entry is the positional tuple [target, BigNumber(value), data]
+ *   - a proposal with NO execution calls passes `batches: []` — the empty
+ *     outer array, not [[], []] (vote create only builds per-option batches
+ *     when --calls is given). Wrap commands always pass [option0Calls, []].
+ *   - hatIds default to [] and must be BigNumbers/strings — real Hats IDs
+ *     exceed 2^53 and are mangled by Number
+ *
+ * First consumers: vote create / propose-quorum / propose-config / classes
+ * propose (tx/vote.ts), task perms propose-global, org set-metadata-admin,
+ * project propose. Other agents import these from './governance'.
+ */
+import { ethers } from 'ethers';
+import type { TxIntent } from './intent';
+/** One execution call in an option batch: encoded as [target, value, calldata]. */
+export interface ExecutionCall {
+    target: string;
+    value: ethers.BigNumberish;
+    calldata: string;
+}
+export interface GovernanceWrapParams {
+    /** Hybrid or DD voting module address (the proposal is created on it). */
+    votingAddress: string;
+    votingAbiName: 'HybridVotingNew' | 'DirectDemocracyVotingNew';
+    /** Proposal title — encoded with stringToBytes. */
+    title: string;
+    /** bytes32 — ipfsCidToBytes32 of the pinned proposal metadata. */
+    descriptionHash: string;
+    durationMinutes: ethers.BigNumberish;
+    /** 2 for yes/no wraps. */
+    numOptions: number;
+    /**
+     * Option-indexed execution batches. CLI wraps use [option0Calls, []];
+     * a call-free proposal uses [] (see module doc — the empty-array quirk).
+     */
+    batches: ExecutionCall[][];
+    /** Restricted-voting hats; [] default. */
+    hatIds?: ethers.BigNumberish[];
+    orgId?: string;
+    /** meta.action override (default 'create'). */
+    action?: string;
+    /** meta.domain override for non-vote consumers (default 'vote'). */
+    domain?: string;
+    summary?: Record<string, unknown>;
+    /** meta.ipfs passthrough for builders that pinned the metadata themselves. */
+    ipfs?: {
+        cid: string;
+        metadata: unknown;
+    };
+}
+/**
+ * Level-1 pure builder for `createProposal` — port of the tx built by
+ * `pop vote create` (src/commands/vote/create.ts) and shared verbatim by
+ * every governance-wrap command (propose-quorum, propose-config, classes
+ * propose, perms propose-global, set-metadata-admin, project propose).
+ */
+export declare function buildGovernanceProposal(p: GovernanceWrapParams): TxIntent;
+/**
+ * Encode one execution call for an option batch: calldata via the named ABI's
+ * Interface (both voting ABIs and TaskManagerNew carry exactly one fragment
+ * per method name, so this matches the CLI's inline-fragment encoding
+ * byte-for-byte).
+ */
+export declare function encodeExecutorCall(abiName: string, target: string, method: string, args: unknown[], value?: ethers.BigNumberish): ExecutionCall;
+/**
+ * Extract the created proposal ID from parsed receipt logs — the CLI's
+ * `result.logs?.find(l => l.name === 'NewProposal' || l.name === 'NewHatProposal')`
+ * shared by every createProposal site. Accepts any parsed-log shape
+ * (ethers LogDescription[] / TxResult.logs).
+ */
+export declare function parseProposalCreatedLogs(logs: Array<{
+    name: string;
+    args?: any;
+}> | undefined | null): string | undefined;

package/dist/tx/governance.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Governance wraps — the shared createProposal builder.
+ *
+ * Every governance-side change in POP (~10 CLI commands) broadcasts the SAME
+ * method: `createProposal(titleBytes, descriptionHash, durationMinutes,
+ * numOptions, batches, hatIds)` on a HybridVoting or DirectDemocracyVoting
+ * module, where option 0's batch carries `[target, value, calldata][]` triples
+ * that the Executor runs if option 0 wins.
+ *
+ * Encoding parity notes (verified against src/commands/vote/create.ts and
+ * src/commands/vote/propose-quorum.ts):
+ *   - title is encoded with stringToBytes (UTF-8 Uint8Array), NOT bytes32
+ *   - each batch entry is the positional tuple [target, BigNumber(value), data]
+ *   - a proposal with NO execution calls passes `batches: []` — the empty
+ *     outer array, not [[], []] (vote create only builds per-option batches
+ *     when --calls is given). Wrap commands always pass [option0Calls, []].
+ *   - hatIds default to [] and must be BigNumbers/strings — real Hats IDs
+ *     exceed 2^53 and are mangled by Number
+ *
+ * First consumers: vote create / propose-quorum / propose-config / classes
+ * propose (tx/vote.ts), task perms propose-global, org set-metadata-admin,
+ * project propose. Other agents import these from './governance'.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGovernanceProposal = buildGovernanceProposal;
+exports.encodeExecutorCall = encodeExecutorCall;
+exports.parseProposalCreatedLogs = parseProposalCreatedLogs;
+const ethers_1 = require("ethers");
+const contracts_1 = require("../contracts");
+const encoding_1 = require("../encoding");
+/**
+ * Level-1 pure builder for `createProposal` — port of the tx built by
+ * `pop vote create` (src/commands/vote/create.ts) and shared verbatim by
+ * every governance-wrap command (propose-quorum, propose-config, classes
+ * propose, perms propose-global, set-metadata-admin, project propose).
+ */
+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 ?? [];
+    return {
+        to: p.votingAddress,
+        abi: (0, contracts_1.getAbi)(p.votingAbiName),
+        method: 'createProposal',
+        args: [
+            (0, encoding_1.stringToBytes)(p.title),
+            p.descriptionHash,
+            p.durationMinutes,
+            p.numOptions,
+            batchTuples,
+            hatIds,
+        ],
+        meta: {
+            domain: p.domain ?? 'vote',
+            action: p.action ?? 'create',
+            orgId: p.orgId,
+            summary: p.summary,
+            ...(p.ipfs ? { ipfs: p.ipfs } : {}),
+        },
+    };
+}
+/**
+ * Encode one execution call for an option batch: calldata via the named ABI's
+ * Interface (both voting ABIs and TaskManagerNew carry exactly one fragment
+ * per method name, so this matches the CLI's inline-fragment encoding
+ * byte-for-byte).
+ */
+function encodeExecutorCall(abiName, target, method, args, value) {
+    const iface = new ethers_1.ethers.utils.Interface((0, contracts_1.getAbi)(abiName));
+    return {
+        target,
+        value: value ?? 0,
+        calldata: iface.encodeFunctionData(method, args),
+    };
+}
+/**
+ * Extract the created proposal ID from parsed receipt logs — the CLI's
+ * `result.logs?.find(l => l.name === 'NewProposal' || l.name === 'NewHatProposal')`
+ * shared by every createProposal site. Accepts any parsed-log shape
+ * (ethers LogDescription[] / TxResult.logs).
+ */
+function parseProposalCreatedLogs(logs) {
+    const proposalEvent = (logs ?? []).find(l => l.name === 'NewProposal' || l.name === 'NewHatProposal');
+    return proposalEvent?.args?.id?.toString();
+}

package/dist/tx/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Intent builders by domain. tx/intent.ts (TxIntent, encodeIntent) is
+ * re-exported flat; each domain is a namespace.
+ */
+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';
+export * as project from './project';
+export * as task from './task';
+export * as token from './token';
+export * as treasury from './treasury';
+export * as user from './user';
+export * as vote from './vote';
+export * as zkemail from './zkemail';

package/dist/tx/index.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Intent builders by domain. tx/intent.ts (TxIntent, encodeIntent) is
+ * re-exported flat; each domain is a namespace.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zkemail = exports.vote = exports.user = exports.treasury = exports.token = exports.task = exports.project = exports.paymaster = exports.org = exports.governance = exports.eligibility = exports.education = void 0;
+__exportStar(require("./intent"), exports);
+exports.education = __importStar(require("./education"));
+exports.eligibility = __importStar(require("./eligibility"));
+exports.governance = __importStar(require("./governance"));
+exports.org = __importStar(require("./org"));
+exports.paymaster = __importStar(require("./paymaster"));
+exports.project = __importStar(require("./project"));
+exports.task = __importStar(require("./task"));
+exports.token = __importStar(require("./token"));
+exports.treasury = __importStar(require("./treasury"));
+exports.user = __importStar(require("./user"));
+exports.vote = __importStar(require("./vote"));
+exports.zkemail = __importStar(require("./zkemail"));

package/dist/tx/intent.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Transaction intents — the wallet-agnostic write primitive.
+ *
+ * Every POP write is representable as (to, abi, method, args, value): the CLI
+ * has always funneled that tuple into executeTx, and the frontend funnels the
+ * same tuple into its three interchangeable transaction managers (direct EOA,
+ * ERC-4337 passkey, EIP-7702 sponsored). A TxIntent reifies the tuple as data
+ * so ANY of those stacks — plus wagmi/viem, Safe batches, raw JSON-RPC — can
+ * execute it:
+ *
+ *   CLI / agent:     executeIntent(signer, intent)            (execute/ethers)
+ *   wagmi/viem:      writeContract({ address: intent.to, abi: intent.abi,
+ *                                    functionName: intent.method, args: intent.args })
+ *   4337 / 7702:     sendSponsored(key, intent.to, encodeIntent(intent).data, ...)
+ *   anything else:   encodeIntent(intent) → { to, data, value }
+ *
+ * Domain builders (tx/<domain>.ts) return intents; they never sign or send.
+ */
+import { ethers } from 'ethers';
+export interface TxIntentMeta {
+    /** Command-style domain, e.g. 'task' | 'vote' | 'org' | 'treasury'. */
+    domain: string;
+    /** Action within the domain, e.g. 'create' | 'cast' | 'claim'. */
+    action: string;
+    /** Org the intent targets, when org-scoped. */
+    orgId?: string;
+    /** Human-readable preview fields for confirmation UIs. */
+    summary?: Record<string, unknown>;
+    /** Metadata pinned to IPFS while building the intent, if any. */
+    ipfs?: {
+        cid: string;
+        metadata: unknown;
+    };
+}
+export interface TxIntent {
+    /** Resolved contract address. */
+    to: string;
+    /** Full fragment set — used for encoding AND receipt-log parsing. */
+    abi: any[];
+    /** Contract method name, e.g. 'createTask'. */
+    method: string;
+    /** Fully encoded, contract-ordered arguments. */
+    args: unknown[];
+    /** Native value, when the method is payable. */
+    value?: ethers.BigNumberish;
+    meta: TxIntentMeta;
+}
+/**
+ * Pure calldata encoding — no provider, no signer, no network.
+ * `value` is returned as a decimal string ('0' when absent) so the result is
+ * JSON-serializable and stack-agnostic.
+ */
+export declare function encodeIntent(intent: TxIntent): {
+    to: string;
+    data: string;
+    value: string;
+};
+/**
+ * Materialize an intent as an ethers v5 Contract call triple, for hosts that
+ * already speak (contract, method, args) — the CLI's executeTx and the
+ * frontend's txManager.execute both do.
+ */
+export declare function intentToContractCall(intent: TxIntent, signerOrProvider: ethers.Signer | ethers.providers.Provider): {
+    contract: ethers.Contract;
+    method: string;
+    args: unknown[];
+};

package/dist/tx/intent.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Transaction intents — the wallet-agnostic write primitive.
+ *
+ * Every POP write is representable as (to, abi, method, args, value): the CLI
+ * has always funneled that tuple into executeTx, and the frontend funnels the
+ * same tuple into its three interchangeable transaction managers (direct EOA,
+ * ERC-4337 passkey, EIP-7702 sponsored). A TxIntent reifies the tuple as data
+ * so ANY of those stacks — plus wagmi/viem, Safe batches, raw JSON-RPC — can
+ * execute it:
+ *
+ *   CLI / agent:     executeIntent(signer, intent)            (execute/ethers)
+ *   wagmi/viem:      writeContract({ address: intent.to, abi: intent.abi,
+ *                                    functionName: intent.method, args: intent.args })
+ *   4337 / 7702:     sendSponsored(key, intent.to, encodeIntent(intent).data, ...)
+ *   anything else:   encodeIntent(intent) → { to, data, value }
+ *
+ * Domain builders (tx/<domain>.ts) return intents; they never sign or send.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeIntent = encodeIntent;
+exports.intentToContractCall = intentToContractCall;
+const ethers_1 = require("ethers");
+/**
+ * Pure calldata encoding — no provider, no signer, no network.
+ * `value` is returned as a decimal string ('0' when absent) so the result is
+ * JSON-serializable and stack-agnostic.
+ */
+function encodeIntent(intent) {
+    const iface = new ethers_1.ethers.utils.Interface(intent.abi);
+    return {
+        to: intent.to,
+        data: iface.encodeFunctionData(intent.method, intent.args),
+        value: ethers_1.ethers.BigNumber.from(intent.value ?? 0).toString(),
+    };
+}
+/**
+ * Materialize an intent as an ethers v5 Contract call triple, for hosts that
+ * already speak (contract, method, args) — the CLI's executeTx and the
+ * frontend's txManager.execute both do.
+ */
+function intentToContractCall(intent, signerOrProvider) {
+    return {
+        contract: new ethers_1.ethers.Contract(intent.to, intent.abi, signerOrProvider),
+        method: intent.method,
+        args: intent.args,
+    };
+}

package/dist/tx/org.d.ts

@@ -0,0 +1,321 @@
+/**
+ * Org write builders.
+ *
+ * Ports:
+ *   - `pop org deploy`             — src/commands/org/deploy.ts
+ *   - `pop org update-metadata`    — src/commands/org/update-metadata.ts
+ *   - `pop org set-metadata-admin` — src/commands/org/set-metadata-admin.ts
+ *
+ * Level-1 builders are pure (sync, zero I/O) and own ALL argument encoding.
+ * Level-2 `<action>Intent(ctx, params)` builders resolve addresses via the
+ * subgraph, pin metadata to IPFS, and delegate to Level 1.
+ */
+import { ethers } from 'ethers';
+import type { TxIntent } from './intent';
+import type { PopContext } from '../context';
+import type { OrgLink, OrgMetadataUpdates } from '../metadata/org';
+/**
+ * Org deploy config schema (port of the config-file schema in
+ * src/commands/org/deploy.ts). Matches the DeploymentParams struct expected
+ * by OrgDeployer.deployFullOrg().
+ */
+export interface OrgDeployConfig {
+    orgName: string;
+    deployerUsername?: string;
+    description?: string;
+    links?: OrgLink[];
+    autoUpgrade?: boolean;
+    hybridVoting: {
+        thresholdPct: number;
+        classes: Array<{
+            strategy: 'DIRECT' | 'ERC20_BAL';
+            slicePct: number;
+            quadratic?: boolean;
+            minBalance?: string;
+            asset?: string;
+            hatIds?: number[];
+        }>;
+    };
+    directDemocracy: {
+        thresholdPct: number;
+    };
+    roles: Array<{
+        name: string;
+        image?: string;
+        canVote: boolean;
+        vouching?: {
+            enabled: boolean;
+            quorum: number;
+            voucherRoleIndex: number;
+            combineWithHierarchy?: boolean;
+        };
+        defaults?: {
+            eligible: boolean;
+            standing: boolean;
+        };
+        hierarchy?: {
+            adminRoleIndex: number;
+        };
+        distribution?: {
+            mintToDeployer: boolean;
+            additionalWearers?: string[];
+        };
+        hatConfig?: {
+            maxSupply: number;
+            mutableHat: boolean;
+        };
+    }>;
+    roleAssignments: {
+        quickJoinRoles: number[];
+        tokenMemberRoles: number[];
+        tokenApproverRoles: number[];
+        taskCreatorRoles: number[];
+        educationCreatorRoles?: number[];
+        educationMemberRoles?: number[];
+        hybridProposalCreatorRoles: number[];
+        ddVotingRoles: number[];
+        ddCreatorRoles: number[];
+    };
+    metadataAdminRoleIndex?: number;
+    educationHub?: {
+        enabled: boolean;
+    };
+    paymaster?: {
+        operatorRoleIndex: number;
+        maxFeePerGas: string;
+        maxPriorityFeePerGas: string;
+        defaultBudgetCapPerEpoch: string;
+        defaultBudgetEpochLen: number;
+        funding?: string;
+    };
+    /**
+     * Optional org-wide TaskManager ROLE_PERM grants applied at deploy time
+     * (OrgDeployer.TaskManagerPermConfig — roleIndices resolve to hat IDs,
+     * masks are TaskPerm bitmasks: 1=create 2=claim 4=review 8=assign …).
+     */
+    taskManagerPerms?: {
+        roleIndices: number[];
+        masks: number[];
+    };
+}
+/** Port of indicesToBitmap in src/commands/org/deploy.ts. */
+export declare function indicesToBitmap(indices: number[]): ethers.BigNumber;
+/**
+ * Reject role indices that do not name a role in the config.
+ *
+ * RoleResolver reverts UnregisteredRole(roleIdx) when a bitmap bit has no registered hat
+ * (audit M-09) — previously hat 0 was silently stored as an "authorized" hat and the deploy
+ * succeeded with a broken allowlist. Either way the config is wrong, and we know roles.length
+ * here, so name the offending field instead of surfacing a bare index from gas estimation
+ * (older deployers) or an aborted deploy (upgraded ones).
+ */
+export declare function assertRoleIndices(field: string, indices: number[] | undefined, roleCount: number): void;
+/**
+ * Derive the deterministic orgId + normalized name the deployer uses:
+ * orgId = keccak256(orgName.toLowerCase().replace(/\s+/g, '-')).
+ * The normalized name is also the default deployer username.
+ */
+export declare function deriveOrgId(orgName: string): {
+    orgId: string;
+    normalizedName: string;
+};
+/**
+ * Minimal structural type for an ethers v5 signer that can sign EIP-712
+ * typed data (Wallet and JsonRpcSigner both satisfy it).
+ */
+export interface RegisterAccountSigner {
+    _signTypedData(domain: Record<string, unknown>, types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>, value: Record<string, unknown>): Promise<string>;
+}
+/** EIP-712 type set for UniversalAccountRegistry registration. */
+export declare const REGISTER_ACCOUNT_TYPES: {
+    readonly RegisterAccount: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly name: "username";
+        readonly type: "string";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
+/** EIP-712 domain for UniversalAccountRegistry registration. */
+export declare function registerAccountDomain(chainId: number, registryAddress: string): {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: string;
+};
+export interface RegisterAccountMessage {
+    registryAddress: string;
+    chainId: number;
+    user: string;
+    username: string;
+    nonce: ethers.BigNumberish;
+    deadline: number;
+}
+/**
+ * Port of the EIP-712 RegisterAccount signature step in `pop org deploy`
+ * (src/commands/org/deploy.ts): registration happens INSIDE deployFullOrg via
+ * this signature — it is not a separate tx. Kept as a separate function taking
+ * a Signer so hosts control key custody; everything else here is pure data.
+ */
+export declare function signRegisterAccount(signer: RegisterAccountSigner, params: RegisterAccountMessage): Promise<string>;
+/** Resolved inputs the pure param assembly needs beyond the config file. */
+export interface DeploymentResolvedInputs {
+    /** keccak256 of the lowercased-dashed org name (see deriveOrgId). */
+    orgId: string;
+    /** bytes32 of the pinned org metadata CID. */
+    metadataHash: string;
+    /** UniversalAccountRegistry proxy (globalAccountRegistryProxy). */
+    registryAddr: string;
+    deployerAddress: string;
+    deployerUsername: string;
+    /** unix seconds; the CLI uses now + 900 (nonce-bound, so not replayable). */
+    regDeadline: number;
+    /** UniversalAccountRegistry.nonces(deployerAddress). */
+    regNonce: ethers.BigNumberish;
+    /** EIP-712 RegisterAccount signature (signRegisterAccount). */
+    regSignature: string;
+}
+/** Recommended gasLimit for deployFullOrg — the CLI always sends 15,000,000. */
+export declare const DEPLOY_FULL_ORG_GAS_LIMIT = 15000000;
+/**
+ * Pure assembly of the DeploymentParams struct — port of the param build in
+ * `pop org deploy` (src/commands/org/deploy.ts:257-403), byte-for-byte the
+ * same encoding. Validates taskManagerPerms lengths and every roleAssignments
+ * index exactly like the CLI (both gate the broadcast).
+ *
+ * ABI field order (verified against src/abi/OrgDeployerNew.json +
+ * contracts origin/main src/OrgDeployer.sol DeploymentParams):
+ *   orgId, orgName, metadataHash, registryAddr, deployerAddress,
+ *   deployerUsername, regDeadline, regNonce, regSignature, autoUpgrade,
+ *   hybridThresholdPct, ddThresholdPct, hybridClasses, ddInitialTargets,
+ *   roles, roleAssignments, metadataAdminRoleIndex, passkeyEnabled,
+ *   educationHubConfig, bootstrap, paymasterConfig, taskManagerPerms
+ */
+export declare function buildDeploymentParams(config: OrgDeployConfig, resolved: DeploymentResolvedInputs): unknown[];
+export interface DeployFullOrgArgs {
+    /** OrgDeployer proxy (orgDeployerProxy from infrastructure). */
+    orgDeployerAddress: string;
+    /** Assembled DeploymentParams struct (buildDeploymentParams). */
+    deployParams: unknown[];
+    /** Optional paymaster funding ETH (parseEther of paymaster.funding). */
+    value?: ethers.BigNumberish;
+    orgId?: string;
+    orgName?: string;
+}
+/**
+ * Port of `pop org deploy` — src/commands/org/deploy.ts.
+ * OrgDeployer.deployFullOrg([DeploymentParams]) — the single on-chain write,
+ * which internally deploys every org module (registration happens inside it
+ * via the EIP-712 signature carried in the params).
+ *
+ * NOTE: the CLI always sends this with gasLimit 15,000,000
+ * (DEPLOY_FULL_ORG_GAS_LIMIT) — pass it in the executor's options; TxIntent
+ * carries no gas policy.
+ */
+export declare function buildDeployFullOrg(a: DeployFullOrgArgs): TxIntent;
+export interface DeployFullOrgParams {
+    config: OrgDeployConfig;
+    /** The deployer wallet address (registered inside deployFullOrg). */
+    deployerAddress: string;
+    /** Signs the EIP-712 RegisterAccount message; key custody stays host-side. */
+    signer: RegisterAccountSigner;
+    /**
+     * Registration-signature validity in unix seconds. Default now + 900 like
+     * the CLI (must survive an interactive confirmation prompt; nonce-bound, so
+     * a longer window is not replayable).
+     */
+    regDeadline?: number;
+}
+/**
+ * Resolved builder for `pop org deploy` — src/commands/org/deploy.ts.
+ *
+ * Performs the CLI's pre-steps in the same order: config validation,
+ * infrastructure address resolution (orgDeployerProxy +
+ * globalAccountRegistryProxy), org metadata pin, on-chain
+ * UniversalAccountRegistry.nonces() read (requires ctx.provider), and the
+ * EIP-712 RegisterAccount signature — then delegates to buildDeployFullOrg.
+ */
+export declare function deployFullOrgIntent(ctx: PopContext, params: DeployFullOrgParams): Promise<TxIntent>;
+export interface UpdateOrgMetaArgs {
+    /** OrgRegistry proxy (global infrastructure, not an org module). */
+    orgRegistryAddress: string;
+    orgId: string;
+    /** Full replacement org name (the write overwrites name + metadata). */
+    name: string;
+    /** bytes32 of the pinned metadata CID. */
+    metadataHash: string;
+}
+/**
+ * Port of `pop org update-metadata` — src/commands/org/update-metadata.ts.
+ * OrgRegistry.updateOrgMetaAsAdmin(orgId, stringToBytes(name), metadataHash).
+ * Caller must wear the org's metadata-admin hat (topHat fallback) — revert
+ * NotOrgMetadataAdmin otherwise. FULL OVERWRITE of name + metadata hash.
+ */
+export declare function buildUpdateOrgMetaAsAdmin(a: UpdateOrgMetaArgs): TxIntent;
+export interface UpdateOrgMetaParams extends OrgMetadataUpdates {
+    /** Org name or 0x id. */
+    org: string;
+    /** New org name; omitted keeps the current name (full-overwrite write). */
+    name?: string;
+    /** Raw logo bytes to pin (replaces the CLI's fs.readFileSync path). */
+    logo?: Uint8Array;
+}
+/**
+ * Resolved builder for `pop org update-metadata` — src/commands/org/update-metadata.ts.
+ *
+ * Merge base is the RAW IPFS doc (fetchJson of the current metadataHash),
+ * spread FIRST so unknown keys (e.g. zkEmailAllowlist) and frontend key order
+ * survive; refuses (INFRA) when IPFS is unreachable but the subgraph shows
+ * metadata exists — proceeding would drop any key the CLI does not model.
+ */
+export declare function updateOrgMetaIntent(ctx: PopContext, params: UpdateOrgMetaParams): Promise<TxIntent>;
+export interface SetMetadataAdminProposalArgs {
+    /** Org HybridVoting module (the proposal target). */
+    hybridVotingAddress: string;
+    /** OrgRegistry proxy (the option-0 execution target). */
+    orgRegistryAddress: string;
+    orgId: string;
+    /** New metadata-admin hat; 0 clears the override (topHat fallback). */
+    hatId: ethers.BigNumberish;
+    durationMinutes: ethers.BigNumberish;
+    /** Proposal title; default matches the CLI. */
+    title?: string;
+    /** bytes32 of the pinned proposal metadata CID. */
+    descriptionHash: string;
+}
+/** The exact proposal title `pop org set-metadata-admin` uses. */
+export declare function setMetadataAdminTitle(hatId: ethers.BigNumberish): string;
+/**
+ * Port of `pop org set-metadata-admin` — src/commands/org/set-metadata-admin.ts.
+ *
+ * setOrgMetadataAdminHat(bytes32 orgId, uint256 hatId) is executor-only after
+ * bootstrap (revert NotOrgExecutor), so it ships as a HybridVoting proposal
+ * whose option-0 execution batch calls the OrgRegistry via the executor.
+ * Option 1 is "keep current" (empty batch). hatId 0 is meaningful: it clears
+ * the override so updateOrgMetaAsAdmin falls back to the org topHat.
+ */
+export declare function buildSetMetadataAdminProposal(a: SetMetadataAdminProposalArgs): TxIntent;
+export interface SetMetadataAdminParams {
+    /** Org name or 0x id. */
+    org: string;
+    /** New metadata-admin hat (decimal/hex); 0 = clear (topHat fallback). */
+    hatId: ethers.BigNumberish;
+    /** Vote duration in minutes — CLI default 60. */
+    durationMinutes?: number;
+}
+/**
+ * Resolved builder for `pop org set-metadata-admin` — src/commands/org/set-metadata-admin.ts.
+ * Resolves the org's HybridVoting module + the global OrgRegistry, pins the
+ * proposal metadata ({description, optionNames, createdAt} — key order is
+ * load-bearing), and delegates to buildSetMetadataAdminProposal.
+ */
+export declare function setMetadataAdminIntent(ctx: PopContext, params: SetMetadataAdminParams): Promise<TxIntent>;