@poa-box/core 0.1.0

package/dist/metadata/user.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * User-profile metadata — the document `pop user update-profile` pins to IPFS
+ * before calling UniversalAccountRegistry.setProfileMetadata.
+ *
+ * Port of the merge logic in src/commands/user/update-profile.ts.
+ *
+ * KEY ORDER IS A PROTOCOL CONTRACT: keys are CONDITIONALLY PRESENT but appear
+ * in the fixed order {bio, avatar, github, twitter, website} — a key is
+ * included when the caller supplies a new value (even an empty string) OR the
+ * existing indexed metadata carries a truthy value for it. The subgraph's
+ * AccountMetadata mapping and the frontend both consume this document; do not
+ * reorder or unconditionally include keys.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USER_PROFILE_FIELDS = void 0;
+exports.buildUserProfileMetadata = buildUserProfileMetadata;
+exports.serializeUserProfileMetadata = serializeUserProfileMetadata;
+const errors_1 = require("../errors");
+const exit_codes_1 = require("../exit-codes");
+/** The five profile fields, in canonical document order. */
+exports.USER_PROFILE_FIELDS = ['bio', 'avatar', 'github', 'twitter', 'website'];
+/**
+ * Read-then-merge profile metadata builder.
+ * Port of `pop user update-profile` — src/commands/user/update-profile.ts.
+ *
+ * Replicates the CLI's inclusion + precedence rules EXACTLY:
+ *   - a key is included when `updates.<k> !== undefined` OR `existing.<k>` is
+ *     truthy (so single-flag edits preserve the other fields, and an explicit
+ *     empty string clears a field while keeping the key);
+ *   - value precedence: updates.<k> ?? existing.<k> ?? '';
+ *   - bio is capped at 280 chars (same error message and exit code).
+ */
+function buildUserProfileMetadata(updates, existing) {
+    const prev = existing || {};
+    const metadata = {};
+    // Conditional keys, fixed order — order is load-bearing.
+    if (updates.bio !== undefined || prev.bio)
+        metadata.bio = updates.bio ?? prev.bio ?? '';
+    if (updates.avatar !== undefined || prev.avatar)
+        metadata.avatar = updates.avatar ?? prev.avatar ?? '';
+    if (updates.github !== undefined || prev.github)
+        metadata.github = updates.github ?? prev.github ?? '';
+    if (updates.twitter !== undefined || prev.twitter)
+        metadata.twitter = updates.twitter ?? prev.twitter ?? '';
+    if (updates.website !== undefined || prev.website)
+        metadata.website = updates.website ?? prev.website ?? '';
+    if (metadata.bio && metadata.bio.length > 280) {
+        throw new errors_1.CliError(`Bio too long: ${metadata.bio.length}/280 chars`, exit_codes_1.EXIT.USAGE);
+    }
+    return metadata;
+}
+/**
+ * Serialize with the exact conditional key order the CLI pins. Rebuilt with
+ * explicit ordering so callers cannot accidentally pin a reordered document.
+ */
+function serializeUserProfileMetadata(metadata) {
+    const ordered = {};
+    if (metadata.bio !== undefined)
+        ordered.bio = metadata.bio;
+    if (metadata.avatar !== undefined)
+        ordered.avatar = metadata.avatar;
+    if (metadata.github !== undefined)
+        ordered.github = metadata.github;
+    if (metadata.twitter !== undefined)
+        ordered.twitter = metadata.twitter;
+    if (metadata.website !== undefined)
+        ordered.website = metadata.website;
+    return JSON.stringify(ordered);
+}

