@settlemint/dalp-sdk 3.1.11-main.33723791073 → 3.1.11-main.33724992663

package/README.md

@@ -63,6 +63,15 @@ id and the status URL. That is not a failed write: the transaction is still on
 its way to a block, and resubmitting is a second transfer. `settlementTimeoutMs`
 sets the bound per client, and a call may override it.
 
+A write the funding gate parks on an operator payment is stopped, not slow. The
+status row carries the open ask as `activeRequirement`, and every read that
+reports one restarts the bound, so the wait outlasts the pause and resolves
+with the settled record once the ask is paid. When an ask lapses unpaid the
+platform fails the request, and that failure is what the client reports. A
+caller that cannot wait that long ends the wait through `signal`, and
+`waitForTransaction` takes `holdWhilePaused: false` to end on the first parked
+status with reason `funding-paused` instead.
+
 ### Conditional requests and ETags
 
 The client reuses a held body when the server answers a matching ETag with 304.

package/dist/auth.js

@@ -2,7 +2,7 @@ import {
   SDK_USER_AGENT,
   createCookieStoreFetch,
   makeCookieStore
-} from "./chunk-tm3g9mh4.js";
+} from "./chunk-g5ch7ns0.js";
 import {
   normalizeDalpBaseUrl,
   secret,

package/dist/bundler.js

@@ -1,8 +1,9 @@
 import {
   createDalpClient
-} from "./chunk-wk8e0p9d.js";
+} from "./chunk-vw4bccje.js";
 import"./chunk-f4t1bm86.js";
-import"./chunk-mrfkqrht.js";
+import"./chunk-gpezyfx3.js";
+import"./chunk-fjnq61hj.js";
 import"./chunk-0m709wz4.js";
 import"./chunk-h12fatty.js";
 import"./chunk-y0d2c7kp.js";

package/dist/chunk-fjnq61hj.js

@@ -0,0 +1,11 @@
+// src/reads-as-funding-paused.ts
+function readsAsFundingPaused(status) {
+  if (status === null || typeof status !== "object") {
+    return false;
+  }
+  const requirement = Reflect.get(status, "activeRequirement");
+  return requirement !== undefined && requirement !== null;
+}
+var PAUSED_POLL_INTERVAL_MAX_MS = 30000;
+
+export { readsAsFundingPaused, PAUSED_POLL_INTERVAL_MAX_MS };

package/dist/{chunk-tm3g9mh4.js → chunk-g5ch7ns0.js}

