@relai-fi/x402 0.5.8 → 0.5.9

package/dist/index.js

@@ -22,6 +22,117 @@ var CHAIN_IDS = {
   "polygon": 137,
   "ethereum": 1
 };
+var NETWORK_TOKENS = {
+  "solana": [
+    {
+      address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 6
+    }
+  ],
+  "base": [
+    {
+      address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 6,
+      domainVersion: "2",
+      isStableUsd: true
+    }
+  ],
+  "avalanche": [
+    {
+      address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 6,
+      domainVersion: "2",
+      isStableUsd: true
+    }
+  ],
+  "skale-base": [
+    {
+      address: "0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20",
+      symbol: "USDC",
+      name: "Bridged USDC (SKALE Bridge)",
+      decimals: 6,
+      domainVersion: "2",
+      isStableUsd: true
+    },
+    {
+      address: "0x2bF5bF154b515EaA82C31a65ec11554fF5aF7fCA",
+      symbol: "USDT",
+      name: "Bridged USDT (SKALE Bridge)",
+      decimals: 6,
+      domainVersion: "2",
+      isStableUsd: true
+    },
+    {
+      address: "0x1aeeCFE5454c83B42D8A316246CAc9739E7f690e",
+      symbol: "WBTC",
+      name: "Wrapped Bitcoin",
+      decimals: 8,
+      domainVersion: "2",
+      isStableUsd: false
+    },
+    {
+      address: "0x7bD39ABBd0Dd13103542cAe3276C7fA332bCA486",
+      symbol: "WETH",
+      name: "Wrapped Ether",
+      decimals: 18,
+      domainVersion: "2",
+      isStableUsd: false
+    }
+  ],
+  "skale-base-sepolia": [
+    {
+      address: "0x2e08028E3C4c2356572E096d8EF835cD5C6030bD",
+      symbol: "USDC",
+      name: "Bridged USDC (SKALE Bridge)",
+      decimals: 6,
+      domainVersion: "2",
+      isStableUsd: true
+    }
+  ],
+  "skale-bite": [
+    {
+      address: "0xc4083B1E81ceb461Ccef3FDa8A9F24F0d764B6D8",
+      symbol: "USDC",
+      name: "USDC",
+      decimals: 6,
+      domainVersion: "1",
+      isStableUsd: true
+    }
+  ],
+  "polygon": [
+    {
+      address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 6,
+      domainVersion: "2",
+      isStableUsd: true
+    }
+  ],
+  "ethereum": [
+    {
+      address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 6,
+      domainVersion: "2",
+      isStableUsd: true
+    }
+  ]
+};
+function resolveToken(network, asset) {
+  const tokens = NETWORK_TOKENS[network];
+  if (!tokens || tokens.length === 0) return null;
+  if (!asset) return tokens[0];
+  const normalized = String(asset).toLowerCase();
+  return tokens.find((token) => token.address.toLowerCase() === normalized) || null;
+}
 var USDC_ADDRESSES = {
   "solana": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
   "base": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
@@ -96,9 +207,103 @@ function stripePayTo(stripeSecretKey, options) {
     stripeNetwork: options?.network || "base"
   };
 }
