@escro/sdk 0.2.0 → 0.3.0

package/dist/index.js

@@ -100,6 +100,26 @@ function verifyBotDescriptorSignature(descriptor) {
     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"];
@@ -114,9 +134,10 @@ var EscrowPaymentRouter = class {
 
 // src/errors.ts
 var EscroError = class extends Error {
-  constructor(message, code = "ESCRO_ERROR") {
+  constructor(message, code = "ESCRO_ERROR", retryAfterMs2) {
     super(message);
     __publicField(this, "code", code);
+    __publicField(this, "retryAfterMs", retryAfterMs2);
     this.name = "EscroError";
   }
 };
@@ -147,6 +168,14 @@ 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");
@@ -177,7 +206,10 @@ async function handleError(res, address) {
   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) {
@@ -253,6 +285,22 @@ var ApiClient = class {
     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.
@@ -342,7 +390,7 @@ var ApiClient = class {
    */
   async raiseDispute(address, params) {
     const path = `/v1/escrows/${address}/dispute`;
-    const rawBody = JSON.stringify({ reason: params.reason, evidence: params.evidence });
+    const rawBody = JSON.stringify({ reason: params.reason });
     const res = await fetch(this.url(path), {
       method: "POST",
       headers: {
@@ -354,6 +402,35 @@ var ApiClient = class {
     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
@@ -563,6 +640,30 @@ async function buildReleasePaymentTx(params) {
 }
 
 // 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");
@@ -578,18 +679,14 @@ var Escro = class {
   // ── 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,
-      this.cluster
-    );
+    const signature = await this.send(unsignedTx);
+    await this.confirm(escrowPda, signature);
     return { escrowId, escrowPda, signature };
   }
   /**
@@ -629,24 +726,31 @@ var Escro = class {
   }
   /**
    * 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, this.cluster);
+    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, this.cluster);
+    return this.sendAndConfirm(address, unsignedTx);
   }
   // ── Payments (dual-path; x402 reserved) ───────────────────────────────────────
   /**
@@ -671,23 +775,23 @@ var Escro = class {
   // ── 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, this.cluster);
+    return this.sendAndConfirm(address, unsignedTx);
   }
   /**
    * Submit a deliverable for the buyer to review. Worker must be the wallet.
-   * Signs and submits the `submit_deliverable` on-chain tx.
+   * 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, this.cluster);
+    return this.sendAndConfirm(address, unsignedTx);
   }
   /**
    * List tasks assigned to the wallet's public key.
@@ -797,6 +901,51 @@ var Escro = class {
     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
@@ -930,9 +1079,9 @@ function createBittensorSubnetAdapter(config) {
     id,
     capabilities: config.capabilities,
     healthCheck: config.checkHealth,
-    async execute(spec) {
+    async execute(spec2) {
       const budgetTao = await config.swap(config.taskBudgetMicroUsdc);
-      const content = await config.callSubnet(spec, budgetTao);
+      const content = await config.callSubnet(spec2, budgetTao);
       const contentHash = sha256Hex2(content);
       const proofUri = await config.pin(content);
       return {
@@ -1015,16 +1164,16 @@ function scoreGradientsDemoDeliverable(content) {
   }
   return matches / expected.length;
 }
-function referencePlaceholder(spec) {
+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: spec.taskType
+    taskType: spec2.taskType
   });
 }
-var defaultCallSubnet = (spec) => Promise.resolve(
-  spec.metadata.demo === GRADIENTS_DEMO_MARKER ? solveGradientsDemo() : referencePlaceholder(spec)
+var defaultCallSubnet = (spec2) => Promise.resolve(
+  spec2.metadata.demo === GRADIENTS_DEMO_MARKER ? solveGradientsDemo() : referencePlaceholder(spec2)
 );
 function createGradientsAdapter(config = {}) {
   return createBittensorSubnetAdapter({
@@ -1136,17 +1285,17 @@ function scoreRidgesDemoDeliverable(content) {
   }
   return coveredInputs.size / DEMO_INPUTS.length;
 }
-function referencePlaceholder2(spec) {
+function referencePlaceholder2(spec2) {
   return canonicalize({
     language: "typescript",
     solution: "// reference stub - replace the runAgent port with a real Ridges agent call.",
     passed: false,
     tests: [],
-    taskType: spec.taskType
+    taskType: spec2.taskType
   });
 }
-var defaultRunAgent = (spec) => Promise.resolve(
-  spec.metadata.demo === RIDGES_DEMO_MARKER ? solveRidgesDemo() : referencePlaceholder2(spec)
+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 = {}) {
@@ -1159,8 +1308,8 @@ function createRidgesAdapter(config = {}) {
     id: service,
     capabilities,
     healthCheck: checkHealth,
-    async execute(spec) {
-      const content = await runAgent(spec);
+    async execute(spec2) {
+      const content = await runAgent(spec2);
       const contentHash = sha256Hex3(content);
       const proofUri = await pin(content);
       return {
@@ -1269,15 +1418,15 @@ function score404genDemoDeliverable(content) {
   }
   return Math.min(batch.assets.length / DEMO_EXPECTATION.requestedAssets, 1);
 }
-function referencePlaceholder3(spec) {
+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: spec.taskType
+    taskType: spec2.taskType
   });
 }
-var defaultCallSubnet2 = (spec) => Promise.resolve(
-  spec.metadata.demo === GEN404_DEMO_MARKER ? solveGen404Demo() : referencePlaceholder3(spec)
+var defaultCallSubnet2 = (spec2) => Promise.resolve(
+  spec2.metadata.demo === GEN404_DEMO_MARKER ? solveGen404Demo() : referencePlaceholder3(spec2)
 );
 function create404genAdapter(config = {}) {
   return createBittensorSubnetAdapter({
@@ -1377,17 +1526,17 @@ function scoreLiumDemoDeliverable(content) {
   }
   return parsed.artifact === computeLiumDemoArtifact() ? 1 : 0;
 }
-function referencePlaceholder4(spec) {
+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: spec.taskType
+    taskType: spec2.taskType
   });
 }
-var defaultRunJob = (spec) => Promise.resolve(
-  spec.metadata.demo === LIUM_DEMO_MARKER ? solveLiumDemo() : referencePlaceholder4(spec)
+var defaultRunJob = (spec2) => Promise.resolve(
+  spec2.metadata.demo === LIUM_DEMO_MARKER ? solveLiumDemo() : referencePlaceholder4(spec2)
 );
 function createLiumAdapter(config = {}) {
   return createBittensorSubnetAdapter({
@@ -1496,17 +1645,17 @@ function scoreAkashDemoDeliverable(content) {
   }
   return parsed.artifact === computeAkashDemoArtifact() ? 1 : 0;
 }
-function referencePlaceholder5(spec) {
+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: spec.taskType
+    taskType: spec2.taskType
   });
 }
-var defaultRunDeployment = (spec) => Promise.resolve(
-  spec.metadata.demo === AKASH_DEMO_MARKER ? solveAkashDemo() : referencePlaceholder5(spec)
+var defaultRunDeployment = (spec2) => Promise.resolve(
+  spec2.metadata.demo === AKASH_DEMO_MARKER ? solveAkashDemo() : referencePlaceholder5(spec2)
 );
 function createAkashAdapter(config = {}) {
   const capabilities = config.capabilities ?? [...AKASH_CAPABILITIES];
@@ -1519,9 +1668,9 @@ function createAkashAdapter(config = {}) {
     id: AKASH_ADAPTER_ID,
     capabilities,
     healthCheck: checkHealth,
-    async execute(spec) {
+    async execute(spec2) {
       const budgetAkt = await swap(taskBudgetMicroUsdc);
-      const content = await runDeployment(spec, budgetAkt);
+      const content = await runDeployment(spec2, budgetAkt);
       const contentHash = sha256Hex4(content);
       const proofUri = await pin(content);
       return {
@@ -1638,17 +1787,17 @@ function scoreRenderDemoDeliverable(content) {
   }
   return parsed.frame === computeRenderDemoArtifact() ? 1 : 0;
 }
-function referencePlaceholder6(spec) {
+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: spec.taskType
+    taskType: spec2.taskType
   });
 }
-var defaultRunJob2 = (spec) => Promise.resolve(
-  spec.metadata.demo === RENDER_DEMO_MARKER ? solveRenderDemo() : referencePlaceholder6(spec)
+var defaultRunJob2 = (spec2) => Promise.resolve(
+  spec2.metadata.demo === RENDER_DEMO_MARKER ? solveRenderDemo() : referencePlaceholder6(spec2)
 );
 function createRenderAdapter(config = {}) {
   const service = config.service ?? DEFAULT_SERVICE2;
@@ -1662,9 +1811,9 @@ function createRenderAdapter(config = {}) {
     id: service,
     capabilities,
     healthCheck: checkHealth,
-    async execute(spec) {
+    async execute(spec2) {
       const budgetRender = await swap(taskBudgetMicroUsdc);
-      const content = await runJob(spec, budgetRender);
+      const content = await runJob(spec2, budgetRender);
       const contentHash = sha256Hex5(content);
       const proofUri = await pin(content);
       return {
@@ -1691,15 +1840,15 @@ function sha256Hex6(content) {
 var LCG_MULT = 1103515245n;
 var LCG_INC = 12345n;
 var LCG_MOD = 1n << 31n;
-function readComputeParams(spec) {
-  const rawSeed = spec.metadata.seed;
-  const rawSteps = spec.metadata.steps;
+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 = (spec) => {
-  const { seed, steps } = readComputeParams(spec);
+var reproduceGensynCompute = (spec2) => {
+  const { seed, steps } = readComputeParams(spec2);
   const states = [];
   let x = BigInt(seed) % LCG_MOD;
   if (x < 0n) {
@@ -1721,10 +1870,10 @@ function commitmentOf(base) {
     )
   );
 }
-function buildReeProof(spec, exec, content) {
+function buildReeProof(spec2, exec, content) {
   const base = {
     scheme: GENSYN_REE_SCHEME,
-    specHash: sha256Hex6(canonicalize(spec)),
+    specHash: sha256Hex6(canonicalize(spec2)),
     outputHash: sha256Hex6(content),
     steps: exec.steps,
     transcriptHash: sha256Hex6(canonicalize(exec.states))
@@ -1831,11 +1980,11 @@ function createGensynAdapter(config = {}) {
     id: GENSYN_ADAPTER_ID,
     capabilities,
     healthCheck: checkHealth,
-    async execute(spec) {
-      const exec = runCompute(spec);
+    async execute(spec2) {
+      const exec = runCompute(spec2);
       const content = gensynDeliverable(exec);
       const contentHash = sha256Hex6(content);
-      const proof = buildReeProof(spec, exec, content);
+      const proof = buildReeProof(spec2, exec, content);
       const proofUri = await pin(content);
       return {
         content,
@@ -2010,21 +2159,21 @@ function solveZkmlDemo() {
     output: { label: "cat", confidence: 0.98 }
   });
 }
-function referencePlaceholderOutput(spec) {
+function referencePlaceholderOutput(spec2) {
   return {
     content: canonicalize({
       note: "reference stub - replace the runInference port with a real zk-verified inference call.",
-      taskType: spec.taskType
+      taskType: spec2.taskType
     }),
     modelCommitment: sha256Hex7("zkml-reference-stub-model"),
-    inputCommitment: sha256Hex7(canonicalize(spec))
+    inputCommitment: sha256Hex7(canonicalize(spec2))
   };
 }
-var defaultRunInference = (spec) => spec.metadata.demo === ZKML_DEMO_MARKER ? {
+var defaultRunInference = (spec2) => spec2.metadata.demo === ZKML_DEMO_MARKER ? {
   content: solveZkmlDemo(),
   modelCommitment: DEMO_MODEL_COMMITMENT,
   inputCommitment: DEMO_INPUT_COMMITMENT
-} : referencePlaceholderOutput(spec);
+} : referencePlaceholderOutput(spec2);
 function createZkmlAdapter(config = {}) {
   const id = config.id ?? ZKML_ADAPTER_ID;
   const capabilities = config.capabilities ?? [...ZKML_CAPABILITIES];
@@ -2039,10 +2188,10 @@ function createZkmlAdapter(config = {}) {
   return {
     id,
     capabilities,
-    async execute(spec) {
-      const output = await runInference(spec);
+    async execute(spec2) {
+      const output = await runInference(spec2);
       const contentHash = sha256Hex7(output.content);
-      const proof = await prove({ spec, output, outputHash: contentHash });
+      const proof = await prove({ spec: spec2, output, outputHash: contentHash });
       const proofUri = await pin(proof);
       return {
         content: output.content,
@@ -2069,6 +2218,7 @@ export {
   ApiClient,
   ENABLED_RAILS,
   Escro,
+  EscroConfirmError,
   EscroError,
   EscroRailNotEnabledError,
   EscrowNotFoundError,