@poa-box/core 0.1.0

package/dist/tx/paymaster.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * Paymaster transaction builders — ports of `pop paymaster *` write paths
+ * (src/commands/paymaster/).
+ *
+ *   buildDepositForOrg / depositForOrgIntent — pop paymaster deposit
+ *     (PaymasterHub.depositForOrg(bytes32) payable — permissionless)
+ *   buildRegisterCalldata / buildAdminCallRegister / registerOrgIntent —
+ *     pop paymaster register (PoaManager.adminCall wrapping the
+ *     registrar-gated registerOrg / registerAndConfigureOrg)
+ *
+ * Registration gate — VERIFIED against contracts origin/main
+ * src/PaymasterHub.sol: registerOrg / registerAndConfigureOrg are
+ * registrar-gated (_onlyRegistrar: msg.sender must be the PoaManager CONTRACT
+ * or the orgRegistrar, i.e. the OrgDeployer). No EOA can ever call them
+ * directly — the after-the-fact path is the PoaManager OWNER routing the call
+ * through PoaManager.adminCall(target, data). adminCall is NOT payable, so an
+ * initial deposit is always its own, separate depositForOrg transaction.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEPLOY_CONFIG_TUPLE = void 0;
+exports.parsePaymasterHatId = parsePaymasterHatId;
+exports.parseDepositAmount = parseDepositAmount;
+exports.buildRegisterCalldata = buildRegisterCalldata;
+exports.buildDepositForOrg = buildDepositForOrg;
+exports.buildAdminCallRegister = buildAdminCallRegister;
+exports.depositForOrgIntent = depositForOrgIntent;
+exports.registerOrgIntent = registerOrgIntent;
+const ethers_1 = require("ethers");
+const contracts_1 = require("../contracts");
+const resolve_1 = require("../reads/resolve");
+const paymaster_1 = require("../reads/paymaster");
+const errors_1 = require("../errors");
+const exit_codes_1 = require("../exit-codes");
+// ---------------------------------------------------------------------------
+// Encoding — identical fragments/conversions to src/commands/paymaster/register.ts
+// ---------------------------------------------------------------------------
+/** DeployConfig struct shape — verified against PaymasterHub.sol origin/main. */
+exports.DEPLOY_CONFIG_TUPLE = 'tuple(uint256 operatorHatId, uint256 maxFeePerGas, uint256 maxPriorityFeePerGas, '
+    + 'uint32 maxCallGas, uint32 maxVerificationGas, uint32 maxPreVerificationGas, '
+    + 'address[] ruleTargets, bytes4[] ruleSelectors, bool[] ruleAllowed, uint32[] ruleMaxCallGasHints, '
+    + 'bytes32[] budgetSubjectKeys, uint128[] budgetCapsPerEpoch, uint32[] budgetEpochLens)';
+const REGISTER_IFACE = new ethers_1.ethers.utils.Interface([
+    'function registerOrg(bytes32 orgId, uint256 adminHatId, uint256 operatorHatId)',
+    `function registerAndConfigureOrg(bytes32 orgId, uint256 adminHatId, ${exports.DEPLOY_CONFIG_TUPLE} config) payable`,
+]);
+/** Parse a hat ID flag — BigNumber, never parseInt (Hats IDs exceed 2^53). */
+function parsePaymasterHatId(input, flag) {
+    try {
+        return ethers_1.ethers.BigNumber.from(String(input).trim());
+    }
+    catch {
+        throw new errors_1.CliError(`Invalid ${flag} "${input}".`, exit_codes_1.EXIT.USAGE, 'Pass the hat ID as a decimal or 0x-hex integer (see pop org roles).');
+    }
+}
+/** Parse an amount in ether units of the native gas token — port of parseDepositAmount in src/commands/paymaster/deposit.ts. */
+function parseDepositAmount(input) {
+    let wei;
+    try {
+        wei = ethers_1.ethers.utils.parseEther(String(input).trim());
+    }
+    catch {
+        throw new errors_1.CliError(`Invalid --amount "${input}".`, exit_codes_1.EXIT.USAGE, 'Pass the amount in ether units of the native gas token, e.g. --amount 0.05');
+    }
+    if (wei.lte(0)) {
+        throw new errors_1.CliError('Deposit amount must be greater than zero (the contract reverts ZeroAmount).', exit_codes_1.EXIT.USAGE);
+    }
+    return wei;
+}
+/**
+ * Build the registerOrg / registerAndConfigureOrg calldata from the hat IDs +
+ * the optional config (gwei fee caps + ether budget caps). Pure port of
+ * buildRegisterCalldata in src/commands/paymaster/register.ts — byte-for-byte
+ * identical encoding.
+ */
+function buildRegisterCalldata(orgId, adminHatId, operatorHatId, config) {
+    if (!config) {
+        return {
+            method: 'registerOrg',
+            data: REGISTER_IFACE.encodeFunctionData('registerOrg', [orgId, adminHatId, operatorHatId]),
+        };
+    }
+    const rules = config.rules ?? [];
+    const budgets = (config.budgets ?? []).map((b) => {
+        const subjectKey = b.subjectKey
+            ?? (b.hatId !== undefined
+                ? ethers_1.ethers.utils.hexZeroPad(ethers_1.ethers.BigNumber.from(String(b.hatId)).toHexString(), 32)
+                : undefined);
+        if (!subjectKey) {
+            throw new errors_1.CliError('Each budget entry needs "subjectKey" (bytes32) or "hatId".', exit_codes_1.EXIT.USAGE);
+        }
+        return {
+            subjectKey,
+            capPerEpoch: ethers_1.ethers.utils.parseEther(String(b.capPerEpoch)),
+            epochLen: b.epochLen,
+        };
+    });
+    const deployConfig = {
+        operatorHatId: config.operatorHatId !== undefined
+            ? ethers_1.ethers.BigNumber.from(String(config.operatorHatId))
+            : operatorHatId,
+        maxFeePerGas: config.maxFeePerGas !== undefined ? ethers_1.ethers.utils.parseUnits(String(config.maxFeePerGas), 'gwei') : 0,
+        maxPriorityFeePerGas: config.maxPriorityFeePerGas !== undefined
+            ? ethers_1.ethers.utils.parseUnits(String(config.maxPriorityFeePerGas), 'gwei')
+            : 0,
+        maxCallGas: config.maxCallGas ?? 0,
+        maxVerificationGas: config.maxVerificationGas ?? 0,
+        maxPreVerificationGas: config.maxPreVerificationGas ?? 0,
+        ruleTargets: rules.map(r => r.target),
+        ruleSelectors: rules.map(r => r.selector),
+        ruleAllowed: rules.map(r => Boolean(r.allowed)),
+        ruleMaxCallGasHints: rules.map(r => r.maxCallGasHint ?? 0),
+        budgetSubjectKeys: budgets.map(b => b.subjectKey),
+        budgetCapsPerEpoch: budgets.map(b => b.capPerEpoch),
+        budgetEpochLens: budgets.map(b => b.epochLen),
+    };
+    return {
+        method: 'registerAndConfigureOrg',
+        data: REGISTER_IFACE.encodeFunctionData('registerAndConfigureOrg', [orgId, adminHatId, deployConfig]),
+    };
+}
+/**
+ * Port of `pop paymaster deposit` — src/commands/paymaster/deposit.ts:
+ * PaymasterHub.depositForOrg(bytes32 orgId) payable. PERMISSIONLESS ("anyone
+ * can deposit to any org"); reverts ZeroAmount on msg.value == 0 and
+ * OrgNotRegistered when the org has no paymaster config (adminHatId == 0).
+ * ONE-WAY on the deployed hub: no withdraw exists (PR #185 / audit M-04 not
+ * shipped) — funds draw down only as sponsored UserOperations consume them.
+ */
+function buildDepositForOrg(a) {
+    return {
+        to: a.paymasterHubAddress,
+        abi: (0, contracts_1.getAbi)('PaymasterHub'),
+        method: 'depositForOrg',
+        args: [a.orgId],
+        value: a.amountWei,
+        meta: {
+            domain: 'paymaster',
+            action: 'deposit',
+            orgId: a.orgId,
+            summary: { paymasterHub: a.paymasterHubAddress, amountWei: String(a.amountWei) },
+        },
+    };
+}
+/**
+ * Port of the owner path of `pop paymaster register` —
+ * src/commands/paymaster/register.ts: PoaManager.adminCall(paymasterHub,
+ * registerCalldata). Only the PoaManager OWNER can send this (adminCall is
+ * onlyOwner); any other signer's transaction must revert — the CLI prints the
+ * calldata for the owner instead of broadcasting, which hosts can reproduce
+ * with buildRegisterCalldata + encodeIntent.
+ */
+function buildAdminCallRegister(a) {
+    const { method, data } = buildRegisterCalldata(a.orgId, a.adminHatId, a.operatorHatId, a.config);
+    return {
+        to: a.poaManagerAddress,
+        abi: (0, contracts_1.getAbi)('PoaManager'),
+        method: 'adminCall',
+        args: [a.paymasterHubAddress, data],
+        meta: {
+            domain: 'paymaster',
+            action: 'register',
+            orgId: a.orgId,
+            summary: {
+                method,
+                paymasterHub: a.paymasterHubAddress,
+                adminHatId: a.adminHatId.toString(),
+                operatorHatId: a.operatorHatId.toString(),
+                registerCalldata: data,
+            },
+        },
+    };
+}
+/**
+ * Resolved port of `pop paymaster deposit` — src/commands/paymaster/deposit.ts.
+ * Resolves the org id and the chain's singleton PaymasterHub proxy from the
+ * infrastructure subgraph (the hub is NOT in the org's module list). When
+ * ctx.provider is present, replicates the CLI's authoritative
+ * OrgNotRegistered gate (an eth_call on purpose — subgraph lag in a
+ * revert-predicting read means knowingly broadcasting a doomed tx).
+ */
+async function depositForOrgIntent(ctx, params) {
+    const amountWei = parseDepositAmount(params.amount);
+    const orgId = await (0, resolve_1.resolveOrgId)(ctx.client, params.org, ctx.chainId);
+    const { paymasterHubAddress } = await (0, paymaster_1.resolvePaymasterInfra)(ctx.client, ctx.chainId);
+    if (ctx.provider) {
+        const orgConfig = await (0, paymaster_1.readPaymasterOrgConfig)(ctx.provider, paymasterHubAddress, orgId);
+        if (!orgConfig.registered) {
+            throw new errors_1.PreconditionError(`Org ${params.org} is not registered with the PaymasterHub — depositForOrg would revert OrgNotRegistered.`, 'Register it first: pop paymaster register --admin-hat <hatId>');
+        }
+    }
+    return buildDepositForOrg({ paymasterHubAddress, orgId, amountWei });
+}
+/**
+ * Resolved port of `pop paymaster register` —
+ * src/commands/paymaster/register.ts (the adminCall route). Resolves the org
+ * id + PaymasterHub + PoaManager from the infrastructure subgraph and returns
+ * the PoaManager.adminCall intent.
+ *
+ * Registration check is asymmetric like the CLI: a POSITIVE indexed
+ * "registered" answer is trusted; a negative is re-confirmed on chain when
+ * ctx.provider is available. An already-registered org throws
+ * PreconditionError (the CLI reports it as a no-op success — builder callers
+ * need the hard stop, since the intent would be a doomed re-registration).
+ *
+ * NOTE the on-chain gate the builder cannot check for you: adminCall is
+ * onlyOwner on the PoaManager, and PoaManager.owner() has no subgraph field
+ * in either live deployment — the CLI reads it via eth_call and prints the
+ * calldata instead of broadcasting when the signer is not the owner. Hosts
+ * should do the same before executing this intent.
+ */
+async function registerOrgIntent(ctx, params) {
+    const adminHatId = parsePaymasterHatId(params.adminHat, '--admin-hat');
+    const operatorHatId = params.operatorHat !== undefined
+        ? parsePaymasterHatId(params.operatorHat, '--operator-hat')
+        : ethers_1.ethers.BigNumber.from(0);
+    if (adminHatId.isZero()) {
+        throw new errors_1.CliError('--admin-hat cannot be 0 (the contract treats adminHatId==0 as unregistered).', exit_codes_1.EXIT.USAGE);
+    }
+    const orgId = await (0, resolve_1.resolveOrgId)(ctx.client, params.org, ctx.chainId);
+    const { paymasterHubAddress, poaManagerAddress } = await (0, paymaster_1.resolvePaymasterInfra)(ctx.client, ctx.chainId);
+    if (!poaManagerAddress) {
+        throw new errors_1.PreconditionError('PoaManager not indexed for this chain — cannot route the registrar-gated call through adminCall.', 'New orgs register automatically when deployed with a paymaster config block (pop org deploy).');
+    }
+    // Already registered? Subgraph first; only a POSITIVE answer is trusted, a
+    // negative is re-confirmed on chain (when a provider is available) — the
+    // indexer can lag behind a fresh registration and never invents one.
+    let registered;
+    if (ctx.provider) {
+        const { config } = await (0, paymaster_1.readPaymasterOrgConfigPreferSubgraph)(ctx.client, ctx.provider, paymasterHubAddress, orgId, ctx.chainId);
+        registered = config.registered;
+    }
+    else {
+        // No provider: only the subgraph's positive answer is usable — a negative
+        // cannot be re-confirmed, which is exactly the direction that is safe to
+        // proceed on (the tx itself re-checks on-chain).
+        const state = await (0, paymaster_1.fetchPaymasterSubgraphState)(ctx.client, orgId, ctx.chainId);
+        registered = Boolean(state.orgConfig?.registered && (0, paymaster_1.subgraphMatchesHub)(state, paymasterHubAddress));
+    }
+    if (registered) {
+        throw new errors_1.PreconditionError('Org is already registered with the PaymasterHub.', 'Fund it with: pop paymaster deposit');
+    }
+    return buildAdminCallRegister({
+        poaManagerAddress,
+        paymasterHubAddress,
+        orgId,
+        adminHatId,
+        operatorHatId,
+        config: params.config,
+    });
+}