+var USD_PRICE_CACHE_TTL_MS = 60 * 1e3;
+var usdPriceCache = /* @__PURE__ */ new Map();
+var COINGECKO_ID_BY_SYMBOL = {
+  WETH: "ethereum",
+  WBTC: "bitcoin"
+};
+function isStableUsdToken(token) {
+  if (token.isStableUsd === true) return true;
+  const symbol = String(token.symbol || "").toUpperCase();
+  return symbol === "USDC" || symbol === "USDT";
+}
+async function fetchUsdPriceFromCoinGecko(coinId) {
+  const now = Date.now();
+  const cached = usdPriceCache.get(coinId);
+  if (cached && cached.expiresAt > now) {
+    return cached.usd;
+  }
+  const url = `https://api.coingecko.com/api/v3/simple/price?ids=${encodeURIComponent(coinId)}&vs_currencies=usd`;
+  const res = await fetch(url, {
+    method: "GET",
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!res.ok) {
+    throw new Error(`CoinGecko price request failed: HTTP ${res.status}`);
+  }
+  const payload = await res.json();
+  const usd = Number(payload?.[coinId]?.usd);
+  if (!Number.isFinite(usd) || usd <= 0) {
+    throw new Error(`CoinGecko returned invalid usd price for ${coinId}`);
+  }
+  usdPriceCache.set(coinId, {
+    usd,
+    expiresAt: now + USD_PRICE_CACHE_TTL_MS
+  });
+  return usd;
+}
+async function resolveAmountAtomicFromUsd({
+  priceUsd,
+  token,
+  network
+}) {
+  const decimals = Number(token.decimals);
+  if (!Number.isFinite(decimals) || decimals < 0) {
+    throw new Error(`Invalid token decimals for ${token.symbol || token.address}`);
+  }
+  if (isStableUsdToken(token)) {
+    const units = Math.floor(priceUsd * Math.pow(10, decimals));
+    return String(Math.max(1, units));
+  }
+  const symbol = String(token.symbol || "").toUpperCase();
+  const coinGeckoId = COINGECKO_ID_BY_SYMBOL[symbol];
+  if (!coinGeckoId) {
+    throw new Error(`No USD quote source configured for token ${symbol || token.address} on ${network}`);
+  }
+  const overrideEnv = process.env[`EVM_TOKEN_PRICE_${symbol}_USD`];
+  const usdPerToken = overrideEnv && Number(overrideEnv) > 0 ? Number(overrideEnv) : await fetchUsdPriceFromCoinGecko(coinGeckoId);
+  const tokenAmount = priceUsd / usdPerToken;
+  const rawUnits = tokenAmount * Math.pow(10, decimals);
+  if (!Number.isFinite(rawUnits) || rawUnits <= 0) {
+    throw new Error(
+      `Invalid conversion result for token ${symbol || token.address}: priceUsd=${priceUsd}, usdPerToken=${usdPerToken}`
+    );
+  }
+  return String(Math.max(1, Math.floor(rawUnits)));
+}
 function isStripePayTo(payTo) {
   return typeof payTo === "object" && payTo !== null && payTo.__brand === "stripePayTo";
 }
+function parseBooleanHeader(value) {
+  if (value == null) return null;
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "off") {
+    return false;
+  }
+  return null;
+}
+function normalizeIntegritasFlow(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (normalized === "single") return "single";
+  if (normalized === "dual") return "dual";
+  return void 0;
+}
+function normalizeIntegritasOptions(value) {
+  if (value === true) return { enabled: true };
+  if (value === false || value == null) return { enabled: false };
+  const flow = normalizeIntegritasFlow(value.flow);
+  const enabled = typeof value.enabled === "boolean" ? value.enabled : true;
+  return {
+    enabled,
+    ...flow ? { flow } : {}
+  };
+}
 async function createStripeDepositAddress(secretKey, amountUsdCents, network = "base") {
   const params = new URLSearchParams();
   params.append("amount", String(amountUsdCents));
@@ -193,8 +398,45 @@ var Relai = class {
         const stripeConfig = isStripePayTo(options.payTo) ? options.payTo : null;
         const network = stripeConfig ? stripeConfig.stripeNetwork || "base" : options.network || self.network;
         const caip2 = NETWORK_CAIP2[network];
-        const asset = USDC_ADDRESSES[network];
-        const amount = String(Math.floor(resolvedPrice * 1e6));
+        const requestedAsset = typeof options.asset === "string" && options.asset.trim() !== "" ? options.asset.trim() : void 0;
+        const explicitToken = requestedAsset ? resolveToken(network, requestedAsset) : null;
+        if (requestedAsset && !explicitToken) {
+          return res.status(400).json({
+            error: `Unsupported asset ${requestedAsset} for network ${network}`
+          });
+        }
+        const fallbackToken = {
+          address: USDC_ADDRESSES[network],
+          symbol: "USDC",
+          name: network === "skale-bite" ? "USDC" : "USD Coin",
+          decimals: 6,
+          domainVersion: network === "skale-bite" ? "1" : "2",
+          isStableUsd: true
+        };
+        const token = explicitToken || resolveToken(network) || fallbackToken;
+        const asset = token.address;
+        const tokenName = token.name || "USD Coin";
+        const tokenVersion = token.domainVersion || (network === "skale-bite" ? "1" : "2");
+        const tokenDecimals = Number.isFinite(Number(token.decimals)) ? Number(token.decimals) : 6;
+        let amount;
+        try {
+          amount = await resolveAmountAtomicFromUsd({
+            priceUsd: resolvedPrice,
+            token,
+            network
+          });
+        } catch (err) {
+          console.error("[Relai] Failed to convert USD amount to token units:", err);
+          return res.status(500).json({
+            error: "Failed to quote token amount for payment requirements"
+          });
+        }
+        const configuredIntegritas = normalizeIntegritasOptions(options.integritas);
+        const headerIntegritasEnabled = parseBooleanHeader(req.headers["x-integritas"]);
+        const headerIntegritasFlow = normalizeIntegritasFlow(req.headers["x-integritas-flow"]);
+        const integritasEnabled = headerIntegritasEnabled === null ? configuredIntegritas.enabled : headerIntegritasEnabled;
+        const integritasFlow = headerIntegritasFlow || configuredIntegritas.flow;
+        const integritasMode = integritasFlow === "single" ? "single_signature_fee_included" : integritasFlow === "dual" ? "dual_signature_split" : void 0;
         const paymentHeader = req.headers["x-payment"] || req.headers["payment-signature"] || req.headers["x-payment-signature"];
         if (!paymentHeader) {
           options.onPaymentRequired?.(req, { price: resolvedPrice, network });
@@ -210,23 +452,6 @@ var Relai = class {
             resolvedPayTo = options.payTo;
           }
           const feePayer = await self.getFeePayer(caip2);
-          const tokenMetadata = {
-            "eip155:103698795": { name: "USDC", version: "1" },
-            // SKALE BITE
-            "eip155:1187947933": { name: "Bridged USDC (SKALE Bridge)", version: "2" },
-            // SKALE Base
-            "eip155:324705682": { name: "Bridged USDC (SKALE Bridge)", version: "2" },
-            // SKALE Base Sepolia
-            "eip155:8453": { name: "USD Coin", version: "2" },
-            // Base
-            "eip155:43114": { name: "USD Coin", version: "2" },
-            // Avalanche
-            "eip155:137": { name: "USD Coin", version: "2" },
-            // Polygon
-            "eip155:1": { name: "USD Coin", version: "2" }
-            // Ethereum
-          };
-          const metadata = tokenMetadata[caip2] || { name: "USDC", version: "1" };
           return res.status(402).json({
             x402Version: 2,
             error: "Payment required",
@@ -243,13 +468,28 @@ var Relai = class {
               payTo: resolvedPayTo,
               maxTimeoutSeconds: options.maxTimeoutSeconds || 60,
               extra: {
-                name: metadata.name,
-                version: metadata.version,
-                decimals: 6,
-                ...feePayer && { feePayer }
+                name: tokenName,
+                version: tokenVersion,
+                decimals: tokenDecimals,
+                symbol: token.symbol,
+                ...feePayer && { feePayer },
                 // Add feePayer if available
+                ...integritasEnabled ? { integritasEnabled: true } : {},
+                ...integritasFlow ? { integritasFlow } : {},
+                ...integritasMode ? { integritasMode } : {},
+                ...integritasFlow === "single" ? { integritasSingleSignature: true } : {}
+              }
+            }],
+            ...configuredIntegritas.enabled || integritasEnabled || !!integritasFlow ? {
+              extensions: {
+                integritas: {
+                  available: true,
+                  selectedFlow: integritasFlow || null,
+                  availableFlows: ["single", "dual"],
+                  enabled: integritasEnabled
+                }
               }
-            }]
+            } : {}
           });
         }
         let paymentProof;
