@alleyboss/micropay-solana-x402-paywall 3.2.2 → 3.3.1

package/dist/index.js

@@ -4,7 +4,7 @@ export * from '@x402/core/client';
 export * from '@x402/svm';
 import { decodePaymentRequiredHeader, encodePaymentSignatureHeader } from '@x402/core/http';
 import { PublicKey, Transaction, SystemProgram, LAMPORTS_PER_SOL, Keypair, TransactionMessage, VersionedTransaction, ComputeBudgetProgram } from '@solana/web3.js';
-import { useState, useCallback, useEffect } from 'react';
+import { useState, useCallback, useEffect, useRef } from 'react';
 import bs58 from 'bs58';
 import { SignJWT, jwtVerify } from 'jose';
 
@@ -41,8 +41,8 @@ function buildSolanaPayUrl(params) {
   }
   return url.toString();
 }
-function createPaymentFlow(config2) {
-  const { network, recipientWallet, amount, asset = "native", memo } = config2;
+function createPaymentFlow(config) {
+  const { network, recipientWallet, amount, asset = "native", memo } = config;
   let decimals = 9;
   let mintAddress;
   if (asset === "usdc") {
@@ -58,7 +58,7 @@ function createPaymentFlow(config2) {
   const naturalAmount = Number(amount) / Math.pow(10, decimals);
   return {
     /** Get the payment configuration */
-    getConfig: () => ({ ...config2 }),
+    getConfig: () => ({ ...config }),
     /** Get amount in natural display units (e.g., 0.01 SOL) */
     getDisplayAmount: () => naturalAmount,
     /** Get amount formatted with symbol */
@@ -188,13 +188,17 @@ function usePaywallResource({
         if (wwwAuth) {
           setPaymentHeader(wwwAuth);
           try {
-            const match = wwwAuth.match(/amount="([^"]+)",\s*payTo="([^"]+)"/);
-            if (match) {
-              setPrice(BigInt(match[1]));
-              setRecipient(match[2]);
+            const { decodePaymentRequiredHeader: decodePaymentRequiredHeader2 } = await import('@x402/core/http');
+            const cleanHeader = wwwAuth.replace(/^[Xx]402\s+/, "");
+            const decoded = decodePaymentRequiredHeader2(cleanHeader);
+            const accepts = Array.isArray(decoded.accepts) ? decoded.accepts[0] : decoded.accepts;
+            if (accepts) {
+              const amountStr = accepts.amount || accepts.maxAmountRequired || "0";
+              setPrice(BigInt(amountStr));
+              setRecipient(accepts.payTo);
             }
           } catch (e) {
-            console.warn("Failed to parse 402 details from header", e);
+            console.warn("[usePaywallResource] Failed to parse x402 header:", e);
           }
         }
         setIsLocked(true);
@@ -246,10 +250,265 @@ function usePaywallResource({
     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"
+        };
+        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 }));
+}
+
+// src/client/hooks.ts
+function usePricing(refreshIntervalMs = 6e4) {
+  const [priceData, setPriceData] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const intervalRef = useRef(null);
+  const fetchPrice = 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);
+    }
+  }, []);
+  useEffect(() => {
+    fetchPrice();
+    if (refreshIntervalMs > 0) {
+      intervalRef.current = setInterval(fetchPrice, refreshIntervalMs);
+    }
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+      }
+    };
+  }, [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] = useState("idle");
+  const [error, setError] = useState(null);
+  const [signature, setSignature] = useState(null);
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setError(null);
+    setSignature(null);
+  }, []);
+  const pay = 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) {
+    return {
+      sol: null,
+      usd: null,
+      formatted: "Loading...",
+      isLoading
+    };
+  }
+  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(config2 = {}) {
-  const { enabled = false, microLamports, computeUnits } = config2;
+function createPriorityFeeInstructions(config = {}) {
+  const { enabled = false, microLamports, computeUnits } = config;
   if (!enabled) {
     return [];
   }
@@ -260,14 +519,14 @@ function createPriorityFeeInstructions(config2 = {}) {
   instructions.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: price }));
   return instructions;
 }
-async function buildVersionedTransaction(config2) {
+async function buildVersionedTransaction(config) {
   const {
     connection,
     payer,
     instructions,
     priorityFee,
     recentBlockhash
-  } = config2;
+  } = config;
   const priorityIxs = createPriorityFeeInstructions(priorityFee);
   const allInstructions = [...priorityIxs, ...instructions];
   let blockhash;
@@ -383,9 +642,9 @@ async function getAgentBalance(connection, agentKeypair) {
     balanceSol: balance / LAMPORTS_PER_SOL
   };
 }
