@escro/sdk 0.4.1 → 0.5.0

package/dist/index.d.ts

@@ -1,21 +1,51 @@
-import { Keypair } from '@solana/web3.js';
+import { Keypair, Connection } from '@solana/web3.js';
+
+interface PlatformConfigAccount {
+    version: number;
+    feeBps: number;
+    oracleAuthority: string;
+    usdcMint: string;
+    treasury: string;
+    bump: number;
+}
 
 type SolanaCluster = "devnet" | "mainnet";
+/**
+ * The minimum escrow `amount` in micro-USDC ($5.00): the worker's net, not the buyer's deposit
+ * (amount plus the additive fee). Mirrors `MIN_ESCROW_AMOUNT` in the program; a test reads the
+ * program source and fails on drift.
+ */
+declare const MIN_ESCROW_AMOUNT: 5000000;
+/**
+ * The most UTF-8 bytes `submit_deliverable`'s `proof_uri` may hold. MIRROR of the `#[max_len]` on
+ * `proof_uri` in the program's `EscrowAccount`; a test reads the program source and fails on
+ * drift. The program bounds the field only by the account's allocation; the
+ * API's submit builder enforces this cap. Checked off chain by `proofUriError`.
+ */
+declare const MAX_PROOF_URI_BYTES: 128;
+declare const ONCHAIN_REFUND_GRACE_SECONDS: 900;
+/**
+ * The furthest escrow deadline, in seconds from now, an agent-driven pay surface accepts (7 days): the
+ * ceiling and the default of the MCP's, SAK's and Eliza's pay bound.
+ */
+declare const PAY_MAX_DEADLINE_SECONDS: 604800;
 
 /**
- * All possible lifecycle states of an AgentEscrow account on-chain.
+ * Lifecycle states of an escrow, each transition validated by the on-chain program.
  *
- * State transitions (happy path):
- * CREATED → FUNDED → IN_PROGRESS → SUBMITTED → COMPLETED
+ * Happy path: FUNDED → IN_PROGRESS → SUBMITTED → COMPLETED (buyer release or the 24h
+ * timeout release).
  *
  * Exception paths:
- * Any state (before COMPLETED) → DISPUTED (human arbitration)
- * CREATED | FUNDED → CANCELLED (buyer cancels before agent accepts)
- * SUBMITTED → COMPLETED (24h timeout auto-release to worker)
- * IN_PROGRESS → REFUNDED (deadline expiry auto-refund to buyer)
+ * IN_PROGRESS | SUBMITTED → DISPUTED (resolved only by arbitration, to COMPLETED or REFUNDED)
+ * FUNDED → CANCELLED (buyer cancels before the claim; on chain the account is REFUNDED)
+ * FUNDED | IN_PROGRESS → REFUNDED (deadline plus grace passed before a submission)
  */
 declare enum EscrowState {
-    /** Escrow PDA created on-chain; awaiting token deposit from the maker. */
+    /**
+     * An unconfirmed intent: the API's create build recorded it and no landed create_escrow has
+     * funded it yet. Never persisted on chain and never served by a read.
+     */
     CREATED = "CREATED",
     /** Maker deposited tokens into the vault; open for agent acceptance. */
     FUNDED = "FUNDED",
@@ -42,15 +72,15 @@ type Network = "mainnet-beta" | "devnet" | "localnet";
  *   - `amount` is in the SPL token's smallest denomination (e.g. μUSDC = 10⁻⁶ USDC).
  *   - timestamps are Unix seconds as stored in the Anchor account.
  *
- * When serialising over HTTP, `amount` is represented as a decimal `string`
- * (see {@link GetEscrowResponse}) to avoid JSON `number` precision loss.
+ * When serialising over HTTP (the API's escrow responses), `amount` is represented as a
+ * decimal `string` of the smallest denomination to avoid JSON `number` precision loss.
  */
 interface EscrowAccount {
     /** Base-58 public key of the escrow PDA. */
     address: string;
     /** Base-58 public key of the task creator (the party paying for the work). */
     maker: string;
-    /** Base-58 public key of the assigned agent, or `null` if no agent has accepted yet. */
+    /** Base-58 public key of the worker assigned at creation (every escrow has one). */
     taker: string | null;
     /** Base-58 public key of the SPL token mint used for payment (e.g. USDC mint). */
     mint: string;
@@ -64,24 +94,28 @@ interface EscrowAccount {
     /**
      * SHA-256 hex digest of the canonical UTF-8 JSON serialisation of the {@link TaskSpec}.
      * Recorded on-chain (the account's `spec_hash` holds this hash, bare, or as `ipfs://<hash>` on
-     * escrows created before P18.T0c), so the buyer and worker (and an arbitrator) can check that a
+     * older escrows), so the buyer and worker (and an arbitrator) can check that a
      * spec is the one the escrow was created for.
      */
     taskSpecHash: string;
     /**
      * The exact string the escrow's on-chain `spec_hash` holds: the bare 64-hex `taskSpecHash`
-     * (escrows created since P18.T0c), `ipfs://<taskSpecHash>` (earlier), `null` before the
-     * spec_uri migration ran. A label for the {@link TaskSpec}'s hash, not a fetchable copy (Escro
-     * stores no spec body; the buyer shares the spec).
+     * (current creates), `ipfs://<taskSpecHash>` (older escrows), or `null` where the API's record
+     * of an older escrow lacks it. A label for the {@link TaskSpec}'s hash, not a fetchable copy
+     * (Escro stores no spec body; the buyer shares the spec).
      */
     taskSpecUri: string | null;
-    /** Base-58 public key of the oracle authority permitted to sign timeout_release / refund_buyer. */
+    /**
+     * Base-58 public key of the oracle authority permitted to sign timeout_release
+     * (refund_buyer is permissionless).
+     */
     oracle: string;
     /**
-     * Platform fee in basis points. The API serves the value it recorded at registration
-     * (`PLATFORM_FEE_BPS`, the mirror of PlatformConfig `fee_bps`); on chain `create_escrow`
-     * stores PlatformConfig's value. Additive: the buyer deposits `amount` plus the fee and
-     * the worker receives the full `amount`.
+     * Platform fee in basis points. Once the API has read the escrow's `create_escrow` from chain,
+     * it serves the escrow's on-chain `fee_bps` from its `EscrowCreated` event (PlatformConfig's
+     * value, stored per escrow at creation); on a CREATED intent not yet read it serves its
+     * `PLATFORM_FEE_BPS` mirror. Additive: the buyer deposits `amount` plus the fee and the
+     * worker receives the full `amount`.
      */
     oracleFeeBps: number;
     /** Unix timestamp (seconds) when the escrow PDA was initialised. */
@@ -115,6 +149,21 @@ interface EscrowAccount {
     /** Solana cluster this account belongs to. */
     network: Network;
 }
+/**
+ * `GET /v1/escrows/outstanding?maker=`: the maker's open deposits, the escrows whose vault still
+ * holds the buyer's money (FUNDED, IN_PROGRESS, SUBMITTED, DISPUTED; never CREATED).
+ */
+interface OutstandingDeposits {
+    /** Base-58 public key of the buyer the figures are for. */
+    maker: string;
+    /** Number of open escrows counted. */
+    count: number;
+    /**
+     * Sum over those escrows of `amount` plus the program's fee at the escrow's stored rate, in
+     * micro-USDC, as a decimal u64 string (it can exceed `Number.MAX_SAFE_INTEGER`).
+     */
+    depositsMicroUsdc: string;
+}
 /** One set of `GET /v1/stats` figures: the public block, or the operator block. */
 interface ProtocolStatsFigures {
     totalEscrows: number;
@@ -139,7 +188,7 @@ interface ProtocolStats extends ProtocolStatsFigures {
     /** That cluster's one USDC mint (`getUsdcMint`): every figure here is in this token. */
     usdcMint: string;
     /**
-     * Escro-operated fleet figures (ARCHITECTURE section 9): the same fields over
+     * Escro-operated fleet figures: the same fields over
      * escrows whose buyer and assigned worker are both in the API's operator
      * allowlist. They are real settlements but not third-party demand, so every
      * public field excludes them; never sum this block with the public fields.
@@ -215,7 +264,7 @@ interface AcceptanceCriterion {
  * This object is:
  *  1. Serialised to canonical UTF-8 JSON (sorted keys, no trailing whitespace).
  *  2. Hashed with SHA-256 → stored on-chain as `EscrowAccount.taskSpecHash`.
- *  3. Written into `create_escrow`'s `spec_hash` bare (since P18.T0c; `ipfs://<hash>` before) and
+ *  3. Written into `create_escrow`'s `spec_hash` bare (`ipfs://<hash>` on older escrows) and
  *     recorded as `EscrowAccount.taskSpecUri` (a label for the hash; Escro stores no spec body,
  *     and the buyer shares the spec itself).
  *
@@ -261,8 +310,8 @@ interface TaskSpec {
 
 /**
  * Every machine-readable error code the escro.ai REST API's route handlers send in the `code`
- * field of an error response (a test derives the set from the API source). A request Fastify
- * refuses before a handler runs carries Fastify's own `FST_ERR_*` code instead.
+ * field of an error response, and no other. A request Fastify refuses before a handler runs
+ * carries Fastify's own `FST_ERR_*` code instead.
  *
  * Consumers should switch on this value to handle errors programmatically
  * rather than parsing the human-readable `error` string.
@@ -272,13 +321,15 @@ type EscrowErrorCode =
 "ESCROW_NOT_FOUND"
 /** The requested operation is not permitted in the escrow's current state. */
  | "ESCROW_INVALID_STATE"
-/** Release: the API's RPC still shows the escrow account open at `confirmed`; retry once the release lands. */
+/** Release: no settlement of the escrow is recorded or listed yet; retry once the release lands. */
  | "ESCROW_NOT_SETTLED"
-/** Confirm: no transaction for the signature at `confirmed` yet; retry once it lands. */
+/** Confirm: the escrow PDA was initialised again and the transaction acts on that later lifecycle, which the escrow does not record. */
+ | "ESCROW_PDA_REUSED"
+/** Confirm: the transaction cannot be recorded yet (not visible at `confirmed`, an earlier transaction on its escrow unrecorded, or more escrows than a hint records); retry. */
  | "TX_NOT_FOUND"
 /** Confirm: the transaction landed with an error. */
  | "TX_FAILED"
-/** Confirm: the transaction holds no single escrow instruction this route records for the escrow. */
+/** Confirm: the transaction holds no instruction of the program on the escrow, or one the API does not classify. */
  | "TX_MISMATCH"
 /** The Solana RPC read failed; retry. */
  | "RPC_UNAVAILABLE"
@@ -308,19 +359,19 @@ type EscrowErrorCode =
  | "VALIDATION_ERROR";
 
 /**
- * EscroBots v0 - the permissionless capability directory (ARCHITECTURE §8).
+ * EscroBots v0 - the permissionless capability directory.
  *
  * A bot advertises itself by publishing a wallet-signed capability descriptor.
  * The descriptor is a *claim*, not a verified fact - on-chain history is the
- * verification (surfaced in the Phase 7 v1 directory). The registry performs no
+ * verification (surfaced in the v1 directory). The registry performs no
  * approval, review, or ranking; fraud against the protocol is the only removal
  * criterion. The descriptor document itself is independently verifiable: anyone
  * holding it can check `signature` against `wallet` without trusting the API.
  */
 /**
  * The advertisable roles. Single source for both the `BotRole` type and the API's
- * zod enum (routes/bots.ts uses `z.enum(BOT_ROLES)`), so the accepted values and
- * the type cannot drift: a role added here flows into validation automatically.
+ * validation of a role, so the accepted values and the type cannot drift: a role
+ * added here flows into validation automatically.
  */
 declare const BOT_ROLES: readonly ["worker", "buyer", "both"];
 /** Whether the bot hires work, performs work, or both. */
@@ -384,6 +435,184 @@ interface ReviewPolicy {
     evaluate(deliverable: ReviewDeliverable): ReviewResult | Promise<ReviewResult>;
 }
 
+interface ResourceInfo {
+    url: string;
+    description?: string;
+    mimeType?: string;
+    /** Service metadata a discovery catalog lists (x402 `specs/extensions/bazaar.md` at e4a08681). */
+    serviceName?: string;
+    tags?: string[];
+    iconUrl?: string;
+    [member: string]: unknown;
+}
+/** How a discovery catalog calls an HTTP endpoint: `info.input` of a `bazaar` declaration. */
+interface BazaarHttpInput {
+    type: "http";
+    method: "GET" | "HEAD" | "DELETE" | "POST" | "PUT" | "PATCH";
+    bodyType?: "json" | "form-data" | "text";
+    body?: unknown;
+    queryParams?: Record<string, unknown>;
+    headers?: Record<string, string>;
+}
+/** `extensions.bazaar` of a 402 (x402 `specs/extensions/bazaar.md` at e4a08681). */
+interface BazaarDeclaration {
+    info: {
+        input: BazaarHttpInput;
+        output?: {
+            type: string;
+            format?: string;
+            example?: unknown;
+        };
+    };
+    schema: Record<string, unknown>;
+}
+interface PaymentRequirements {
+    scheme: string;
+    network: string;
+    amount: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra?: Record<string, unknown>;
+}
+interface PaymentRequired {
+    x402Version: 2;
+    error?: string;
+    resource: ResourceInfo;
+    accepts: PaymentRequirements[];
+    extensions?: Record<string, unknown>;
+}
+interface PaymentPayload<P = Record<string, unknown>> {
+    x402Version: 2;
+    resource?: ResourceInfo;
+    accepted: PaymentRequirements;
+    payload: P;
+    extensions?: Record<string, unknown>;
+}
+interface SettlementResponse {
+    success: boolean;
+    transaction: string;
+    network: string;
+    payer?: string;
+    errorReason?: string;
+    errorMessage?: string;
+    /** The amount settled, where the scheme reports one (`upto`). */
+    amount?: string;
+    extensions?: Record<string, unknown>;
+}
+/** A facilitator's `/verify` answer. */
+interface VerifyResponse {
+    isValid: boolean;
+    invalidReason?: string;
+    invalidMessage?: string;
+    payer?: string;
+}
+/** One scheme and network a facilitator settles, from its `/supported` answer. */
+interface SupportedKind {
+    x402Version: number;
+    scheme: string;
+    network: string;
+    extra?: Record<string, unknown>;
+}
+/** A facilitator's `/supported` answer. */
+interface SupportedResponse {
+    kinds: SupportedKind[];
+    extensions: string[];
+    signers: Record<string, string[]>;
+}
+/** What a worker's menu settles an `exact` payment through: the SDK's `createHttpFacilitator`, or any equivalent. */
+interface Facilitator {
+    verify(payment: PaymentPayload, requirements: PaymentRequirements): Promise<VerifyResponse>;
+    settle(payment: PaymentPayload, requirements: PaymentRequirements): Promise<SettlementResponse>;
+    getSupported(): Promise<SupportedResponse>;
+}
+type OnDeliveryScheme = "on-delivery" | "job-escrow";
+type SettlementMode = "release" | "refund";
+type OnDeliveryExtra = Readonly<{
+    program: string;
+    specHash: string;
+    specUri: string;
+    deadline: number;
+    reviewWindowSeconds: number;
+    feeBps: number;
+    feePayer: "client";
+    settlementMode: SettlementMode;
+    paymentFlow: "upfront" | "escrow";
+}>;
+interface OnDeliveryAccept extends PaymentRequirements {
+    scheme: OnDeliveryScheme;
+    extra: OnDeliveryExtra;
+}
+interface OnDeliveryPayloadFields {
+    escrow: string;
+    buyer: string;
+    taskId: string;
+    createSignature: string;
+    /** Unix milliseconds. */
+    signedAt: number;
+    buyerSignature: string;
+}
+interface OnDeliveryPaymentPayload extends PaymentPayload<OnDeliveryPayloadFields> {
+    accepted: OnDeliveryAccept;
+}
+/**
+ * The `escro` x402 extension's `acceptance` (docs/specs/escro-extension.md "acceptance";
+ * `$defs.acceptance` in escro-extension.schema.json): the predicate a judge applies to a delivery.
+ * `paramsHash` is the SHA-256 hex of the RFC 8785 canonical JSON of the predicate's parameters.
+ */
+interface Acceptance {
+    name: string;
+    paramsHash: string;
+    fixtureHashes?: string[];
+}
+interface EscroReceipt {
+    schema: string;
+    verifierUrl?: string;
+}
+interface EscroSettlementTerms {
+    reviewWindowSeconds: number;
+    settlementMode: SettlementMode;
+    feePayer: "client" | "worker";
+}
+type EscroNextAction = {
+    channel: "onchain";
+    action: string;
+    actor: string;
+    notBefore?: number;
+    network: string;
+    instruction: string;
+    address?: string;
+    args?: Record<string, unknown>;
+} | {
+    channel: "server";
+    action: string;
+    actor: string;
+    notBefore?: number;
+    method: "GET" | "POST";
+    url: string;
+} | {
+    channel: "mcp";
+    action: string;
+    actor: string;
+    notBefore?: number;
+    server: string;
+    tool: string;
+    args?: Record<string, unknown>;
+};
+interface EscroExtensionInfo {
+    acceptance?: Acceptance;
+    receipt?: EscroReceipt;
+    settlement?: EscroSettlementTerms;
+    nextActions?: EscroNextAction[];
+}
+/** The hex SHA-256 of a TaskSpec's canonical JSON: what an escrow's `spec_hash` holds. */
+declare function computeTaskSpecHash(spec: TaskSpec): string;
+/**
+ * Why `uri` cannot be submitted as a deliverable's `proofUri`, or null when it can. The on-chain
+ * `proof_uri` allocation counts UTF-8 bytes, so a URI whose UTF-16 length fits can still be too long.
+ */
+declare function proofUriError(uri: string): string | null;
+
 /** Dispute tally with its outcome split (from the wallet's perspective). */
 interface DisputeRecord {
     /** Total disputes this wallet was party to (raised by either side). */
@@ -473,14 +702,20 @@ interface ServedWalletReputation extends SerializedWalletReputation {
     walletAgeSeconds: number | null;
 }
 
+/** Docs for the payment rails, linked from the rail-not-enabled error and the kit config's rejection
+ *  message so both point to the same place. Re-exported from `payments.ts`. */
+declare const RAILS_DOCS_URL = "https://escro.ai/rails";
 /**
  * Base class for all errors thrown by the @escro/sdk. `retryAfterMs` is the
- * server's Retry-After delay, when it sent one in seconds.
+ * server's Retry-After delay, when it sent one in seconds; `options.cause` is the
+ * failure this error reports.
  */
 declare class EscroError extends Error {
     readonly code: string;
     readonly retryAfterMs?: number | undefined;
-    constructor(message: string, code?: string, retryAfterMs?: number | undefined);
+    constructor(message: string, code?: string, retryAfterMs?: number | undefined, options?: {
+        cause?: unknown;
+    });
 }
 /** The requested escrow was not found (HTTP 404). */
 declare class EscrowNotFoundError extends EscroError {
@@ -522,13 +757,55 @@ declare class UnauthorizedError extends EscroError {
     constructor(message?: string);
 }
 /**
- * A payment rail was requested that is not enabled in this build. The `x402`
- * (synchronous) rail is reserved (ARCHITECTURE §7a) and lands in Phase 9;
- * {@link Escro.pay} throws this until then. `rail` names the unavailable rail.
+ * A payment rail is not available. {@link Escro.pay} throws this for the `x402` rail when its
+ * packages fail to load (`cause` is the load failure); nothing was signed and nothing is counted.
+ * `rail` names the unavailable rail.
  */
 declare class EscroRailNotEnabledError extends EscroError {
     readonly rail: string;
-    constructor(rail: string);
+    constructor(rail: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Why {@link Escro.pay} refused a payment; see {@link EscroPayError}. */
+type PayRefusal = "no_offer" | "both_offers" | "url" | "request_header" | "request" | "redirect" | "not_402" | "resource_mismatch" | "no_eligible_entry" | "timeout_ceiling" | "policy_choice" | "unsupported_scheme" | "scheme_conflict" | "presentation" | "settlement" | "timeout" | "requirements" | "transaction" | "host";
+/**
+ * {@link Escro.pay} refused, or the payment router refused a scheme; `reason` names the check and
+ * `detail` the offending value where there is one. Once the escrow is created, `escrowPda` and
+ * `createSignature` are set: the escrow is funded, and `cancelEscrow(escrowPda)` recovers the
+ * deposit while it is Funded. `status` is the paid request's HTTP status when it answered. On the
+ * x402 rail a failure after the payment left the process carries `payment`, and no `escrowPda`. A
+ * paid request answered with an error status carries `settlement` when the answer's
+ * `PAYMENT-RESPONSE` decodes with a boolean `success` and a string `transaction` and `network`:
+ * the worker's own unverified report, whatever its `success`.
+ */
+declare class EscroPayError extends EscroError {
+    readonly reason: PayRefusal;
+    readonly detail?: string;
+    readonly escrowPda?: string;
+    readonly createSignature?: string;
+    readonly status?: number;
+    /**
+     * What a failed x402 settlement can be matched by against the wallet's token-account history, in
+     * case the resource server still lands the transfer: the Memo instruction's text (byte-exact),
+     * the amount and `payTo`. Never the partially signed transaction.
+     */
+    readonly payment?: {
+        readonly memo: string;
+        readonly amountMicroUsdc: number;
+        readonly payTo: string;
+    };
+    /** The `PAYMENT-RESPONSE` a worker sent beside an error status: its unverified word, as sent. */
+    readonly settlement?: SettlementResponse;
+    constructor(reason: PayRefusal, message: string, options?: {
+        detail?: string;
+        escrowPda?: string;
+        createSignature?: string;
+        status?: number;
+        payment?: EscroPayError["payment"];
+        settlement?: SettlementResponse;
+        cause?: unknown;
+    });
 }
 
 /** Constructor options for the {@link Escro} client. */
@@ -536,7 +813,7 @@ interface EscroOptions {
     /**
      * Which Solana cluster this client talks to. Required so the program ID and
      * USDC mint resolve correctly. Pass `"devnet"` for testing, `"mainnet"` for
-     * production. Breaking change in SDK 0.2.0 (previously implicit devnet).
+     * production.
      */
     cluster: SolanaCluster;
     /** Solana RPC endpoint URL. */
@@ -545,6 +822,92 @@ interface EscroOptions {
     apiUrl: string;
     /** Ed25519 keypair used to sign transactions and API requests. */
     wallet: Keypair;
+    /**
+     * The most micro-USDC this wallet may hold locked in open escrows, each counted as its
+     * deposit: amount plus fee. {@link Escro.createEscrow} refuses (`SPEND_CAP_EXCEEDED`), before
+     * the create is sent, a create whose deposit would pass it. Required for `createEscrow` on
+     * `"mainnet"`, which refuses without it; the other methods never read it. Copied at
+     * construction.
+     *
+     * Outstanding is the API's total of the wallet's FUNDED, IN_PROGRESS, SUBMITTED and DISPUTED
+     * deposits (one `GET /v1/escrows/outstanding` per create), plus this process's own creates in
+     * flight: a create holds its deposit from the API's answer to its POST. A create that throws
+     * before its transaction is sent (the SDK's refusal of the server's transaction as not the
+     * create it asked for, `UNEXPECTED_TRANSACTION`; an undecodable server transaction; a failed
+     * blockhash read) holds nothing. Once sent, the hold lasts until a successful
+     * {@link Escro.confirm} of its address, until a later create's admission reads the escrow from
+     * the API (one `GET /v1/escrows/:address` per create in flight; a read that fails keeps the
+     * hold and refuses nothing), or until evidence shows the transaction never took effect: the
+     * RPC rejected it (a `SendTransactionError`) other than as already processed, or it failed at
+     * execution (`TX_FAILED`, from the send's confirmation or a confirm). A create that throws
+     * after its transaction is sent for any other reason (a transport error, a confirmation
+     * timeout, an `EscroConfirmError`) keeps counting, and shrinks the cap's room, until
+     * `confirm(address, signature)` succeeds or the process exits. An "already processed" rejection carries no signature to confirm with, so its
+     * hold lasts until the process exits. An outstanding read that fails, answers something
+     * malformed or takes longer than 15 s refuses the create (`SPEND_CAP_UNREADABLE`, a failed or
+     * timed-out read as its `cause`); a PlatformConfig read that fails or takes longer than 15 s
+     * throws its own error, with no code.
+     *
+     * The cap holds per process: every capped `Escro` for one wallet and cluster in the process
+     * shares one admission queue and one in-flight set. Two processes or hosts on one wallet each
+     * enforce it and together can pass it by the other's in-flight deposits; run one buyer process
+     * per wallet, or give each process its share.
+     */
+    spendCap?: {
+        /** The cap, in integer micro-USDC (1 USDC = 1_000_000); deposits equal to it are allowed. */
+        maxOutstandingMicroUsdc: number;
+        /**
+         * Replaces the API read: the micro-USDC already locked in this wallet's open escrows,
+         * deposits counted. The process's in-flight creates are added to its answer. Called with the
+         * `spendCap` object given at construction as `this`. Bound like the API read: one that has
+         * not answered within 15 s is abandoned (it is passed no signal, so it is not cancelled) and
+         * the create refused with `SPEND_CAP_UNREADABLE`.
+         */
+        outstanding?: () => Promise<number>;
+    };
+    /**
+     * The most micro-USDC {@link Escro.pay} may spend over the x402 rail, separate from
+     * {@link EscroOptions.spendCap}: neither cap draws on the other. Required for an `exact` payment
+     * on `"mainnet"`, which refuses without it (`SPEND_CAP_REQUIRED`); a payment that would pass it
+     * refuses (`SPEND_CAP_EXCEEDED`). Copied at construction.
+     *
+     * A payment counts at its full amount from admission, before it is signed, and is credited back
+     * only if it is refused before its signature exists: once signed it stays counted, because the
+     * resource server can still land the transfer. The budget is per process, per cluster and wallet,
+     * and RESETS WHEN THE PROCESS RESTARTS; give `spent` to carry a budget across restarts.
+     */
+    x402SpendCap?: {
+        /** The cap, in integer micro-USDC (1 USDC = 1_000_000); spending up to it is allowed. */
+        maxMicroUsdc: number;
+        /**
+         * The micro-USDC the operator records as already spent on this wallet's x402 rail, added to the
+         * process's own total. A reader that also counts this process's payments double-counts them,
+         * which refuses early and never overspends. Called with the `x402SpendCap` object given at
+         * construction as `this`. One that fails, answers anything but a whole non-negative number or
+         * takes longer than 15 s refuses the payment (`SPEND_CAP_UNREADABLE`).
+         */
+        spent?: () => Promise<number>;
+    };
+}
+/** The {@link EscroOptions.spendCap} option. */
+type SpendCap = NonNullable<EscroOptions["spendCap"]>;
+/** The {@link EscroOptions.x402SpendCap} option. */
+type X402SpendCap = NonNullable<EscroOptions["x402SpendCap"]>;
+/** How a lifecycle call (create, claim, submit, cancel, dispute, release) sends its transaction. */
+interface SendOptions {
+    /**
+     * `true` (the default): send, wait for the transaction to confirm on chain, then have the API
+     * record it. `false`: check and sign the transaction exactly as the default does, send it and
+     * return its signature without waiting or notifying the API. The caller learns the outcome by
+     * `getEscrow(address)` (the API records every landed transaction within about a minute plus
+     * finality), by the signature's status on chain, or by
+     * `confirm(address, signature)` as a hint. A dispute's evidence travels
+     * only with the disputant's confirm, so `raiseDispute` with `evidence` refuses `wait: false`.
+     * Under {@link EscroOptions.spendCap}, a create sent this way stays counted as in flight until
+     * a later create's admission reads the escrow from the API, a confirm records it, or a confirm
+     * of its signature shows it failed on chain.
+     */
+    wait?: boolean;
 }
 /** Parameters for creating a new escrow. */
 interface CreateEscrowParams {
@@ -559,7 +922,7 @@ interface CreateEscrowParams {
     /** Unix timestamp (seconds) at which the escrow deadline expires. */
     deadlineUnix: number;
     /**
-     * Base-58 public key of the worker assigned to this task. Required —
+     * Base-58 public key of the worker assigned to this task. Required:
      * every escrow is created against a specific worker (open tasks are
      * not supported).
      */
@@ -589,6 +952,10 @@ interface ReleasePaymentOutcome {
         error: EscroConfirmError;
     };
 }
+/** {@link ReleasePaymentOutcome} of a predicate release, with the decision memo it carried. */
+type ReleaseWithPredicateOutcome = ReleasePaymentOutcome & {
+    memo: string;
+};
 /** Parameters for submitting a deliverable. */
 interface SubmitDeliverableParams {
     /** SHA-256 hex digest (or content-addressed hash) of the deliverable content. */
@@ -607,9 +974,9 @@ interface RaiseDisputeParams {
 interface PollOptions {
     /**
      * Enable polling with exponential backoff.
-     * - 0–5 min: poll every 15 s
-     * - 5–30 min: poll every 30 s
-     * - 30 min–24 h: poll every 60 s
+     * - 0 to 5 min: poll every 15 s
+     * - 5 to 30 min: poll every 30 s
+     * - 30 min to 24 h: poll every 60 s
      * - After 24 h: throws {@link EscrowTimeoutError}
      * @default false
      */
@@ -648,9 +1015,9 @@ interface ListBotsParams {
 }
 /**
  * One candidate returned by {@link Escro.findWorkers}. The `descriptor` is a
- * self-reported CLAIM (ARCHITECTURE §8); `signatureValid` attests only that the
+ * self-reported CLAIM; `signatureValid` attests only that the
  * claim was genuinely signed by `descriptor.wallet` (authorship), NOT that its
- * capabilities are true. On-chain history (EscroRep, Phase 7) is the verification
+ * capabilities are true. On-chain history (EscroRep) is the verification
  * of the claim, deliberately kept separate here, never merged into one flag.
  */
 interface WorkerCandidate {
@@ -661,30 +1028,26 @@ interface WorkerCandidate {
 }
 
 /**
- * Reserved dual-path payment surface (ARCHITECTURE §7a, BOT_KIT_PRD §10).
+ * The dual-path payment surface: the escrow rail and the x402 rail behind one `pay()`.
  *
- * PLUMBING ONLY. The escrow rail is the sole implemented backend; the `x402`
- * (synchronous) rail is reserved and lands in Phase 9 as an additive backend.
- * Every name here is a FREEZE CONTRACT that Phase 9 inherits "by name":
- * enabling x402 must not be a breaking change for any kit-generated bot. The
- * shapes below are pinned by a type-level test (src/__tests__/payments.test.ts);
- * Phase 9 may add only OPTIONAL fields.
+ * `pay()` reaches the escrow rail from a 402's `on-delivery` or `job-escrow` entry and
+ * the x402 rail from an `exact` entry. Every name here is a FREEZE CONTRACT: a new rail
+ * or field must not be a breaking change for any kit-generated bot.
+ * The shapes below are pinned by a type-level test; fields are added only as
+ * OPTIONAL fields.
  */
+
 /** Single source for the rail identifiers. The {@link Rail} type is derived from
  *  this list (drift-safe, mirroring the BOT_ROLES pattern in @escro/shared). */
 declare const RAILS: readonly ["escrow", "x402"];
-/** The payment rails Escro can route across. Only `escrow` is implemented today;
- *  `x402` is RESERVED and not enabled until Phase 9. */
+/** The payment rails Escro can route across. */
 type Rail = (typeof RAILS)[number];
-/** The rails enabled in this build. Frozen to escrow-only until Phase 9 enables
- *  x402. Typed `readonly Rail[]` (not the literal tuple) so runtime membership
- *  checks stay honest: `ENABLED_RAILS.includes(rail)` narrows nothing away. */
+/** The rails enabled in this build. Typed `readonly Rail[]` (not the literal tuple) so
+ *  runtime membership checks stay honest: `ENABLED_RAILS.includes(rail)` narrows nothing
+ *  away. */
 declare const ENABLED_RAILS: readonly Rail[];
-/** Docs for the payment rails, linked from the reserved-rail error and the kit
- *  config's rejection message so both point to the same place. */
-declare const RAILS_DOCS_URL = "https://docs.escro.ai/rails";
 /** The minimal payment shape a {@link PaymentRouter} inspects to choose a rail.
- *  FROZEN; Phase 9 may add only optional fields. */
+ *  FROZEN; the x402 rail may add only optional fields. */
 interface TxShape {
     /** Recipient wallet address (base58). */
     readonly to: string;
@@ -692,26 +1055,76 @@ interface TxShape {
     readonly amountMicroUsdc: number;
     /** `async` (verification-needed) work routes to escrow; `sync` work is x402's territory. */
     readonly mode: "async" | "sync";
+    /** The 402 entry being paid; its `scheme` routes when `scheme` is absent. */
+    readonly accept?: PaymentRequirements;
+    /** The x402 scheme being paid; given with `accept`, the two must be equal. */
+    readonly scheme?: string;
 }
-/** Chooses the rail for a payment. Defined now with a single backend; `x402` is
- *  returned only once that rail is enabled (Phase 9). FROZEN signature. */
+/** Chooses the rail for a payment, throwing rather than return a rail that is not
+ *  enabled. FROZEN signature. */
 interface PaymentRouter {
     selectRail(tx: TxShape): Rail;
 }
-/** The one backend shipped today. Async work routes to escrow; sync work would
- *  prefer x402, but x402 is reserved and not enabled (ARCHITECTURE §7a), so the
- *  router falls back to escrow rather than ever returning a disabled rail. */
+/**
+ * The router. With no scheme, async work routes to escrow and sync work prefers x402, falling back
+ * to escrow when x402 is not enabled. With a scheme (`tx.scheme`, else `tx.accept.scheme`),
+ * `on-delivery` and `job-escrow` route to escrow under `async`, `exact` and `upto` to x402 under
+ * `sync`. It throws {@link EscroPayError} `scheme_conflict` when `scheme` and `accept.scheme`
+ * differ or the mode is not the scheme's, `unsupported_scheme` for any other scheme, and
+ * {@link EscroRailNotEnabledError} for a scheme whose rail is not enabled: a scheme's rail is never
+ * swapped for another.
+ */
 declare class EscrowPaymentRouter implements PaymentRouter {
     selectRail(tx: TxShape): Rail;
 }
-/** Parameters for a synchronous payment via {@link Escro.pay}. FROZEN: both
- *  fields are required now so Phase 9 adds only optional fields; a required field
- *  added later would break every kit-generated bot. */
+/** The HTTP request {@link Escro.pay} pays for: sent as given, plus `PAYMENT-SIGNATURE` once paid. */
+interface PayRequest {
+    /** Default `GET`. */
+    readonly method?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly body?: string;
+}
+/** What a {@link PayPolicy} sees of the 402 beside its entries. */
+interface PayOffer {
+    readonly resource: ResourceInfo;
+    readonly extensions?: Readonly<Record<string, unknown>>;
+}
+/** Chooses the entry to pay from a deep-frozen copy of the 402's `accepts`; it returns one of those
+ *  elements. It can only narrow: the entry must still match the caller's `to` and amount. */
+type PayPolicy = (accepts: readonly PaymentRequirements[], offer: PayOffer) => PaymentRequirements;
+/** Parameters for {@link Escro.pay}. FROZEN: `to` and `amountMicroUsdc` stay
+ *  required and every other field optional; a required field added later would break
+ *  every kit-generated bot. Exactly one of `paymentRequired` and `url` is given. */
 interface PayParams {
-    /** Recipient wallet address (base58). */
+    /** Recipient wallet address (base58): the only worker paid. */
     readonly to: string;
-    /** Amount to pay, in USDC micro-units (integer, 6 decimals). */
+    /** Amount to pay, in USDC micro-units (integer, 6 decimals): the only amount paid. */
     readonly amountMicroUsdc: number;
+    /** A 402 the caller already decoded; the paid request goes to its `resource.url`. */
+    readonly paymentRequired?: PaymentRequired;
+    /**
+     * An absolute http: or https: URL without credentials, requested for its 402. A `url`, or with
+     * `paymentRequired` the 402's `resource.url`, on a port `fetch` blocks is refused before any
+     * lookup or request.
+     */
+    readonly url?: string;
+    /** The request being paid for; default a bare `GET`. */
+    readonly request?: PayRequest;
+    /**
+     * Chooses among the entries. Absent, the escrow rail wins: when an `on-delivery` or `job-escrow`
+     * entry matches the caller's terms an `exact` entry is never paid, whatever the 402's order, and
+     * the 402's order decides only within a rail. A policy overrides that.
+     */
+    readonly policy?: PayPolicy;
+    /** Decides an `acceptance` predicate the 402 carries; absent, such a 402 is refused. */
+    readonly admitAcceptance?: (acceptance: Acceptance) => boolean;
+    /**
+     * Decides each address pay() may connect to. Given, pay() resolves each host it requests (the 402's resource, and on
+     * the escrow rail the job specification's host) once per call with lookup(host, { all: true }), passes every answer
+     * (or the literal address) here with the request's target, and connects only to those answers; an address is admitted
+     * only when this returns true, and one refused answer refuses the call.
+     */
+    readonly admitAddress?: (address: string, target: "resource" | "spec") => boolean;
 }
 /** Result of a completed payment. FROZEN and rail-generic: `reference` is the
  *  rail-native settlement id (a Solana signature for escrow, an x402 receipt for
@@ -719,9 +1132,157 @@ interface PayParams {
 interface PaymentResult {
     /** Which rail settled the payment. */
     readonly rail: Rail;
-    /** Rail-native settlement reference. */
+    /** Rail-native settlement reference: on the escrow rail, the `create_escrow` signature; on the
+     *  x402 rail, the settlement's transaction. */
     readonly reference: string;
+    /** Escrow rail: the escrow's PDA, the handle for `cancelEscrow` and every later call. */
+    readonly escrow?: string;
+    /** The paid request's `PAYMENT-RESPONSE`, decoded. */
+    readonly settlement?: SettlementResponse;
+    /** The paid request's response, its body unread. */
+    readonly response?: Response;
+}
+
+type PredicateName = "hash-matches" | "tests-pass" | "json-schema" | "file-format" | "pod-receipt" | "llm-rubric" | "ci-check" | "period-sla" | "attestation-valid";
+/** The job a decision record decides (docs/specs/escro-extension.md "Decision record", `job`). */
+interface DecisionJob {
+    /** CAIP-2: `solana:<32 base58>` or `eip155:<decimal chain id>`. */
+    network: string;
+    /** Solana: the base58 program id; ERC-8183: the lowercase `0x` contract address. */
+    program: string;
+    /** Solana: the escrow PDA, base58; ERC-8183: the jobId in decimal. */
+    id: string;
+}
+/** The one decision record the `escro` extension defines (docs/specs/escro-extension.md "Decision record"). */
+interface DecisionRecord {
+    acceptance: Acceptance;
+    decision: "pass" | "fail";
+    deliverableHash: string;
+    job: DecisionJob;
+}
+interface Delivery {
+    /** The delivered bytes, as the deliverable derivation defines them. */
+    bytes: Uint8Array;
+    /** pod-receipt: a base58 ed25519 signature. */
+    receipt?: string;
+    /** attestation-valid: the attestation as the worker supplied it. */
+    attestation?: Uint8Array;
+}
+/** Every external evaluator is the buyer's own function; the library calls nothing else. */
+interface PredicateContext {
+    runTests?(i: {
+        suite: string;
+        delivery: Uint8Array;
+    }): Promise<{
+        passed: number;
+        failed: number;
+    }>;
+    grade?(i: {
+        rubric: string;
+        model: string;
+        delivery: Uint8Array;
+    }): Promise<number>;
+    ciStatus?(i: {
+        repository: string;
+        revision: string;
+        check: string;
+    }): Promise<"success" | "failure" | "pending" | "missing">;
+    samples?(i: {
+        metric: string;
+        from: number;
+        to: number;
+    }): Promise<number[]>;
+    verifyAttestation?(i: {
+        kind: string;
+        attestation: Uint8Array;
+    }): Promise<{
+        valid: boolean;
+        subjectSha256: string;
+    }>;
+}
+interface PredicateOutcome {
+    decision: "pass" | "fail";
+    reason: string;
+}
+interface Predicate<P = unknown> {
+    readonly name: PredicateName;
+    /** Throws {@link PredicateParamsError}; callable before funding. */
+    parseParams(raw: unknown): P;
+    evaluate(delivery: Delivery, params: P, ctx: PredicateContext): Promise<PredicateOutcome>;
+}
+/** Parameters a predicate does not accept, or that do not hash to the advertised `paramsHash`. */
+declare class PredicateParamsError extends EscroError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** A decision record, or an `acceptance`, the extension's schema refuses. */
+declare class PredicateRecordError extends EscroError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** No decision was reached: the buyer's evaluator is absent, failed, or cannot decide yet. */
+declare class PredicateEvaluationError extends EscroError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** RFC 8785 canonical JSON: a refusal pass ({@link PredicateParamsError}), then the shared `canonicalize`. */
+declare function jcs(value: unknown): string;
+/** The SHA-256 hex of the UTF-8 {@link jcs} of `params`: what `acceptance.paramsHash` carries. */
+declare function paramsHash(params: unknown): string;
+
+declare const attestationValid: Predicate;
+
+declare const ciCheck: Predicate;
+
+declare const fileFormat: Predicate;
+
+declare const hashMatches: Predicate;
+
+declare const jsonSchema: Predicate;
+
+declare const llmRubric: Predicate;
+
+declare const periodSla: Predicate;
+
+declare const podReceipt: Predicate;
+
+declare const testsPass: Predicate;
+
+/** The `escro` extension's predicate catalogue (docs/specs/escro-extension.md "Predicate catalogue"). */
+declare const PREDICATES: Readonly<Record<PredicateName, Predicate>>;
+interface PredicateCheck {
+    acceptance: Acceptance;
+    params: unknown;
+    /** The job the record decides; build it with {@link predicateJob}. */
+    job: DecisionJob;
+}
+interface PredicateResult {
+    record: DecisionRecord;
+    memo: string;
+    reason: string;
 }
+/**
+ * The job a record decides on Solana: this cluster's CAIP-2 network and Escro program, and the
+ * escrow's address. Throws {@link PredicateRecordError} when `address` is not a canonical base58
+ * key of 32 bytes.
+ */
+declare function predicateJob(cluster: SolanaCluster, address: string): DecisionJob;
+/** The SHA-256 hex of the UTF-8 {@link jcs} of a valid decision record. */
+declare function decisionRecordHash(record: DecisionRecord): string;
+/** `escro:predicate:<name>:<pass|fail>:<decisionRecordHash>`. Throws {@link PredicateRecordError}. */
+declare function predicateMemo(record: DecisionRecord): string;
+/**
+ * Applies one advertised check to a delivery, in the buyer's process: refuses an `acceptance` the
+ * extension refuses, a `job` the extension refuses, a name this library does not implement, params
+ * the predicate refuses, and params that do not hash to `acceptance.paramsHash`, all before the
+ * predicate runs; then returns the one decision record, naming `check.job`, its memo and the
+ * predicate's reason. Throws {@link PredicateEvaluationError} when the buyer's evaluator reaches
+ * no decision.
+ */
+declare function runPredicate(check: PredicateCheck, delivery: Delivery, ctx?: PredicateContext): Promise<PredicateResult>;
 
 declare class Escro {
     private readonly connection;
@@ -729,24 +1290,37 @@ declare class Escro {
     private readonly options;
     private readonly cluster;
     private readonly router;
+    private readonly spendCap;
+    private readonly x402SpendCap;
     constructor(options: EscroOptions);
     /**
      * Create a new escrow: registers with the API, signs and submits the
      * on-chain `create_escrow` transaction, then confirms it with the API.
+     * Before any request it refuses (`VALIDATION_ERROR`) an `assignedWorker` that is not a
+     * base-58 public key or an `amountUsdc` that is not a positive whole number and, on
+     * `"mainnet"`, a client constructed without the `spendCap` option (`SPEND_CAP_REQUIRED`).
+     * With a `spendCap` it refuses (`SPEND_CAP_EXCEEDED`), before the create is sent, a create
+     * whose deposit would pass the cap; see {@link EscroOptions.spendCap}. With
+     * `{ wait: false }` it returns once the create is sent; see {@link SendOptions.wait}.
+     * An error thrown after the transaction was handed to the RPC, unless it shows the transaction
+     * never took effect, is the original error with two own string properties set, `escrowPda` and
+     * `signature`: the create may have landed, and those name it. A rejection that is not an `Error`
+     * becomes a new `Error` carrying the two properties, with the original value as its `cause`.
      *
-     * @returns `{ escrowId, escrowPda, signature }` — use `escrowPda` for all subsequent calls.
+     * @returns `{ escrowId, escrowPda, signature }`; use `escrowPda` for all subsequent calls.
      */
-    createEscrow(params: CreateEscrowParams): Promise<CreateEscrowResult>;
+    createEscrow(params: CreateEscrowParams, options?: SendOptions): Promise<CreateEscrowResult>;
     /**
      * Release payment to the worker. Buyer must be the wallet in the constructor.
      * Builds and submits the `release_payment` on-chain tx FIRST (the chain is the
      * source of truth), then has the API record it, retrying as
      * {@link Escro.releasePaymentWithOutcome} does. Use that method to see whether the
-     * API recorded the release.
+     * API recorded the release. With `{ wait: false }` it returns once the release is sent and
+     * asks the API to record nothing; see {@link SendOptions.wait}.
      *
      * @returns Solana transaction signature.
      */
-    releasePayment(address: string): Promise<string>;
+    releasePayment(address: string, options?: SendOptions): Promise<string>;
     /**
      * {@link Escro.releasePayment}, reporting whether the API recorded the release.
      * `ESCROW_NOT_SETTLED` (the API's RPC does not yet show the escrow closed), the codes
@@ -760,47 +1334,93 @@ declare class Escro {
      * @returns `{ signature, confirm }`.
      */
     releasePaymentWithOutcome(address: string): Promise<ReleasePaymentOutcome>;
+    /**
+     * Release payment on a passing predicate result, with its decision memo
+     * (`escro:predicate:<name>:pass:<record hash>`) as one SPL Memo instruction, last, in the
+     * buyer's own `release_payment`. Before anything is signed it refuses, with an
+     * {@link EscroError}, an `address` that is not a base-58 public key (`VALIDATION_ERROR`, before
+     * any read), then a result whose decision is not `pass` (`PREDICATE_NOT_PASSED`), a record the
+     * extension refuses, a record with no `job` included (`PREDICATE_RECORD`), then a record whose
+     * `job` names another network (`PREDICATE_NETWORK_MISMATCH`), another program
+     * (`PREDICATE_PROGRAM_MISMATCH`) or another escrow (`PREDICATE_JOB_MISMATCH`) than this
+     * client's cluster and `address`, all before any read; and, from the escrow's account read on
+     * chain, an escrow that is not on chain, not owned by the Escro program, not SUBMITTED, or whose
+     * committed `deliverable_hash` is not the record's `deliverableHash`
+     * (`PREDICATE_DELIVERABLE_MISMATCH`). The memo is computed from `result.record`, never taken
+     * from `result.memo`. The release then runs and is recorded as
+     * {@link Escro.releasePaymentWithOutcome} does.
+     *
+     * @returns `{ signature, confirm, memo }`.
+     */
+    releaseWithPredicate(address: string, result: PredicateResult): Promise<ReleaseWithPredicateOutcome>;
+    private assertOwnJob;
+    private assertCommitted;
+    private release;
+    private sendRelease;
     /**
      * Raise a dispute for an escrow. Either the buyer or the assigned worker
      * may call this. Signs and submits the `raise_dispute` on-chain tx, then confirms it with the API.
+     * With `{ wait: false }` it returns once the dispute is sent; `evidence` then is refused
+     * (`VALIDATION_ERROR`) before any request: attach it later with
+     * `confirm(address, signature, { evidence })`. See {@link SendOptions.wait}.
      *
      * @returns Solana transaction signature.
      */
-    raiseDispute(address: string, params: RaiseDisputeParams): Promise<string>;
+    raiseDispute(address: string, params: RaiseDisputeParams, options?: SendOptions): Promise<string>;
     /**
      * Cancel a funded escrow before any worker has claimed it.
      * Buyer must be the wallet in the constructor. Only valid when state is `FUNDED`.
      * Signs and submits the `cancel_escrow` on-chain tx, then confirms it with the API; full USDC refund to buyer.
+     * With `{ wait: false }` it returns once the cancel is sent; see {@link SendOptions.wait}.
      *
      * @returns Solana transaction signature.
      */
-    cancelEscrow(address: string): Promise<string>;
+    cancelEscrow(address: string, options?: SendOptions): Promise<string>;
     /**
-     * Reserved synchronous-payment entrypoint (ARCHITECTURE §7a). `pay()` settles
-     * over the x402 rail, which is not implemented until Phase 9; today it rejects
-     * with {@link EscroRailNotEnabledError}. The signature is FROZEN so enabling
-     * x402 later is not a breaking change for kit-generated bots. For asynchronous,
-     * verification-needed work use {@link createEscrow}, the core product.
+     * Pays an x402 V2 402: `params.url`, which the SDK requests for its 402, or
+     * `params.paymentRequired`, a 402 the caller already decoded. Only an entry paying exactly
+     * `params.amountMicroUsdc` to `params.to` on this client's cluster is paid; `params.policy` can
+     * only narrow the choice. An `on-delivery` (or `job-escrow`) entry is funded through
+     * {@link createEscrow}, with `to` as the assigned worker and its spend cap unchanged, and the
+     * payment is presented once to the URL that answered the 402 (no redirect followed, nothing
+     * retried); the result carries the `create_escrow` signature as `reference`, the escrow PDA, and
+     * the paid request's decoded `PAYMENT-RESPONSE` and response.
      *
-     * Not `async`: it returns a rejected promise (never awaits) so callers can
-     * `await`/`.catch()` it uniformly, and it exercises the same {@link PaymentRouter}
-     * routing seam Phase 9 will implement.
+     * Without a `policy` the escrow rail wins: when an `on-delivery` or `job-escrow` entry matches
+     * the caller's terms it is the one paid, whatever the 402's order. An `exact` entry is paid over
+     * the x402 rail, from this wallet, under {@link EscroOptions.x402SpendCap} (required on mainnet):
+     * the official client builds the transaction, a guarded signer checks it against the entry and
+     * the caller's terms before the key runs, and the payment header goes once to the 402's resource
+     * URL, never to a facilitator. The result's `reference` is the settlement's transaction. An `upto`
+     * entry is never paid ({@link EscroPayError} `unsupported_scheme`). A failure after the payment
+     * left the process (`settlement`, `presentation`, `redirect`, `timeout`) carries `payment`, the
+     * Memo text, amount and `payTo`, to match against the wallet's token-account history; the amount
+     * stays counted. x402 V2 has no idempotency key: two calls are two payments, each counted.
+     *
+     * The first request is bounded by 30 s, the paid request by the entry's `maxTimeoutSeconds`; an
+     * entry over 3600 seconds is not paid. A network failure of the first request rejects
+     * {@link EscroError} `NETWORK_ERROR`, with nothing funded. Refusals are {@link EscroPayError}s; a
+     * failure after the escrow is funded carries `escrowPda` and `createSignature`, and
+     * `cancelEscrow(escrowPda)` recovers the deposit while it is Funded. There is no idempotency key:
+     * two calls fund two escrows. The signature is FROZEN.
      */
     pay(params: PayParams): Promise<PaymentResult>;
     /**
      * Claim an assigned task. Worker must be the wallet in the constructor.
      * Signs and submits the `claim_task` on-chain tx, then confirms it with the API.
+     * With `{ wait: false }` it returns once the claim is sent; see {@link SendOptions.wait}.
      *
      * @returns Solana transaction signature.
      */
-    claimTask(address: string): Promise<string>;
+    claimTask(address: string, options?: SendOptions): Promise<string>;
     /**
      * Submit a deliverable for the buyer to review. Worker must be the wallet.
      * Signs and submits the `submit_deliverable` on-chain tx, then confirms it with the API.
+     * With `{ wait: false }` it returns once the submit is sent; see {@link SendOptions.wait}.
      *
      * @returns Solana transaction signature.
      */
-    submitDeliverable(address: string, params: SubmitDeliverableParams): Promise<string>;
+    submitDeliverable(address: string, params: SubmitDeliverableParams, options?: SendOptions): Promise<string>;
     /**
      * List tasks assigned to the wallet's public key.
      * Optionally filter by state(s) and paginate results.
@@ -808,10 +1428,26 @@ declare class Escro {
      * If `options.poll` is true, polls with exponential backoff until at least
      * one task is returned.
      *
+     * Serves open tasks only (FUNDED, IN_PROGRESS, SUBMITTED); a DISPUTED or settled
+     * escrow assigned to the wallet comes from {@link getMyAssignedEscrows}.
+     *
      * @param state   - Filter by one or more states (first state used as API filter).
      * @param options - Polling, pagination (limit/offset).
      */
     getMyTasks(state?: EscrowState[], options?: PollOptions & ListOptions): Promise<PaginatedResult<EscrowAccount>>;
+    /**
+     * List every escrow assigned to the wallet's public key in any served state,
+     * DISPUTED and the settled states (COMPLETED, REFUNDED) included, unlike
+     * {@link getMyTasks}, which serves open tasks only. Optionally filter by state
+     * and paginate. Never polls.
+     *
+     * A Worker Bot uses this to read its DISPUTED escrows, whose fronted cost stays
+     * committed until arbitration settles them.
+     *
+     * @param state   - Filter by one or more states (first state used as API filter).
+     * @param options - Pagination (limit/offset).
+     */
+    getMyAssignedEscrows(state?: EscrowState[], options?: ListOptions): Promise<PaginatedResult<EscrowAccount>>;
     /**
      * List escrows CREATED by the wallet's public key (the maker / buyer), the
      * mirror of {@link getMyTasks} for the buyer side. Optionally filter by state
@@ -829,20 +1465,20 @@ declare class Escro {
      * Find worker bots in the EscroBots registry, optionally filtered by
      * capability. Queries `GET /v1/bots?role=worker` (the API includes `both`
      * bots) and returns candidates in REGISTRY ORDER: this method does no
-     * ranking, scoring, or reordering (ARCHITECTURE §8: no curation; §13: not a
-     * marketplace). Escro-shipped code never ranks; the caller's own bot decides.
+     * ranking, scoring, or reordering: the directory is an open index with no
+     * curation, not a marketplace. Escro-shipped code never ranks; the caller's own bot decides.
      *
      * Each candidate keeps the CLAIM (`descriptor`) separate from the AUTHORSHIP
      * check (`signatureValid`, verified locally so a third party need not trust the
-     * API). Capabilities remain unverified claims; on-chain history (EscroRep,
-     * Phase 7) is their verification, deliberately not merged in here.
+     * API). Capabilities remain unverified claims; on-chain history (EscroRep)
+     * is their verification, deliberately not merged in here.
      */
     findWorkers(params?: {
         capability?: string;
     } & ListOptions): Promise<WorkerCandidate[]>;
     /**
      * Fetch the EscroRep bulk export: every indexed wallet's RAW reputation
-     * components (ARCHITECTURE §9), each wallet exactly once, in one fetch. Returns
+     * components, each wallet exactly once, in one fetch. Returns
      * the raw components verbatim - this method does NO ranking, scoring, or default
      * weighting (Escro-shipped code never ranks; the caller's own bot weights and
      * decides). Selection layers join these components to {@link findWorkers}
@@ -862,18 +1498,27 @@ declare class Escro {
      * not-yet-visible transaction, an RPC failure, a gateway error or a rate limit
      * for about 30 s (waiting at least a sent Retry-After), never a rejection. Throws
      * {@link EscroConfirmError}; calling again is safe (a replay of a recorded
-     * transition succeeds).
+     * transition succeeds). An `address` that is not a base-58 public key throws an
+     * {@link EscroError} with code `VALIDATION_ERROR` before any request, not an
+     * `EscroConfirmError`. A successful confirm of a create, or a confirm of its signature
+     * refused `TX_FAILED` (the create landed and failed), ends its in-flight hold under
+     * {@link EscroOptions.spendCap}.
      */
     confirm(address: string, signature: string, opts?: {
         evidence?: string;
     }): Promise<EscrowAccount>;
     private retryRecord;
+    private admitCreate;
+    private dropServed;
+    private readOutstanding;
     private send;
     private sendAndConfirm;
     /**
      * Fetch an escrow by its PDA address.
      * If `options.poll` is true, polls with exponential backoff until the escrow
-     * appears (useful immediately after a create tx before the API DB syncs).
+     * appears (useful immediately after a create tx before the API records it).
+     * An `address` that is not a base-58 public key throws an {@link EscroError} with code
+     * `VALIDATION_ERROR` at once, with or without `poll`.
      */
     getEscrow(address: string, options?: PollOptions): Promise<EscrowAccount>;
 }
@@ -885,10 +1530,11 @@ declare class ApiClient {
     private url;
     /** GET /v1/escrows/:address */
     getEscrow(address: string): Promise<EscrowAccount>;
-    /** GET /v1/escrows?assignedTo=...&maker=...&state=... */
+    /** GET /v1/escrows?assignedTo=...&maker=...&taker=...&state=... */
     listEscrows(params: {
         assignedTo?: string;
         maker?: string;
+        taker?: string;
         state?: EscrowState;
         limit?: number;
         offset?: number;
@@ -900,7 +1546,7 @@ declare class ApiClient {
      */
     listBots(params: ListBotsParams): Promise<PaginatedResult<BotDescriptor>>;
     /**
-     * GET /rep : EscroRep bulk export (ARCHITECTURE §9). Unauthenticated public
+     * GET /rep : EscroRep bulk export. Unauthenticated public
      * read (no auth headers). Returns every indexed wallet's RAW components exactly
      * once (no composite score). Ranking layers join against this ONE bulk fetch:
      * the per-wallet endpoint shares a 10/min public-metrics budget, so a
@@ -910,7 +1556,7 @@ declare class ApiClient {
      */
     listReputations(): Promise<ServedWalletReputation[]>;
     /**
-     * GET /rep/:wallet : one wallet's EscroRep RAW components (ARCHITECTURE §9).
+     * GET /rep/:wallet : one wallet's EscroRep RAW components.
      * Unauthenticated public read (no auth headers). Unknown wallets return zeroed
      * components, never 404; a 404 means the deployment mounted no reputation
      * source and surfaces as {@link ReputationUnavailableError}. Shares the public
@@ -919,8 +1565,15 @@ declare class ApiClient {
      */
     getReputation(wallet: string): Promise<ServedWalletReputation>;
     /**
-     * POST /v1/escrows — create escrow, returns unsigned tx + ids.
-     * Requires auth.
+     * GET /v1/escrows/outstanding?maker=: the maker's open deposits (FUNDED, IN_PROGRESS,
+     * SUBMITTED, DISPUTED; never CREATED). Unauthenticated. Abandoned with code `API_TIMEOUT`
+     * after {@link API_REQUEST_TIMEOUT_MS}.
+     */
+    getOutstandingDeposits(maker: string): Promise<OutstandingDeposits>;
+    /**
+     * POST /v1/escrows: registers the escrow and returns its ids and the unsigned
+     * `create_escrow`. Requires auth. Abandoned with code `API_TIMEOUT` after
+     * {@link API_REQUEST_TIMEOUT_MS}.
      */
     createEscrow(params: CreateEscrowParams): Promise<{
         escrowId: string;
@@ -928,14 +1581,14 @@ declare class ApiClient {
         unsignedTx: string;
     }>;
     /**
-     * POST /v1/escrows/:address/claim — returns unsigned tx.
+     * POST /v1/escrows/:address/claim: returns unsigned tx.
      * Requires auth (worker).
      */
     claimTask(address: string): Promise<{
         unsignedTx: string;
     }>;
     /**
-     * POST /v1/escrows/:address/submit — returns unsigned tx.
+     * POST /v1/escrows/:address/submit: returns unsigned tx.
      * Requires auth (worker).
      */
     submitDeliverable(address: string, params: SubmitDeliverableParams): Promise<{
@@ -950,14 +1603,14 @@ declare class ApiClient {
      */
     releasePaymentDb(address: string): Promise<void>;
     /**
-     * POST /v1/escrows/:address/cancel — returns unsigned tx.
+     * POST /v1/escrows/:address/cancel: returns unsigned tx.
      * Requires auth (buyer). Only valid when state is FUNDED.
      */
     cancelEscrow(address: string): Promise<{
         unsignedTx: string;
     }>;
     /**
-     * POST /v1/escrows/:address/dispute — returns unsigned tx.
+     * POST /v1/escrows/:address/dispute: returns unsigned tx.
      * Requires auth (buyer or worker).
      */
     raiseDispute(address: string, params: Pick<RaiseDisputeParams, "reason">): Promise<{
@@ -972,20 +1625,45 @@ declare class ApiClient {
      */
     confirm(address: string, signature: string, evidence?: string): Promise<EscrowAccount>;
     /**
-     * GET /v1/stats — public protocol-wide stats.
+     * GET /v1/stats: public protocol-wide stats.
      * No auth required. Upstream typing in {@link Escro.getStats} narrows the
      * return shape.
      */
     getStats(): Promise<unknown>;
 }
 
+/** The `code` of each {@link EscroError} the spend cap throws. */
+declare const SPEND_CAP_ERROR_CODES: {
+    /** A mainnet `createEscrow` on a client constructed without the `spendCap` option. */
+    readonly required: "SPEND_CAP_REQUIRED";
+    /** The create's deposit would pass the cap. */
+    readonly exceeded: "SPEND_CAP_EXCEEDED";
+    /** The outstanding deposits could not be read. */
+    readonly unreadable: "SPEND_CAP_UNREADABLE";
+};
+/**
+ * Throws an {@link EscroError} with code `SPEND_CAP_EXCEEDED` when the outstanding deposits plus
+ * the proposed one would pass the cap. All three are integer micro-USDC; reaching the cap exactly
+ * is allowed.
+ */
+declare function assertWithinSpendCap(check: {
+    maxOutstandingMicroUsdc: number;
+    outstandingMicroUsdc: number;
+    proposedMicroUsdc: number;
+}): void;
+/**
+ * A plain decimal USDC amount (`"12.5"`, at most six decimals, no sign or exponent) as integer
+ * micro-USDC. Throws an {@link EscroError} with code `VALIDATION_ERROR` otherwise.
+ */
+declare function parseUsdc(text: string): number;
+
 /**
  * The result a {@link ServiceAdapter} returns from `execute`. Escro is agnostic
  * to what produced it: `content` is the deliverable itself, `contentHash` is the
  * SHA-256 hex digest the Buyer verifies the deliverable against, and `proofUri`
  * optionally points at where the content is pinned (IPFS/Arweave) or at a proof.
- * No currency or token field appears here; token conversion is adapter-internal
- * (ARCHITECTURE §3, §7).
+ * No currency or token field appears here; token conversion is adapter-internal,
+ * since the escrow vault holds USDC only.
  */
 interface ServiceResult {
     /** The deliverable itself. */
@@ -1001,7 +1679,7 @@ interface ServiceResult {
  * A Worker Bot implements ServiceAdapter to wrap any async service (a Bittensor
  * subnet, an Akash deployment, a Render job, ...). Escro never sees what is
  * underneath and never sees a non-USDC token: the adapter handles any token
- * conversion internally (ARCHITECTURE §3, §7). Every pre-built adapter reuses
+ * conversion internally. Every pre-built adapter reuses
  * this interface and is validated by `assertServiceAdapterContract`.
  */
 interface ServiceAdapter {
@@ -1014,6 +1692,12 @@ interface ServiceAdapter {
     /** Report whether the underlying service is reachable and ready. */
     healthCheck(): Promise<boolean>;
 }
+/**
+ * The buyer's port that fetches the bytes a `proofUri` names (an IPFS or Arweave gateway,
+ * a storage bucket). A throw or rejection is an infrastructure failure that propagates to
+ * the caller, which retries it; it is never a verdict on the deliverable.
+ */
+type ResolveProofUri = (proofUri: string) => Promise<string | Buffer> | string | Buffer;
 /**
  * Map a {@link ServiceResult} onto {@link SubmitDeliverableParams}, surfacing the
  * `contentHash` (and `proofUri`, when present) that `submit_deliverable` records.
@@ -1041,8 +1725,8 @@ declare class AdapterContractError extends EscroError {
  * ServiceResult produced by `execute(sampleSpec)` when the adapter conforms;
  * rejects with an {@link AdapterContractError} listing every violation otherwise.
  *
- * Reusable across adapters (this phase's Bittensor one, Phase 6's four, Phase 8's
- * networks): a conforming adapter passes, a malformed one fails. The parameter is
+ * Reusable across adapters (the Bittensor subnets, the compute networks, the proof
+ * adapters): a conforming adapter passes, a malformed one fails. The parameter is
  * typed `ServiceAdapter`, but the harness validates at runtime: JS callers and
  * `as`-cast objects reach this too, so every field is checked defensively.
  */
@@ -1072,13 +1756,13 @@ type PinContent$3 = (content: string | Buffer) => Promise<string>;
 
 /**
  * Gradients (Bittensor SN56) ServiceAdapter: the first SHIPPED, supported adapter
- * (the reference pattern P6.T6b-d replicate). A Worker Bot wraps the Gradients
+ * (the reference pattern the other subnet adapters replicate). A Worker Bot wraps the Gradients
  * fine-tuning subnet behind the `ServiceAdapter` interface: it swaps a per-task
  * USDC budget into TAO internally, pays subnet miners in TAO to fine-tune, collects
  * a checkpoint + eval deliverable, and returns a currency-free `ServiceResult`. The
  * Buyer and the escrow contract only ever see USDC; no TAO-typed value crosses this
- * boundary into SDK core (ARCHITECTURE §3, §7; see ../bittensor/bittensor.type-test.ts
- * for the compile-time proof shared by the Bittensor trio).
+ * boundary into SDK core (the branded `Tao` type of ../bittensor/index.ts keeps it out
+ * at compile time for the Bittensor trio).
  *
  * The swap, subnet call, and pinning are injectable ports so the reference runs (and
  * is tested) without a live DEX, subnet, or IPFS node. A production worker supplies
@@ -1087,11 +1771,11 @@ type PinContent$3 = (content: string | Buffer) => Promise<string>;
  * RELEASE JUDGMENT IS NOT HERE. This adapter only PRODUCES the deliverable (checkpoint
  * + eval JSON). Whether the eval clears the threshold is decided by the BUYER's
  * review.ts, which independently recomputes the score (see `scoreGradientsDemoDeliverable`).
- * The worker never scores-for-release and never releases (CLAUDE.md product framing).
+ * The worker never scores-for-release and never releases: the buyer is the judge.
  *
  * Relationship to `examples/worker-bot/bittensor-adapter.ts`: that example is
  * pedagogy ("author your own adapter against the public interface", driven by e2e
- * scenario 13 / the P5.T2b obligation); THIS module is the shipped, importable
+ * scenario 13); THIS module is the shipped, importable
  * surface a generated bot uses. The USDC->TAO port skeleton and the execute shape are
  * shared with the other Bittensor adapters via `../bittensor/index.js`; this module
  * supplies only its subnet identity, capabilities, budget, and demo logic.
@@ -1166,8 +1850,7 @@ interface RidgesAdapterConfig {
 }
 /**
  * Stable id/capabilities. Locked against `ADAPTER_DESCRIPTORS.ridges` by a kit test
- * at merge (consult C2; the lock lives in create-escro-bot, which depends on this
- * package, and is landed with the barrel wiring — LANE-NOTES merge step 3).
+ * (the lock lives in create-escro-bot, which depends on this package).
  */
 declare const RIDGES_ADAPTER_ID = "ridges";
 declare const RIDGES_CAPABILITIES: readonly ["code-generation"];
@@ -1213,8 +1896,8 @@ declare function createRidgesAdapter(config?: RidgesAdapterConfig): ServiceAdapt
  * it swaps a per-task USDC budget into TAO internally, pays subnet miners in TAO to
  * generate a batch of 3D assets, collects the batch deliverable, and returns a
  * currency-free `ServiceResult`. The Buyer and the escrow contract only ever see USDC;
- * no TAO-typed value crosses this boundary into SDK core (ARCHITECTURE §3, §7; see
- * ../bittensor/bittensor.type-test.ts for the compile-time proof shared by the Bittensor trio).
+ * no TAO-typed value crosses this boundary into SDK core (the branded `Tao` type of
+ * ../bittensor/index.ts keeps it out at compile time for the Bittensor trio).
  *
  * The swap, subnet call, and pinning are injectable ports so the reference runs (and
  * is tested) without a live DEX, subnet, or IPFS node. A production worker supplies
@@ -1229,7 +1912,7 @@ declare function createRidgesAdapter(config?: RidgesAdapterConfig): ServiceAdapt
  * completeness). That recompute reads the DECLARED descriptors, not the asset bytes: a
  * production 404gen buyer generating novel assets must derive the container from the
  * fetched asset's magic bytes and the polygon count from its parsed geometry before
- * releasing. The worker never scores-for-release and never releases (CLAUDE.md framing).
+ * releasing. The worker never scores-for-release and never releases: the buyer is the judge.
  *
  * The USDC->TAO port skeleton and the execute shape are shared with the other Bittensor
  * adapters via `../bittensor/index.js`; this module supplies only its subnet identity,
@@ -1297,13 +1980,13 @@ declare function create404genAdapter(config?: Gen404AdapterConfig): ServiceAdapt
 
 /**
  * Lium (Bittensor SN51) ServiceAdapter: a SHIPPED, supported adapter following the
- * P6.T6a Gradients pattern. A Worker Bot wraps the Lium GPU-compute subnet behind the
+ * Gradients pattern. A Worker Bot wraps the Lium GPU-compute subnet behind the
  * `ServiceAdapter` interface: it swaps a per-task USDC budget into TAO internally,
  * rents GPU compute from subnet miners in TAO to run the job, collects the output
  * artifact, and returns a currency-free `ServiceResult`. The Buyer and the escrow
  * contract only ever see USDC; no TAO-typed value crosses this boundary into SDK core
- * (ARCHITECTURE §3, §7; see ../bittensor/bittensor.type-test.ts for the compile-time
- * proof shared by the Bittensor trio).
+ * (the branded `Tao` type of ../bittensor/index.ts keeps it out at compile time for the
+ * Bittensor trio).
  *
  * The swap, GPU-job call, and pinning are injectable ports so the reference runs (and
  * is tested) without a live DEX, subnet, or IPFS node. A production worker supplies
@@ -1315,7 +1998,7 @@ declare function create404genAdapter(config?: Gen404AdapterConfig): ServiceAdapt
  * the BUYER's review.ts, which independently recomputes the scripted job's output and
  * compares hashes (see `scoreLiumDemoDeliverable`). The worker never scores-for-release
  * and never releases, and its self-reported `artifactHash` is never trusted
- * (CLAUDE.md product framing: the buyer is the judge).
+ * (the buyer is the judge).
  *
  * The USDC->TAO port skeleton and the execute shape are shared with the other Bittensor
  * adapters via `../bittensor/index.js`; this module supplies only its subnet identity,
@@ -1354,8 +2037,8 @@ declare const LIUM_DEMO_ACCEPT_FLOOR = 1;
  */
 declare function computeLiumDemoArtifact(): string;
 /**
- * The canned Lium demo job. Deterministic; its specHash is pinned by a test (consult
- * C8) because the buyer journey depends on hash stability.
+ * The canned Lium demo job. Deterministic; its specHash is pinned by a test because
+ * the buyer journey depends on hash stability.
  */
 declare const liumDemoJobSpec: TaskSpec;
 /**
@@ -1370,8 +2053,8 @@ declare function solveLiumDemo(): string;
  * when the deliverable satisfies all three criteria and 0 otherwise. It checks
  * completion (status), artifact presence, and hash match by RECOMPUTING the scripted
  * job's output and comparing the substantive artifact; it deliberately IGNORES any
- * self-reported `artifactHash`, so release can never be worker-controlled (consult
- * C10). Malformed or unparseable content scores 0 and never throws.
+ * self-reported `artifactHash`, so release can never be worker-controlled.
+ * Malformed or unparseable content scores 0 and never throws.
  */
 declare function scoreLiumDemoDeliverable(content: string | Buffer): number;
 /**
@@ -1404,8 +2087,8 @@ type RunAkashDeployment = (spec: TaskSpec, budget: Akt) => Promise<string | Buff
 type PinContent$1 = (content: string | Buffer) => Promise<string>;
 /**
  * Stable id/capabilities. The adapter's own tests pin its runtime output to these
- * constants; the EscroBots registry descriptor for `akash` is registered separately in
- * P8.T6 (capability taxonomy extension).
+ * constants; the EscroBots registry descriptor for `akash` is registered separately (the
+ * capability taxonomy).
  */
 declare const AKASH_ADAPTER_ID = "akash";
 declare const AKASH_CAPABILITIES: readonly ["cloud-compute"];
@@ -1539,7 +2222,7 @@ declare function scoreRenderDemoDeliverable(content: string | Buffer): number;
  */
 declare function createRenderAdapter(config?: RenderAdapterConfig): ServiceAdapter;
 
-/** Stable adapter identity + EscroBots capability (locked by gensyn.test.ts). */
+/** Stable adapter identity + EscroBots capability (pinned by a test). */
 declare const GENSYN_ADAPTER_ID = "gensyn";
 declare const GENSYN_CAPABILITIES: readonly ["verifiable-compute"];
 /** REE proof scheme tag. A verifier accepts only proofs carrying this exact scheme. */
@@ -1627,20 +2310,53 @@ interface AutoReleaseDecision {
 /**
  * The buyer bot's auto-release decision for a Gensyn deliverable. Releases ONLY when
  * the REE proof verifies against the delivered content and the commissioned spec;
- * an invalid or malformed proof never releases. This is the whole T4 acceptance
+ * an invalid or malformed proof never releases. This is the whole acceptance
  * mechanism, and it lives entirely at the buyer layer.
  */
 declare function gensynAutoRelease(bundle: GensynDeliverableBundle, ctx: {
     spec: TaskSpec;
     reproduce?: ReproduceCompute;
 }): AutoReleaseDecision;
+/** Encode the document a Gensyn worker pins: the deliverable content and its REE proof. */
+declare function encodeGensynBundle(bundle: {
+    content: string;
+    proof: ReeProof;
+}): string;
+/**
+ * Decode the document a `proofUri` resolves to. Returns null unless it parses to an object
+ * with a string `content` and an object `proof` (the proof itself is verified later).
+ */
+declare function decodeGensynBundle(document: string | Buffer): GensynDeliverableBundle | null;
+/** Options for {@link gensynProofAutoRelease}. */
+interface GensynProofAutoReleaseOptions {
+    /**
+     * Fetch the bundle document the submitted `proofUri` names. A throw or rejection
+     * propagates (retried), never a verdict.
+     */
+    resolveProofUri: ResolveProofUri;
+    /** The task spec the buyer commissioned; the proof must bind it. */
+    spec: TaskSpec;
+    /** The reproducible compute; defaults to the reference {@link reproduceGensynCompute}. */
+    reproduce?: ReproduceCompute;
+}
+/**
+ * Buyer-layer auto-release over the pinned Gensyn bundle. It resolves `proofUri` through
+ * `resolveProofUri`, requires the bundle's content to re-hash to the worker-submitted
+ * `contentHash`, then releases only when {@link gensynAutoRelease} does; anything else
+ * DISPUTES. A resolver that throws propagates: an infrastructure failure is not a verdict.
+ * Construction throws `ADAPTER_CONFIG_ERROR` when `resolveProofUri` or `spec` is missing.
+ */
+declare function gensynProofAutoRelease(opts: GensynProofAutoReleaseOptions): ReviewPolicy;
 /** Configuration and injectable ports for {@link createGensynAdapter}. */
 interface GensynAdapterConfig {
     /** Advertised capabilities for EscroBots discovery. Defaults to `["verifiable-compute"]`. */
     capabilities?: string[];
     /** The reproducible compute the worker runs. Default: the reference LCG walk. */
     runCompute?: ReproduceCompute;
-    /** Pinning port. Default: a deterministic `ipfs://` placeholder URI. */
+    /**
+     * Pinning port: receives the bundle document ({@link encodeGensynBundle}) and returns its
+     * reference. Default: a deterministic `ipfs://` placeholder URI over those bytes.
+     */
     pin?: (content: string | Buffer) => Promise<string>;
     /** Health-check port. Default: resolves `true`. */
     checkHealth?: () => Promise<boolean>;
@@ -1649,8 +2365,8 @@ interface GensynAdapterConfig {
 declare const gensynDemoJobSpec: TaskSpec;
 /**
  * Build a Gensyn {@link ServiceAdapter}. `execute` runs the reproducible compute,
- * serializes the deliverable, and attaches an REE proof (in `metadata.reeProof`) the
- * buyer verifies with {@link verifyReeProof} / {@link gensynAutoRelease}. Passes
+ * serializes the deliverable, builds its REE proof and pins the bundle of both; `proofUri`
+ * names that bundle, which the buyer verifies with {@link gensynProofAutoRelease}. Passes
  * `assertServiceAdapterContract` with the default ports; supply real ports (a real
  * Gensyn job runner, a real pinner) for production.
  */
@@ -1663,7 +2379,7 @@ declare const ZKML_CAPABILITIES: readonly ["zk-verified-inference"];
 declare const ZKML_DEMO_MARKER = "zkml-demo-v1";
 /** The reference proving scheme this verifier understands. Unknown schemes are malformed to it. */
 declare const ZKML_PROOF_SCHEME = "escro-zkml-ref-v1";
-/** Prefix marking an inline (self-contained) zkml proof URI: `zkml-proof:<base64url(json)>`. */
+/** Prefix marking a ZKML bundle document, the bytes a worker pins: `zkml-proof:<base64url(json)>`. */
 declare const ZKML_PROOF_URI_PREFIX = "zkml-proof:";
 /**
  * A ZKML proof: its public inputs plus a `verificationTag` binding them. In the
@@ -1690,15 +2406,21 @@ declare function buildZkmlProof(args: {
     inputCommitment: string;
     outputHash: string;
 }): ZkmlProof;
-/** Encode a proof as a self-contained inline proof URI. */
-declare function encodeZkmlProofUri(proof: ZkmlProof): string;
+/** The document a ZKML worker pins: the deliverable content and the proof over it. */
+interface ZkmlProofBundle {
+    /** The deliverable content; its SHA-256 is the escrow's on-chain `contentHash`. */
+    content: string;
+    /** The proof binding `content` to the committed model and input. */
+    proof: ZkmlProof;
+}
+/** Encode a bundle as the document a worker pins; `proofUri` is that document's reference. */
+declare function encodeZkmlProofUri(bundle: ZkmlProofBundle): string;
 /**
- * Decode an inline zkml proof URI back to a {@link ZkmlProof}. Returns null for any
- * URI that is not an inline zkml proof or does not decode to the proof shape (a
- * pinned `ipfs://`/`ar://` proof is fetched by the caller, then passed to
- * {@link verifyZkmlProof} directly).
+ * Decode the document a `proofUri` resolves to back to a {@link ZkmlProofBundle}. Returns
+ * null for a document without the prefix, an undecodable payload, a `content` that is not
+ * a string or a `proof` that is not proof-shaped.
  */
-declare function decodeZkmlProofUri(uri: string): ZkmlProof | null;
+declare function decodeZkmlProofUri(document: string | Buffer): ZkmlProofBundle | null;
 /**
  * The outcome of verifying a proof. `malformed` = the verifier cannot understand the
  * proof (missing/wrong-typed fields, unsupported scheme, undecodable URI); `invalid`
@@ -1712,24 +2434,29 @@ type ZkmlVerification = {
     category: "invalid" | "malformed";
     reason: string;
 };
-/** What the Buyer expects the proof to attest to. */
+/** What the Buyer expects the proof to attest to: values the Buyer computes itself. */
 interface ZkmlExpectation {
     /** The submitted deliverable's contentHash; the proof's outputHash must equal it. */
     contentHash: string;
-    /** When set, the proof's modelCommitment must equal it (pin to a specific model). */
-    modelCommitment?: string;
+    /** The model the Buyer hired; the proof's modelCommitment must equal it. */
+    modelCommitment: string;
+    /** The Buyer's commitment over its own input; the proof's inputCommitment must equal it. */
+    inputCommitment: string;
 }
 /**
  * Verify a decoded proof against the Buyer's expectation. NOTE: this is the REFERENCE
  * verifier and is NOT cryptographically sound -- the tag is a keyless hash, so a `valid`
- * result means only that the proof is internally consistent and bound to
- * `expected.contentHash`, not that a trustworthy party produced it. Pass a real verifier
+ * result means only that the proof is internally consistent and bound to the expected
+ * output, model and input, not that a trustworthy party produced it. Pass a real verifier
  * to {@link zkmlProofAutoRelease} for production. `malformed` = an unusable proof;
  * `invalid` = a usable proof that fails the checks.
  */
 declare function verifyZkmlProof(proof: unknown, expected: ZkmlExpectation): ZkmlVerification;
-/** Decode an inline proof URI (or reject a missing/foreign one) and verify it. */
-declare function verifyZkmlProofUri(uri: string | null | undefined, expected: ZkmlExpectation): ZkmlVerification;
+/**
+ * Decode the document a `proofUri` resolved to (or reject an absent or foreign one),
+ * require its content to hash to `expected.contentHash`, then verify its proof.
+ */
+declare function verifyZkmlProofUri(document: string | Buffer | null | undefined, expected: ZkmlExpectation): ZkmlVerification;
 /** The submitted deliverable as the Buyer's review reads it off the escrow read model. */
 type ZkmlDeliverable = ReviewDeliverable;
 /** A release decision: release, and if not, whether to contest via dispute. */
@@ -1739,40 +2466,35 @@ type ZkmlReviewPolicy = ReviewPolicy;
 /** Options for {@link zkmlProofAutoRelease}. */
 interface ZkmlProofAutoReleaseOptions {
     /**
-     * Fetch the ACTUAL delivered artifact so the predicate can re-hash it. Integrity comes
-     * from the buyer recomputing `sha256(artifact)` and requiring it equals the worker-
-     * submitted `contentHash` -- never from trusting the submitted hash (mirror of the
-     * buyer template's `evalThresholdReview`). Required: without the artifact the predicate
-     * would be trusting a worker-chosen number.
+     * Fetch the bundle document the submitted `proofUri` names. Required: the content and
+     * its proof come only from that document. A throw or rejection propagates (retried),
+     * never a verdict.
      */
-    fetchContent: (deliverable: ZkmlDeliverable) => Promise<string | Buffer> | string | Buffer;
-    /** When set, the proof's modelCommitment must equal it (pin to a specific model). */
-    modelCommitment?: string;
+    resolveProofUri: ResolveProofUri;
+    /** The model the Buyer hired; the proof's modelCommitment must equal it. */
+    modelCommitment: string;
+    /** The Buyer's commitment over its own spec ({@link computeZkmlInputCommitment}). */
+    inputCommitment: string;
     /**
      * The proof verifier. DEFAULT is {@link verifyZkmlProof}, the reference verifier, which
      * is NOT cryptographically sound. A production buyer MUST pass a real SNARK/STARK
      * verifier here; the default is for demos only.
      */
     verify?: (proof: ZkmlProof, expected: ZkmlExpectation) => ZkmlVerification;
-    /**
-     * Resolve a non-inline (pinned) proof URI to a proof. Default: only inline
-     * `zkml-proof:` URIs are understood; a pinned `ipfs://` proof needs this port.
-     */
-    fetchProof?: (uri: string) => Promise<ZkmlProof | null> | ZkmlProof | null;
 }
 /**
- * Buyer-layer auto-release predicate for zk-verified jobs. RELEASE only when BOTH hold:
- * (1) the delivered artifact re-hashes to the worker-submitted `contentHash` (fetched via
- * `fetchContent`, never trusted), and (2) the attached proof verifies against that buyer-
- * recomputed hash (and the pinned model, when given). Otherwise DISPUTE. Disputing rather
- * than holding is deliberate -- a held SUBMITTED escrow is auto-released to the worker by
- * the 24h protocol timeout, so a buyer who required a proof contests a missing/invalid one
+ * Buyer-layer auto-release predicate for zk-verified jobs. It resolves `proofUri` through
+ * `resolveProofUri` to the pinned bundle, requires the bundle's content to re-hash to the
+ * worker-submitted `contentHash`, and requires the proof's output, model and input to equal
+ * that hash, the pinned model and the Buyer's input commitment (checked here, whatever
+ * `verify` returns); `verify` then decides. Anything else DISPUTES. Disputing rather than
+ * holding is deliberate -- a held SUBMITTED escrow is auto-released to the worker by the
+ * 24h protocol timeout, so a buyer who required a proof contests a missing/invalid one
  * instead of letting it time out to release. This is the Buyer's judgment, not the
- * protocol's. Soundness of step (2) lives in the `verify` option; the default reference
- * verifier is a demo and proves nothing on its own. A port that throws (e.g.
- * `fetchContent` failing to retrieve the artifact) PROPAGATES: a transient infra failure
- * is not a verdict, so the caller retries it -- it is never silently converted into a
- * dispute.
+ * protocol's. Soundness lives in the `verify` option; the default reference verifier is a
+ * demo and proves nothing on its own. A resolver that throws PROPAGATES: a transient infra
+ * failure is not a verdict, so the caller retries it -- it is never silently converted into
+ * a dispute. Construction throws `ADAPTER_CONFIG_ERROR` when a required option is missing.
  */
 declare function zkmlProofAutoRelease(opts: ZkmlProofAutoReleaseOptions): ZkmlReviewPolicy;
 /** What an inference run yields: the output plus the commitments the proof binds. */
@@ -1798,29 +2520,578 @@ interface ZkmlAdapterConfig {
         output: ZkmlInferenceOutput;
         outputHash: string;
     }) => Promise<ZkmlProof> | ZkmlProof;
-    /** Pinning port. Default: a self-contained inline proof URI. A production worker pins the proof. */
-    pin?: (proof: ZkmlProof) => Promise<string> | string;
+    /**
+     * Pinning port: receives the bundle document ({@link encodeZkmlProofUri}) and returns its
+     * reference. Default: `ipfs://placeholder-<16 hex of the document's sha256>`, which stores
+     * nothing; a production worker pins the document to IPFS/Arweave.
+     */
+    pin?: (document: string) => Promise<string> | string;
     /** Health-check port. Default: resolves `true`. */
     checkHealth?: () => Promise<boolean>;
 }
 /**
- * The canned zk-verified-inference demo job (BOT_KIT_PRD §6 / §13): a deterministic
- * classification the buyer template's zero-config journey hires this bot for.
+ * The canned zk-verified-inference demo job: a deterministic
+ * classification the buyer template's demo journey hires this bot for.
  * Acceptance is machine-checkable by the buyer via {@link zkmlProofAutoRelease}.
  */
 declare const zkmlDemoJobSpec: TaskSpec;
+/** Commitment to the demo model: the value a buyer of the demo job pins. */
+declare const ZKML_DEMO_MODEL_COMMITMENT: string;
+/** The buyer's commitment over its own spec: the `inputCommitment` a proof must attest. */
+declare function computeZkmlInputCommitment(spec: TaskSpec): string;
 /**
  * The reference solution to the demo job: the classifier's output as canonical JSON.
  * Deterministic. Exposed so the demo journey and tests share one source of truth.
  */
 declare function solveZkmlDemo(): string;
 /**
- * Build a ZKML {@link ServiceAdapter}. Passes `assertServiceAdapterContract` with the
- * default ports and, out of the box, produces a demo deliverable whose proof verifies
- * under {@link zkmlProofAutoRelease}. Supply real ports (a genuine inference call, a
- * real prover, a pin to IPFS/Arweave) for production use.
+ * Build a ZKML {@link ServiceAdapter}. `execute` pins the bundle of the delivered content and
+ * its proof and returns that document's reference as `proofUri`. Passes
+ * `assertServiceAdapterContract` with the default ports; the default pin stores nothing, so
+ * a release needs a real pin and the buyer's `resolveProofUri` in {@link zkmlProofAutoRelease}.
+ * Supply real ports (a genuine inference call, a real prover, a pin to IPFS/Arweave) for
+ * production use.
  */
 declare function createZkmlAdapter(config?: ZkmlAdapterConfig): ServiceAdapter;
 
-export { AKASH_ADAPTER_ID, AKASH_CAPABILITIES, AKASH_DEMO_ACCEPT_FLOOR, AKASH_DEMO_MARKER, AdapterContractError, ApiClient, ENABLED_RAILS, Escro, EscroConfirmError, EscroError, EscroRailNotEnabledError, EscrowNotFoundError, EscrowPaymentRouter, EscrowState, EscrowStateError, EscrowTimeoutError, GEN404_ADAPTER_ID, GEN404_CAPABILITIES, GEN404_DEMO_EVAL_FLOOR, GEN404_DEMO_MARKER, GENSYN_ADAPTER_ID, GENSYN_CAPABILITIES, GENSYN_DEMO_MARKER, GENSYN_REE_SCHEME, GRADIENTS_ADAPTER_ID, GRADIENTS_CAPABILITIES, GRADIENTS_DEMO_EVAL_FLOOR, GRADIENTS_DEMO_MARKER, LIUM_ADAPTER_ID, LIUM_CAPABILITIES, LIUM_DEMO_ACCEPT_FLOOR, LIUM_DEMO_MARKER, RAILS, RAILS_DOCS_URL, REFERENCE_MICRO_USDC_PER_AKT, REFERENCE_MICRO_USDC_PER_RENDER, RENDER_ADAPTER_ID, RENDER_CAPABILITIES, RENDER_DEMO_ACCEPT_FLOOR, RENDER_DEMO_MARKER, RIDGES_ADAPTER_ID, RIDGES_CAPABILITIES, RIDGES_DEMO_COVERAGE_TARGET, RIDGES_DEMO_MARKER, ReputationUnavailableError, UnauthorizedError, ZKML_ADAPTER_ID, ZKML_CAPABILITIES, ZKML_DEMO_MARKER, ZKML_PROOF_SCHEME, ZKML_PROOF_URI_PREFIX, akashDemoJobSpec, akt, assertServiceAdapterContract, buildReeProof, buildZkmlProof, computeAkashDemoArtifact, computeLiumDemoArtifact, computeRenderDemoArtifact, create404genAdapter, createAkashAdapter, createGensynAdapter, createGradientsAdapter, createLiumAdapter, createRenderAdapter, createRidgesAdapter, createZkmlAdapter, decodeZkmlProofUri, encodeZkmlProofUri, gen404DemoJobSpec, gensynAutoRelease, gensynDemoJobSpec, gradientsDemoJobSpec, liumDemoJobSpec, renderAmount, renderDemoJobSpec, reproduceGensynCompute, ridgesDemoJobSpec, score404genDemoDeliverable, scoreAkashDemoDeliverable, scoreGradientsDemoDeliverable, scoreLiumDemoDeliverable, scoreRenderDemoDeliverable, scoreRidgesDemoDeliverable, serviceResultToSubmitParams, solveAkashDemo, solveGen404Demo, solveGradientsDemo, solveLiumDemo, solveRenderDemo, solveRidgesDemo, solveZkmlDemo, tao, verifyReeProof, verifyZkmlProof, verifyZkmlProofUri, zkmlDemoJobSpec, zkmlProofAutoRelease };
-export type { AcceptanceCriterion, AdapterContractOptions, AkashAdapterConfig, Akt, AutoReleaseDecision, BotDescriptor, BotRole, CreateEscrowParams, CreateEscrowResult, DeliverableFormat, DeliverableType, EscroOptions, EscrowAccount, EscrowErrorCode, Gen404AdapterConfig, GensynAdapterConfig, GensynDeliverableBundle, GradientsAdapterConfig, ListBotsParams, ListOptions, LiumAdapterConfig, Network, PaginatedResult, PayParams, PaymentResult, PaymentRouter, PinContent$3 as PinContent, PollOptions, ProtocolStats, Rail, RaiseDisputeParams, ReeExecution, ReeProof, ReeVerification, ReeVerifyContext, ReleasePaymentOutcome, Render, RenderAdapterConfig, ReproduceCompute, RidgesAdapterConfig, RunAkashDeployment, RunCodingAgent, RunGpuJob, RunRenderJob, ServedWalletReputation, ServiceAdapter, ServiceResult, SubmitDeliverableParams, SubnetCall, Tao, TaskSpec, TaskType, TxShape, UnsignedBotDescriptor, UsdcToAktSwap, UsdcToRenderSwap, UsdcToTaoSwap, WorkerCandidate, ZkmlAdapterConfig, ZkmlDeliverable, ZkmlExpectation, ZkmlInferenceOutput, ZkmlProof, ZkmlProofAutoReleaseOptions, ZkmlReviewPolicy, ZkmlReviewResult, ZkmlVerification };
+/**
+ * The RPC methods the reader calls; a web3.js Connection satisfies it. A history holding a
+ * version-1 transaction reads only through a connection {@link chainReadConnection} builds; a
+ * custom transport (headers, a proxy, a test double) goes in as its `fetchFn`. A connection built
+ * any other way fails a version-1 history with `CHAIN_RPC_FAILED`, whose archival advice does not
+ * apply to that failure.
+ */
+type ChainReadRpc = Pick<Connection, "getAccountInfo" | "getSignaturesForAddress" | "getTransaction">;
+type ChainReadTarget = {
+    address: string;
+} | {
+    buyer: string;
+    taskId: string;
+};
+interface ReadEscrowFromChainOptions {
+    /** Selects the program id through `getProgramId`; a localnet run of the devnet build is "devnet". */
+    cluster: SolanaCluster;
+    /**
+     * The RPC read. A history holding a version-1 transaction reads only through a connection
+     * {@link chainReadConnection} builds; a custom transport (headers, a proxy, a test double) goes
+     * in as its `fetchFn`. A connection built any other way fails a version-1 history with
+     * `CHAIN_RPC_FAILED`, whose archival advice does not apply to that failure.
+     */
+    rpc: ChainReadRpc;
+    /** The most getTransaction calls one read makes; default {@link CHAIN_READ_MAX_TRANSACTIONS}. */
+    maxTransactions?: number;
+}
+/** Every EscrowAccount field by its IDL name (snake_case), u64 as bigint, i64 as number, pubkeys base58. */
+type DecodedEscrowAccount = Record<string, string | number | bigint | null>;
+interface ChainEscrowFigures {
+    address: string;
+    buyer: string;
+    worker: string | null;
+    taskId: string;
+    amountMicro: bigint;
+    feeBps: number;
+    /** `escrowFee(amountMicro, feeBps)`, the escrow's own stored rate. */
+    feeMicro: bigint;
+    /** What the buyer deposited: amount plus fee. */
+    depositMicro: bigint;
+    deadline: number;
+    specHash: string;
+    createdAt: number;
+    deliverableHash: string | null;
+    proofUri: string | null;
+    submittedAt: number | null;
+}
+interface ChainSettlement {
+    kind: "released" | "refunded" | "cancelled";
+    /** PaymentReleased.worker_amount. */
+    workerAmountMicro: bigint | null;
+    /** PaymentReleased.fee_amount. */
+    feeAmountMicro: bigint | null;
+    /** BuyerRefunded or EscrowCancelled refund_amount. */
+    refundAmountMicro: bigint | null;
+    /** The event's resolved_at, or cancelled_at for a cancel. */
+    resolvedAt: number;
+    /** The settling transaction. */
+    signature: string;
+}
+interface ChainEscrowReading {
+    source: "account" | "history";
+    cluster: SolanaCluster;
+    programId: string;
+    /** FUNDED to DISPUTED while open; COMPLETED, REFUNDED or CANCELLED once closed. */
+    state: EscrowState;
+    /** From an account, the state is DISPUTED; from history, a DisputeRaised is in the lifecycle. */
+    disputed: boolean;
+    figures: ChainEscrowFigures;
+    /** Null while open. */
+    settlement: ChainSettlement | null;
+    /** From history, the lifecycle's successful transactions, oldest first; from an account, none. */
+    signatures: string[];
+}
+type ChainReadErrorCode = "CHAIN_ESCROW_NOT_FOUND" | "CHAIN_HISTORY_INCOMPLETE" | "CHAIN_HISTORY_BUDGET" | "CHAIN_LOGS_TRUNCATED" | "CHAIN_ACCOUNT_INVALID" | "CHAIN_RPC_FAILED" | "CHAIN_TRANSACTION_VERSION" | "INVALID_INPUT";
+type ChainAccountInvalidReason = "owner" | "discriminator" | "version" | "layout" | "pda";
+/**
+ * A chain read that gave no reading. `reason` names the failed account check on
+ * `CHAIN_ACCOUNT_INVALID`. A `CHAIN_RPC_FAILED` message is fixed text naming the RPC method, a
+ * `CHAIN_TRANSACTION_VERSION` one the transaction and the address; the transport's own error, which
+ * may echo the RPC URL, is only the `cause`.
+ */
+declare class ChainReadError extends EscroError {
+    readonly reason: ChainAccountInvalidReason | undefined;
+    constructor(code: ChainReadErrorCode, message: string, options?: {
+        reason?: ChainAccountInvalidReason;
+        cause?: unknown;
+    });
+}
+declare const ARCHIVAL_RPC_NOTE = "A settled escrow is closed on chain and survives only in transaction history; if it is older than this RPC's history, read it through an archival RPC.";
+/** getTransaction calls per read: one lifecycle takes at most five, so about ten reuses or spam. */
+declare const CHAIN_READ_MAX_TRANSACTIONS = 50;
+/** getSignaturesForAddress pages per read, of {@link SIGNATURE_PAGE} signatures each. */
+declare const CHAIN_READ_MAX_SIGNATURE_PAGES = 5;
+declare const ESCROW_ACCOUNT_DISCRIMINATOR: readonly number[];
+type FieldKind = "pubkey" | "u8" | "u16" | "u64" | "i64" | "string" | "option<pubkey>" | "option<string>" | "option<i64>" | "enum";
+/** The EscrowAccount fields in on-chain order (escrow_account.rs, the committed IDL). */
+declare const ESCROW_ACCOUNT_LAYOUT: readonly {
+    name: string;
+    kind: FieldKind;
+}[];
+/** The program's allocation: 8 + EscrowAccount::INIT_SPACE. The tail past the content is zero. */
+declare const ESCROW_ACCOUNT_SIZE = 537;
+/**
+ * Decode EscrowAccount bytes as the program allocates them. Throws {@link ChainReadError}
+ * `CHAIN_ACCOUNT_INVALID` (reason `discriminator`, `version` or `layout`) on anything else.
+ * `state` is the IDL variant name (`Funded`, `InProgress`, ...).
+ */
+declare function decodeEscrowAccount(data: Uint8Array): DecodedEscrowAccount;
+/**
+ * A connection at `rpcUrl` and `confirmed` through which a history holding version-1 transactions
+ * reads, a custom transport (headers, a proxy, a test double) going in as `fetchFn` (default
+ * `globalThis.fetch`, resolved when called); a connection built any other way fails a version-1
+ * history with `CHAIN_RPC_FAILED`, whose archival advice does not apply to that failure.
+ */
+declare function chainReadConnection(rpcUrl: string, fetchFn?: typeof globalThis.fetch): Connection;
+/**
+ * What the program recorded for one escrow, read from `options.rpc` alone. An open escrow reads
+ * from its account and makes no history call; a closed one is rebuilt from the program's events
+ * in the address's history, its newest lifecycle only. Throws {@link ChainReadError}.
+ */
+declare function readEscrowFromChain(target: ChainReadTarget, options: ReadEscrowFromChainOptions): Promise<ChainEscrowReading>;
+
+/** The SPL Memo program (the current one; the legacy `Memo1Uhk...` program is not admitted). */
+declare const MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+
+/** Why {@link payUrlRefusal} refuses a URL; each surface turns a kind into its own sentence. */
+type PayUrlRefusal = "private_host" | "unresolved_host" | "mainnet_http";
+/** node:dns/promises' lookup satisfies it; the SDK resolves nothing itself. */
+type HostLookup = (hostname: string, options: {
+    all: true;
+}) => Promise<readonly {
+    address: string;
+}[]>;
+/**
+ * True only for text that parses as an IPv4 or IPv6 address (no brackets, no zone id) outside the
+ * refused set, so an unknown form (a name, a zone id, a non-strict quad) is never public.
+ */
+declare function isPublicAddress(address: string): boolean;
+/**
+ * Whether a pay action may reach `url`, before any request, signature or funding: on any cluster
+ * but devnet an `http:` URL to a host the operator has not admitted as private is refused, and
+ * without the opt-in any host that is not public is refused. Null admits, and leaves a URL that does
+ * not parse, or is not http or https, to pay()'s own refusal. Resolves the host at most once, and
+ * only when the answer decides.
+ */
+declare function payUrlRefusal(url: string, options: {
+    cluster: EscroOptions["cluster"] | undefined;
+    allowPrivateHosts: boolean;
+    lookup: HostLookup;
+}): Promise<PayUrlRefusal | null>;
+/**
+ * The address rule a surface passes as PayParams.admitAddress, for the URL it checked with
+ * {@link payUrlRefusal}. Without the opt-in both targets admit exactly the public addresses. With it,
+ * on any cluster but devnet over http:, the resource admits exactly the addresses that are not
+ * public (a host the operator declared local has no public network path) and the spec host, always
+ * https:, admits every address. With the opt-in otherwise there is no rule (undefined). A URL that
+ * does not parse, or is not http or https, takes the rule without the opt-in.
+ */
+declare function payAddressRule(options: {
+    cluster: EscroOptions["cluster"] | undefined;
+    allowPrivateHosts: boolean;
+    url: string;
+}): PayParams["admitAddress"];
+/**
+ * pay()'s own rail choice with a deadline bound added: an escrow entry on the caller's terms is
+ * returned only when its deadline is at most now plus `maxDeadlineSeconds`, and is never passed over
+ * for an `exact` entry; an `exact` entry is returned only when no escrow entry is on the terms, and
+ * never with `escrowOnly`. Only entries on the cluster's network are on the terms: devnet's for
+ * `"devnet"`, mainnet's for any other value, as {@link payUrlRefusal} reads a cluster. Refusals carry
+ * the caller's values only, never the 402's text. The clock (`now`, milliseconds, default
+ * `Date.now`) is read each time the policy runs, which pay() does before its first chain read, spec
+ * fetch or signature.
+ */
+declare function deadlineBoundedPolicy(terms: {
+    to: string;
+    amountMicroUsdc: number;
+    cluster: EscroOptions["cluster"] | undefined;
+    maxDeadlineSeconds: number;
+    escrowOnly?: boolean;
+    now?: () => number;
+}): PayPolicy;
+
+/** An http: or https: URL whose port (the scheme's default when the URL names none) `fetch` blocks. */
+declare function isBadPortUrl(url: URL): boolean;
+
+/** The three x402 V2 HTTP header names. */
+declare const X402_HEADERS: {
+    readonly paymentRequired: "PAYMENT-REQUIRED";
+    readonly paymentSignature: "PAYMENT-SIGNATURE";
+    readonly paymentResponse: "PAYMENT-RESPONSE";
+};
+/** A 402's `PAYMENT-REQUIRED` header value. */
+declare function encodePaymentRequired(value: PaymentRequired): string;
+/**
+ * A `PAYMENT-REQUIRED` header's value, checked for version 2, `resource.url` and each entry's
+ * `scheme` and `network`; throws {@link X402CodecError} otherwise.
+ */
+declare function decodePaymentRequired(header: string): PaymentRequired;
+/** A payment's `PAYMENT-SIGNATURE` header value. */
+declare function encodePaymentSignature(value: PaymentPayload): string;
+/**
+ * A `PAYMENT-SIGNATURE` header's value, checked for version 2 and the `accepted` and `payload`
+ * objects; throws {@link X402CodecError} otherwise.
+ */
+declare function decodePaymentSignature(header: string): PaymentPayload;
+/** A settlement's `PAYMENT-RESPONSE` header value. */
+declare function encodePaymentResponse(value: SettlementResponse): string;
+/**
+ * A `PAYMENT-RESPONSE` header's value, checked for a boolean `success`; throws
+ * {@link X402CodecError} otherwise.
+ */
+declare function decodePaymentResponse(header: string): SettlementResponse;
+
+/** A `PAYMENT-REQUIRED`, `PAYMENT-SIGNATURE` or `PAYMENT-RESPONSE` header that is not the x402 V2 encoding. */
+declare class X402CodecError extends EscroError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** No PlatformConfig account at the cluster's PlatformConfig PDA. */
+declare class PlatformConfigNotFoundError extends EscroError {
+    constructor(address: string);
+}
+/** Why an `on-delivery` entry was not selected (docs/specs/scheme_on_delivery_svm.md, client checks). */
+type OnDeliveryAcceptRefusal = "no_entry" | "network" | "program" | "asset" | "fee_bps" | "settlement_mode" | "review_window" | "fee_payer" | "payment_flow" | "amount" | "over_limit" | "pay_to" | "spec_hash" | "spec_uri" | "deadline" | "max_timeout" | "extra_shape" | "extension_invalid" | "extension_terms" | "acceptance";
+/**
+ * No acceptable `on-delivery` entry. `refusals` lists each candidate's first refusal; `index` is the
+ * entry's index in `accepts`, or -1 where no entry is concerned (`no_entry`, an `escro` extension
+ * parsed alone, an entry `buildEscrowAccept` refused to build).
+ */
+declare class OnDeliveryAcceptError extends EscroError {
+    readonly refusals: readonly {
+        index: number;
+        reason: OnDeliveryAcceptRefusal;
+    }[];
+    constructor(refusals: readonly {
+        index: number;
+        reason: OnDeliveryAcceptRefusal;
+    }[]);
+}
+type OnDeliveryFundRefusal = "selection_unknown" | "selection_spent" | "resource_url" | "resource_mismatch" | "spec_fetch" | "spec_host" | "spec_hash_mismatch" | "spec_refused" | "escrow_mismatch";
+/** `fundFromAccept` or `fetchTaskSpec` refused; `reason` names the check. */
+declare class OnDeliveryFundError extends EscroError {
+    readonly reason: OnDeliveryFundRefusal;
+    /** Set on `escrow_mismatch` only: the create landed; recover with `Escro.cancelEscrow(escrowPda)`. */
+    readonly escrowId?: string;
+    readonly escrowPda?: string;
+    readonly signature?: string;
+    constructor(reason: OnDeliveryFundRefusal, message: string, options?: {
+        cause?: unknown;
+        escrowId?: string;
+        escrowPda?: string;
+        signature?: string;
+    });
+}
+/** The facilitator operation an {@link EscroFacilitatorError} failed in. */
+type FacilitatorOperation = "verify" | "settle" | "supported";
+/**
+ * A facilitator call that failed with no answer: unreachable, timed out, an unrecognised error, or its client not
+ * loadable. `indeterminate` is set on every `settle` failure: the facilitator may still have sent the transfer. The
+ * message holds no part of the facilitator URL, and the error carries no `cause`.
+ */
+declare class EscroFacilitatorError extends EscroError {
+    readonly operation: FacilitatorOperation;
+    readonly indeterminate: boolean;
+    constructor(operation: FacilitatorOperation, message: string);
+}
+/** Why {@link buildExactAccept} refused to build an `exact` entry. */
+type ExactAcceptRefusal = "pay_to" | "fee_payer" | "amount" | "max_timeout";
+/** The worker's `exact` entry would be one a buyer cannot pay or a facilitator cannot settle in time. */
+declare class ExactAcceptError extends EscroError {
+    readonly reason: ExactAcceptRefusal;
+    constructor(reason: ExactAcceptRefusal, message: string);
+}
+
+interface BuildBazaarDeclarationOptions {
+    method: "GET" | "POST";
+    /** The example request: the JSON body of a POST, the query parameters of a GET. */
+    example: Record<string, unknown>;
+    /** The example response. */
+    output?: {
+        type: string;
+        example?: unknown;
+    };
+}
+/**
+ * The `bazaar` declaration of an HTTP route: a POST takes `example` as its JSON body, a GET as its query parameters;
+ * the schema requires `input.type` "http" and a method of the route's family. Throws an Error naming `example` when it
+ * is not a plain object that survives a JSON round trip, and naming `output.type` when that is empty. The declaration
+ * is a copy: a later change to `example` or `output` does not reach it.
+ */
+declare function buildBazaarDeclaration(options: BuildBazaarDeclarationOptions): BazaarDeclaration;
+
+interface BuildExactAcceptOptions {
+    cluster: SolanaCluster;
+    amountMicroUsdc: bigint;
+    /** The worker's own wallet. */
+    payTo: string;
+    /** The facilitator's fee payer, from its `/supported` answer ({@link exactFeePayer}). */
+    feePayer: string;
+    maxTimeoutSeconds: number;
+}
+/**
+ * The `exact` entry a worker offers beside its `on-delivery` entry. Throws {@link ExactAcceptError} for a `payTo` or
+ * `feePayer` that is not a canonical key, a fee payer that is the worker itself, an amount outside 1..2^64-1, or a
+ * `maxTimeoutSeconds` that is not a whole number from 10 to 3600.
+ */
+declare function buildExactAccept(options: BuildExactAcceptOptions): PaymentRequirements;
+/**
+ * The `extra.feePayer` of the first x402 V2 `exact` kind on the cluster's network in a facilitator's `/supported`
+ * answer; undefined when none names one. Its validity is {@link buildExactAccept}'s to check.
+ */
+declare function exactFeePayer(supported: SupportedResponse, cluster: SolanaCluster): string | undefined;
+
+interface HttpFacilitatorOptions {
+    /** `https:`, with no userinfo, query or fragment; a path is allowed. */
+    url: string;
+    /** Per request. Default 30 000. */
+    timeoutMs?: number;
+}
+/**
+ * A facilitator at `url`. Synchronous and offline: the client is loaded and built on the first call, once per
+ * facilitator. Throws a TypeError, naming the rule and never the URL, for a URL that is not `https:` or carries a
+ * username, password, query or fragment.
+ */
+declare function createHttpFacilitator(options: HttpFacilitatorOptions): Facilitator;
+
+type PlatformConfigTerms = Pick<PlatformConfigAccount, "usdcMint" | "feeBps">;
+/**
+ * The cluster's PlatformConfig, read at its PDA and decoded by the shared decoder. Throws
+ * {@link PlatformConfigNotFoundError} when no account is there, and {@link ChainReadError}
+ * `CHAIN_ACCOUNT_INVALID` (reason `version`) on a version this SDK does not read.
+ */
+declare function readPlatformConfig(rpc: Pick<Connection, "getAccountInfo">, cluster: SolanaCluster): Promise<PlatformConfigTerms & {
+    treasury: string;
+}>;
+/**
+ * The settlement modes this client funds. The version-1 account layout has no refund on silence
+ * (the binding: `refund` is offered from a future account layout), so `release` only.
+ */
+declare const SUPPORTED_SETTLEMENT_MODES: readonly SettlementMode[];
+/** Whether the entry's `extra.settlementMode` is one of {@link SUPPORTED_SETTLEMENT_MODES}. */
+declare function settlementModeSupported(entry: {
+    extra: {
+        settlementMode: unknown;
+    };
+}): boolean;
+interface ParseEscrowAcceptContext {
+    cluster: SolanaCluster;
+    /** From {@link readPlatformConfig}: the entry's mint and fee must equal these. */
+    platformConfig: PlatformConfigTerms;
+    /** The buyer's own bound on what it deposits: `amount` plus the fee at `platformConfig.feeBps`. */
+    maxDepositMicroUsdc: bigint;
+    /** When given, the only worker the buyer funds. */
+    payTo?: string;
+    /** Decides an `acceptance` predicate the 402 carries; absent, such an entry is refused. */
+    admitAcceptance?: (acceptance: Acceptance) => boolean;
+    /** Unix milliseconds. */
+    now?: () => number;
+}
+interface EscrowAcceptSelection {
+    readonly cluster: SolanaCluster;
+    readonly resource: ResourceInfo;
+    readonly entry: OnDeliveryAccept;
+    readonly extension: EscroExtensionInfo | undefined;
+    readonly extensions: Record<string, unknown> | undefined;
+}
+/**
+ * The first `on-delivery` (or `job-escrow`) entry of the 402 that passes every client check of the
+ * binding, against the cluster's pinned values, `ctx.platformConfig` and the buyer's own deposit
+ * bound; entries of other schemes are ignored. The selection holds a deep-frozen copy of the 402's
+ * resource, entry and extensions taken before the checks, and is the only input
+ * {@link fundFromAccept} funds, once. Throws {@link OnDeliveryAcceptError} listing each candidate's
+ * first refusal when none passes, and {@link EscroError} `VALIDATION_ERROR` when
+ * `ctx.maxDepositMicroUsdc` is not a bigint or the 402 is not plain data.
+ */
+declare function parseEscrowAccept(required: PaymentRequired, ctx: ParseEscrowAcceptContext): EscrowAcceptSelection;
+interface BuildEscrowAcceptOptions {
+    cluster: SolanaCluster;
+    amountMicroUsdc: bigint;
+    payTo: string;
+    specHash: string;
+    specUri: string;
+    /** Unix seconds. */
+    deadline: number;
+    /** PlatformConfig's `fee_bps`, read by {@link readPlatformConfig}. */
+    feeBps: number;
+    maxTimeoutSeconds: number;
+    /** Default `upfront`. */
+    paymentFlow?: "upfront" | "escrow";
+}
+/**
+ * The `on-delivery` entry a worker advertises: network, asset, program, review window, settlement
+ * mode and fee payer from the cluster's pinned values, the fee from `options.feeBps`. Throws
+ * {@link OnDeliveryAcceptError} for an entry the client side would refuse on its own terms (an
+ * amount under the minimum escrow, a malformed key, hash, URI or bound).
+ */
+declare function buildEscrowAccept(options: BuildEscrowAcceptOptions): OnDeliveryAccept;
+
+/**
+ * The `escro` extension's `info`, validated by the rules this client holds (closed objects; `args`
+ * free-form). Throws {@link OnDeliveryAcceptError} with reason `extension_invalid` otherwise.
+ */
+declare function parseEscroExtension(info: unknown): EscroExtensionInfo;
+
+/** The buyer message's method place: a value no API route accepts. */
+declare const BUYER_MESSAGE_METHOD: "ON-DELIVERY";
+/**
+ * `escro:<signedAt>:ON-DELIVERY:<resourceUrl>:<escrow>`: the API's request message shape with a
+ * method no API route accepts and an absolute URL in the path place, so it never verifies as an API
+ * request signature. Throws on a `resourceUrl` that is not an absolute http(s) URL, an `escrow` that
+ * is not a canonical base58 key, or a `signedAt` that is not a non-negative safe integer.
+ */
+declare function buyerMessage(signedAt: number, resourceUrl: string, escrow: string): string;
+/**
+ * The payload fields signed by `wallet` over the buyer message for `resourceUrl`, `signedAt` being
+ * `now()`. A poll re-signs with the poll URL and a fresh `now()`.
+ */
+declare function signEscrowPayload(fields: Pick<OnDeliveryPayloadFields, "escrow" | "buyer" | "taskId" | "createSignature">, options: {
+    wallet: Keypair;
+    resourceUrl: string;
+    now?: () => number;
+}): OnDeliveryPayloadFields;
+
+/**
+ * The job specification at an `https:` `specUri`, fetched with no SDK header (only `Accept`), no
+ * redirect, a total deadline of `timeoutMs` (default 10 000) and at most 256 KiB of body. Throws
+ * {@link OnDeliveryFundError} `spec_fetch` on any other URI, a network failure, a non-2xx status,
+ * an oversized, non-UTF-8 or non-JSON body, or a document that is not a JSON object; a URI carrying a
+ * username or password, or naming a port `fetch` blocks, is refused before any lookup or connection. With
+ * `admitAddress`, the host is resolved once within the deadline, every answer is put to it, and the
+ * request connects only to the answers it admitted (exactly `true`); a refused answer throws
+ * `spec_host`, an unresolved host `spec_fetch`.
+ */
+declare function fetchTaskSpec(specUri: string, options?: {
+    timeoutMs?: number;
+    admitAddress?: (address: string) => boolean;
+}): Promise<Record<string, unknown>>;
+interface FundFromAcceptDeps {
+    escro: Pick<Escro, "createEscrow">;
+    wallet: Keypair;
+    /** The absolute URL the paid request goes to: the 402's `resource.url`. */
+    resourceUrl: string;
+    /** Fetches `extra.specUri`; the only way to read an `ipfs:` URI. Default {@link fetchTaskSpec}. */
+    fetchSpec?: (specUri: string) => Promise<unknown>;
+    /**
+     * Decides each address the default spec fetch may connect to (see {@link fetchTaskSpec}); a caller's
+     * `fetchSpec` is its own transport and does not read it.
+     */
+    admitAddress?: (address: string) => boolean;
+    /** The buyer's veto over the hash-checked specification, before `createEscrow`; absent admits. */
+    admitSpec?: (spec: TaskSpec) => boolean;
+    /** Unix milliseconds. */
+    now?: () => number;
+}
+interface FundFromAcceptResult {
+    payment: OnDeliveryPaymentPayload;
+    taskSpec: TaskSpec;
+}
+/**
+ * Funds a selection {@link parseEscrowAccept} returned, once: fetches the job specification, checks
+ * its hash before it is used or sent, creates the escrow through `deps.escro.createEscrow` with
+ * `payTo` as the assigned worker, and returns the `PAYMENT-SIGNATURE` payload signed by
+ * `deps.wallet` over `deps.resourceUrl`, with the hash-checked specification.
+ *
+ * A selection is known only to the copy of the SDK that parsed it. An `escro` built with another
+ * wallet, or for another cluster, is caught after the create lands, as `escrow_mismatch`; that
+ * error carries `escrowId`, `escrowPda` and `signature`, and `cancelEscrow` is the recovery. An
+ * error from `createEscrow` propagates unchanged.
+ */
+declare function fundFromAccept(selection: EscrowAcceptSelection, deps: FundFromAcceptDeps): Promise<FundFromAcceptResult>;
+
+/**
+ * The record of accepted presentations a server keeps; one per server, never module state.
+ */
+interface ReplayStore {
+    /**
+     * Records `key` until `expiresAtMs` (inclusive) and returns true; returns false when `key` is held and unexpired at
+     * `nowMs`. Atomic per key (a shared store: Redis `SET NX PX`, Postgres `INSERT ... ON CONFLICT DO NOTHING`). A claim
+     * is spent before the account read: a presentation that fails a later step is re-signed.
+     */
+    claim(key: string, expiresAtMs: number, nowMs: number): boolean | Promise<boolean>;
+}
+/**
+ * An in-memory {@link ReplayStore}: one map per call, held by this process only, so it suits a
+ * single-process server; servers behind a load balancer share a store. Each claim drops the keys
+ * expired at its `nowMs`. `size` is the number of keys held.
+ */
+declare function memoryReplayStore(): ReplayStore & {
+    readonly size: number;
+};
+/** The binding's error-code table, in its order. */
+declare const ON_DELIVERY_SVM_INVALID_REASONS: readonly ["invalid_on_delivery_svm_payload", "invalid_on_delivery_svm_escrow_address_mismatch", "invalid_on_delivery_svm_buyer_signature", "invalid_on_delivery_svm_signature_expired", "invalid_on_delivery_svm_escrow_not_found", "invalid_on_delivery_svm_escrow_owner", "invalid_on_delivery_svm_escrow_version", "invalid_on_delivery_svm_wrong_state", "invalid_on_delivery_svm_buyer_mismatch", "invalid_on_delivery_svm_worker_mismatch", "invalid_on_delivery_svm_amount_mismatch", "invalid_on_delivery_svm_spec_hash_mismatch", "invalid_on_delivery_svm_deadline", "invalid_on_delivery_svm_claim_failed"];
+type OnDeliveryInvalidReason = (typeof ON_DELIVERY_SVM_INVALID_REASONS)[number] | "invalid_x402_version" | "invalid_scheme" | "invalid_network" | "invalid_payment_requirements";
+interface VerifyPresentationContext {
+    /** The absolute URL this server is serving: the paid route, or the poll URL for a poll. */
+    resourceUrl: string;
+    replay: ReplayStore;
+    /** Unix milliseconds. */
+    now?: () => number;
+}
+interface VerifyEscrowContext extends VerifyPresentationContext {
+    rpc: Pick<Connection, "getAccountInfo">;
+}
+type BuyerPresentationResult = {
+    isValid: true;
+    payer: string;
+} | {
+    isValid: false;
+    invalidReason: OnDeliveryInvalidReason;
+};
+/** `payer` is set on an invalid verdict exactly when the buyer's signature verified. */
+type OnDeliveryVerifyResult = {
+    isValid: true;
+    payer: string;
+    job: "new" | "retry";
+    escrow: DecodedEscrowAccount;
+} | {
+    isValid: false;
+    invalidReason: OnDeliveryInvalidReason;
+    payer?: string;
+};
+/**
+ * Binding server steps 1 to 3, with no RPC call: what a poll runs, `ctx.resourceUrl` being the poll
+ * URL. Throws {@link EscroError} `VALIDATION_ERROR` before any work when `ctx.replay` is missing or
+ * `ctx.resourceUrl` is not an absolute http: or https: URL.
+ */
+declare function verifyBuyerPresentation(payment: PaymentPayload, entry: OnDeliveryAccept, ctx: VerifyPresentationContext): Promise<BuyerPresentationResult>;
+/**
+ * Binding server steps 1 to 6 against the server's own `entry`: the payload, the escrow PDA, the
+ * buyer's signature within 30 s, claimed once in `ctx.replay`, then the escrow account read at
+ * `confirmed`. A Funded escrow is a new job; InProgress or Submitted a retry. Throws
+ * {@link ChainReadError} `CHAIN_RPC_FAILED` when the RPC fails, and {@link EscroError}
+ * `VALIDATION_ERROR` before any work when `ctx.replay` is missing or `ctx.resourceUrl` is not an
+ * absolute http: or https: URL.
+ */
+declare function verifyEscrowPayload(payment: PaymentPayload, entry: OnDeliveryAccept, ctx: VerifyEscrowContext): Promise<OnDeliveryVerifyResult>;
+
+export { AKASH_ADAPTER_ID, AKASH_CAPABILITIES, AKASH_DEMO_ACCEPT_FLOOR, AKASH_DEMO_MARKER, ARCHIVAL_RPC_NOTE, AdapterContractError, ApiClient, BUYER_MESSAGE_METHOD, CHAIN_READ_MAX_SIGNATURE_PAGES, CHAIN_READ_MAX_TRANSACTIONS, ChainReadError, ENABLED_RAILS, ESCROW_ACCOUNT_DISCRIMINATOR, ESCROW_ACCOUNT_LAYOUT, ESCROW_ACCOUNT_SIZE, Escro, EscroConfirmError, EscroError, EscroFacilitatorError, EscroPayError, EscroRailNotEnabledError, EscrowNotFoundError, EscrowPaymentRouter, EscrowState, EscrowStateError, EscrowTimeoutError, ExactAcceptError, GEN404_ADAPTER_ID, GEN404_CAPABILITIES, GEN404_DEMO_EVAL_FLOOR, GEN404_DEMO_MARKER, GENSYN_ADAPTER_ID, GENSYN_CAPABILITIES, GENSYN_DEMO_MARKER, GENSYN_REE_SCHEME, GRADIENTS_ADAPTER_ID, GRADIENTS_CAPABILITIES, GRADIENTS_DEMO_EVAL_FLOOR, GRADIENTS_DEMO_MARKER, LIUM_ADAPTER_ID, LIUM_CAPABILITIES, LIUM_DEMO_ACCEPT_FLOOR, LIUM_DEMO_MARKER, MAX_PROOF_URI_BYTES, MEMO_PROGRAM_ID, MIN_ESCROW_AMOUNT, ONCHAIN_REFUND_GRACE_SECONDS, ON_DELIVERY_SVM_INVALID_REASONS, OnDeliveryAcceptError, OnDeliveryFundError, PAY_MAX_DEADLINE_SECONDS, PREDICATES, PlatformConfigNotFoundError, PredicateEvaluationError, PredicateParamsError, PredicateRecordError, RAILS, RAILS_DOCS_URL, REFERENCE_MICRO_USDC_PER_AKT, REFERENCE_MICRO_USDC_PER_RENDER, RENDER_ADAPTER_ID, RENDER_CAPABILITIES, RENDER_DEMO_ACCEPT_FLOOR, RENDER_DEMO_MARKER, RIDGES_ADAPTER_ID, RIDGES_CAPABILITIES, RIDGES_DEMO_COVERAGE_TARGET, RIDGES_DEMO_MARKER, ReputationUnavailableError, SPEND_CAP_ERROR_CODES, SUPPORTED_SETTLEMENT_MODES, UnauthorizedError, X402CodecError, X402_HEADERS, ZKML_ADAPTER_ID, ZKML_CAPABILITIES, ZKML_DEMO_MARKER, ZKML_DEMO_MODEL_COMMITMENT, ZKML_PROOF_SCHEME, ZKML_PROOF_URI_PREFIX, akashDemoJobSpec, akt, assertServiceAdapterContract, assertWithinSpendCap, attestationValid, buildBazaarDeclaration, buildEscrowAccept, buildExactAccept, buildReeProof, buildZkmlProof, buyerMessage, chainReadConnection, ciCheck, computeAkashDemoArtifact, computeLiumDemoArtifact, computeRenderDemoArtifact, computeTaskSpecHash, computeZkmlInputCommitment, create404genAdapter, createAkashAdapter, createGensynAdapter, createGradientsAdapter, createHttpFacilitator, createLiumAdapter, createRenderAdapter, createRidgesAdapter, createZkmlAdapter, deadlineBoundedPolicy, decisionRecordHash, decodeEscrowAccount, decodeGensynBundle, decodePaymentRequired, decodePaymentResponse, decodePaymentSignature, decodeZkmlProofUri, encodeGensynBundle, encodePaymentRequired, encodePaymentResponse, encodePaymentSignature, encodeZkmlProofUri, exactFeePayer, fetchTaskSpec, fileFormat, fundFromAccept, gen404DemoJobSpec, gensynAutoRelease, gensynDemoJobSpec, gensynProofAutoRelease, gradientsDemoJobSpec, hashMatches, isBadPortUrl, isPublicAddress, jcs, jsonSchema, liumDemoJobSpec, llmRubric, memoryReplayStore, paramsHash, parseEscroExtension, parseEscrowAccept, parseUsdc, payAddressRule, payUrlRefusal, periodSla, podReceipt, predicateJob, predicateMemo, proofUriError, readEscrowFromChain, readPlatformConfig, renderAmount, renderDemoJobSpec, reproduceGensynCompute, ridgesDemoJobSpec, runPredicate, score404genDemoDeliverable, scoreAkashDemoDeliverable, scoreGradientsDemoDeliverable, scoreLiumDemoDeliverable, scoreRenderDemoDeliverable, scoreRidgesDemoDeliverable, serviceResultToSubmitParams, settlementModeSupported, signEscrowPayload, solveAkashDemo, solveGen404Demo, solveGradientsDemo, solveLiumDemo, solveRenderDemo, solveRidgesDemo, solveZkmlDemo, tao, testsPass, verifyBuyerPresentation, verifyEscrowPayload, verifyReeProof, verifyZkmlProof, verifyZkmlProofUri, zkmlDemoJobSpec, zkmlProofAutoRelease };
+export type { Acceptance, AcceptanceCriterion, AdapterContractOptions, AkashAdapterConfig, Akt, AutoReleaseDecision, BazaarDeclaration, BazaarHttpInput, BotDescriptor, BotRole, BuildBazaarDeclarationOptions, BuildEscrowAcceptOptions, BuildExactAcceptOptions, BuyerPresentationResult, ChainAccountInvalidReason, ChainEscrowFigures, ChainEscrowReading, ChainReadErrorCode, ChainReadRpc, ChainReadTarget, ChainSettlement, CreateEscrowParams, CreateEscrowResult, DecisionJob, DecisionRecord, DecodedEscrowAccount, DeliverableFormat, DeliverableType, Delivery, EscroExtensionInfo, EscroNextAction, EscroOptions, EscroReceipt, EscroSettlementTerms, EscrowAcceptSelection, EscrowAccount, EscrowErrorCode, ExactAcceptRefusal, Facilitator, FacilitatorOperation, FundFromAcceptDeps, FundFromAcceptResult, Gen404AdapterConfig, GensynAdapterConfig, GensynDeliverableBundle, GensynProofAutoReleaseOptions, GradientsAdapterConfig, HostLookup, HttpFacilitatorOptions, ListBotsParams, ListOptions, LiumAdapterConfig, Network, OnDeliveryAccept, OnDeliveryAcceptRefusal, OnDeliveryExtra, OnDeliveryFundRefusal, OnDeliveryInvalidReason, OnDeliveryPayloadFields, OnDeliveryPaymentPayload, OnDeliveryScheme, OnDeliveryVerifyResult, PaginatedResult, ParseEscrowAcceptContext, PayOffer, PayParams, PayPolicy, PayRefusal, PayRequest, PayUrlRefusal, PaymentPayload, PaymentRequired, PaymentRequirements, PaymentResult, PaymentRouter, PinContent$3 as PinContent, PlatformConfigTerms, PollOptions, Predicate, PredicateCheck, PredicateContext, PredicateName, PredicateOutcome, PredicateResult, ProtocolStats, ProtocolStatsFigures, Rail, RaiseDisputeParams, ReadEscrowFromChainOptions, ReeExecution, ReeProof, ReeVerification, ReeVerifyContext, ReleasePaymentOutcome, ReleaseWithPredicateOutcome, Render, RenderAdapterConfig, ReplayStore, ReproduceCompute, ResolveProofUri, ResourceInfo, RidgesAdapterConfig, RunAkashDeployment, RunCodingAgent, RunGpuJob, RunRenderJob, SendOptions, ServedWalletReputation, ServiceAdapter, ServiceResult, SettlementMode, SettlementResponse, SpendCap, SubmitDeliverableParams, SubnetCall, SupportedKind, SupportedResponse, Tao, TaskSpec, TaskType, TxShape, UnsignedBotDescriptor, UsdcToAktSwap, UsdcToRenderSwap, UsdcToTaoSwap, VerifyEscrowContext, VerifyPresentationContext, VerifyResponse, WorkerCandidate, X402SpendCap, ZkmlAdapterConfig, ZkmlDeliverable, ZkmlExpectation, ZkmlInferenceOutput, ZkmlProof, ZkmlProofAutoReleaseOptions, ZkmlProofBundle, ZkmlReviewPolicy, ZkmlReviewResult, ZkmlVerification };