@relai-fi/x402 0.6.4 → 0.6.6

package/dist/react/index.cjs

@@ -268,6 +268,71 @@ function normalizeNetwork(network) {
   return null;
 }
 
+// src/bridge.ts
+var RELAI_API_BASE = "https://api.relai.fi";
+var _cacheMap = /* @__PURE__ */ new Map();
+var CACHE_TTL = 5 * 60 * 1e3;
+async function getBridgeInfo(baseUrl = RELAI_API_BASE) {
+  const key = baseUrl.replace(/\/$/, "");
+  const now = Date.now();
+  const cached = _cacheMap.get(key);
+  if (cached && now - cached.time < CACHE_TTL) return cached.info;
+  const url = `${key}/bridge/info`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    if (cached) return cached.info;
+    throw new Error(`[relai:bridge] Failed to fetch ${url}: ${res.status}`);
+  }
+  const data = await res.json();
+  const info = {
+    settleEndpoint: data.settleEndpoint,
+    supportedSourceChains: data.supportedSourceChains || [],
+    supportedSourceAssets: data.supportedSourceAssets || [],
+    payTo: data.payTo || {},
+    feePayerSvm: data.feePayerSvm ?? null,
+    feeBps: data.feeBps ?? 100,
+    paymentFacilitator: data.paymentFacilitator || "https://facilitator.x402.fi"
+  };
+  _cacheMap.set(key, { info, time: now });
+  return info;
+}
+async function settleBridge(settleEndpoint, body) {
+  const res = await fetch(settleEndpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(`[relai:bridge] settle failed: ${err.error || res.status}${err.details ? " \u2014 " + err.details : ""}`);
+  }
+  return res.json();
+}
+function selectSourceChain(supportedChains, hasEvmWallet, hasSolanaWallet, preferredSourceChainId) {
+  if (preferredSourceChainId && hasEvmWallet) {
+    const preferred = `eip155:${preferredSourceChainId}`;
+    if (supportedChains.includes(preferred)) {
+      return { type: "evm", chain: preferred };
+    }
+  }
+  if (hasSolanaWallet) {
+    const sol = supportedChains.find((c) => c.startsWith("solana:"));
+    if (sol) return { type: "solana", chain: sol };
+  }
+  if (hasEvmWallet) {
+    for (const chain of supportedChains) {
+      if (chain.startsWith("eip155:")) {
+        return { type: "evm", chain };
+      }
+    }
+  }
+  return null;
+}
+function computeSourceAmount(targetAmount, feeBps) {
+  const fee = targetAmount * BigInt(feeBps) / 10000n;
+  return targetAmount + fee;
+}
+
 // src/client.ts
 var PERMIT_NETWORKS = /* @__PURE__ */ new Set([]);
 var DEFAULT_EVM_RPC_URLS = {
@@ -294,7 +359,8 @@ function createX402Client(config) {
     integritas,
     verbose = false,
     defaultHeaders = {},
-    mpp
+    mpp,
+    bridge: bridgeConfig
   } = config;
   const relayWsEnabled = relayWs?.enabled === true;
   const relayWsPreflightTimeoutMs = relayWs?.preflightTimeoutMs ?? 5e3;
@@ -713,6 +779,38 @@ function createX402Client(config) {
     }
     return null;
   }
+  function extractMppChallengeFromWsError(error) {
+    if (isRecord(error) && typeof error.mppChallenge === "string") {
+      return error.mppChallenge;
+    }
+    if (isRecord(error.data) && typeof error.data.mppChallenge === "string") {
+      return error.data.mppChallenge;
+    }
+    const metadata = isRecord(error) ? error.responseHeaders : void 0;
+    if (isRecord(metadata)) {
+      for (const [key, value] of Object.entries(metadata)) {
+        if (key.toLowerCase() === "www-authenticate" && typeof value === "string") {
+          if (/^Payment\s+/i.test(value.trim())) {
+            return value;
+          }
+        }
+      }
+    }
+    return null;
+  }
+  function buildSyntheticMppResponse(mppChallenge, wsError) {
+    const headers = new Headers();
+    headers.set("WWW-Authenticate", mppChallenge);
+    const responseHeaders = isRecord(wsError) ? wsError.responseHeaders : void 0;
+    if (isRecord(responseHeaders)) {
+      for (const [key, value] of Object.entries(responseHeaders)) {
+        if (typeof value === "string" && key.toLowerCase() !== "www-authenticate") {
+          headers.set(key, value);
+        }
+      }
+    }
+    return new Response(null, { status: 402, headers });
+  }
   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;