package/dist/multicall.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Multicall3 Batching
+ * Batch read-only eth_calls through the canonical Multicall3 deployment
+ * (same address on every chain, https://www.multicall3.com). When Multicall3
+ * is not deployed on the target chain, degrades to parallel provider.call
+ * with per-call error trapping so callers always get one result per call.
+ */
+import { ethers } from 'ethers';
+/** Canonical Multicall3 address (identical across all supported chains). */
+export declare const MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
+export interface Call {
+    to: string;
+    data: string;
+}
+export interface CallResult {
+    success: boolean;
+    returnData: string;
+}
+/**
+ * Batch read-only calls through Multicall3.tryAggregate(requireSuccess=false),
+ * one RPC round-trip for the whole batch. Per-call reverts surface as
+ * { success: false } instead of throwing. When Multicall3 is unavailable
+ * (or the aggregate call itself fails), falls back to parallel provider.call
+ * with the same per-call error mapping.
+ */
+export declare function tryAggregate(provider: ethers.providers.Provider, calls: Call[], opts?: {
+    blockTag?: number;
+}): Promise<CallResult[]>;
+/** Calldata for Multicall3.getEthBalance(address), for batching native-balance reads. */
+export declare function getEthBalanceCall(address: string): Call;
+/** Decode the uint256 balance from a getEthBalance return payload. */
+export declare function decodeEthBalance(returnData: string): ethers.BigNumber;

package/dist/multicall.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Multicall3 Batching
+ * Batch read-only eth_calls through the canonical Multicall3 deployment
+ * (same address on every chain, https://www.multicall3.com). When Multicall3
+ * is not deployed on the target chain, degrades to parallel provider.call
+ * with per-call error trapping so callers always get one result per call.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MULTICALL3 = void 0;
+exports.tryAggregate = tryAggregate;
+exports.getEthBalanceCall = getEthBalanceCall;
+exports.decodeEthBalance = decodeEthBalance;
+const ethers_1 = require("ethers");
+/** Canonical Multicall3 address (identical across all supported chains). */
+exports.MULTICALL3 = '0xcA11bde05977b3631167028862bE2a173976CA11';
+const MULTICALL3_IFACE = new ethers_1.ethers.utils.Interface([
+    'function tryAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) returns (tuple(bool success, bytes returnData)[] returnData)',
+    'function getEthBalance(address addr) view returns (uint256 balance)',
+]);
+/**
+ * Multicall3 availability, cached per provider instance (a provider is bound
+ * to one chain, so this is effectively per provider/chain).
+ */
+const availabilityCache = new WeakMap();
+function isMulticallAvailable(provider) {
+    let available = availabilityCache.get(provider);
+    if (!available) {
+        available = provider
+            .getCode(exports.MULTICALL3)
+            .then((code) => typeof code === 'string' && code.length > 2 && code !== '0x0')
+            .catch(() => false);
+        availabilityCache.set(provider, available);
+    }
+    return available;
+}
+/**
+ * Fallback for chains without Multicall3: issue the call directly.
+ * getEthBalance calls target Multicall3 itself, so without the deployment
+ * they are answered from eth_getBalance instead of eth_call.
+ */
+async function fallbackCall(provider, call, blockTag) {
+    try {
+        if (call.to.toLowerCase() === exports.MULTICALL3.toLowerCase() &&
+            call.data.slice(0, 10).toLowerCase() === MULTICALL3_IFACE.getSighash('getEthBalance').toLowerCase()) {
+            const [addr] = MULTICALL3_IFACE.decodeFunctionData('getEthBalance', call.data);
+            const balance = await provider.getBalance(addr, blockTag);
+            return { success: true, returnData: ethers_1.ethers.utils.defaultAbiCoder.encode(['uint256'], [balance]) };
+        }
+        const returnData = await provider.call({ to: call.to, data: call.data }, blockTag);
+        return { success: true, returnData };
+    }
+    catch {
+        return { success: false, returnData: '0x' };
+    }
+}
+/**
+ * Batch read-only calls through Multicall3.tryAggregate(requireSuccess=false),
+ * one RPC round-trip for the whole batch. Per-call reverts surface as
+ * { success: false } instead of throwing. When Multicall3 is unavailable
+ * (or the aggregate call itself fails), falls back to parallel provider.call
+ * with the same per-call error mapping.
+ */
+async function tryAggregate(provider, calls, opts) {
+    if (calls.length === 0)
+        return [];
+    if (await isMulticallAvailable(provider)) {
+        try {
+            const data = MULTICALL3_IFACE.encodeFunctionData('tryAggregate', [
+                false,
+                calls.map((c) => [c.to, c.data]),
+            ]);
+            const raw = await provider.call({ to: exports.MULTICALL3, data }, opts?.blockTag);
+            const [results] = MULTICALL3_IFACE.decodeFunctionResult('tryAggregate', raw);
+            return results.map((r) => ({
+                success: r.success,
+                returnData: r.returnData,
+            }));
+        }
+        catch {
+            // Aggregate call failed — degrade to the parallel fallback below.
+        }
+    }
+    return Promise.all(calls.map((call) => fallbackCall(provider, call, opts?.blockTag)));
+}
+/** Calldata for Multicall3.getEthBalance(address), for batching native-balance reads. */
+function getEthBalanceCall(address) {
+    return {
+        to: exports.MULTICALL3,
+        data: MULTICALL3_IFACE.encodeFunctionData('getEthBalance', [address]),
+    };
+}
+/** Decode the uint256 balance from a getEthBalance return payload. */
+function decodeEthBalance(returnData) {
+    return MULTICALL3_IFACE.decodeFunctionResult('getEthBalance', returnData)[0];
+}

package/dist/payout.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Task payout + token-label conventions.
+ *
+ * Port of the frontend's `poa-app/src/util/taskUtils.js` (payout math, 15-minute time helpers)
+ * and `src/util/tokenLabel.js` (token label). None of this is enforced on-chain — TaskManager
+ * stores whatever payout it is handed — so it is a shared CONVENTION between the UI and the
+ * CLI. Diverging here produces tasks that look mispriced in the app next to identical ones
+ * created in the browser, which is why the numbers are copied rather than re-derived.
+ *
+ * Two payout modes:
+ *   - default:    difficulty-weighted, base + multiplier x estimated hours
+ *   - hours-only: the org sets `taskPayoutHoursOnly` in its metadata; difficulty is ignored
+ *                 and payout is simply rate x estimated hours
+ */
+/**
+ * Difficulty configuration for payout calculation.
+ * base payout + (multiplier * estimated hours) = total payout.
+ */
+export declare const DIFFICULTY_CONFIG: Record<string, {
+    base: number;
+    multiplier: number;
+}>;
+/** Tokens-per-hour default for orgs that opt into hours-only payouts. */
+export declare const DEFAULT_HOURLY_RATE = 10;
+/** Orgs default to "Shares" unless they opt into the token's on-chain symbol. */
+export declare const DEFAULT_TOKEN_LABEL = "Shares";
+export declare const MINUTES_STEP = 15;
+export interface PayoutConfig {
+    hoursOnly?: boolean;
+    hourlyRate?: number | string | null;
+}
+/** Normalize a configured hourly rate to a positive finite number. */
+export declare function normalizeHourlyRate(value: unknown): number;
+/**
+ * Calculate a task payout the same way the web app does.
+ *
+ * An unknown difficulty falls back to `medium` rather than throwing, matching the frontend —
+ * the CLI accepts free-text --difficulty and older tasks carry values no longer in the config.
+ */
+export declare function calculatePayout(difficulty: string | undefined, estimatedHours: number, payoutConfig?: PayoutConfig): number;
+/**
+ * Resolve the user-facing label for an org's participation token.
+ * `useTokenSymbol` is an OrgMetadata flag; without it every amount reads as "Shares".
+ */
+export declare function resolveTokenLabel(args?: {
+    useTokenSymbol?: boolean;
+    symbol?: string | null;
+}): string;
+/**
+ * Format decimal hours as a compact "1h 30m" / "45m" / "2h" label.
+ *
+ * Durations are stored as decimal hours (0.25 = 15 min); hours-only orgs enter and read them
+ * in 15-minute steps, so "0.25 hrs" is the wrong unit to show those members.
+ */
+export declare function formatEstTime(hours: number | string): string;
+/** Read an org's payout convention out of its OrgMetadata (subgraph entity or raw IPFS doc). */
+export declare function payoutConfigFromMetadata(metadata: any): PayoutConfig & {
+    useTokenSymbol: boolean;
+};

package/dist/payout.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Task payout + token-label conventions.
+ *
+ * Port of the frontend's `poa-app/src/util/taskUtils.js` (payout math, 15-minute time helpers)
+ * and `src/util/tokenLabel.js` (token label). None of this is enforced on-chain — TaskManager
+ * stores whatever payout it is handed — so it is a shared CONVENTION between the UI and the
+ * CLI. Diverging here produces tasks that look mispriced in the app next to identical ones
+ * created in the browser, which is why the numbers are copied rather than re-derived.
+ *
+ * Two payout modes:
+ *   - default:    difficulty-weighted, base + multiplier x estimated hours
+ *   - hours-only: the org sets `taskPayoutHoursOnly` in its metadata; difficulty is ignored
+ *                 and payout is simply rate x estimated hours
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MINUTES_STEP = exports.DEFAULT_TOKEN_LABEL = exports.DEFAULT_HOURLY_RATE = exports.DIFFICULTY_CONFIG = void 0;
+exports.normalizeHourlyRate = normalizeHourlyRate;
+exports.calculatePayout = calculatePayout;
+exports.resolveTokenLabel = resolveTokenLabel;
+exports.formatEstTime = formatEstTime;
+exports.payoutConfigFromMetadata = payoutConfigFromMetadata;
+/**
+ * Difficulty configuration for payout calculation.
+ * base payout + (multiplier * estimated hours) = total payout.
+ */
+exports.DIFFICULTY_CONFIG = {
+    easy: { base: 1, multiplier: 16.5 },
+    medium: { base: 4, multiplier: 24 },
+    hard: { base: 10, multiplier: 30 },
+    veryHard: { base: 25, multiplier: 37.5 },
+};
+/** Tokens-per-hour default for orgs that opt into hours-only payouts. */
+exports.DEFAULT_HOURLY_RATE = 10;
+/** Orgs default to "Shares" unless they opt into the token's on-chain symbol. */
+exports.DEFAULT_TOKEN_LABEL = 'Shares';
+exports.MINUTES_STEP = 15;
+/** Normalize a configured hourly rate to a positive finite number. */
+function normalizeHourlyRate(value) {
+    const rate = Number(value);
+    return Number.isFinite(rate) && rate > 0 ? rate : exports.DEFAULT_HOURLY_RATE;
+}
+/**
+ * Calculate a task payout the same way the web app does.
+ *
+ * An unknown difficulty falls back to `medium` rather than throwing, matching the frontend —
+ * the CLI accepts free-text --difficulty and older tasks carry values no longer in the config.
+ */
+function calculatePayout(difficulty, estimatedHours, payoutConfig) {
+    const hours = Number(estimatedHours) || 0;
+    if (payoutConfig?.hoursOnly) {
+        return Math.round(normalizeHourlyRate(payoutConfig.hourlyRate) * hours);
+    }
+    const config = exports.DIFFICULTY_CONFIG[difficulty];
+    if (!config)
+        return calculatePayout('medium', hours);
+    return Math.round(config.base + config.multiplier * hours);
+}
+/**
+ * Resolve the user-facing label for an org's participation token.
+ * `useTokenSymbol` is an OrgMetadata flag; without it every amount reads as "Shares".
+ */
+function resolveTokenLabel(args) {
+    const { useTokenSymbol, symbol } = args || {};
+    if (useTokenSymbol === true && symbol && typeof symbol === 'string' && symbol.trim()) {
+        return symbol.trim();
+    }
+    return exports.DEFAULT_TOKEN_LABEL;
+}
+/**
+ * Format decimal hours as a compact "1h 30m" / "45m" / "2h" label.
+ *
+ * Durations are stored as decimal hours (0.25 = 15 min); hours-only orgs enter and read them
+ * in 15-minute steps, so "0.25 hrs" is the wrong unit to show those members.
+ */
+function formatEstTime(hours) {
+    const totalMin = Math.round(Number(hours) * 60);
+    if (!Number.isFinite(totalMin) || totalMin <= 0)
+        return '0m';
+    const h = Math.floor(totalMin / 60);
+    const m = totalMin % 60;
+    if (h && m)
+        return `${h}h ${m}m`;
+    if (h)
+        return `${h}h`;
+    return `${m}m`;
+}
+/** Read an org's payout convention out of its OrgMetadata (subgraph entity or raw IPFS doc). */
+function payoutConfigFromMetadata(metadata) {
+    return {
+        hoursOnly: metadata?.taskPayoutHoursOnly === true,
+        // BigDecimal arrives from the subgraph as a string; normalizeHourlyRate coerces it.
+        hourlyRate: metadata?.taskPayoutHourlyRate ?? null,
+        useTokenSymbol: metadata?.useTokenSymbol === true,
+    };
+}

package/dist/perms.d.ts

@@ -0,0 +1,47 @@
+/**
+ * TaskManager Permission Bitmask Utilities
+ * Parse, format, and describe TaskPerm bitmasks used by the
+ * TaskManager contract's per-member permission system.
+ */
+export declare const PERM_BITS: {
+    readonly create: 1;
+    readonly claim: 2;
+    readonly review: 4;
+    readonly assign: 8;
+    readonly 'self-review': 16;
+    readonly budget: 32;
+    readonly 'edit-meta': 64;
+    readonly 'edit-full': 128;
+};
+export type PermName = keyof typeof PERM_BITS;
+/**
+ * Parse a comma-separated list of permission names into a bitmask.
+ * Case-insensitive, whitespace-tolerant. Empty string or 'none' → 0.
+ * Throws CliError listing valid names on an unknown permission.
+ */
+export declare function parsePermList(input: string): number;
+/**
+ * Format a bitmask as a comma-separated list of permission names.
+ * 0 → 'none'. Unrecognized high bits render as 'bitN' (N = bit index).
+ */
+export declare function formatMask(mask: number): string;
+/**
+ * Describe each set bit of a bitmask as a human-readable sentence.
+ * Unknown bits render as 'unknown permission (bitN)'.
+ */
+export declare function describeMask(mask: number): string[];
+/**
+ * EligibilityModule vouch-config flag bits (EligibilityModule.sol:156-157).
+ * Packed into the `flags` byte of the VouchConfig tuple returned by getVouchConfig.
+ */
+export declare const VOUCH_FLAG_ENABLED = 1;
+export declare const VOUCH_FLAG_COMBINE_HIERARCHY = 2;
+/**
+ * Would enabling vouching and default-eligibility on the same hat conflict?
+ *
+ * Audit M-03 made these mutually exclusive in BOTH directions: a hat that everyone is eligible
+ * for by default makes a vouch quorum a no-op, so the contract reverts
+ * DefaultEligibilityConflictsWithVouch. The guard only fires when vouching is enabled AND
+ * combineWithHierarchy is set — vouching alone, or without combine, is fine.
+ */
+export declare function vouchConflictsWithDefaultEligibility(vouchFlags: number, vouchQuorum: number, defaultEligible: boolean): boolean;

package/dist/perms.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * TaskManager Permission Bitmask Utilities
+ * Parse, format, and describe TaskPerm bitmasks used by the
+ * TaskManager contract's per-member permission system.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VOUCH_FLAG_COMBINE_HIERARCHY = exports.VOUCH_FLAG_ENABLED = exports.PERM_BITS = void 0;
+exports.parsePermList = parsePermList;
+exports.formatMask = formatMask;
+exports.describeMask = describeMask;
+exports.vouchConflictsWithDefaultEligibility = vouchConflictsWithDefaultEligibility;
+const errors_1 = require("./errors");
+exports.PERM_BITS = {
+    create: 1,
+    claim: 2,
+    review: 4,
+    assign: 8,
+    'self-review': 16,
+    budget: 32,
+    'edit-meta': 64,
+    'edit-full': 128,
+};
+const PERM_DESCRIPTIONS = {
+    create: 'create tasks',
+    claim: 'claim tasks',
+    review: 'review submissions',
+    assign: 'assign tasks to others',
+    'self-review': 'review own submissions',
+    budget: 'edit project budgets',
+    'edit-meta': 'edit task metadata post-claim',
+    'edit-full': 'edit all task fields post-claim',
+};
+/**
+ * Parse a comma-separated list of permission names into a bitmask.
+ * Case-insensitive, whitespace-tolerant. Empty string or 'none' → 0.
+ * Throws CliError listing valid names on an unknown permission.
+ */
+function parsePermList(input) {
+    const trimmed = (input || '').trim();
+    if (trimmed === '' || trimmed.toLowerCase() === 'none')
+        return 0;
+    let mask = 0;
+    for (const part of trimmed.split(',')) {
+        const name = part.trim().toLowerCase();
+        if (name === '')
+            continue;
+        const bit = exports.PERM_BITS[name];
+        if (bit === undefined) {
+            throw new errors_1.CliError(`Unknown permission "${name}". Valid permissions: ${Object.keys(exports.PERM_BITS).join(', ')}`);
+        }
+        mask |= bit;
+    }
+    return mask;
+}
+/**
+ * Format a bitmask as a comma-separated list of permission names.
+ * 0 → 'none'. Unrecognized high bits render as 'bitN' (N = bit index).
+ */
+function formatMask(mask) {
+    if (mask === 0)
+        return 'none';
+    const names = [];
+    let known = 0;
+    for (const [name, bit] of Object.entries(exports.PERM_BITS)) {
+        if (mask & bit) {
+            names.push(name);
+            known |= bit;
+        }
+    }
+    let remaining = mask & ~known;
+    for (let i = 0; remaining !== 0 && i < 32; i++) {
+        if (remaining & (1 << i)) {
+            names.push(`bit${i}`);
+            remaining &= ~(1 << i);
+        }
+    }
+    return names.join(',');
+}
+/**
+ * Describe each set bit of a bitmask as a human-readable sentence.
+ * Unknown bits render as 'unknown permission (bitN)'.
+ */
+function describeMask(mask) {
+    const sentences = [];
+    let known = 0;
+    for (const [name, bit] of Object.entries(exports.PERM_BITS)) {
+        if (mask & bit) {
+            sentences.push(PERM_DESCRIPTIONS[name]);
+            known |= bit;
+        }
+    }
+    let remaining = mask & ~known;
+    for (let i = 0; remaining !== 0 && i < 32; i++) {
+        if (remaining & (1 << i)) {
+            sentences.push(`unknown permission (bit${i})`);
+            remaining &= ~(1 << i);
+        }
+    }
+    return sentences;
+}
+/**
+ * EligibilityModule vouch-config flag bits (EligibilityModule.sol:156-157).
+ * Packed into the `flags` byte of the VouchConfig tuple returned by getVouchConfig.
+ */
+exports.VOUCH_FLAG_ENABLED = 0x01;
+exports.VOUCH_FLAG_COMBINE_HIERARCHY = 0x02;
+/**
+ * Would enabling vouching and default-eligibility on the same hat conflict?
+ *
+ * Audit M-03 made these mutually exclusive in BOTH directions: a hat that everyone is eligible
+ * for by default makes a vouch quorum a no-op, so the contract reverts
+ * DefaultEligibilityConflictsWithVouch. The guard only fires when vouching is enabled AND
+ * combineWithHierarchy is set — vouching alone, or without combine, is fine.
+ */
+function vouchConflictsWithDefaultEligibility(vouchFlags, vouchQuorum, defaultEligible) {
+    const enabled = (vouchFlags & exports.VOUCH_FLAG_ENABLED) !== 0 && vouchQuorum > 0;
+    const combine = (vouchFlags & exports.VOUCH_FLAG_COMBINE_HIERARCHY) !== 0;
+    return enabled && combine && defaultEligible;
+}

package/dist/preflight.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Pre-flight Checks
+ * Read-only validations that run before a write command sends its
+ * transaction, so predictable failures surface as one actionable message
+ * instead of an on-chain revert (or a silent wrong-state write). Contract
+ * reads batch through Multicall3 in a single RPC round-trip; local checks
+ * run concurrently. ALL failures are collected before throwing.
+ */
+import { ethers } from 'ethers';
+import type { SponsoredConfig } from './sponsorship-config';
+export interface CheckResult {
+    ok: boolean;
+    detail?: string;
+    suggestion?: string;
+}
+export interface PreflightCheck {
+    /** Short human label, e.g. 'gas balance' or 'task 12 status'. */
+    label: string;
+    /** Read-only eth_call, batched through Multicall3 with the other checks. */
+    call?: {
+        to: string;
+        data: string;
+    };
+    /** Local/off-chain check; runs concurrently with the batched calls. */
+    local?: () => Promise<CheckResult> | CheckResult;
+    /** Interpret the batched call's result. Used only when `call` is set. */
+    interpret?: (returnData: string, success: boolean) => CheckResult;
+}
+/**
+ * Run all checks (batched calls + concurrent locals), collect every failure,
+ * and throw a single PreconditionError listing them. `opts.skip` (from a
+ * --skip-checks flag) bypasses everything.
+ */
+export declare function runPreflight(provider: ethers.providers.Provider, checks: PreflightCheck[], opts?: {
+    skip?: boolean;
+}): Promise<void>;
+/**
+ * Wallet holds at least `minWei` (default 0.0001 ether) of the chain's
+ * native gas token, read via Multicall3.getEthBalance. Pass the resolved
+ * sponsorship config as `sponsored` to skip the check for sponsored wallets
+ * (the CLI resolves it from env via resolveSponsoredConfig).
+ */
+export declare function checkGasBalance(address: string, minWei?: ethers.BigNumber, sponsored?: SponsoredConfig): PreflightCheck;
+/** Wearer holds the given hat (IHats balanceOf(wearer, hatId) > 0). */
+export declare function checkHasHat(hatsAddress: string, wearer: string, hatId: ethers.BigNumberish): PreflightCheck;
+/** Username is unregistered (UAR getAddressOfUsername returns the zero address). */
+export declare function checkUsernameFree(registryAddr: string, username: string): PreflightCheck;
+/**
+ * Task is in one of `allowedStatuses` (authoritative on-chain read via
+ * TaskManager.getLensData). Options:
+ * - claimerMustBe: task.claimer must equal this address (case-insensitive)
+ * - allowExpiredTakeover: a CLAIMED task outside allowedStatuses still passes
+ *   when its claim deadline has lapsed (deriveClaimState === 'expired-claimable')
+ * - now: injectable unix timestamp for deadline math (tests)
+ */
+export declare function checkTaskStatus(taskManagerAddr: string, taskId: ethers.BigNumberish, allowedStatuses: number[], opts?: {
+    claimerMustBe?: string;
+    allowExpiredTakeover?: boolean;
+    now?: number;
+}): PreflightCheck;
+/**
+ * Proposal ID exists on the voting contract (proposalsCount() > id).
+ *
+ * Kept on RPC on purpose. Counting Proposal/DDVProposal rows in the subgraph
+ * would be semantically equivalent, but it saves nothing and costs something:
+ * this check's `call` rides inside the SAME Multicall3 batch as the gas-balance
+ * check that every write already performs, so dropping it removes zero RPC
+ * round-trips while adding a subgraph round-trip. Worse, the propose→cast
+ * sequence agents run means the proposal is frequently seconds old, and an
+ * un-indexed row would block a perfectly legitimate vote. Net: strictly worse.
+ */
+export declare function checkProposalActive(votingAddr: string, proposalId: number): PreflightCheck;