@parallel-protocol/x402 0.5.3 → 0.7.0

package/dist/chunk-POU7EH3E.cjs

@@ -0,0 +1,755 @@
+'use strict';
+
+var chunkJPMK5YBU_cjs = require('./chunk-JPMK5YBU.cjs');
+var chains = require('@parallel-protocol/chains');
+var zod = require('zod');
+
+var PARALLEL_TOKENS = {
+  ethereum: {
+    usdp: "0x9B3a8f7CEC208e247d97dEE13313690977e24459",
+    susdp: "0xd3a452B305C8285c0Dd7b8537665c734d3D279eF",
+    usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    frxUSD: "0xCAcd6fd266aF91b8AeD52aCCc382b4e165586E29",
+    sfrxUSD: "0xcf62F905562626CfcDD2261162a51fd02Fc9c5b6",
+    USDe: "0x4c9EDD5852cd905f086C759E8383e09bff1E68B3",
+    sUSDe: "0x9D39A5DE30e57443BfF2A8307A4256c8797A3497"
+  },
+  base: {
+    usdp: "0x76A9A0062ec6712b99B4f63bD2b4270185759dd5",
+    susdp: "0x472eD57b376fE400259FB28e5C46eB53f0E3e7E7",
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    USDS: "0x820C137fa70C8691f0e44Dc420a5e53c168921Dc",
+    sUSDS: "0x5875eEE11Cf8398102FdAd704C9E96607675467a"
+  },
+  avalanche: {
+    usdp: "0x9eE1963f05553eF838604Dd39403be21ceF26AA4",
+    susdp: "0x9d92c21205383651610f90722131655a5b8ed3e0",
+    usdc: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+    ygamiUSDC: "0x9fD32FD5e32C6B95483d36C5E724C5C5250Ce010"
+  },
+  hyperevm: {
+    usdp: "0xBE65F0F410A72BeC163dC65d46c83699e957D588",
+    susdp: "0x9B3a8f7CEC208e247d97dEE13313690977e24459",
+    usdc: "0xb88339cb7199b77e23db6e890353e22632ba630f",
+    USDe: "0x5d3a1Ff2b6BAb83b63cd9AD0787074081a52ef34",
+    sUSDe: "0x211Cc4DD073734dA055fbF44a2b4667d5E5fE5d2"
+  }
+};
+function getDefaultAcceptedTokens(network) {
+  const entry = PARALLEL_TOKENS[network];
+  if (!entry) return void 0;
+  return [entry.usdp, entry.usdc, entry.susdp];
+}
+function getMeteredAcceptedTokens(network) {
+  const entry = PARALLEL_TOKENS[network];
+  if (!entry) return void 0;
+  return [entry.usdp];
+}
+function getTokenDecimals(network, address) {
+  return chains.getTokenDecimals(network, address);
+}
+
+// src/utils.ts
+var EIP155_NETWORKS = {
+  ethereum: "eip155:1",
+  base: "eip155:8453",
+  avalanche: "eip155:43114",
+  hyperevm: "eip155:999"
+};
+function parseDecimalAmount(amount, decimals) {
+  const multiplier = 10n ** BigInt(decimals);
+  const parts = amount.split(".");
+  const whole = parts[0] ?? "0";
+  const fraction = (parts[1] ?? "").padEnd(decimals, "0").slice(0, decimals);
+  return BigInt(whole) * multiplier + BigInt(fraction || "0");
+}
+function parsePrice(price, decimals = 18) {
+  if (typeof price === "bigint") return price;
+  const match = price.match(/^(\d+(?:\.\d+)?)$/);
+  if (match?.[1]) return parseDecimalAmount(match[1], decimals);
+  throw new Error(
+    `Invalid price format: "${price}". Expected "0.01" or a bigint.`
+  );
+}
+function isJsonContentType(contentType) {
+  return /^application\/(?:[\w.-]+\+)?json(?:\s*;.*)?$/i.test(
+    contentType?.trim() ?? ""
+  );
+}
+function parseJsonBody(contentType, text) {
+  if (text === void 0 || !isJsonContentType(contentType)) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+async function jsonFromResponse(res) {
+  const contentType = res.headers.get("content-type") ?? void 0;
+  if (!isJsonContentType(contentType)) return void 0;
+  try {
+    return parseJsonBody(contentType, await res.clone().text());
+  } catch {
+    return void 0;
+  }
+}
+function validateAddress(address) {
+  return /^0x[0-9a-fA-F]{40}$/.test(address);
+}
+function toEip155Network(network) {
+  if (network.startsWith("eip155:")) return network;
+  return EIP155_NETWORKS[network] ?? `eip155:${network}`;
+}
+function encodeBase64(obj) {
+  return Buffer.from(JSON.stringify(obj)).toString("base64");
+}
+function decodeBase64(str) {
+  return JSON.parse(Buffer.from(str, "base64").toString("utf8"));
+}
+function matchRoute(path, routes) {
+  if (routes[path]) return routes[path];
+  let bestMatch;
+  let bestLength = 0;
+  for (const [pattern, config] of Object.entries(routes)) {
+    if (path.startsWith(`${pattern}/`) && pattern.length > bestLength) {
+      bestMatch = config;
+      bestLength = pattern.length;
+    }
+  }
+  return bestMatch;
+}
+var ethereumAddressSchema = zod.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "Invalid Ethereum address");
+var txHashSchema = zod.z.string().regex(/^0x[0-9a-fA-F]{64}$/);
+var priceSchema = zod.z.union([
+  zod.z.bigint().positive("Price must be greater than 0"),
+  zod.z.string().regex(/^\d+(?:\.\d+)?$/, 'Price must be in format "0.01"').refine((price) => Number(price) > 0, "Price must be greater than 0"),
+  // A per-request price function; its return value is checked per request.
+  zod.z.custom(
+    (value) => typeof value === "function",
+    "Price must be a string, a bigint or a function of the request"
+  )
+]);
+var facilitatorConfigSchema = zod.z.object({
+  url: zod.z.string().refine((v) => URL.canParse(v), "Invalid facilitator URL"),
+  apiKey: zod.z.string().optional()
+});
+var UPTO_MAX_TIMEOUT_SECONDS = 3600;
+var routeConfigSchema = zod.z.object({
+  price: priceSchema,
+  network: zod.z.string().min(1, "Network is required"),
+  payTo: ethereumAddressSchema,
+  acceptedTokens: zod.z.array(ethereumAddressSchema).optional(),
+  description: zod.z.string().optional(),
+  scheme: zod.z.enum(["exact", "upto"]).optional(),
+  maxTimeoutSeconds: zod.z.number().int().positive().optional(),
+  meter: zod.z.custom(
+    (value) => typeof value === "function",
+    "meter must be a function of the response"
+  ).optional()
+}).refine(
+  (route) => route.meter === void 0 || route.scheme === "upto",
+  "meter only applies to upto routes"
+).refine(
+  (route) => route.scheme !== "upto" || (route.maxTimeoutSeconds ?? 300) <= UPTO_MAX_TIMEOUT_SECONDS,
+  `maxTimeoutSeconds must be at most ${UPTO_MAX_TIMEOUT_SECONDS} on an upto route`
+).refine((route) => {
+  if (route.scheme !== "upto" || !route.acceptedTokens?.length) return true;
+  const usdp = PARALLEL_TOKENS[route.network]?.usdp;
+  if (!usdp) return true;
+  return route.acceptedTokens.every(
+    (token) => token.toLowerCase() === usdp.toLowerCase()
+  );
+}, "acceptedTokens on an upto route may only list the network's USDp");
+var paymentMiddlewareConfigSchema = zod.z.object({
+  facilitator: facilitatorConfigSchema,
+  routes: zod.z.record(zod.z.string(), routeConfigSchema).refine((r) => Object.keys(r).length > 0, "At least one route is required")
+});
+var facilitatorResponseSchema = zod.z.discriminatedUnion("success", [
+  zod.z.object({
+    success: zod.z.literal(true),
+    txHash: txHashSchema,
+    route: zod.z.string(),
+    chain: zod.z.string(),
+    gasSponsored: zod.z.boolean(),
+    networkId: zod.z.string(),
+    amountSettled: zod.z.string().optional()
+  }),
+  zod.z.object({
+    success: zod.z.literal(false),
+    error: zod.z.object({
+      code: zod.z.string(),
+      message: zod.z.string(),
+      hint: zod.z.string().optional()
+    })
+  })
+]);
+var verifyResponseSchema = zod.z.object({
+  isValid: zod.z.literal(true)
+});
+var settleSuccessSchema = zod.z.object({
+  txHash: txHashSchema,
+  route: zod.z.string(),
+  gasSponsored: zod.z.boolean(),
+  // Metered routes: the amount actually charged (smallest unit).
+  amountSettled: zod.z.string().optional()
+});
+var settleErrorSchema = zod.z.object({
+  error: zod.z.string(),
+  message: zod.z.string()
+});
+var settleResponseSchema = zod.z.union([
+  settleSuccessSchema,
+  settleErrorSchema
+]);
+
+// src/client.ts
+var FACILITATOR_TIMEOUT_MS = 1e4;
+var SETTLE_TIMEOUT_MS = 6e4;
+function decodePaymentHeader(paymentHeader) {
+  try {
+    return decodeBase64(paymentHeader);
+  } catch {
+    throw new chunkJPMK5YBU_cjs.X402RuntimeError(chunkJPMK5YBU_cjs.X402_ERROR_CODES.INVALID_PAYMENT);
+  }
+}
+var FacilitatorClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async verify(paymentHeader, paymentRequirements) {
+    const paymentPayload = decodePaymentHeader(paymentHeader);
+    let json;
+    try {
+      const response = await fetch(`${this.config.url}/x402/verify`, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({ paymentPayload, paymentRequirements }),
+        signal: AbortSignal.timeout(FACILITATOR_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => null);
+        const code = errorBody?.error ?? chunkJPMK5YBU_cjs.X402_ERROR_CODES.FACILITATOR_UNAVAILABLE;
+        throw new chunkJPMK5YBU_cjs.X402RuntimeError(code);
+      }
+      json = await response.json();
+    } catch (e) {
+      if (e instanceof chunkJPMK5YBU_cjs.X402RuntimeError) throw e;
+      throw new chunkJPMK5YBU_cjs.X402RuntimeError(chunkJPMK5YBU_cjs.X402_ERROR_CODES.FACILITATOR_UNAVAILABLE);
+    }
+    try {
+      verifyResponseSchema.parse(json);
+    } catch {
+      throw new chunkJPMK5YBU_cjs.X402RuntimeError(chunkJPMK5YBU_cjs.X402_ERROR_CODES.FACILITATOR_INVALID_RESPONSE);
+    }
+  }
+  async settle(paymentHeader, paymentRequirements, options) {
+    const paymentPayload = decodePaymentHeader(paymentHeader);
+    let json;
+    try {
+      const response = await fetch(`${this.config.url}/x402/settle`, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        // settleAmount only travels for metered routes — exact bodies are unchanged.
+        body: JSON.stringify({
+          paymentPayload,
+          paymentRequirements,
+          ...options?.amount !== void 0 && {
+            settleAmount: options.amount
+          }
+        }),
+        signal: AbortSignal.timeout(SETTLE_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => null);
+        const code = errorBody?.error ?? "SUBMISSION_FAILED";
+        const message = errorBody?.message ?? "Settlement failed";
+        return { success: false, error: { code, message } };
+      }
+      json = await response.json();
+    } catch (e) {
+      if (e instanceof chunkJPMK5YBU_cjs.X402RuntimeError) throw e;
+      throw new chunkJPMK5YBU_cjs.X402RuntimeError(chunkJPMK5YBU_cjs.X402_ERROR_CODES.FACILITATOR_UNAVAILABLE);
+    }
+    try {
+      const parsed = settleResponseSchema.parse(json);
+      if ("txHash" in parsed) {
+        return {
+          success: true,
+          txHash: parsed.txHash,
+          route: parsed.route,
+          chain: paymentRequirements.network,
+          gasSponsored: parsed.gasSponsored,
+          networkId: toEip155Network(paymentRequirements.network),
+          ...parsed.amountSettled !== void 0 && {
+            amountSettled: parsed.amountSettled
+          }
+        };
+      }
+      return {
+        success: false,
+        error: { code: parsed.error, message: parsed.message }
+      };
+    } catch {
+      throw new chunkJPMK5YBU_cjs.X402RuntimeError(chunkJPMK5YBU_cjs.X402_ERROR_CODES.FACILITATOR_INVALID_RESPONSE);
+    }
+  }
+  async pay(paymentHeader) {
+    const headers = this.buildHeaders();
+    headers["X-PAYMENT"] = paymentHeader;
+    let json;
+    try {
+      const response = await fetch(`${this.config.url}/x402/pay`, {
+        method: "POST",
+        headers,
+        signal: AbortSignal.timeout(FACILITATOR_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        throw new chunkJPMK5YBU_cjs.X402RuntimeError(chunkJPMK5YBU_cjs.X402_ERROR_CODES.FACILITATOR_UNAVAILABLE);
+      }
+      json = await response.json();
+    } catch (e) {
+      if (e instanceof chunkJPMK5YBU_cjs.X402RuntimeError) throw e;
+      throw new chunkJPMK5YBU_cjs.X402RuntimeError(chunkJPMK5YBU_cjs.X402_ERROR_CODES.FACILITATOR_UNAVAILABLE);
+    }
+    try {
+      return facilitatorResponseSchema.parse(json);
+    } catch {
+      throw new chunkJPMK5YBU_cjs.X402RuntimeError(chunkJPMK5YBU_cjs.X402_ERROR_CODES.FACILITATOR_INVALID_RESPONSE);
+    }
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.apiKey) {
+      headers["X-API-Key"] = this.config.apiKey;
+    }
+    return headers;
+  }
+};
+
+// src/timeout.ts
+var HANDLER_TIMEOUT_MS = 3e4;
+var HANDLER_TIMEOUT = /* @__PURE__ */ Symbol("x402:handler-timeout");
+async function raceTimeout(promise, ms = HANDLER_TIMEOUT_MS) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(HANDLER_TIMEOUT), ms);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/middleware.ts
+var PRICE_FORMAT = /^\d+(?:\.\d+)?$/;
+async function requestContext(adapter) {
+  return {
+    method: adapter.getMethod(),
+    path: adapter.getPath(),
+    url: adapter.getUrl(),
+    header: (name) => adapter.getHeader(name),
+    body: adapter.getBody ? await adapter.getBody() : void 0
+  };
+}
+async function resolvePrice(config, ctx) {
+  if (typeof config.price !== "function") return config.price;
+  if (!ctx) throw new chunkJPMK5YBU_cjs.X402ConfigError("A price function needs the request");
+  let price;
+  try {
+    price = await config.price(ctx);
+  } catch (cause) {
+    if (chunkJPMK5YBU_cjs.isPriceRejection(cause)) throw cause;
+    throw new chunkJPMK5YBU_cjs.X402ConfigError(
+      `The price function of route "${config.network}${ctx.path}" threw`,
+      cause
+    );
+  }
+  const valid = typeof price === "bigint" ? price > 0n : typeof price === "string" && PRICE_FORMAT.test(price) && Number(price) > 0;
+  if (!valid) {
+    throw new chunkJPMK5YBU_cjs.X402ConfigError(
+      `The price function of route "${config.network}${ctx.path}" returned ${JSON.stringify(
+        typeof price === "bigint" ? price.toString() : price
+      )} \u2014 expected a positive amount like "0.01" or a bigint`
+    );
+  }
+  return price;
+}
+var SETTLE_AMOUNT_HEADER = "payment-settle-amount";
+var DEFAULT_MAX_TIMEOUT_SECONDS = 300;
+function handlerTimeoutFor(config) {
+  if ((config.scheme ?? "exact") !== "upto") return HANDLER_TIMEOUT_MS;
+  const seconds = config.maxTimeoutSeconds ?? DEFAULT_MAX_TIMEOUT_SECONDS;
+  return Math.max(HANDLER_TIMEOUT_MS, (seconds - 60) * 1e3);
+}
+function resolveSettleAmount(raw, maxAmount, decimals) {
+  if (raw === void 0)
+    return { kind: "settle", amount: maxAmount.toString() };
+  const value = raw.trim();
+  let amount;
+  try {
+    amount = parsePrice(value, decimals);
+  } catch {
+    return { kind: "invalid", reason: "malformed" };
+  }
+  const fraction = value.split(".")[1] ?? "";
+  if (fraction.length > decimals)
+    return { kind: "invalid", reason: "precision" };
+  if (amount === 0n) return { kind: "skip" };
+  if (amount > maxAmount) return { kind: "invalid", reason: "above-cap" };
+  return { kind: "settle", amount: amount.toString() };
+}
+var INVALID_SETTLE_AMOUNT_RESPONSE = {
+  error: "INVALID_SETTLE_AMOUNT",
+  message: `The handler set an invalid ${SETTLE_AMOUNT_HEADER} header \u2014 expected a decimal amount in token units, formatted like the route price and within the token's precision, at most the route price.`
+};
+var INVALID_METER_RESPONSE = {
+  error: "INVALID_SETTLE_AMOUNT",
+  message: "The route's meter function failed or returned something that is not an amount; the response was discarded and nothing was charged."
+};
+function invalidSettleAmountResponse(reason) {
+  return reason === "meter" ? INVALID_METER_RESPONSE : INVALID_SETTLE_AMOUNT_RESPONSE;
+}
+var AMOUNT_FORMAT = /^\d+(?:\.\d+)?$/;
+async function resolveCharge(verified, settleHeader, response) {
+  if (verified.meter) {
+    if (!verified.request) {
+      throw new chunkJPMK5YBU_cjs.X402ConfigError(
+        "A metered payment carries a meter but no request context"
+      );
+    }
+    let result;
+    try {
+      const body = await raceTimeout(
+        response.body(),
+        verified.handlerTimeoutMs
+      );
+      if (body === HANDLER_TIMEOUT) return { kind: "invalid", reason: "meter" };
+      result = await verified.meter({
+        status: response.status,
+        header: response.header,
+        body,
+        request: verified.request
+      });
+    } catch {
+      return { kind: "invalid", reason: "meter" };
+    }
+    if (result != null) {
+      let amount;
+      if (typeof result === "bigint") {
+        if (result < 0n) return { kind: "invalid", reason: "meter" };
+        amount = result;
+      } else if (typeof result === "string" && AMOUNT_FORMAT.test(result)) {
+        const fraction = result.split(".")[1] ?? "";
+        if (fraction.length > verified.decimals) {
+          return { kind: "invalid", reason: "meter" };
+        }
+        amount = parsePrice(result, verified.decimals);
+      } else {
+        return { kind: "invalid", reason: "meter" };
+      }
+      if (amount === 0n) return { kind: "skip" };
+      if (amount > verified.maxAmount) amount = verified.maxAmount;
+      return { kind: "settle", amount: amount.toString() };
+    }
+  }
+  return resolveSettleAmount(
+    settleHeader,
+    verified.maxAmount,
+    verified.decimals
+  );
+}
+function resolveAcceptedTokens(config) {
+  if (config.acceptedTokens?.length) {
+    return config.acceptedTokens;
+  }
+  const defaults = config.scheme === "upto" ? getMeteredAcceptedTokens(config.network) : getDefaultAcceptedTokens(config.network);
+  if (defaults) return defaults;
+  throw new chunkJPMK5YBU_cjs.X402ConfigError(
+    `acceptedTokens is required for network "${config.network}" \u2014 no defaults available for this chain`
+  );
+}
+function resolveDecimals(config, asset) {
+  const decimals = config.decimals ?? getTokenDecimals(config.network, asset);
+  if (decimals === void 0) {
+    throw new chunkJPMK5YBU_cjs.X402ConfigError(
+      `Unknown decimals for token ${asset} on "${config.network}" \u2014 add it to the @parallel-protocol/chains catalog or set the route's \`decimals\` explicitly`
+    );
+  }
+  return decimals;
+}
+function priceInUnits(price, decimals, asset) {
+  const units = parsePrice(price, decimals);
+  if (units === 0n) {
+    throw new chunkJPMK5YBU_cjs.X402ConfigError(
+      `Price ${typeof price === "bigint" ? price.toString() : `"${price}"`} is below the precision of token ${asset} (${decimals} decimals)`
+    );
+  }
+  return units.toString();
+}
+function buildPaymentRequired(url, config, resolvedTokens, price) {
+  const network = toEip155Network(config.network);
+  const accepts = resolvedTokens.map((asset) => {
+    const decimals = resolveDecimals(config, asset);
+    return {
+      scheme: config.scheme ?? "exact",
+      network,
+      asset,
+      amount: priceInUnits(price, decimals, asset),
+      payTo: config.payTo,
+      maxTimeoutSeconds: config.maxTimeoutSeconds ?? DEFAULT_MAX_TIMEOUT_SECONDS,
+      extra: { decimals }
+    };
+  });
+  return {
+    x402Version: 2,
+    resource: {
+      url,
+      description: config.description,
+      mimeType: "application/json"
+    },
+    accepts
+  };
+}
+function decodePaymentPayload(header) {
+  try {
+    const parsed = JSON.parse(
+      Buffer.from(header, "base64").toString("utf8")
+    );
+    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function deliveredToken(payload, chainTokens) {
+  if (payload.method === "depositWithAuthorization" || payload.payload?.depositAuthorization) {
+    return chainTokens?.susdp;
+  }
+  if (payload.method === "redeemWithAuthorization") return chainTokens?.usdp;
+  if (payload.swapParams?.tokenOut) return payload.swapParams.tokenOut;
+  if (payload.method === "partialRedeemWithAuthorization") {
+    return chainTokens?.usdp;
+  }
+  return payload.tokenIn ?? chainTokens?.usdp;
+}
+function resolveDeliveredAsset(header, config, resolvedTokens) {
+  const payload = decodePaymentPayload(header);
+  const target = payload ? deliveredToken(
+    payload,
+    PARALLEL_TOKENS[config.network]
+  ) : void 0;
+  const lower = target?.toLowerCase();
+  return resolvedTokens.find((token) => token.toLowerCase() === lower) ?? resolvedTokens[0];
+}
+function buildFacilitatorRequirements(config, asset, price) {
+  const decimals = resolveDecimals(config, asset);
+  const scheme = config.scheme ?? "exact";
+  return {
+    maxAmountRequired: priceInUnits(price, decimals, asset),
+    asset,
+    payTo: config.payTo,
+    network: config.network,
+    // Only metered routes name their scheme — exact requirements are unchanged.
+    ...scheme === "upto" && {
+      scheme,
+      maxTimeoutSeconds: config.maxTimeoutSeconds ?? DEFAULT_MAX_TIMEOUT_SECONDS
+    }
+  };
+}
+function paymentRequiredResponse(url, config, resolvedTokens, price, error) {
+  const paymentRequired = buildPaymentRequired(
+    url,
+    config,
+    resolvedTokens,
+    price
+  );
+  if (error) paymentRequired.error = error;
+  return {
+    status: 402,
+    headers: {
+      "Content-Type": "application/json",
+      "payment-required": encodeBase64(paymentRequired),
+      "access-control-expose-headers": "payment-required"
+    },
+    body: paymentRequired
+  };
+}
+function createPaymentGate(config) {
+  try {
+    paymentMiddlewareConfigSchema.parse(config);
+  } catch (cause) {
+    throw new chunkJPMK5YBU_cjs.X402ConfigError(
+      "Invalid paymentMiddleware config \u2014 check your routes, facilitator URL and payTo addresses",
+      cause
+    );
+  }
+  const client = new FacilitatorClient(config.facilitator);
+  return async (adapter) => {
+    if (adapter.getMethod().toUpperCase() === "OPTIONS")
+      return { type: "pass" };
+    const routeConfig = matchRoute(adapter.getPath(), config.routes);
+    if (!routeConfig) return { type: "pass" };
+    const resolvedTokens = resolveAcceptedTokens(routeConfig);
+    let request = typeof routeConfig.price === "function" ? await requestContext(adapter) : void 0;
+    let price;
+    try {
+      price = await resolvePrice(routeConfig, request);
+    } catch (err) {
+      if (!chunkJPMK5YBU_cjs.isPriceRejection(err)) throw err;
+      const status = Number.isInteger(err.status) && err.status >= 400 && err.status <= 599 ? err.status : 400;
+      return {
+        type: "error",
+        result: {
+          status,
+          headers: { "Content-Type": "application/json" },
+          body: { error: err.code, message: err.message }
+        }
+      };
+    }
+    const paymentHeader = adapter.getHeader("payment-signature") ?? adapter.getHeader("x-payment");
+    if (!paymentHeader) {
+      return {
+        type: "error",
+        result: paymentRequiredResponse(
+          adapter.getUrl(),
+          routeConfig,
+          resolvedTokens,
+          price
+        )
+      };
+    }
+    const asset = resolveDeliveredAsset(
+      paymentHeader,
+      routeConfig,
+      resolvedTokens
+    );
+    const requirements = buildFacilitatorRequirements(
+      routeConfig,
+      asset,
+      price
+    );
+    try {
+      await client.verify(paymentHeader, requirements);
+    } catch (e) {
+      const code = e instanceof chunkJPMK5YBU_cjs.X402RuntimeError ? e.code : chunkJPMK5YBU_cjs.X402_ERROR_CODES.FACILITATOR_UNAVAILABLE;
+      return {
+        type: "error",
+        result: paymentRequiredResponse(
+          adapter.getUrl(),
+          routeConfig,
+          resolvedTokens,
+          price,
+          code
+        )
+      };
+    }
+    if (routeConfig.meter && !request) request = await requestContext(adapter);
+    return {
+      type: "verified",
+      scheme: routeConfig.scheme ?? "exact",
+      maxAmount: BigInt(requirements.maxAmountRequired),
+      decimals: resolveDecimals(routeConfig, asset),
+      handlerTimeoutMs: handlerTimeoutFor(routeConfig),
+      // Exact routes keep the historical two-argument client call.
+      settle: (options) => options ? client.settle(paymentHeader, requirements, options) : client.settle(paymentHeader, requirements),
+      ...routeConfig.meter && { meter: routeConfig.meter, request }
+    };
+  };
+}
+function createPaymentMiddleware(config) {
+  const gate = createPaymentGate(config);
+  return async (adapter) => {
+    const gateResult = await gate(adapter);
+    if (gateResult.type === "pass") return { pass: true };
+    if (gateResult.type === "error") return gateResult.result;
+    let handlerResult;
+    try {
+      handlerResult = await adapter.runHandler({
+        timeoutMs: gateResult.handlerTimeoutMs
+      });
+    } catch {
+      return { pass: true, handlerRan: true };
+    }
+    let raw;
+    if (gateResult.scheme === "upto") {
+      raw = handlerResult.getResponseHeader?.(SETTLE_AMOUNT_HEADER);
+      handlerResult.removeResponseHeader?.(SETTLE_AMOUNT_HEADER);
+    }
+    if (handlerResult.status >= 200 && handlerResult.status < 300) {
+      let settleOptions;
+      if (gateResult.scheme === "upto") {
+        const resolved = await resolveCharge(gateResult, raw, {
+          status: handlerResult.status,
+          header: (name) => handlerResult.getResponseHeader?.(name),
+          body: async () => handlerResult.getResponseBody?.()
+        });
+        if (resolved.kind === "invalid") {
+          handlerResult.discardResponse();
+          return {
+            status: 402,
+            headers: { "Content-Type": "application/json" },
+            body: invalidSettleAmountResponse(resolved.reason)
+          };
+        }
+        if (resolved.kind === "skip") {
+          handlerResult.sendResponse();
+          return { pass: true, handlerRan: true };
+        }
+        settleOptions = { amount: resolved.amount };
+      }
+      let settled = false;
+      try {
+        const settleResponse = settleOptions ? await gateResult.settle(settleOptions) : await gateResult.settle();
+        if (settleResponse.success) {
+          handlerResult.setResponseHeader(
+            "payment-response",
+            encodeBase64(settleResponse)
+          );
+          handlerResult.setResponseHeader(
+            "access-control-expose-headers",
+            "payment-response"
+          );
+          settled = true;
+        }
+      } catch {
+      }
+      if (!settled) {
+        handlerResult.discardResponse();
+        return {
+          status: 402,
+          headers: { "Content-Type": "application/json" },
+          body: {
+            error: "PAYMENT_SETTLEMENT_FAILED",
+            message: "Payment could not be confirmed after multiple attempts. Please retry."
+          }
+        };
+      }
+    }
+    handlerResult.sendResponse();
+    return { pass: true, handlerRan: true };
+  };
+}
+
+exports.FacilitatorClient = FacilitatorClient;
+exports.HANDLER_TIMEOUT = HANDLER_TIMEOUT;
+exports.PARALLEL_TOKENS = PARALLEL_TOKENS;
+exports.SETTLE_AMOUNT_HEADER = SETTLE_AMOUNT_HEADER;
+exports.createPaymentGate = createPaymentGate;
+exports.createPaymentMiddleware = createPaymentMiddleware;
+exports.encodeBase64 = encodeBase64;
+exports.getDefaultAcceptedTokens = getDefaultAcceptedTokens;
+exports.invalidSettleAmountResponse = invalidSettleAmountResponse;
+exports.isJsonContentType = isJsonContentType;
+exports.jsonFromResponse = jsonFromResponse;
+exports.matchRoute = matchRoute;
+exports.parseJsonBody = parseJsonBody;
+exports.parsePrice = parsePrice;
+exports.raceTimeout = raceTimeout;
+exports.resolveCharge = resolveCharge;
+exports.resolveSettleAmount = resolveSettleAmount;
+exports.toEip155Network = toEip155Network;
+exports.validateAddress = validateAddress;