@@ -102,7 +102,7 @@ function createCookieStoreFetch(cookieStore, fetchImpl = globalThis.fetch) {
 // package.json
 var package_default = {
   name: "@settlemint/dalp-sdk",
-  version: "3.1.11-main.33723791073",
+  version: "3.1.11-main.33724992663",
   private: false,
   description: "Fully typed SDK for the DALP tokenization platform API",
   homepage: "https://settlemint.com",

package/dist/{chunk-mrfkqrht.js → chunk-gpezyfx3.js}

@@ -1,3 +1,7 @@
+import {
+  PAUSED_POLL_INTERVAL_MAX_MS,
+  readsAsFundingPaused
+} from "./chunk-fjnq61hj.js";
 import {
   Secret,
   normalizeDalpBaseUrl,
@@ -749,13 +753,14 @@ async function resolveSettlement(transport, payload, options, now = Date.now, sl
     return payload;
   }
   const timeoutMs = options?.settlementTimeoutMs ?? transport.settlementTimeoutMs ?? DEFAULT_SETTLEMENT_TIMEOUT_MS;
-  const deadline = now() + timeoutMs;
+  let deadline = now() + timeoutMs;
+  let pollIntervalMs = POLL_INTERVAL_MS;
   const statusUrl = handle.statusUrl.startsWith("http") ? handle.statusUrl : `${transport.baseUrl}${handle.statusUrl}`;
   for (;; ) {
     if (now() >= deadline) {
       throw new SettlementTimeoutError(handle.transactionId, handle.statusUrl, timeoutMs);
     }
-    await sleep(POLL_INTERVAL_MS);
+    await sleep(pollIntervalMs);
     const response = await transport.fetch(statusUrl, {
       method: "GET",
       headers: callHeaders(transport, options),
@@ -771,6 +776,12 @@ async function resolveSettlement(transport, payload, options, now = Date.now, sl
     if (state !== undefined && FAILURE_STATES.has(state)) {
       throw new SettlementFailedError(handle.transactionId, state, readString2(body, "errorMessage"));
     }
+    if (readsAsFundingPaused(body)) {
+      deadline = now() + timeoutMs;
+      pollIntervalMs = Math.min(pollIntervalMs * 2, PAUSED_POLL_INTERVAL_MAX_MS);
+    } else {
+      pollIntervalMs = POLL_INTERVAL_MS;
+    }
   }
 }
 

package/dist/{chunk-wk8e0p9d.js → chunk-vw4bccje.js}

@@ -8,7 +8,7 @@ import {
   createTransport,
   sendRequest,
   streamRequest
-} from "./chunk-mrfkqrht.js";
+} from "./chunk-gpezyfx3.js";
 import {
   data
 } from "./chunk-0m709wz4.js";

package/dist/effect.js

@@ -8,7 +8,8 @@ import {
   queryKeyFor,
   sendRequest,
   streamRequest
-} from "./chunk-mrfkqrht.js";
+} from "./chunk-gpezyfx3.js";
+import"./chunk-fjnq61hj.js";
 import {
   data
 } from "./chunk-0m709wz4.js";

package/dist/index.js

@@ -3,10 +3,10 @@ import {
   SDK_VERSION,
   createCookieStoreFetch,
   makeCookieStore
-} from "./chunk-tm3g9mh4.js";
+} from "./chunk-g5ch7ns0.js";
 import {
   createDalpClient
-} from "./chunk-wk8e0p9d.js";
+} from "./chunk-vw4bccje.js";
 import"./chunk-f4t1bm86.js";
 import {
   DEFAULT_SETTLEMENT_TIMEOUT_MS,
@@ -17,7 +17,8 @@ import {
   findDalpSdkError,
   isDalpApiError,
   makeDalpApiError
-} from "./chunk-mrfkqrht.js";
+} from "./chunk-gpezyfx3.js";
+import"./chunk-fjnq61hj.js";
 import"./chunk-0m709wz4.js";
 import {
   SECRET_REDACTION_MARKER,

package/dist/proxy/settlement.d.ts

@@ -12,14 +12,30 @@
  * not a failed mutation, and reporting it as one would tell a caller their
  * write was rejected when it is still queued. `SettlementTimeoutError` carries
  * `transactionId` and `statusUrl` so the caller can resume the wait through
- * `./wait-for-transaction` or read the status route directly.
+ * `../wait-for-transaction` or read the status route directly.
+ *
+ * The bound measures the platform's progress, not the calendar. A write the
+ * funding gate has parked on an operator payment is stopped, not slow: the
+ * status row reports the open ask as `activeRequirement` on every read, and no
+ * progress is expected until the ask is paid. Every read that reports one
+ * restarts the bound, so a parked write is never reported as a timeout and a
+ * resumed write gets its whole budget back. What ends a pause is the payment
+ * arriving or the platform failing the request when the ask lapses, and both
+ * reach this loop as status. A caller that cannot wait that long ends the
+ * wait through its `signal`. While the write is parked the reads slow down,
+ * because the gate resumes it at its own cadence and the status route pays
+ * for every read.
  *
  * @module
  */
 import { DalpSdkError } from "../errors/sdk-error.ts";
 import type { CallOptions } from "./builder.ts";
 import { type Transport } from "./transport.ts";
-/** Default bound on how long the SDK follows a handle before giving it back. */
+/**
+ * Default bound on how long the SDK follows a handle while the platform is
+ * making progress. Time the write spends parked on a funding ask does not
+ * count against it.
+ */
 export declare const DEFAULT_SETTLEMENT_TIMEOUT_MS = 120000;
 /** Raised when the wait runs out while the work is still queued. */
 export declare class SettlementTimeoutError extends DalpSdkError {
@@ -44,6 +60,8 @@ export declare function readHandle(payload: unknown): SettlementHandle | undefin
  *
  * Returns the settled payload the status route reports. Raises
  * {@link SettlementFailedError} on a terminal failure and
- * {@link SettlementTimeoutError} when the bound elapses first.
+ * {@link SettlementTimeoutError} when the bound elapses first. The bound
+ * restarts on every status read that reports an open funding ask, so it never
+ * elapses while the write is parked on a payment.
  */
 export declare function resolveSettlement(transport: Transport, payload: unknown, options: CallOptions | undefined, now?: () => number, sleep?: (ms: number) => Promise<void>): Promise<unknown>;

package/dist/react-query.js

@@ -2,7 +2,8 @@ import {
   UI_SETTLEMENT_TIMEOUT_MS,
   canonicalize,
   queryKeyFor
-} from "./chunk-mrfkqrht.js";
+} from "./chunk-gpezyfx3.js";
+import"./chunk-fjnq61hj.js";
 import"./chunk-h12fatty.js";
 import"./chunk-y0d2c7kp.js";
 export {

package/dist/reads-as-funding-paused.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Whether a transaction status row says the write is parked on an operator's
+ * gas funding payment.
+ *
+ * The funding gate holds the queue state of a write it pauses, so `status`
+ * does not move while the operator is being asked for money. The open ask,
+ * published as `activeRequirement` on the status route and its stream, is the
+ * only field that says the write is waiting on a payment rather than on the
+ * chain. The wire declares it absent or null when there is no ask.
+ */
+export declare function readsAsFundingPaused(status: unknown): boolean;
+/**
+ * Longest gap between two status reads of a parked write.
+ *
+ * A write waiting on a payment moves at the funding gate's own cadence, which
+ * grows to minutes, so reading it faster than this learns nothing and costs
+ * the status route a request for every parked write on every second of a pause
+ * that can last a day.
+ */
+export declare const PAUSED_POLL_INTERVAL_MAX_MS = 30000;

package/dist/wait-for-transaction.d.ts

@@ -15,6 +15,8 @@ export interface WaitForTransactionStatus {
     readonly errorMessage: string | null;
     readonly contractError?: WaitForTransactionContractError | null;
     readonly result?: WaitForTransactionResult;
+    /** The open funding ask a write parked by the funding gate is waiting on. */
+    readonly activeRequirement?: EvmTransactionStatusOutput["activeRequirement"];
 }
 /** Kind-scoped terminal result from the generated transaction status contract. */
 export type WaitForTransactionResult = NonNullable<EvmTransactionStatusOutput["result"]>;
@@ -26,11 +28,20 @@ export interface WaitForTransactionOptions {
     readonly pollIntervalMs?: number;
     readonly signal?: AbortSignal;
     readonly onStatus?: (status: WaitForTransactionStatus) => void;
+    /**
+     * Whether the wait outlasts a funding pause. True, the default, restarts the
+     * timeout on every status that reports an open funding ask, so the wait ends
+     * only when the ask is paid or the platform fails the request. False ends
+     * the wait on the first such status with reason `funding-paused`, for a
+     * caller that shows the write as pending and lets the payment land on its
+     * own time.
+     */
+    readonly holdWhilePaused?: boolean;
     readonly now?: () => number;
     readonly sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
     readonly readStatus?: (transactionId: string, signal?: AbortSignal) => Promise<WaitForTransactionStatus>;
 }
-export type TransactionWaitFailureReason = "terminal-failure" | "timeout" | "aborted";
+export type TransactionWaitFailureReason = "terminal-failure" | "timeout" | "aborted" | "funding-paused";
 export declare class DalpTransactionWaitError extends Error {
     readonly code = "sdk.transaction.WAIT_FAILED";
     readonly category: "operational";
@@ -44,5 +55,13 @@ export declare class DalpTransactionWaitError extends Error {
     get retryable(): boolean;
 }
 export declare const isDalpTransactionWaitError: (error: unknown) => error is DalpTransactionWaitError;
-/** Poll transaction status until a terminal verdict, timeout, or abort. */
+/**
+ * Poll transaction status until a terminal verdict, timeout, or abort.
+ *
+ * The timeout measures the platform's progress. A status that reports an
+ * open funding ask restarts it, so a write parked on an operator payment is
+ * never reported as a timeout and a resumed write gets its whole budget back.
+ * `holdWhilePaused: false` ends the wait on that status instead. The
+ * `elapsedMs` a timeout carries is the whole wait, pauses included.
+ */
 export declare function waitForTransaction(client: DalpClient, transactionId: string, options?: WaitForTransactionOptions): Promise<WaitForTransactionSuccess>;

package/dist/wait-for-transaction.js

@@ -1,3 +1,8 @@
+import {
+  PAUSED_POLL_INTERVAL_MAX_MS,
+  readsAsFundingPaused
+} from "./chunk-fjnq61hj.js";
+
 // src/wait-for-transaction.ts
 var failedStates = new Set(["FAILED", "DEAD_LETTER", "CANCELLED"]);
 var isWaitForTransactionSuccess = (status) => status.status === "COMPLETED";
@@ -15,6 +20,8 @@ class DalpTransactionWaitError extends Error {
       message = `Transaction ${transactionId} reached terminal state ${lastStatus?.status ?? "UNKNOWN"}`;
     } else if (reason === "timeout") {
       message = `Transaction ${transactionId} did not reach a terminal state within ${elapsedMs ?? 0}ms`;
+    } else if (reason === "funding-paused") {
+      message = `Transaction ${transactionId} is paused waiting for a gas funding payment`;
     } else {
       message = `Transaction status observation was aborted for transaction ${transactionId}`;
     }
@@ -32,7 +39,7 @@ class DalpTransactionWaitError extends Error {
     return this.lastStatus?.subStatus ?? null;
   }
   get retryable() {
-    return this.reason === "timeout";
+    return this.reason === "timeout" || this.reason === "funding-paused";
   }
 }
 var isDalpTransactionWaitError = (error) => error instanceof DalpTransactionWaitError;
@@ -62,16 +69,18 @@ async function waitForTransaction(client, transactionId, options = {}) {
   const now = options.now ?? Date.now;
   const sleep = options.sleep ?? defaultSleep;
   const readStatus = options.readStatus ?? routeStatusReader(client);
-  const startedAt = now();
+  const holdWhilePaused = options.holdWhilePaused ?? true;
+  const waitStartedAt = now();
+  let budgetStartedAt = waitStartedAt;
+  let pollDelayMs = pollIntervalMs;
   let lastStatus;
   const isAborted = () => options.signal?.aborted === true;
   while (true) {
     if (isAborted()) {
       throw new DalpTransactionWaitError(transactionId, "aborted", lastStatus);
     }
-    const elapsed = now() - startedAt;
-    if (elapsed >= timeoutMs) {
-      throw new DalpTransactionWaitError(transactionId, "timeout", lastStatus, elapsed);
+    if (now() - budgetStartedAt >= timeoutMs) {
+      throw new DalpTransactionWaitError(transactionId, "timeout", lastStatus, now() - waitStartedAt);
     }
     try {
       lastStatus = await readStatus(transactionId, options.signal);
@@ -88,8 +97,17 @@ async function waitForTransaction(client, transactionId, options = {}) {
     if (isWaitForTransactionSuccess(lastStatus)) {
       return lastStatus;
     }
+    if (readsAsFundingPaused(lastStatus)) {
+      if (!holdWhilePaused) {
+        throw new DalpTransactionWaitError(transactionId, "funding-paused", lastStatus, now() - waitStartedAt);
+      }
+      budgetStartedAt = now();
+      pollDelayMs = Math.min(pollDelayMs * 2, Math.max(pollIntervalMs, PAUSED_POLL_INTERVAL_MAX_MS));
+    } else {
+      pollDelayMs = pollIntervalMs;
+    }
     try {
-      await sleep(Math.min(pollIntervalMs, Math.max(0, timeoutMs - (now() - startedAt))), options.signal);
+      await sleep(Math.min(pollDelayMs, Math.max(0, timeoutMs - (now() - budgetStartedAt))), options.signal);
     } catch {
       throw new DalpTransactionWaitError(transactionId, "aborted", lastStatus);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@settlemint/dalp-sdk",
-  "version": "3.1.11-main.33723791073",
+  "version": "3.1.11-main.33724992663",
   "private": false,
   "description": "Fully typed SDK for the DALP tokenization platform API",
   "homepage": "https://settlemint.com",