package/dist/tx/project.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Project-domain transaction builders (TaskManagerNew createProject /
+ * deleteProject, plus the governance-wrapped propose path).
+ *
+ * Level 1 — pure builders returning TxIntents (or an ExecutionCall for the
+ * governance wrap). Level 2 — resolved builders that resolve the org, pin the
+ * `{description}` project metadata when given, and delegate. Same rules as
+ * tx/task: confirmation prompts, pre-flights and receipt parsing are host UX.
+ */
+import { ethers } from 'ethers';
+import type { TxIntent } from './intent';
+import { type ExecutionCall } from './governance';
+import type { PopContext } from '../context';
+/**
+ * BootstrapProjectConfig inputs. Struct field order (verified against the
+ * createProject components in the synced TaskManagerNew ABI, and the send
+ * sites in project/create.ts + project/propose.ts):
+ * [title, metaHash, cap, managers, createHats, claimHats, reviewHats,
+ *  assignHats, bountyTokens, bountyCaps].
+ */
+export interface CreateProjectArgs {
+    taskManagerAddress: string;
+    /** Project name; encoded with stringToBytes here. */
+    name: string;
+    /** CIDv0 or bytes32 of the pinned `{description}` doc; omit ⇒ HashZero. */
+    metadataHash?: string;
+    /** Human PT cap (18 decimals applied here; 0/omitted = unlimited). */
+    cap?: number | string;
+    /** Manager addresses (project propose forces this empty — hat-based). */
+    managers?: string[];
+    createHats?: ethers.BigNumberish[];
+    claimHats?: ethers.BigNumberish[];
+    reviewHats?: ethers.BigNumberish[];
+    assignHats?: ethers.BigNumberish[];
+    /** Bounty token addresses (parallel to bountyCaps). */
+    bountyTokens?: string[];
+    /** Bounty caps in RAW wei, exactly as the CLI takes --bounty-caps. */
+    bountyCaps?: ethers.BigNumberish[];
+    orgId?: string;
+}
+/**
+ * The raw BootstrapProjectConfig tuple, shared by the direct and the
+ * governance-wrapped paths so the two cannot drift.
+ */
+export declare function encodeProjectStruct(a: CreateProjectArgs): unknown[];
+/**
+ * Port of `pop project create` — src/commands/project/create.ts
+ * (createProject send). Direct tx: _requireCreator() gates on-chain (creator
+ * hat or executor); permissions are not pre-checked.
+ */
+export declare function buildCreateProject(a: CreateProjectArgs): TxIntent;
+export interface DeleteProjectArgs {
+    taskManagerAddress: string;
+    /** Resolved bytes32 project id. */
+    projectId: string;
+    orgId?: string;
+}
+/**
+ * Port of `pop project delete` — src/commands/project/delete.ts
+ * (deleteProject send; DESTRUCTIVE — consent is host UX).
+ */
+export declare function buildDeleteProject(a: DeleteProjectArgs): TxIntent;
+/**
+ * The createProject(BootstrapProjectConfig) call the executor performs when a
+ * `pop project propose` vote passes — src/commands/project/propose.ts:97
+ * (encoded via the full TaskManagerNew ABI, exactly as the CLI's loadAbi path).
+ */
+export declare function buildCreateProjectCall(a: CreateProjectArgs): ExecutionCall;
+export interface ProposeProjectArgs {
+    hybridVotingAddress: string;
+    taskManagerAddress: string;
+    /** Project name (used for the struct AND the proposal title/option names). */
+    name: string;
+    /** CIDv0 or bytes32 of the pinned project `{description}` doc; omit ⇒ HashZero. */
+    metadataHash?: string;
+    /** Human PT cap (0/omitted = unlimited). */
+    cap?: number | string;
+    createHats?: ethers.BigNumberish[];
+    claimHats?: ethers.BigNumberish[];
+    reviewHats?: ethers.BigNumberish[];
+    assignHats?: ethers.BigNumberish[];
+    /** Vote duration in minutes. */
+    durationMinutes: ethers.BigNumberish;
+    /** CIDv0 or bytes32 of the pinned proposal metadata. */
+    descriptionHash: string;
+    orgId?: string;
+}
+/**
+ * Port of `pop project propose` — src/commands/project/propose.ts.
+ * HybridVoting.createProposal(`Create project: <name>`, descriptionHash,
+ * duration, 2, [[createProject call], []], []). Managers, bountyTokens and
+ * bountyCaps are forced empty (hat-based), matching the CLI struct.
+ */
+export declare function buildProposeProject(a: ProposeProjectArgs): TxIntent;
+export interface CreateProjectParams {
+    org: string;
+    name: string;
+    /** Pinned as `{description}` only when given (else metaHash = HashZero). */
+    description?: string;
+    cap?: number;
+    managers?: string[];
+    createHats?: Array<string | number>;
+    claimHats?: Array<string | number>;
+    reviewHats?: Array<string | number>;
+    assignHats?: Array<string | number>;
+    bountyTokens?: string[];
+    /** Raw wei values, as `--bounty-caps` takes them. */
+    bountyCaps?: Array<string | number>;
+}
+/**
+ * Port of `pop project create` — src/commands/project/create.ts. Resolves the
+ * org's TaskManager, pins the `{description}` metadata when provided, and
+ * delegates to buildCreateProject.
+ */
+export declare function createProjectIntent(ctx: PopContext, p: CreateProjectParams): Promise<TxIntent>;
+export interface DeleteProjectParams {
+    org: string;
+    /** bytes32 hex | composite '<tm>-<hex>' | decimal counter | title. */
+    project: string;
+}
+/**
+ * Port of `pop project delete` — src/commands/project/delete.ts. Resolves the
+ * project input (bytes32 / composite / decimal → bytes32(uint) / title via
+ * subgraph) and builds deleteProject. The existence pre-flight (lens
+ * PROJECT_INFO) and destructive consent are host UX.
+ */
+export declare function deleteProjectIntent(ctx: PopContext, p: DeleteProjectParams): Promise<TxIntent>;
+export interface ProposeProjectParams {
+    org: string;
+    name: string;
+    description?: string;
+    cap?: number;
+    /** Vote duration in minutes (CLI default 1440 = 24h). */
+    duration?: number;
+    createHats?: Array<string | number>;
+    claimHats?: Array<string | number>;
+    reviewHats?: Array<string | number>;
+    assignHats?: Array<string | number>;
+}
+/**
+ * Port of `pop project propose` — src/commands/project/propose.ts. Two pins:
+ * the project `{description}` doc (only when given) and the proposal metadata
+ * {description, optionNames, createdAt} with the CLI's exact strings. Then
+ * wraps the createProject calldata in a HybridVoting proposal.
+ */
+export declare function proposeProjectIntent(ctx: PopContext, p: ProposeProjectParams): Promise<TxIntent>;

