@alleyboss/micropay-solana-x402-paywall 3.3.7 → 3.3.9

package/dist/index.cjs

@@ -4,9 +4,7 @@ var core = require('@x402/core');
 var types = require('@x402/core/types');
 var client = require('@x402/core/client');
 var svm = require('@x402/svm');
-var http = require('@x402/core/http');
 var web3_js = require('@solana/web3.js');
-var react = require('react');
 var bs58 = require('bs58');
 var jose = require('jose');
 
@@ -15,519 +13,216 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var bs58__default = /*#__PURE__*/_interopDefault(bs58);
 
 // src/index.ts
-
-// src/client/types.ts
-var TOKEN_MINTS = {
-  /** USDC on mainnet */
-  USDC_MAINNET: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-  /** USDC on devnet */
-  USDC_DEVNET: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
-  /** USDT on mainnet */
-  USDT_MAINNET: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
-};
-
-// src/client/payment.ts
-function buildSolanaPayUrl(params) {
-  const { recipient, amount, splToken, reference, label, message } = params;
-  const url = new URL(`solana:${recipient}`);
-  if (amount !== void 0) {
-    url.searchParams.set("amount", amount.toString());
-  }
-  if (splToken) {
-    url.searchParams.set("spl-token", splToken);
-  }
-  if (reference) {
-    url.searchParams.set("reference", reference);
-  }
-  if (label) {
-    url.searchParams.set("label", label);
-  }
-  if (message) {
-    url.searchParams.set("message", message);
-  }
-  return url.toString();
-}
-function createPaymentFlow(config) {
-  const { network, recipientWallet, amount, asset = "native", memo } = config;
-  let decimals = 9;
-  let mintAddress;
-  if (asset === "usdc") {
-    decimals = 6;
-    mintAddress = network === "mainnet-beta" ? TOKEN_MINTS.USDC_MAINNET : TOKEN_MINTS.USDC_DEVNET;
-  } else if (asset === "usdt") {
-    decimals = 6;
-    mintAddress = TOKEN_MINTS.USDT_MAINNET;
-  } else if (typeof asset === "object" && "mint" in asset) {
-    decimals = asset.decimals ?? 6;
-    mintAddress = asset.mint;
-  }
-  const naturalAmount = Number(amount) / Math.pow(10, decimals);
-  return {
-    /** Get the payment configuration */
-    getConfig: () => ({ ...config }),
-    /** Get amount in natural display units (e.g., 0.01 SOL) */
-    getDisplayAmount: () => naturalAmount,
-    /** Get amount formatted with symbol */
-    getFormattedAmount: () => {
-      const symbol = asset === "native" ? "SOL" : asset === "usdc" ? "USDC" : asset === "usdt" ? "USDT" : "tokens";
-      return `${naturalAmount.toFixed(decimals > 6 ? 4 : 2)} ${symbol}`;
-    },
-    /** Generate Solana Pay URL for QR codes */
-    getSolanaPayUrl: (options = {}) => {
-      return buildSolanaPayUrl({
-        recipient: recipientWallet,
-        amount: naturalAmount,
-        splToken: mintAddress,
-        label: options.label,
-        reference: options.reference,
-        message: memo
-      });
-    },
-    /** Get the token mint address (undefined for native SOL) */
-    getMintAddress: () => mintAddress,
-    /** Check if this is a native SOL payment */
-    isNativePayment: () => asset === "native",
-    /** Get network information */
-    getNetworkInfo: () => ({
-      network,
-      isMainnet: network === "mainnet-beta",
-      explorerUrl: network === "mainnet-beta" ? "https://explorer.solana.com" : "https://explorer.solana.com?cluster=devnet"
-    }),
-    /** Build explorer URL for a transaction */
-    getExplorerUrl: (signature) => {
-      const baseUrl = "https://explorer.solana.com/tx";
-      const cluster = network === "mainnet-beta" ? "" : "?cluster=devnet";
-      return `${baseUrl}/${signature}${cluster}`;
-    }
+var LocalSvmFacilitator = class {
+  scheme = "exact";
+  caipFamily = "solana:*";
+  connection;
+  constructor(rpcUrl) {
+    console.log("[LocalSvmFacilitator] Initialized with RPC:", rpcUrl);
+    this.connection = new web3_js.Connection(rpcUrl, "confirmed");
+  }
+  /**
+   * Get supported payment kinds
+   * Mocking the response of the /supported endpoint
+   */
+  /**
+   * Network Constants - CAIP-2 format for x402 v2
+   * These match the official Solana chain IDs used by x402 protocol
+   */
+  NETWORKS = {
+    DEVNET: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+    MAINNET: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
   };
-}
-function createPaymentReference() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
-}
-function createX402AuthorizationHeader(signature, paymentRequiredHeader) {
-  const cleanHeader = paymentRequiredHeader.replace(/^[Xx]402\s+/, "");
-  const required = http.decodePaymentRequiredHeader(cleanHeader);
-  const accepts = Array.isArray(required.accepts) ? required.accepts[0] : required.accepts;
-  const payload = {
-    accepted: accepts,
-    client: {
-      scheme: accepts.scheme,
-      // TypeScript knows this exists on PaymentRequirements
-      network: accepts.network
-    },
-    payment: {
-      signature
-    }
-  };
-  const token = http.encodePaymentSignatureHeader(payload);
-  return `x402 ${token}`;
-}
-async function sendSolanaPayment({
-  connection,
-  wallet,
-  recipientAddress,
-  amount,
-  // memo, // TODO: Add memo support to transaction
-  commitment = "confirmed"
-}) {
-  if (!wallet.publicKey) {
-    throw new Error("Wallet not connected");
-  }
-  if (amount <= 0n) {
-    throw new Error("Amount must be greater than 0");
-  }
-  try {
-    const recipientPubkey = new web3_js.PublicKey(recipientAddress);
-    const transaction = new web3_js.Transaction().add(
-      web3_js.SystemProgram.transfer({
-        fromPubkey: wallet.publicKey,
-        toPubkey: recipientPubkey,
-        lamports: amount
-      })
-    );
-    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash(commitment);
-    transaction.recentBlockhash = blockhash;
-    transaction.feePayer = wallet.publicKey;
-    const signature = await wallet.sendTransaction(transaction, connection);
-    await connection.confirmTransaction({
-      signature,
-      blockhash,
-      lastValidBlockHeight
-    }, commitment);
-    return {
-      signature,
-      amountSol: Number(amount) / web3_js.LAMPORTS_PER_SOL
+  /**
+   * DUMMY_FEE_PAYER Explanation (for auditors):
+   * 
+   * In a HOSTED facilitator (like x402.org), the `feePayer` field in the 
+   * SupportedResponse.extra specifies which address will pay transaction fees
+   * when the facilitator submits transactions on behalf of users.
+   * 
+   * In LOCAL/SELF-SOVEREIGN mode (this implementation):
+   * - The USER pays their own transaction fees directly
+   * - The facilitator NEVER submits transactions - it only VERIFIES them
+   * - Therefore, no fee payer address is actually used
+   * 
+   * However, the x402 protocol REQUIRES this field in the response schema.
+   * We use the System Program address (all 1s) as a placeholder because:
+   * 1. It's clearly not a real wallet (obvious placeholder)
+   * 2. It cannot receive funds or sign transactions
+   * 3. It signals to developers that fee paying is handled differently
+   * 
+   * SECURITY NOTE: This is NOT a security risk because:
+   * - The fee payer is never used in verify() or settle() methods
+   * - Users sign and pay for their own transactions
+   * - The address is just a protocol-required placeholder
+   * 
+   * @see https://docs.x402.org for protocol specification
+   */
+  DUMMY_FEE_PAYER = "11111111111111111111111111111111";
+  /**
+   * Get supported payment kinds
+   * Returns x402 v2 compatible response with CAIP-2 network identifiers
+   * 
+   * NOTE: The feePayer in extra.feePayer is a placeholder only.
+   * In self-sovereign mode, users pay their own transaction fees.
+   */
+  async getSupported(_extensionKeys = []) {
+    const supported = {
+      kinds: [
+        {
+          x402Version: 2,
+          scheme: "exact",
+          network: this.NETWORKS.DEVNET,
+          extra: { feePayer: this.DUMMY_FEE_PAYER }
+        },
+        {
+          x402Version: 2,
+          scheme: "exact",
+          network: this.NETWORKS.MAINNET,
+          extra: { feePayer: this.DUMMY_FEE_PAYER }
+        }
+      ],
+      extensions: [],
+      signers: {
+        // Placeholder - in self-sovereign mode, users are their own signers
+        "solana:*": [this.DUMMY_FEE_PAYER]
+      }
     };
-  } catch (error) {
-    console.error("Payment failed:", error);
-    throw new Error(error.message || "Payment failed");
+    return supported;
+  }
+  /**
+   * Get mechanism-specific extra data
+   */
+  getExtra(_network) {
+    return void 0;
+  }
+  /**
+   * Get default signers (not used for local verification usually, but required by interface)
+   */
+  getSigners(_network) {
+    return [];
   }
-}
-function usePaywallResource({
-  url,
-  connection,
-  wallet
-}) {
-  const [data, setData] = react.useState(null);
-  const [isLocked, setIsLocked] = react.useState(true);
-  const [isLoading, setIsLoading] = react.useState(true);
-  const [error, setError] = react.useState(null);
-  const [paymentHeader, setPaymentHeader] = react.useState(null);
-  const [price, setPrice] = react.useState();
-  const [recipient, setRecipient] = react.useState();
-  const fetchData = react.useCallback(async (authHeader) => {
-    setIsLoading(true);
-    setError(null);
+  /**
+   * Enable debug logging (disable in production)
+   */
+  debug = process.env.NODE_ENV === "development";
+  /**
+   * Verify a payment on-chain
+   */
+  async verify(payload, requirements) {
     try {
-      const headers = {
-        "Content-Type": "application/json"
-      };
-      if (authHeader) {
-        headers["Authorization"] = authHeader;
+      const signature = payload.payload.signature;
+      if (!signature) {
+        return { isValid: false, invalidReason: "Missing signature in payment payload" };
       }
-      const res = await fetch(url, {
-        headers,
-        credentials: "include"
-        // Ensure cookies are sent/received
-      });
-      if (res.status === 402) {
-        const wwwAuth = res.headers.get("WWW-Authenticate") || res.headers.get("Payment-Required");
-        const errorReason = res.headers.get("X-Payment-Error");
-        console.log("[usePaywallResource] 402 Response. Header:", wwwAuth, "Error:", errorReason);
-        if (authHeader && errorReason) {
-          console.error("[usePaywallResource] Verification Failed:", errorReason);
-          setError(`Verification Failed: ${errorReason}`);
+      const payTo = requirements.payTo;
+      const amountVal = requirements.amount || requirements.maxAmountRequired || "0";
+      const requiredAmount = BigInt(amountVal);
+      if (this.debug) {
+        console.log(`[LocalSvmFacilitator] Verifying tx: ${signature.slice(0, 8)}...`);
+      }
+      const tx = await this.fetchTransactionWithRetry(signature, 3);
+      if (!tx) {
+        return { isValid: false, invalidReason: "Transaction not found or not confirmed" };
+      }
+      const instructions = tx.transaction.message.instructions;
+      let paidAmount = 0n;
+      let payer = void 0;
+      for (const ix of instructions) {
+        if ("program" in ix && ix.program === "system") {
+          const parsed = ix.parsed;
+          if (parsed?.type === "transfer" && parsed.info?.destination === payTo) {
+            paidAmount += BigInt(parsed.info.lamports);
+            if (!payer) payer = parsed.info.source;
+          }
         }
-        if (wwwAuth) {
-          setPaymentHeader(wwwAuth);
-          try {
-            const { decodePaymentRequiredHeader: decodePaymentRequiredHeader2 } = await import('@x402/core/http');
-            const cleanHeader = wwwAuth.replace(/^[Xx]402\s+/, "");
-            const decoded = decodePaymentRequiredHeader2(cleanHeader);
-            console.log("[usePaywallResource] Decoded header:", decoded);
-            const accepts = Array.isArray(decoded.accepts) ? decoded.accepts[0] : decoded.accepts;
-            console.log("[usePaywallResource] Accepts:", accepts);
-            if (accepts) {
-              const amountStr = accepts.amount || accepts.price || accepts.maxAmountRequired || "0";
-              setPrice(BigInt(amountStr));
-              setRecipient(accepts.payTo);
-              console.log("[usePaywallResource] Set price:", amountStr, "recipient:", accepts.payTo);
-            } else {
-              console.warn("[usePaywallResource] No accepts found in header");
+        if ("program" in ix && (ix.program === "spl-token" || ix.program === "spl-token-2022")) {
+          const parsed = ix.parsed;
+          if (parsed?.type === "transferChecked" || parsed?.type === "transfer") {
+            if (this.debug) {
+              console.log(`[LocalSvmFacilitator] Found SPL transfer`);
             }
-          } catch (e) {
-            console.warn("[usePaywallResource] Failed to parse x402 header:", e);
           }
-        } else {
-          console.warn("[usePaywallResource] 402 response missing WWW-Authenticate header");
         }
-        setIsLocked(true);
-        setData(null);
-      } else if (res.ok) {
-        const json = await res.json();
-        setData(json);
-        setIsLocked(false);
-      } else {
-        throw new Error(`Request failed with status ${res.status}`);
       }
-    } catch (err) {
-      setError(err.message || "Failed to fetch resource");
-    } finally {
-      setIsLoading(false);
-    }
-  }, [url]);
-  react.useEffect(() => {
-    fetchData();
-  }, [fetchData]);
-  const unlock = react.useCallback(async () => {
-    if (!paymentHeader || !price || !recipient) {
-      setError("Missing payment requirements");
-      return;
-    }
-    setIsLoading(true);
-    try {
-      const { signature } = await sendSolanaPayment({
-        connection,
-        wallet,
-        recipientAddress: recipient,
-        amount: price
-      });
-      const authHeader = createX402AuthorizationHeader(signature, paymentHeader);
-      await fetchData(authHeader);
-    } catch (err) {
-      console.error("Unlock failed", err);
-      setError(err.message || "Payment/Unlock failed");
-      setIsLoading(false);
-    }
-  }, [connection, wallet, paymentHeader, price, recipient, fetchData]);
-  return {
-    data,
-    isLocked,
-    isLoading,
-    price,
-    recipient,
-    error,
-    unlock
-  };
-}
-
-// src/pricing/utils.ts
-function lamportsToSol(lamports) {
-  return Number(lamports) / 1e9;
-}
-
-// src/pricing/index.ts
-var priceCache = null;
-var currentConfig = {};
-function configurePricing(newConfig) {
-  currentConfig = { ...currentConfig, ...newConfig };
-}
-var PROVIDERS = [
-  {
-    name: "coincap",
-    url: "https://api.coincap.io/v2/assets/solana",
-    parse: (data) => parseFloat(data.data?.priceUsd || "0")
-  },
-  {
-    name: "binance",
-    url: "https://api.binance.com/api/v3/ticker/price?symbol=SOLUSDT",
-    parse: (data) => parseFloat(data.price || "0")
-  },
-  {
-    name: "coingecko",
-    url: "https://api.coingecko.com/api/v3/simple/price?ids=solana&vs_currencies=usd",
-    parse: (data) => data.solana?.usd || 0
-  },
-  {
-    name: "kraken",
-    url: "https://api.kraken.com/0/public/Ticker?pair=SOLUSD",
-    parse: (data) => parseFloat(data.result?.SOLUSD?.c?.[0] || "0")
-  }
-];
-async function fetchFromProvider(provider, timeout) {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeout);
-  try {
-    const response = await fetch(provider.url, {
-      headers: { "Accept": "application/json" },
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`);
-    }
-    const data = await response.json();
-    const price = provider.parse(data);
-    if (!price || price <= 0) {
-      throw new Error("Invalid price");
-    }
-    return { price, source: provider.name };
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-async function fetchPriceParallel(timeout) {
-  const promises = PROVIDERS.map(
-    (provider) => fetchFromProvider(provider, timeout).catch(() => null)
-  );
-  const results = await Promise.all(promises);
-  const validResult = results.find((r) => r !== null);
-  if (validResult) {
-    return validResult;
-  }
-  throw new Error("All providers failed");
-}
-async function fetchPriceSequential(timeout) {
-  for (const provider of PROVIDERS) {
-    try {
-      return await fetchFromProvider(provider, timeout);
-    } catch {
-      continue;
-    }
-  }
-  throw new Error("All providers failed");
-}
-async function getSolPrice() {
-  const cacheTTL = currentConfig.cacheTTL ?? 6e4;
-  const timeout = currentConfig.timeout ?? 3e3;
-  const useParallel = currentConfig.parallelFetch ?? true;
-  const now = Date.now();
-  if (priceCache && now - priceCache.timestamp < cacheTTL) {
-    return priceCache.data;
-  }
-  if (currentConfig.customProvider) {
-    try {
-      const price = await currentConfig.customProvider();
-      if (price > 0) {
-        const data = {
-          solPrice: price,
-          fetchedAt: /* @__PURE__ */ new Date(),
-          source: "custom"
+      if (paidAmount >= requiredAmount) {
+        if (this.debug) {
+          console.log(`[LocalSvmFacilitator] Verification SUCCESS for tx: ${signature.slice(0, 8)}...`);
+        }
+        return {
+          isValid: true,
+          payer: payer || tx.transaction.message.accountKeys[0].pubkey.toBase58()
         };
-        priceCache = { data, timestamp: now };
-        return data;
       }
-    } catch {
-    }
-  }
-  try {
-    const result = useParallel ? await fetchPriceParallel(timeout) : await fetchPriceSequential(timeout);
-    const data = {
-      solPrice: result.price,
-      fetchedAt: /* @__PURE__ */ new Date(),
-      source: result.source
-    };
-    priceCache = { data, timestamp: now };
-    return data;
-  } catch {
-    if (priceCache) {
       return {
-        ...priceCache.data,
-        source: `${priceCache.data.source} (stale)`
+        isValid: false,
+        invalidReason: "Insufficient payment amount",
+        payer
       };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      if (this.debug) {
+        console.error("[LocalSvmFacilitator] Verify error:", errorMessage);
+      }
+      throw new types.VerifyError(500, {
+        isValid: false,
+        invalidReason: errorMessage
+      });
     }
-    throw new Error(
-      "Failed to fetch SOL price from all providers. Configure a custom provider or ensure network connectivity."
-    );
   }
-}
-async function lamportsToUsd(lamports) {
-  const { solPrice } = await getSolPrice();
-  const sol = Number(lamports) / 1e9;
-  return sol * solPrice;
-}
-async function usdToLamports(usd) {
-  const { solPrice } = await getSolPrice();
-  const sol = usd / solPrice;
-  return BigInt(Math.floor(sol * 1e9));
-}
-async function formatPriceDisplay(lamports) {
-  const { solPrice } = await getSolPrice();
-  const sol = Number(lamports) / 1e9;
-  const usd = sol * solPrice;
-  return `${sol.toFixed(4)} SOL (~$${usd.toFixed(2)})`;
-}
-function formatPriceSync(lamports, solPrice) {
-  const sol = Number(lamports) / 1e9;
-  const usd = sol * solPrice;
-  return {
-    sol,
-    usd,
-    formatted: `${sol.toFixed(4)} SOL (~$${usd.toFixed(2)})`
-  };
-}
-function clearPriceCache() {
-  priceCache = null;
-}
-function getProviders() {
-  return PROVIDERS.map((p) => ({ name: p.name, url: p.url }));
-}
-
-// src/client/hooks.ts
-function usePricing(refreshIntervalMs = 6e4) {
-  const [priceData, setPriceData] = react.useState(null);
-  const [isLoading, setIsLoading] = react.useState(true);
-  const [error, setError] = react.useState(null);
-  const intervalRef = react.useRef(null);
-  const fetchPrice = react.useCallback(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const data = await getSolPrice();
-      setPriceData(data);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : "Failed to fetch price");
-    } finally {
-      setIsLoading(false);
-    }
-  }, []);
-  react.useEffect(() => {
-    fetchPrice();
-    if (refreshIntervalMs > 0) {
-      intervalRef.current = setInterval(fetchPrice, refreshIntervalMs);
-    }
-    return () => {
-      if (intervalRef.current) {
-        clearInterval(intervalRef.current);
+  /**
+   * Fetch transaction with exponential backoff retry
+   */
+  async fetchTransactionWithRetry(signature, maxRetries = 3) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const tx = await this.connection.getParsedTransaction(signature, {
+          maxSupportedTransactionVersion: 0,
+          commitment: "confirmed"
+        });
+        if (tx) return tx;
+        if (attempt < maxRetries - 1) {
+          await this.sleep(Math.pow(2, attempt) * 1e3);
+        }
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error("RPC error");
+        if (attempt < maxRetries - 1) {
+          await this.sleep(Math.pow(2, attempt) * 1e3);
+        }
       }
-    };
-  }, [fetchPrice, refreshIntervalMs]);
-  return {
-    solPrice: priceData?.solPrice ?? null,
-    source: priceData?.source ?? null,
-    fetchedAt: priceData?.fetchedAt ?? null,
-    isLoading,
-    error,
-    refresh: fetchPrice
-  };
-}
-function useLamportsToUsd(lamports) {
-  const { solPrice, isLoading } = usePricing();
-  if (isLoading || !solPrice || lamports === null) {
-    return { usd: null, formatted: null, isLoading };
-  }
-  const lamportsBigInt = typeof lamports === "number" ? BigInt(lamports) : lamports;
-  const sol = Number(lamportsBigInt) / 1e9;
-  const usd = sol * solPrice;
-  return {
-    usd,
-    formatted: `$${usd.toFixed(2)}`,
-    isLoading: false
-  };
-}
-function useMicropay() {
-  const [status, setStatus] = react.useState("idle");
-  const [error, setError] = react.useState(null);
-  const [signature, setSignature] = react.useState(null);
-  const reset = react.useCallback(() => {
-    setStatus("idle");
-    setError(null);
-    setSignature(null);
-  }, []);
-  const pay = react.useCallback(async (_options) => {
-    setStatus("pending");
-    setError(null);
-    try {
-      throw new Error(
-        "useMicropay requires implementation of onSign/onSend callbacks. See documentation for wallet adapter integration."
-      );
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : "Payment failed";
-      setError(errorMessage);
-      setStatus("error");
-      return { success: false, error: errorMessage };
     }
-  }, []);
-  return {
-    status,
-    error,
-    signature,
-    pay,
-    reset
-  };
-}
-function useFormatPrice(lamports) {
-  const { solPrice, isLoading } = usePricing();
-  if (isLoading || !solPrice || lamports === null) {
+    if (lastError) throw lastError;
+    return null;
+  }
+  /**
+   * Sleep helper
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Settle a payment (not applicable for direct chain verification, usually)
+   * But we must implement it. For 'exact', settlement is just verification + finality.
+   */
+  async settle(payload, requirements) {
+    const verifyResult = await this.verify(payload, requirements);
+    if (!verifyResult.isValid) {
+      throw new types.SettleError(400, {
+        success: false,
+        errorReason: verifyResult.invalidReason || "Verification failed",
+        transaction: payload.payload.signature,
+        network: requirements.network
+      });
+    }
     return {
-      sol: null,
-      usd: null,
-      formatted: "Loading...",
-      isLoading
+      success: true,
+      payer: verifyResult.payer,
+      transaction: payload.payload.signature,
+      network: requirements.network
     };
   }
-  const lamportsBigInt = typeof lamports === "number" ? BigInt(lamports) : lamports;
-  const sol = Number(lamportsBigInt) / 1e9;
-  const usd = sol * solPrice;
-  return {
-    sol,
-    usd,
-    formatted: `${sol.toFixed(4)} SOL (~$${usd.toFixed(2)})`,
-    isLoading: false
-  };
-}
+};
 var DEFAULT_COMPUTE_UNITS = 2e5;
 var DEFAULT_MICRO_LAMPORTS = 1e3;
 function createPriorityFeeInstructions(config = {}) {
@@ -870,14 +565,162 @@ async function getRemainingCredits(token, secret) {
   };
 }
 
+// src/pricing/utils.ts
+function lamportsToSol(lamports) {
+  return Number(lamports) / 1e9;
+}
+
+// src/pricing/index.ts
+var priceCache = null;
+var currentConfig = {};
+function configurePricing(newConfig) {
+  currentConfig = { ...currentConfig, ...newConfig };
+}
+var PROVIDERS = [
+  {
+    name: "coincap",
+    url: "https://api.coincap.io/v2/assets/solana",
+    parse: (data) => parseFloat(data.data?.priceUsd || "0")
+  },
+  {
+    name: "binance",
+    url: "https://api.binance.com/api/v3/ticker/price?symbol=SOLUSDT",
+    parse: (data) => parseFloat(data.price || "0")
+  },
+  {
+    name: "coingecko",
+    url: "https://api.coingecko.com/api/v3/simple/price?ids=solana&vs_currencies=usd",
+    parse: (data) => data.solana?.usd || 0
+  },
+  {
+    name: "kraken",
+    url: "https://api.kraken.com/0/public/Ticker?pair=SOLUSD",
+    parse: (data) => parseFloat(data.result?.SOLUSD?.c?.[0] || "0")
+  }
+];
+async function fetchFromProvider(provider, timeout) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(provider.url, {
+      headers: { "Accept": "application/json" },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    const price = provider.parse(data);
+    if (!price || price <= 0) {
+      throw new Error("Invalid price");
+    }
+    return { price, source: provider.name };
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function fetchPriceParallel(timeout) {
+  const promises = PROVIDERS.map(
+    (provider) => fetchFromProvider(provider, timeout).catch(() => null)
+  );
+  const results = await Promise.all(promises);
+  const validResult = results.find((r) => r !== null);
+  if (validResult) {
+    return validResult;
+  }
+  throw new Error("All providers failed");
+}
+async function fetchPriceSequential(timeout) {
+  for (const provider of PROVIDERS) {
+    try {
+      return await fetchFromProvider(provider, timeout);
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("All providers failed");
+}
+async function getSolPrice() {
+  const cacheTTL = currentConfig.cacheTTL ?? 6e4;
+  const timeout = currentConfig.timeout ?? 3e3;
+  const useParallel = currentConfig.parallelFetch ?? true;
+  const now = Date.now();
+  if (priceCache && now - priceCache.timestamp < cacheTTL) {
+    return priceCache.data;
+  }
+  if (currentConfig.customProvider) {
+    try {
+      const price = await currentConfig.customProvider();
+      if (price > 0) {
+        const data = {
+          solPrice: price,
+          fetchedAt: /* @__PURE__ */ new Date(),
+          source: "custom"
+        };
+        priceCache = { data, timestamp: now };
+        return data;
+      }
+    } catch {
+    }
+  }
+  try {
+    const result = useParallel ? await fetchPriceParallel(timeout) : await fetchPriceSequential(timeout);
+    const data = {
+      solPrice: result.price,
+      fetchedAt: /* @__PURE__ */ new Date(),
+      source: result.source
+    };
+    priceCache = { data, timestamp: now };
+    return data;
+  } catch {
+    if (priceCache) {
+      return {
+        ...priceCache.data,
+        source: `${priceCache.data.source} (stale)`
+      };
+    }
+    throw new Error(
+      "Failed to fetch SOL price from all providers. Configure a custom provider or ensure network connectivity."
+    );
+  }
+}
+async function lamportsToUsd(lamports) {
+  const { solPrice } = await getSolPrice();
+  const sol = Number(lamports) / 1e9;
+  return sol * solPrice;
+}
+async function usdToLamports(usd) {
+  const { solPrice } = await getSolPrice();
+  const sol = usd / solPrice;
+  return BigInt(Math.floor(sol * 1e9));
+}
+async function formatPriceDisplay(lamports) {
+  const { solPrice } = await getSolPrice();
+  const sol = Number(lamports) / 1e9;
+  const usd = sol * solPrice;
+  return `${sol.toFixed(4)} SOL (~$${usd.toFixed(2)})`;
+}
+function formatPriceSync(lamports, solPrice) {
+  const sol = Number(lamports) / 1e9;
+  const usd = sol * solPrice;
+  return {
+    sol,
+    usd,
+    formatted: `${sol.toFixed(4)} SOL (~$${usd.toFixed(2)})`
+  };
+}
+function clearPriceCache() {
+  priceCache = null;
+}
+function getProviders() {
+  return PROVIDERS.map((p) => ({ name: p.name, url: p.url }));
+}
+
+exports.LocalSvmFacilitator = LocalSvmFacilitator;
 exports.addCredits = addCredits;
-exports.buildSolanaPayUrl = buildSolanaPayUrl;
 exports.clearPriceCache = clearPriceCache;
 exports.configurePricing = configurePricing;
 exports.createCreditSession = createCreditSession;
-exports.createPaymentFlow = createPaymentFlow;
-exports.createPaymentReference = createPaymentReference;
-exports.createX402AuthorizationHeader = createX402AuthorizationHeader;
 exports.executeAgentPayment = executeAgentPayment;
 exports.formatPriceDisplay = formatPriceDisplay;
 exports.formatPriceSync = formatPriceSync;
@@ -890,14 +733,8 @@ exports.hasAgentSufficientBalance = hasAgentSufficientBalance;
 exports.keypairFromBase58 = keypairFromBase58;
 exports.lamportsToSol = lamportsToSol;
 exports.lamportsToUsd = lamportsToUsd;
-exports.sendSolanaPayment = sendSolanaPayment;
 exports.usdToLamports = usdToLamports;
 exports.useCredit = useCredit;
-exports.useFormatPrice = useFormatPrice;
-exports.useLamportsToUsd = useLamportsToUsd;
-exports.useMicropay = useMicropay;
-exports.usePaywallResource = usePaywallResource;
-exports.usePricing = usePricing;
 exports.validateCreditSession = validateCreditSession;
 Object.keys(core).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {