@escro/sdk 0.1.4 → 0.3.0

package/dist/index.js

@@ -5,15 +5,139 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // src/client.ts
 import { Connection as Connection2, PublicKey as PublicKey2 } from "@solana/web3.js";
 
-// src/api.ts
+// ../shared/dist/index.js
+import { createHash } from "crypto";
 import nacl from "tweetnacl";
 import bs58 from "bs58";
+import nacl2 from "tweetnacl";
+import bs582 from "bs58";
+var EscrowState = /* @__PURE__ */ ((EscrowState2) => {
+  EscrowState2["CREATED"] = "CREATED";
+  EscrowState2["FUNDED"] = "FUNDED";
+  EscrowState2["IN_PROGRESS"] = "IN_PROGRESS";
+  EscrowState2["SUBMITTED"] = "SUBMITTED";
+  EscrowState2["COMPLETED"] = "COMPLETED";
+  EscrowState2["CANCELLED"] = "CANCELLED";
+  EscrowState2["DISPUTED"] = "DISPUTED";
+  EscrowState2["REFUNDED"] = "REFUNDED";
+  return EscrowState2;
+})(EscrowState || {});
+function canonicalize(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) {
+    return "[" + value.map((v) => v === void 0 ? "null" : canonicalize(v)).join(",") + "]";
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort();
+    return "{" + keys.map((k) => JSON.stringify(k) + ":" + canonicalize(obj[k])).join(",") + "}";
+  }
+  return JSON.stringify(value);
+}
+var PROGRAM_ID_DEVNET = "EjLpJ3obUYk1f2KDensU7UdGBZTxSdxufm7CSnMA3H5C";
+var PROGRAM_ID_MAINNET = "4CwLNRF4mFXutiBGjtMHQBxh8whW8T8EyvJXdRhY1rvr";
+var ONCHAIN_REFUND_GRACE_SECONDS = 900;
+var ONCHAIN_TIMEOUT_SECONDS = 86400;
+var CLOCK_SKEW_SECONDS = 60;
+var SCANNER_REFUND_GRACE_SECONDS = ONCHAIN_REFUND_GRACE_SECONDS + CLOCK_SKEW_SECONDS;
+var SCANNER_TIMEOUT_SECONDS = ONCHAIN_TIMEOUT_SECONDS + CLOCK_SKEW_SECONDS;
+var MAINNET_PROGRAM_ID_PLACEHOLDER = "11111111111111111111111111111111";
+function getProgramId(cluster) {
+  return cluster === "mainnet" ? PROGRAM_ID_MAINNET : PROGRAM_ID_DEVNET;
+}
+function isPlaceholderProgramId(id) {
+  return id === MAINNET_PROGRAM_ID_PLACEHOLDER;
+}
+function assertProgramIdNotPlaceholder(id, cluster) {
+  if (cluster === "mainnet" && isPlaceholderProgramId(id)) {
+    throw new Error(
+      `PROGRAM_ID_MAINNET is still the System Program placeholder (${MAINNET_PROGRAM_ID_PLACEHOLDER}). Run scripts/deploy-mainnet.sh to bootstrap mainnet, then update the placeholder in packages/shared/src/config.ts, packages/program/programs/escro/src/lib.rs, packages/program/Anchor.toml, and infra/bin/escro.ts.`
+    );
+  }
+}
+function hashBody(rawBody) {
+  return createHash("sha256").update(rawBody, "utf8").digest("hex");
+}
+function buildSignedMessage(timestamp, method, fullPath, bodyHash) {
+  return `escro:${String(timestamp)}:${method}:${fullPath}:${bodyHash}`;
+}
+function signRequestRaw(secretKey, walletAddress, method, fullPath, rawBody) {
+  const timestamp = Date.now();
+  const bodyHash = hashBody(rawBody);
+  const message = buildSignedMessage(timestamp, method, fullPath, bodyHash);
+  const sigBytes = nacl.sign.detached(new TextEncoder().encode(message), secretKey);
+  return {
+    "x-wallet-address": walletAddress,
+    "x-signature": bs58.encode(sigBytes),
+    "x-timestamp": String(timestamp),
+    "x-content-sha256": bodyHash
+  };
+}
+function signRequest(wallet, method, fullPath, rawBody) {
+  return signRequestRaw(wallet.secretKey, wallet.publicKey.toBase58(), method, fullPath, rawBody);
+}
+function canonicalBotDescriptorMessage(descriptor) {
+  return canonicalize({
+    wallet: descriptor.wallet,
+    role: descriptor.role,
+    capabilities: descriptor.capabilities,
+    serviceRef: descriptor.serviceRef,
+    pricingHint: descriptor.pricingHint,
+    endpoint: descriptor.endpoint,
+    signedAt: descriptor.signedAt
+  });
+}
+function verifyBotDescriptorSignature(descriptor) {
+  try {
+    const { signature, ...unsigned } = descriptor;
+    const message = new TextEncoder().encode(canonicalBotDescriptorMessage(unsigned));
+    const signatureBytes = bs582.decode(signature);
+    if (signatureBytes.length !== 64) return false;
+    const pubkeyBytes = bs582.decode(descriptor.wallet);
+    if (pubkeyBytes.length !== 32) return false;
+    return nacl2.sign.detached.verify(message, signatureBytes, pubkeyBytes);
+  } catch {
+    return false;
+  }
+}
+function spec(discriminator, escrowAccountIndex, cause) {
+  return {
+    discriminator: Uint8Array.from(discriminator),
+    escrowAccountIndex,
+    signerAccountIndex: 0,
+    cause
+  };
+}
+var ESCROW_INSTRUCTIONS = {
+  create_escrow: spec([253, 215, 165, 116, 36, 108, 68, 80], 4, null),
+  claim_task: spec([49, 222, 219, 238, 155, 68, 221, 136], 1, null),
+  submit_deliverable: spec([38, 137, 64, 44, 237, 11, 125, 101], 1, null),
+  raise_dispute: spec([41, 243, 1, 51, 150, 95, 246, 73], 1, null),
+  cancel_escrow: spec([156, 203, 54, 179, 38, 72, 33, 21], 3, "CANCELLED"),
+  release_payment: spec([24, 34, 191, 86, 145, 160, 183, 233], 3, "EXPLICIT_RELEASE"),
+  timeout_release: spec([98, 176, 26, 12, 83, 105, 154, 68], 3, "TIMEOUT_RELEASE"),
+  refund_buyer: spec([199, 139, 203, 146, 192, 150, 53, 218], 3, "DEADLINE_REFUND"),
+  arbitration_release: spec([118, 157, 141, 26, 104, 117, 94, 229], 4, "ARBITRATION_RELEASE"),
+  arbitration_refund: spec([255, 194, 84, 248, 185, 249, 120, 122], 4, "ARBITRATION_REFUND")
+};
+
+// src/payments.ts
+var RAILS = ["escrow", "x402"];
+var ENABLED_RAILS = ["escrow"];
+var RAILS_DOCS_URL = "https://docs.escro.ai/rails";
+var EscrowPaymentRouter = class {
+  selectRail(tx) {
+    const preferred = tx.mode === "sync" ? "x402" : "escrow";
+    return ENABLED_RAILS.includes(preferred) ? preferred : "escrow";
+  }
+};
 
 // src/errors.ts
 var EscroError = class extends Error {
-  constructor(message, code = "ESCRO_ERROR") {
+  constructor(message, code = "ESCRO_ERROR", retryAfterMs2) {
     super(message);
-    this.code = code;
+    __publicField(this, "code", code);
+    __publicField(this, "retryAfterMs", retryAfterMs2);
     this.name = "EscroError";
   }
 };
@@ -23,6 +147,15 @@ var EscrowNotFoundError = class extends EscroError {
     this.name = "EscrowNotFoundError";
   }
 };