package/dist/tx/project.js

@@ -0,0 +1,217 @@
+"use strict";
+/**
+ * Project-domain transaction builders (TaskManagerNew createProject /
+ * deleteProject, plus the governance-wrapped propose path).
+ *
+ * Level 1 — pure builders returning TxIntents (or an ExecutionCall for the
+ * governance wrap). Level 2 — resolved builders that resolve the org, pin the
+ * `{description}` project metadata when given, and delegate. Same rules as
+ * tx/task: confirmation prompts, pre-flights and receipt parsing are host UX.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeProjectStruct = encodeProjectStruct;
+exports.buildCreateProject = buildCreateProject;
+exports.buildDeleteProject = buildDeleteProject;
+exports.buildCreateProjectCall = buildCreateProjectCall;
+exports.buildProposeProject = buildProposeProject;
+exports.createProjectIntent = createProjectIntent;
+exports.deleteProjectIntent = deleteProjectIntent;
+exports.proposeProjectIntent = proposeProjectIntent;
+const ethers_1 = require("ethers");
+const governance_1 = require("./governance");
+const contracts_1 = require("../contracts");
+const encoding_1 = require("../encoding");
+const ipfs_1 = require("../ipfs");
+const errors_1 = require("../errors");
+const exit_codes_1 = require("../exit-codes");
+const resolve_1 = require("../reads/resolve");
+const project_1 = require("../reads/project");
+const task_1 = require("../metadata/task");
+const proposal_1 = require("../metadata/proposal");
+/**
+ * The raw BootstrapProjectConfig tuple, shared by the direct and the
+ * governance-wrapped paths so the two cannot drift.
+ */
+function encodeProjectStruct(a) {
+    const cap = a.cap ? ethers_1.ethers.utils.parseUnits(a.cap.toString(), 18) : 0;
+    return [
+        (0, encoding_1.stringToBytes)(a.name),
+        a.metadataHash ? (0, encoding_1.ipfsCidToBytes32)(a.metadataHash) : ethers_1.ethers.constants.HashZero,
+        cap,
+        a.managers ?? [],
+        (a.createHats ?? []).map((h) => ethers_1.ethers.BigNumber.from(h)),
+        (a.claimHats ?? []).map((h) => ethers_1.ethers.BigNumber.from(h)),
+        (a.reviewHats ?? []).map((h) => ethers_1.ethers.BigNumber.from(h)),
+        (a.assignHats ?? []).map((h) => ethers_1.ethers.BigNumber.from(h)),
+        a.bountyTokens ?? [],
+        (a.bountyCaps ?? []).map((c) => ethers_1.ethers.BigNumber.from(c)),
+    ];
+}
+/**
+ * Port of `pop project create` — src/commands/project/create.ts
+ * (createProject send). Direct tx: _requireCreator() gates on-chain (creator
+ * hat or executor); permissions are not pre-checked.
+ */
+function buildCreateProject(a) {
+    return {
+        to: a.taskManagerAddress,
+        abi: (0, contracts_1.getAbi)('TaskManagerNew'),
+        method: 'createProject',
+        args: [encodeProjectStruct(a)],
+        meta: {
+            domain: 'project',
+            action: 'create',
+            orgId: a.orgId,
+            summary: { name: a.name, cap: a.cap ? String(a.cap) : 'unlimited' },
+        },
+    };
+}
+/**
+ * Port of `pop project delete` — src/commands/project/delete.ts
+ * (deleteProject send; DESTRUCTIVE — consent is host UX).
+ */
+function buildDeleteProject(a) {
+    return {
+        to: a.taskManagerAddress,
+        abi: (0, contracts_1.getAbi)('TaskManagerNew'),
+        method: 'deleteProject',
+        args: [a.projectId],
+        meta: { domain: 'project', action: 'delete', orgId: a.orgId, summary: { projectId: a.projectId } },
+    };
+}
+/**
+ * The createProject(BootstrapProjectConfig) call the executor performs when a
+ * `pop project propose` vote passes — src/commands/project/propose.ts:97
+ * (encoded via the full TaskManagerNew ABI, exactly as the CLI's loadAbi path).
+ */
+function buildCreateProjectCall(a) {
+    return (0, governance_1.encodeExecutorCall)('TaskManagerNew', a.taskManagerAddress, 'createProject', [encodeProjectStruct(a)]);
+}
+/**
+ * Port of `pop project propose` — src/commands/project/propose.ts.
+ * HybridVoting.createProposal(`Create project: <name>`, descriptionHash,
+ * duration, 2, [[createProject call], []], []). Managers, bountyTokens and
+ * bountyCaps are forced empty (hat-based), matching the CLI struct.
+ */
+function buildProposeProject(a) {
+    const call = buildCreateProjectCall({
+        taskManagerAddress: a.taskManagerAddress,
+        name: a.name,
+        metadataHash: a.metadataHash,
+        cap: a.cap,
+        managers: [], // hat-based instead
+        createHats: a.createHats,
+        claimHats: a.claimHats,
+        reviewHats: a.reviewHats,
+        assignHats: a.assignHats,
+        bountyTokens: [],
+        bountyCaps: [],
+    });
+    return (0, governance_1.buildGovernanceProposal)({
+        votingAddress: a.hybridVotingAddress,
+        votingAbiName: 'HybridVotingNew',
+        title: `Create project: ${a.name}`,
+        descriptionHash: (0, encoding_1.ipfsCidToBytes32)(a.descriptionHash),
+        durationMinutes: a.durationMinutes,
+        numOptions: 2,
+        batches: [
+            [call], // option 0: create project
+            [], // option 1: do nothing
+        ],
+        hatIds: [],
+        orgId: a.orgId,
+        domain: 'project',
+        action: 'propose',
+        summary: { name: a.name, cap: a.cap ? String(a.cap) : 'unlimited' },
+    });
+}
+/**
+ * Port of `pop project create` — src/commands/project/create.ts. Resolves the
+ * org's TaskManager, pins the `{description}` metadata when provided, and
+ * delegates to buildCreateProject.
+ */
+async function createProjectIntent(ctx, p) {
+    const modules = await (0, resolve_1.resolveOrgModules)(ctx.client, p.org, ctx.chainId);
+    const taskManagerAddress = (0, resolve_1.requireModule)(modules, 'taskManagerAddress');
+    let metaCid;
+    let metadata;
+    if (p.description) {
+        metadata = (0, task_1.buildProjectMetadata)(p.description);
+        metaCid = await (0, ipfs_1.pinJson)((0, task_1.serializeProjectMetadata)(metadata), ctx.ipfs);
+    }
+    const intent = buildCreateProject({
+        taskManagerAddress,
+        name: p.name,
+        metadataHash: metaCid,
+        cap: p.cap,
+        managers: p.managers,
+        createHats: p.createHats,
+        claimHats: p.claimHats,
+        reviewHats: p.reviewHats,
+        assignHats: p.assignHats,
+        bountyTokens: p.bountyTokens,
+        bountyCaps: p.bountyCaps,
+        orgId: modules.orgId,
+    });
+    if (metaCid && metadata)
+        intent.meta.ipfs = { cid: metaCid, metadata };
+    return intent;
+}
+/**
+ * Port of `pop project delete` — src/commands/project/delete.ts. Resolves the
+ * project input (bytes32 / composite / decimal → bytes32(uint) / title via
+ * subgraph) and builds deleteProject. The existence pre-flight (lens
+ * PROJECT_INFO) and destructive consent are host UX.
+ */
+async function deleteProjectIntent(ctx, p) {
+    const modules = await (0, resolve_1.resolveOrgModules)(ctx.client, p.org, ctx.chainId);
+    const taskManagerAddress = (0, resolve_1.requireModule)(modules, 'taskManagerAddress');
+    const { pid, title } = await (0, project_1.resolveProjectInput)(ctx.client, p.project, modules.orgId, ctx.chainId);
+    const intent = buildDeleteProject({ taskManagerAddress, projectId: pid, orgId: modules.orgId });
+    if (title && intent.meta.summary)
+        intent.meta.summary.title = title;
+    return intent;
+}
+/**
+ * Port of `pop project propose` — src/commands/project/propose.ts. Two pins:
+ * the project `{description}` doc (only when given) and the proposal metadata
+ * {description, optionNames, createdAt} with the CLI's exact strings. Then
+ * wraps the createProject calldata in a HybridVoting proposal.
+ */
+async function proposeProjectIntent(ctx, p) {
+    const modules = await (0, resolve_1.resolveOrgModules)(ctx.client, p.org, ctx.chainId);
+    const taskManagerAddress = (0, resolve_1.requireModule)(modules, 'taskManagerAddress');
+    const hybridVotingAddress = modules.hybridVotingAddress;
+    if (!hybridVotingAddress) {
+        throw new errors_1.CliError('No HybridVoting found for this org', exit_codes_1.EXIT.PRECONDITION, 'This org cannot run governance proposals.');
+    }
+    const duration = p.duration ?? 1440;
+    // Pin project metadata to IPFS (only when a description was given).
+    let metaCid;
+    if (p.description) {
+        metaCid = await (0, ipfs_1.pinJson)((0, task_1.serializeProjectMetadata)((0, task_1.buildProjectMetadata)(p.description)), ctx.ipfs);
+    }
+    // Proposal metadata — key order {description, optionNames, createdAt} is a
+    // protocol contract; strings match project/propose.ts verbatim.
+    const proposalMeta = (0, proposal_1.buildProposalMetadata)({
+        description: `Create project "${p.name}"${p.description ? ': ' + p.description : ''}. PT cap: ${p.cap || 'unlimited'}. If this proposal passes, the project will be created automatically via execution call.`,
+        optionNames: [`Create "${p.name}"`, 'Do not create'],
+    });
+    const proposalCid = await (0, ipfs_1.pinJson)((0, proposal_1.serializeProposalMetadata)(proposalMeta), ctx.ipfs);
+    const intent = buildProposeProject({
+        hybridVotingAddress,
+        taskManagerAddress,
+        name: p.name,
+        metadataHash: metaCid,
+        cap: p.cap,
+        createHats: p.createHats,
+        claimHats: p.claimHats,
+        reviewHats: p.reviewHats,
+        assignHats: p.assignHats,
+        durationMinutes: duration,
+        descriptionHash: proposalCid,
+        orgId: modules.orgId,
+    });
+    intent.meta.ipfs = { cid: proposalCid, metadata: proposalMeta };
+    return intent;
+}