@lunora/x402 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/charge/index.d.mts

@@ -1,5 +1,5 @@
-import { F as FacilitatorConfig, c as X402ChargeConfig, f as X402Price } from "../packem_shared/config.d-D8gKQLAq.mjs";
-export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, type a as EvmAddress, type P as PaymentEventRow, type d as X402Network, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2, x as toPaymentEventRow, y as toReceipt } from "../packem_shared/config.d-D8gKQLAq.mjs";
+import { F as FacilitatorConfig, c as X402ChargeConfig, f as X402Price } from "../packem_shared/config.d-B-NYmHgG.mjs";
+export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, type a as EvmAddress, type P as PaymentEventRow, type d as X402Network, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2, x as toPaymentEventRow, y as toReceipt } from "../packem_shared/config.d-B-NYmHgG.mjs";
 import { HTTPFacilitatorClient } from '@x402/core/server';
 import { RouteConfig } from '@x402/core/http';
 import '@x402/evm';
@@ -7,68 +7,106 @@ import '@x402/svm';
 import '@x402/core/client';
 import '@x402/core/types';
 /**
-* Build an `@x402/core` facilitator client from Lunora's {@link FacilitatorConfig}.
-*
-* `config.headers` (e.g. a CDP bearer token) are applied to every facilitator
-* call — `@x402/core` splits auth per endpoint (`verify` / `settle` /
-* `supported`), so the same header map is handed to each. With no config the
-* client points at the public {@link resolveFacilitatorUrl default} and sends no
-* auth headers.
-* @experimental
-*/
+ * Build an `@x402/core` facilitator client from Lunora's {@link FacilitatorConfig}.
+ *
+ * `config.headers` (e.g. a CDP bearer token) are applied to every facilitator
+ * call — `@x402/core` splits auth per endpoint (`verify` / `settle` /
+ * `supported`), so the same header map is handed to each. With no config the
+ * client points at the public {@link resolveFacilitatorUrl default} and sends no
+ * auth headers.
+ * @experimental
+ */
 declare const createFacilitatorClient: (config?: FacilitatorConfig) => HTTPFacilitatorClient;
 /**
-* A handler shaped like a Lunora HTTP action: `(context, request) => Response`.
-* @experimental
-*/
+ * A handler shaped like a Lunora HTTP action: `(context, request) => Response`.
+ * @experimental
+ */
 type HttpActionHandler<Context> = (context: Context, request: Request) => Promise<Response> | Response;
 /**
-* Gate `handler` behind an x402 paywall described by `config`. Returns a handler
-* of the same shape, ready to pass to `httpAction`.
-* @experimental
-*/
+ * Gate `handler` behind an x402 paywall described by `config`. Returns a handler
+ * of the same shape, ready to pass to `httpAction`.
+ * @experimental
+ */
 declare const withX402: <Context>(config: X402ChargeConfig, handler: HttpActionHandler<Context>) => HttpActionHandler<Context>;
 /**
-* Runs the protected resource handler, producing the Response to gate.
-* @experimental
-*/
+ * Runs the protected resource handler, producing the Response to gate.
+ * @experimental
+ */
 type ChargeHandler = () => Promise<Response> | Response;
 /**
-* A prepared, initialised paywall. Build once (it fetches facilitator support), reuse per request.
-* @experimental
-*/
+ * Per-request platform seams `handle` can use, beyond the request/handler pair.
+ * @experimental
+ */
+interface ChargeHandlerDeps {
+  /**
+   * Keep background work (the receipt sink) alive past the response — the
+   * request's `ctx.waitUntil`. Absent on paths with no platform execution
+   * context reaching the middleware (e.g. today's HTTP-action rail).
+   */
+  readonly waitUntil?: (promise: Promise<unknown>) => void;
+}
+/**
+ * A prepared, initialised paywall. Build once (it fetches facilitator support), reuse per request.
+ * @experimental
+ */
 interface ChargeMiddleware {
   /** Gate `request`: challenge / verify / settle around `runHandler`. */
-  handle: (request: Request, runHandler: ChargeHandler) => Promise<Response>;
+  handle: (request: Request, runHandler: ChargeHandler, deps?: ChargeHandlerDeps) => Promise<Response>;
 }
 /**
-* Route metadata a caller can layer onto the generated catch-all route. The
-* procedure gate sets `resource` to the `functionPath` so the x402 challenge
-* names the paid function (x402 core falls back to the request URL otherwise —
-* every RPC POSTs to the same `/_lunora/rpc`, so the URL can't tell two paid
-* procedures apart).
-* @experimental
-*/
+ * Route metadata a caller can layer onto the generated catch-all route. The
+ * procedure gate sets `resource` to the `functionPath` so the x402 challenge
+ * names the paid function (x402 core falls back to the request URL otherwise —
+ * every RPC POSTs to the same `/_lunora/rpc`, so the URL can't tell two paid
+ * procedures apart).
+ * @experimental
+ */
 type ChargeRouteOverrides = Pick<RouteConfig, "description" | "resource">;
 /**
-* Build and initialise a {@link ChargeMiddleware} for `config`. Fetches
-* facilitator support once (via `initialize()`), so call this once per config
-* and reuse the result across requests. `routeOverrides` layers extra route
-* metadata (e.g. `resource`) onto the generated catch-all route.
-* @experimental
-*/
-declare const createChargeMiddleware: (config: X402ChargeConfig, routeOverrides?: ChargeRouteOverrides) => Promise<ChargeMiddleware>;
+ * Behaviour knobs for {@link createChargeMiddleware} beyond route metadata.
+ * @experimental
+ */
+interface ChargeMiddlewareOptions {
+  /**
+   * Settle the verified payment **before** dispatching `runHandler`, instead
+   * of after. Use this for a mutation/procedure gate: a settlement failure
+   * then means the handler never runs at all, so a paid mutation's writes can
+   * never be committed without payment (the free-execution gap X402-04
+   * closes). Once settlement succeeds the payment is final (on-chain) — a
+   * handler failure after that point is a normal application error, not a
+   * payment to unwind: there is nothing left to cancel, so it is not caught
+   * here and simply propagates.
+   *
+   * Default `false` (settle-after, the historical behaviour): the handler's
+   * response is passed to settlement as transport context (`responseHeaders`
+   * — read by some schemes for settlement overrides), and a handler throw
+   * still releases the verified-but-unsettled payment via
+   * `cancellationDispatcher.cancel`. Because settlement can still fail after
+   * the handler already ran on this path, `.x402()` handlers gated this way
+   * MUST be idempotent or compensatable — see the `@lunora/x402` charge docs.
+   */
+  readonly settleBeforeHandler?: boolean;
+}
+/**
+ * Build and initialise a {@link ChargeMiddleware} for `config`. Fetches
+ * facilitator support once (via `initialize()`), so call this once per config
+ * and reuse the result across requests. `routeOverrides` layers extra route
+ * metadata (e.g. `resource`) onto the generated catch-all route; `options`
+ * controls settlement ordering (see {@link ChargeMiddlewareOptions}).
+ * @experimental
+ */
+declare const createChargeMiddleware: (config: X402ChargeConfig, routeOverrides?: ChargeRouteOverrides, options?: ChargeMiddlewareOptions) => Promise<ChargeMiddleware>;
 /**
-* Charge config for the procedure gate: the worker-level settlement vocabulary
-* (network, recipient, facilitator) minus `price` — price is per-procedure and
-* arrives with each {@link X402ProcedureSpec}.
-* @experimental
-*/
+ * Charge config for the procedure gate: the worker-level settlement vocabulary
+ * (network, recipient, facilitator) minus `price` — price is per-procedure and
+ * arrives with each {@link X402ProcedureSpec}.
+ * @experimental
+ */
 type X402ProcedureChargeConfig = Omit<X402ChargeConfig, "price">;
 /**
-* The per-RPC charge spec the runtime passes the gate for each paid dispatch.
-* @experimental
-*/
+ * The per-RPC charge spec the runtime passes the gate for each paid dispatch.
+ * @experimental
+ */
 interface X402ProcedureSpec {
   /** The `file:function` id of the paid procedure; becomes the x402 challenge `resource`. */
   readonly functionPath: string;
@@ -76,20 +114,26 @@ interface X402ProcedureSpec {
   readonly price: X402Price;
 }
 /**
-* Gate one paid RPC. Returns a real `402` + `PAYMENT-REQUIRED` challenge when the
-* request is unpaid, or the dispatched response (with `X-PAYMENT-RESPONSE`
-* attached) once the client's `X-PAYMENT` is verified and settled. `dispatch`
-* runs the actual shard forward — it is only invoked after payment is verified.
-* @experimental
-*/
-type X402ProcedureChargeGate = (request: Request, spec: X402ProcedureSpec, dispatch: () => Promise<Response>) => Promise<Response>;
+ * Gate one paid RPC. Returns a real `402` + `PAYMENT-REQUIRED` challenge when the
+ * request is unpaid, or the dispatched response (with `X-PAYMENT-RESPONSE`
+ * attached) once the client's `X-PAYMENT` is verified and settled. `dispatch`
+ * runs the actual shard forward — settlement happens **before** `dispatch` is
+ * invoked (settle-first), so a settlement failure means the shard forward
+ * (the mutation's commit) never runs at all — no committed-but-unpaid write is
+ * possible. `deps.waitUntil`, when supplied (the request's `ctx.waitUntil`),
+ * keeps the opt-in receipt sink alive past the response.
+ * @experimental
+ */
+type X402ProcedureChargeGate = (request: Request, spec: X402ProcedureSpec, dispatch: () => Promise<Response>, deps?: ChargeHandlerDeps) => Promise<Response>;
 /**
-* Build the injectable procedure charge gate for `config`. One initialised
-* {@link ChargeMiddleware} is memoised per `functionPath` (each bakes that
-* function's price + `resource`), since `createChargeMiddleware` fetches
-* facilitator support on first use. A failed init is not cached, so a transient
-* facilitator outage retries on the next request.
-* @experimental
-*/
+ * Build the injectable procedure charge gate for `config`. One initialised
+ * {@link ChargeMiddleware} is memoised per `functionPath` (each bakes that
+ * function's price + `resource`), since `createChargeMiddleware` fetches
+ * facilitator support on first use. A failed init is not cached, so a transient
+ * facilitator outage retries on the next request. Settlement runs before
+ * `dispatch` (`settleBeforeHandler: true`) since `dispatch` commits the
+ * procedure's real mutation — see `createChargeMiddleware`'s `ChargeMiddlewareOptions`.
+ * @experimental
+ */
 declare const createProcedureChargeGate: (config: X402ProcedureChargeConfig) => X402ProcedureChargeGate;
-export { type ChargeHandler, type ChargeMiddleware, type ChargeRouteOverrides, type FacilitatorConfig, type HttpActionHandler, type X402ChargeConfig, type X402Price, type X402ProcedureChargeConfig, type X402ProcedureChargeGate, type X402ProcedureSpec, createChargeMiddleware, createFacilitatorClient, createProcedureChargeGate, withX402 };
+export { type ChargeHandler, type ChargeHandlerDeps, type ChargeMiddleware, type ChargeMiddlewareOptions, type ChargeRouteOverrides, type FacilitatorConfig, type HttpActionHandler, type X402ChargeConfig, type X402Price, type X402ProcedureChargeConfig, type X402ProcedureChargeGate, type X402ProcedureSpec, createChargeMiddleware, createFacilitatorClient, createProcedureChargeGate, withX402 };

package/dist/charge/index.d.ts

@@ -1,5 +1,5 @@
-import { F as FacilitatorConfig, c as X402ChargeConfig, f as X402Price } from "../packem_shared/config.d-D8gKQLAq.js";
-export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, type a as EvmAddress, type P as PaymentEventRow, type d as X402Network, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2, x as toPaymentEventRow, y as toReceipt } from "../packem_shared/config.d-D8gKQLAq.js";
+import { F as FacilitatorConfig, c as X402ChargeConfig, f as X402Price } from "../packem_shared/config.d-B-NYmHgG.js";
+export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, type a as EvmAddress, type P as PaymentEventRow, type d as X402Network, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2, x as toPaymentEventRow, y as toReceipt } from "../packem_shared/config.d-B-NYmHgG.js";
 import { HTTPFacilitatorClient } from '@x402/core/server';
 import { RouteConfig } from '@x402/core/http';
 import '@x402/evm';
@@ -7,68 +7,106 @@ import '@x402/svm';
 import '@x402/core/client';
 import '@x402/core/types';
 /**
-* Build an `@x402/core` facilitator client from Lunora's {@link FacilitatorConfig}.
-*
-* `config.headers` (e.g. a CDP bearer token) are applied to every facilitator
-* call — `@x402/core` splits auth per endpoint (`verify` / `settle` /
-* `supported`), so the same header map is handed to each. With no config the
-* client points at the public {@link resolveFacilitatorUrl default} and sends no
-* auth headers.
-* @experimental
-*/
+ * Build an `@x402/core` facilitator client from Lunora's {@link FacilitatorConfig}.
+ *
+ * `config.headers` (e.g. a CDP bearer token) are applied to every facilitator
+ * call — `@x402/core` splits auth per endpoint (`verify` / `settle` /
+ * `supported`), so the same header map is handed to each. With no config the
+ * client points at the public {@link resolveFacilitatorUrl default} and sends no
+ * auth headers.
+ * @experimental
+ */
 declare const createFacilitatorClient: (config?: FacilitatorConfig) => HTTPFacilitatorClient;
 /**
-* A handler shaped like a Lunora HTTP action: `(context, request) => Response`.
-* @experimental
-*/
+ * A handler shaped like a Lunora HTTP action: `(context, request) => Response`.
+ * @experimental
+ */
 type HttpActionHandler<Context> = (context: Context, request: Request) => Promise<Response> | Response;
 /**
-* Gate `handler` behind an x402 paywall described by `config`. Returns a handler
-* of the same shape, ready to pass to `httpAction`.
-* @experimental
-*/
+ * Gate `handler` behind an x402 paywall described by `config`. Returns a handler
+ * of the same shape, ready to pass to `httpAction`.
+ * @experimental
+ */
 declare const withX402: <Context>(config: X402ChargeConfig, handler: HttpActionHandler<Context>) => HttpActionHandler<Context>;
 /**
-* Runs the protected resource handler, producing the Response to gate.
-* @experimental
-*/
+ * Runs the protected resource handler, producing the Response to gate.
+ * @experimental
+ */
 type ChargeHandler = () => Promise<Response> | Response;
 /**
-* A prepared, initialised paywall. Build once (it fetches facilitator support), reuse per request.
-* @experimental
-*/
+ * Per-request platform seams `handle` can use, beyond the request/handler pair.
+ * @experimental
+ */
+interface ChargeHandlerDeps {
+  /**
+   * Keep background work (the receipt sink) alive past the response — the
+   * request's `ctx.waitUntil`. Absent on paths with no platform execution
+   * context reaching the middleware (e.g. today's HTTP-action rail).
+   */
+  readonly waitUntil?: (promise: Promise<unknown>) => void;
+}
+/**
+ * A prepared, initialised paywall. Build once (it fetches facilitator support), reuse per request.
+ * @experimental
+ */
 interface ChargeMiddleware {
   /** Gate `request`: challenge / verify / settle around `runHandler`. */
-  handle: (request: Request, runHandler: ChargeHandler) => Promise<Response>;
+  handle: (request: Request, runHandler: ChargeHandler, deps?: ChargeHandlerDeps) => Promise<Response>;
 }
 /**
-* Route metadata a caller can layer onto the generated catch-all route. The
-* procedure gate sets `resource` to the `functionPath` so the x402 challenge
-* names the paid function (x402 core falls back to the request URL otherwise —
-* every RPC POSTs to the same `/_lunora/rpc`, so the URL can't tell two paid
-* procedures apart).
-* @experimental
-*/
+ * Route metadata a caller can layer onto the generated catch-all route. The
+ * procedure gate sets `resource` to the `functionPath` so the x402 challenge
+ * names the paid function (x402 core falls back to the request URL otherwise —
+ * every RPC POSTs to the same `/_lunora/rpc`, so the URL can't tell two paid
+ * procedures apart).
+ * @experimental
+ */
 type ChargeRouteOverrides = Pick<RouteConfig, "description" | "resource">;
 /**
-* Build and initialise a {@link ChargeMiddleware} for `config`. Fetches
-* facilitator support once (via `initialize()`), so call this once per config
-* and reuse the result across requests. `routeOverrides` layers extra route
-* metadata (e.g. `resource`) onto the generated catch-all route.
-* @experimental
-*/
-declare const createChargeMiddleware: (config: X402ChargeConfig, routeOverrides?: ChargeRouteOverrides) => Promise<ChargeMiddleware>;
+ * Behaviour knobs for {@link createChargeMiddleware} beyond route metadata.
+ * @experimental
+ */
+interface ChargeMiddlewareOptions {
+  /**
+   * Settle the verified payment **before** dispatching `runHandler`, instead
+   * of after. Use this for a mutation/procedure gate: a settlement failure
+   * then means the handler never runs at all, so a paid mutation's writes can
+   * never be committed without payment (the free-execution gap X402-04
+   * closes). Once settlement succeeds the payment is final (on-chain) — a
+   * handler failure after that point is a normal application error, not a
+   * payment to unwind: there is nothing left to cancel, so it is not caught
+   * here and simply propagates.
+   *
+   * Default `false` (settle-after, the historical behaviour): the handler's
+   * response is passed to settlement as transport context (`responseHeaders`
+   * — read by some schemes for settlement overrides), and a handler throw
+   * still releases the verified-but-unsettled payment via
+   * `cancellationDispatcher.cancel`. Because settlement can still fail after
+   * the handler already ran on this path, `.x402()` handlers gated this way
+   * MUST be idempotent or compensatable — see the `@lunora/x402` charge docs.
+   */
+  readonly settleBeforeHandler?: boolean;
+}
+/**
+ * Build and initialise a {@link ChargeMiddleware} for `config`. Fetches
+ * facilitator support once (via `initialize()`), so call this once per config
+ * and reuse the result across requests. `routeOverrides` layers extra route
+ * metadata (e.g. `resource`) onto the generated catch-all route; `options`
+ * controls settlement ordering (see {@link ChargeMiddlewareOptions}).
+ * @experimental
+ */
+declare const createChargeMiddleware: (config: X402ChargeConfig, routeOverrides?: ChargeRouteOverrides, options?: ChargeMiddlewareOptions) => Promise<ChargeMiddleware>;
 /**
-* Charge config for the procedure gate: the worker-level settlement vocabulary
-* (network, recipient, facilitator) minus `price` — price is per-procedure and
-* arrives with each {@link X402ProcedureSpec}.
-* @experimental
-*/
+ * Charge config for the procedure gate: the worker-level settlement vocabulary
+ * (network, recipient, facilitator) minus `price` — price is per-procedure and
+ * arrives with each {@link X402ProcedureSpec}.
+ * @experimental
+ */
 type X402ProcedureChargeConfig = Omit<X402ChargeConfig, "price">;
 /**
-* The per-RPC charge spec the runtime passes the gate for each paid dispatch.
-* @experimental
-*/
+ * The per-RPC charge spec the runtime passes the gate for each paid dispatch.
+ * @experimental
+ */
 interface X402ProcedureSpec {
   /** The `file:function` id of the paid procedure; becomes the x402 challenge `resource`. */
   readonly functionPath: string;
@@ -76,20 +114,26 @@ interface X402ProcedureSpec {
   readonly price: X402Price;
 }
 /**
-* Gate one paid RPC. Returns a real `402` + `PAYMENT-REQUIRED` challenge when the
-* request is unpaid, or the dispatched response (with `X-PAYMENT-RESPONSE`
-* attached) once the client's `X-PAYMENT` is verified and settled. `dispatch`
-* runs the actual shard forward — it is only invoked after payment is verified.
-* @experimental
-*/
-type X402ProcedureChargeGate = (request: Request, spec: X402ProcedureSpec, dispatch: () => Promise<Response>) => Promise<Response>;
+ * Gate one paid RPC. Returns a real `402` + `PAYMENT-REQUIRED` challenge when the
+ * request is unpaid, or the dispatched response (with `X-PAYMENT-RESPONSE`
+ * attached) once the client's `X-PAYMENT` is verified and settled. `dispatch`
+ * runs the actual shard forward — settlement happens **before** `dispatch` is
+ * invoked (settle-first), so a settlement failure means the shard forward
+ * (the mutation's commit) never runs at all — no committed-but-unpaid write is
+ * possible. `deps.waitUntil`, when supplied (the request's `ctx.waitUntil`),
+ * keeps the opt-in receipt sink alive past the response.
+ * @experimental
+ */
+type X402ProcedureChargeGate = (request: Request, spec: X402ProcedureSpec, dispatch: () => Promise<Response>, deps?: ChargeHandlerDeps) => Promise<Response>;
 /**
-* Build the injectable procedure charge gate for `config`. One initialised
-* {@link ChargeMiddleware} is memoised per `functionPath` (each bakes that
-* function's price + `resource`), since `createChargeMiddleware` fetches
-* facilitator support on first use. A failed init is not cached, so a transient
-* facilitator outage retries on the next request.
-* @experimental
-*/
+ * Build the injectable procedure charge gate for `config`. One initialised
+ * {@link ChargeMiddleware} is memoised per `functionPath` (each bakes that
+ * function's price + `resource`), since `createChargeMiddleware` fetches
+ * facilitator support on first use. A failed init is not cached, so a transient
+ * facilitator outage retries on the next request. Settlement runs before
+ * `dispatch` (`settleBeforeHandler: true`) since `dispatch` commits the
+ * procedure's real mutation — see `createChargeMiddleware`'s `ChargeMiddlewareOptions`.
+ * @experimental
+ */
 declare const createProcedureChargeGate: (config: X402ProcedureChargeConfig) => X402ProcedureChargeGate;
-export { type ChargeHandler, type ChargeMiddleware, type ChargeRouteOverrides, type FacilitatorConfig, type HttpActionHandler, type X402ChargeConfig, type X402Price, type X402ProcedureChargeConfig, type X402ProcedureChargeGate, type X402ProcedureSpec, createChargeMiddleware, createFacilitatorClient, createProcedureChargeGate, withX402 };
+export { type ChargeHandler, type ChargeHandlerDeps, type ChargeMiddleware, type ChargeMiddlewareOptions, type ChargeRouteOverrides, type FacilitatorConfig, type HttpActionHandler, type X402ChargeConfig, type X402Price, type X402ProcedureChargeConfig, type X402ProcedureChargeGate, type X402ProcedureSpec, createChargeMiddleware, createFacilitatorClient, createProcedureChargeGate, withX402 };

package/dist/charge/index.mjs

@@ -1,7 +1,7 @@
 export { DEFAULT_FACILITATOR_URL, resolveFacilitatorUrl } from '../packem_shared/DEFAULT_FACILITATOR_URL-Cbz6kIqa.mjs';
 export { createFacilitatorClient } from '../packem_shared/createFacilitatorClient-rXHBnCZm.mjs';
 export { isEvmNetwork, isSvmNetwork, toCaip2 } from '../packem_shared/EVM_NETWORKS-BhnYWUQ4.mjs';
-export { withX402 } from '../packem_shared/withX402-SOW47gf3.mjs';
-export { createChargeMiddleware } from '../packem_shared/createChargeMiddleware-CARkBOyH.mjs';
-export { createProcedureChargeGate } from '../packem_shared/createProcedureChargeGate-MaMhu9L9.mjs';
+export { withX402 } from '../packem_shared/withX402-DILL2DvD.mjs';
+export { createChargeMiddleware } from '../packem_shared/createChargeMiddleware-D3yhOpFs.mjs';
+export { createProcedureChargeGate } from '../packem_shared/createProcedureChargeGate-eh9yv36U.mjs';
 export { toPaymentEventRow, toReceipt } from '../packem_shared/toPaymentEventRow-DW4O9N7Y.mjs';

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, E as EVM_NETWORKS, type a as EvmAddress, type F as FacilitatorConfig, type b as FriendlyNetwork, N as NETWORK_TO_CAIP2, S as SVM_NETWORKS, type X as X402CdpSignerConfig, type c as X402ChargeConfig, type d as X402Network, type e as X402PayConfig, type f as X402Price, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, type j as X402SignerConfig, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2 } from "./packem_shared/config.d-D8gKQLAq.mjs";
+export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, E as EVM_NETWORKS, type a as EvmAddress, type F as FacilitatorConfig, type b as FriendlyNetwork, N as NETWORK_TO_CAIP2, S as SVM_NETWORKS, type X as X402CdpSignerConfig, type c as X402ChargeConfig, type d as X402Network, type e as X402PayConfig, type f as X402Price, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, type j as X402SignerConfig, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2 } from "./packem_shared/config.d-B-NYmHgG.mjs";
 import '@x402/evm';
 import '@x402/svm';
 import '@x402/core/http';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, E as EVM_NETWORKS, type a as EvmAddress, type F as FacilitatorConfig, type b as FriendlyNetwork, N as NETWORK_TO_CAIP2, S as SVM_NETWORKS, type X as X402CdpSignerConfig, type c as X402ChargeConfig, type d as X402Network, type e as X402PayConfig, type f as X402Price, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, type j as X402SignerConfig, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2 } from "./packem_shared/config.d-D8gKQLAq.js";
+export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, E as EVM_NETWORKS, type a as EvmAddress, type F as FacilitatorConfig, type b as FriendlyNetwork, N as NETWORK_TO_CAIP2, S as SVM_NETWORKS, type X as X402CdpSignerConfig, type c as X402ChargeConfig, type d as X402Network, type e as X402PayConfig, type f as X402Price, type g as X402Receipt, type h as X402ReceiptSink, type i as X402Recipient, type j as X402SignerConfig, k as isEvmNetwork, l as isSvmNetwork, r as resolveFacilitatorUrl, t as toCaip2 } from "./packem_shared/config.d-B-NYmHgG.js";
 import '@x402/evm';
 import '@x402/svm';
 import '@x402/core/http';

package/dist/packem_shared/{DEFAULT_STABLECOIN_DECIMALS-CSu5b5lD.mjs → DEFAULT_STABLECOIN_DECIMALS-CpW619nu.mjs}

@@ -10,6 +10,9 @@ const createSpendState = () => {
     add: (amount) => {
       spent += amount;
     },
+    release: (amount) => {
+      spent = spent > amount ? spent - amount : 0n;
+    },
     get spentAtomic() {
       return spent;
     }
@@ -59,27 +62,29 @@ const buildPaymentGuard = (policy, state) => {
         reason: `x402 policy: this payment (${requirement.amount}) would exceed the per-run cap (already spent ${state.spentAtomic.toString()}, cap ${maxPerRun.toString()}, in atomic base units).`
       };
     }
+    state.add(amount);
     if (policy.onPaymentRequired !== void 0) {
       const approved = await policy.onPaymentRequired(requirement);
       if (!approved) {
+        state.release(amount);
         return { abort: true, reason: "x402 policy: payment was declined by onPaymentRequired." };
       }
     }
     return void 0;
   };
 };
