@alleyboss/micropay-solana-x402-paywall 2.3.0 → 3.0.0

package/dist/index.js

@@ -1,8 +1,14 @@
-import { PublicKey, LAMPORTS_PER_SOL, ComputeBudgetProgram, TransactionMessage, VersionedTransaction, clusterApiUrl, Connection } from '@solana/web3.js';
+export * from '@x402/core';
+export * from '@x402/core/types';
+export * from '@x402/core/client';
+export * from '@x402/svm';
+import { PublicKey, SystemProgram, LAMPORTS_PER_SOL, Keypair, TransactionMessage, VersionedTransaction, ComputeBudgetProgram } from '@solana/web3.js';
 import { SignJWT, jwtVerify } from 'jose';
 import { v4 } from 'uuid';
 
-// src/types/payment.ts
+// src/index.ts
+
+// src/client/types.ts
 var TOKEN_MINTS = {
   /** USDC on mainnet */
   USDC_MAINNET: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
@@ -11,471 +17,87 @@ var TOKEN_MINTS = {
   /** 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 clusterApiUrl(network);
-}
-function createConnection(rpcUrl) {
-  return new 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" };
+
+// 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());
   }
-  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" };
+  if (splToken) {
+    url.searchParams.set("spl-token", splToken);
   }
-}
-async function getWalletTransactions(walletAddress, clientConfig, limit = 20) {
-  if (!isValidWalletAddress(walletAddress)) {
-    return [];
+  if (reference) {
+    url.searchParams.set("reference", reference);
   }
-  const safeLimit = Math.min(Math.max(limit, 1), 100);
-  const connection = getConnection(clientConfig);
-  try {
-    const pubkey = new 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 [];
+  if (label) {
+    url.searchParams.set("label", label);
   }
-}
-function lamportsToSol(lamports) {
-  return Number(lamports) / LAMPORTS_PER_SOL;
-}
-function solToLamports(sol) {
-  if (!Number.isFinite(sol) || sol < 0) {
-    throw new Error("Invalid SOL amount");
+  if (message) {
+    url.searchParams.set("message", message);
   }
-  return BigInt(Math.floor(sol * LAMPORTS_PER_SOL));
+  return url.toString();
 }
-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;
+function createPaymentFlow(config2) {
+  const { network, recipientWallet, amount, asset = "native", memo } = config2;
+  let decimals = 9;
+  let mintAddress;
   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
-              };
-            }
-          }
-        }
-      }
-    }
+    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;
   }
-  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
-          };
-        }
-      }
+  const naturalAmount = Number(amount) / Math.pow(10, decimals);
+  return {
+    /** Get the payment configuration */
+    getConfig: () => ({ ...config2 }),
+    /** 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}`;
     }
-  }
-  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 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 createPaymentReference() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
   }
-}
-function isNativeAsset(asset) {
-  return asset === "native";
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
 }
 var DEFAULT_COMPUTE_UNITS = 2e5;
 var DEFAULT_MICRO_LAMPORTS = 1e3;
@@ -491,33 +113,11 @@ function createPriorityFeeInstructions(config2 = {}) {
   instructions.push(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;
@@ -538,7 +138,7 @@ async function buildVersionedTransaction(config2) {
     payerKey: payer,
     recentBlockhash: blockhash,
     instructions: allInstructions
-  }).compileToV0Message(lookupTables);
+  }).compileToV0Message([]);
   const transaction = new VersionedTransaction(message);
   return {
     transaction,
@@ -546,20 +146,129 @@ async function buildVersionedTransaction(config2) {
     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);
+
+// 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_REGEX.test(address);
+}
+async function executeAgentPayment(params) {
+  const {
+    connection,
+    agentKeypair,
+    recipientAddress,
+    amountLamports,
+    priorityFee,
+    confirmationTimeout = 6e4
+  } = params;
+  if (!isValidWalletAddress(recipientAddress)) {
+    return {
+      success: false,
+      error: "Invalid recipient address format"
+    };
+  }
+  if (amountLamports <= 0n) {
+    return {
+      success: false,
+      error: "Amount must be greater than 0"
+    };
+  }
+  try {
+    const recipientPubkey = new PublicKey(recipientAddress);
+    const transferInstruction = SystemProgram.transfer({
+      fromPubkey: agentKeypair.publicKey,
+      toPubkey: recipientPubkey,
+      lamports: amountLamports
+    });
+    const { transaction, lastValidBlockHeight } = await buildVersionedTransaction({
+      connection,
+      payer: agentKeypair.publicKey,
+      instructions: [transferInstruction],
+      priorityFee
+    });
+    transaction.sign([agentKeypair]);
+    const signature = await connection.sendTransaction(transaction, {
+      maxRetries: 3,
+      skipPreflight: false
+    });
+    const confirmationPromise = connection.confirmTransaction(
+      {
+        signature,
+        lastValidBlockHeight,
+        blockhash: transaction.message.recentBlockhash
+      },
+      "confirmed"
+    );
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("Confirmation timeout")), confirmationTimeout);
+    });
+    const confirmation = await Promise.race([confirmationPromise, timeoutPromise]);
+    if (confirmation.value.err) {
+      return {
+        success: false,
+        signature,
+        error: "Transaction failed on-chain"
+      };
+    }
+    const txDetails = await connection.getTransaction(signature, {
+      commitment: "confirmed",
+      maxSupportedTransactionVersion: 0
+    });
+    return {
+      success: true,
+      signature,
+      confirmedAt: txDetails?.blockTime ?? Math.floor(Date.now() / 1e3),
+      slot: txDetails?.slot ?? confirmation.context.slot,
+      amountLamports,
+      amountSol: Number(amountLamports) / LAMPORTS_PER_SOL
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return {
+      success: false,
+      error: errorMessage
+    };
+  }
+}
+async function getAgentBalance(connection, agentKeypair) {
+  const balance = await connection.getBalance(agentKeypair.publicKey);
+  return {
+    balance: BigInt(balance),
+    balanceSol: balance / LAMPORTS_PER_SOL
+  };
+}
+async function hasAgentSufficientBalance(connection, agentKeypair, requiredLamports) {
+  const { balance } = await getAgentBalance(connection, agentKeypair);
+  const totalRequired = requiredLamports + 10000n;
+  return {
+    sufficient: balance >= totalRequired,
+    balance,
+    required: totalRequired
+  };
+}
+function keypairFromBase58(base58Secret) {
+  const bytes = Buffer.from(base58Secret, "base64");
+  if (bytes.length !== 64) {
+    const parts = base58Secret.split(",").map((n) => parseInt(n.trim(), 10));
+    if (parts.length === 64) {
+      return Keypair.fromSecretKey(Uint8Array.from(parts));
     }
+    throw new Error("Invalid secret key format. Expected base58 string or comma-separated bytes.");
   }
-  return tables;
+  return Keypair.fromSecretKey(bytes);
 }
-function isVersionedTransaction(tx) {
-  return tx instanceof VersionedTransaction;
+function generateAgentKeypair() {
+  const keypair = Keypair.generate();
+  const secretBytes = Array.from(keypair.secretKey);
+  return {
+    keypair,
+    secretBase58: secretBytes.join(","),
+    // Comma-separated for easy storage
+    publicKey: keypair.publicKey.toBase58()
+  };
 }
-var MAX_ARTICLES_PER_SESSION = 100;
+var MAX_CREDITS = 1e3;
 var MIN_SECRET_LENGTH = 32;
 function getSecretKey(secret) {
   if (!secret || typeof secret !== "string") {
@@ -575,659 +284,159 @@ function validateWalletAddress(address) {
   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) {
+async function createCreditSession(walletAddress, purchaseId, config2) {
   if (!validateWalletAddress(walletAddress)) {
     throw new Error("Invalid wallet address format");
   }
-  if (!validateArticleId(articleId)) {
-    throw new Error("Invalid article ID format");
+  if (config2.initialCredits <= 0 || config2.initialCredits > MAX_CREDITS) {
+    throw new Error(`Credits must be between 1 and ${MAX_CREDITS}`);
   }
-  if (!config2.durationHours || config2.durationHours <= 0 || config2.durationHours > 720) {
-    throw new Error("Session duration must be between 1 and 720 hours");
+  if (!config2.durationHours || config2.durationHours <= 0 || config2.durationHours > 8760) {
+    throw new Error("Session duration must be between 1 and 8760 hours (1 year)");
   }
   const sessionId = v4();
   const now = Math.floor(Date.now() / 1e3);
   const expiresAt = now + config2.durationHours * 3600;
+  const bundleExpiry = config2.bundleExpiryHours ? now + config2.bundleExpiryHours * 3600 : expiresAt;
   const session = {
     id: sessionId,
     walletAddress,
-    unlockedArticles: [articleId],
-    siteWideUnlock: Boolean(siteWide),
+    unlockedArticles: [purchaseId],
+    siteWideUnlock: false,
     createdAt: now,
-    expiresAt
+    expiresAt,
+    credits: config2.initialCredits,
+    bundleExpiry,
+    bundleType: config2.bundleType
   };
   const payload = {
     sub: walletAddress,
     sid: sessionId,
     articles: session.unlockedArticles,
-    siteWide: session.siteWideUnlock,
+    siteWide: false,
+    credits: config2.initialCredits,
+    bundleExpiry,
+    bundleType: config2.bundleType,
     iat: now,
     exp: expiresAt
   };
   const token = await new SignJWT(payload).setProtectedHeader({ alg: "HS256" }).setIssuedAt().setExpirationTime(`${config2.durationHours}h`).sign(getSecretKey(config2.secret));
   return { token, session };
 }
-async function validateSession(token, secret) {
+async function validateCreditSession(token, secret) {
   if (!token || typeof token !== "string") {
     return { valid: false, reason: "Invalid token format" };
   }
   try {
     const { payload } = await jwtVerify(token, getSecretKey(secret));
-    const sessionPayload = payload;
-    if (!sessionPayload.sub || !sessionPayload.sid || !sessionPayload.exp) {
+    const creditPayload = payload;
+    if (!creditPayload.sub || !creditPayload.sid || !creditPayload.exp) {
       return { valid: false, reason: "Malformed session payload" };
     }
     const now = Math.floor(Date.now() / 1e3);
-    if (sessionPayload.exp < now) {
+    if (creditPayload.exp < now) {
       return { valid: false, reason: "Session expired" };
     }
-    if (!validateWalletAddress(sessionPayload.sub)) {
+    if (creditPayload.bundleExpiry && creditPayload.bundleExpiry < now) {
+      return { valid: false, reason: "Bundle expired" };
+    }
+    if (!validateWalletAddress(creditPayload.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
+      id: creditPayload.sid,
+      walletAddress: creditPayload.sub,
+      unlockedArticles: Array.isArray(creditPayload.articles) ? creditPayload.articles : [],
+      siteWideUnlock: Boolean(creditPayload.siteWide),
+      createdAt: creditPayload.iat ?? 0,
+      expiresAt: creditPayload.exp,
+      credits: creditPayload.credits ?? 0,
+      bundleExpiry: creditPayload.bundleExpiry,
+      bundleType: creditPayload.bundleType
     };
     return { valid: true, session };
-  } catch (error) {
+  } catch {
     return { valid: false, reason: "Invalid session" };
   }
 }
-async function addArticleToSession(token, articleId, secret) {
-  if (!validateArticleId(articleId)) {
-    return null;
+async function useCredit(token, secret, creditsToUse = 1) {
+  if (creditsToUse <= 0) {
+    return { success: false, remainingCredits: 0, error: "Invalid credit amount" };
   }
-  const validation = await validateSession(token, secret);
+  const validation = await validateCreditSession(token, secret);
   if (!validation.valid || !validation.session) {
-    return null;
+    return {
+      success: false,
+      remainingCredits: 0,
+      error: validation.reason || "Invalid session"
+    };
   }
   const session = validation.session;
-  if (session.unlockedArticles.includes(articleId)) {
-    return { token, session };
-  }
-  if (session.unlockedArticles.length >= MAX_ARTICLES_PER_SESSION) {
-    return null;
+  if (session.credits < creditsToUse) {
+    return {
+      success: false,
+      remainingCredits: session.credits,
+      error: "Insufficient credits"
+    };
   }
-  const updatedArticles = [...session.unlockedArticles, articleId];
+  const newCredits = session.credits - creditsToUse;
   const payload = {
     sub: session.walletAddress,
     sid: session.id,
-    articles: updatedArticles,
+    articles: session.unlockedArticles,
     siteWide: session.siteWideUnlock,
+    credits: newCredits,
+    bundleExpiry: session.bundleExpiry,
+    bundleType: session.bundleType,
     iat: session.createdAt,
     exp: session.expiresAt
   };
   const newToken = await new SignJWT(payload).setProtectedHeader({ alg: "HS256" }).sign(getSecretKey(secret));
   return {
-    token: newToken,
-    session: { ...session, unlockedArticles: updatedArticles }
+    success: true,
+    remainingCredits: newCredits,
+    newToken
   };
 }
-async function isArticleUnlocked(token, articleId, secret) {
-  if (!validateArticleId(articleId)) {
-    return false;
+async function addCredits(token, secret, creditsToAdd) {
+  if (creditsToAdd <= 0 || creditsToAdd > MAX_CREDITS) {
+    return { success: false, error: "Invalid credit amount" };
   }
-  const validation = await validateSession(token, secret);
+  const validation = await validateCreditSession(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" };
+    return { success: false, error: validation.reason || "Invalid session" };
   }
-  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();
-    }
+  const session = validation.session;
+  const newCredits = Math.min(session.credits + creditsToAdd, MAX_CREDITS);
+  const payload = {
+    sub: session.walletAddress,
+    sid: session.id,
+    articles: session.unlockedArticles,
+    siteWide: session.siteWideUnlock,
+    credits: newCredits,
+    bundleExpiry: session.bundleExpiry,
+    bundleType: session.bundleType,
+    iat: session.createdAt,
+    exp: session.expiresAt
   };
-}
-
-// src/store/redis.ts
-function createRedisStore(options) {
-  const { client, keyPrefix = "micropay:sig:" } = options;
-  const buildKey = (signature) => `${keyPrefix}${signature}`;
+  const newToken = await new SignJWT(payload).setProtectedHeader({ alg: "HS256" }).sign(getSecretKey(secret));
   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;
-      }
-    }
+    success: true,
+    newToken,
+    totalCredits: newCredits
   };
 }
-
-// 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);
+async function getRemainingCredits(token, secret) {
+  const validation = await validateCreditSession(token, secret);
   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/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/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 { credits: 0, valid: false };
   }
-  return url.toString();
-}
-function createPaymentFlow(config2) {
-  const { network, recipientWallet, amount, asset = "native", memo } = config2;
-  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: () => ({ ...config2 }),
-    /** 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}`;
-    }
+    credits: validation.session.credits,
+    valid: true,
+    bundleExpiry: validation.session.bundleExpiry
   };
 }
-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;
@@ -1359,6 +568,6 @@ function getProviders() {
   return PROVIDERS.map((p) => ({ name: p.name, url: p.url }));
 }
 
-export { TOKEN_MINTS, X402_HEADERS, addArticleToSession, buildPaymentRequirement, buildSolanaPayUrl, buildVersionedTransaction, calculatePriorityFeeCost, checkPaywallAccess, clearPriceCache, configurePricing, create402Headers, create402Response, create402ResponseBody, createMemoryStore, createPaymentFlow, createPaymentReference, createPaywallMiddleware, createPriorityFeeInstructions, createRedisStore, createSession, decodePaymentRequired, encodePaymentRequired, encodePaymentRequirement, encodePaymentResponse, estimatePriorityFee, fetchLookupTables, formatPriceDisplay, formatPriceSync, getConnection, getConnectionWithFallback, getProviders, getSolPrice, getTokenDecimals, getWalletTransactions, isArticleUnlocked, isMainnet, isNativeAsset, isRetryableRPCError, isVersionedTransaction, lamportsToSol, lamportsToUsd, parsePaymentHeader, resetConnection, resolveMintAddress, solToLamports, toX402Network, usdToLamports, validateSession, verifyPayment, verifySPLPayment, verifyX402Payment, waitForConfirmation, withFallback, withPaywall, withRetry };
+export { addCredits, buildSolanaPayUrl, clearPriceCache, configurePricing, createCreditSession, createPaymentFlow, createPaymentReference, executeAgentPayment, formatPriceDisplay, formatPriceSync, generateAgentKeypair, getAgentBalance, getProviders, getRemainingCredits, getSolPrice, hasAgentSufficientBalance, keypairFromBase58, lamportsToUsd, usdToLamports, useCredit, validateCreditSession };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map