@@ -284,7 +524,15 @@ var Relai = class {
           amount,
           asset,
           payTo: settlePayTo,
-          maxTimeoutSeconds: options.maxTimeoutSeconds || 60
+          maxTimeoutSeconds: options.maxTimeoutSeconds || 60,
+          ...integritasEnabled ? {
+            extra: {
+              integritasEnabled: true,
+              ...integritasFlow ? { integritasFlow } : {},
+              ...integritasMode ? { integritasMode } : {},
+              ...integritasFlow === "single" ? { integritasSingleSignature: true } : {}
+            }
+          } : {}
         };
         const settleUrl = `${self.facilitatorUrl}/settle`;
         const settleRes = await fetch(settleUrl, {
@@ -374,12 +622,32 @@ function createX402Client(config) {
     wallets = {},
     wallet: legacyWallet,
     facilitatorUrl = RELAI_FACILITATOR_URL,
+    relayWs,
     preferredNetwork,
     solanaRpcUrl = "https://api.mainnet-beta.solana.com",
     evmRpcUrls = {},
     maxAmountAtomic,
+    integritas,
     verbose = false
   } = config;
+  const relayWsEnabled = relayWs?.enabled === true;
+  const relayWsPreflightTimeoutMs = relayWs?.preflightTimeoutMs ?? 5e3;
+  const relayWsPaymentTimeoutMs = relayWs?.paymentTimeoutMs ?? 1e4;
+  const relayWsFallbackToHttp = relayWs?.fallbackToHttp ?? true;
+  const defaultIntegritas = normalizeIntegritasOptions2(integritas);
+  const relayWsReservedSubdomains = /* @__PURE__ */ new Set([
+    "www",
+    "api",
+    "localhost",
+    "admin",
+    "app",
+    "dashboard",
+    "docs",
+    "documentation",
+    "status",
+    "blog",
+    "facilitator"
+  ]);
   const log = verbose ? console.log.bind(console, "[relai-x402]") : () => {
   };
   const effectiveWallets = { ...wallets };
@@ -390,6 +658,408 @@ function createX402Client(config) {
     effectiveWallets.solana?.publicKey && effectiveWallets.solana?.signTransaction
   );
   if (hasSolanaWallet) log("Solana wallet ready");
+  function isRecord(value) {
+    return typeof value === "object" && value !== null;
+  }
+  function parseJsonSafe(value) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  function addSocketListener(socket, eventName, listener) {
+    if (socket.addEventListener) {
+      socket.addEventListener(eventName, listener);
+      return;
+    }
+    if (socket.on) {
+      socket.on(eventName, listener);
+    }
+  }
+  function removeSocketListener(socket, eventName, listener) {
+    if (socket.removeEventListener) {
+      socket.removeEventListener(eventName, listener);
+      return;
+    }
+    if (socket.off) {
+      socket.off(eventName, listener);
+      return;
+    }
+    if (socket.removeListener) {
+      socket.removeListener(eventName, listener);
+    }
+  }
+  function resolveRelayWsUrl(relayUrl) {
+    if (relayWs?.wsUrl && relayWs.wsUrl.trim() !== "") {
+      return relayWs.wsUrl.trim();
+    }
+    const parsedRelayUrl = new URL(relayUrl);
+    const wsProtocol = parsedRelayUrl.protocol === "https:" ? "wss:" : "ws:";
+    return `${wsProtocol}//${parsedRelayUrl.host}/api/ws/relay`;
+  }
+  function resolveRelayWhitelabel(parsedRelayUrl) {
+    const hostParts = parsedRelayUrl.hostname.toLowerCase().split(".").filter(Boolean);
+    if (hostParts.length < 2) {
+      return null;
+    }
+    const candidate = decodeURIComponent(hostParts[0] || "").trim();
+    if (!candidate) {
+      return null;
+    }
+    if (relayWsReservedSubdomains.has(candidate.toLowerCase())) {
+      return null;
+    }
+    const lastPart = hostParts[hostParts.length - 1];
+    const secondLastPart = hostParts[hostParts.length - 2];
+    const isX402WhitelabelHost = hostParts.length >= 3 && secondLastPart === "x402" && lastPart === "fi";
+    const isLocalWhitelabelHost = hostParts.length === 2 && lastPart === "localhost";
+    if (!isX402WhitelabelHost && !isLocalWhitelabelHost) {
+      return null;
+    }
+    return candidate;
+  }
+  function resolveRelayTarget(relayUrl) {
+    const parsedRelayUrl = new URL(relayUrl);
+    const match = parsedRelayUrl.pathname.match(/\/relay\/([^/]+)(\/.*)?$/);
+    if (match) {
+      const apiId = decodeURIComponent(match[1]);
+      const pathPart2 = match[2] || "/";
+      return {
+        apiId,
+        path: `${pathPart2}${parsedRelayUrl.search || ""}`
+      };
+    }
+    const whitelabel = resolveRelayWhitelabel(parsedRelayUrl);
+    if (!whitelabel) {
+      throw new Error(
+        `[relai-x402] Unsupported relay URL format for WS transport: ${relayUrl}. Expected /relay/:apiId/... or <whitelabel>.x402.fi/...`
+      );
+    }
+    const pathPart = parsedRelayUrl.pathname && parsedRelayUrl.pathname !== "" ? parsedRelayUrl.pathname : "/";
+    return {
+      apiId: whitelabel,
+      path: `${pathPart}${parsedRelayUrl.search || ""}`
+    };
+  }
+  function isRelayRequestUrl(requestUrl) {
+    try {
+      resolveRelayTarget(requestUrl);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function headersToRecord(headersInit) {
+    if (!headersInit) return {};
+    const output = {};
+    if (typeof Headers !== "undefined" && headersInit instanceof Headers) {
+      headersInit.forEach((value, key) => {
+        output[key] = value;
+      });
+      return output;
+    }
+    if (Array.isArray(headersInit)) {
+      for (const [key, value] of headersInit) {
+        output[key] = value;
+      }
+      return output;
+    }
+    for (const [key, value] of Object.entries(headersInit)) {
+      if (typeof value === "string") {
+        output[key] = value;
+      } else if (Array.isArray(value)) {
+        output[key] = value.join(", ");
+      } else if (value !== void 0 && value !== null) {
+        output[key] = String(value);
+      }
+    }
+    return output;
+  }
+  function hasHeaderCaseInsensitive(headers, headerName) {
+    const normalized = headerName.toLowerCase();
+    return Object.keys(headers).some((key) => key.toLowerCase() === normalized);
+  }
+  function normalizeIntegritasFlow2(value) {
+    const normalized = String(value || "").trim().toLowerCase();
+    if (normalized === "single") return "single";
+    if (normalized === "dual") return "dual";
+    return void 0;
+  }
+  function normalizeIntegritasOptions2(value) {
+    if (value === true) return { enabled: true };
+    if (value === false || value == null) return { enabled: false };
+    const flow = normalizeIntegritasFlow2(value.flow);
+    const enabled = typeof value.enabled === "boolean" ? value.enabled : true;
+    return {
+      enabled,
+      ...flow ? { flow } : {}
+    };
+  }
+  function resolveIntegritasOptions(override) {
+    if (override === void 0) {
+      return defaultIntegritas;
+    }
+    if (typeof override === "boolean") {
+      return {
+        enabled: override,
+        ...override && defaultIntegritas.flow ? { flow: defaultIntegritas.flow } : {}
+      };
+    }
+    const flow = normalizeIntegritasFlow2(override.flow) || defaultIntegritas.flow;
+    const enabled = typeof override.enabled === "boolean" ? override.enabled : defaultIntegritas.enabled;
+    return {
+      enabled,
+      ...enabled && flow ? { flow } : {}
+    };
+  }
+  function stripInternalInit(init) {
+    if (!init) return void 0;
+    const { x402: _x402, ...requestInit } = init;
+    return requestInit;
+  }
+  function applyIntegritasHeaders(headers, options) {
+    if (!options.enabled) return headers;
+    if (!hasHeaderCaseInsensitive(headers, "x-integritas")) {
+      headers["X-Integritas"] = "true";
+    }
+    if (options.flow && !hasHeaderCaseInsensitive(headers, "x-integritas-flow")) {
+      headers["X-Integritas-Flow"] = options.flow;
+    }
+    return headers;
+  }
+  function getRequestMethod(input, init) {
+    const inputMethod = input instanceof Request ? input.method : void 0;
+    return (init?.method || inputMethod || "GET").toUpperCase();
+  }
+  async function bodyInitToWsPayload(bodyInit) {
+    if (bodyInit === void 0 || bodyInit === null) {
+      return void 0;
+    }
+    if (typeof bodyInit === "string") {
+      const parsed = parseJsonSafe(bodyInit);
+      return parsed === null ? bodyInit : parsed;
+    }
+    if (typeof URLSearchParams !== "undefined" && bodyInit instanceof URLSearchParams) {
+      return bodyInit.toString();
+    }
+    if (typeof FormData !== "undefined" && bodyInit instanceof FormData) {
+      const entries = {};
+      for (const [key, value] of bodyInit.entries()) {
+        entries[key] = typeof value === "string" ? value : value.name;
+      }
+      return entries;
+    }
+    if (typeof Blob !== "undefined" && bodyInit instanceof Blob) {
+      const text = await bodyInit.text();
+      if (!text) return void 0;
+      const parsed = parseJsonSafe(text);
+      return parsed === null ? text : parsed;
+    }
+    if (bodyInit instanceof ArrayBuffer) {
+      return Array.from(new Uint8Array(bodyInit));
+    }
+    if (ArrayBuffer.isView(bodyInit)) {
+      return Array.from(new Uint8Array(bodyInit.buffer, bodyInit.byteOffset, bodyInit.byteLength));
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(bodyInit)) {
+      return Array.from(bodyInit.values());
+    }
+    if (isRecord(bodyInit)) {
+      return bodyInit;
+    }
+    return String(bodyInit);
+  }
+  async function resolveRequestBody(input, init) {
+    if (init && Object.prototype.hasOwnProperty.call(init, "body")) {
+      return bodyInitToWsPayload(init.body);
+    }
+    if (input instanceof Request) {
+      const method = getRequestMethod(input, init);
+      if (method === "GET" || method === "HEAD") {
+        return void 0;
+      }
+      try {
+        const cloned = input.clone();
+        const text = await cloned.text();
+        if (!text) return void 0;
+        const parsed = parseJsonSafe(text);
+        return parsed === null ? text : parsed;
+      } catch {
+        return void 0;
+      }
+    }
+    return void 0;
+  }
+  function getRequestHeaders(input, init) {
+    const fromInput = input instanceof Request ? headersToRecord(input.headers) : {};
+    const fromInit = headersToRecord(init?.headers);
+    const merged = {
+      ...fromInput,
+      ...fromInit
+    };
+    if (!merged.Accept && !merged.accept) {
+      merged.Accept = "application/json";
+    }
+    return merged;
+  }
+  function toMessageString(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    if (isRecord(data) && typeof data.data !== "undefined") {
+      return toMessageString(data.data);
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
+      return data.toString("utf8");
+    }
+    if (data instanceof ArrayBuffer) {
+      const bytes = new Uint8Array(data);
+      if (typeof Buffer !== "undefined") {
+        return Buffer.from(bytes).toString("utf8");
+      }
+      if (typeof TextDecoder !== "undefined") {
+        return new TextDecoder().decode(bytes);
+      }
+      throw new Error("Unsupported WebSocket message data type");
+    }
+    if (ArrayBuffer.isView(data)) {
+      const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+      if (typeof Buffer !== "undefined") {
+        return Buffer.from(bytes).toString("utf8");
+      }
+      if (typeof TextDecoder !== "undefined") {
+        return new TextDecoder().decode(bytes);
+      }
+      throw new Error("Unsupported WebSocket message data type");
+    }
+    throw new Error("Unsupported WebSocket message data type");
+  }
+  function getWebSocketFactory() {
+    if (relayWs?.webSocketFactory) {
+      return relayWs.webSocketFactory;
+    }
+    if (typeof WebSocket !== "undefined") {
+      return (wsUrl) => new WebSocket(wsUrl);
+    }
+    throw new Error(
+      "[relai-x402] WebSocket is not available in this runtime. Provide relayWs.webSocketFactory."
+    );
+  }
+  async function relayCallOverWebSocket(request) {
+    const wsFactory = getWebSocketFactory();
+    const wsUrl = resolveRelayWsUrl(request.relayUrl);
+    const target = resolveRelayTarget(request.relayUrl);
+    const requestId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const socket = wsFactory(wsUrl);
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const settleResolve = (value) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        try {
+          socket.close();
+        } catch {
+        }
+        resolve(value);
+      };
+      const settleReject = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        try {
+          socket.close();
+        } catch {
+        }
+        reject(error);
+      };
+      const timeoutId = setTimeout(() => {
+        settleReject(new Error(`[relai-x402] Timed out waiting for WS relay response after ${request.timeoutMs}ms`));
+      }, request.timeoutMs);
+      const cleanup = () => {
+        clearTimeout(timeoutId);
+        removeSocketListener(socket, "open", onOpen);
+        removeSocketListener(socket, "message", onMessage);
+        removeSocketListener(socket, "error", onError);
+        removeSocketListener(socket, "close", onClose);
+      };
+      const onOpen = () => {
+        const envelope = {
+          id: requestId,
+          method: "relay.call",
+          params: {
+            apiId: target.apiId,
+            path: target.path,
+            requestMethod: request.requestMethod,
+            requestHeaders: request.requestHeaders,
+            ...request.requestBody !== void 0 ? { requestBody: request.requestBody } : {}
+          }
+        };
+        if (request.paymentPayload !== void 0) {
+          envelope.payment = request.paymentPayload;
+        }
+        try {
+          socket.send(JSON.stringify(envelope));
+        } catch {
+          settleReject(new Error("[relai-x402] Failed to send WS relay request"));
+        }
+      };
+      const onMessage = (...args) => {
+        const payload = args.length > 0 ? args[0] : void 0;
+        let parsed;
+        try {
+          parsed = parseJsonSafe(toMessageString(payload));
+        } catch {
+          return;
+        }
+        if (!isRecord(parsed)) return;
+        const responseId = typeof parsed.id === "string" || typeof parsed.id === "number" ? String(parsed.id) : "";
+        if (responseId !== requestId) return;
+        settleResolve(parsed);
+      };
+      const onError = () => {
+        settleReject(new Error("[relai-x402] WebSocket relay transport error"));
+      };
+      const onClose = () => {
+        settleReject(new Error("[relai-x402] WebSocket relay connection closed before response"));
+      };
+      addSocketListener(socket, "open", onOpen);
+      addSocketListener(socket, "message", onMessage);
+      addSocketListener(socket, "error", onError);
+      addSocketListener(socket, "close", onClose);
+    });
+  }
+  function extractPaymentRequirementsFromWsError(error) {
+    const candidates = [error.paymentRequired, error.data];
+    for (const candidate of candidates) {
+      if (!isRecord(candidate)) continue;
+      if (Array.isArray(candidate.accepts)) {
+        return candidate;
+      }
+      if (isRecord(candidate.paymentRequired) && Array.isArray(candidate.paymentRequired.accepts)) {
+        return candidate.paymentRequired;
+      }
+      if (isRecord(candidate.data) && Array.isArray(candidate.data.accepts)) {
+        return candidate.data;
+      }
+    }
+    return null;
+  }
+  function buildWsResponse(wsResponse) {
+    const statusFromMetadata = isRecord(wsResponse.metadata) && typeof wsResponse.metadata.status === "number" ? wsResponse.metadata.status : 200;
+    const status = Number.isInteger(statusFromMetadata) && statusFromMetadata >= 100 && statusFromMetadata <= 599 ? statusFromMetadata : 200;
+    const headers = new Headers();
+    headers.set("Content-Type", "application/json");
+    if (wsResponse.paymentResponse !== void 0) {
+      headers.set("PAYMENT-RESPONSE", encodeBase64Json(wsResponse.paymentResponse));
+    }
+    const bodyPayload = wsResponse.result === void 0 ? null : wsResponse.result;
+    return new Response(JSON.stringify(bodyPayload), {
+      status,
+      headers
+    });
+  }
   function selectAccept(accepts) {
     if (preferredNetwork) {
       const caip2 = NETWORK_CAIP2[preferredNetwork];
@@ -501,7 +1171,7 @@ function createX402Client(config) {
         amount: paymentAmount
       }
     };
-    return btoa(JSON.stringify(paymentPayload));
+    return encodeBase64Json(paymentPayload);
   }
   async function buildEvmPayment(accept, requirements, url) {
     const evmWallet = effectiveWallets.evm;
@@ -569,7 +1239,7 @@ function createX402Client(config) {
       },
       facilitatorUrl
     };
