@unicitylabs/sphere-sdk 0.14.5 → 0.14.6

package/dist/token-engine/index.js

@@ -314,7 +314,18 @@ function pause(ms, signal) {
     );
   });
 }
-async function awaitProofBounded(deps, transaction, external) {
+async function retryTransient(attempt, signal, intervalMs) {
+  for (; ; ) {
+    try {
+      return await attempt();
+    } catch (err) {
+      if (signal.aborted) throw err;
+      if (!isTransientGatewayError(err)) throw err;
+      await pause(intervalMs, signal);
+    }
+  }
+}
+function certificationDeadline(timeoutMs, external, label) {
   const controller = new AbortController();
   const relayAbort = () => {
     controller.abort(external?.reason);
@@ -324,47 +335,29 @@ async function awaitProofBounded(deps, transaction, external) {
     else external.addEventListener("abort", relayAbort, { once: true });
   }
   const timer = setTimeout(() => {
-    controller.abort(
-      new SphereError(
-        `inclusion proof not confirmed within ${String(deps.timeoutMs)} ms`,
-        "AGGREGATOR_ERROR"
-      )
-    );
-  }, deps.timeoutMs);
-  try {
-    for (; ; ) {
-      try {
-        return await waitInclusionProof(
-          deps.client,
-          deps.trustBase,
-          deps.predicateVerifier,
-          transaction,
-          controller.signal,
-          deps.intervalMs
-        );
-      } catch (err) {
-        if (controller.signal.aborted) throw err;
-        if (!isTransientGatewayError(err)) throw err;
-        await pause(deps.intervalMs, controller.signal);
-      }
+    controller.abort(new SphereError(`${label} within ${String(timeoutMs)} ms`, "AGGREGATOR_ERROR"));
+  }, timeoutMs);
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clearTimeout(timer);
+      external?.removeEventListener("abort", relayAbort);
     }
-  } finally {
-    clearTimeout(timer);
-    external?.removeEventListener("abort", relayAbort);
-  }
+  };
 }
-
-// core/uuid.ts
-function randomUUID() {
-  const c = globalThis.crypto;
-  if (typeof c !== "undefined" && typeof c.randomUUID === "function") {
-    return c.randomUUID();
-  }
-  const b = c.getRandomValues(new Uint8Array(16));
-  b[6] = b[6] & 15 | 64;
-  b[8] = b[8] & 63 | 128;
-  const h = Array.from(b, (x) => x.toString(16).padStart(2, "0"));
-  return `${h[0]}${h[1]}${h[2]}${h[3]}-${h[4]}${h[5]}-${h[6]}${h[7]}-${h[8]}${h[9]}-${h[10]}${h[11]}${h[12]}${h[13]}${h[14]}${h[15]}`;
+async function awaitProofBounded(deps, transaction, signal) {
+  return retryTransient(
+    () => waitInclusionProof(
+      deps.client,
+      deps.trustBase,
+      deps.predicateVerifier,
+      transaction,
+      signal,
+      deps.intervalMs
+    ),
+    signal,
+    deps.intervalMs
+  );
 }
 
 // token-engine/errors.ts
@@ -406,6 +399,34 @@ var CheckpointTrustbaseMismatchError = class extends SphereError {
   }
 };
 
+// token-engine/certification-outcome.ts
+function certificationFailure(err, failLabel, submitError, submitRejectedCleanly) {
+  if (err instanceof Error && err.message === `Invalid inclusion proof status: ${InclusionProofVerificationStatus.TRANSACTION_HASH_MISMATCH}`) {
+    return new TransferConflictError(
+      `${failLabel}: the source state was already consumed by a different transaction (lost race \u2014 abort this intent and re-plan under a new transferId)`,
+      err
+    );
+  }
+  if (submitRejectedCleanly) return submitError;
+  return new ProofUnconfirmedError(
+    `${failLabel}: certification unconfirmed \u2014 the source spend may be on-chain; keep the intent open and resume under the same transferId`,
+    submitError ?? err
+  );
+}
+
+// core/uuid.ts
+function randomUUID() {
+  const c = globalThis.crypto;
+  if (typeof c !== "undefined" && typeof c.randomUUID === "function") {
+    return c.randomUUID();
+  }
+  const b = c.getRandomValues(new Uint8Array(16));
+  b[6] = b[6] & 15 | 64;
+  b[8] = b[8] & 63 | 128;
+  const h = Array.from(b, (x) => x.toString(16).padStart(2, "0"));
+  return `${h[0]}${h[1]}${h[2]}${h[3]}-${h[4]}${h[5]}-${h[6]}${h[7]}-${h[8]}${h[9]}-${h[10]}${h[11]}${h[12]}${h[13]}${h[14]}${h[15]}`;
+}
+
 // token-engine/token-blob.ts
 var TOKEN_BLOB_TAG = 39051n;
 var TOKEN_BLOB_VERSION = 1;
