@escro/sdk 0.1.4 → 0.3.0

package/dist/index.d.cts

@@ -1,9 +1,426 @@
-import { TaskSpec, EscrowState, EscrowAccount } from '@escro/shared';
-export { AcceptanceCriterion, DeliverableFormat, DeliverableType, EscrowAccount, EscrowErrorCode, EscrowState, Network, TaskSpec, TaskType } from '@escro/shared';
 import { Keypair } from '@solana/web3.js';
 
+/**
+ * All possible lifecycle states of an AgentEscrow account on-chain.
+ *
+ * State transitions (happy path):
+ * CREATED → FUNDED → IN_PROGRESS → SUBMITTED → COMPLETED
+ *
+ * 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)
+ */
+declare enum EscrowState {
+    /** Escrow PDA created on-chain; awaiting token deposit from the maker. */
+    CREATED = "CREATED",
+    /** Maker deposited tokens into the vault; open for agent acceptance. */
+    FUNDED = "FUNDED",
+    /** An agent accepted the task; work is underway. */
+    IN_PROGRESS = "IN_PROGRESS",
+    /** Agent submitted a deliverable URI; awaiting buyer review or 24h auto-release. */
+    SUBMITTED = "SUBMITTED",
+    /** Funds released to the agent. Terminal state. */
+    COMPLETED = "COMPLETED",
+    /** Buyer cancelled before work started. Terminal state. */
+    CANCELLED = "CANCELLED",
+    /** Maker or agent raised a dispute; requires human arbitration. */
+    DISPUTED = "DISPUTED",
+    /** Funds returned to the maker (deadline expiry or dispute resolution). Terminal state. */
+    REFUNDED = "REFUNDED"
+}
+/** Solana cluster the escrow account lives on. */
+type Network = "mainnet-beta" | "devnet" | "localnet";
+/**
+ * Full on-chain representation of an AgentEscrow PDA, enriched with
+ * off-chain metadata resolved by the API server.
+ *
+ * `amount` and all `*At` timestamps use the on-chain units:
+ *   - `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.
+ */
+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. */
+    taker: string | null;
+    /** Base-58 public key of the SPL token mint used for payment (e.g. USDC mint). */
+    mint: string;
+    /**
+     * Payment amount held in escrow, in the mint's smallest denomination.
+     * Stored as `bigint` to preserve full u64 precision from the on-chain account.
+     */
+    amount: bigint;
+    /** Current lifecycle state of the escrow. */
+    state: EscrowState;
+    /**
+     * SHA-256 hex digest of the canonical UTF-8 JSON serialisation of the {@link TaskSpec}.
+     * Stored on-chain; used by the oracle to verify it is evaluating the correct spec.
+     */
+    taskSpecHash: string;
+    /**
+     * Content-addressed URI (ipfs:// or ar://) where the full {@link TaskSpec} JSON is pinned.
+     * `null` until the maker uploads the spec via `POST /v1/task-specs`.
+     */
+    taskSpecUri: string | null;
+    /** Base-58 public key of the oracle authority permitted to sign timeout_release / refund_buyer. */
+    oracle: string;
+    /**
+     * Percentage of `amount` charged as a platform fee, in basis points.
+     * Deducted from the escrow vault on successful settlement.
+     * Valid range: 0–10 000 (0 %–100 %).
+     */
+    oracleFeeBps: number;
+    /** Unix timestamp (seconds) when the escrow PDA was initialised. */
+    createdAt: number;
+    /**
+     * Unix timestamp (seconds) at which the escrow deadline expires; mirrors the
+     * on-chain `deadline` field set at `create_escrow`. A Worker Bot reads this to
+     * decide whether it can finish a job before the deadline (never claim what it
+     * can't finish); after it passes, an unstarted escrow is refundable to the maker.
+     */
+    deadline: number;
+    /** Unix timestamp (seconds) of the most recent agent submission, or `null`. */
+    submittedAt: number | null;
+    /**
+     * SHA-256 hex digest of the worker's submitted deliverable, mirrored from the
+     * on-chain `deliverable_hash` written at `submit_deliverable`; `null` until the
+     * escrow reaches SUBMITTED. The on-chain value is authoritative: a Buyer Bot's
+     * review re-verifies a deliverable against a hash it independently expects and
+     * never treats this mirror as proof of integrity on its own.
+     */
+    deliverableHash: string | null;
+    /**
+     * URI of the submitted deliverable artifact (S3 presigned / IPFS / Arweave),
+     * mirrored from the off-chain `proof_uri` recorded at `submit_deliverable`;
+     * `null` until SUBMITTED. The Buyer Bot fetches the deliverable content here to
+     * review it.
+     */
+    proofUri: string | null;
+    /** PDA canonical bump seed, stored on-chain to validate future instructions. */
+    bump: number;
+    /** Solana cluster this account belongs to. */
+    network: Network;
+}
+/** Protocol-wide aggregate statistics — public, unauthenticated. */
+interface ProtocolStats {
+    totalEscrows: number;
+    totalVolumeUsdc: string;
+    /**
+     * Settled USDC volume: the sum of `amount_usdc` (the job amount, which the
+     * worker keeps in full; the additive platform fee is protocol revenue, not
+     * settled work volume) over escrows in the COMPLETED terminal state. COMPLETED
+     * is reached only by the three worker-paying instructions (release_payment,
+     * timeout_release, arbitration_release); refunded and cancelled escrows never
+     * paid a worker and are excluded. This is the honest headline number: it counts
+     * settlement, not transaction volume.
+     */
+    settledVolumeUsdc: string;
+    byState: Record<EscrowState, number>;
+    activeEscrows: number;
+}
+
+/**
+ * Broad categories of agent work.
+ *
+ * Used for analytics and UI display. Use `"custom"` for task types not
+ * covered by the built-in categories.
+ */
+type TaskType = "code_generation" | "code_review" | "data_analysis" | "content_writing" | "translation" | "summarization" | "question_answering" | "image_generation" | "audio_transcription" | "custom";
+/** High-level container format for a deliverable artifact. */
+type DeliverableType = "text" | "json" | "file" | "url" | "code";
+/**
+ * Constraints on the shape, size, and encoding of the expected deliverable.
+ */
+interface DeliverableFormat {
+    /** High-level container type. Determines which other fields are applicable. */
+    type: DeliverableType;
+    /**
+     * JSON Schema (draft-07) object the deliverable must validate against.
+     * Only applicable when `type === "json"`.
+     */
+    schema?: Record<string, unknown>;
+    /**
+     * Expected MIME type of the delivered file (e.g. `"application/pdf"`, `"image/png"`).
+     * Only applicable when `type === "file"`.
+     */
+    mimeType?: string;
+    /**
+     * Maximum permitted size of the deliverable content in bytes.
+     * Applies to `"file"`, `"text"`, `"code"`, and `"json"` types.
+     */
+    maxSizeBytes?: number;
+    /**
+     * Programming language identifier for code deliverables (e.g. `"typescript"`, `"python"`).
+     * Only applicable when `type === "code"`.
+     */
+    language?: string;
+}
+/**
+ * A single acceptance criterion that the deliverable must satisfy.
+ */
+interface AcceptanceCriterion {
+    /**
+     * Unique identifier for this criterion within the task spec.
+     * Convention: short kebab-case string, e.g. `"ac-correctness"`, `"ac-format"`.
+     * Must be unique within a single {@link TaskSpec}.
+     */
+    id: string;
+    /**
+     * Human-readable description of what must be true for this criterion to pass.
+     */
+    description: string;
+    /**
+     * Relative importance of this criterion.
+     * Weights are normalised across all criteria, so only their ratios matter.
+     * Defaults to `1.0` when omitted.
+     */
+    weight?: number;
+    /**
+     * When `true`, this criterion is mandatory for acceptance.
+     * Defaults to `false`.
+     */
+    required?: boolean;
+}
+/**
+ * Canonical specification of the unit of work held in escrow.
+ *
+ * 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. Pinned to IPFS or Arweave → URI stored as `EscrowAccount.taskSpecUri`.
+ *
+ * Any mutation of the spec changes its hash, invalidating the on-chain record.
+ */
+interface TaskSpec {
+    /**
+     * Semver string identifying the task spec schema version (e.g. `"1.0.0"`).
+     * Allows the oracle and API server to handle format evolution gracefully.
+     * Increment the minor version for backwards-compatible additions;
+     * the major version for breaking changes.
+     */
+    version: string;
+    /**
+     * Broad category of the task. See {@link TaskType} for supported values.
+     */
+    taskType: TaskType;
+    /**
+     * Complete description of the task, written for both the agent performing it
+     * and the oracle evaluating the result.
+     *
+     * Good descriptions:
+     *  - State the goal, not just the method.
+     *  - Include any non-obvious constraints (language, style, performance bounds).
+     *  - Are precise enough that an LLM could verify correctness without ambiguity.
+     */
+    description: string;
+    /**
+     * Ordered list of acceptance criteria the deliverable must satisfy.
+     * Must contain at least one entry.
+     */
+    acceptanceCriteria: AcceptanceCriterion[];
+    /**
+     * Structural and size constraints the deliverable must conform to.
+     */
+    deliverableFormat: DeliverableFormat;
+    /**
+     * Arbitrary key-value extension map for protocol plugins, agent hints, or audit trails.
+     */
+    metadata: Record<string, unknown>;
+}
+
+/**
+ * Exhaustive set of machine-readable error codes returned by the escro.ai REST API
+ * in the `code` field of an {@link ApiError} response.
+ *
+ * Consumers should switch on this value to handle errors programmatically
+ * rather than parsing the human-readable `error` string.
+ */
+type EscrowErrorCode = 
+/** The requested escrow PDA does not exist on the specified network. */
+"ESCROW_NOT_FOUND"
+/** The requested operation is not permitted in the escrow's current state. */
+ | "ESCROW_INVALID_STATE"
+/** The referenced task spec hash has not been registered. */
+ | "TASK_SPEC_NOT_FOUND"
+/** The submitted task spec failed schema validation. */
+ | "TASK_SPEC_INVALID"
+/** The caller does not have permission to perform this action. */
+ | "UNAUTHORIZED"
+/** The provided transaction signature is invalid or does not match the escrow. */
+ | "INVALID_SIGNATURE"
+/** The requested token amount is zero, negative, or exceeds the u64 maximum. */
+ | "INVALID_AMOUNT"
+/** The escrow's network does not match the caller's requested network. */
+ | "NETWORK_MISMATCH"
+/** The caller has exceeded the rate limit; retry after the indicated backoff. */
+ | "RATE_LIMITED"
+/** An unexpected server-side error occurred; report to escro.ai support. */
+ | "INTERNAL_ERROR"
+/** Request body or query parameters failed schema validation. */
+ | "VALIDATION_ERROR"
+/** Confirm: no transaction for the signature at `confirmed` yet; retry once it lands. */
+ | "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. */
+ | "TX_MISMATCH"
+/** Confirm: the Solana RPC read failed; retry. */
+ | "RPC_UNAVAILABLE";
+
+/**
+ * EscroBots v0 - the permissionless capability directory (ARCHITECTURE §8).
+ *
+ * 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
+ * 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.
+ */
+declare const BOT_ROLES: readonly ["worker", "buyer", "both"];
+/** Whether the bot hires work, performs work, or both. */
+type BotRole = (typeof BOT_ROLES)[number];
+/**
+ * The descriptor fields the bot's wallet signs. Everything a registry consumer
+ * needs to find and reach the bot, minus the signature over these fields.
+ */
+interface UnsignedBotDescriptor {
+    /** Base58 Solana pubkey - the advertising bot and the descriptor's signer. */
+    wallet: string;
+    /** What the bot does in the escrow relationship. */
+    role: BotRole;
+    /** Free-form capability tags, e.g. `["fine-tune", "eval"]`. Filterable. */
+    capabilities: string[];
+    /** The underlying service the bot wraps, e.g. `"bittensor:sn56"`. */
+    serviceRef: string;
+    /** Human-readable pricing guidance, e.g. `"~$5 per fine-tune job"`. */
+    pricingHint: string;
+    /** Optional http(s) endpoint a buyer can reach the bot at. */
+    endpoint?: string;
+    /** Unix milliseconds when the descriptor was signed. Monotonic per wallet. */
+    signedAt: number;
+}
+/**
+ * A signed capability descriptor as stored and served by the registry.
+ * `signature` is a base58 detached Ed25519 signature over the canonical form of
+ * the {@link UnsignedBotDescriptor} fields (see `canonicalBotDescriptorMessage`).
+ */
+interface BotDescriptor extends UnsignedBotDescriptor {
+    /** Base58 detached Ed25519 signature over the canonical unsigned descriptor. */
+    signature: string;
+}
+
+type SolanaCluster = "devnet" | "mainnet";
+
+/** Dispute tally with its outcome split (from the wallet's perspective). */
+interface DisputeRecord {
+    /** Total disputes this wallet was party to (raised by either side). */
+    total: number;
+    /** Disputes resolved in this wallet's favour. */
+    won: number;
+    /** Disputes resolved against this wallet. */
+    lost: number;
+}
+/** Worker-side raw reputation components for a wallet. */
+interface WorkerReputation {
+    /** Tasks this wallet claimed. */
+    tasksClaimed: number;
+    /**
+     * Completions credited to the Worker. Per the #23.1 ruling this is exactly the
+     * explicit-Buyer-release and timeout-release paths; an arbitration_release is a
+     * dispute WIN (see {@link disputes}), not a completion, though its funds still
+     * count in {@link volumeSettledUsdc}.
+     */
+    completions: number;
+    /** Completions via explicit Buyer release (stored distinctly — #23.1). */
+    completionsViaRelease: number;
+    /** Completions via timeout release (stored distinctly — #23.1). */
+    completionsViaTimeout: number;
+    /** Claimed-but-not-delivered escrows (deadline-expiry refund — #23.2). */
+    nonDeliveries: number;
+    /** completions / tasksClaimed; null when no task was claimed. */
+    completionRate: number | null;
+    /** Disputes as Worker: won = arbitration_release, lost = arbitration_refund. */
+    disputes: DisputeRecord;
+    /** disputes.total / tasksClaimed; null when no task was claimed. */
+    disputeRate: number | null;
+    /** Sum of worker_amount received in μUSDC. */
+    volumeSettledUsdc: bigint;
+    /** Avg seconds create->claim across this wallet's claimed escrows; null if none. */
+    avgCreateToClaimSeconds: number | null;
+    /** Avg seconds claim->submit across this wallet's submitted escrows; null if none. */
+    avgClaimToSubmitSeconds: number | null;
+}
+/** Buyer-side raw reputation components for a wallet. */
+interface BuyerReputation {
+    /** Escrows this wallet created. */
+    escrowsCreated: number;
+    /** Escrows that settled via timeout release — buyer non-response signal (#23.1). */
+    timeoutReleases: number;
+    /** Disputes as Buyer: won = arbitration_refund, lost = arbitration_release. */
+    disputes: DisputeRecord;
+    /** disputes.total / escrowsCreated; null when no escrow was created. */
+    disputeRate: number | null;
+    /** Sum of worker_amount settled out of escrows this wallet funded, in μUSDC. */
+    volumeSettledUsdc: bigint;
+}
+/**
+ * The complete raw reputation for one wallet. No composite/overall score field
+ * exists by design (ARCHITECTURE §9).
+ */
+interface WalletReputation {
+    /** Base-58 wallet address. */
+    wallet: string;
+    /** Worker-side components. */
+    asWorker: WorkerReputation;
+    /** Buyer-side components. */
+    asBuyer: BuyerReputation;
+    /** Unix seconds of first Escro activity (wallet-age basis); null if none. */
+    firstActivityAt: number | null;
+    /** Unix seconds of most recent Escro activity; null if none. */
+    lastActivityAt: number | null;
+}
+/** JSON-safe form of {@link WalletReputation} (bigint volumes as decimal strings). */
+interface SerializedWalletReputation extends Omit<WalletReputation, "asWorker" | "asBuyer"> {
+    asWorker: Omit<WorkerReputation, "volumeSettledUsdc"> & {
+        volumeSettledUsdc: string;
+    };
+    asBuyer: Omit<BuyerReputation, "volumeSettledUsdc"> & {
+        volumeSettledUsdc: string;
+    };
+}
+/**
+ * The wire shape served by the internal reputation endpoint: the serialized
+ * aggregates plus wallet age derived at serve time. The indexer stores raw
+ * clock-free timestamps ({@link WalletReputation.firstActivityAt}); age (#23.5,
+ * "age since first Escro activity") is a function of the serving clock, so it is
+ * derived here rather than baked into the stored aggregates.
+ */
+interface ServedWalletReputation extends SerializedWalletReputation {
+    /** now - firstActivityAt in seconds; null when the wallet has no activity. */
+    walletAgeSeconds: number | null;
+}
+
 /** Constructor options for the {@link Escro} client. */
 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).