@@ -1207,6 +1305,41 @@ function createX402Client(config) {
         if (Number(wsPreflightResponse.error.code) !== 402) {
           throw new Error(wsPreflightResponse.error.message || "[relai-x402] WebSocket relay request failed");
         }
+        if (mpp) {
+          const mppChallenge = extractMppChallengeFromWsError(wsPreflightResponse.error);
+          if (mppChallenge) {
+            log("MPP challenge detected in WS 402 response");
+            try {
+              const syntheticResponse = buildSyntheticMppResponse(mppChallenge, wsPreflightResponse.error);
+              const credential = await mpp.createCredential(syntheticResponse);
+              if (credential) {
+                log("MPP credential created, retrying via WS with Authorization: Payment");
+                wsPaymentPhaseStarted = true;
+                const wsMppResponse = await relayCallOverWebSocket({
+                  relayUrl: url,
+                  requestMethod,
+                  requestHeaders: {
+                    ...requestHeaders,
+                    "Authorization": credential.startsWith("Payment ") ? credential : `Payment ${credential}`
+                  },
+                  requestBody,
+                  timeoutMs: relayWsPaymentTimeoutMs
+                });
+                if (!wsMppResponse.error) {
+                  return buildWsResponse(wsMppResponse);
+                }
+                if (Number(wsMppResponse.error.code) !== 402) {
+                  throw new Error(wsMppResponse.error.message || "[relai-x402] WebSocket MPP retry failed");
+                }
+                log("MPP retry via WS still returned 402, falling through to x402 WS flow");
+                wsPaymentPhaseStarted = false;
+              }
+            } catch (mppWsErr) {
+              if (wsPaymentPhaseStarted) throw mppWsErr;
+              log(`MPP over WS failed (${mppWsErr instanceof Error ? mppWsErr.message : mppWsErr}), falling through to x402 WS flow`);
+            }
+          }
+        }
         const wsRequirements = extractPaymentRequirementsFromWsError(wsPreflightResponse.error);
         if (!wsRequirements) {
           throw new Error(
@@ -1224,6 +1357,17 @@ function createX402Client(config) {
         }
         const wsSelected = selectAccept(wsAccepts);
         if (!wsSelected) {
+          const wsBridge = getBridgeExtension(wsRequirements);
+          if (wsBridge && selectBridgeSource(wsBridge)) {
+            log("No direct wallet match in WS flow \u2014 attempting bridge extension");
+            wsPaymentPhaseStarted = true;
+            const bridgePaymentHeader = await executeBridgePayment(wsBridge, wsAccepts, wsRequirements, url);
+            log("Retrying with X-PAYMENT header (bridge via WS fallback to HTTP)");
+            return fetch(input, {
+              ...stripInternalInit(init) || {},
+              headers: { ...requestHeaders, "X-PAYMENT": bridgePaymentHeader }
+            });
+          }
           throw new Error(buildNoWalletError(wsAccepts, true));
         }
         const { accept: accept2, chain: chain2 } = wsSelected;
@@ -1331,6 +1475,70 @@ function createX402Client(config) {
           headers: { ...requestHeaders, "X-PAYMENT": paymentHeader }
         });
       }
+      if (bridgeConfig?.enabled) {
+        log("No direct wallet match \u2014 attempting auto-bridge via RelAI API");
+        try {
+          const info = await getBridgeInfo(bridgeConfig.baseUrl);
+          const targetAccept = accepts[0];
+          const hasEvm = !!effectiveWallets.evm;
+          const hasSol = !!hasSolanaWallet;
+          const source = selectSourceChain(info.supportedSourceChains, hasEvm, hasSol);
+          if (source) {
+            const bridgePayTo = info.payTo[source.chain];
+            if (bridgePayTo) {
+              const targetAmount = targetAccept.amount || targetAccept.maxAmountRequired;
+              const sourceAmount = computeSourceAmount(BigInt(targetAmount), info.feeBps).toString();
+              const sourceChainIdx = info.supportedSourceChains.indexOf(source.chain);
+              const sourceAsset = sourceChainIdx >= 0 && info.supportedSourceAssets[sourceChainIdx] || (source.type === "evm" ? info.supportedSourceAssets.find((a) => a.startsWith("0x")) || targetAccept.asset : info.supportedSourceAssets.find((a) => !a.startsWith("0x")) || "");
+              let sourcePaymentHeader;
+              const sourceAccept = {
+                scheme: "exact",
+                network: source.chain,
+                asset: sourceAsset,
+                payTo: bridgePayTo,
+                amount: sourceAmount,
+                extra: {
+                  ...targetAccept.extra || {},
+                  ...source.type === "solana" && info.feePayerSvm ? { feePayer: info.feePayerSvm } : {}
+                }
+              };
+              if (source.type === "solana" && hasSolanaWallet) {
+                sourcePaymentHeader = await buildSolanaPayment(sourceAccept, requirements, url);
+              } else if (source.type === "evm") {
+                const evmNetwork = normalizeNetwork(source.chain);
+                const usePermit = evmNetwork && PERMIT_NETWORKS.has(evmNetwork);
+                sourcePaymentHeader = usePermit ? await buildEvmPermitPayment(sourceAccept, requirements, url) : await buildEvmPayment(sourceAccept, requirements, url);
+              } else {
+                throw new Error(`[relai-x402] No wallet for source chain type: ${source.type}`);
+              }
+              const settleData = await settleBridge(info.settleEndpoint, {
+                sourcePayment: sourcePaymentHeader,
+                sourceChain: source.chain,
+                targetAccept: {
+                  scheme: "exact",
+                  network: targetAccept.network,
+                  asset: targetAccept.asset,
+                  payTo: targetAccept.payTo,
+                  amount: targetAmount
+                },
+                requirements,
+                resource: url,
+                paymentFacilitator: info.paymentFacilitator
+              });
+              if (settleData.xPayment) {
+                log(`Auto-bridge settled: target=${settleData.targetTxId}`);
+                return fetch(input, {
+                  ...requestInitWithHeaders,
+                  headers: { ...requestHeaders, "X-PAYMENT": settleData.xPayment }
+                });
+              }
+              throw new Error("[relai-x402] Bridge settle did not return xPayment");
+            }
+          }
+        } catch (bridgeErr) {
+          log(`Auto-bridge failed: ${bridgeErr instanceof Error ? bridgeErr.message : bridgeErr}`);
+        }
+      }
       throw new Error(buildNoWalletError(accepts, false));
     }
     const { accept, chain } = selected;