@@ -1348,10 +1369,28 @@ var SphereTokenEngine = class {
    *                                   failure, not a resume case).
    */
   async submitAndAwaitProof(certificationData, transaction, failLabel, failCode, options) {
+    const deadline = certificationDeadline(
+      this.proofTimeoutMs,
+      options?.signal,
+      `${failLabel}: not certified`
+    );
+    try {
+      return await this.submitThenProve(certificationData, transaction, failLabel, failCode, deadline.signal);
+    } finally {
+      deadline.dispose();
+    }
+  }
+  /** One certification attempt under one deadline: the metered submit retries
+   *  transient answers instead of falling through to a proof that cannot exist. */
+  async submitThenProve(certificationData, transaction, failLabel, failCode, signal) {
     let submitError = null;
     let submitRejectedCleanly = false;
     try {
-      const response = await this.deps.client.submitCertificationRequest(certificationData);
+      const response = await retryTransient(
+        () => this.deps.client.submitCertificationRequest(certificationData),
+        signal,
+        this.deps.proofPollIntervalMs ?? DEFAULT_PROOF_POLL_INTERVAL_MS
+      );
       if (response.status !== CertificationStatus.SUCCESS) {
         submitError = new SphereError(`${failLabel}: ${response.status}`, failCode);
         submitRejectedCleanly = CLEAN_REJECT_STATUSES.has(response.status);
@@ -1365,33 +1404,21 @@ var SphereTokenEngine = class {
           client: this.deps.client,
           trustBase: this.deps.trustBase,
           predicateVerifier: this.deps.predicateVerifier,
-          timeoutMs: this.proofTimeoutMs,
           intervalMs: this.deps.proofPollIntervalMs ?? DEFAULT_PROOF_POLL_INTERVAL_MS
           // #683
         },
         transaction,
-        options?.signal
+        signal
       );
     } catch (err) {
-      if (err instanceof Error && err.message === `Invalid inclusion proof status: ${InclusionProofVerificationStatus.TRANSACTION_HASH_MISMATCH}`) {
-        throw new TransferConflictError(
-          `${failLabel}: the source state was already consumed by a different transaction (lost race \u2014 abort this intent and re-plan under a new transferId)`,
-          err
-        );
-      }
-      if (submitRejectedCleanly) throw submitError;
-      throw new ProofUnconfirmedError(
-        `${failLabel}: certification unconfirmed \u2014 the source spend may be on-chain; keep the intent open and resume under the same transferId`,
-        submitError ?? err
-      );
+      throw certificationFailure(err, failLabel, submitError, submitRejectedCleanly);
     }
   }
   /**
-   * One inclusion-proof wait, with the deadline OWNED here (#739). The SDK's own
-   * default deadline is unreliable — see lateDeliveringSignal — and a lost one
-   * means an op that never settles, which also wedges PaymentsFacade.stop().
-   * A deadline hit throws, and the caller maps that to ProofUnconfirmedError
-   * (keep-open), which is the correct posture: the spend may be on-chain.
+   * One inclusion-proof wait, with the deadline OWNED here (#739) so it is bounded
+   * and configurable rather than the SDK's fixed default. A hit throws, and the
+   * caller maps it to ProofUnconfirmedError (keep-open) — the correct posture,
+   * since the spend may be on-chain.
    */
   /** Fail fast if this engine's key does not own the token's current state. */
   assertOwned(token) {