@alleyboss/micropay-solana-x402-paywall 2.3.1 → 3.0.1

package/dist/index.cjs

@@ -1,1153 +1,24 @@
 'use strict';
 
+var core = require('@x402/core');
+var types = require('@x402/core/types');
+var client = require('@x402/core/client');
+var svm = require('@x402/svm');
 var web3_js = require('@solana/web3.js');
 var jose = require('jose');
 var uuid = require('uuid');
 
-// src/types/payment.ts
-var TOKEN_MINTS = {
-  /** USDC on mainnet */
-  USDC_MAINNET: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-  /** USDC on devnet */
-  USDC_DEVNET: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
-  /** USDT on mainnet */
-  USDT_MAINNET: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
-};
-var cachedConnection = null;
-var cachedNetwork = null;
-var cachedFallbacks = [];
-var cachedFallbackEnabled = false;
-function buildRpcUrl(config2) {
-  const { network, rpcUrl, tatumApiKey } = config2;
-  if (rpcUrl) {
-    if (rpcUrl.includes("tatum.io") && tatumApiKey && !rpcUrl.includes(tatumApiKey)) {
-      return rpcUrl.endsWith("/") ? `${rpcUrl}${tatumApiKey}` : `${rpcUrl}/${tatumApiKey}`;
-    }
-    return rpcUrl;
-  }
-  if (tatumApiKey) {
-    const baseUrl = network === "mainnet-beta" ? "https://solana-mainnet.gateway.tatum.io" : "https://solana-devnet.gateway.tatum.io";
-    return `${baseUrl}/${tatumApiKey}`;
-  }
-  return web3_js.clusterApiUrl(network);
-}
-function createConnection(rpcUrl) {
-  return new web3_js.Connection(rpcUrl, {
-    commitment: "confirmed",
-    confirmTransactionInitialTimeout: 6e4
-  });
-}
-function getConnection(config2) {
-  const { network } = config2;
-  if (cachedConnection && cachedNetwork === network) {
-    return cachedConnection;
-  }
-  const rpcUrl = buildRpcUrl(config2);
-  cachedConnection = createConnection(rpcUrl);
-  cachedNetwork = network;
-  cachedFallbackEnabled = config2.enableFallback ?? false;
-  cachedFallbacks = [];
-  if (cachedFallbackEnabled && config2.fallbackRpcUrls?.length) {
-    cachedFallbacks = config2.fallbackRpcUrls.map(createConnection);
-  }
-  return cachedConnection;
-}
-function getConnectionWithFallback(config2) {
-  const connection = getConnection(config2);
-  return {
-    connection,
-    fallbacks: cachedFallbacks,
-    fallbackEnabled: cachedFallbackEnabled
-  };
-}
-async function withFallback(config2, operation) {
-  const { connection, fallbacks, fallbackEnabled } = getConnectionWithFallback(config2);
-  try {
-    return await operation(connection);
-  } catch (error) {
-    if (!fallbackEnabled || fallbacks.length === 0) {
-      throw error;
-    }
-    if (!isRetryableError(error)) {
-      throw error;
-    }
-    for (let i = 0; i < fallbacks.length; i++) {
-      try {
-        return await operation(fallbacks[i]);
-      } catch (fallbackError) {
-        if (i === fallbacks.length - 1) {
-          throw fallbackError;
-        }
-      }
-    }
-    throw error;
-  }
-}
-function isRetryableError(error) {
-  if (error instanceof Error) {
-    const message = error.message.toLowerCase();
-    return message.includes("429") || message.includes("503") || message.includes("502") || message.includes("timeout") || message.includes("econnrefused") || message.includes("enotfound") || message.includes("rate limit");
-  }
-  return false;
-}
-function resetConnection() {
-  cachedConnection = null;
-  cachedNetwork = null;
-}
-function isMainnet(network) {
-  return network === "mainnet-beta";
-}
-function toX402Network(network) {
-  return network === "mainnet-beta" ? "solana-mainnet" : "solana-devnet";
-}
-var SIGNATURE_REGEX = /^[1-9A-HJ-NP-Za-km-z]{87,88}$/;
-var WALLET_REGEX = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
-function isValidSignature(signature) {
-  if (!signature || typeof signature !== "string") return false;
-  return SIGNATURE_REGEX.test(signature);
-}
-function isValidWalletAddress(address) {
-  if (!address || typeof address !== "string") return false;
-  return WALLET_REGEX.test(address);
-}
-function parseSOLTransfer(transaction, expectedRecipient) {
-  const instructions = transaction.transaction.message.instructions;
-  for (const ix of instructions) {
-    if ("parsed" in ix && ix.program === "system") {
-      const parsed = ix.parsed;
-      if (parsed.type === "transfer" && parsed.info.destination === expectedRecipient) {
-        return {
-          from: parsed.info.source,
-          to: parsed.info.destination,
-          amount: BigInt(parsed.info.lamports)
-        };
-      }
-    }
-  }
-  if (transaction.meta?.innerInstructions) {
-    for (const inner of transaction.meta.innerInstructions) {
-      for (const ix of inner.instructions) {
-        if ("parsed" in ix && ix.program === "system") {
-          const parsed = ix.parsed;
-          if (parsed.type === "transfer" && parsed.info.destination === expectedRecipient) {
-            return {
-              from: parsed.info.source,
-              to: parsed.info.destination,
-              amount: BigInt(parsed.info.lamports)
-            };
-          }
-        }
-      }
-    }
-  }
-  return null;
-}
-async function verifyPayment(params) {
-  const {
-    signature,
-    expectedRecipient,
-    expectedAmount,
-    maxAgeSeconds = 300,
-    clientConfig,
-    signatureStore
-  } = params;
-  if (!isValidSignature(signature)) {
-    return { valid: false, confirmed: false, signature, error: "Invalid signature format" };
-  }
-  if (!isValidWalletAddress(expectedRecipient)) {
-    return { valid: false, confirmed: false, signature, error: "Invalid recipient address" };
-  }
-  if (expectedAmount <= 0n) {
-    return { valid: false, confirmed: false, signature, error: "Invalid expected amount" };
-  }
-  if (signatureStore) {
-    const isUsed = await signatureStore.hasBeenUsed(signature);
-    if (isUsed) {
-      return { valid: false, confirmed: true, signature, error: "Signature already used" };
-    }
-  }
-  const effectiveMaxAge = Math.min(Math.max(maxAgeSeconds, 60), 3600);
-  const connection = getConnection(clientConfig);
-  try {
-    const transaction = await connection.getParsedTransaction(signature, {
-      commitment: "confirmed",
-      maxSupportedTransactionVersion: 0
-    });
-    if (!transaction) {
-      return { valid: false, confirmed: false, signature, error: "Transaction not found" };
-    }
-    if (transaction.meta?.err) {
-      return {
-        valid: false,
-        confirmed: true,
-        signature,
-        error: "Transaction failed on-chain"
-      };
-    }
-    if (transaction.blockTime) {
-      const now = Math.floor(Date.now() / 1e3);
-      if (now - transaction.blockTime > effectiveMaxAge) {
-        return { valid: false, confirmed: true, signature, error: "Transaction too old" };
-      }
-      if (transaction.blockTime > now + 60) {
-        return { valid: false, confirmed: true, signature, error: "Invalid transaction time" };
-      }
-    }
-    const transferDetails = parseSOLTransfer(transaction, expectedRecipient);
-    if (!transferDetails) {
-      return {
-        valid: false,
-        confirmed: true,
-        signature,
-        error: "No valid SOL transfer to recipient found"
-      };
-    }
-    if (transferDetails.amount < expectedAmount) {
-      return {
-        valid: false,
-        confirmed: true,
-        signature,
-        from: transferDetails.from,
-        to: transferDetails.to,
-        amount: transferDetails.amount,
-        error: "Insufficient payment amount"
-      };
-    }
-    return {
-      valid: true,
-      confirmed: true,
-      signature,
-      from: transferDetails.from,
-      to: transferDetails.to,
-      amount: transferDetails.amount,
-      blockTime: transaction.blockTime ?? void 0,
-      slot: transaction.slot
-    };
-  } catch (error) {
-    return {
-      valid: false,
-      confirmed: false,
-      signature,
-      error: "Verification failed"
-    };
-  }
-}
-async function waitForConfirmation(signature, clientConfig) {
-  if (!isValidSignature(signature)) {
-    return { confirmed: false, error: "Invalid signature format" };
-  }
-  const connection = getConnection(clientConfig);
-  try {
-    const confirmation = await connection.confirmTransaction(signature, "confirmed");
-    if (confirmation.value.err) {
-      return { confirmed: false, error: "Transaction failed" };
-    }
-    return { confirmed: true, slot: confirmation.context?.slot };
-  } catch {
-    return { confirmed: false, error: "Confirmation timeout" };
-  }
-}
-async function getWalletTransactions(walletAddress, clientConfig, limit = 20) {
-  if (!isValidWalletAddress(walletAddress)) {
-    return [];
-  }
-  const safeLimit = Math.min(Math.max(limit, 1), 100);
-  const connection = getConnection(clientConfig);
-  try {
-    const pubkey = new web3_js.PublicKey(walletAddress);
-    const signatures = await connection.getSignaturesForAddress(pubkey, { limit: safeLimit });
-    return signatures.map((sig) => ({
-      signature: sig.signature,
-      blockTime: sig.blockTime ?? void 0,
-      slot: sig.slot
-    }));
-  } catch {
-    return [];
-  }
-}
-function lamportsToSol(lamports) {
-  return Number(lamports) / web3_js.LAMPORTS_PER_SOL;
-}
-function solToLamports(sol) {
-  if (!Number.isFinite(sol) || sol < 0) {
-    throw new Error("Invalid SOL amount");
-  }
-  return BigInt(Math.floor(sol * web3_js.LAMPORTS_PER_SOL));
-}
-var SIGNATURE_REGEX2 = /^[1-9A-HJ-NP-Za-km-z]{87,88}$/;
-var WALLET_REGEX2 = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
-function resolveMintAddress(asset, network) {
-  if (asset === "native") return null;
-  if (asset === "usdc") {
-    return network === "mainnet-beta" ? TOKEN_MINTS.USDC_MAINNET : TOKEN_MINTS.USDC_DEVNET;
-  }
-  if (asset === "usdt") {
-    return TOKEN_MINTS.USDT_MAINNET;
-  }
-  if (typeof asset === "object" && "mint" in asset) {
-    return asset.mint;
-  }
-  return null;
-}
-function getTokenDecimals(asset) {
-  if (asset === "native") return 9;
-  if (asset === "usdc" || asset === "usdt") return 6;
-  if (typeof asset === "object" && "decimals" in asset) {
-    return asset.decimals ?? 6;
-  }
-  return 6;
-}
-function parseSPLTransfer(transaction, expectedRecipient, expectedMint) {
-  const instructions = transaction.transaction.message.instructions;
-  for (const ix of instructions) {
-    if ("parsed" in ix && (ix.program === "spl-token" || ix.program === "spl-token-2022")) {
-      const parsed = ix.parsed;
-      if (parsed.type === "transfer" || parsed.type === "transferChecked") {
-        const amount = parsed.info.amount || parsed.info.tokenAmount?.amount;
-        if (amount && parsed.info.destination) {
-          return {
-            from: parsed.info.authority || parsed.info.source || "",
-            to: parsed.info.destination,
-            amount: BigInt(amount),
-            mint: parsed.info.mint || expectedMint
-          };
-        }
-      }
-    }
-  }
-  if (transaction.meta?.innerInstructions) {
-    for (const inner of transaction.meta.innerInstructions) {
-      for (const ix of inner.instructions) {
-        if ("parsed" in ix && (ix.program === "spl-token" || ix.program === "spl-token-2022")) {
-          const parsed = ix.parsed;
-          if (parsed.type === "transfer" || parsed.type === "transferChecked") {
-            const amount = parsed.info.amount || parsed.info.tokenAmount?.amount;
-            if (amount) {
-              return {
-                from: parsed.info.authority || parsed.info.source || "",
-                to: parsed.info.destination || "",
-                amount: BigInt(amount),
-                mint: parsed.info.mint || expectedMint
-              };
-            }
-          }
-        }
-      }
-    }
-  }
-  if (transaction.meta?.postTokenBalances && transaction.meta?.preTokenBalances) {
-    const preBalances = transaction.meta.preTokenBalances;
-    const postBalances = transaction.meta.postTokenBalances;
-    for (const post of postBalances) {
-      if (post.mint === expectedMint && post.owner === expectedRecipient) {
-        const pre = preBalances.find(
-          (p) => p.accountIndex === post.accountIndex
-        );
-        const preAmount = BigInt(pre?.uiTokenAmount?.amount || "0");
-        const postAmount = BigInt(post.uiTokenAmount?.amount || "0");
-        const transferred = postAmount - preAmount;
-        if (transferred > 0n) {
-          return {
-            from: "",
-            // Can't determine from balance changes
-            to: expectedRecipient,
-            amount: transferred,
-            mint: expectedMint
-          };
-        }
-      }
-    }
-  }
-  return null;
-}
-async function verifySPLPayment(params) {
-  const {
-    signature,
-    expectedRecipient,
-    expectedAmount,
-    asset,
-    clientConfig,
-    maxAgeSeconds = 300,
-    signatureStore
-  } = params;
-  if (signatureStore) {
-    const isUsed = await signatureStore.hasBeenUsed(signature);
-    if (isUsed) {
-      return { valid: false, confirmed: true, signature, error: "Signature already used" };
-    }
-  }
-  if (!SIGNATURE_REGEX2.test(signature)) {
-    return { valid: false, confirmed: false, signature, error: "Invalid signature format" };
-  }
-  if (!WALLET_REGEX2.test(expectedRecipient)) {
-    return { valid: false, confirmed: false, signature, error: "Invalid recipient address" };
-  }
-  const mintAddress = resolveMintAddress(asset, clientConfig.network);
-  if (!mintAddress) {
-    return { valid: false, confirmed: false, signature, error: "Invalid asset configuration" };
-  }
-  if (expectedAmount <= 0n) {
-    return { valid: false, confirmed: false, signature, error: "Invalid expected amount" };
-  }
-  const effectiveMaxAge = Math.min(Math.max(maxAgeSeconds, 60), 3600);
-  const connection = getConnection(clientConfig);
-  try {
-    const transaction = await connection.getParsedTransaction(signature, {
-      commitment: "confirmed",
-      maxSupportedTransactionVersion: 0
-    });
-    if (!transaction) {
-      return { valid: false, confirmed: false, signature, error: "Transaction not found" };
-    }
-    if (transaction.meta?.err) {
-      return { valid: false, confirmed: true, signature, error: "Transaction failed on-chain" };
-    }
-    if (transaction.blockTime) {
-      const now = Math.floor(Date.now() / 1e3);
-      if (now - transaction.blockTime > effectiveMaxAge) {
-        return { valid: false, confirmed: true, signature, error: "Transaction too old" };
-      }
-      if (transaction.blockTime > now + 60) {
-        return { valid: false, confirmed: true, signature, error: "Invalid transaction time" };
-      }
-    }
-    const transfer = parseSPLTransfer(transaction, expectedRecipient, mintAddress);
-    if (!transfer) {
-      return {
-        valid: false,
-        confirmed: true,
-        signature,
-        error: "No valid token transfer to recipient found"
-      };
-    }
-    if (transfer.to) {
-      try {
-        const destinationInfo = await connection.getParsedAccountInfo(new web3_js.PublicKey(transfer.to));
-        const owner = destinationInfo.value?.data?.parsed?.info?.owner;
-        if (owner && owner !== expectedRecipient) {
-          return {
-            valid: false,
-            confirmed: true,
-            signature,
-            error: "Recipient mismatch: Token account not owned by merchant"
-          };
-        }
-      } catch (e) {
-        return {
-          valid: false,
-          confirmed: true,
-          signature,
-          error: "Could not verify token account owner"
-        };
-      }
-    }
-    if (transfer.mint !== mintAddress) {
-      return {
-        valid: false,
-        confirmed: true,
-        signature,
-        error: "Token mint mismatch"
-      };
-    }
-    if (transfer.amount < expectedAmount) {
-      return {
-        valid: false,
-        confirmed: true,
-        signature,
-        from: transfer.from,
-        to: transfer.to,
-        mint: transfer.mint,
-        amount: transfer.amount,
-        error: "Insufficient payment amount"
-      };
-    }
-    return {
-      valid: true,
-      confirmed: true,
-      signature,
-      from: transfer.from,
-      to: transfer.to,
-      mint: transfer.mint,
-      amount: transfer.amount,
-      blockTime: transaction.blockTime ?? void 0,
-      slot: transaction.slot
-    };
-  } catch {
-    return { valid: false, confirmed: false, signature, error: "Verification failed" };
-  }
-}
-function isNativeAsset(asset) {
-  return asset === "native";
-}
-var DEFAULT_COMPUTE_UNITS = 2e5;
-var DEFAULT_MICRO_LAMPORTS = 1e3;
-function createPriorityFeeInstructions(config2 = {}) {
-  const { enabled = false, microLamports, computeUnits } = config2;
-  if (!enabled) {
-    return [];
-  }
-  const instructions = [];
-  const units = computeUnits ?? DEFAULT_COMPUTE_UNITS;
-  instructions.push(web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units }));
-  const price = microLamports ?? DEFAULT_MICRO_LAMPORTS;
-  instructions.push(web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: price }));
-  return instructions;
-}
-async function estimatePriorityFee(connection, accounts = []) {
-  try {
-    const fees = await connection.getRecentPrioritizationFees({
-      lockedWritableAccounts: accounts
-    });
-    if (fees.length === 0) {
-      return DEFAULT_MICRO_LAMPORTS;
-    }
-    const sortedFees = fees.map((f) => f.prioritizationFee).filter((f) => f > 0).sort((a, b) => a - b);
-    if (sortedFees.length === 0) {
-      return DEFAULT_MICRO_LAMPORTS;
-    }
-    const medianIndex = Math.floor(sortedFees.length / 2);
-    return sortedFees[medianIndex];
-  } catch {
-    return DEFAULT_MICRO_LAMPORTS;
-  }
-}
-function calculatePriorityFeeCost(microLamportsPerCU, computeUnits) {
-  return Math.ceil(microLamportsPerCU * computeUnits / 1e6);
-}
-async function buildVersionedTransaction(config2) {
-  const {
-    connection,
-    payer,
-    instructions,
-    lookupTables = [],
-    priorityFee,
-    recentBlockhash
-  } = config2;
-  const priorityIxs = createPriorityFeeInstructions(priorityFee);
-  const allInstructions = [...priorityIxs, ...instructions];
-  let blockhash;
-  let lastValidBlockHeight;
-  if (recentBlockhash) {
-    blockhash = recentBlockhash;
-    const slot = await connection.getSlot();
-    lastValidBlockHeight = slot + 150;
-  } else {
-    const latestBlockhash = await connection.getLatestBlockhash("confirmed");
-    blockhash = latestBlockhash.blockhash;
-    lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
-  }
-  const message = new web3_js.TransactionMessage({
-    payerKey: payer,
-    recentBlockhash: blockhash,
-    instructions: allInstructions
-  }).compileToV0Message(lookupTables);
-  const transaction = new web3_js.VersionedTransaction(message);
-  return {
-    transaction,
-    blockhash,
-    lastValidBlockHeight
-  };
-}
-async function fetchLookupTables(connection, addresses) {
-  const tables = [];
-  for (const address of addresses) {
-    const result = await connection.getAddressLookupTable(address);
-    if (result.value) {
-      tables.push(result.value);
-    }
-  }
-  return tables;
-}
-function isVersionedTransaction(tx) {
-  return tx instanceof web3_js.VersionedTransaction;
-}
-var MAX_ARTICLES_PER_SESSION = 100;
-var MIN_SECRET_LENGTH = 32;
-function getSecretKey(secret) {
-  if (!secret || typeof secret !== "string") {
-    throw new Error("Session secret is required");
-  }
-  if (secret.length < MIN_SECRET_LENGTH) {
-    throw new Error(`Session secret must be at least ${MIN_SECRET_LENGTH} characters`);
-  }
-  return new TextEncoder().encode(secret);
-}
-function validateWalletAddress(address) {
-  if (!address || typeof address !== "string") return false;
-  const base58Regex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
-  return base58Regex.test(address);
-}
-function validateArticleId(articleId) {
-  if (!articleId || typeof articleId !== "string") return false;
-  if (articleId.length > 128) return false;
-  const safeIdRegex = /^[a-zA-Z0-9_-]+$/;
-  return safeIdRegex.test(articleId);
-}
-async function createSession(walletAddress, articleId, config2, siteWide = false) {
-  if (!validateWalletAddress(walletAddress)) {
-    throw new Error("Invalid wallet address format");
-  }
-  if (!validateArticleId(articleId)) {
-    throw new Error("Invalid article ID format");
-  }
-  if (!config2.durationHours || config2.durationHours <= 0 || config2.durationHours > 720) {
-    throw new Error("Session duration must be between 1 and 720 hours");
-  }
-  const sessionId = uuid.v4();
-  const now = Math.floor(Date.now() / 1e3);
-  const expiresAt = now + config2.durationHours * 3600;
-  const session = {
-    id: sessionId,
-    walletAddress,
-    unlockedArticles: [articleId],
-    siteWideUnlock: Boolean(siteWide),
-    createdAt: now,
-    expiresAt
-  };
-  const payload = {
-    sub: walletAddress,
-    sid: sessionId,
-    articles: session.unlockedArticles,
-    siteWide: session.siteWideUnlock,
-    iat: now,
-    exp: expiresAt
-  };
-  const token = await new jose.SignJWT(payload).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(`${config2.durationHours}h`).sign(getSecretKey(config2.secret));
-  return { token, session };
-}
-async function validateSession(token, secret) {
-  if (!token || typeof token !== "string") {
-    return { valid: false, reason: "Invalid token format" };
-  }
-  try {
-    const { payload } = await jose.jwtVerify(token, getSecretKey(secret));
-    const sessionPayload = payload;
-    if (!sessionPayload.sub || !sessionPayload.sid || !sessionPayload.exp) {
-      return { valid: false, reason: "Malformed session payload" };
-    }
-    const now = Math.floor(Date.now() / 1e3);
-    if (sessionPayload.exp < now) {
-      return { valid: false, reason: "Session expired" };
-    }
-    if (!validateWalletAddress(sessionPayload.sub)) {
-      return { valid: false, reason: "Invalid session data" };
-    }
-    const session = {
-      id: sessionPayload.sid,
-      walletAddress: sessionPayload.sub,
-      unlockedArticles: Array.isArray(sessionPayload.articles) ? sessionPayload.articles : [],
-      siteWideUnlock: Boolean(sessionPayload.siteWide),
-      createdAt: sessionPayload.iat ?? 0,
-      expiresAt: sessionPayload.exp
-    };
-    return { valid: true, session };
-  } catch (error) {
-    return { valid: false, reason: "Invalid session" };
-  }
-}
-async function addArticleToSession(token, articleId, secret) {
-  if (!validateArticleId(articleId)) {
-    return null;
-  }
-  const validation = await validateSession(token, secret);
-  if (!validation.valid || !validation.session) {
-    return null;
-  }
-  const session = validation.session;
-  if (session.unlockedArticles.includes(articleId)) {
-    return { token, session };
-  }
-  if (session.unlockedArticles.length >= MAX_ARTICLES_PER_SESSION) {
-    return null;
-  }
-  const updatedArticles = [...session.unlockedArticles, articleId];
-  const payload = {
-    sub: session.walletAddress,
-    sid: session.id,
-    articles: updatedArticles,
-    siteWide: session.siteWideUnlock,
-    iat: session.createdAt,
-    exp: session.expiresAt
-  };
-  const newToken = await new jose.SignJWT(payload).setProtectedHeader({ alg: "HS256" }).sign(getSecretKey(secret));
-  return {
-    token: newToken,
-    session: { ...session, unlockedArticles: updatedArticles }
-  };
-}
-async function isArticleUnlocked(token, articleId, secret) {
-  if (!validateArticleId(articleId)) {
-    return false;
-  }
-  const validation = await validateSession(token, secret);
-  if (!validation.valid || !validation.session) {
-    return false;
-  }
-  if (validation.session.siteWideUnlock) {
-    return true;
-  }
-  return validation.session.unlockedArticles.includes(articleId);
-}
-
-// src/x402/config.ts
-var WALLET_REGEX3 = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
-function sanitizeDisplayString(str, maxLength = 200) {
-  if (!str || typeof str !== "string") return "";
-  return str.slice(0, maxLength).replace(/[<>"'&]/g, "");
-}
-function isValidUrl(url) {
-  try {
-    const parsed = new URL(url);
-    return parsed.protocol === "http:" || parsed.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-function buildPaymentRequirement(params) {
-  if (!WALLET_REGEX3.test(params.creatorWallet)) {
-    throw new Error("Invalid creator wallet address");
-  }
-  if (params.priceInLamports <= 0n) {
-    throw new Error("Price must be positive");
-  }
-  if (!isValidUrl(params.resourceUrl)) {
-    throw new Error("Invalid resource URL");
-  }
-  if (params.network !== "devnet" && params.network !== "mainnet-beta") {
-    throw new Error("Invalid network");
-  }
-  const timeout = params.maxTimeoutSeconds ?? 300;
-  if (timeout < 60 || timeout > 3600) {
-    throw new Error("Timeout must be between 60 and 3600 seconds");
-  }
-  const x402Network = toX402Network(params.network);
-  const safeTitle = sanitizeDisplayString(params.articleTitle, 200);
-  const safeArticleId = sanitizeDisplayString(params.articleId, 128);
-  return {
-    scheme: "exact",
-    network: x402Network,
-    maxAmountRequired: params.priceInLamports.toString(),
-    resource: params.resourceUrl,
-    description: `Unlock: ${safeTitle}`,
-    mimeType: "text/html",
-    payTo: params.creatorWallet,
-    maxTimeoutSeconds: timeout,
-    asset: "native",
-    extra: {
-      name: safeTitle,
-      articleId: safeArticleId
-    }
-  };
-}
-function encodePaymentRequired(requirement) {
-  return Buffer.from(JSON.stringify(requirement)).toString("base64");
-}
-function decodePaymentRequired(encoded) {
-  if (!encoded || typeof encoded !== "string") {
-    throw new Error("Invalid encoded requirement");
-  }
-  if (encoded.length > 1e4) {
-    throw new Error("Encoded requirement too large");
-  }
-  try {
-    const decoded = Buffer.from(encoded, "base64").toString("utf-8");
-    return JSON.parse(decoded);
-  } catch {
-    throw new Error("Failed to decode payment requirement");
-  }
-}
-var X402_HEADERS = {
-  PAYMENT_REQUIRED: "X-Payment-Required",
-  PAYMENT: "X-Payment",
-  PAYMENT_RESPONSE: "X-Payment-Response"
-};
-function create402ResponseBody(requirement) {
-  const assetStr = typeof requirement.asset === "string" ? requirement.asset : requirement.asset.mint;
-  return {
-    error: "Payment Required",
-    message: requirement.description,
-    price: {
-      amount: requirement.maxAmountRequired,
-      asset: assetStr,
-      network: requirement.network
-    }
-  };
-}
-function create402Headers(requirement) {
-  const encoded = encodePaymentRequired(requirement);
-  return {
-    "Content-Type": "application/json",
-    [X402_HEADERS.PAYMENT_REQUIRED]: encoded,
-    "Access-Control-Expose-Headers": X402_HEADERS.PAYMENT_REQUIRED
-  };
-}
-
-// src/x402/verification.ts
-var SIGNATURE_REGEX3 = /^[1-9A-HJ-NP-Za-km-z]{87,88}$/;
-async function verifyX402Payment(payload, requirement, clientConfig) {
-  if (!payload || typeof payload !== "object") {
-    return { valid: false, invalidReason: "Invalid payload" };
-  }
-  const signature = payload.payload?.signature;
-  if (!signature || typeof signature !== "string") {
-    return { valid: false, invalidReason: "Missing transaction signature" };
-  }
-  if (!SIGNATURE_REGEX3.test(signature)) {
-    return { valid: false, invalidReason: "Invalid signature format" };
-  }
-  if (payload.x402Version !== 1) {
-    return { valid: false, invalidReason: "Unsupported x402 version" };
-  }
-  if (payload.scheme !== "exact") {
-    return { valid: false, invalidReason: "Unsupported payment scheme" };
-  }
-  if (payload.network !== requirement.network) {
-    return {
-      valid: false,
-      invalidReason: `Network mismatch: expected ${requirement.network}`
-    };
-  }
-  const walletRegex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
-  if (!walletRegex.test(requirement.payTo)) {
-    return { valid: false, invalidReason: "Invalid recipient configuration" };
-  }
-  let expectedAmount;
-  try {
-    expectedAmount = BigInt(requirement.maxAmountRequired);
-    if (expectedAmount <= 0n) {
-      return { valid: false, invalidReason: "Invalid payment amount" };
-    }
-  } catch {
-    return { valid: false, invalidReason: "Invalid payment amount format" };
-  }
-  const verification = await verifyPayment({
-    signature,
-    expectedRecipient: requirement.payTo,
-    expectedAmount,
-    maxAgeSeconds: requirement.maxTimeoutSeconds,
-    clientConfig
-  });
-  if (!verification.valid) {
-    return {
-      valid: false,
-      invalidReason: verification.error || "Transaction verification failed"
-    };
-  }
-  return {
-    valid: true,
-    settled: verification.confirmed,
-    from: verification.from,
-    transaction: {
-      signature: verification.signature,
-      blockTime: verification.blockTime,
-      slot: verification.slot
-    }
-  };
-}
-function parsePaymentHeader(header) {
-  if (!header || typeof header !== "string") {
-    return null;
-  }
-  if (header.length > 1e4) {
-    return null;
-  }
-  try {
-    const decoded = Buffer.from(header, "base64").toString("utf-8");
-    const parsed = JSON.parse(decoded);
-    if (!parsed || typeof parsed !== "object") {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function encodePaymentRequirement(requirement) {
-  return Buffer.from(JSON.stringify(requirement)).toString("base64");
-}
-function encodePaymentResponse(response) {
-  return Buffer.from(JSON.stringify(response)).toString("base64");
-}
-function create402Response(requirement, body) {
-  const headers = new Headers({
-    "Content-Type": "application/json",
-    "X-Payment-Required": encodePaymentRequirement(requirement)
-  });
-  const responseBody = body || {
-    error: "Payment Required",
-    message: "This resource requires payment to access",
-    x402Version: 1,
-    accepts: [requirement]
-  };
-  return new Response(JSON.stringify(responseBody), {
-    status: 402,
-    headers
-  });
-}
-
-// src/store/memory.ts
-function createMemoryStore(options = {}) {
-  const { cleanupInterval = 6e4 } = options;
-  const store = /* @__PURE__ */ new Map();
-  const cleanupTimer = setInterval(() => {
-    const now = Date.now();
-    for (const [key, record] of store.entries()) {
-      if (record.expiresAt < now) {
-        store.delete(key);
-      }
-    }
-  }, cleanupInterval);
-  return {
-    async hasBeenUsed(signature) {
-      const record = store.get(signature);
-      if (!record) return false;
-      if (record.expiresAt < Date.now()) {
-        store.delete(signature);
-        return false;
-      }
-      return true;
-    },
-    async markAsUsed(signature, resourceId, expiresAt) {
-      store.set(signature, {
-        resourceId,
-        usedAt: Date.now(),
-        expiresAt: expiresAt.getTime()
-      });
-    },
-    async getUsage(signature) {
-      const record = store.get(signature);
-      if (!record) return null;
-      if (record.expiresAt < Date.now()) {
-        store.delete(signature);
-        return null;
-      }
-      return {
-        signature,
-        resourceId: record.resourceId,
-        usedAt: new Date(record.usedAt),
-        expiresAt: new Date(record.expiresAt),
-        walletAddress: record.walletAddress
-      };
-    },
-    /** Stop cleanup timer (for graceful shutdown) */
-    close() {
-      clearInterval(cleanupTimer);
-      store.clear();
-    }
-  };
-}
-
-// src/store/redis.ts
-function createRedisStore(options) {
-  const { client, keyPrefix = "micropay:sig:" } = options;
-  const buildKey = (signature) => `${keyPrefix}${signature}`;
-  return {
-    async hasBeenUsed(signature) {
-      const exists = await client.exists(buildKey(signature));
-      return exists > 0;
-    },
-    async markAsUsed(signature, resourceId, expiresAt) {
-      const key = buildKey(signature);
-      const ttl = Math.max(1, Math.floor((expiresAt.getTime() - Date.now()) / 1e3));
-      const record = {
-        signature,
-        resourceId,
-        usedAt: /* @__PURE__ */ new Date(),
-        expiresAt
-      };
-      if (client.setex) {
-        await client.setex(key, ttl, JSON.stringify(record));
-      } else {
-        await client.set(key, JSON.stringify(record), { EX: ttl });
-      }
-    },
-    async getUsage(signature) {
-      const data = await client.get(buildKey(signature));
-      if (!data) return null;
-      try {
-        const record = JSON.parse(data);
-        return {
-          ...record,
-          usedAt: new Date(record.usedAt),
-          expiresAt: new Date(record.expiresAt)
-        };
-      } catch {
-        return null;
-      }
-    }
-  };
-}
-
-// src/middleware/nextjs.ts
-function matchesProtectedPath(path, patterns) {
-  for (const pattern of patterns) {
-    const regexPattern = pattern.replace(/\*\*/g, "{{DOUBLE_STAR}}").replace(/\*/g, "[^/]*").replace(/{{DOUBLE_STAR}}/g, ".*");
-    const regex = new RegExp(`^${regexPattern}$`);
-    if (regex.test(path)) {
-      return true;
-    }
-  }
-  return false;
-}
-async function checkPaywallAccess(path, sessionToken, config2) {
-  if (!matchesProtectedPath(path, config2.protectedPaths)) {
-    return { allowed: true };
-  }
-  if (!sessionToken) {
-    return {
-      allowed: false,
-      reason: "No session token",
-      requiresPayment: true
-    };
-  }
-  const validation = await validateSession(sessionToken, config2.sessionSecret);
-  if (!validation.valid || !validation.session) {
-    return {
-      allowed: false,
-      reason: validation.reason || "Invalid session",
-      requiresPayment: true
-    };
-  }
-  return {
-    allowed: true,
-    session: validation.session
-  };
-}
-function createPaywallMiddleware(config2) {
-  const { cookieName = "x402_session" } = config2;
-  return async function middleware(request) {
-    const url = new URL(request.url);
-    const path = url.pathname;
-    const cookieHeader = request.headers.get("cookie") || "";
-    const cookies = Object.fromEntries(
-      cookieHeader.split(";").map((c) => {
-        const [key, ...vals] = c.trim().split("=");
-        return [key, vals.join("=")];
-      })
-    );
-    const sessionToken = cookies[cookieName];
-    const result = await checkPaywallAccess(path, sessionToken, config2);
-    if (!result.allowed && result.requiresPayment) {
-      const headers = {
-        "Content-Type": "application/json"
-      };
-      if (config2.paymentRequirement) {
-        const requirement = typeof config2.paymentRequirement === "function" ? config2.paymentRequirement(path) : config2.paymentRequirement;
-        headers["X-Payment-Required"] = encodePaymentRequirement(requirement);
-      }
-      const body = config2.custom402Response ? config2.custom402Response(path) : {
-        error: "Payment Required",
-        message: "This resource requires payment to access",
-        x402Version: 1,
-        path
-      };
-      return new Response(JSON.stringify(body), {
-        status: 402,
-        headers
-      });
-    }
-    return null;
-  };
-}
-function withPaywall(handler, options) {
-  const { sessionSecret, cookieName = "x402_session", articleId } = options;
-  return async function protectedHandler(request) {
-    const cookieHeader = request.headers.get("cookie") || "";
-    const cookies = Object.fromEntries(
-      cookieHeader.split(";").map((c) => {
-        const [key, ...vals] = c.trim().split("=");
-        return [key, vals.join("=")];
-      })
-    );
-    const sessionToken = cookies[cookieName];
-    if (!sessionToken) {
-      return new Response(
-        JSON.stringify({ error: "Payment Required", message: "No session token" }),
-        { status: 402, headers: { "Content-Type": "application/json" } }
-      );
-    }
-    const validation = await validateSession(sessionToken, sessionSecret);
-    if (!validation.valid || !validation.session) {
-      return new Response(
-        JSON.stringify({ error: "Payment Required", message: validation.reason }),
-        { status: 402, headers: { "Content-Type": "application/json" } }
-      );
-    }
-    if (articleId) {
-      const { session } = validation;
-      const hasAccess = session.siteWideUnlock || session.unlockedArticles.includes(articleId);
-      if (!hasAccess) {
-        return new Response(
-          JSON.stringify({ error: "Payment Required", message: "Article not unlocked" }),
-          { status: 402, headers: { "Content-Type": "application/json" } }
-        );
-      }
-    }
-    return handler(request, validation.session);
-  };
-}
+// src/index.ts
 
-// src/utils/retry.ts
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function calculateDelay(attempt, options) {
-  const { baseDelay, maxDelay, jitter } = options;
-  let delay = baseDelay * Math.pow(2, attempt);
-  delay = Math.min(delay, maxDelay);
-  if (jitter) {
-    const jitterAmount = delay * 0.25;
-    delay += Math.random() * jitterAmount * 2 - jitterAmount;
-  }
-  return Math.floor(delay);
-}
-async function withRetry(fn, options = {}) {
-  const {
-    maxAttempts = 3,
-    baseDelay = 500,
-    maxDelay = 1e4,
-    jitter = true,
-    retryOn = () => true
-  } = options;
-  let lastError;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (!retryOn(error)) {
-        throw error;
-      }
-      if (attempt < maxAttempts - 1) {
-        const delay = calculateDelay(attempt, {
-          baseDelay,
-          maxDelay,
-          jitter
-        });
-        await sleep(delay);
-      }
-    }
-  }
-  throw lastError;
-}
-function isRetryableRPCError(error) {
-  if (error instanceof Error) {
-    const message = error.message.toLowerCase();
-    if (message.includes("429") || message.includes("rate limit")) {
-      return true;
-    }
-    if (message.includes("timeout") || message.includes("econnreset")) {
-      return true;
-    }
-    if (message.includes("503") || message.includes("502") || message.includes("500")) {
-      return true;
-    }
-    if (message.includes("blockhash not found") || message.includes("slot skipped")) {
-      return true;
-    }
-  }
-  return false;
-}
+// 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) {
@@ -1198,172 +69,91 @@ function createPaymentFlow(config2) {
     /** 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}`;
-    }
-  };
-}
-function createPaymentReference() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
-}
-
-// 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;
+        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}`;
     }
-  }
-  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));
+function createPaymentReference() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
 }
-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)})`;
+var DEFAULT_COMPUTE_UNITS = 2e5;
+var DEFAULT_MICRO_LAMPORTS = 1e3;
+function createPriorityFeeInstructions(config2 = {}) {
+  const { enabled = false, microLamports, computeUnits } = config2;
+  if (!enabled) {
+    return [];
+  }
+  const instructions = [];
+  const units = computeUnits ?? DEFAULT_COMPUTE_UNITS;
+  instructions.push(web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units }));
+  const price = microLamports ?? DEFAULT_MICRO_LAMPORTS;
+  instructions.push(web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: price }));
+  return instructions;
 }
-function formatPriceSync(lamports, solPrice) {
-  const sol = Number(lamports) / 1e9;
-  const usd = sol * solPrice;
+async function buildVersionedTransaction(config2) {
+  const {
+    connection,
+    payer,
+    instructions,
+    priorityFee,
+    recentBlockhash
+  } = config2;
+  const priorityIxs = createPriorityFeeInstructions(priorityFee);
+  const allInstructions = [...priorityIxs, ...instructions];
+  let blockhash;
+  let lastValidBlockHeight;
+  if (recentBlockhash) {
+    blockhash = recentBlockhash;
+    const slot = await connection.getSlot();
+    lastValidBlockHeight = slot + 150;
+  } else {
+    const latestBlockhash = await connection.getLatestBlockhash("confirmed");
+    blockhash = latestBlockhash.blockhash;
+    lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
+  }
+  const message = new web3_js.TransactionMessage({
+    payerKey: payer,
+    recentBlockhash: blockhash,
+    instructions: allInstructions
+  }).compileToV0Message([]);
+  const transaction = new web3_js.VersionedTransaction(message);
   return {
-    sol,
-    usd,
-    formatted: `${sol.toFixed(4)} SOL (~$${usd.toFixed(2)})`
+    transaction,
+    blockhash,
+    lastValidBlockHeight
   };
 }
-function clearPriceCache() {
-  cachedPrice = null;
-  lastProviderIndex = -1;
-}
-function getProviders() {
-  return PROVIDERS.map((p) => ({ name: p.name, url: p.url }));
-}
-var WALLET_REGEX4 = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
-function isValidWalletAddress2(address) {
+
+// src/agent/agentPayment.ts
+var WALLET_REGEX = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+function isValidWalletAddress(address) {
   if (!address || typeof address !== "string") return false;
-  return WALLET_REGEX4.test(address);
+  return WALLET_REGEX.test(address);
 }
 async function executeAgentPayment(params) {
   const {
@@ -1374,7 +164,7 @@ async function executeAgentPayment(params) {
     priorityFee,
     confirmationTimeout = 6e4
   } = params;
-  if (!isValidWalletAddress2(recipientAddress)) {
+  if (!isValidWalletAddress(recipientAddress)) {
     return {
       success: false,
       error: "Invalid recipient address format"
@@ -1481,23 +271,23 @@ function generateAgentKeypair() {
   };
 }
 var MAX_CREDITS = 1e3;
-var MIN_SECRET_LENGTH2 = 32;
-function getSecretKey2(secret) {
+var MIN_SECRET_LENGTH = 32;
+function getSecretKey(secret) {
   if (!secret || typeof secret !== "string") {
     throw new Error("Session secret is required");
   }
-  if (secret.length < MIN_SECRET_LENGTH2) {
-    throw new Error(`Session secret must be at least ${MIN_SECRET_LENGTH2} characters`);
+  if (secret.length < MIN_SECRET_LENGTH) {
+    throw new Error(`Session secret must be at least ${MIN_SECRET_LENGTH} characters`);
   }
   return new TextEncoder().encode(secret);
 }
-function validateWalletAddress2(address) {
+function validateWalletAddress(address) {
   if (!address || typeof address !== "string") return false;
   const base58Regex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
   return base58Regex.test(address);
 }
 async function createCreditSession(walletAddress, purchaseId, config2) {
-  if (!validateWalletAddress2(walletAddress)) {
+  if (!validateWalletAddress(walletAddress)) {
     throw new Error("Invalid wallet address format");
   }
   if (config2.initialCredits <= 0 || config2.initialCredits > MAX_CREDITS) {
@@ -1532,7 +322,7 @@ async function createCreditSession(walletAddress, purchaseId, config2) {
     iat: now,
     exp: expiresAt
   };
-  const token = await new jose.SignJWT(payload).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(`${config2.durationHours}h`).sign(getSecretKey2(config2.secret));
+  const token = await new jose.SignJWT(payload).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(`${config2.durationHours}h`).sign(getSecretKey(config2.secret));
   return { token, session };
 }
 async function validateCreditSession(token, secret) {
@@ -1540,7 +330,7 @@ async function validateCreditSession(token, secret) {
     return { valid: false, reason: "Invalid token format" };
   }
   try {
-    const { payload } = await jose.jwtVerify(token, getSecretKey2(secret));
+    const { payload } = await jose.jwtVerify(token, getSecretKey(secret));
     const creditPayload = payload;
     if (!creditPayload.sub || !creditPayload.sid || !creditPayload.exp) {
       return { valid: false, reason: "Malformed session payload" };
@@ -1552,7 +342,7 @@ async function validateCreditSession(token, secret) {
     if (creditPayload.bundleExpiry && creditPayload.bundleExpiry < now) {
       return { valid: false, reason: "Bundle expired" };
     }
-    if (!validateWalletAddress2(creditPayload.sub)) {
+    if (!validateWalletAddress(creditPayload.sub)) {
       return { valid: false, reason: "Invalid session data" };
     }
     const session = {
@@ -1603,7 +393,7 @@ async function useCredit(token, secret, creditsToUse = 1) {
     iat: session.createdAt,
     exp: session.expiresAt
   };
-  const newToken = await new jose.SignJWT(payload).setProtectedHeader({ alg: "HS256" }).sign(getSecretKey2(secret));
+  const newToken = await new jose.SignJWT(payload).setProtectedHeader({ alg: "HS256" }).sign(getSecretKey(secret));
   return {
     success: true,
     remainingCredits: newCredits,
@@ -1631,7 +421,7 @@ async function addCredits(token, secret, creditsToAdd) {
     iat: session.createdAt,
     exp: session.expiresAt
   };
-  const newToken = await new jose.SignJWT(payload).setProtectedHeader({ alg: "HS256" }).sign(getSecretKey2(secret));
+  const newToken = await new jose.SignJWT(payload).setProtectedHeader({ alg: "HS256" }).sign(getSecretKey(secret));
   return {
     success: true,
     newToken,
@@ -1650,70 +440,180 @@ async function getRemainingCredits(token, secret) {
   };
 }
 
-exports.TOKEN_MINTS = TOKEN_MINTS;
-exports.X402_HEADERS = X402_HEADERS;
-exports.addArticleToSession = addArticleToSession;
+// 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 }));
+}
+
 exports.addCredits = addCredits;
-exports.buildPaymentRequirement = buildPaymentRequirement;
 exports.buildSolanaPayUrl = buildSolanaPayUrl;
-exports.buildVersionedTransaction = buildVersionedTransaction;
-exports.calculatePriorityFeeCost = calculatePriorityFeeCost;
-exports.checkPaywallAccess = checkPaywallAccess;
 exports.clearPriceCache = clearPriceCache;
 exports.configurePricing = configurePricing;
-exports.create402Headers = create402Headers;
-exports.create402Response = create402Response;
-exports.create402ResponseBody = create402ResponseBody;
 exports.createCreditSession = createCreditSession;
-exports.createMemoryStore = createMemoryStore;
 exports.createPaymentFlow = createPaymentFlow;
 exports.createPaymentReference = createPaymentReference;
-exports.createPaywallMiddleware = createPaywallMiddleware;
-exports.createPriorityFeeInstructions = createPriorityFeeInstructions;
-exports.createRedisStore = createRedisStore;
-exports.createSession = createSession;
-exports.decodePaymentRequired = decodePaymentRequired;
-exports.encodePaymentRequired = encodePaymentRequired;
-exports.encodePaymentRequirement = encodePaymentRequirement;
-exports.encodePaymentResponse = encodePaymentResponse;
-exports.estimatePriorityFee = estimatePriorityFee;
 exports.executeAgentPayment = executeAgentPayment;
-exports.fetchLookupTables = fetchLookupTables;
 exports.formatPriceDisplay = formatPriceDisplay;
 exports.formatPriceSync = formatPriceSync;
 exports.generateAgentKeypair = generateAgentKeypair;
 exports.getAgentBalance = getAgentBalance;
-exports.getConnection = getConnection;
-exports.getConnectionWithFallback = getConnectionWithFallback;
 exports.getProviders = getProviders;
 exports.getRemainingCredits = getRemainingCredits;
 exports.getSolPrice = getSolPrice;
-exports.getTokenDecimals = getTokenDecimals;
-exports.getWalletTransactions = getWalletTransactions;
 exports.hasAgentSufficientBalance = hasAgentSufficientBalance;
-exports.isArticleUnlocked = isArticleUnlocked;
-exports.isMainnet = isMainnet;
-exports.isNativeAsset = isNativeAsset;
-exports.isRetryableRPCError = isRetryableRPCError;
-exports.isVersionedTransaction = isVersionedTransaction;
 exports.keypairFromBase58 = keypairFromBase58;
-exports.lamportsToSol = lamportsToSol;
 exports.lamportsToUsd = lamportsToUsd;
-exports.parsePaymentHeader = parsePaymentHeader;
-exports.resetConnection = resetConnection;
-exports.resolveMintAddress = resolveMintAddress;
-exports.solToLamports = solToLamports;
-exports.toX402Network = toX402Network;
 exports.usdToLamports = usdToLamports;
 exports.useCredit = useCredit;
 exports.validateCreditSession = validateCreditSession;
-exports.validateSession = validateSession;
-exports.verifyPayment = verifyPayment;
-exports.verifySPLPayment = verifySPLPayment;
-exports.verifyX402Payment = verifyX402Payment;
-exports.waitForConfirmation = waitForConfirmation;
-exports.withFallback = withFallback;
-exports.withPaywall = withPaywall;
-exports.withRetry = withRetry;
+Object.keys(core).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return core[k]; }
+  });
+});
+Object.keys(types).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return types[k]; }
+  });
+});
+Object.keys(client).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return client[k]; }
+  });
+});
+Object.keys(svm).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return svm[k]; }
+  });
+});
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map