-async function hasAgentSufficientBalance(connection, agentKeypair, requiredLamports) {
+async function hasAgentSufficientBalance(connection, agentKeypair, requiredLamports, feeBufferLamports = 5000000n) {
   const { balance } = await getAgentBalance(connection, agentKeypair);
-  const totalRequired = requiredLamports + 10000n;
+  const totalRequired = requiredLamports + feeBufferLamports;
   return {
     sufficient: balance >= totalRequired,
     balance,
@@ -434,20 +693,20 @@ function validateWalletAddress(address) {
   const base58Regex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
   return base58Regex.test(address);
 }
-async function createCreditSession(walletAddress, purchaseId, config2) {
+async function createCreditSession(walletAddress, purchaseId, config) {
   if (!validateWalletAddress(walletAddress)) {
     throw new Error("Invalid wallet address format");
   }
-  if (config2.initialCredits <= 0 || config2.initialCredits > MAX_CREDITS) {
+  if (config.initialCredits <= 0 || config.initialCredits > MAX_CREDITS) {
     throw new Error(`Credits must be between 1 and ${MAX_CREDITS}`);
   }
-  if (!config2.durationHours || config2.durationHours <= 0 || config2.durationHours > 8760) {
+  if (!config.durationHours || config.durationHours <= 0 || config.durationHours > 8760) {
     throw new Error("Session duration must be between 1 and 8760 hours (1 year)");
   }
   const sessionId = uuidv4();
   const now = Math.floor(Date.now() / 1e3);
-  const expiresAt = now + config2.durationHours * 3600;
-  const bundleExpiry = config2.bundleExpiryHours ? now + config2.bundleExpiryHours * 3600 : expiresAt;
+  const expiresAt = now + config.durationHours * 3600;
+  const bundleExpiry = config.bundleExpiryHours ? now + config.bundleExpiryHours * 3600 : expiresAt;
   const session = {
     id: sessionId,
     walletAddress,
@@ -455,22 +714,22 @@ async function createCreditSession(walletAddress, purchaseId, config2) {
     siteWideUnlock: false,
     createdAt: now,
     expiresAt,
-    credits: config2.initialCredits,
+    credits: config.initialCredits,
     bundleExpiry,
-    bundleType: config2.bundleType
+    bundleType: config.bundleType
   };
   const payload = {
     sub: walletAddress,
     sid: sessionId,
     articles: session.unlockedArticles,
     siteWide: false,
-    credits: config2.initialCredits,
+    credits: config.initialCredits,
     bundleExpiry,
-    bundleType: config2.bundleType,
+    bundleType: config.bundleType,
     iat: now,
     exp: expiresAt
   };
-  const token = await new SignJWT(payload).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(`${config2.durationHours}h`).sign(getSecretKey(config2.secret));
+  const token = await new SignJWT(payload).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(`${config.durationHours}h`).sign(getSecretKey(config.secret));
   return { token, session };
 }
 async function validateCreditSession(token, secret) {
@@ -588,139 +847,4 @@ async function getRemainingCredits(token, secret) {
   };
 }
 
-// src/pricing/utils.ts
-function lamportsToSol(lamports) {
-  return Number(lamports) / 1e9;
-}
-
-// src/pricing/index.ts
-var cachedPrice = null;
-var config = {};
-var lastProviderIndex = -1;
-function configurePricing(newConfig) {
-  config = { ...config, ...newConfig };
-  cachedPrice = null;
-}
-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;
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-async function getSolPrice() {
-  const cacheTTL = config.cacheTTL ?? 6e4;
-  const timeout = config.timeout ?? 5e3;
-  if (cachedPrice && Date.now() - cachedPrice.fetchedAt.getTime() < cacheTTL) {
-    return cachedPrice;
-  }
-  if (config.customProvider) {
-    try {
-      const price = await config.customProvider();
-      if (price > 0) {
-        cachedPrice = {
-          solPrice: price,
-          fetchedAt: /* @__PURE__ */ new Date(),
-          source: "custom"
-        };
-        return cachedPrice;
-      }
-    } catch {
-    }
-  }
-  for (let i = 0; i < PROVIDERS.length; i++) {
-    const idx = (lastProviderIndex + 1 + i) % PROVIDERS.length;
-    const provider = PROVIDERS[idx];
-    try {
-      const price = await fetchFromProvider(provider, timeout);
-      lastProviderIndex = idx;
-      cachedPrice = {
-        solPrice: price,
-        fetchedAt: /* @__PURE__ */ new Date(),
-        source: provider.name
-      };
-      return cachedPrice;
-    } catch {
-      continue;
-    }
-  }
-  if (cachedPrice) {
-    return {
-      ...cachedPrice,
-      source: `${cachedPrice.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() {
-  cachedPrice = null;
-  lastProviderIndex = -1;
-}
-function getProviders() {
-  return PROVIDERS.map((p) => ({ name: p.name, url: p.url }));
-}
-
-export { addCredits, buildSolanaPayUrl, clearPriceCache, configurePricing, createCreditSession, createPaymentFlow, createPaymentReference, createX402AuthorizationHeader, executeAgentPayment, formatPriceDisplay, formatPriceSync, generateAgentKeypair, getAgentBalance, getProviders, getRemainingCredits, getSolPrice, hasAgentSufficientBalance, keypairFromBase58, lamportsToSol, lamportsToUsd, sendSolanaPayment, usdToLamports, useCredit, usePaywallResource, validateCreditSession };
+export { addCredits, buildSolanaPayUrl, clearPriceCache, configurePricing, createCreditSession, createPaymentFlow, createPaymentReference, createX402AuthorizationHeader, executeAgentPayment, formatPriceDisplay, formatPriceSync, generateAgentKeypair, getAgentBalance, getProviders, getRemainingCredits, getSolPrice, hasAgentSufficientBalance, keypairFromBase58, lamportsToSol, lamportsToUsd, sendSolanaPayment, usdToLamports, useCredit, useFormatPrice, useLamportsToUsd, useMicropay, usePaywallResource, usePricing, validateCreditSession };