-    return btoa(JSON.stringify(paymentPayload));
+    return encodeBase64Json(paymentPayload);
   }
   async function buildSolanaPayment(accept, requirements, url) {
     const solWallet = effectiveWallets.solana;
@@ -633,7 +1303,17 @@ function createX402Client(config) {
         transaction: serializedTx
       }
     };
-    return btoa(JSON.stringify(paymentPayload));
+    return encodeBase64Json(paymentPayload);
+  }
+  function encodeBase64Json(payload) {
+    const serialized = JSON.stringify(payload);
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(serialized, "utf8").toString("base64");
+    }
+    if (typeof btoa !== "undefined") {
+      return btoa(serialized);
+    }
+    throw new Error("[relai-x402] Base64 encoding is not available in this runtime");
   }
   function decodeBase64Json(encoded) {
     try {
@@ -674,7 +1354,101 @@ function createX402Client(config) {
   async function x402Fetch(input, init) {
     const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
     log("Request:", url);
-    const response = await fetch(input, init);
+    const requestInit = stripInternalInit(init);
+    const integritasOptions = resolveIntegritasOptions(init?.x402?.integritas);
+    const requestMethod = getRequestMethod(input, requestInit);
+    const requestHeaders = applyIntegritasHeaders(
+      getRequestHeaders(input, requestInit),
+      integritasOptions
+    );
+    const requestInitWithHeaders = {
+      ...requestInit || {},
+      headers: requestHeaders
+    };
+    const requestBody = await resolveRequestBody(input, requestInitWithHeaders);
+    if (relayWsEnabled && isRelayRequestUrl(url)) {
+      let wsPaymentPhaseStarted = false;
+      try {
+        log("Using WebSocket relay transport");
+        const wsPreflightResponse = await relayCallOverWebSocket({
+          relayUrl: url,
+          requestMethod,
+          requestHeaders,
+          requestBody,
+          timeoutMs: relayWsPreflightTimeoutMs
+        });
+        if (!wsPreflightResponse.error) {
+          return buildWsResponse(wsPreflightResponse);
+        }
+        if (Number(wsPreflightResponse.error.code) !== 402) {
+          throw new Error(wsPreflightResponse.error.message || "[relai-x402] WebSocket relay request failed");
+        }
+        const wsRequirements = extractPaymentRequirementsFromWsError(wsPreflightResponse.error);
+        if (!wsRequirements) {
+          throw new Error(
+            wsPreflightResponse.error.message || "[relai-x402] No payment requirements in WS 402 response"
+          );
+        }
+        const wsAccepts = getAccepts(wsRequirements);
+        if (!wsAccepts.length) {
+          throw new Error("[relai-x402] No payment options in WS 402 response");
+        }
+        if (wsAccepts.length > 1) {
+          throw new Error(
+            "[relai-x402] WS relay currently supports a single payment payload; use HTTP flow for multi-accept payments"
+          );
+        }
+        const wsSelected = selectAccept(wsAccepts);
+        if (!wsSelected) {
+          const networks = wsAccepts.map((a) => a.network).join(", ");
+          throw new Error(`[relai-x402] No wallet available for WS networks: ${networks}`);
+        }
+        const { accept: accept2, chain: chain2 } = wsSelected;
+        const amount2 = accept2.amount || accept2.maxAmountRequired;
+        if (maxAmountAtomic && BigInt(amount2) > BigInt(maxAmountAtomic)) {
+          throw new Error(`[relai-x402] Amount ${amount2} exceeds max ${maxAmountAtomic}`);
+        }
+        wsPaymentPhaseStarted = true;
+        let paymentHeader = null;
+        if (chain2 === "solana" && hasSolanaWallet) {
+          paymentHeader = await buildSolanaPayment(accept2, wsRequirements, url);
+        } else if (chain2 === "evm") {
+          const evmNetwork = normalizeNetwork(accept2.network || "");
+          const usePermit = evmNetwork && PERMIT_NETWORKS.has(evmNetwork);
+          paymentHeader = usePermit ? await buildEvmPermitPayment(accept2, wsRequirements, url) : await buildEvmPayment(accept2, wsRequirements, url);
+        }
+        if (!paymentHeader) {
+          throw new Error("[relai-x402] Unexpected state - no WS payment handler matched");
+        }
+        const paymentPayload = decodeBase64Json(paymentHeader);
+        if (!paymentPayload) {
+          throw new Error("[relai-x402] Failed to decode payment payload for WS relay call");
+        }
+        const wsPaidResponse = await relayCallOverWebSocket({
+          relayUrl: url,
+          requestMethod,
+          requestHeaders,
+          requestBody,
+          paymentPayload,
+          timeoutMs: relayWsPaymentTimeoutMs
+        });
+        if (wsPaidResponse.error) {
+          throw new Error(wsPaidResponse.error.message || "[relai-x402] WebSocket paid relay request failed");
+        }
+        return buildWsResponse(wsPaidResponse);
+      } catch (wsError) {
+        const wsMessage = wsError instanceof Error ? wsError.message : String(wsError);
+        log("WebSocket relay transport failed:", wsMessage);
+        if (wsPaymentPhaseStarted) {
+          throw wsError instanceof Error ? wsError : new Error(`[relai-x402] ${wsMessage}`);
+        }
+        if (!relayWsFallbackToHttp) {
+          throw wsError instanceof Error ? wsError : new Error(`[relai-x402] ${wsMessage}`);
+        }
+        log("Falling back to HTTP x402 flow");
+      }
+    }
+    const response = await fetch(input, requestInitWithHeaders);
     if (response.status !== 402) return response;
     log("Got 402 Payment Required");
     let requirementsFromBody = null;
@@ -712,9 +1486,9 @@ function createX402Client(config) {
       const paymentHeader = await buildSolanaPayment(accept, requirements, url);
       log("Retrying with X-PAYMENT header (Solana)");
       return fetch(input, {
-        ...init,
+        ...requestInitWithHeaders,
         headers: {
-          ...init?.headers || {},
+          ...requestHeaders,
           "X-PAYMENT": paymentHeader
         }
       });
@@ -725,14 +1499,14 @@ function createX402Client(config) {
       const paymentHeader = usePermit ? await buildEvmPermitPayment(accept, requirements, url) : await buildEvmPayment(accept, requirements, url);
       log("Retrying with X-PAYMENT header");
       return fetch(input, {
-        ...init,
+        ...requestInitWithHeaders,
         headers: {
-          ...init?.headers || {},
+          ...requestHeaders,
           "X-PAYMENT": paymentHeader
         }
       });
     }
-    throw new Error("[relai-x402] Unexpected state \u2014 no payment handler matched");
+    throw new Error("[relai-x402] Unexpected state - no payment handler matched");
   }
   return { fetch: x402Fetch };
 }
@@ -881,6 +1655,7 @@ export {
   EXPLORER_TX_URL,
   NETWORK_CAIP2,
   NETWORK_LABELS,
+  NETWORK_TOKENS,
   NETWORK_V1_TO_V2,
   NETWORK_V2_TO_V1,
   RELAI_FACILITATOR_URL,
@@ -906,6 +1681,7 @@ export {
   networkV2ToV1,
   normalizeNetwork,
   normalizePaymentHeader,
+  resolveToken,
   stripePayTo,
   toAtomicUnits
 };