@dexterai/x402 1.4.1 → 1.5.0

package/dist/react/index.d.ts

@@ -1,6 +1,7 @@
-import { a as X402Client } from '../x402-client-COrn-FQk.js';
-import { W as WalletSet, B as BalanceInfo } from '../types-DNx7-QUN.js';
-export { X as X402Error } from '../types-B7T6dZ-y.js';
+import { a as X402Client } from '../x402-client-BxQWcK2Z.js';
+import { W as WalletSet, B as BalanceInfo } from '../types-BtpD4ULe.js';
+import { a as AccessPassTier } from '../types-CcVAaoro.js';
+export { A as AccessPassClientConfig, b as AccessPassInfo, X as X402Error } from '../types-CcVAaoro.js';
 
 /**
  * React Hook for x402 v2 Payments
@@ -99,10 +100,113 @@ interface UseX402PaymentReturn {
     reset: () => void;
     /** Refresh balances manually */
     refreshBalances: () => Promise<void>;
+    /**
+     * Access pass state (null if server doesn't support access passes
+     * or no pass has been purchased in this session).
+     */
+    accessPass: {
+        /** Whether a valid, non-expired pass is active */
+        active: boolean;
+        /** Tier ID of the active pass */
+        tier: string | null;
+        /** ISO expiration timestamp */
+        expiresAt: string | null;
+        /** Seconds remaining on the pass */
+        remainingSeconds: number | null;
+    } | null;
 }
 /**
  * React hook for managing x402 v2 payments across chains
  */
 declare function useX402Payment(config: UseX402PaymentConfig): UseX402PaymentReturn;
 
-export { BalanceInfo, type ConnectedChains, type PaymentStatus, type UseX402PaymentConfig, type UseX402PaymentReturn, WalletSet, useX402Payment };
+/**
+ * React Hook for x402 Access Pass
+ *
+ * Dedicated hook for managing the access pass lifecycle:
+ * tier discovery, pass purchase, token caching, and auto-fetch with pass.
+ *
+ * @example
+ * ```tsx
+ * import { useAccessPass } from '@dexterai/x402/react';
+ *
+ * function DataDashboard() {
+ *   const {
+ *     tiers,
+ *     pass,
+ *     isPassValid,
+ *     purchasePass,
+ *     isPurchasing,
+ *     fetch: apFetch,
+ *   } = useAccessPass({
+ *     wallets: { solana: solanaWallet },
+ *     resourceUrl: 'https://api.example.com',
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {!isPassValid && tiers && (
+ *         <div>
+ *           {tiers.map(t => (
+ *             <button key={t.id} onClick={() => purchasePass(t.id)}>
+ *               {t.label} — ${t.price}
+ *             </button>
+ *           ))}
+ *         </div>
+ *       )}
+ *       {isPassValid && <p>Pass active! Expires: {pass?.expiresAt}</p>}
+ *       <button onClick={() => apFetch('/api/data').then(r => r.json()).then(console.log)}>
+ *         Fetch Data
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+
+interface UseAccessPassConfig {
+    /** Wallets for each chain type */
+    wallets?: WalletSet;
+    /** Legacy: Single Solana wallet */
+    wallet?: unknown;
+    /** Preferred network */
+    preferredNetwork?: string;
+    /** Custom RPC URLs by network */
+    rpcUrls?: Record<string, string>;
+    /** The base URL of the x402 resource */
+    resourceUrl: string;
+    /** Auto-fetch tier info on mount @default true */
+    autoConnect?: boolean;
+    /** Enable verbose logging */
+    verbose?: boolean;
+}
+interface UseAccessPassReturn {
+    /** Available tiers from the server (null until fetched) */
+    tiers: AccessPassTier[] | null;
+    /** Custom rate per hour (if server supports custom durations) */
+    customRatePerHour: string | null;
+    /** Whether tier info is being loaded */
+    isLoadingTiers: boolean;
+    /** Current active pass (null if no valid pass) */
+    pass: {
+        jwt: string;
+        tier: string;
+        expiresAt: string;
+        remainingSeconds: number;
+    } | null;
+    /** Whether the current pass is valid and not expired */
+    isPassValid: boolean;
+    /** Fetch tier info from the server */
+    fetchTiers: () => Promise<void>;
+    /** Purchase a pass for a specific tier or custom duration */
+    purchasePass: (tier?: string, durationSeconds?: number) => Promise<void>;
+    /** Whether a pass purchase is in progress */
+    isPurchasing: boolean;
+    /** Error from the last purchase attempt */
+    purchaseError: Error | null;
+    /** Fetch with automatic pass inclusion */
+    fetch: (path: string, init?: RequestInit) => Promise<Response>;
+}
+declare function useAccessPass(config: UseAccessPassConfig): UseAccessPassReturn;
+
+export { AccessPassTier, BalanceInfo, type ConnectedChains, type PaymentStatus, type UseAccessPassConfig, type UseAccessPassReturn, type UseX402PaymentConfig, type UseX402PaymentReturn, WalletSet, useAccessPass, useX402Payment };

package/dist/react/index.js

@@ -444,10 +444,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;
@@ -482,13 +513,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(
@@ -865,11 +1041,154 @@ function useX402Payment(config) {
     connectedChains,
     isAnyWalletConnected,
     reset,
-    refreshBalances
+    refreshBalances,
+    accessPass: null
+    // Access pass state managed by useAccessPass hook for granular control
+  };
+}
+
+// src/react/useAccessPass.ts
+import { useState as useState2, useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2 } from "react";
+function useAccessPass(config) {
+  const {
+    wallets: walletSet,
+    wallet: legacyWallet,
+    preferredNetwork,
+    rpcUrls = {},
+    resourceUrl,
+    autoConnect = true,
+    verbose = false
+  } = config;
+  const [tiers, setTiers] = useState2(null);
+  const [customRatePerHour, setCustomRatePerHour] = useState2(null);
+  const [isLoadingTiers, setIsLoadingTiers] = useState2(false);
+  const [passJwt, setPassJwt] = useState2(null);
+  const [passInfo, setPassInfo] = useState2(null);
+  const [isPurchasing, setIsPurchasing] = useState2(false);
+  const [purchaseError, setPurchaseError] = useState2(null);
+  const log = useCallback2((...args) => {
+    if (verbose) console.log("[useAccessPass]", ...args);
+  }, [verbose]);
+  const wallets = useMemo2(() => {
+    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 = useMemo2(() => createX402Client({
+    adapters: [createSolanaAdapter({ verbose, rpcUrls }), createEvmAdapter({ verbose, rpcUrls })],
+    wallets,
+    preferredNetwork,
+    rpcUrls,
+    verbose,
+    accessPass: { enabled: true, autoRenew: true }
+  }), [wallets, preferredNetwork, rpcUrls, verbose]);
+  const pass = useMemo2(() => {
+    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] = useState2(0);
+  useEffect2(() => {
+    if (!isPassValid) return;
+    const interval = setInterval(() => setTick((t) => t + 1), 1e3);
+    return () => clearInterval(interval);
+  }, [isPassValid]);
+  const fetchTiers = useCallback2(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]);
+  useEffect2(() => {
+    if (autoConnect) fetchTiers();
+  }, [autoConnect, fetchTiers]);
+  const purchasePass = useCallback2(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 = useCallback2(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
   };
 }
 export {
   X402Error,
+  useAccessPass,
   useX402Payment
 };
 //# sourceMappingURL=index.js.map