-const recordSpend = (state) => (context) => {
-  state.add(BigInt(context.selectedRequirements.amount));
+const releaseSpendOnFailure = (state) => (context) => {
+  state.release(BigInt(context.selectedRequirements.amount));
   return Promise.resolve();
 };
 const assertBoundedPolicy = (policy) => {
-  const bounded = policy.maxPerCall !== void 0 || policy.maxPerRun !== void 0 || (policy.allowedRecipients?.length ?? 0) > 0 || (policy.allowedNetworks?.length ?? 0) > 0 || policy.onPaymentRequired !== void 0;
+  const bounded = policy.maxPerCall !== void 0 || policy.maxPerRun !== void 0 || policy.onPaymentRequired !== void 0;
   if (!bounded) {
     throw new LunoraError(
       "FORBIDDEN",
-      "x402 pay: refusing to build a wallet with an unbounded spend policy. Set at least one of maxPerCall, maxPerRun, allowedRecipients, allowedNetworks, or onPaymentRequired."
+      "x402 pay: refusing to build a wallet with an unbounded spend policy. Set at least one of maxPerCall, maxPerRun, or onPaymentRequired (allowedNetworks/allowedRecipients narrow but do not bound spend)."
     );
   }
 };
 
-export { DEFAULT_STABLECOIN_DECIMALS, assertBoundedPolicy, buildPaymentGuard, buildSpendPolicy, createSpendState, recordSpend, usdToAtomic };
+export { DEFAULT_STABLECOIN_DECIMALS, assertBoundedPolicy, buildPaymentGuard, buildSpendPolicy, createSpendState, releaseSpendOnFailure, usdToAtomic };