@dexterai/x402 1.4.0 → 1.5.0

package/dist/{evm-BaoETN1Y.d.cts → evm-BYjwU6ZW.d.cts}

@@ -1,5 +1,5 @@
-import { A as AdapterConfig, C as ChainAdapter, S as SignedTransaction } from './types-CQGDK_7X.cjs';
-import { P as PaymentAccept } from './types-B7T6dZ-y.cjs';
+import { A as AdapterConfig, C as ChainAdapter, S as SignedTransaction } from './types--r7urkVI.cjs';
+import { P as PaymentAccept } from './types-CcVAaoro.cjs';
 
 /**
  * Solana Chain Adapter

package/dist/react/index.cjs

@@ -416,6 +416,7 @@ var init_evm = __esm({
 var react_exports = {};
 __export(react_exports, {
   X402Error: () => X402Error,
+  useAccessPass: () => useAccessPass,
   useX402Payment: () => useX402Payment
 });
 module.exports = __toCommonJS(react_exports);
@@ -456,10 +457,41 @@ function createX402Client(config) {
     rpcUrls = {},
     maxAmountAtomic,
     fetch: customFetch = globalThis.fetch,
-    verbose = false
+    verbose = false,
+    accessPass: accessPassConfig
   } = config;
   const log = verbose ? console.log.bind(console, "[x402]") : () => {
   };
+  const passCache = /* @__PURE__ */ new Map();
+  function getCachedPass(url) {
+    try {
+      const host = new URL(url).host;
+      const cached = passCache.get(host);
+      if (cached && cached.expiresAt > Date.now() / 1e3 + 10) {
+        return cached.jwt;
+      }
+      if (cached) {
+        passCache.delete(host);
+      }
+    } catch {
+    }
+    return null;
+  }
+  function cachePass(url, jwt) {
+    try {
+      const host = new URL(url).host;
+      const parts = jwt.split(".");
+      if (parts.length === 3) {
+        const payload = JSON.parse(atob(parts[1].replace(/-/g, "+").replace(/_/g, "/")));
+        if (payload.exp) {
+          passCache.set(host, { jwt, expiresAt: payload.exp });
+          log("Access pass cached for", host, "| expires:", new Date(payload.exp * 1e3).toISOString());
+        }
+      }
+    } catch {
+      log("Failed to cache access pass");
+    }
+  }
   const wallets = walletSet || {};
   if (legacyWallet && !wallets.solana && isSolanaWallet(legacyWallet)) {
     wallets.solana = legacyWallet;
@@ -494,13 +526,158 @@ function createX402Client(config) {
   function getRpcUrl(network, adapter) {
     return rpcUrls[network] || adapter.getDefaultRpcUrl(network);
   }
+  async function purchaseAccessPass(input, init, originalResponse, passInfo, url) {
+    let tierQuery = "";
+    if (accessPassConfig?.preferTier && passInfo.tiers) {
+      const match2 = passInfo.tiers.find((t) => t.id === accessPassConfig.preferTier);
+      if (match2) {
+        if (accessPassConfig.maxSpend && parseFloat(match2.price) > parseFloat(accessPassConfig.maxSpend)) {
+          throw new X402Error(
+            "access_pass_exceeds_max_spend",
+            `Access pass tier "${match2.id}" costs $${match2.price}, exceeds max spend $${accessPassConfig.maxSpend}`
+          );
+        }
+        tierQuery = `tier=${match2.id}`;
+      }
+    } else if (accessPassConfig?.preferDuration && passInfo.ratePerHour) {
+      tierQuery = `duration=${accessPassConfig.preferDuration}`;
+    } else if (passInfo.tiers && passInfo.tiers.length > 0) {
+      const cheapest = passInfo.tiers[0];
+      if (accessPassConfig?.maxSpend && parseFloat(cheapest.price) > parseFloat(accessPassConfig.maxSpend)) {
+        throw new X402Error(
+          "access_pass_exceeds_max_spend",
+          `Cheapest access pass costs $${cheapest.price}, exceeds max spend $${accessPassConfig?.maxSpend}`
+        );
+      }
+      tierQuery = `tier=${cheapest.id}`;
+    }
+    const passUrl = tierQuery ? url.includes("?") ? `${url}&${tierQuery}` : `${url}?${tierQuery}` : url;
+    log("Purchasing access pass:", tierQuery || "default tier");
+    const paymentRequiredHeader = originalResponse.headers.get("PAYMENT-REQUIRED");
+    if (!paymentRequiredHeader) return null;
+    let requirements;
+    try {
+      requirements = JSON.parse(atob(paymentRequiredHeader));
+    } catch {
+      return null;
+    }
+    const match = findPaymentOption(requirements.accepts);
+    if (!match) return null;
+    const { accept, adapter, wallet } = match;
+    if (adapter.name === "Solana" && !accept.extra?.feePayer) return null;
+    const USDC_MINTS = [
+      "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+      "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
+      "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+    ];
+    const decimals = accept.extra?.decimals ?? (USDC_MINTS.includes(accept.asset) ? 6 : void 0);
+    if (typeof decimals !== "number") return null;
+    const paymentAmount = accept.amount || accept.maxAmountRequired;
+    if (!paymentAmount) return null;
+    const rpcUrl = getRpcUrl(accept.network, adapter);
+    const balance = await adapter.getBalance(accept, wallet, rpcUrl);
+    const requiredAmount = Number(paymentAmount) / Math.pow(10, decimals);
+    if (balance < requiredAmount) {
+      throw new X402Error(
+        "insufficient_balance",
+        `Insufficient balance for access pass. Have $${balance.toFixed(4)}, need $${requiredAmount.toFixed(4)}`
+      );
+    }
+    const signedTx = await adapter.buildTransaction(accept, wallet, rpcUrl);
+    let payload;
+    if (adapter.name === "EVM") {
+      payload = JSON.parse(signedTx.serialized);
+    } else {
+      payload = { transaction: signedTx.serialized };
+    }
+    const originalUrl = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    let resolvedResource = requirements.resource;
+    if (typeof requirements.resource === "string") {
+      try {
+        resolvedResource = new URL(requirements.resource, originalUrl).toString();
+      } catch {
+      }
+    } else if (requirements.resource && typeof requirements.resource === "object" && "url" in requirements.resource) {
+      const rObj = requirements.resource;
+      try {
+        resolvedResource = { ...rObj, url: new URL(rObj.url, originalUrl).toString() };
+      } catch {
+      }
+    }
+    const paymentSignature = {
+      x402Version: accept.x402Version ?? 2,
+      resource: resolvedResource,
+      accepted: accept,
+      payload
+    };
+    const paymentSignatureHeader = btoa(JSON.stringify(paymentSignature));
+    const passResponse = await customFetch(passUrl, {
+      ...init,
+      headers: {
+        ...init?.headers || {},
+        "PAYMENT-SIGNATURE": paymentSignatureHeader
+      }
+    });
+    if (!passResponse.ok) {
+      log("Pass purchase failed:", passResponse.status);
+      return null;
+    }
+    const accessPassJwt = passResponse.headers.get("ACCESS-PASS");
+    if (!accessPassJwt) {
+      return passResponse;
+    }
+    cachePass(url, accessPassJwt);
+    log("Access pass purchased and cached");
+    const retryResponse = await customFetch(input, {
+      ...init,
+      headers: {
+        ...init?.headers || {},
+        "Authorization": `Bearer ${accessPassJwt}`
+      }
+    });
+    return retryResponse;
+  }
   async function x402Fetch(input, init) {
-    log("Making request:", input);
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    log("Making request:", url);
+    if (accessPassConfig) {
+      const cachedJwt = getCachedPass(url);
+      if (cachedJwt) {
+        log("Using cached access pass");
+        const passResponse = await customFetch(input, {
+          ...init,
+          headers: {
+            ...init?.headers || {},
+            "Authorization": `Bearer ${cachedJwt}`
+          }
+        });
+        if (passResponse.status !== 401 && passResponse.status !== 402) {
+          return passResponse;
+        }
+        log("Cached pass rejected (status", passResponse.status, "), purchasing new pass");
+        try {
+          passCache.delete(new URL(url).host);
+        } catch {
+        }
+      }
+    }
     const response = await customFetch(input, init);
     if (response.status !== 402) {
       return response;
     }
     log("Received 402 Payment Required");
+    const passTiersHeader = response.headers.get("X-ACCESS-PASS-TIERS");
+    if (accessPassConfig && passTiersHeader) {
+      log("Server offers access passes, purchasing...");
+      try {
+        const passInfo = JSON.parse(atob(passTiersHeader));
+        const passResponse = await purchaseAccessPass(input, init, response, passInfo, url);
+        if (passResponse) return passResponse;
+      } catch (e) {
+        log("Access pass purchase failed, falling back to per-request payment:", e);
+      }
+    }
     const paymentRequiredHeader = response.headers.get("PAYMENT-REQUIRED");
     if (!paymentRequiredHeader) {
       throw new X402Error(
@@ -877,12 +1054,155 @@ function useX402Payment(config) {
     connectedChains,
     isAnyWalletConnected,
     reset,
-    refreshBalances
+    refreshBalances,
+    accessPass: null
+    // Access pass state managed by useAccessPass hook for granular control
+  };
+}
+
+// src/react/useAccessPass.ts
+var import_react2 = require("react");
+function useAccessPass(config) {
+  const {
+    wallets: walletSet,
+    wallet: legacyWallet,
+    preferredNetwork,
+    rpcUrls = {},
+    resourceUrl,
+    autoConnect = true,
+    verbose = false
+  } = config;
+  const [tiers, setTiers] = (0, import_react2.useState)(null);
+  const [customRatePerHour, setCustomRatePerHour] = (0, import_react2.useState)(null);
+  const [isLoadingTiers, setIsLoadingTiers] = (0, import_react2.useState)(false);
+  const [passJwt, setPassJwt] = (0, import_react2.useState)(null);
+  const [passInfo, setPassInfo] = (0, import_react2.useState)(null);
+  const [isPurchasing, setIsPurchasing] = (0, import_react2.useState)(false);
+  const [purchaseError, setPurchaseError] = (0, import_react2.useState)(null);
+  const log = (0, import_react2.useCallback)((...args) => {
+    if (verbose) console.log("[useAccessPass]", ...args);
+  }, [verbose]);
+  const wallets = (0, import_react2.useMemo)(() => {
+    const w = { ...walletSet };
+    if (legacyWallet && !w.solana && isSolanaWallet(legacyWallet)) {
+      w.solana = legacyWallet;
+    }
+    if (legacyWallet && !w.evm && isEvmWallet(legacyWallet)) {
+      w.evm = legacyWallet;
+    }
+    return w;
+  }, [walletSet, legacyWallet]);
+  const client = (0, import_react2.useMemo)(() => createX402Client({
+    adapters: [createSolanaAdapter({ verbose, rpcUrls }), createEvmAdapter({ verbose, rpcUrls })],
+    wallets,
+    preferredNetwork,
+    rpcUrls,
+    verbose,
+    accessPass: { enabled: true, autoRenew: true }
+  }), [wallets, preferredNetwork, rpcUrls, verbose]);
+  const pass = (0, import_react2.useMemo)(() => {
+    if (!passJwt || !passInfo) return null;
+    const expiresAtMs = new Date(passInfo.expiresAt).getTime();
+    const remaining = Math.max(0, Math.floor((expiresAtMs - Date.now()) / 1e3));
+    if (remaining <= 0) return null;
+    return { jwt: passJwt, tier: passInfo.tier, expiresAt: passInfo.expiresAt, remainingSeconds: remaining };
+  }, [passJwt, passInfo]);
+  const isPassValid = pass !== null && pass.remainingSeconds > 0;
+  const [, setTick] = (0, import_react2.useState)(0);
+  (0, import_react2.useEffect)(() => {
+    if (!isPassValid) return;
+    const interval = setInterval(() => setTick((t) => t + 1), 1e3);
+    return () => clearInterval(interval);
+  }, [isPassValid]);
+  const fetchTiers = (0, import_react2.useCallback)(async () => {
+    setIsLoadingTiers(true);
+    try {
+      const res = await fetch(resourceUrl);
+      if (res.status === 402) {
+        const tiersHeader = res.headers.get("X-ACCESS-PASS-TIERS");
+        if (tiersHeader) {
+          const info = JSON.parse(atob(tiersHeader));
+          setTiers(info.tiers || null);
+          setCustomRatePerHour(info.ratePerHour || null);
+          log("Tier info loaded:", info);
+        }
+      }
+    } catch (e) {
+      log("Failed to fetch tiers:", e);
+    } finally {
+      setIsLoadingTiers(false);
+    }
+  }, [resourceUrl, log]);
+  (0, import_react2.useEffect)(() => {
+    if (autoConnect) fetchTiers();
+  }, [autoConnect, fetchTiers]);
+  const purchasePass = (0, import_react2.useCallback)(async (tier, durationSeconds) => {
+    setIsPurchasing(true);
+    setPurchaseError(null);
+    try {
+      let url = resourceUrl;
+      if (tier) url += (url.includes("?") ? "&" : "?") + `tier=${tier}`;
+      else if (durationSeconds) url += (url.includes("?") ? "&" : "?") + `duration=${durationSeconds}`;
+      const res = await client.fetch(url);
+      const jwt = res.headers.get("ACCESS-PASS");
+      if (jwt) {
+        setPassJwt(jwt);
+        try {
+          const body = await res.json();
+          setPassInfo({
+            tier: body.accessPass?.tier || tier || "unknown",
+            expiresAt: body.accessPass?.expiresAt || ""
+          });
+        } catch {
+          const parts = jwt.split(".");
+          if (parts.length === 3) {
+            const payload = JSON.parse(atob(parts[1].replace(/-/g, "+").replace(/_/g, "/")));
+            setPassInfo({
+              tier: payload.tier || tier || "unknown",
+              expiresAt: new Date(payload.exp * 1e3).toISOString()
+            });
+          }
+        }
+        log("Pass purchased:", tier);
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      setPurchaseError(error);
+      throw error;
+    } finally {
+      setIsPurchasing(false);
+    }
+  }, [resourceUrl, client, log]);
+  const fetchWithPass = (0, import_react2.useCallback)(async (path, init) => {
+    const url = path.startsWith("http") ? path : `${resourceUrl.replace(/\/$/, "")}${path.startsWith("/") ? "" : "/"}${path}`;
+    if (isPassValid && pass) {
+      return fetch(url, {
+        ...init,
+        headers: {
+          ...init?.headers || {},
+          "Authorization": `Bearer ${pass.jwt}`
+        }
+      });
+    }
+    return client.fetch(url, init);
+  }, [resourceUrl, isPassValid, pass, client]);
+  return {
+    tiers,
+    customRatePerHour,
+    isLoadingTiers,
+    pass,
+    isPassValid,
+    fetchTiers,
+    purchasePass,
+    isPurchasing,
+    purchaseError,
+    fetch: fetchWithPass
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   X402Error,
+  useAccessPass,
   useX402Payment
 });
 //# sourceMappingURL=index.cjs.map