uvd-x402-sdk 2.96.0 → 2.97.0

package/dist/backend/index.mjs

@@ -104,6 +104,24 @@ function paymentResponseHeaders(result) {
     "Cache-Control": "no-store"
   };
 }
+var LIST_HEADERS = ["Access-Control-Expose-Headers", "Cache-Control"];
+function mergeHeaderList(existing, additions) {
+  const name = (entry) => entry.split("=")[0].trim().toLowerCase();
+  const kept = (existing || "").split(",").map((entry) => entry.trim()).filter(Boolean);
+  const seen = new Set(kept.map(name));
+  for (const entry of additions.split(",").map((value) => value.trim()).filter(Boolean)) {
+    if (!seen.has(name(entry))) {
+      kept.push(entry);
+      seen.add(name(entry));
+    }
+  }
+  return kept.join(", ");
+}
+function mergePaymentResponseHeaders(result, current) {
+  const headers = paymentResponseHeaders(result);
+  for (const name of LIST_HEADERS) headers[name] = mergeHeaderList(current(name), headers[name]);
+  return headers;
+}
 function receiptFromResponse(response) {
   const values = [response.headers.get("PAYMENT-RESPONSE"), response.headers.get("X-PAYMENT-RESPONSE")].filter((v) => v !== null);
   if (!values.length) return null;
@@ -991,7 +1009,8 @@ var SUPPORTED_CHAINS = {
   // Pinned by src/arc-testnet.test.ts.
   //
   // Mainnet (5042) and testnet (5042002) were verified independently against
-  // their official RPCs on 2026-09-16. EURC domains checked on 2026-09-17; live payments pending.
+  // their official RPCs on 2026-09-16. EURC domains checked on 2026-09-17; funded EURC payments settled on Arc mainnet on
+  // 2026-09-22 (x402 v1/v2, docs/networks/arc.md); testnet pending.
   arc: {
     chainId: 5042,
     chainIdHex: "0x13b2",
@@ -1706,6 +1725,9 @@ var REPLAYABLE_LEASE_REASONS = [
 ];
 var AMBIGUOUS_LEASE_REASONS = ["forward_failed"];
 var SETTLEMENT_UNCONFIRMED = "settlement_unconfirmed";
+var AUTHORIZATION_ALREADY_SETTLED = "authorization_already_settled";
+var AUTHORIZATION_IN_FLIGHT = "authorization_in_flight";
+var RECEIPT_REQUEST_CONFLICT = "receipt_request_conflict";
 var MAX_RETRY_AFTER_SECONDS = 15;
 var DEFAULT_RETRY_AFTER_SECONDS = 5;
 var DEFAULT_FACILITATOR_RETRIES = 2;
@@ -1766,6 +1788,12 @@ function isDeclaredUnretryable(parsed) {
 function isSettlementUnconfirmed(failure) {
   return failure.errorCode === SETTLEMENT_UNCONFIRMED;
 }
+function isAuthorizationAlreadyUsed(failure) {
+  return failure.errorCode === AUTHORIZATION_ALREADY_SETTLED || failure.errorCode === RECEIPT_REQUEST_CONFLICT;
+}
+function isAuthorizationInFlight(failure) {
+  return failure.errorCode === AUTHORIZATION_IN_FLIGHT;
+}
 async function readFacilitatorError(response) {
   let body = "";
   try {
@@ -1777,7 +1805,8 @@ async function readFacilitatorError(response) {
   const parsed = parseFacilitatorErrorBody(body);
   const reason = parsed.reason;
   const transportRetryable = status === 429 || status === 502 || status === 503 || status === 504;
-  const retryable = transportRetryable && !isDeclaredUnretryable(parsed);
+  const inFlight = status === 409 && parsed.errorCode === AUTHORIZATION_IN_FLIGHT;
+  const retryable = inFlight || transportRetryable && !isDeclaredUnretryable(parsed);
   const retryAfterSeconds = retryable ? parseRetryAfterSeconds(response) ?? DEFAULT_RETRY_AFTER_SECONDS : void 0;
   const safeToReplay = retryable && (status === 429 || status === 503 && isReplayableLeaseReason(reason));
   return {
@@ -2053,6 +2082,78 @@ function getCorsHeaders(origin = "*") {
     ...X402_CORS_HEADERS
   };
 }
+var IDEMPOTENCY_KEY_HEADER = "Idempotency-Key";
+var IDEMPOTENT_REPLAYED_HEADER = "Idempotent-Replayed";
+function createIdempotencyKey() {
+  return `x402-${bytesToHex(randomBytes(32))}`;
+}
+function checkIdempotencyKey(key) {
+  if (typeof key !== "string" || !/^[\x21-\x7e]{1,255}$/.test(key) || key.startsWith("receipt:")) {
+    throw new Error('idempotencyKey must be 1-255 visible ASCII characters and must not start with "receipt:"');
+  }
+  return key;
+}
+function isReplayed(response) {
+  try {
+    return response?.headers?.get?.(IDEMPOTENT_REPLAYED_HEADER)?.trim().toLowerCase() === "true";
+  } catch {
+    return false;
+  }
+}
+function refuseUnboundReplay(result) {
+  if (!result.replayed) return result;
+  const pending = result.receipt?.status === "pending" || result.receipt?.status === "unknown" || result.errorCode === "settlement_in_progress";
+  if (!result.success && !pending) return result;
+  const {
+    transactionHash: _tx,
+    proofOfPayment: _proof,
+    paymentId: _id,
+    transaction: _t,
+    retryAfterSeconds,
+    ...rest
+  } = result;
+  if (result.success) {
+    return {
+      ...rest,
+      success: false,
+      error: AUTHORIZATION_ALREADY_SETTLED,
+      errorCode: AUTHORIZATION_ALREADY_SETTLED,
+      retryable: false,
+      safeToReplay: false
+    };
+  }
+  return {
+    ...rest,
+    success: false,
+    error: AUTHORIZATION_IN_FLIGHT,
+    errorCode: AUTHORIZATION_IN_FLIGHT,
+    retryable: true,
+    safeToReplay: false,
+    retryAfterSeconds: retryAfterSeconds ?? DEFAULT_RETRY_AFTER_SECONDS
+  };
+}
+function facilitatorHeaders(idempotencyKey, receiptContext) {
+  return {
+    "Content-Type": "application/json",
+    [IDEMPOTENCY_KEY_HEADER]: idempotencyKey,
+    ...receiptContext ? { "X-UVD-Purchase": receiptContext } : {}
+  };
+}
+function admittedVerdict(result) {
+  if (result.isValid !== false) return {};
+  if (result.invalidReason === AUTHORIZATION_IN_FLIGHT) {
+    return {
+      errorCode: AUTHORIZATION_IN_FLIGHT,
+      retryable: true,
+      safeToReplay: false,
+      retryAfterSeconds: DEFAULT_RETRY_AFTER_SECONDS
+    };
+  }
+  if (result.invalidReason === AUTHORIZATION_ALREADY_SETTLED) {
+    return { errorCode: AUTHORIZATION_ALREADY_SETTLED, retryable: false, safeToReplay: false };
+  }
+  return {};
+}
 var FacilitatorClient = class {
   baseUrl;
   timeout;
@@ -2085,11 +2186,19 @@ var FacilitatorClient = class {
    *
    * Call this before providing the paid resource to validate the payment.
    *
+   * An authorization the facilitator already admitted for another request
+   * comes back invalid with `errorCode` {@link AUTHORIZATION_ALREADY_SETTLED}
+   * (do not serve, do not ask for a new signature) or
+   * {@link AUTHORIZATION_IN_FLIGHT} (`retryable`: the same request learns the
+   * verdict later). Neither is a rejected payment: never answer them with 402.
+   *
    * @param paymentHeader - Parsed x402 payment header
    * @param requirements - Payment requirements
+   * @param options - Purchase context and the payment's `idempotencyKey`
    * @returns Verification result
    */
   async verify(paymentHeader, requirements, options = {}) {
+    const idempotencyKey = checkIdempotencyKey(options.idempotencyKey ?? createIdempotencyKey());
     const body = buildVerifyRequestForVersion(
       paymentHeader,
       requirements,
@@ -2100,7 +2209,7 @@ var FacilitatorClient = class {
         `${this.baseUrl}/verify`,
         {
           method: "POST",
-          headers: { "Content-Type": "application/json", ...options.receiptContext ? { "X-UVD-Purchase": options.receiptContext } : {} },
+          headers: facilitatorHeaders(idempotencyKey, options.receiptContext),
           body: JSON.stringify(body)
         },
         { timeoutMs: this.timeout, retries: this.retries }
@@ -2110,18 +2219,20 @@ var FacilitatorClient = class {
           isValid: false,
           invalidReason: error.error,
           ...failureFields(error),
-          receipt: receiptFromErrorBody(error.body)
+          receipt: receiptFromErrorBody(error.body),
+          idempotencyKey
         };
       }
       const result = await response.json();
-      return { ...result, receipt: parseFacilitatorReceipt(result.receipt) };
+      return { ...result, ...admittedVerdict(result), receipt: parseFacilitatorReceipt(result.receipt), idempotencyKey };
     } catch (error) {
       return {
         isValid: false,
         invalidReason: error instanceof Error ? error.message : "Unknown error",
         retryable: true,
         safeToReplay: false,
-        retryAfterSeconds: DEFAULT_RETRY_AFTER_SECONDS
+        retryAfterSeconds: DEFAULT_RETRY_AFTER_SECONDS,
+        idempotencyKey
       };
     }
   }
@@ -2130,11 +2241,23 @@ var FacilitatorClient = class {
    *
    * Call this after providing the paid resource to execute the on-chain transfer.
    *
+   * Send the `idempotencyKey` the payment was verified with, and the same one
+   * on any retry: it is the binding that earns the original answer back after
+   * a lost response (`replayed: true`). Without it, or with another one, an
+   * authorization already admitted comes back `409`
+   * {@link AUTHORIZATION_ALREADY_SETTLED}, {@link AUTHORIZATION_IN_FLIGHT} or
+   * {@link RECEIPT_REQUEST_CONFLICT} -- the X-PAYMENT was used; do not serve it
+   * again. With no key and no context the call uses a fresh key, so a replay
+   * it receives is refused the same way.
+   *
    * @param paymentHeader - Parsed x402 payment header
    * @param requirements - Payment requirements
+   * @param options - Purchase context and the payment's `idempotencyKey`
    * @returns Settlement result with transaction hash
    */
   async settle(paymentHeader, requirements, options = {}) {
+    const unbound = options.idempotencyKey === void 0 && !options.receiptContext;
+    const idempotencyKey = checkIdempotencyKey(options.idempotencyKey ?? createIdempotencyKey());
     const body = buildSettleRequestForVersion(
       paymentHeader,
       requirements,
@@ -2146,7 +2269,8 @@ var FacilitatorClient = class {
         `${this.baseUrl}/settle`,
         {
           method: "POST",
-          headers: { "Content-Type": "application/json", ...options.receiptContext ? { "X-UVD-Purchase": options.receiptContext } : {} },
+          // The same init, key included, goes out on every automatic retry.
+          headers: facilitatorHeaders(idempotencyKey, options.receiptContext),
           body: JSON.stringify(body)
         },
         { timeoutMs: settleTimeout, retries: this.retries }
@@ -2156,7 +2280,8 @@ var FacilitatorClient = class {
           success: false,
           error: error.error,
           ...failureFields(error),
-          receipt: receiptFromErrorBody(error.body)
+          receipt: receiptFromErrorBody(error.body),
+          idempotencyKey
         };
       }
       const result = await response.json();
@@ -2166,7 +2291,7 @@ var FacilitatorClient = class {
           "[x402] settle reported success but carried no transaction hash under transaction/transactionHash/transaction_hash \u2014 treat delivery as unconfirmed"
         );
       }
-      return {
+      const settled = {
         // Read the facilitator's verdict instead of asserting one.
         //
         // This was the literal `true`, so a settle was reported successful
@@ -2197,15 +2322,21 @@ var FacilitatorClient = class {
         payer: result.payer,
         receipt: parseFacilitatorReceipt(result.receipt),
         paymentId: result.paymentId,
-        ...result.receipt?.status === "unknown" || result.receipt?.status === "pending" ? { retryable: true, safeToReplay: false } : {}
+        ...result.receipt?.status === "unknown" || result.receipt?.status === "pending" ? { retryable: true, safeToReplay: false } : {},
+        // `202 settlement_in_progress` and friends: a 2xx that names its state.
+        ...!result.success && typeof result.error === "string" && result.error ? { errorCode: result.error } : {},
+        ...isReplayed(response) ? { replayed: true } : {},
+        idempotencyKey
       };
+      return unbound ? refuseUnboundReplay(settled) : settled;
     } catch (error) {
       return {
         success: false,
         error: error instanceof Error ? error.message : "Unknown error",
         retryable: true,
         safeToReplay: false,
-        retryAfterSeconds: DEFAULT_RETRY_AFTER_SECONDS
+        retryAfterSeconds: DEFAULT_RETRY_AFTER_SECONDS,
+        idempotencyKey
       };
     }
   }
@@ -2215,27 +2346,41 @@ var FacilitatorClient = class {
    * Convenience method that verifies first, then settles if valid.
    * Use this for simple payment flows where you don't need custom logic between verify and settle.
    *
+   * Both steps carry ONE `Idempotency-Key` (`options.idempotencyKey`, or a
+   * fresh one reported back as `idempotencyKey`). With a fresh key and no
+   * purchase context, a replay of an earlier settle is not this purchase and
+   * comes back `settled: false` with `errorCode`
+   * {@link AUTHORIZATION_ALREADY_SETTLED}.
+   *
    * @param paymentHeader - Parsed x402 payment header
    * @param requirements - Payment requirements
+   * @param options - Purchase context and the payment's `idempotencyKey`
    * @returns Combined result with verify and settle status
    */
-  async verifyAndSettle(paymentHeader, requirements) {
-    const verifyResult = await this.verify(paymentHeader, requirements);
+  async verifyAndSettle(paymentHeader, requirements, options = {}) {
+    const unbound = options.idempotencyKey === void 0 && !options.receiptContext;
+    const binding = { ...options, idempotencyKey: checkIdempotencyKey(options.idempotencyKey ?? createIdempotencyKey()) };
+    const { idempotencyKey } = binding;
+    const verifyResult = await this.verify(paymentHeader, requirements, binding);
     if (!verifyResult.isValid) {
       return {
         verified: false,
         settled: false,
         error: verifyResult.invalidReason,
-        ...carryFailureFields(verifyResult)
+        ...carryFailureFields(verifyResult),
+        idempotencyKey
       };
     }
-    const settleResult = await this.settle(paymentHeader, requirements);
+    const answered = await this.settle(paymentHeader, requirements, binding);
+    const settleResult = unbound ? refuseUnboundReplay(answered) : answered;
     return {
       verified: true,
       settled: settleResult.success,
       transactionHash: settleResult.transactionHash,
       error: settleResult.error,
-      ...carryFailureFields(settleResult)
+      ...carryFailureFields(settleResult),
+      ...settleResult.replayed ? { replayed: true } : {},
+      idempotencyKey
     };
   }
   /**
@@ -2623,16 +2768,22 @@ async function resolvePaymentRequirement(payment, requirements, resolver) {
   }
   return { requirement: matches[0] };
 }
-function createVerifiedPaymentState(client, payment, requirements, verifyResult, receiptContext, onSettled) {
+function createVerifiedPaymentState(client, payment, requirements, verifyResult, binding, onSettled) {
   let settlePromise = null;
   return {
     payment,
     requirements,
     verifyResult,
+    idempotencyKey: binding.idempotencyKey,
     settle: () => {
       if (!settlePromise) {
-        settlePromise = client.settle(payment, requirements, { receiptContext }).then((result) => {
-          onSettled?.(result);
+        settlePromise = client.settle(payment, requirements, binding).then((answer) => {
+          const result = binding.receiptContext ? answer : refuseUnboundReplay(answer);
+          try {
+            onSettled?.(result);
+          } catch (error) {
+            console.warn("[x402] settled, but the payment response headers could not be attached:", error);
+          }
           return result;
         });
       }
@@ -2640,6 +2791,28 @@ function createVerifiedPaymentState(client, payment, requirements, verifyResult,
     }
   };
 }
+function propagatedResult(result) {
+  const { idempotencyKey: _key, ...propagated } = result;
+  return propagated;
+}
+function buildPaymentConflictResponse(failure) {
+  if (isAuthorizationInFlight(failure)) {
+    const { headers, body } = buildUnavailableResponse("Payment authorization in flight", failure);
+    return { status: 503, headers, body: { ...body, reason: AUTHORIZATION_IN_FLIGHT } };
+  }
+  const used = isAuthorizationAlreadyUsed(failure);
+  if (!used && failure.status !== 409) return null;
+  return {
+    status: 409,
+    headers: {},
+    body: {
+      error: used ? "Payment authorization already used" : "Payment request conflict",
+      reason: failure.errorCode ?? failure.invalidReason ?? failure.error,
+      retryable: false,
+      safeToReplay: false
+    }
+  };
+}
 function buildUnavailableResponse(message, failure) {
   const seconds = Math.max(1, Math.ceil(failure.retryAfterSeconds ?? DEFAULT_RETRY_AFTER_SECONDS));
   return {
@@ -2656,14 +2829,25 @@ function buildUnavailableResponse(message, failure) {
   };
 }
 function respondUnavailable(res, message, failure) {
-  const { status, headers, body } = buildUnavailableResponse(message, failure);
+  respondExpress(res, buildUnavailableResponse(message, failure));
+}
+function respondExpress(res, { status, headers, body }) {
   const staged = res.status(status);
-  if (typeof staged.set === "function") {
+  if (Object.keys(headers).length > 0 && typeof staged.set === "function") {
     staged.set(headers).json(body);
     return;
   }
   staged.json(body);
 }
+function setExpressPaymentHeaders(res, result) {
+  if (!result.receipt || !res.set || res.headersSent) return;
+  const current = (name) => {
+    const value = res.getHeader ? res.getHeader(name) : res.get?.(name);
+    if (value === void 0 || value === null) return void 0;
+    return Array.isArray(value) ? value.join(", ") : String(value);
+  };
+  res.set(mergePaymentResponseHeaders(propagatedResult(result), current));
+}
 function createPaymentMiddleware(getRequirements, options = {}) {
   const client = new FacilitatorClient({
     baseUrl: options.facilitatorUrl || options.baseUrl,
@@ -2694,9 +2878,15 @@ function createPaymentMiddleware(getRequirements, options = {}) {
       res.status(400).json({ error: "receipt_context_mismatch" });
       return;
     }
-    const verifyResult = await client.verify(payment, requirements, { receiptContext });
-    if (verifyResult.receipt) res.set?.(paymentResponseHeaders({ ...verifyResult }));
+    const binding = { idempotencyKey: createIdempotencyKey(), receiptContext };
+    const verifyResult = await client.verify(payment, requirements, binding);
+    setExpressPaymentHeaders(res, verifyResult);
     if (!verifyResult.isValid) {
+      const conflict = buildPaymentConflictResponse(verifyResult);
+      if (conflict) {
+        respondExpress(res, conflict);
+        return;
+      }
       if (verifyResult.retryable) {
         respondUnavailable(res, "Payment verification unavailable", verifyResult);
         return;
@@ -2707,12 +2897,22 @@ function createPaymentMiddleware(getRequirements, options = {}) {
       });
       return;
     }
-    req.x402 = createVerifiedPaymentState(client, payment, requirements, verifyResult, receiptContext, (result) => {
-      if (result.receipt) res.set?.(paymentResponseHeaders({ ...result }));
-    });
+    req.x402 = createVerifiedPaymentState(
+      client,
+      payment,
+      requirements,
+      verifyResult,
+      binding,
+      (result) => setExpressPaymentHeaders(res, result)
+    );
     if (settlementStrategy === "before-handler") {
       const settleResult = await req.x402.settle();
       if (!settleResult.success) {
+        const conflict = buildPaymentConflictResponse(settleResult);
+        if (conflict) {
+          respondExpress(res, conflict);
+          return;
+        }
         if (settleResult.retryable) {
           respondUnavailable(res, "Payment settlement unavailable", settleResult);
           return;
@@ -2735,12 +2935,21 @@ function settlementFailureBody(failure, fallbackReason) {
   };
 }
 function honoUnavailable(c, message, failure) {
-  const { status, headers, body } = buildUnavailableResponse(message, failure);
+  return respondHono(c, buildUnavailableResponse(message, failure));
+}
+function respondHono(c, { status, headers, body }) {
   for (const [name, value] of Object.entries(headers)) {
     c.header?.(name, value);
   }
   return c.json(body, status);
 }
+function setHonoPaymentHeaders(c, result) {
+  if (!result.receipt || !c.header || c.finalized) return;
+  const current = (name) => c.res?.headers.get(name) ?? void 0;
+  for (const [name, value] of Object.entries(mergePaymentResponseHeaders(propagatedResult(result), current))) {
+    c.header(name, value);
+  }
+}
 function createHonoMiddleware(options) {
   const client = new FacilitatorClient({
     baseUrl: options.facilitatorUrl || options.baseUrl,
@@ -2795,9 +3004,12 @@ function createHonoMiddleware(options) {
     } catch {
       return c.json({ error: "receipt_context_mismatch" }, 400);
     }
-    const verifyResult = await client.verify(parsed, requirement, { receiptContext });
-    if (verifyResult.receipt) for (const [name, value] of Object.entries(paymentResponseHeaders({ ...verifyResult }))) c.header?.(name, value);
+    const binding = { idempotencyKey: createIdempotencyKey(), receiptContext };
+    const verifyResult = await client.verify(parsed, requirement, binding);
+    setHonoPaymentHeaders(c, verifyResult);
     if (!verifyResult.isValid) {
+      const conflict = buildPaymentConflictResponse(verifyResult);
+      if (conflict) return respondHono(c, conflict);
       if (verifyResult.retryable) {
         return honoUnavailable(c, "Payment verification unavailable", verifyResult);
       }
@@ -2806,13 +3018,20 @@ function createHonoMiddleware(options) {
         reason: verifyResult.invalidReason
       }, 402);
     }
-    const verifiedPayment = createVerifiedPaymentState(client, parsed, requirement, verifyResult, receiptContext, (result) => {
-      if (result.receipt) for (const [name, value] of Object.entries(paymentResponseHeaders({ ...result }))) c.header?.(name, value);
-    });
+    const verifiedPayment = createVerifiedPaymentState(
+      client,
+      parsed,
+      requirement,
+      verifyResult,
+      binding,
+      (result) => setHonoPaymentHeaders(c, result)
+    );
     c.set?.("x402", verifiedPayment);
     if (settlementStrategy === "before-handler") {
       const settleResult = await verifiedPayment.settle();
       if (!settleResult.success) {
+        const conflict = buildPaymentConflictResponse(settleResult);
+        if (conflict) return respondHono(c, conflict);
         if (settleResult.retryable) {
           return honoUnavailable(c, "Payment settlement unavailable", settleResult);
         }
@@ -5703,6 +5922,6 @@ var AdvancedEscrowClient = class {
   }
 };
 
-export { AMBIGUOUS_LEASE_REASONS, AdvancedEscrowClient, BASE_MAINNET_CONTRACTS, BazaarClient, DEFAULT_FACILITATOR_RETRIES, DEFAULT_RETRY_AFTER_SECONDS, DEPOSIT_LIMIT_USDC, ERC8004_CONTRACTS, ERC8004_EXTENSION_ID, ESCROW_CONTRACTS, ESCROW_TIMEOUT_MS, Erc8004Client, Erc8004LookupError, EscrowClient, FacilitatorClient, HEALTH_FILTERS, MAX_RETRY_AFTER_SECONDS, MAX_SEARCH_LEN, OPERATOR_ABI, OPERATOR_ABI_CREATE3, PAYMENT_INFO_TYPEHASH, RECEIPT_ISSUER, RELAYED_FEEDBACK_NETWORKS, REPLAYABLE_LEASE_REASONS, RegistrationPendingError, SETTLEMENT_UNCONFIRMED, SOLANA_FEEDBACK_NETWORKS, TIER_FILTERS, TIER_TIMINGS, USDC_DOMAIN_NAME, WRITER_LEASE_REASONS, X402_CORS_HEADERS, X402_HEADER_NAMES, ZERO_ADDRESS, buildErc8004PaymentRequirements, buildPaymentRequirements, buildSettleRequest, buildSettleRequestForVersion, buildSettleRequestV2, buildUnavailableResponse, buildVerifyRequest, buildVerifyRequestForVersion, buildVerifyRequestV2, canRefundEscrow, canReleaseEscrow, canonicalReceiptJson, carryFailureFields, create402Response, createHonoMiddleware, createPaymentMiddleware, createPurchaseContext, epochToDate, escrowTimeRemaining, extractPaymentFromHeaders, facilitatorFetch, fetchWithReceipt, getCorsHeaders, getEscrowContractsByChainId, getEscrowSupportedChainIds, getFacilitatorReceipt, isAlive, isAmbiguousLeaseReason, isEscrowExpired, isEscrowSupportedOnChain, isRegisterJobTerminal, isReplayableLeaseReason, isSettlementUnconfirmed, parseFacilitatorErrorBody, parseFacilitatorReceipt, parsePaymentHeader, parseRetryAfterSeconds, paymentResponseHeaders, purchaseContextHeader, readFacilitatorError, receiptCommitment, receiptFromErrorBody, receiptFromResponse, resolveEnvelopeVersion, supportsRelayedFeedback, supportsSolanaFeedback, toPaymentRequirementsV2, toResourceInfoV2, validatePurchaseContext, verifyFacilitatorReceipt, wireNetwork };
+export { AMBIGUOUS_LEASE_REASONS, AUTHORIZATION_ALREADY_SETTLED, AUTHORIZATION_IN_FLIGHT, AdvancedEscrowClient, BASE_MAINNET_CONTRACTS, BazaarClient, DEFAULT_FACILITATOR_RETRIES, DEFAULT_RETRY_AFTER_SECONDS, DEPOSIT_LIMIT_USDC, ERC8004_CONTRACTS, ERC8004_EXTENSION_ID, ESCROW_CONTRACTS, ESCROW_TIMEOUT_MS, Erc8004Client, Erc8004LookupError, EscrowClient, FacilitatorClient, HEALTH_FILTERS, IDEMPOTENCY_KEY_HEADER, IDEMPOTENT_REPLAYED_HEADER, MAX_RETRY_AFTER_SECONDS, MAX_SEARCH_LEN, OPERATOR_ABI, OPERATOR_ABI_CREATE3, PAYMENT_INFO_TYPEHASH, RECEIPT_ISSUER, RECEIPT_REQUEST_CONFLICT, RELAYED_FEEDBACK_NETWORKS, REPLAYABLE_LEASE_REASONS, RegistrationPendingError, SETTLEMENT_UNCONFIRMED, SOLANA_FEEDBACK_NETWORKS, TIER_FILTERS, TIER_TIMINGS, USDC_DOMAIN_NAME, WRITER_LEASE_REASONS, X402_CORS_HEADERS, X402_HEADER_NAMES, ZERO_ADDRESS, buildErc8004PaymentRequirements, buildPaymentConflictResponse, buildPaymentRequirements, buildSettleRequest, buildSettleRequestForVersion, buildSettleRequestV2, buildUnavailableResponse, buildVerifyRequest, buildVerifyRequestForVersion, buildVerifyRequestV2, canRefundEscrow, canReleaseEscrow, canonicalReceiptJson, carryFailureFields, create402Response, createHonoMiddleware, createIdempotencyKey, createPaymentMiddleware, createPurchaseContext, epochToDate, escrowTimeRemaining, extractPaymentFromHeaders, facilitatorFetch, fetchWithReceipt, getCorsHeaders, getEscrowContractsByChainId, getEscrowSupportedChainIds, getFacilitatorReceipt, isAlive, isAmbiguousLeaseReason, isAuthorizationAlreadyUsed, isAuthorizationInFlight, isEscrowExpired, isEscrowSupportedOnChain, isRegisterJobTerminal, isReplayableLeaseReason, isSettlementUnconfirmed, mergeHeaderList, mergePaymentResponseHeaders, parseFacilitatorErrorBody, parseFacilitatorReceipt, parsePaymentHeader, parseRetryAfterSeconds, paymentResponseHeaders, purchaseContextHeader, readFacilitatorError, receiptCommitment, receiptFromErrorBody, receiptFromResponse, resolveEnvelopeVersion, supportsRelayedFeedback, supportsSolanaFeedback, toPaymentRequirementsV2, toResourceInfoV2, validatePurchaseContext, verifyFacilitatorReceipt, wireNetwork };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map