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

package/dist/solana/index.cjs

@@ -1,589 +0,0 @@
-'use strict';
-
-var web3_js = require('@solana/web3.js');
-
-// src/solana/client.ts
-var cachedConnection = null;
-var cachedNetwork = null;
-var cachedFallbacks = [];
-var cachedFallbackEnabled = false;
-function buildRpcUrl(config) {
-  const { network, rpcUrl, tatumApiKey } = config;
-  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(config) {
-  const { network } = config;
-  if (cachedConnection && cachedNetwork === network) {
-    return cachedConnection;
-  }
-  const rpcUrl = buildRpcUrl(config);
-  cachedConnection = createConnection(rpcUrl);
-  cachedNetwork = network;
-  cachedFallbackEnabled = config.enableFallback ?? false;
-  cachedFallbacks = [];
-  if (cachedFallbackEnabled && config.fallbackRpcUrls?.length) {
-    cachedFallbacks = config.fallbackRpcUrls.map(createConnection);
-  }
-  return cachedConnection;
-}
-function getConnectionWithFallback(config) {
-  const connection = getConnection(config);
-  return {
-    connection,
-    fallbacks: cachedFallbacks,
-    fallbackEnabled: cachedFallbackEnabled
-  };
-}
-async function withFallback(config, operation) {
-  const { connection, fallbacks, fallbackEnabled } = getConnectionWithFallback(config);
-  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));
-}
-
-// 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"
-};
-
-// src/solana/spl.ts
-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(config = {}) {
-  const { enabled = false, microLamports, computeUnits } = config;
-  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(config) {
-  const {
-    connection,
-    payer,
-    instructions,
-    lookupTables = [],
-    priorityFee,
-    recentBlockhash
-  } = config;
-  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;
-}
-
-exports.buildVersionedTransaction = buildVersionedTransaction;
-exports.calculatePriorityFeeCost = calculatePriorityFeeCost;
-exports.createPriorityFeeInstructions = createPriorityFeeInstructions;
-exports.estimatePriorityFee = estimatePriorityFee;
-exports.fetchLookupTables = fetchLookupTables;
-exports.getConnection = getConnection;
-exports.getConnectionWithFallback = getConnectionWithFallback;
-exports.getTokenDecimals = getTokenDecimals;
-exports.getWalletTransactions = getWalletTransactions;
-exports.isMainnet = isMainnet;
-exports.isNativeAsset = isNativeAsset;
-exports.isVersionedTransaction = isVersionedTransaction;
-exports.lamportsToSol = lamportsToSol;
-exports.resetConnection = resetConnection;
-exports.resolveMintAddress = resolveMintAddress;
-exports.solToLamports = solToLamports;
-exports.toX402Network = toX402Network;
-exports.verifyPayment = verifyPayment;
-exports.verifySPLPayment = verifySPLPayment;
-exports.waitForConfirmation = waitForConfirmation;
-exports.withFallback = withFallback;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map