+     */
+    cluster: SolanaCluster;
     /** Solana RPC endpoint URL. */
     rpcUrl: string;
     /** Escro REST API base URL (e.g. "https://api.escro.ai"). */
@@ -22,8 +439,12 @@ interface CreateEscrowParams {
      */
     amountUsdc: number;
     /** Unix timestamp (seconds) at which the escrow deadline expires. */
-    deadlineSeconds: number;
-    /** Base-58 public key of the worker pre-assigned to this task. */
+    deadlineUnix: number;
+    /**
+     * 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).
+     */
     assignedWorker: string;
 }
 /** Return value from {@link Escro.createEscrow}. */
@@ -81,29 +502,120 @@ interface PaginatedResult<T> {
     /** The effective offset applied to this response. */
     offset: number;
 }
+/** Filters for an EscroBots registry read (`GET /v1/bots`). */
+interface ListBotsParams {
+    /** Free-form capability tag to filter by, e.g. `"fine-tune"`. */
+    capability?: string;
+    /** Role filter. `worker` includes `both` bots (a `both` bot is hireable as a worker). */
+    role?: BotDescriptor["role"];
+    /** Maximum number of descriptors to return. */
+    limit?: number;
+    /** Zero-based offset for pagination. */
+    offset?: number;
+}
+/**
+ * One candidate returned by {@link Escro.findWorkers}. The `descriptor` is a
+ * self-reported CLAIM (ARCHITECTURE §8); `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
+ * of the claim, deliberately kept separate here, never merged into one flag.
+ */
+interface WorkerCandidate {
+    /** The wallet-signed capability descriptor as served by the registry (a claim). */
+    descriptor: BotDescriptor;
+    /** True iff `descriptor.signature` verifies against `descriptor.wallet` (authorship only). */
+    signatureValid: boolean;
+}
+
+/**
+ * Reserved dual-path payment surface (ARCHITECTURE §7a, BOT_KIT_PRD §10).
+ *
+ * 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 (P9.T5) 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.
+ */
+/** 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. */
+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. */
+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. */
+interface TxShape {
+    /** Recipient wallet address (base58). */
+    readonly to: string;
+    /** Amount to move, in USDC micro-units (integer, 6 decimals). */
+    readonly amountMicroUsdc: number;
+    /** `async` (verification-needed) work routes to escrow; `sync` work is x402's territory. */
+    readonly mode: "async" | "sync";
+}
+/** 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. */
+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. */
+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. */
+interface PayParams {
+    /** Recipient wallet address (base58). */
+    readonly to: string;
+    /** Amount to pay, in USDC micro-units (integer, 6 decimals). */
+    readonly amountMicroUsdc: number;
+}
+/** 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
+ *  x402), so the shape describes either rail without change. */
+interface PaymentResult {
+    /** Which rail settled the payment. */
+    readonly rail: Rail;
+    /** Rail-native settlement reference. */
+    readonly reference: string;
+}
 
 declare class Escro {
     private readonly connection;
     private readonly api;
     private readonly options;
+    private readonly cluster;
+    private readonly router;
     constructor(options: EscroOptions);
     /**
      * Create a new escrow: registers with the API, signs and submits the
-     * on-chain `create_escrow` transaction.
+     * on-chain `create_escrow` transaction, then confirms it with the API.
      *
      * @returns `{ escrowId, escrowPda, signature }` — use `escrowPda` for all subsequent calls.
      */
     createEscrow(params: CreateEscrowParams): Promise<CreateEscrowResult>;
     /**
      * Release payment to the worker. Buyer must be the wallet in the constructor.
-     * Updates API DB state, then builds and submits the `release_payment` on-chain tx.
+     * Builds and submits the `release_payment` on-chain tx FIRST (the chain is the
+     * source of truth), then confirms DB state. The DB confirmation is best-effort:
+     * the oracle sweep reconciles it if it fails.
      *
      * @returns Solana transaction signature.
      */
     releasePayment(address: string): Promise<string>;
     /**
      * 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.
+     * may call this. Signs and submits the `raise_dispute` on-chain tx, then confirms it with the API.
      *
      * @returns Solana transaction signature.
      */
@@ -111,21 +623,33 @@ declare class Escro {
     /**
      * 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; full USDC refund to buyer.
+     * Signs and submits the `cancel_escrow` on-chain tx, then confirms it with the API; full USDC refund to buyer.
      *
      * @returns Solana transaction signature.
      */
     cancelEscrow(address: string): 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.
+     *
+     * 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.
+     */
+    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.
+     * Signs and submits the `claim_task` on-chain tx, then confirms it with the API.
      *
      * @returns Solana transaction signature.
      */
     claimTask(address: string): Promise<string>;
     /**
-     * Submit a deliverable for oracle evaluation. Worker must be the wallet.
-     * Signs and submits the `submit_deliverable` on-chain tx.
+     * 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.
      *
      * @returns Solana transaction signature.
      */
@@ -141,6 +665,63 @@ declare class Escro {
      * @param options - Polling, pagination (limit/offset).
      */
     getMyTasks(state?: EscrowState[], options?: PollOptions & 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
+     * and paginate.
+     *
+     * A Buyer Bot uses this to sum its own outstanding (still-locked) escrows for
+     * the client-side spend cap: the program is the source of truth, so the total
+     * is read from chain state (via the API), never a local tally a crash could lose.
+     *
+     * @param state   - Filter by one or more states (first state used as API filter).
+     * @param options - Polling, pagination (limit/offset).
+     */
+    getMyEscrows(state?: EscrowState[], options?: PollOptions & ListOptions): Promise<PaginatedResult<EscrowAccount>>;
+    /**
+     * 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.
+     *
+     * 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.
+     */
+    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
+     * 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}
+     * candidates by wallet. Throws {@link ReputationUnavailableError} when the
+     * deployment mounts no reputation source (HTTP 404).
+     */
+    listReputations(): Promise<ServedWalletReputation[]>;
+    /**
+     * Fetch protocol-wide stats from the public `GET /v1/stats` endpoint.
+     *
+     * @returns protocol-wide {@link ProtocolStats}.
+     */
+    getStats(): Promise<ProtocolStats>;
+    /**
+     * Ask the API to record the create, claim, submit, cancel or dispute that the
+     * landed `signature` carries; the API verifies it on chain first. Retries a
+     * 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).
+     */
+    confirm(address: string, signature: string, opts?: {
+        evidence?: string;
+    }): Promise<EscrowAccount>;
+    private send;
+    private sendAndConfirm;
     /**
      * Fetch an escrow by its PDA address.
      * If `options.poll` is true, polls with exponential backoff until the escrow
@@ -149,15 +730,170 @@ declare class Escro {
     getEscrow(address: string, options?: PollOptions): Promise<EscrowAccount>;
 }
 
-/** Base class for all errors thrown by the @escro/sdk. */
+declare class ApiClient {
+    private readonly baseUrl;
+    private readonly wallet;
+    constructor(baseUrl: string, wallet: Keypair);
+    private url;
+    /** GET /v1/escrows/:address */
+    getEscrow(address: string): Promise<EscrowAccount>;
+    /** GET /v1/escrows?assignedTo=...&maker=...&state=... */
+    listEscrows(params: {
+        assignedTo?: string;
+        maker?: string;
+        state?: EscrowState;
+        limit?: number;
+        offset?: number;
+    }): Promise<PaginatedResult<EscrowAccount>>;
+    /**
+     * GET /v1/bots?capability=...&role=...&limit=...&offset= : EscroBots registry
+     * read. Unauthenticated public read (no auth headers). Returns descriptors in
+     * registry order (newest first); descriptors are self-reported claims.
+     */
+    listBots(params: ListBotsParams): Promise<PaginatedResult<BotDescriptor>>;
+    /**
+     * GET /rep : EscroRep bulk export (ARCHITECTURE §9). 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
+     * per-candidate fan-out would rate-limit itself. A 404 means the deployment
+     * mounted no reputation source (unknown wallets return zeroed rep, never 404),
+     * so it surfaces as {@link ReputationUnavailableError}, not EscrowNotFoundError.
+     */
+    listReputations(): Promise<ServedWalletReputation[]>;
+    /**
+     * GET /rep/:wallet : one wallet's EscroRep RAW components (ARCHITECTURE §9).
+     * 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
+     * per-wallet rate budget with every other caller, so fan-outs should use
+     * {@link listReputations} instead.
+     */
+    getReputation(wallet: string): Promise<ServedWalletReputation>;
+    /**
+     * POST /v1/escrows — create escrow, returns unsigned tx + ids.
+     * Requires auth.
+     */
+    createEscrow(params: CreateEscrowParams): Promise<{
+        escrowId: string;
+        escrowPda: string;
+        unsignedTx: string;
+    }>;
+    /**
+     * 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.
+     * Requires auth (worker).
+     */
+    submitDeliverable(address: string, params: SubmitDeliverableParams): Promise<{
+        unsignedTx: string;
+    }>;
+    /**
+     * POST /v1/escrows/:address/release — DB-only state update.
+     * Requires auth (buyer). No on-chain tx returned.
+     */
+    releasePaymentDb(address: string): Promise<void>;
+    /**
+     * 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.
+     * Requires auth (buyer or worker).
+     */
+    raiseDispute(address: string, params: Pick<RaiseDisputeParams, "reason">): Promise<{
+        unsignedTx: string;
+    }>;
+    /**
+     * POST /v1/escrows/:address/confirm: the API records the create, claim, submit,
+     * cancel or dispute the landed `signature` carries, after verifying it on chain.
+     * A non-2xx answer throws an {@link EscroError} with the server's code, or
+     * `HTTP_<status>` when the answer carries none; a network failure rejects with
+     * fetch's own error. {@link Escro.confirm} decides which to retry.
+     */
+    confirm(address: string, signature: string, evidence?: string): Promise<EscrowAccount>;
+    /**
+     * GET /v1/stats — public protocol-wide stats.
+     * No auth required. Upstream typing in {@link Escro.getStats} narrows the
+     * return shape.
+     */
+    getStats(): Promise<unknown>;
+}
+
+/**
+ * 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).
+ */
+interface ServiceResult {
+    /** The deliverable itself. */
+    content: string | Buffer;
+    /** SHA-256 hex digest of {@link ServiceResult.content}. */
+    contentHash: string;
+    /** Content-addressed URI (ipfs://, ar://) or proof URI for the deliverable. */
+    proofUri?: string;
+    /** Arbitrary adapter-specific metadata (model, timings, subnet ids, ...). */
+    metadata: Record<string, unknown>;
+}
+/**
+ * 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
+ * this interface and is validated by `assertServiceAdapterContract`.
+ */
+interface ServiceAdapter {
+    /** Stable identifier, e.g. "bittensor:sn56", "akash", "render". */
+    id: string;
+    /** Advertised capabilities, e.g. ["llm_inference", "image_gen"]. */
+    capabilities: string[];
+    /** Execute the task described by `spec` and return the deliverable. */
+    execute(spec: TaskSpec): Promise<ServiceResult>;
+    /** Report whether the underlying service is reachable and ready. */
+    healthCheck(): Promise<boolean>;
+}
+/**
+ * Map a {@link ServiceResult} onto {@link SubmitDeliverableParams}, surfacing the
+ * `contentHash` (and `proofUri`, when present) that `submit_deliverable` records.
+ * This is the single point where an adapter's output crosses into the escrow
+ * worker flow.
+ */
+declare function serviceResultToSubmitParams(result: ServiceResult): SubmitDeliverableParams;
+
+/**
+ * Base class for all errors thrown by the @escro/sdk. `retryAfterMs` is the
+ * server's Retry-After delay, when it sent one in seconds.
+ */
 declare class EscroError extends Error {
     readonly code: string;
-    constructor(message: string, code?: string);
+    readonly retryAfterMs?: number | undefined;
+    constructor(message: string, code?: string, retryAfterMs?: number | undefined);
 }
 /** The requested escrow was not found (HTTP 404). */
 declare class EscrowNotFoundError extends EscroError {
     constructor(address: string);
 }
+/**
+ * The reputation endpoint is not available on this deployment (HTTP 404). A 404
+ * from `GET /rep` means no `ReputationSource` is mounted (the surface is
+ * unmounted), NOT that a wallet is unknown - unknown wallets return zeroed raw
+ * components, never a 404. Kept distinct from {@link EscrowNotFoundError}, whose
+ * 404 is about a missing escrow.
+ */
+declare class ReputationUnavailableError extends EscroError {
+    constructor();
+}
 /** The operation is not valid for the escrow's current state (HTTP 409). */
 declare class EscrowStateError extends EscroError {
     constructor(message: string);
@@ -166,9 +902,853 @@ declare class EscrowStateError extends EscroError {
 declare class EscrowTimeoutError extends EscroError {
     constructor(address: string);
 }
+/**
+ * A transaction landed (or was sent) but the API did not record it. `code` is the
+ * server's code (e.g. TX_MISMATCH, TX_FAILED, or TX_NOT_FOUND after the retry
+ * window), `NETWORK_ERROR` when the last attempt never reached the API, or
+ * `HTTP_<status>` when the answer carried no code. Call {@link Escro.confirm} again
+ * with `address` and `signature` to retry.
+ */
+declare class EscroConfirmError extends EscroError {
+    readonly address: string;
+    readonly signature: string;
+    constructor(address: string, signature: string, code: string, message: string);
+}
 /** The caller is not authorized to perform this action (HTTP 401/403). */
 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.
+ */
+declare class EscroRailNotEnabledError extends EscroError {
+    readonly rail: string;
+    constructor(rail: string);
+}
+
+/** Options controlling {@link assertServiceAdapterContract}. */
+interface AdapterContractOptions {
+    /**
+     * A representative TaskSpec the adapter can execute. The harness calls
+     * `execute(sampleSpec)` and validates the returned ServiceResult, so the spec
+     * should be one the adapter genuinely handles.
+     */
+    sampleSpec: TaskSpec;
+}
+/** Thrown by {@link assertServiceAdapterContract}, listing every contract violation. */
+declare class AdapterContractError extends EscroError {
+    readonly violations: string[];
+    constructor(adapterId: string, violations: string[]);
+}
+/**
+ * Assert that `adapter` satisfies the ServiceAdapter contract. Resolves with the
+ * 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
+ * typed `ServiceAdapter`, but the harness validates at runtime: JS callers and
+ * `as`-cast objects reach this too, so every field is checked defensively.
+ */
+declare function assertServiceAdapterContract(adapter: ServiceAdapter, options: AdapterContractOptions): Promise<ServiceResult>;
+
+/**
+ * Amount denominated in TAO (Bittensor's token). Branded so it cannot be assigned to
+ * or from a plain `number` by accident and (the point of the brand) so it can never
+ * appear in a `ServiceResult` or the escrow submit path: those types have no field of
+ * this type. TAO exists ONLY inside the Bittensor adapter layer.
+ */
+type Tao = number & {
+    readonly __brand: "TAO";
+};
+/** Construct a {@link Tao} amount from a plain number. Adapter-internal use only. */
+declare function tao(amount: number): Tao;
+/** Swap a microUSDC budget into TAO. Real workers route this through a DEX (e.g. Jupiter). */
+type UsdcToTaoSwap = (microUsdc: number) => Promise<Tao>;
+/**
+ * Pay subnet miners `budget` TAO to run `spec`; resolve with the raw deliverable. The
+ * single shared port shape across every Bittensor adapter (a GPU-rental call is a paid
+ * subnet call too; lium re-exports this as `RunGpuJob`).
+ */
+type SubnetCall = (spec: TaskSpec, budget: Tao) => Promise<string | Buffer>;
+/** Pin `content` and resolve with a content-addressed proof URI (ipfs://, ar://). */
+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
+ * 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).
+ *
+ * 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
+ * real implementations (Jupiter for the swap, the SN56 dendrite, Pinata/Arweave).
+ *
+ * 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).
+ *
+ * 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
+ * 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.
+ */
+
+/** Configuration and injectable ports for {@link createGradientsAdapter}. */
+interface GradientsAdapterConfig {
+    /** Subnet identifier. Defaults to "sn56" (Gradients); forms the adapter id `bittensor:<subnet>`. */
+    subnet?: string;
+    /** Advertised capabilities for EscroBots discovery. Defaults to `["fine-tune"]`. */
+    capabilities?: string[];
+    /** μUSDC the worker allocates to a single task before converting to TAO (internal budgeting). */
+    taskBudgetMicroUsdc?: number;
+    /** Swap port. Default: a fixed-rate reference stub. */
+    swap?: UsdcToTaoSwap;
+    /** Subnet-call port. Default: solves the canned demo job; a deterministic placeholder otherwise. */
+    callSubnet?: SubnetCall;
+    /** Pinning port. Default: a deterministic `ipfs://` placeholder URI. */
+    pin?: PinContent$3;
+    /** Health-check port. Default: resolves `true`. */
+    checkHealth?: () => Promise<boolean>;
+}
+/** Stable id/capabilities, LOCKED against `ADAPTER_DESCRIPTORS.gradients` by a kit test (consult C2). */
+declare const GRADIENTS_ADAPTER_ID = "bittensor:sn56";
+declare const GRADIENTS_CAPABILITIES: readonly ["fine-tune"];
+/** Stable marker on the demo spec's metadata so the default subnet stub recognizes it. */
+declare const GRADIENTS_DEMO_MARKER = "gradients-sn56-demo-v1";
+/** The demo eval floor: predictions must be at least this accurate to be accepted. */
+declare const GRADIENTS_DEMO_EVAL_FLOOR = 0.8;
+/**
+ * The canned Gradients demo job. Deterministic; its specHash is pinned by a test
+ * (consult C8) because the buyer journey depends on hash stability.
+ */
+declare const gradientsDemoJobSpec: TaskSpec;
+/**
+ * The reference solution to the demo job: the correct predictions plus a
+ * (self-reported, buyer-ignored) eval block, as canonical JSON. Deterministic.
+ * Exposed so the demo journey and tests share one source of the expected artifact.
+ */
+declare function solveGradientsDemo(): string;
+/**
+ * The BUYER's independent recompute of the demo eval score in [0, 1]. Reads the
+ * substantive output (the predictions) and compares it to the target map the buyer
+ * itself defines; it deliberately IGNORES any self-reported `eval.score` in the
+ * deliverable, so release can never be worker-controlled (consult C10). Malformed
+ * or unparseable content scores 0 and never throws.
+ */
+declare function scoreGradientsDemoDeliverable(content: string | Buffer): number;
+/**
+ * Build a Gradients (SN56) {@link ServiceAdapter}. Passes `assertServiceAdapterContract`
+ * with the default ports; supply real ports for production use. The USDC->TAO swap,
+ * pinning, and execute skeleton come from the shared Bittensor core.
+ */
+declare function createGradientsAdapter(config?: GradientsAdapterConfig): ServiceAdapter;
+
+/** Run the coding agent for `spec`; resolve with the raw deliverable (a test report). */
+type RunCodingAgent = (spec: TaskSpec) => Promise<string | Buffer>;
+/** Pin `content` and resolve with a content-addressed proof URI (ipfs://, ar://). */
+type PinContent$2 = (content: string | Buffer) => Promise<string>;
+/** Configuration and injectable ports for {@link createRidgesAdapter}. */
+interface RidgesAdapterConfig {
+    /** Service identifier. Defaults to "ridges"; forms the adapter id. */
+    service?: string;
+    /** Advertised capabilities for EscroBots discovery. Defaults to `["code-generation"]`. */
+    capabilities?: string[];
+    /** Coding-agent port. Default: solves the canned demo kata; a placeholder otherwise. */
+    runAgent?: RunCodingAgent;
+    /** Pinning port. Default: a deterministic `ipfs://` placeholder URI. */
+    pin?: PinContent$2;
+    /** Health-check port. Default: resolves `true`. */
+    checkHealth?: () => Promise<boolean>;
+}
+/**
+ * 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).
+ */
+declare const RIDGES_ADAPTER_ID = "ridges";
+declare const RIDGES_CAPABILITIES: readonly ["code-generation"];
+/** Stable marker on the demo spec's metadata so the default agent stub recognizes it. */
+declare const RIDGES_DEMO_MARKER = "ridges-demo-v1";
+/** The demo coverage target: the fraction of the test battery that must be covered. */
+declare const RIDGES_DEMO_COVERAGE_TARGET = 0.8;
+/**
+ * The canned Ridges demo job. Deterministic; its specHash is pinned by a test
+ * because the buyer journey depends on hash stability.
+ */
+declare const ridgesDemoJobSpec: TaskSpec;
+/**
+ * The reference solution to the demo kata: a passing test report over the full
+ * battery, plus a (self-reported, buyer-ignored) pass/coverage block, as canonical
+ * JSON. Deterministic. Exposed so the demo journey and tests share one source of the
+ * expected artifact.
+ */
+declare function solveRidgesDemo(): string;
+/**
+ * The BUYER's independent recompute of the demo acceptance, as a score in [0, 1].
+ * It reads the substantive output (the delivered test outputs) and recomputes the
+ * expected FizzBuzz result for each; it deliberately IGNORES any self-reported
+ * pass/coverage in the deliverable, so release can never be worker-controlled
+ * (consult C10). Semantics:
+ *   - Any delivered test whose output is wrong = the suite did not pass (exit != 0):
+ *     score 0, no matter how much of the battery is covered.
+ *   - Otherwise the score is coverage = (distinct battery inputs delivered) / (battery
+ *     size); the buyer releases when it clears {@link RIDGES_DEMO_COVERAGE_TARGET}.
+ * Malformed or unparseable content scores 0 and never throws.
+ */
+declare function scoreRidgesDemoDeliverable(content: string | Buffer): number;
+/**
+ * Build a Ridges {@link ServiceAdapter}. Passes `assertServiceAdapterContract` with
+ * the default ports; supply real ports for production use.
+ */
+declare function createRidgesAdapter(config?: RidgesAdapterConfig): ServiceAdapter;
+
+/**
+ * 404gen (Bittensor SN17) ServiceAdapter: a batch 3D-generation reference adapter,
+ * built to the pattern the shipped Gradients (SN56) adapter established (P6.T6a). A
+ * Worker Bot wraps the 404gen text-to-3D subnet behind the `ServiceAdapter` interface:
+ * 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).
+ *
+ * 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
+ * real implementations (Jupiter for the swap, the SN17 dendrite, Pinata/Arweave).
+ *
+ * RELEASE JUDGMENT IS NOT HERE. This adapter only PRODUCES the deliverable (a batch of
+ * 3D assets, each with a declared container format and polygon count). Whether the batch
+ * is acceptable is decided by the BUYER's review.ts. For the canned demo the buyer knows
+ * the exact expected artifact (the eval-threshold review re-verifies the fetched
+ * deliverable hashes to the submitted contentHash) and additionally gates on the declared
+ * per-asset descriptors via `score404genDemoDeliverable` (format, polygon range, batch
+ * 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).
+ *
+ * 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.
+ */
+
+/** Configuration and injectable ports for {@link create404genAdapter}. */
+interface Gen404AdapterConfig {
+    /** Subnet identifier. Defaults to "sn17" (404gen); forms the adapter id `bittensor:<subnet>`. */
+    subnet?: string;
+    /** Advertised capabilities for EscroBots discovery. Defaults to `["3d-generation"]`. */
+    capabilities?: string[];
+    /** μUSDC the worker allocates to a single task before converting to TAO (internal budgeting). */
+    taskBudgetMicroUsdc?: number;
+    /** Swap port. Default: a fixed-rate reference stub. */
+    swap?: UsdcToTaoSwap;
+    /** Subnet-call port. Default: solves the canned demo job; a deterministic placeholder otherwise. */
+    callSubnet?: SubnetCall;
+    /** Pinning port. Default: a deterministic `ipfs://` placeholder URI. */
+    pin?: PinContent$3;
+    /** Health-check port. Default: resolves `true`. */
+    checkHealth?: () => Promise<boolean>;
+}
+/** Stable id/capabilities, to be locked against `ADAPTER_DESCRIPTORS["404gen"]` by a kit test at merge (consult C2). */
+declare const GEN404_ADAPTER_ID = "bittensor:sn17";
+declare const GEN404_CAPABILITIES: readonly ["3d-generation"];
+/** Stable marker on the demo spec's metadata so the default subnet stub recognizes it. */
+declare const GEN404_DEMO_MARKER = "404gen-sn17-demo-v1";
+/** The demo eval floor: the batch must be complete and every asset valid (score 1). */
+declare const GEN404_DEMO_EVAL_FLOOR = 1;
+/**
+ * The canned 404gen demo job. Deterministic; its specHash is pinned by a test
+ * (consult C8) because the buyer journey depends on hash stability.
+ */
+declare const gen404DemoJobSpec: TaskSpec;
+/**
+ * The reference solution to the demo job: a complete batch of valid assets plus a
+ * (self-reported, buyer-ignored) eval block, as canonical JSON. Deterministic.
+ * Exposed so the demo journey and tests share one source of the expected artifact.
+ */
+declare function solveGen404Demo(): string;
+/**
+ * The BUYER's recompute of the demo batch score in [0, 1] over the deliverable's
+ * DECLARED per-asset descriptors. Every delivered asset must pass the format and
+ * polygon-range checks (any single invalid asset scores 0, so a well-formed but junk
+ * extra cannot slip through), and the batch must contain at least the requested count
+ * (completeness); a short batch scores the filled fraction. Any self-reported `eval`
+ * score in the deliverable is ignored. Malformed or unparseable content scores 0 and
+ * never throws.
+ *
+ * NOTE: this gates the deliverable's declared `format`/`polygonCount` fields, not the
+ * asset bytes. For the deterministic canned demo that is sufficient because the buyer
+ * additionally knows the exact expected artifact (the eval-threshold review re-verifies
+ * the fetched deliverable hashes to the submitted contentHash). 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 (kit-docs debt).
+ */
+declare function score404genDemoDeliverable(content: string | Buffer): number;
+/**
+ * Build a 404gen (SN17) {@link ServiceAdapter}. Passes `assertServiceAdapterContract`
+ * with the default ports; supply real ports for production use. The USDC->TAO swap,
+ * pinning, and execute skeleton come from the shared Bittensor core.
+ */
+declare function create404genAdapter(config?: Gen404AdapterConfig): ServiceAdapter;
+
+/**
+ * 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
+ * `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 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
+ * real implementations (Jupiter for the swap, the SN51 GPU-rental dendrite,
+ * Pinata/Arweave for pinning).
+ *
+ * RELEASE JUDGMENT IS NOT HERE. This adapter only PRODUCES the deliverable (the job's
+ * output artifact). Whether the job completed with a matching artifact is decided by
+ * 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 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. A GPU-rental call is a paid subnet call, so its
+ * port reuses the shared `SubnetCall` shape under the local `RunGpuJob` name.
+ */
+
+/** Rent GPU compute for `budget` TAO and run `spec`'s job; resolve with the raw output artifact. */
+type RunGpuJob = SubnetCall;
+/** Configuration and injectable ports for {@link createLiumAdapter}. */
+interface LiumAdapterConfig {
+    /** Subnet identifier. Defaults to "sn51" (Lium GPU compute); forms the adapter id `bittensor:<subnet>`. */
+    subnet?: string;
+    /** Advertised capabilities for EscroBots discovery. Defaults to `["gpu-compute"]`. */
+    capabilities?: string[];
+    /** μUSDC the worker allocates to a single task before converting to TAO (internal budgeting). */
+    taskBudgetMicroUsdc?: number;
+    /** Swap port. Default: a fixed-rate reference stub. */
+    swap?: UsdcToTaoSwap;
+    /** GPU-job port. Default: runs the canned demo job; a deterministic placeholder otherwise. */
+    runJob?: RunGpuJob;
+    /** Pinning port. Default: a deterministic `ipfs://` placeholder URI. */
+    pin?: PinContent$3;
+    /** Health-check port. Default: resolves `true`. */
+    checkHealth?: () => Promise<boolean>;
+}
+declare const LIUM_ADAPTER_ID = "bittensor:sn51";
+declare const LIUM_CAPABILITIES: readonly ["gpu-compute"];
+/** Stable marker on the demo spec's metadata so the default job stub recognizes it. */
+declare const LIUM_DEMO_MARKER = "lium-sn51-demo-v1";
+/** The demo accept floor: hash-match is exact, so the buyer requires a full match. */
+declare const LIUM_DEMO_ACCEPT_FLOOR = 1;
+/**
+ * The scripted GPU job's deterministic output artifact: a hash chain over the fixed
+ * seed. Deterministic and cheap to recompute, so the buyer can verify it independently.
+ */
+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.
+ */
+declare const liumDemoJobSpec: TaskSpec;
+/**
+ * The reference solution to the demo job: the completed job report carrying the
+ * correct output artifact plus a (self-reported, buyer-ignored) artifactHash, as
+ * canonical JSON. Deterministic. Exposed so the demo journey and tests share one
+ * source of the expected artifact.
+ */
+declare function solveLiumDemo(): string;
+/**
+ * The BUYER's independent recompute of the demo acceptance predicate, returning 1
+ * 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.
+ */
+declare function scoreLiumDemoDeliverable(content: string | Buffer): number;
+/**
+ * Build a Lium (SN51) {@link ServiceAdapter}. Passes `assertServiceAdapterContract`
+ * with the default ports; supply real ports for production use. The USDC->TAO swap,
+ * pinning, and execute skeleton come from the shared Bittensor core; the GPU-rental
+ * port is wired in as the core's `callSubnet`.
+ */
+declare function createLiumAdapter(config?: LiumAdapterConfig): ServiceAdapter;
+
+/**
+ * Amount denominated in AKT (Akash's token). Branded so it cannot be assigned to or from a
+ * plain `number` by accident and (the point of the brand) so it can never appear in a
+ * `ServiceResult` or the escrow submit path: those types have no field of this type. AKT
+ * exists ONLY inside the Akash adapter layer.
+ */
+type Akt = number & {
+    readonly __brand: "AKT";
+};
+/** Construct an {@link Akt} amount from a plain number. Adapter-internal use only. */
+declare function akt(amount: number): Akt;
+/** Swap a microUSDC budget into AKT. Real workers route this through a DEX/CEX. */
+type UsdcToAktSwap = (microUsdc: number) => Promise<Akt>;
+/**
+ * Provision an Akash deployment/lease funded with `budget` AKT to run `spec`; resolve with
+ * the raw deliverable (the job's output artifact).
+ */
+type RunAkashDeployment = (spec: TaskSpec, budget: Akt) => Promise<string | Buffer>;
+/** Pin `content` and resolve with a content-addressed proof URI (ipfs://, ar://). */
+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).
+ */
+declare const AKASH_ADAPTER_ID = "akash";
+declare const AKASH_CAPABILITIES: readonly ["cloud-compute"];
+declare const REFERENCE_MICRO_USDC_PER_AKT = 3000000;
+/** Configuration and injectable ports for {@link createAkashAdapter}. */
+interface AkashAdapterConfig {
+    /** Advertised capabilities for EscroBots discovery. Defaults to `["cloud-compute"]`. */
+    capabilities?: string[];
+    /** μUSDC the worker allocates to a single task before converting to AKT (internal budgeting). */
+    taskBudgetMicroUsdc?: number;
+    /** Swap port. Default: a fixed-rate reference stub. */
+    swap?: UsdcToAktSwap;
+    /** Deployment port. Default: runs the canned demo job; a deterministic placeholder otherwise. */
+    runDeployment?: RunAkashDeployment;
+    /** Pinning port. Default: a deterministic `ipfs://` placeholder URI. */
+    pin?: PinContent$1;
+    /** Health-check port. Default: resolves `true`. */
+    checkHealth?: () => Promise<boolean>;
+}
+/** Stable marker on the demo spec's metadata so the default deployment stub recognizes it. */
+declare const AKASH_DEMO_MARKER = "akash-demo-v1";
+/** The demo accept floor: hash-match is exact, so the buyer requires a full match. */
+declare const AKASH_DEMO_ACCEPT_FLOOR = 1;
+/**
+ * The scripted batch job's deterministic output artifact: a hash chain over the fixed
+ * seed. Deterministic and cheap to recompute, so the buyer can verify it independently.
+ */
+declare function computeAkashDemoArtifact(): string;
+/**
+ * The canned Akash demo job. Deterministic; its specHash is pinned by a test because the
+ * buyer journey depends on hash stability.
+ */
+declare const akashDemoJobSpec: TaskSpec;
+/**
+ * The reference solution to the demo job: the completed job report carrying the correct
+ * output artifact plus a (self-reported, buyer-ignored) artifactHash, as canonical JSON.
+ * Deterministic. Exposed so the demo journey and tests share one source of the expected
+ * artifact.
+ */
+declare function solveAkashDemo(): string;
+/**
+ * The BUYER's independent recompute of the demo acceptance predicate, returning 1 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. Malformed or unparseable content scores 0 and
+ * never throws.
+ */
+declare function scoreAkashDemoDeliverable(content: string | Buffer): number;
+/**
+ * Build an Akash {@link ServiceAdapter}. Passes `assertServiceAdapterContract` with the
+ * default ports; supply real ports for production use. The execute skeleton: swap the USDC
+ * budget into AKT (internal, never surfaced), provision the deployment and collect the
+ * output, then hash and pin. The recorded `ServiceResult` is currency-free (no AKT field).
+ */
+declare function createAkashAdapter(config?: AkashAdapterConfig): ServiceAdapter;
+
+/**
+ * Amount denominated in RENDER (Render Network's Solana SPL token). Branded so it cannot
+ * be assigned to or from a plain `number` by accident and (the point of the brand) so it
+ * can never appear in a `ServiceResult` or the escrow submit path: those types have no
+ * field of this type. RENDER exists ONLY inside this adapter module.
+ */
+type Render = number & {
+    readonly __brand: "RENDER";
+};
+/** Construct a {@link Render} amount from a plain number. Adapter-internal use only. */
+declare function renderAmount(amount: number): Render;
+/** Swap a microUSDC budget into RENDER. Real workers route this through a Solana DEX (e.g. Jupiter). */
+type UsdcToRenderSwap = (microUsdc: number) => Promise<Render>;
+/** Submit `spec`'s render job funded with `budget` RENDER; resolve with the raw rendered artifact. */
+type RunRenderJob = (spec: TaskSpec, budget: Render) => Promise<string | Buffer>;
+/** Pin `content` and resolve with a content-addressed proof URI (ipfs://, ar://). */
+type PinContent = (content: string | Buffer) => Promise<string>;
+/** Configuration and injectable ports for {@link createRenderAdapter}. */
+interface RenderAdapterConfig {
+    /** Service identifier. Defaults to "render"; forms the adapter id. */
+    service?: string;
+    /** Advertised capabilities for EscroBots discovery. Defaults to {@link RENDER_CAPABILITIES}. */
+    capabilities?: string[];
+    /** microUSDC the worker allocates to a single task before converting to RENDER (internal budgeting). */
+    taskBudgetMicroUsdc?: number;
+    /** Swap port. Default: a fixed-rate reference stub (no live price feed). */
+    swap?: UsdcToRenderSwap;
+    /** Render-job port. Default: renders the canned demo scene; a deterministic placeholder otherwise. */
+    runJob?: RunRenderJob;
+    /** Pinning port. Default: a deterministic `ipfs://` placeholder URI. */
+    pin?: PinContent;
+    /** Health-check port. Default: resolves `true`. */
+    checkHealth?: () => Promise<boolean>;
+}
+declare const RENDER_ADAPTER_ID = "render";
+declare const RENDER_CAPABILITIES: readonly ["3d-rendering", "video-rendering", "gpu-inference"];
+declare const REFERENCE_MICRO_USDC_PER_RENDER = 2000000;
+/** Stable marker on the demo spec's metadata so the default job stub recognizes it. */
+declare const RENDER_DEMO_MARKER = "render-demo-v1";
+/** The demo accept floor: frame-match is exact, so the buyer requires a full match. */
+declare const RENDER_DEMO_ACCEPT_FLOOR = 1;
+/**
+ * Render the fixed demo scene into a grayscale raster and return its hex encoding.
+ * Deterministic and cheap to recompute, so the buyer verifies the frame independently.
+ */
+declare function computeRenderDemoArtifact(): string;
+/**
+ * The canned Render demo job. Deterministic; its specHash is pinned by a test because
+ * the buyer journey depends on hash stability.
+ */
+declare const renderDemoJobSpec: TaskSpec;
+/**
+ * The reference solution to the demo job: the completed job report carrying the correct
+ * rendered frame plus a (self-reported, buyer-ignored) frameHash, as canonical JSON.
+ * Deterministic. Exposed so the demo journey and tests share one source of the expected
+ * artifact.
+ */
+declare function solveRenderDemo(): string;
+/**
+ * The BUYER's independent recompute of the demo acceptance predicate, returning 1 when
+ * the deliverable satisfies all three criteria and 0 otherwise. It checks completion
+ * (status), frame presence, and a frame match by RE-RENDERING the scripted scene and
+ * comparing the substantive frame; it deliberately IGNORES any self-reported
+ * `frameHash`, so release can never be worker-controlled (consult C10). Malformed or
+ * unparseable content scores 0 and never throws.
+ */
+declare function scoreRenderDemoDeliverable(content: string | Buffer): number;
+/**
+ * Build a Render {@link ServiceAdapter}. Passes `assertServiceAdapterContract` with the
+ * default ports; supply real ports for production use. The execute skeleton: swap the
+ * USDC budget into RENDER (internal, same-chain, never surfaced), pay the render job in
+ * RENDER and collect the frame, then hash and pin. The recorded `ServiceResult` is
+ * currency-free (no RENDER field).
+ */
+declare function createRenderAdapter(config?: RenderAdapterConfig): ServiceAdapter;
+
+/** Stable adapter identity + EscroBots capability (locked by gensyn.test.ts). */
+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. */
+declare const GENSYN_REE_SCHEME = "gensyn-ree-v1";
+/** Marker on the demo spec's metadata so the default reproducible compute recognizes it. */
+declare const GENSYN_DEMO_MARKER = "gensyn-ree-demo-v1";
+/** The result of one reproducible execution: its transcript and final output. */
+interface ReeExecution {
+    /** Seed the walk started from. */
+    seed: number;
+    /** Number of steps walked. */
+    steps: number;
+    /** Ordered per-step states (the execution transcript). */
+    states: number[];
+    /** Final state (the deliverable's numeric result). */
+    result: number;
+}
+/** Run the reproducible compute for `spec`, deriving the transcript and result. */
+type ReproduceCompute = (spec: TaskSpec) => ReeExecution;
+/**
+ * The reference reproducible execution. Deterministic from `spec` (its seed/steps
+ * come from `spec.metadata`, defaulting to the demo parameters), so both worker and
+ * buyer derive the same transcript.
+ */
+declare const reproduceGensynCompute: ReproduceCompute;
+/**
+ * A Gensyn REE proof. Every field is a commitment the buyer re-derives:
+ * `commitment` binds the whole tuple, `outputHash` binds the delivered content,
+ * `specHash` binds the task asked, `transcriptHash` binds the reproducible run.
+ */
+interface ReeProof {
+    scheme: typeof GENSYN_REE_SCHEME;
+    /** SHA-256 hex of the canonical task spec. */
+    specHash: string;
+    /** SHA-256 hex of the delivered content. */
+    outputHash: string;
+    /** Number of reproducible execution steps (positive integer). */
+    steps: number;
+    /** SHA-256 hex of the canonical execution transcript. */
+    transcriptHash: string;
+    /** SHA-256 hex binding scheme, specHash, outputHash, steps, and transcriptHash. */
+    commitment: string;
+}
+/**
+ * Build the REE proof a worker attaches to its deliverable. Not a trust anchor on
+ * its own: `verifyReeProof` re-derives every field, so a proof only accepts when it
+ * genuinely binds the content, spec, and a reproducible transcript.
+ */
+declare function buildReeProof(spec: TaskSpec, exec: ReeExecution, content: string | Buffer): ReeProof;
+/** The verifier's verdict: a proof is either valid, or invalid/malformed with a reason. */
+interface ReeVerification {
+    valid: boolean;
+    /** Prefixed `malformed` (shape/structure) or `invalid` (a binding failed), or a pass note. */
+    reason: string;
+}
+/** Inputs the buyer verifies a proof against: the task asked and the content received. */
+interface ReeVerifyContext {
+    /** The task spec the buyer commissioned. */
+    spec: TaskSpec;
+    /** The deliverable content the buyer received (fetched from proofUri in production). */
+    content: string | Buffer;
+    /** The reproducible compute; defaults to the reference {@link reproduceGensynCompute}. */
+    reproduce?: ReproduceCompute;
+}
+/**
+ * The BUYER's verification of an REE proof (untrusted input from the worker). Returns
+ * `valid: true` only when the proof is well-formed AND every binding holds: the
+ * commitment is self-consistent, the committed output hash equals the delivered
+ * content, the spec hash equals the commissioned task, and the transcript hash
+ * matches the buyer's own reproduction of the execution. Never throws.
+ */
+declare function verifyReeProof(proof: unknown, ctx: ReeVerifyContext): ReeVerification;
+/** What the buyer assembles to decide acceptance: the received content and the worker's proof. */
+interface GensynDeliverableBundle {
+    /** The deliverable content the buyer received. */
+    content: string | Buffer;
+    /** The REE proof the worker attached (untrusted; verified before any release). */
+    proof: unknown;
+}
+/** A buyer auto-release decision. `release: true` means "call release_payment()". */
+interface AutoReleaseDecision {
+    release: boolean;
+    reason: string;
+}
+/**
+ * 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
+ * mechanism, and it lives entirely at the buyer layer.
+ */
+declare function gensynAutoRelease(bundle: GensynDeliverableBundle, ctx: {
+    spec: TaskSpec;
+    reproduce?: ReproduceCompute;
+}): AutoReleaseDecision;
+/** 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. */
+    pin?: (content: string | Buffer) => Promise<string>;
+    /** Health-check port. Default: resolves `true`. */
+    checkHealth?: () => Promise<boolean>;
+}
+/** The canned demo job the buyer template's journey hires a Gensyn worker for. */
+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
+ * `assertServiceAdapterContract` with the default ports; supply real ports (a real
+ * Gensyn job runner, a real pinner) for production.
+ */
+declare function createGensynAdapter(config?: GensynAdapterConfig): ServiceAdapter;
+
+/** Stable id/capabilities; locked against the EscroBots registry descriptor by a kit test at merge (consult C2). */
+declare const ZKML_ADAPTER_ID = "zkml";
+declare const ZKML_CAPABILITIES: readonly ["zk-verified-inference"];
+/** Marker on the demo spec's metadata so the default inference port recognizes it. */
+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)>`. */
+declare const ZKML_PROOF_URI_PREFIX = "zkml-proof:";
+/**
+ * A ZKML proof: its public inputs plus a `verificationTag` binding them. In the
+ * reference scheme the tag is recomputable (see {@link computeZkmlVerificationTag});
+ * in a production scheme it is a SNARK/STARK checked against a verifying key over the
+ * same public inputs.
+ */
+interface ZkmlProof {
+    /** Proving scheme identifier; the verifier only understands {@link ZKML_PROOF_SCHEME}. */
+    scheme: string;
+    /** Commitment to the model that produced the output (e.g. a weights hash). */
+    modelCommitment: string;
+    /** Commitment to the input the model was run on. */
+    inputCommitment: string;
+    /** SHA-256 hex of the delivered output; binds the proof to a specific deliverable. */
+    outputHash: string;
+    /** Binding tag over the public inputs (reference: recomputable; production: a SNARK). */
+    verificationTag: string;
+}
+/** Build a well-formed reference proof binding the given public inputs. */
+declare function buildZkmlProof(args: {
+    scheme?: string;
+    modelCommitment: string;
+    inputCommitment: string;
+    outputHash: string;
+}): ZkmlProof;
+/** Encode a proof as a self-contained inline proof URI. */
+declare function encodeZkmlProofUri(proof: ZkmlProof): 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).
+ */
+declare function decodeZkmlProofUri(uri: string): ZkmlProof | null;
+/**
+ * The outcome of verifying a proof. `malformed` = the verifier cannot understand the
+ * proof (missing/wrong-typed fields, unsupported scheme, undecodable URI); `invalid`
+ * = a well-formed proof that fails verification (tag does not recompute, or attests a
+ * different output/model than expected).
+ */
+type ZkmlVerification = {
+    valid: true;
+} | {
+    valid: false;
+    category: "invalid" | "malformed";
+    reason: string;
+};
+/** What the Buyer expects the proof to attest to. */
+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;
+}
+/**
+ * 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
+ * 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;
+/** The submitted deliverable as the Buyer's review reads it off the escrow read model. */
+interface ZkmlDeliverable {
+    /**
+     * SHA-256 hex the WORKER submitted on-chain (mirrored to the read model). It is the
+     * worker's CLAIM about the artifact; {@link zkmlProofAutoRelease} re-hashes the real
+     * artifact (via its `fetchContent` port) and never trusts this value on its own.
+     */
+    contentHash: string;
+    /** URI where the ZK proof is (inline `zkml-proof:` or a pinned `ipfs://`), or null. */
+    proofUri: string | null;
+}
+/** A release decision: release, and if not, whether to contest via dispute. */
+interface ZkmlReviewResult {
+    accept: boolean;
+    dispute: boolean;
+    reason: string;
+}
+/**
+ * A named release policy the Buyer's review wires in. Field-for-field this mirrors the
+ * buyer template's `ReviewPolicy`
+ * (packages/create-escro-bot/templates/buyer/src/review.ts). The SDK cannot import the
+ * scaffolding templates, and promoting the shared review shapes into `@escro/shared` is
+ * a cross-package change owned by `main`, not this lane -- tracked as a merge-time
+ * follow-up (LANE-NOTES).
+ */
+interface ZkmlReviewPolicy {
+    name: string;
+    evaluate(deliverable: ZkmlDeliverable): Promise<ZkmlReviewResult>;
+}
+/** 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.
+     */
+    fetchContent: (deliverable: ZkmlDeliverable) => Promise<string | Buffer> | string | Buffer;
+    /** When set, the proof's modelCommitment must equal it (pin to a specific model). */
+    modelCommitment?: 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
+ * 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.
+ */
+declare function zkmlProofAutoRelease(opts: ZkmlProofAutoReleaseOptions): ZkmlReviewPolicy;
+/** What an inference run yields: the output plus the commitments the proof binds. */
+interface ZkmlInferenceOutput {
+    /** The deliverable content. */
+    content: string;
+    /** Commitment to the model that produced `content`. */
+    modelCommitment: string;
+    /** Commitment to the input the model was run on. */
+    inputCommitment: string;
+}
+/** Configuration and injectable ports for {@link createZkmlAdapter}. */
+interface ZkmlAdapterConfig {
+    /** Adapter id. Defaults to `"zkml"`. */
+    id?: string;
+    /** Advertised capabilities for EscroBots discovery. Defaults to `["zk-verified-inference"]`. */
+    capabilities?: string[];
+    /** Inference port. Default: solves the canned demo job; a deterministic placeholder otherwise. */
+    runInference?: (spec: TaskSpec) => Promise<ZkmlInferenceOutput> | ZkmlInferenceOutput;
+    /** Proving port. Default: builds a reference proof binding the output to its commitments. */
+    prove?: (args: {
+        spec: TaskSpec;
+        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;
+    /** 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.
+ * Acceptance is machine-checkable by the buyer via {@link zkmlProofAutoRelease}.
+ */
+declare const zkmlDemoJobSpec: TaskSpec;
+/**
+ * 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.
+ */
+declare function createZkmlAdapter(config?: ZkmlAdapterConfig): ServiceAdapter;
 
-export { type CreateEscrowParams, type CreateEscrowResult, Escro, EscroError, type EscroOptions, EscrowNotFoundError, EscrowStateError, EscrowTimeoutError, type ListOptions, type PaginatedResult, type PollOptions, type RaiseDisputeParams, type SubmitDeliverableParams, UnauthorizedError };
+export { AKASH_ADAPTER_ID, AKASH_CAPABILITIES, AKASH_DEMO_ACCEPT_FLOOR, AKASH_DEMO_MARKER, type AcceptanceCriterion, AdapterContractError, type AdapterContractOptions, type AkashAdapterConfig, type Akt, ApiClient, type AutoReleaseDecision, type BotDescriptor, type BotRole, type CreateEscrowParams, type CreateEscrowResult, type DeliverableFormat, type DeliverableType, ENABLED_RAILS, Escro, EscroConfirmError, EscroError, type EscroOptions, EscroRailNotEnabledError, type EscrowAccount, type EscrowErrorCode, 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, type Gen404AdapterConfig, type GensynAdapterConfig, type GensynDeliverableBundle, type GradientsAdapterConfig, LIUM_ADAPTER_ID, LIUM_CAPABILITIES, LIUM_DEMO_ACCEPT_FLOOR, LIUM_DEMO_MARKER, type ListBotsParams, type ListOptions, type LiumAdapterConfig, type Network, type PaginatedResult, type PayParams, type PaymentResult, type PaymentRouter, type PinContent$3 as PinContent, type PollOptions, type ProtocolStats, 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, type Rail, type RaiseDisputeParams, type ReeExecution, type ReeProof, type ReeVerification, type ReeVerifyContext, type Render, type RenderAdapterConfig, type ReproduceCompute, ReputationUnavailableError, type RidgesAdapterConfig, type RunAkashDeployment, type RunCodingAgent, type RunGpuJob, type RunRenderJob, type ServedWalletReputation, type ServiceAdapter, type ServiceResult, type SubmitDeliverableParams, type SubnetCall, type Tao, type TaskSpec, type TaskType, type TxShape, UnauthorizedError, type UnsignedBotDescriptor, type UsdcToAktSwap, type UsdcToRenderSwap, type UsdcToTaoSwap, type WorkerCandidate, ZKML_ADAPTER_ID, ZKML_CAPABILITIES, ZKML_DEMO_MARKER, ZKML_PROOF_SCHEME, ZKML_PROOF_URI_PREFIX, type ZkmlAdapterConfig, type ZkmlDeliverable, type ZkmlExpectation, type ZkmlInferenceOutput, type ZkmlProof, type ZkmlProofAutoReleaseOptions, type ZkmlReviewPolicy, type ZkmlReviewResult, type ZkmlVerification, 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 };