+var ReputationUnavailableError = class extends EscroError {
+  constructor() {
+    super(
+      "Reputation endpoint is unavailable (HTTP 404): this deployment has no reputation source mounted.",
+      "REPUTATION_UNAVAILABLE"
+    );
+    this.name = "ReputationUnavailableError";
+  }
+};
 var EscrowStateError = class extends EscroError {
   constructor(message) {
     super(message, "ESCROW_INVALID_STATE");
@@ -35,40 +168,58 @@ var EscrowTimeoutError = class extends EscroError {
     this.name = "EscrowTimeoutError";
   }
 };
+var EscroConfirmError = class extends EscroError {
+  constructor(address, signature, code, message) {
+    super(`Confirm failed for escrow ${address} (signature ${signature}): ${message}`, code);
+    __publicField(this, "address", address);
+    __publicField(this, "signature", signature);
+    this.name = "EscroConfirmError";
+  }
+};
 var UnauthorizedError = class extends EscroError {
   constructor(message = "Unauthorized") {
     super(message, "UNAUTHORIZED");
     this.name = "UnauthorizedError";
   }
 };
+var EscroRailNotEnabledError = class extends EscroError {
+  constructor(rail) {
+    super(
+      `Payment rail "${rail}" is not enabled. Only the escrow rail is available today; the x402 rail is reserved and lands in Phase 9. See ${RAILS_DOCS_URL}`,
+      "ESCRO_RAIL_NOT_ENABLED"
+    );
+    __publicField(this, "rail", rail);
+    this.name = "EscroRailNotEnabledError";
+  }
+};
 
 // src/api.ts
-function authHeaders(wallet, method, path) {
-  const timestamp = Date.now();
-  const message = `escro:${timestamp}:${method}:${path}`;
-  const msgBytes = new TextEncoder().encode(message);
-  const sigBytes = nacl.sign.detached(msgBytes, wallet.secretKey);
-  return {
-    "x-wallet-address": wallet.publicKey.toBase58(),
-    "x-signature": bs58.encode(sigBytes),
-    "x-timestamp": String(timestamp)
-  };
+function authHeaders(wallet, method, path, rawBody = "") {
+  return signRequest(wallet, method, path, rawBody);
 }
 function deserialize(raw) {
   return { ...raw, amount: BigInt(raw.amount) };
 }
 async function handleError(res, address) {
   const body = await res.json().catch(() => ({}));
-  const msg = body.error ?? `HTTP ${res.status}`;
+  const msg = body.error ?? `HTTP ${String(res.status)}`;
   if (res.status === 404) throw new EscrowNotFoundError(address ?? msg);
   if (res.status === 409) throw new EscrowStateError(msg);
   if (res.status === 401 || res.status === 403) throw new UnauthorizedError(msg);
-  throw new EscroError(msg, body.code ?? "UNKNOWN");
+  throw new EscroError(msg, body.code ?? "UNKNOWN", retryAfterMs(res.headers.get("retry-after")));
+}
+function retryAfterMs(header) {
+  return header !== null && /^\d+$/.test(header.trim()) ? Number(header.trim()) * 1e3 : void 0;
 }
 var ApiClient = class {
   constructor(baseUrl, wallet) {
-    this.baseUrl = baseUrl;
-    this.wallet = wallet;
+    __publicField(this, "baseUrl", baseUrl);
+    __publicField(this, "wallet", wallet);
+    const url = new URL(baseUrl);
+    const isLocalhost = url.hostname === "localhost" || url.hostname === "127.0.0.1";
+    if (url.protocol !== "https:" && !isLocalhost) {
+      throw new Error("apiUrl must use HTTPS in production");
+    }
   }
   url(path) {
     return `${this.baseUrl}${path}`;
@@ -80,10 +231,11 @@ var ApiClient = class {
     if (!res.ok) await handleError(res, address);
     return deserialize(await res.json());
   }
-  /** GET /v1/escrows?assignedTo=...&state=... */
+  /** GET /v1/escrows?assignedTo=...&maker=...&state=... */
   async listEscrows(params) {
     const qs = new URLSearchParams();
     if (params.assignedTo) qs.set("assignedTo", params.assignedTo);
+    if (params.maker) qs.set("maker", params.maker);
     if (params.state) qs.set("state", params.state);
     if (params.limit != null) qs.set("limit", String(params.limit));
     if (params.offset != null) qs.set("offset", String(params.offset));
@@ -98,21 +250,77 @@ var ApiClient = class {
       offset: body.offset
     };
   }
+  /**
+   * 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.
+   */
+  async listBots(params) {
+    const qs = new URLSearchParams();
+    if (params.capability != null) qs.set("capability", params.capability);
+    if (params.role != null) qs.set("role", params.role);
+    if (params.limit != null) qs.set("limit", String(params.limit));
+    if (params.offset != null) qs.set("offset", String(params.offset));
+    const path = `/v1/bots?${qs.toString()}`;
+    const res = await fetch(this.url(path));
+    if (!res.ok) await handleError(res);
+    const body = await res.json();
+    return { items: body.items, total: body.total, limit: body.limit, offset: body.offset };
+  }
+  /**
+   * 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.
+   */
+  async listReputations() {
+    const res = await fetch(this.url("/rep"));
+    if (!res.ok) {
+      if (res.status === 404) throw new ReputationUnavailableError();
+      await handleError(res);
+    }
+    const body = await res.json();
+    return body.wallets;
+  }
+  /**
+   * 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.
+   */
+  async getReputation(wallet) {
+    const res = await fetch(this.url(`/rep/${encodeURIComponent(wallet)}`));
+    if (!res.ok) {
+      if (res.status === 404) throw new ReputationUnavailableError();
+      await handleError(res);
+    }
+    return await res.json();
+  }
   /**
    * POST /v1/escrows — create escrow, returns unsigned tx + ids.
    * Requires auth.
    */
   async createEscrow(params) {
     const path = "/v1/escrows";
+    const bodyObj = {
+      taskSpec: params.taskSpec,
+      amountUsdc: params.amountUsdc,
+      deadlineUnix: params.deadlineUnix,
+      assignedWorker: params.assignedWorker
+    };
+    const rawBody = JSON.stringify(bodyObj);
     const res = await fetch(this.url(path), {
       method: "POST",
-      headers: { ...authHeaders(this.wallet, "POST", path), "content-type": "application/json" },
-      body: JSON.stringify({
-        taskSpec: params.taskSpec,
-        amountUsdc: params.amountUsdc,
-        deadlineSeconds: params.deadlineSeconds,
-        assignedWorker: params.assignedWorker
-      })
+      headers: {
+        ...authHeaders(this.wallet, "POST", path, rawBody),
+        "content-type": "application/json"
+      },
+      body: rawBody
     });
     if (!res.ok) await handleError(res);
     return res.json();
@@ -136,13 +344,17 @@ var ApiClient = class {
    */
   async submitDeliverable(address, params) {
     const path = `/v1/escrows/${address}/submit`;
+    const rawBody = JSON.stringify({
+      contentHash: params.contentHash,
+      proofUri: params.proofUri
+    });
     const res = await fetch(this.url(path), {
       method: "POST",
-      headers: { ...authHeaders(this.wallet, "POST", path), "content-type": "application/json" },
-      body: JSON.stringify({
-        contentHash: params.contentHash,
-        proofUri: params.proofUri
-      })
+      headers: {
+        ...authHeaders(this.wallet, "POST", path, rawBody),
+        "content-type": "application/json"
+      },
+      body: rawBody
     });
     if (!res.ok) await handleError(res, address);
     return res.json();
@@ -178,14 +390,58 @@ var ApiClient = class {
    */
   async raiseDispute(address, params) {
     const path = `/v1/escrows/${address}/dispute`;
+    const rawBody = JSON.stringify({ reason: params.reason });
     const res = await fetch(this.url(path), {
       method: "POST",
-      headers: { ...authHeaders(this.wallet, "POST", path), "content-type": "application/json" },
-      body: JSON.stringify({ reason: params.reason, evidence: params.evidence })
+      headers: {
+        ...authHeaders(this.wallet, "POST", path, rawBody),
+        "content-type": "application/json"
+      },
+      body: rawBody
     });
     if (!res.ok) await handleError(res, address);
     return res.json();
   }
+  /**
+   * 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.
+   */
+  async confirm(address, signature, evidence) {
+    const path = `/v1/escrows/${address}/confirm`;
+    const rawBody = JSON.stringify({ signature, evidence });
+    const res = await fetch(this.url(path), {
+      method: "POST",
+      headers: {
+        ...authHeaders(this.wallet, "POST", path, rawBody),
+        "content-type": "application/json"
+      },
+      body: rawBody
+    });
+    if (!res.ok) {
+      const body2 = await res.json().catch(() => ({}));
+      throw new EscroError(
+        body2.error ?? `HTTP ${String(res.status)}`,
+        body2.code ?? `HTTP_${String(res.status)}`,
+        retryAfterMs(res.headers.get("retry-after"))
+      );
+    }
+    const body = await res.json();
+    return deserialize(body.escrow);
+  }
+  /**
+   * GET /v1/stats — public protocol-wide stats.
+   * No auth required. Upstream typing in {@link Escro.getStats} narrows the
+   * return shape.
+   */
+  async getStats() {
+    const path = "/v1/stats";
+    const res = await fetch(this.url(path));
+    if (!res.ok) await handleError(res);
+    return res.json();
+  }
 };
 
 // src/poll.ts
@@ -202,7 +458,7 @@ function sleep(ms) {
 }
 async function pollUntil(address, fetcher, predicate, timeoutMs = MS_24_H) {
   const deadline = Date.now() + timeoutMs;
-  while (true) {
+  for (; ; ) {
     const result = await fetcher();
     if (predicate(result)) return result;
     const elapsed = Date.now() - (deadline - timeoutMs);
@@ -219,8 +475,9 @@ async function pollUntil(address, fetcher, predicate, timeoutMs = MS_24_H) {
 }
 
 // src/solana.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import {
+  ComputeBudgetProgram,
   PublicKey,
   Transaction,
   TransactionInstruction
@@ -229,41 +486,111 @@ import {
   TOKEN_PROGRAM_ID,
   ASSOCIATED_TOKEN_PROGRAM_ID,
   getAssociatedTokenAddressSync,
-  createAssociatedTokenAccountInstruction
+  createAssociatedTokenAccountIdempotentInstruction
 } from "@solana/spl-token";
 function disc(name) {
-  return Buffer.from(
-    createHash("sha256").update(`global:${name}`).digest()
-  ).subarray(0, 8);
+  return Buffer.from(createHash2("sha256").update(`global:${name}`).digest()).subarray(0, 8);
 }
 var DISC_RELEASE_PAYMENT = disc("release_payment");
-var PROGRAM_ID = new PublicKey("EjLpJ3obUYk1f2KDensU7UdGBZTxSdxufm7CSnMA3H5C");
-async function fetchPlatformConfig(connection) {
-  const [pda] = PublicKey.findProgramAddressSync([Buffer.from("config")], PROGRAM_ID);
+function resolveProgramId(cluster) {
+  const id = getProgramId(cluster);
+  assertProgramIdNotPlaceholder(id, cluster);
+  return new PublicKey(id);
+}
+function allowedProgramIds(programId) {
+  return /* @__PURE__ */ new Set([
+    programId.toBase58(),
+    TOKEN_PROGRAM_ID.toBase58(),
+    ASSOCIATED_TOKEN_PROGRAM_ID.toBase58(),
+    ComputeBudgetProgram.programId.toBase58()
+  ]);
+}
+var MAX_INSTRUCTIONS = 6;
+var FORBIDDEN_TOKEN_IX_TAGS = /* @__PURE__ */ new Set([
+  3,
+  // Transfer
+  4,
+  // Approve
+  6,
+  // SetAuthority
+  7,
+  // MintTo
+  8,
+  // Burn
+  9,
+  // CloseAccount
+  12,
+  // TransferChecked
+  13,
+  // ApproveChecked
+  14,
+  // MintToChecked
+  15
+  // BurnChecked
+]);
+var EXPECTED_PLATFORM_CONFIG_VERSION = 1;
+var VERSION_OFFSET = 8;
+var MINT_OFFSET = 43;
+var TREASURY_OFFSET = 75;
+async function fetchPlatformConfig(connection, cluster) {
+  const programId = resolveProgramId(cluster);
+  const [pda] = PublicKey.findProgramAddressSync([Buffer.from("config")], programId);
   const info = await connection.getAccountInfo(pda);
   if (!info) throw new Error("PlatformConfig account not found on-chain");
+  const version = info.data[VERSION_OFFSET];
+  if (version !== EXPECTED_PLATFORM_CONFIG_VERSION) {
+    throw new Error(
+      `PlatformConfig version mismatch: expected ${String(EXPECTED_PLATFORM_CONFIG_VERSION)}, got ${String(version)}`
+    );
+  }
   return {
-    mint: new PublicKey(info.data.slice(42, 74)),
-    treasury: new PublicKey(info.data.slice(74, 106))
+    mint: new PublicKey(info.data.subarray(MINT_OFFSET, MINT_OFFSET + 32)),
+    treasury: new PublicKey(info.data.subarray(TREASURY_OFFSET, TREASURY_OFFSET + 32))
   };
 }
-async function signAndSend(base64Tx, wallet, connection) {
+function validateTransaction(tx, cluster) {
+  const programId = resolveProgramId(cluster);
+  const allowed = allowedProgramIds(programId);
+  const tokenProgram = TOKEN_PROGRAM_ID.toBase58();
+  for (const ix of tx.instructions) {
+    const id = ix.programId.toBase58();
+    if (!allowed.has(id)) {
+      throw new Error(
+        `Unexpected program in transaction: ${id}. Allowed: ${[...allowed].join(", ")}`
+      );
+    }
+    if (id === tokenProgram) {
+      const tag = ix.data.length > 0 ? ix.data[0] : void 0;
+      if (tag !== void 0 && FORBIDDEN_TOKEN_IX_TAGS.has(tag)) {
+        throw new Error(
+          `Refusing to sign a fund-moving SPL Token instruction (tag ${String(tag)}) in a server-built transaction. Escro never requires the wallet to directly sign a token transfer/approve/burn/close; all token movement is a CPI inside the escro program.`
+        );
+      }
+    }
+  }
+  if (tx.instructions.length > MAX_INSTRUCTIONS) {
+    throw new Error(
+      `Too many instructions (${String(tx.instructions.length)}). Max allowed: ${String(MAX_INSTRUCTIONS)}`
+    );
+  }
+}
+async function signAndSend(base64Tx, wallet, connection, cluster) {
   const buf = Buffer.from(base64Tx, "base64");
   const tx = Transaction.from(buf);
+  validateTransaction(tx, cluster);
   tx.partialSign(wallet);
   const raw = tx.serialize();
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
   const signature = await connection.sendRawTransaction(raw, {
     skipPreflight: false
   });
-  await connection.confirmTransaction(signature, "confirmed");
+  await connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, "confirmed");
   return signature;
 }
 async function buildReleasePaymentTx(params) {
-  const { buyer, escrowPda, worker, mint, treasury, connection } = params;
-  const [platformConfig] = PublicKey.findProgramAddressSync(
-    [Buffer.from("config")],
-    PROGRAM_ID
-  );
+  const { buyer, escrowPda, worker, mint, treasury, connection, cluster } = params;
+  const programId = resolveProgramId(cluster);
+  const [platformConfig] = PublicKey.findProgramAddressSync([Buffer.from("config")], programId);
   const vault = getAssociatedTokenAddressSync(
     mint,
     escrowPda,
@@ -281,16 +608,12 @@ async function buildReleasePaymentTx(params) {
   const treasuryAta = getAssociatedTokenAddressSync(
     mint,
     treasury,
-    false,
+    true,
     TOKEN_PROGRAM_ID,
     ASSOCIATED_TOKEN_PROGRAM_ID
   );
-  const [workerAtaInfo, treasuryAtaInfo] = await connection.getMultipleAccountsInfo([
-    workerAta,
-    treasuryAta
-  ]);
   const ix = new TransactionInstruction({
-    programId: PROGRAM_ID,
+    programId,
     keys: [
       { pubkey: buyer, isSigner: true, isWritable: true },
       { pubkey: platformConfig, isSigner: false, isWritable: false },
@@ -310,45 +633,67 @@ async function buildReleasePaymentTx(params) {
   const tx = new Transaction();
   tx.recentBlockhash = blockhash;
   tx.feePayer = buyer;
-  if (!workerAtaInfo) {
-    tx.add(
-      createAssociatedTokenAccountInstruction(buyer, workerAta, worker, mint)
-    );
-  }
-  if (!treasuryAtaInfo) {
-    tx.add(
-      createAssociatedTokenAccountInstruction(buyer, treasuryAta, treasury, mint)
-    );
-  }
+  tx.add(createAssociatedTokenAccountIdempotentInstruction(buyer, workerAta, worker, mint));
+  tx.add(createAssociatedTokenAccountIdempotentInstruction(buyer, treasuryAta, treasury, mint));
   tx.add(ix);
   return tx.serialize({ requireAllSignatures: false }).toString("base64");
 }
 
 // src/client.ts
+var CONFIRM_WINDOW_MS = 3e4;
+var CONFIRM_FIRST_DELAY_MS = 500;
+var CONFIRM_MAX_DELAY_MS = 4e3;
+var RETRYABLE_CONFIRM_CODES = [
+  "TX_NOT_FOUND",
+  "RPC_UNAVAILABLE",
+  "HTTP_502",
+  "HTTP_503",
+  "HTTP_504",
+  "RATE_LIMITED",
+  "HTTP_429"
+];
+function isRetryableConfirmCode(code) {
+  return RETRYABLE_CONFIRM_CODES.includes(code);
+}
+function isUrl(value) {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var Escro = class {
   constructor(options) {
     __publicField(this, "connection");
     __publicField(this, "api");
     __publicField(this, "options");
+    __publicField(this, "cluster");
+    __publicField(this, "router", new EscrowPaymentRouter());
     this.options = options;
+    this.cluster = options.cluster;
     this.connection = new Connection2(options.rpcUrl, "confirmed");
     this.api = new ApiClient(options.apiUrl, options.wallet);
   }
   // ── Buyer Bot ────────────────────────────────────────────────────────────────
   /**
    * 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.
    */
   async createEscrow(params) {
     const { escrowId, escrowPda, unsignedTx } = await this.api.createEscrow(params);
-    const signature = await signAndSend(unsignedTx, this.options.wallet, this.connection);
+    const signature = await this.send(unsignedTx);
+    await this.confirm(escrowPda, signature);
     return { escrowId, escrowPda, signature };
   }
   /**
    * 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.
    */
@@ -357,59 +702,96 @@ var Escro = class {
     if (!escrow.taker) {
       throw new EscrowNotFoundError(`Escrow ${address} has no assigned worker`);
     }
-    const { treasury, mint } = await fetchPlatformConfig(this.connection);
-    await this.api.releasePaymentDb(address);
+    const { treasury, mint } = await fetchPlatformConfig(this.connection, this.cluster);
     const unsignedTx = await buildReleasePaymentTx({
       buyer: this.options.wallet.publicKey,
       escrowPda: new PublicKey2(address),
       worker: new PublicKey2(escrow.taker),
       mint,
       treasury,
-      connection: this.connection
+      connection: this.connection,
+      cluster: this.cluster
     });
-    return signAndSend(unsignedTx, this.options.wallet, this.connection);
+    const signature = await signAndSend(
+      unsignedTx,
+      this.options.wallet,
+      this.connection,
+      this.cluster
+    );
+    try {
+      await this.api.releasePaymentDb(address);
+    } catch {
+    }
+    return signature;
   }
   /**
    * 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.
    */
   async raiseDispute(address, params) {
-    const { unsignedTx } = await this.api.raiseDispute(address, params);
-    return signAndSend(unsignedTx, this.options.wallet, this.connection);
+    if (params.evidence !== void 0 && !isUrl(params.evidence)) {
+      throw new EscroError(`evidence must be a URL: ${params.evidence}`, "VALIDATION_ERROR");
+    }
+    const { unsignedTx } = await this.api.raiseDispute(address, { reason: params.reason });
+    const signature = await this.send(unsignedTx);
+    await this.confirm(address, signature, {
+      ...params.evidence !== void 0 && { evidence: params.evidence }
+    });
+    return signature;
   }
   /**
    * 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.
    */
   async cancelEscrow(address) {
     const { unsignedTx } = await this.api.cancelEscrow(address);
-    return signAndSend(unsignedTx, this.options.wallet, this.connection);
+    return this.sendAndConfirm(address, unsignedTx);
+  }
+  // ── Payments (dual-path; x402 reserved) ───────────────────────────────────────
+  /**
+   * 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) {
+    const rail = this.router.selectRail({
+      to: params.to,
+      amountMicroUsdc: params.amountMicroUsdc,
+      mode: "sync"
+    });
+    return Promise.reject(new EscroRailNotEnabledError(rail === "escrow" ? "x402" : rail));
   }
   // ── Worker Bot ───────────────────────────────────────────────────────────────
   /**
    * 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.
    */
   async claimTask(address) {
     const { unsignedTx } = await this.api.claimTask(address);
-    return signAndSend(unsignedTx, this.options.wallet, this.connection);
+    return this.sendAndConfirm(address, unsignedTx);
   }
   /**
-   * 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.
    */
   async submitDeliverable(address, params) {
     const { unsignedTx } = await this.api.submitDeliverable(address, params);
-    return signAndSend(unsignedTx, this.options.wallet, this.connection);
+    return this.sendAndConfirm(address, unsignedTx);
   }
   /**
    * List tasks assigned to the wallet's public key.
@@ -440,7 +822,130 @@ var Escro = class {
       options.timeoutMs
     );
   }
+  /**
+   * 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).
+   */
+  async getMyEscrows(state, options) {
+    const maker = this.options.wallet.publicKey.toBase58();
+    const params = {
+      maker,
+      ...state?.[0] != null && { state: state[0] },
+      ...options?.limit != null && { limit: options.limit },
+      ...options?.offset != null && { offset: options.offset }
+    };
+    if (!options?.poll) {
+      return this.api.listEscrows(params);
+    }
+    const fetcher = () => this.api.listEscrows(params).then((result) => result.items.length > 0 ? result : null);
+    return pollUntil(
+      maker,
+      fetcher,
+      (r) => r !== null,
+      options.timeoutMs
+    );
+  }
+  // ── EscroBots discovery ──────────────────────────────────────────────────────
+  /**
+   * 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.
+   */
+  async findWorkers(params = {}) {
+    const { items } = await this.api.listBots({
+      role: "worker",
+      ...params.capability != null && { capability: params.capability },
+      ...params.limit != null && { limit: params.limit },
+      ...params.offset != null && { offset: params.offset }
+    });
+    return items.map((descriptor) => ({
+      descriptor,
+      signatureValid: verifyBotDescriptorSignature(descriptor)
+    }));
+  }
+  /**
+   * 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).
+   */
+  async listReputations() {
+    return this.api.listReputations();
+  }
+  // ── Stats ────────────────────────────────────────────────────────────────────
+  /**
+   * Fetch protocol-wide stats from the public `GET /v1/stats` endpoint.
+   *
+   * @returns protocol-wide {@link ProtocolStats}.
+   */
+  async getStats() {
+    const data = await this.api.getStats();
+    return data;
+  }
   // ── Shared ───────────────────────────────────────────────────────────────────
+  /**
+   * 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).
+   */
+  async confirm(address, signature, opts = {}) {
+    const deadline = Date.now() + CONFIRM_WINDOW_MS;
+    let delay = CONFIRM_FIRST_DELAY_MS;
+    for (; ; ) {
+      let code;
+      let message;
+      let wait = delay;
+      try {
+        return await this.api.confirm(address, signature, opts.evidence);
+      } catch (err) {
+        if (err instanceof EscroError) {
+          if (!isRetryableConfirmCode(err.code)) {
+            throw new EscroConfirmError(address, signature, err.code, err.message);
+          }
+          code = err.code;
+          message = err.message;
+          wait = Math.max(delay, err.retryAfterMs ?? 0);
+        } else {
+          code = "NETWORK_ERROR";
+          message = err instanceof Error ? err.message : String(err);
+        }
+      }
+      if (Date.now() + wait > deadline) {
+        throw new EscroConfirmError(address, signature, code, message);
+      }
+      await sleep2(wait);
+      delay = Math.min(delay * 2, CONFIRM_MAX_DELAY_MS);
+    }
+  }
+  send(unsignedTx) {
+    return signAndSend(unsignedTx, this.options.wallet, this.connection, this.cluster);
+  }
+  async sendAndConfirm(address, unsignedTx) {
+    const signature = await this.send(unsignedTx);
+    await this.confirm(address, signature);
+    return signature;
+  }
   /**
    * Fetch an escrow by its PDA address.
    * If `options.poll` is true, polls with exponential backoff until the escrow
@@ -452,18 +957,1356 @@ var Escro = class {
     }
     return pollUntil(
       address,
-      () => this.api.getEscrow(address).catch((e) => e instanceof EscrowNotFoundError ? null : Promise.reject(e)),
+      () => this.api.getEscrow(address).catch((e) => {
+        if (e instanceof EscrowNotFoundError) return null;
+        throw e instanceof Error ? e : new Error(String(e));
+      }),
       (r) => r !== null,
       options.timeoutMs
     );
   }
 };
+
+// src/adapter.ts
+function serviceResultToSubmitParams(result) {
+  return {
+    contentHash: result.contentHash,
+    ...result.proofUri !== void 0 && { proofUri: result.proofUri }
+  };
+}
+
+// src/adapter-contract.ts
+import { createHash as createHash3 } from "crypto";
+var AdapterContractError = class extends EscroError {
+  constructor(adapterId, violations) {
+    super(
+      `ServiceAdapter "${adapterId}" violates the adapter contract:
+- ${violations.join("\n- ")}`,
+      "ADAPTER_CONTRACT_VIOLATION"
+    );
+    __publicField(this, "violations", violations);
+    this.name = "AdapterContractError";
+  }
+};
+function errMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function sha256Hex(content) {
+  return createHash3("sha256").update(content).digest("hex");
+}
+function validateServiceResult(result) {
+  if (typeof result !== "object" || result === null) {
+    return ["`execute()` must resolve to a ServiceResult object"];
+  }
+  const violations = [];
+  const r = result;
+  const contentIsValid = typeof r.content === "string" || Buffer.isBuffer(r.content);
+  if (!contentIsValid) {
+    violations.push("`content` must be a string or Buffer");
+  }
+  if (typeof r.contentHash !== "string" || r.contentHash.trim() === "") {
+    violations.push("`contentHash` must be a non-empty string");
+  } else if (contentIsValid && r.contentHash !== sha256Hex(r.content)) {
+    violations.push("`contentHash` must equal the SHA-256 hex digest of `content`");
+  }
+  if (r.proofUri !== void 0 && typeof r.proofUri !== "string") {
+    violations.push("`proofUri`, when present, must be a string");
+  }
+  if (typeof r.metadata !== "object" || r.metadata === null || Array.isArray(r.metadata)) {
+    violations.push("`metadata` must be a plain object");
+  }
+  return violations;
+}
+async function assertServiceAdapterContract(adapter, options) {
+  const a = adapter;
+  const violations = [];
+  const id = typeof a.id === "string" && a.id.trim() !== "" ? a.id : "(unknown)";
+  if (typeof a.id !== "string" || a.id.trim() === "") {
+    violations.push("`id` must be a non-empty string");
+  }
+  if (!Array.isArray(a.capabilities) || a.capabilities.length === 0 || a.capabilities.some((c) => typeof c !== "string" || c.trim() === "")) {
+    violations.push("`capabilities` must be a non-empty array of non-empty strings");
+  }
+  if (typeof a.healthCheck !== "function") {
+    violations.push("`healthCheck` must be a function");
+  }
+  if (typeof a.execute !== "function") {
+    violations.push("`execute` must be a function");
+  }
+  if (typeof a.healthCheck === "function") {
+    try {
+      const healthy = await a.healthCheck();
+      if (typeof healthy !== "boolean") {
+        violations.push("`healthCheck()` must resolve to a boolean");
+      }
+    } catch (err) {
+      violations.push(`\`healthCheck()\` threw: ${errMessage(err)}`);
+    }
+  }
+  let result;
+  if (typeof a.execute === "function") {
+    try {
+      result = await a.execute(options.sampleSpec);
+      violations.push(...validateServiceResult(result));
+    } catch (err) {
+      violations.push(`\`execute()\` threw: ${errMessage(err)}`);
+      result = void 0;
+    }
+  }
+  if (violations.length > 0 || result === void 0) {
+    throw new AdapterContractError(
+      id,
+      violations.length > 0 ? violations : ["`execute()` produced no result"]
+    );
+  }
+  return result;
+}
+
+// src/adapters/bittensor/index.ts
+import { createHash as createHash4 } from "crypto";
+function tao(amount) {
+  return amount;
+}
+function sha256Hex2(content) {
+  return createHash4("sha256").update(content).digest("hex");
+}
+var REFERENCE_MICRO_USDC_PER_TAO = 3e8;
+var defaultSwap = (microUsdc) => Promise.resolve(tao(microUsdc / REFERENCE_MICRO_USDC_PER_TAO));
+var defaultPin = (content) => Promise.resolve(`ipfs://placeholder-${sha256Hex2(content).slice(0, 16)}`);
+function createBittensorSubnetAdapter(config) {
+  const id = `bittensor:${config.subnet}`;
+  return {
+    id,
+    capabilities: config.capabilities,
+    healthCheck: config.checkHealth,
+    async execute(spec2) {
+      const budgetTao = await config.swap(config.taskBudgetMicroUsdc);
+      const content = await config.callSubnet(spec2, budgetTao);
+      const contentHash = sha256Hex2(content);
+      const proofUri = await config.pin(content);
+      return {
+        content,
+        contentHash,
+        proofUri,
+        metadata: { adapter: id, subnet: config.subnet }
+      };
+    }
+  };
+}
+
+// src/adapters/gradients/index.ts
+var GRADIENTS_ADAPTER_ID = "bittensor:sn56";
+var GRADIENTS_CAPABILITIES = ["fine-tune"];
+var DEFAULT_SUBNET = "sn56";
+var DEFAULT_TASK_BUDGET_MICRO_USDC = 5e6;
+var GRADIENTS_DEMO_MARKER = "gradients-sn56-demo-v1";
+var GRADIENTS_DEMO_EVAL_FLOOR = 0.8;
+var DEMO_DATASET = [3, 7, 11, 15, 19];
+function demoExpectedOutputs() {
+  return DEMO_DATASET.map((x) => 2 * x + 1);
+}
+var gradientsDemoJobSpec = {
+  version: "1.0.0",
+  // TaskType has no fine-tune category; "custom" is the canonical fallback.
+  taskType: "custom",
+  description: "Fine-tune the reference model on the canned SN56 demo dataset and return its predictions on the same inputs. The target map is y = 2x + 1. Acceptance is deterministic and recomputed by the buyer: prediction accuracy must be >= 0.8; the worker's self-reported eval score is not trusted.",
+  acceptanceCriteria: [
+    {
+      id: "ac-eval-floor",
+      description: "Prediction accuracy on the demo dataset is >= 0.8, recomputed by the buyer from the deliverable.",
+      required: true
+    }
+  ],
+  deliverableFormat: { type: "json" },
+  metadata: {
+    demo: GRADIENTS_DEMO_MARKER,
+    dataset: [...DEMO_DATASET],
+    target: "y = 2x + 1",
+    evalFloor: GRADIENTS_DEMO_EVAL_FLOOR
+  }
+};
+function solveGradientsDemo() {
+  const predictions = demoExpectedOutputs();
+  return canonicalize({
+    checkpoint: "reference-sn56-demo-checkpoint",
+    eval: { metric: "accuracy", score: 1 },
+    predictions
+  });
+}
+function parseDemoDeliverable(content) {
+  const text = Buffer.isBuffer(content) ? content.toString("utf8") : content;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return null;
+  }
+  const predictions = parsed.predictions;
+  if (!Array.isArray(predictions) || predictions.some((p) => typeof p !== "number")) {
+    return null;
+  }
+  return { predictions };
+}
+function scoreGradientsDemoDeliverable(content) {
+  const parsed = parseDemoDeliverable(content);
+  if (parsed === null) {
+    return 0;
+  }
+  const expected = demoExpectedOutputs();
+  let matches = 0;
+  for (let i = 0; i < expected.length; i++) {
+    if (parsed.predictions[i] === expected[i]) {
+      matches++;
+    }
+  }
+  return matches / expected.length;
+}
+function referencePlaceholder(spec2) {
+  return canonicalize({
+    checkpoint: "reference-sn56-checkpoint",
+    eval: { metric: "accuracy", score: 0 },
+    note: "reference stub - replace the callSubnet port with a real SN56 miner call.",
+    taskType: spec2.taskType
+  });
+}
+var defaultCallSubnet = (spec2) => Promise.resolve(
+  spec2.metadata.demo === GRADIENTS_DEMO_MARKER ? solveGradientsDemo() : referencePlaceholder(spec2)
+);
+function createGradientsAdapter(config = {}) {
+  return createBittensorSubnetAdapter({
+    subnet: config.subnet ?? DEFAULT_SUBNET,
+    capabilities: config.capabilities ?? [...GRADIENTS_CAPABILITIES],
+    taskBudgetMicroUsdc: config.taskBudgetMicroUsdc ?? DEFAULT_TASK_BUDGET_MICRO_USDC,
+    swap: config.swap ?? defaultSwap,
+    callSubnet: config.callSubnet ?? defaultCallSubnet,
+    pin: config.pin ?? defaultPin,
+    checkHealth: config.checkHealth ?? (() => Promise.resolve(true))
+  });
+}
+
+// src/adapters/ridges/index.ts
+import { createHash as createHash5 } from "crypto";
+var RIDGES_ADAPTER_ID = "ridges";
+var RIDGES_CAPABILITIES = ["code-generation"];
+var DEFAULT_SERVICE = "ridges";
+function sha256Hex3(content) {
+  return createHash5("sha256").update(content).digest("hex");
+}
+var RIDGES_DEMO_MARKER = "ridges-demo-v1";
+var RIDGES_DEMO_COVERAGE_TARGET = 0.8;
+var DEMO_INPUTS = [1, 2, 3, 5, 15];
+function fizzbuzz(n) {
+  if (n % 15 === 0) return "FizzBuzz";
+  if (n % 3 === 0) return "Fizz";
+  if (n % 5 === 0) return "Buzz";
+  return String(n);
+}
+var ridgesDemoJobSpec = {
+  version: "1.0.0",
+  taskType: "code_generation",
+  description: "Implement FizzBuzz for the fixed demo battery and return a test report: for each battery input, the output your implementation produced. Acceptance is deterministic and recomputed by the buyer: every delivered test must pass (exit 0) and coverage of the battery must be >= 0.8; the worker's self-reported pass/coverage is not trusted.",
+  acceptanceCriteria: [
+    {
+      id: "ac-tests-pass",
+      description: "Every delivered test passes (exit 0), recomputed by the buyer from the test report.",
+      required: true
+    },
+    {
+      id: "ac-coverage",
+      description: "Coverage of the demo battery is >= 0.8, recomputed by the buyer.",
+      required: true
+    }
+  ],
+  deliverableFormat: { type: "json" },
+  metadata: {
+    demo: RIDGES_DEMO_MARKER,
+    kata: "fizzbuzz",
+    inputs: [...DEMO_INPUTS],
+    coverageTarget: RIDGES_DEMO_COVERAGE_TARGET
+  }
+};
+var REFERENCE_SOLUTION = 'export function fizzbuzz(n: number): string {\n  if (n % 15 === 0) return "FizzBuzz";\n  if (n % 3 === 0) return "Fizz";\n  if (n % 5 === 0) return "Buzz";\n  return String(n);\n}\n';
+function solveRidgesDemo() {
+  const tests = DEMO_INPUTS.map((input) => ({ input, output: fizzbuzz(input) }));
+  return canonicalize({
+    language: "typescript",
+    solution: REFERENCE_SOLUTION,
+    coverage: 1,
+    passed: true,
+    tests
+  });
+}
+function parseTestReport(content) {
+  const text = Buffer.isBuffer(content) ? content.toString("utf8") : content;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return null;
+  }
+  const tests = parsed.tests;
+  if (!Array.isArray(tests)) {
+    return null;
+  }
+  const results = [];
+  for (const t of tests) {
+    if (typeof t !== "object" || t === null) {
+      return null;
+    }
+    const { input, output } = t;
+    if (typeof input !== "number" || typeof output !== "string") {
+      return null;
+    }
+    results.push({ input, output });
+  }
+  return results;
+}
+function scoreRidgesDemoDeliverable(content) {
+  const results = parseTestReport(content);
+  if (results === null) {
+    return 0;
+  }
+  const battery = new Set(DEMO_INPUTS);
+  const coveredInputs = /* @__PURE__ */ new Set();
+  for (const { input, output } of results) {
+    if (!battery.has(input)) {
+      continue;
+    }
+    if (output !== fizzbuzz(input)) {
+      return 0;
+    }
+    coveredInputs.add(input);
+  }
+  return coveredInputs.size / DEMO_INPUTS.length;
+}
+function referencePlaceholder2(spec2) {
+  return canonicalize({
+    language: "typescript",
+    solution: "// reference stub - replace the runAgent port with a real Ridges agent call.",
+    passed: false,
+    tests: [],
+    taskType: spec2.taskType
+  });
+}
+var defaultRunAgent = (spec2) => Promise.resolve(
+  spec2.metadata.demo === RIDGES_DEMO_MARKER ? solveRidgesDemo() : referencePlaceholder2(spec2)
+);
+var defaultPin2 = (content) => Promise.resolve(`ipfs://placeholder-${sha256Hex3(content).slice(0, 16)}`);
+function createRidgesAdapter(config = {}) {
+  const service = config.service ?? DEFAULT_SERVICE;
+  const capabilities = config.capabilities ?? [...RIDGES_CAPABILITIES];
+  const runAgent = config.runAgent ?? defaultRunAgent;
+  const pin = config.pin ?? defaultPin2;
+  const checkHealth = config.checkHealth ?? (() => Promise.resolve(true));
+  return {
+    id: service,
+    capabilities,
+    healthCheck: checkHealth,
+    async execute(spec2) {
+      const content = await runAgent(spec2);
+      const contentHash = sha256Hex3(content);
+      const proofUri = await pin(content);
+      return {
+        content,
+        contentHash,
+        proofUri,
+        metadata: { adapter: service }
+      };
+    }
+  };
+}
+
+// src/adapters/404gen/index.ts
+var GEN404_ADAPTER_ID = "bittensor:sn17";
+var GEN404_CAPABILITIES = ["3d-generation"];
+var DEFAULT_SUBNET2 = "sn17";
+var DEFAULT_TASK_BUDGET_MICRO_USDC2 = 5e6;
+var GEN404_DEMO_MARKER = "404gen-sn17-demo-v1";
+var GEN404_DEMO_EVAL_FLOOR = 1;
+var DEMO_EXPECTATION = {
+  requestedAssets: 1,
+  allowedFormats: ["GLB", "PLY"],
+  minPolygons: 1e3,
+  maxPolygons: 1e6
+};
+var gen404DemoJobSpec = {
+  version: "1.0.0",
+  // TaskType has no 3D category; "custom" is the canonical fallback.
+  taskType: "custom",
+  description: "Generate the canned SN17 demo batch: one 3D asset in a GLB or PLY container with a polygon count between 1000 and 1000000. Acceptance is deterministic and recomputed by the buyer: every requested asset must be present, in an allowed format, and in polygon range; the worker's self-reported validity is not trusted.",
+  acceptanceCriteria: [
+    {
+      id: "ac-format-valid",
+      description: "Every asset is in an allowed container format (GLB or PLY), recomputed by the buyer.",
+      required: true
+    },
+    {
+      id: "ac-polygon-range",
+      description: "Every asset's polygon count is within [1000, 1000000], recomputed by the buyer.",
+      required: true
+    },
+    {
+      id: "ac-batch-complete",
+      description: "The batch contains all requested assets (completeness), recomputed by the buyer.",
+      required: true
+    }
+  ],
+  deliverableFormat: { type: "json" },
+  metadata: {
+    demo: GEN404_DEMO_MARKER,
+    requestedAssets: DEMO_EXPECTATION.requestedAssets,
+    allowedFormats: [...DEMO_EXPECTATION.allowedFormats],
+    minPolygons: DEMO_EXPECTATION.minPolygons,
+    maxPolygons: DEMO_EXPECTATION.maxPolygons
+  }
+};
+function solveGen404Demo() {
+  return canonicalize({
+    assets: [{ format: "GLB", polygonCount: 5e3, uri: "ipfs://404gen-sn17-demo-asset-0" }],
+    eval: { metric: "validity", score: 1 }
+  });
+}
+function parseBatch(content) {
+  const text = Buffer.isBuffer(content) ? content.toString("utf8") : content;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return null;
+  }
+  const assets = parsed.assets;
+  if (!Array.isArray(assets)) {
+    return null;
+  }
+  const cleaned = [];
+  for (const asset of assets) {
+    if (typeof asset !== "object" || asset === null) {
+      return null;
+    }
+    const format = asset.format;
+    const polygonCount = asset.polygonCount;
+    if (typeof format !== "string" || typeof polygonCount !== "number") {
+      return null;
+    }
+    cleaned.push({ format, polygonCount });
+  }
+  return { assets: cleaned };
+}
+function isAssetValid(asset) {
+  const formatOk = DEMO_EXPECTATION.allowedFormats.some(
+    (f) => f.toLowerCase() === asset.format.toLowerCase()
+  );
+  const rangeOk = asset.polygonCount >= DEMO_EXPECTATION.minPolygons && asset.polygonCount <= DEMO_EXPECTATION.maxPolygons;
+  return formatOk && rangeOk;
+}
+function score404genDemoDeliverable(content) {
+  const batch = parseBatch(content);
+  if (batch === null) {
+    return 0;
+  }
+  if (batch.assets.some((asset) => !isAssetValid(asset))) {
+    return 0;
+  }
+  return Math.min(batch.assets.length / DEMO_EXPECTATION.requestedAssets, 1);
+}
+function referencePlaceholder3(spec2) {
+  return canonicalize({
+    assets: [{ format: "GLB", polygonCount: 0, uri: "ipfs://placeholder" }],
+    note: "reference stub - replace the callSubnet port with a real SN17 miner call.",
+    taskType: spec2.taskType
+  });
+}
+var defaultCallSubnet2 = (spec2) => Promise.resolve(
+  spec2.metadata.demo === GEN404_DEMO_MARKER ? solveGen404Demo() : referencePlaceholder3(spec2)
+);
+function create404genAdapter(config = {}) {
+  return createBittensorSubnetAdapter({
+    subnet: config.subnet ?? DEFAULT_SUBNET2,
+    capabilities: config.capabilities ?? [...GEN404_CAPABILITIES],
+    taskBudgetMicroUsdc: config.taskBudgetMicroUsdc ?? DEFAULT_TASK_BUDGET_MICRO_USDC2,
+    swap: config.swap ?? defaultSwap,
+    callSubnet: config.callSubnet ?? defaultCallSubnet2,
+    pin: config.pin ?? defaultPin,
+    checkHealth: config.checkHealth ?? (() => Promise.resolve(true))
+  });
+}
+
+// src/adapters/lium/index.ts
+var LIUM_ADAPTER_ID = "bittensor:sn51";
+var LIUM_CAPABILITIES = ["gpu-compute"];
+var DEFAULT_SUBNET3 = "sn51";
+var DEFAULT_TASK_BUDGET_MICRO_USDC3 = 2e7;
+var LIUM_DEMO_MARKER = "lium-sn51-demo-v1";
+var LIUM_DEMO_ACCEPT_FLOOR = 1;
+var DEMO_SEED = "lium-sn51-demo-seed";
+var DEMO_ROUNDS = 1e3;
+function computeLiumDemoArtifact() {
+  let h = DEMO_SEED;
+  for (let i = 0; i < DEMO_ROUNDS; i++) {
+    h = sha256Hex2(h);
+  }
+  return h;
+}
+var liumDemoJobSpec = {
+  version: "1.0.0",
+  // TaskType has no GPU-compute category; "custom" is the canonical fallback.
+  taskType: "custom",
+  description: "Run the canned SN51 scripted GPU job (a fixed hash-chain compute over a known seed) and return its output artifact. Acceptance is deterministic and recomputed by the buyer: the job must complete, an output artifact must be present, and the artifact must match the buyer's independent recompute; the worker's self-reported artifact hash is not trusted.",
+  acceptanceCriteria: [
+    {
+      id: "ac-completion",
+      description: "The scripted job ran to completion (status=completed).",
+      required: true
+    },
+    {
+      id: "ac-artifact-present",
+      description: "An output artifact is present in the deliverable.",
+      required: true
+    },
+    {
+      id: "ac-hash-match",
+      description: "The output artifact matches the buyer's independent recompute of the scripted job.",
+      required: true
+    }
+  ],
+  deliverableFormat: { type: "json" },
+  metadata: {
+    demo: LIUM_DEMO_MARKER,
+    seed: DEMO_SEED,
+    rounds: DEMO_ROUNDS,
+    acceptFloor: LIUM_DEMO_ACCEPT_FLOOR
+  }
+};
+function solveLiumDemo() {
+  const artifact = computeLiumDemoArtifact();
+  return canonicalize({
+    job: LIUM_DEMO_MARKER,
+    status: "completed",
+    rounds: DEMO_ROUNDS,
+    artifact,
+    // Self-reported and deliberately ignored by the buyer's recompute.
+    artifactHash: sha256Hex2(artifact)
+  });
+}
+function parseDemoDeliverable2(content) {
+  const text = Buffer.isBuffer(content) ? content.toString("utf8") : content;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return null;
+  }
+  const obj = parsed;
+  const status = typeof obj.status === "string" ? obj.status : "";
+  const artifact = typeof obj.artifact === "string" ? obj.artifact : null;
+  return { status, artifact };
+}
+function scoreLiumDemoDeliverable(content) {
+  const parsed = parseDemoDeliverable2(content);
+  if (parsed === null) {
+    return 0;
+  }
+  if (parsed.status !== "completed") {
+    return 0;
+  }
+  if (parsed.artifact === null) {
+    return 0;
+  }
+  return parsed.artifact === computeLiumDemoArtifact() ? 1 : 0;
+}
+function referencePlaceholder4(spec2) {
+  return canonicalize({
+    job: "lium-sn51-generic",
+    status: "completed",
+    artifact: null,
+    note: "reference stub - replace the runJob port with a real SN51 GPU-rental call.",
+    taskType: spec2.taskType
+  });
+}
+var defaultRunJob = (spec2) => Promise.resolve(
+  spec2.metadata.demo === LIUM_DEMO_MARKER ? solveLiumDemo() : referencePlaceholder4(spec2)
+);
+function createLiumAdapter(config = {}) {
+  return createBittensorSubnetAdapter({
+    subnet: config.subnet ?? DEFAULT_SUBNET3,
+    capabilities: config.capabilities ?? [...LIUM_CAPABILITIES],
+    taskBudgetMicroUsdc: config.taskBudgetMicroUsdc ?? DEFAULT_TASK_BUDGET_MICRO_USDC3,
+    swap: config.swap ?? defaultSwap,
+    callSubnet: config.runJob ?? defaultRunJob,
+    pin: config.pin ?? defaultPin,
+    checkHealth: config.checkHealth ?? (() => Promise.resolve(true))
+  });
+}
+
+// src/adapters/akash/index.ts
+import { createHash as createHash6 } from "crypto";
+function akt(amount) {
+  return amount;
+}
+function sha256Hex4(content) {
+  return createHash6("sha256").update(content).digest("hex");
+}
+var AKASH_ADAPTER_ID = "akash";
+var AKASH_CAPABILITIES = ["cloud-compute"];
+var DEFAULT_TASK_BUDGET_MICRO_USDC4 = 1e7;
+var REFERENCE_MICRO_USDC_PER_AKT = 3e6;
+var defaultSwap2 = (microUsdc) => Promise.resolve(akt(microUsdc / REFERENCE_MICRO_USDC_PER_AKT));
+var defaultPin3 = (content) => Promise.resolve(`ipfs://placeholder-${sha256Hex4(content).slice(0, 16)}`);
+var AKASH_DEMO_MARKER = "akash-demo-v1";
+var AKASH_DEMO_ACCEPT_FLOOR = 1;
+var DEMO_SEED2 = "akash-demo-seed";
+var DEMO_ROUNDS2 = 1e3;
+function computeAkashDemoArtifact() {
+  let h = DEMO_SEED2;
+  for (let i = 0; i < DEMO_ROUNDS2; i++) {
+    h = sha256Hex4(h);
+  }
+  return h;
+}
+var akashDemoJobSpec = {
+  version: "1.0.0",
+  // TaskType has no cloud-compute category; "custom" is the canonical fallback.
+  taskType: "custom",
+  description: "Run the canned Akash scripted batch job (a fixed hash-chain compute over a known seed) on a deployment and return its output artifact. Acceptance is deterministic and recomputed by the buyer: the job must complete, an output artifact must be present, and the artifact must match the buyer's independent recompute; the worker's self-reported artifact hash is not trusted.",
+  acceptanceCriteria: [
+    {
+      id: "ac-completion",
+      description: "The scripted job ran to completion (status=completed).",
+      required: true
+    },
+    {
+      id: "ac-artifact-present",
+      description: "An output artifact is present in the deliverable.",
+      required: true
+    },
+    {
+      id: "ac-hash-match",
+      description: "The output artifact matches the buyer's independent recompute of the scripted job.",
+      required: true
+    }
+  ],
+  deliverableFormat: { type: "json" },
+  metadata: {
+    demo: AKASH_DEMO_MARKER,
+    seed: DEMO_SEED2,
+    rounds: DEMO_ROUNDS2,
+    acceptFloor: AKASH_DEMO_ACCEPT_FLOOR
+  }
+};
+function solveAkashDemo() {
+  const artifact = computeAkashDemoArtifact();
+  return canonicalize({
+    job: AKASH_DEMO_MARKER,
+    status: "completed",
+    rounds: DEMO_ROUNDS2,
+    artifact,
+    // Self-reported and deliberately ignored by the buyer's recompute.
+    artifactHash: sha256Hex4(artifact)
+  });
+}
+function parseDemoDeliverable3(content) {
+  const text = Buffer.isBuffer(content) ? content.toString("utf8") : content;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return null;
+  }
+  const obj = parsed;
+  const status = typeof obj.status === "string" ? obj.status : "";
+  const artifact = typeof obj.artifact === "string" ? obj.artifact : null;
+  return { status, artifact };
+}
+function scoreAkashDemoDeliverable(content) {
+  const parsed = parseDemoDeliverable3(content);
+  if (parsed === null) {
+    return 0;
+  }
+  if (parsed.status !== "completed") {
+    return 0;
+  }
+  if (parsed.artifact === null) {
+    return 0;
+  }
+  return parsed.artifact === computeAkashDemoArtifact() ? 1 : 0;
+}
+function referencePlaceholder5(spec2) {
+  return canonicalize({
+    job: "akash-generic",
+    status: "completed",
+    artifact: null,
+    note: "reference stub - replace the runDeployment port with a real Akash deployment call.",
+    taskType: spec2.taskType
+  });
+}
+var defaultRunDeployment = (spec2) => Promise.resolve(
+  spec2.metadata.demo === AKASH_DEMO_MARKER ? solveAkashDemo() : referencePlaceholder5(spec2)
+);
+function createAkashAdapter(config = {}) {
+  const capabilities = config.capabilities ?? [...AKASH_CAPABILITIES];
+  const taskBudgetMicroUsdc = config.taskBudgetMicroUsdc ?? DEFAULT_TASK_BUDGET_MICRO_USDC4;
+  const swap = config.swap ?? defaultSwap2;
+  const runDeployment = config.runDeployment ?? defaultRunDeployment;
+  const pin = config.pin ?? defaultPin3;
+  const checkHealth = config.checkHealth ?? (() => Promise.resolve(true));
+  return {
+    id: AKASH_ADAPTER_ID,
+    capabilities,
+    healthCheck: checkHealth,
+    async execute(spec2) {
+      const budgetAkt = await swap(taskBudgetMicroUsdc);
+      const content = await runDeployment(spec2, budgetAkt);
+      const contentHash = sha256Hex4(content);
+      const proofUri = await pin(content);
+      return {
+        content,
+        contentHash,
+        proofUri,
+        metadata: { adapter: AKASH_ADAPTER_ID }
+      };
+    }
+  };
+}
+
+// src/adapters/render/index.ts
+import { createHash as createHash7 } from "crypto";
+function renderAmount(amount) {
+  return amount;
+}
+var RENDER_ADAPTER_ID = "render";
+var RENDER_CAPABILITIES = ["3d-rendering", "video-rendering", "gpu-inference"];
+var DEFAULT_SERVICE2 = "render";
+var DEFAULT_TASK_BUDGET_MICRO_USDC5 = 15e6;
+function sha256Hex5(content) {
+  return createHash7("sha256").update(content).digest("hex");
+}
+var REFERENCE_MICRO_USDC_PER_RENDER = 2e6;
+var defaultSwap3 = (microUsdc) => Promise.resolve(renderAmount(microUsdc / REFERENCE_MICRO_USDC_PER_RENDER));
+var defaultPin4 = (content) => Promise.resolve(`ipfs://placeholder-${sha256Hex5(content).slice(0, 16)}`);
+var RENDER_DEMO_MARKER = "render-demo-v1";
+var RENDER_DEMO_ACCEPT_FLOOR = 1;
+var DEMO_SCENE = "render-demo-scene-v1";
+var DEMO_WIDTH = 16;
+var DEMO_HEIGHT = 16;
+function shade(x, y) {
+  return x * 53 + y * 97 + (x ^ y) * 29 & 255;
+}
+function computeRenderDemoArtifact() {
+  const raster = Buffer.alloc(DEMO_WIDTH * DEMO_HEIGHT);
+  let i = 0;
+  for (let y = 0; y < DEMO_HEIGHT; y++) {
+    for (let x = 0; x < DEMO_WIDTH; x++) {
+      raster[i++] = shade(x, y);
+    }
+  }
+  return raster.toString("hex");
+}
+var renderDemoJobSpec = {
+  version: "1.0.0",
+  taskType: "image_generation",
+  description: "Render the canned demo scene (a fixed procedural frame) and return the rendered frame. Acceptance is deterministic and recomputed by the buyer: the job must complete, a rendered frame must be present, and the frame must match the buyer's independent re-render; the worker's self-reported frame hash is not trusted.",
+  acceptanceCriteria: [
+    {
+      id: "ac-completion",
+      description: "The render job ran to completion (status=completed).",
+      required: true
+    },
+    {
+      id: "ac-frame-present",
+      description: "A rendered frame is present in the deliverable.",
+      required: true
+    },
+    {
+      id: "ac-frame-match",
+      description: "The rendered frame matches the buyer's independent re-render of the scene.",
+      required: true
+    }
+  ],
+  deliverableFormat: { type: "json" },
+  metadata: {
+    demo: RENDER_DEMO_MARKER,
+    scene: DEMO_SCENE,
+    width: DEMO_WIDTH,
+    height: DEMO_HEIGHT,
+    acceptFloor: RENDER_DEMO_ACCEPT_FLOOR
+  }
+};
+function solveRenderDemo() {
+  const frame = computeRenderDemoArtifact();
+  return canonicalize({
+    job: RENDER_DEMO_MARKER,
+    status: "completed",
+    width: DEMO_WIDTH,
+    height: DEMO_HEIGHT,
+    frame,
+    // Self-reported and deliberately ignored by the buyer's recompute.
+    frameHash: sha256Hex5(frame)
+  });
+}
+function parseDemoDeliverable4(content) {
+  const text = Buffer.isBuffer(content) ? content.toString("utf8") : content;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return null;
+  }
+  const obj = parsed;
+  const status = typeof obj.status === "string" ? obj.status : "";
+  const frame = typeof obj.frame === "string" ? obj.frame : null;
+  return { status, frame };
+}
+function scoreRenderDemoDeliverable(content) {
+  const parsed = parseDemoDeliverable4(content);
+  if (parsed === null) {
+    return 0;
+  }
+  if (parsed.status !== "completed") {
+    return 0;
+  }
+  if (parsed.frame === null) {
+    return 0;
+  }
+  return parsed.frame === computeRenderDemoArtifact() ? 1 : 0;
+}
+function referencePlaceholder6(spec2) {
+  return canonicalize({
+    job: "render-generic",
+    status: "completed",
+    frame: null,
+    note: "reference stub - replace the runJob port with a real Render Network job submission.",
+    taskType: spec2.taskType
+  });
+}
+var defaultRunJob2 = (spec2) => Promise.resolve(
+  spec2.metadata.demo === RENDER_DEMO_MARKER ? solveRenderDemo() : referencePlaceholder6(spec2)
+);
+function createRenderAdapter(config = {}) {
+  const service = config.service ?? DEFAULT_SERVICE2;
+  const capabilities = config.capabilities ?? [...RENDER_CAPABILITIES];
+  const taskBudgetMicroUsdc = config.taskBudgetMicroUsdc ?? DEFAULT_TASK_BUDGET_MICRO_USDC5;
+  const swap = config.swap ?? defaultSwap3;
+  const runJob = config.runJob ?? defaultRunJob2;
+  const pin = config.pin ?? defaultPin4;
+  const checkHealth = config.checkHealth ?? (() => Promise.resolve(true));
+  return {
+    id: service,
+    capabilities,
+    healthCheck: checkHealth,
+    async execute(spec2) {
+      const budgetRender = await swap(taskBudgetMicroUsdc);
+      const content = await runJob(spec2, budgetRender);
+      const contentHash = sha256Hex5(content);
+      const proofUri = await pin(content);
+      return {
+        content,
+        contentHash,
+        proofUri,
+        metadata: { adapter: service, network: "render" }
+      };
+    }
+  };
+}
+
+// src/adapters/gensyn/index.ts
+import { createHash as createHash8 } from "crypto";
+var GENSYN_ADAPTER_ID = "gensyn";
+var GENSYN_CAPABILITIES = ["verifiable-compute"];
+var GENSYN_REE_SCHEME = "gensyn-ree-v1";
+var GENSYN_DEMO_MARKER = "gensyn-ree-demo-v1";
+var GENSYN_DEMO_SEED = 12345;
+var GENSYN_DEMO_STEPS = 16;
+function sha256Hex6(content) {
+  return createHash8("sha256").update(content).digest("hex");
+}
+var LCG_MULT = 1103515245n;
+var LCG_INC = 12345n;
+var LCG_MOD = 1n << 31n;
+function readComputeParams(spec2) {
+  const rawSeed = spec2.metadata.seed;
+  const rawSteps = spec2.metadata.steps;
+  const seed = typeof rawSeed === "number" && Number.isInteger(rawSeed) ? rawSeed : GENSYN_DEMO_SEED;
+  const steps = typeof rawSteps === "number" && Number.isInteger(rawSteps) && rawSteps > 0 ? rawSteps : GENSYN_DEMO_STEPS;
+  return { seed, steps };
+}
+var reproduceGensynCompute = (spec2) => {
+  const { seed, steps } = readComputeParams(spec2);
+  const states = [];
+  let x = BigInt(seed) % LCG_MOD;
+  if (x < 0n) {
+    x += LCG_MOD;
+  }
+  for (let i = 0; i < steps; i++) {
+    x = (LCG_MULT * x + LCG_INC) % LCG_MOD;
+    states.push(Number(x));
+  }
+  return { seed, steps, states, result: states[states.length - 1] ?? seed };
+};
+function gensynDeliverable(exec) {
+  return canonicalize({ result: exec.result, steps: exec.steps });
+}
+function commitmentOf(base) {
+  return sha256Hex6(
+    [base.scheme, base.specHash, base.outputHash, String(base.steps), base.transcriptHash].join(
+      "\n"
+    )
+  );
+}
+function buildReeProof(spec2, exec, content) {
+  const base = {
+    scheme: GENSYN_REE_SCHEME,
+    specHash: sha256Hex6(canonicalize(spec2)),
+    outputHash: sha256Hex6(content),
+    steps: exec.steps,
+    transcriptHash: sha256Hex6(canonicalize(exec.states))
+  };
+  return { ...base, commitment: commitmentOf(base) };
+}
+var HEX_64 = /^[0-9a-f]{64}$/;
+function isHex64(v) {
+  return typeof v === "string" && HEX_64.test(v);
+}
+function malformed(reason) {
+  return { valid: false, reason: `malformed: ${reason}` };
+}
+function invalid(reason) {
+  return { valid: false, reason: `invalid: ${reason}` };
+}
+function verifyReeProof(proof, ctx) {
+  if (typeof proof !== "object" || proof === null) {
+    return malformed("proof is not an object");
+  }
+  const p = proof;
+  if (p.scheme !== GENSYN_REE_SCHEME) {
+    return malformed(`scheme must be "${GENSYN_REE_SCHEME}"`);
+  }
+  if (!isHex64(p.specHash)) {
+    return malformed("specHash must be a 64-char lowercase hex string");
+  }
+  if (!isHex64(p.outputHash)) {
+    return malformed("outputHash must be a 64-char lowercase hex string");
+  }
+  if (!isHex64(p.transcriptHash)) {
+    return malformed("transcriptHash must be a 64-char lowercase hex string");
+  }
+  if (!isHex64(p.commitment)) {
+    return malformed("commitment must be a 64-char lowercase hex string");
+  }
+  if (typeof p.steps !== "number" || !Number.isInteger(p.steps) || p.steps <= 0) {
+    return malformed("steps must be a positive integer");
+  }
+  const base = {
+    scheme: GENSYN_REE_SCHEME,
+    specHash: p.specHash,
+    outputHash: p.outputHash,
+    steps: p.steps,
+    transcriptHash: p.transcriptHash
+  };
+  if (commitmentOf(base) !== p.commitment) {
+    return invalid("commitment does not bind the proof fields (tampered)");
+  }
+  if (sha256Hex6(ctx.content) !== p.outputHash) {
+    return invalid("outputHash does not match the delivered content");
+  }
+  if (sha256Hex6(canonicalize(ctx.spec)) !== p.specHash) {
+    return invalid("specHash does not match the commissioned task spec");
+  }
+  const exec = (ctx.reproduce ?? reproduceGensynCompute)(ctx.spec);
+  if (p.steps !== exec.steps) {
+    return invalid("steps does not match the reproduced execution");
+  }
+  if (sha256Hex6(canonicalize(exec.states)) !== p.transcriptHash) {
+    return invalid("transcriptHash is not reproducible from the task spec");
+  }
+  if (sha256Hex6(gensynDeliverable(exec)) !== p.outputHash) {
+    return invalid("outputHash does not match the reproduced deliverable");
+  }
+  return {
+    valid: true,
+    reason: "REE proof verified: commitment, spec, transcript, and the reproduced deliverable all bind to the delivered content."
+  };
+}
+function gensynAutoRelease(bundle, ctx) {
+  const verdict = verifyReeProof(bundle.proof, {
+    spec: ctx.spec,
+    content: bundle.content,
+    ...ctx.reproduce !== void 0 && { reproduce: ctx.reproduce }
+  });
+  return { release: verdict.valid, reason: verdict.reason };
+}
+var gensynDemoJobSpec = {
+  version: "1.0.0",
+  taskType: "custom",
+  description: "Run the reference reproducible compute (a fixed LCG walk from the seed in metadata) and return its final result. Acceptance is a valid gensyn-ree-v1 REE proof: the buyer recomputes the transcript and confirms the proof binds the delivered content, this spec, and the reproducible execution. The worker's self-reported result is never trusted on its own.",
+  acceptanceCriteria: [
+    {
+      id: "ac-ree-proof",
+      description: "A valid gensyn-ree-v1 proof binding the delivered content, this spec, and a reproducible transcript.",
+      required: true
+    }
+  ],
+  deliverableFormat: { type: "json" },
+  metadata: {
+    demo: GENSYN_DEMO_MARKER,
+    seed: GENSYN_DEMO_SEED,
+    steps: GENSYN_DEMO_STEPS
+  }
+};
+var defaultPin5 = (content) => Promise.resolve(`ipfs://gensyn-${sha256Hex6(content).slice(0, 16)}`);
+function createGensynAdapter(config = {}) {
+  const runCompute = config.runCompute ?? reproduceGensynCompute;
+  const pin = config.pin ?? defaultPin5;
+  const checkHealth = config.checkHealth ?? (() => Promise.resolve(true));
+  const capabilities = config.capabilities ?? [...GENSYN_CAPABILITIES];
+  return {
+    id: GENSYN_ADAPTER_ID,
+    capabilities,
+    healthCheck: checkHealth,
+    async execute(spec2) {
+      const exec = runCompute(spec2);
+      const content = gensynDeliverable(exec);
+      const contentHash = sha256Hex6(content);
+      const proof = buildReeProof(spec2, exec, content);
+      const proofUri = await pin(content);
+      return {
+        content,
+        contentHash,
+        proofUri,
+        metadata: { adapter: GENSYN_ADAPTER_ID, reeProof: proof }
+      };
+    }
+  };
+}
+
+// src/adapters/zkml/index.ts
+import { createHash as createHash9 } from "crypto";
+var ZKML_ADAPTER_ID = "zkml";
+var ZKML_CAPABILITIES = ["zk-verified-inference"];
+var ZKML_DEMO_MARKER = "zkml-demo-v1";
+var ZKML_PROOF_SCHEME = "escro-zkml-ref-v1";
+var ZKML_PROOF_URI_PREFIX = "zkml-proof:";
+function sha256Hex7(content) {
+  return createHash9("sha256").update(content).digest("hex");
+}
+function computeZkmlVerificationTag(publicInputs) {
+  return sha256Hex7(
+    canonicalize({
+      scheme: publicInputs.scheme,
+      modelCommitment: publicInputs.modelCommitment,
+      inputCommitment: publicInputs.inputCommitment,
+      outputHash: publicInputs.outputHash
+    })
+  );
+}
+function buildZkmlProof(args) {
+  const publicInputs = {
+    scheme: args.scheme ?? ZKML_PROOF_SCHEME,
+    modelCommitment: args.modelCommitment,
+    inputCommitment: args.inputCommitment,
+    outputHash: args.outputHash
+  };
+  return { ...publicInputs, verificationTag: computeZkmlVerificationTag(publicInputs) };
+}
+function encodeZkmlProofUri(proof) {
+  return ZKML_PROOF_URI_PREFIX + Buffer.from(canonicalize(proof), "utf8").toString("base64url");
+}
+function isProofShaped(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const p = value;
+  return typeof p.scheme === "string" && typeof p.modelCommitment === "string" && typeof p.inputCommitment === "string" && typeof p.outputHash === "string" && typeof p.verificationTag === "string";
+}
+function decodeZkmlProofUri(uri) {
+  if (!uri.startsWith(ZKML_PROOF_URI_PREFIX)) {
+    return null;
+  }
+  const encoded = uri.slice(ZKML_PROOF_URI_PREFIX.length);
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+  return isProofShaped(parsed) ? parsed : null;
+}
+function verifyZkmlProof(proof, expected) {
+  if (!isProofShaped(proof)) {
+    return { valid: false, category: "malformed", reason: "proof is missing required fields" };
+  }
+  if (proof.scheme !== ZKML_PROOF_SCHEME) {
+    return {
+      valid: false,
+      category: "malformed",
+      reason: `unsupported proof scheme "${proof.scheme}"`
+    };
+  }
+  if (proof.verificationTag !== computeZkmlVerificationTag(proof)) {
+    return {
+      valid: false,
+      category: "invalid",
+      reason: "verification tag does not recompute (public inputs altered after the tag was computed)"
+    };
+  }
+  if (proof.outputHash !== expected.contentHash) {
+    return {
+      valid: false,
+      category: "invalid",
+      reason: "proof attests a different output than the submitted deliverable"
+    };
+  }
+  if (expected.modelCommitment !== void 0 && proof.modelCommitment !== expected.modelCommitment) {
+    return { valid: false, category: "invalid", reason: "proof attests a different model" };
+  }
+  return { valid: true };
+}
+function verifyZkmlProofUri(uri, expected) {
+  if (typeof uri !== "string" || uri === "") {
+    return { valid: false, category: "malformed", reason: "no proof URI attached" };
+  }
+  const proof = decodeZkmlProofUri(uri);
+  if (proof === null) {
+    return {
+      valid: false,
+      category: "malformed",
+      reason: "proof URI is not a decodable inline zkml proof"
+    };
+  }
+  return verifyZkmlProof(proof, expected);
+}
+async function resolveZkmlProof(uri, fetchProof) {
+  if (typeof uri !== "string" || uri === "") {
+    return null;
+  }
+  if (uri.startsWith(ZKML_PROOF_URI_PREFIX)) {
+    return decodeZkmlProofUri(uri);
+  }
+  return fetchProof ? await fetchProof(uri) : null;
+}
+function zkmlProofAutoRelease(opts) {
+  const verify = opts.verify ?? verifyZkmlProof;
+  return {
+    name: "zkml-proof-auto-release",
+    async evaluate(d) {
+      const recomputed = sha256Hex7(await opts.fetchContent(d));
+      if (recomputed !== d.contentHash) {
+        return {
+          accept: false,
+          dispute: true,
+          reason: "delivered artifact does not hash to the submitted contentHash (tampered or wrong)"
+        };
+      }
+      const proof = await resolveZkmlProof(d.proofUri, opts.fetchProof);
+      if (proof === null) {
+        return { accept: false, dispute: true, reason: "no decodable zkml proof attached" };
+      }
+      const verdict = verify(proof, {
+        contentHash: recomputed,
+        ...opts.modelCommitment !== void 0 && { modelCommitment: opts.modelCommitment }
+      });
+      if (verdict.valid) {
+        return {
+          accept: true,
+          dispute: false,
+          reason: "zkml proof verified against the re-hashed deliverable"
+        };
+      }
+      return {
+        accept: false,
+        dispute: true,
+        reason: `zkml proof ${verdict.category}: ${verdict.reason}`
+      };
+    }
+  };
+}
+var zkmlDemoJobSpec = {
+  version: "1.0.0",
+  taskType: "custom",
+  description: "Run the canned zk-verified inference demo: classify the fixed demo input and attach a proof that the output is the correct result of the committed model on the committed input. Acceptance is deterministic and recomputed by the buyer: the attached proof must verify against the submitted deliverable's contentHash.",
+  acceptanceCriteria: [
+    {
+      id: "ac-proof-verifies",
+      description: "The attached proof verifies against the submitted deliverable's contentHash, recomputed by the buyer.",
+      required: true
+    }
+  ],
+  deliverableFormat: { type: "json" },
+  metadata: { demo: ZKML_DEMO_MARKER }
+};
+var DEMO_MODEL_COMMITMENT = sha256Hex7("zkml-demo-classifier-v1");
+var DEMO_INPUT_COMMITMENT = sha256Hex7("zkml-demo-input-v1");
+function solveZkmlDemo() {
+  return canonicalize({
+    model: "zkml-demo-classifier-v1",
+    output: { label: "cat", confidence: 0.98 }
+  });
+}
+function referencePlaceholderOutput(spec2) {
+  return {
+    content: canonicalize({
+      note: "reference stub - replace the runInference port with a real zk-verified inference call.",
+      taskType: spec2.taskType
+    }),
+    modelCommitment: sha256Hex7("zkml-reference-stub-model"),
+    inputCommitment: sha256Hex7(canonicalize(spec2))
+  };
+}
+var defaultRunInference = (spec2) => spec2.metadata.demo === ZKML_DEMO_MARKER ? {
+  content: solveZkmlDemo(),
+  modelCommitment: DEMO_MODEL_COMMITMENT,
+  inputCommitment: DEMO_INPUT_COMMITMENT
+} : referencePlaceholderOutput(spec2);
+function createZkmlAdapter(config = {}) {
+  const id = config.id ?? ZKML_ADAPTER_ID;
+  const capabilities = config.capabilities ?? [...ZKML_CAPABILITIES];
+  const runInference = config.runInference ?? defaultRunInference;
+  const prove = config.prove ?? ((args) => buildZkmlProof({
+    modelCommitment: args.output.modelCommitment,
+    inputCommitment: args.output.inputCommitment,
+    outputHash: args.outputHash
+  }));
+  const pin = config.pin ?? ((proof) => encodeZkmlProofUri(proof));
+  const checkHealth = config.checkHealth ?? (() => Promise.resolve(true));
+  return {
+    id,
+    capabilities,
+    async execute(spec2) {
+      const output = await runInference(spec2);
+      const contentHash = sha256Hex7(output.content);
+      const proof = await prove({ spec: spec2, output, outputHash: contentHash });
+      const proofUri = await pin(proof);
+      return {
+        content: output.content,
+        contentHash,
+        proofUri,
+        metadata: {
+          adapterId: id,
+          scheme: proof.scheme,
+          modelCommitment: proof.modelCommitment
+        }
+      };
+    },
+    healthCheck() {
+      return checkHealth();
+    }
+  };
+}
 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,
-  UnauthorizedError
+  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
 };
 //# sourceMappingURL=index.js.map