@dexterai/x402 1.7.1 → 1.8.0

package/dist/server/index.cjs

@@ -107,25 +107,77 @@ function decodeBase64Json(encoded) {
 }
 
 // src/server/facilitator-client.ts
+function isRetryable(error) {
+  if (error instanceof TypeError) return true;
+  if (error && typeof error === "object" && "status" in error) {
+    const status = error.status;
+    return status >= 500 && status < 600;
+  }
+  return false;
+}
+var HttpError = class extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`HTTP ${status}`);
+    this.status = status;
+    this.body = body;
+  }
+};
 var FacilitatorClient = class {
   facilitatorUrl;
   cachedSupported = null;
   cacheTime = 0;
   CACHE_TTL_MS = 6e4;
-  // 1 minute cache
-  constructor(facilitatorUrl = DEXTER_FACILITATOR_URL) {
+  timeoutMs;
+  maxRetries;
+  retryBaseMs;
+  constructor(facilitatorUrl = DEXTER_FACILITATOR_URL, config) {
     this.facilitatorUrl = facilitatorUrl.replace(/\/$/, "");
+    this.timeoutMs = config?.timeoutMs ?? 1e4;
+    this.maxRetries = config?.maxRetries ?? 3;
+    this.retryBaseMs = config?.retryBaseMs ?? 500;
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async fetchWithRetry(url, init) {
+    let lastError;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        const response = await this.fetchWithTimeout(url, init);
+        if (!response.ok && response.status >= 500) {
+          throw new HttpError(response.status, await response.text());
+        }
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (attempt < this.maxRetries - 1 && isRetryable(error)) {
+          const delay = this.retryBaseMs * Math.pow(2, attempt);
+          await new Promise((r) => setTimeout(r, delay));
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw lastError;
   }
   /**
-   * Get supported payment kinds from the facilitator
-   * Results are cached for 1 minute to reduce network calls
+   * Get supported payment kinds from the facilitator.
+   * Results are cached for 1 minute to reduce network calls.
    */
   async getSupported() {
     const now = Date.now();
     if (this.cachedSupported && now - this.cacheTime < this.CACHE_TTL_MS) {
       return this.cachedSupported;
     }
-    const response = await fetch(`${this.facilitatorUrl}/supported`);
+    const response = await this.fetchWithTimeout(`${this.facilitatorUrl}/supported`);
     if (!response.ok) {
       throw new Error(`Facilitator /supported returned ${response.status}`);
     }
@@ -135,9 +187,6 @@ var FacilitatorClient = class {
   }
   /**
    * Get the fee payer address for a specific network
-   *
-   * @param network - CAIP-2 network identifier
-   * @returns Fee payer address
    */
   async getFeePayer(network) {
     const supported = await this.getSupported();
@@ -153,9 +202,6 @@ var FacilitatorClient = class {
   }
   /**
    * Get extra data for a network (feePayer, decimals, EIP-712 data, etc.)
-   *
-   * @param network - CAIP-2 network identifier
-   * @returns Extra data from /supported
    */
   async getNetworkExtra(network) {
     const supported = await this.getSupported();
@@ -165,30 +211,22 @@ var FacilitatorClient = class {
     return kind?.extra;
   }
   /**
-   * Verify a payment with the facilitator
-   *
-   * @param paymentSignatureHeader - Base64-encoded PAYMENT-SIGNATURE header value
-   * @param requirements - The payment requirements that were sent to the client
-   * @returns Verification response
+   * Verify a payment with the facilitator.
+   * Retries on 5xx and network errors with exponential backoff.
    */
   async verifyPayment(paymentSignatureHeader, requirements) {
     try {
       const paymentPayload = decodeBase64Json(paymentSignatureHeader);
-      const verifyPayload = {
-        x402Version: 2,
-        paymentPayload,
-        paymentRequirements: requirements
-      };
-      const response = await fetch(`${this.facilitatorUrl}/verify`, {
+      const response = await this.fetchWithRetry(`${this.facilitatorUrl}/verify`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(verifyPayload)
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          x402Version: 2,
+          paymentPayload,
+          paymentRequirements: requirements
+        })
       });
       if (!response.ok) {
-        const errorText = await response.text();
-        console.error(`Facilitator /verify returned ${response.status}:`, errorText);
         return {
           isValid: false,
           invalidReason: `facilitator_error_${response.status}`
@@ -196,38 +234,27 @@ var FacilitatorClient = class {
       }
       return await response.json();
     } catch (error) {
-      console.error("Payment verification failed:", error);
-      return {
-        isValid: false,
-        invalidReason: error instanceof Error ? error.message : "unexpected_verify_error"
-      };
+      const reason = error instanceof HttpError ? `facilitator_error_${error.status}` : error instanceof Error && error.name === "AbortError" ? "facilitator_timeout" : error instanceof Error ? error.message : "unexpected_verify_error";
+      return { isValid: false, invalidReason: reason };
     }
   }
   /**
-   * Settle a payment with the facilitator
-   *
-   * @param paymentSignatureHeader - Base64-encoded PAYMENT-SIGNATURE header value
-   * @param requirements - The payment requirements that were sent to the client
-   * @returns Settlement response with transaction signature on success
+   * Settle a payment with the facilitator.
+   * Retries on 5xx and network errors with exponential backoff.
    */
   async settlePayment(paymentSignatureHeader, requirements) {
     try {
       const paymentPayload = decodeBase64Json(paymentSignatureHeader);
-      const settlePayload = {
-        x402Version: 2,
-        paymentPayload,
-        paymentRequirements: requirements
-      };
-      const response = await fetch(`${this.facilitatorUrl}/settle`, {
+      const response = await this.fetchWithRetry(`${this.facilitatorUrl}/settle`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(settlePayload)
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          x402Version: 2,
+          paymentPayload,
+          paymentRequirements: requirements
+        })
       });
       if (!response.ok) {
-        const errorText = await response.text();
-        console.error(`Facilitator /settle returned ${response.status}:`, errorText);
         return {
           success: false,
           network: requirements.network,
@@ -235,22 +262,27 @@ var FacilitatorClient = class {
         };
       }
       const result = await response.json();
-      return {
-        ...result,
-        network: requirements.network
-      };
+      return { ...result, network: requirements.network };
     } catch (error) {
-      console.error("Payment settlement failed:", error);
+      const reason = error instanceof HttpError ? `facilitator_error_${error.status}` : error instanceof Error && error.name === "AbortError" ? "facilitator_timeout" : error instanceof Error ? error.message : "unexpected_settle_error";
       return {
         success: false,
         network: requirements.network,
-        errorReason: error instanceof Error ? error.message : "unexpected_settle_error"
+        errorReason: reason
       };
     }
   }
 };
 
 // src/server/x402-server.ts
+function extractAmountFromHeader(paymentSignatureHeader) {
+  try {
+    const decoded = decodeBase64Json(paymentSignatureHeader);
+    return decoded?.accepted?.amount ?? decoded?.accepted?.maxAmountRequired;
+  } catch {
+    return void 0;
+  }
+}
 function createX402Server(config) {
   const {
     payTo,
@@ -261,6 +293,29 @@ function createX402Server(config) {
   } = config;
   const facilitator = new FacilitatorClient(facilitatorUrl);
   let cachedExtra = null;
+  const requirementsCache = /* @__PURE__ */ new Map();
+  const CACHE_PRUNE_INTERVAL = 3e4;
+  let lastPrune = Date.now();
+  function cacheRequirements(accept) {
+    const ttl = (accept.maxTimeoutSeconds || defaultTimeoutSeconds) * 1e3;
+    requirementsCache.set(accept.payTo, { accept, expiresAt: Date.now() + ttl });
+    if (Date.now() - lastPrune > CACHE_PRUNE_INTERVAL) {
+      const now = Date.now();
+      for (const [key, entry] of requirementsCache) {
+        if (entry.expiresAt < now) requirementsCache.delete(key);
+      }
+      lastPrune = now;
+    }
+  }
+  function getCachedRequirements(address) {
+    const entry = requirementsCache.get(address);
+    if (!entry) return void 0;
+    if (entry.expiresAt < Date.now()) {
+      requirementsCache.delete(address);
+      return void 0;
+    }
+    return entry.accept;
+  }
   async function resolvePayTo(context) {
     if (typeof payTo === "string") return payTo;
     return payTo(context || {});
@@ -286,7 +341,7 @@ function createX402Server(config) {
       timeoutSeconds = defaultTimeoutSeconds
     } = options;
     const extra = await getNetworkExtra();
-    return {
+    const accept = {
       scheme: "exact",
       network,
       amount: amountAtomic,
@@ -296,6 +351,8 @@ function createX402Server(config) {
       maxTimeoutSeconds: timeoutSeconds,
       extra
     };
+    cacheRequirements(accept);
+    return accept;
   }
   async function getPaymentAccept(options) {
     const address = await resolvePayTo({
@@ -338,14 +395,26 @@ function createX402Server(config) {
   async function verifyPayment(paymentSignatureHeader, requirements) {
     if (!requirements) {
       const address = await resolvePayTo({ paymentHeader: paymentSignatureHeader });
-      requirements = await buildPaymentAccept(address, { amountAtomic: "0", resourceUrl: "" });
+      requirements = getCachedRequirements(address);
+      if (!requirements) {
+        requirements = await buildPaymentAccept(address, {
+          amountAtomic: extractAmountFromHeader(paymentSignatureHeader) ?? "0",
+          resourceUrl: ""
+        });
+      }
     }
     return facilitator.verifyPayment(paymentSignatureHeader, requirements);
   }
   async function settlePayment(paymentSignatureHeader, requirements) {
     if (!requirements) {
       const address = await resolvePayTo({ paymentHeader: paymentSignatureHeader });
-      requirements = await buildPaymentAccept(address, { amountAtomic: "0", resourceUrl: "" });
+      requirements = getCachedRequirements(address);
+      if (!requirements) {
+        requirements = await buildPaymentAccept(address, {
+          amountAtomic: extractAmountFromHeader(paymentSignatureHeader) ?? "0",
+          resourceUrl: ""
+        });
+      }
     }
     return facilitator.settlePayment(paymentSignatureHeader, requirements);
   }
@@ -364,6 +433,15 @@ function createX402Server(config) {
 // src/server/middleware.ts
 var DEFAULT_NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
 var USDC_DECIMALS = 6;
+function resolvePayToForNetwork(payTo, network) {
+  if (typeof payTo === "string" || typeof payTo === "function") return payTo;
+  if (network in payTo) return payTo[network];
+  const prefix = network.split(":")[0];
+  const globKey = `${prefix}:*`;
+  if (globKey in payTo) return payTo[globKey];
+  if ("*" in payTo) return payTo["*"];
+  throw new Error(`No payTo configured for network "${network}"`);
+}
 function x402Middleware(config) {
   const {
     payTo,
@@ -378,18 +456,29 @@ function x402Middleware(config) {
     getAmount,
     getDescription
   } = config;
-  const providerDefaults = typeof payTo !== "string" ? payTo._x402Defaults : void 0;
-  const network = config.network ?? providerDefaults?.network ?? DEFAULT_NETWORK;
-  const facilitatorUrl = config.facilitatorUrl ?? providerDefaults?.facilitatorUrl;
   const log = verbose ? console.log.bind(console, "[x402:middleware]") : () => {
   };
-  const server = createX402Server({
-    payTo,
-    network,
-    asset,
-    facilitatorUrl,
-    defaultTimeoutSeconds: timeoutSeconds
-  });
+  const singleProviderDefaults = typeof payTo === "function" ? payTo._x402Defaults : void 0;
+  const facilitatorUrl = config.facilitatorUrl ?? singleProviderDefaults?.facilitatorUrl;
+  const configuredNetworks = (() => {
+    if (config.network) {
+      return Array.isArray(config.network) ? config.network : [config.network];
+    }
+    if (singleProviderDefaults?.network) return [singleProviderDefaults.network];
+    return [DEFAULT_NETWORK];
+  })();
+  const servers = /* @__PURE__ */ new Map();
+  for (const net of configuredNetworks) {
+    const netPayTo = resolvePayToForNetwork(payTo, net);
+    servers.set(net, createX402Server({
+      payTo: netPayTo,
+      network: net,
+      asset,
+      facilitatorUrl,
+      defaultTimeoutSeconds: timeoutSeconds
+    }));
+  }
+  const primaryServer = servers.get(configuredNetworks[0]);
   return async (req, res, next) => {
     try {
       const paymentSignature = req.headers["payment-signature"];
@@ -407,8 +496,23 @@ function x402Middleware(config) {
           mimeType,
           timeoutSeconds
         };
-        const requirements = await server.buildRequirements(requirementsOptions);
-        const encoded = server.encodeRequirements(requirements);
+        const allAccepts = [];
+        let requirements = null;
+        for (const [, srv] of servers) {
+          try {
+            const reqs = await srv.buildRequirements(requirementsOptions);
+            allAccepts.push(...reqs.accepts);
+            if (!requirements) requirements = reqs;
+          } catch (e) {
+            log("Failed to build requirements for a network:", e);
+          }
+        }
+        if (!requirements || allAccepts.length === 0) {
+          res.status(500).json({ error: "Failed to build payment requirements" });
+          return;
+        }
+        requirements = { ...requirements, accepts: allAccepts };
+        const encoded = primaryServer.encodeRequirements(requirements);
         res.setHeader("PAYMENT-REQUIRED", encoded);
         res.status(402).json({
           error: "Payment required",
@@ -418,7 +522,16 @@ function x402Middleware(config) {
         return;
       }
       log("Payment signature received, verifying...");
-      const verifyResult = await server.verifyPayment(paymentSignature);
+      let targetServer = primaryServer;
+      try {
+        const decoded = JSON.parse(Buffer.from(paymentSignature, "base64").toString());
+        const paymentNetwork = decoded?.accepted?.network;
+        if (paymentNetwork && servers.has(paymentNetwork)) {
+          targetServer = servers.get(paymentNetwork);
+        }
+      } catch {
+      }
+      const verifyResult = await targetServer.verifyPayment(paymentSignature);
       if (!verifyResult.isValid) {
         log("Payment verification failed:", verifyResult.invalidReason);
         res.status(402).json({
@@ -428,7 +541,7 @@ function x402Middleware(config) {
         return;
       }
       log("Payment verified, settling...");
-      const settleResult = await server.settlePayment(paymentSignature);
+      const settleResult = await targetServer.settlePayment(paymentSignature);
       if (!settleResult.success) {
         log("Payment settlement failed:", settleResult.errorReason);
         res.status(402).json({
@@ -438,18 +551,39 @@ function x402Middleware(config) {
         return;
       }
       log("Payment settled:", settleResult.transaction);
+      const settledNetwork = settleResult.network || configuredNetworks[0];
       req.x402 = {
         transaction: settleResult.transaction,
         payer: verifyResult.payer ?? "",
-        network
+        network: settledNetwork
       };
       const paymentResponseData = {
         success: true,
         transaction: settleResult.transaction,
-        network,
+        network: settledNetwork,
         payer: verifyResult.payer ?? ""
       };
+      if (settleResult.extensions) {
+        paymentResponseData.extensions = settleResult.extensions;
+      }
       res.setHeader("PAYMENT-RESPONSE", encodeBase64Json(paymentResponseData));
+      if (config.sponsoredAccess && settleResult.extensions?.["sponsored-access"]) {
+        const extData = settleResult.extensions["sponsored-access"];
+        const recs = extData?.info?.recommendations;
+        if (recs && recs.length > 0) {
+          log("Injecting sponsored-access recommendations into response");
+          const originalJson = res.json.bind(res);
+          res.json = function patchedJson(body) {
+            if (typeof config.sponsoredAccess === "object" && config.sponsoredAccess.inject) {
+              return originalJson(config.sponsoredAccess.inject(body, recs));
+            }
+            if (body && typeof body === "object" && !Array.isArray(body)) {
+              return originalJson({ _x402_sponsored: recs, ...body });
+            }
+            return originalJson(body);
+          };
+        }
+      }
       next();
     } catch (error) {
       log("Middleware error:", error);
@@ -1883,13 +2017,9 @@ function stripePayTo(secretKeyOrConfig) {
       amount: amountInCents,
       currency: "usd",
       payment_method_types: ["crypto"],
-      payment_method_data: {
-        type: "crypto"
-      },
+      payment_method_data: { type: "crypto" },
       payment_method_options: {
-        crypto: {
-          mode: "custom"
-        }
+        crypto: { mode: "custom" }
       },
       confirm: true
     });