@t402/cli 2.0.0

package/dist/esm/chunk-2A2UCRTK.js

@@ -0,0 +1,952 @@
+#!/usr/bin/env node
+
+// src/types.ts
+var DEFAULT_CONFIG = {
+  defaultNetwork: "eip155:8453",
+  facilitatorUrl: "https://facilitator.t402.io",
+  testnet: false,
+  rpcEndpoints: {}
+};
+var NETWORKS = [
+  // EVM Mainnets
+  { id: "eip155:1", name: "Ethereum", type: "evm", testnet: false, assets: ["usdt", "usdt0"] },
+  { id: "eip155:42161", name: "Arbitrum", type: "evm", testnet: false, assets: ["usdt0"] },
+  { id: "eip155:8453", name: "Base", type: "evm", testnet: false, assets: ["usdt0"] },
+  { id: "eip155:10", name: "Optimism", type: "evm", testnet: false, assets: ["usdt0"] },
+  { id: "eip155:57073", name: "Ink", type: "evm", testnet: false, assets: ["usdt0"] },
+  { id: "eip155:80094", name: "Berachain", type: "evm", testnet: false, assets: ["usdt0"] },
+  // EVM Testnets
+  { id: "eip155:11155111", name: "Sepolia", type: "evm", testnet: true, assets: ["usdt0"] },
+  { id: "eip155:421614", name: "Arbitrum Sepolia", type: "evm", testnet: true, assets: ["usdt0"] },
+  { id: "eip155:84532", name: "Base Sepolia", type: "evm", testnet: true, assets: ["usdt0"] },
+  // Solana
+  {
+    id: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+    name: "Solana",
+    type: "solana",
+    testnet: false,
+    assets: ["usdt"]
+  },
+  {
+    id: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+    name: "Solana Devnet",
+    type: "solana",
+    testnet: true,
+    assets: ["usdt"]
+  },
+  // TON
+  { id: "ton:-239", name: "TON", type: "ton", testnet: false, assets: ["usdt"] },
+  { id: "ton:-3", name: "TON Testnet", type: "ton", testnet: true, assets: ["usdt"] },
+  // TRON
+  { id: "tron:mainnet", name: "TRON", type: "tron", testnet: false, assets: ["usdt"] },
+  { id: "tron:nile", name: "TRON Nile", type: "tron", testnet: true, assets: ["usdt"] }
+];
+
+// src/config/index.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: "t402",
+  defaults: DEFAULT_CONFIG
+});
+function getConfig(key) {
+  return config.get(key);
+}
+function setConfig(key, value) {
+  config.set(key, value);
+}
+function getAllConfig() {
+  return config.store;
+}
+function resetConfig() {
+  config.clear();
+}
+function getConfigPath() {
+  return config.path;
+}
+function hasSeedConfigured() {
+  return !!config.get("encryptedSeed");
+}
+function storeSeed(encryptedSeed) {
+  config.set("encryptedSeed", encryptedSeed);
+}
+function getEncryptedSeed() {
+  return config.get("encryptedSeed");
+}
+function clearSeed() {
+  config.delete("encryptedSeed");
+}
+function setRpcEndpoint(network, url) {
+  const endpoints = config.get("rpcEndpoints");
+  config.set("rpcEndpoints", { ...endpoints, [network]: url });
+}
+function getRpcEndpoint(network) {
+  return config.get("rpcEndpoints")[network];
+}
+
+// src/utils/index.ts
+import chalk from "chalk";
+import ora from "ora";
+function createSpinner(text) {
+  return ora({
+    text,
+    color: "cyan"
+  });
+}
+function formatAddress(address, startChars = 6, endChars = 4) {
+  if (address.length <= startChars + endChars + 3) {
+    return address;
+  }
+  return `${address.slice(0, startChars)}...${address.slice(-endChars)}`;
+}
+function formatAmount(amount, decimals = 6) {
+  const value = BigInt(amount);
+  const divisor = BigInt(10 ** decimals);
+  const whole = value / divisor;
+  const fraction = value % divisor;
+  if (fraction === 0n) {
+    return whole.toString();
+  }
+  const fractionStr = fraction.toString().padStart(decimals, "0").replace(/0+$/, "");
+  return `${whole}.${fractionStr}`;
+}
+function formatBalanceResult(result) {
+  const network = getNetworkInfo(result.network);
+  const networkName = network?.name || result.network;
+  const assetName = result.asset.toUpperCase();
+  return `${chalk.bold(networkName)}: ${chalk.green(result.formatted)} ${assetName}`;
+}
+function formatPaymentResult(result) {
+  if (result.success) {
+    const lines = [chalk.green("\u2713 Payment successful!")];
+    if (result.txHash) {
+      lines.push(`  Transaction: ${chalk.cyan(result.txHash)}`);
+    }
+    if (result.network) {
+      const network = getNetworkInfo(result.network);
+      lines.push(`  Network: ${network?.name || result.network}`);
+    }
+    if (result.amount) {
+      lines.push(`  Amount: ${result.amount}`);
+    }
+    return lines.join("\n");
+  } else {
+    return chalk.red(`\u2717 Payment failed: ${result.error || "Unknown error"}`);
+  }
+}
+function getNetworkInfo(networkId) {
+  return NETWORKS.find((n) => n.id === networkId);
+}
+function getNetworkName(networkId) {
+  const network = getNetworkInfo(networkId);
+  return network?.name || networkId;
+}
+function getAvailableNetworks(testnet) {
+  return NETWORKS.filter((n) => n.testnet === testnet);
+}
+function printTable(data) {
+  const maxKeyLength = Math.max(...Object.keys(data).map((k) => k.length));
+  for (const [key, value] of Object.entries(data)) {
+    const paddedKey = key.padEnd(maxKeyLength);
+    console.log(`  ${chalk.gray(paddedKey)}  ${value}`);
+  }
+}
+function printSuccess(message) {
+  console.log(chalk.green(`\u2713 ${message}`));
+}
+function printError(message) {
+  console.error(chalk.red(`\u2717 ${message}`));
+}
+function printWarning(message) {
+  console.log(chalk.yellow(`\u26A0 ${message}`));
+}
+function printInfo(message) {
+  console.log(chalk.cyan(`\u2139 ${message}`));
+}
+function printHeader(title) {
+  console.log();
+  console.log(chalk.bold.underline(title));
+  console.log();
+}
+function isValidSeedPhrase(phrase) {
+  const words = phrase.trim().split(/\s+/);
+  return words.length === 12 || words.length === 24;
+}
+function encryptSeed(seed, key) {
+  const seedBytes = Buffer.from(seed, "utf8");
+  const keyBytes = Buffer.from(key, "utf8");
+  const encrypted = Buffer.alloc(seedBytes.length);
+  for (let i = 0; i < seedBytes.length; i++) {
+    encrypted[i] = seedBytes[i] ^ keyBytes[i % keyBytes.length];
+  }
+  return encrypted.toString("base64");
+}
+function decryptSeed(encrypted, key) {
+  const encryptedBytes = Buffer.from(encrypted, "base64");
+  const keyBytes = Buffer.from(key, "utf8");
+  const decrypted = Buffer.alloc(encryptedBytes.length);
+  for (let i = 0; i < encryptedBytes.length; i++) {
+    decrypted[i] = encryptedBytes[i] ^ keyBytes[i % keyBytes.length];
+  }
+  return decrypted.toString("utf8");
+}
+function parseAmount(amount, decimals = 6) {
+  const parts = amount.split(".");
+  const whole = parts[0] || "0";
+  const fraction = (parts[1] || "").padEnd(decimals, "0").slice(0, decimals);
+  return (BigInt(whole) * BigInt(10 ** decimals) + BigInt(fraction)).toString();
+}
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/wallet.ts
+import chalk2 from "chalk";
+var MACHINE_KEY = `t402-cli-${process.env.USER || "default"}`;
+function registerWalletCommands(program) {
+  const wallet = program.command("wallet").description("Wallet management commands");
+  wallet.command("create").description("Create a new wallet with a generated seed phrase").action(async () => {
+    if (hasSeedConfigured()) {
+      printWarning("A wallet is already configured. Use 'wallet clear' first to remove it.");
+      return;
+    }
+    try {
+      const { generateMnemonic, english } = await import("viem/accounts");
+      const spinner = createSpinner("Generating seed phrase...").start();
+      const mnemonic = generateMnemonic(english);
+      spinner.succeed("Seed phrase generated");
+      console.log();
+      console.log(chalk2.yellow("\u26A0  IMPORTANT: Write down these words and store them safely!"));
+      console.log(chalk2.yellow("   This is the ONLY way to recover your wallet."));
+      console.log();
+      console.log(chalk2.bold("Seed phrase:"));
+      console.log();
+      console.log(`  ${chalk2.cyan(mnemonic)}`);
+      console.log();
+      const encrypted = encryptSeed(mnemonic, MACHINE_KEY);
+      storeSeed(encrypted);
+      printSuccess("Wallet created and saved to config");
+      console.log();
+      console.log("Run 'wallet show' to see your addresses.");
+    } catch (error) {
+      printError(`Failed to create wallet: ${error instanceof Error ? error.message : error}`);
+    }
+  });
+  wallet.command("import").description("Import an existing wallet from a seed phrase").argument("<seed-phrase>", "12 or 24 word seed phrase (in quotes)").action(async (seedPhrase) => {
+    if (hasSeedConfigured()) {
+      printWarning("A wallet is already configured. Use 'wallet clear' first to remove it.");
+      return;
+    }
+    const phrase = seedPhrase.trim();
+    if (!isValidSeedPhrase(phrase)) {
+      printError("Invalid seed phrase. Must be 12 or 24 words.");
+      return;
+    }
+    try {
+      const { mnemonicToAccount } = await import("viem/accounts");
+      mnemonicToAccount(phrase);
+      const encrypted = encryptSeed(phrase, MACHINE_KEY);
+      storeSeed(encrypted);
+      printSuccess("Wallet imported successfully");
+      console.log();
+      console.log("Run 'wallet show' to see your addresses.");
+    } catch (error) {
+      printError(`Failed to import wallet: ${error instanceof Error ? error.message : error}`);
+    }
+  });
+  wallet.command("show").description("Show wallet addresses").action(async () => {
+    const encrypted = getEncryptedSeed();
+    if (!encrypted) {
+      printError("No wallet configured. Run 'wallet create' or 'wallet import' first.");
+      return;
+    }
+    try {
+      const seedPhrase = decryptSeed(encrypted, MACHINE_KEY);
+      const { mnemonicToAccount } = await import("viem/accounts");
+      const spinner = createSpinner("Loading wallet...").start();
+      const account = mnemonicToAccount(seedPhrase);
+      spinner.succeed("Wallet loaded");
+      printHeader("Wallet Addresses");
+      const addresses = {
+        "EVM (Ethereum, Arbitrum, Base, etc.)": account.address
+      };
+      printTable(addresses);
+      console.log();
+      console.log(chalk2.gray("Note: Install @t402/wdk for full multi-chain support"));
+    } catch (error) {
+      printError(`Failed to load wallet: ${error instanceof Error ? error.message : error}`);
+    }
+  });
+  wallet.command("balance").description("Check wallet balances").option("-n, --network <network>", "Specific network to check (e.g., eip155:8453)").option("-a, --all", "Show all networks including zero balances").action(async (options) => {
+    const encrypted = getEncryptedSeed();
+    if (!encrypted) {
+      printError("No wallet configured. Run 'wallet create' or 'wallet import' first.");
+      return;
+    }
+    try {
+      const seedPhrase = decryptSeed(encrypted, MACHINE_KEY);
+      const wdkModule = await import("@t402/wdk");
+      const { T402WDK } = wdkModule;
+      const spinner = createSpinner("Fetching balances...").start();
+      const testnet = getConfig("testnet");
+      const chainConfig = testnet ? {
+        "arbitrum-sepolia": "https://sepolia-rollup.arbitrum.io/rpc",
+        "base-sepolia": "https://sepolia.base.org"
+      } : {
+        arbitrum: "https://arb1.arbitrum.io/rpc",
+        base: "https://mainnet.base.org"
+      };
+      const wdk = new T402WDK(seedPhrase, chainConfig);
+      if (options.network) {
+        const chainName = options.network.replace("eip155:", "").replace("8453", "base").replace("42161", "arbitrum");
+        spinner.text = `Fetching balance for ${getNetworkName(options.network)}...`;
+        const balance = await wdk.getUsdt0Balance(chainName);
+        spinner.succeed("Balance fetched");
+        printHeader(`Balance on ${getNetworkName(options.network)}`);
+        console.log(`  ${chalk2.green(formatAmount(balance.toString()))} USDT0`);
+      } else {
+        const balances = await wdk.getAggregatedBalances();
+        spinner.succeed("Balances fetched");
+        printHeader("Wallet Balances");
+        console.log(`  Total USDT0: ${chalk2.green(formatAmount(balances.totalUsdt0.toString()))}`);
+        if (balances.chains.length > 0) {
+          console.log();
+          for (const chain of balances.chains) {
+            const usdt0 = chain.tokens.find((t) => t.symbol === "USDT0");
+            if (usdt0 && (options.all || usdt0.balance > 0n)) {
+              const color = usdt0.balance > 0n ? chalk2.green : chalk2.gray;
+              console.log(`  ${chain.chain.padEnd(20)} ${color(formatAmount(usdt0.balance.toString()))} USDT0`);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      printError(`Failed to fetch balances: ${error instanceof Error ? error.message : error}`);
+    }
+  });
+  wallet.command("clear").description("Remove wallet from this device").option("-f, --force", "Skip confirmation").action(async (options) => {
+    if (!hasSeedConfigured()) {
+      printWarning("No wallet configured.");
+      return;
+    }
+    if (!options.force) {
+      console.log(chalk2.yellow("\u26A0  WARNING: This will remove your wallet from this device."));
+      console.log(chalk2.yellow("   Make sure you have your seed phrase backed up!"));
+      console.log();
+      console.log("Run with --force to confirm.");
+      return;
+    }
+    clearSeed();
+    printSuccess("Wallet removed from this device");
+  });
+  wallet.command("export").description("Export seed phrase (use with caution!)").option("-f, --force", "Skip warning").action(async (options) => {
+    const encrypted = getEncryptedSeed();
+    if (!encrypted) {
+      printError("No wallet configured.");
+      return;
+    }
+    if (!options.force) {
+      console.log(chalk2.red("\u26A0  DANGER: This will display your seed phrase on screen!"));
+      console.log(chalk2.red("   Anyone who sees this can steal your funds."));
+      console.log();
+      console.log("Run with --force to proceed.");
+      return;
+    }
+    const seedPhrase = decryptSeed(encrypted, MACHINE_KEY);
+    console.log();
+    console.log(chalk2.bold("Seed phrase:"));
+    console.log();
+    console.log(`  ${chalk2.cyan(seedPhrase)}`);
+    console.log();
+  });
+}
+
+// src/commands/pay.ts
+import chalk3 from "chalk";
+var MACHINE_KEY2 = `t402-cli-${process.env.USER || "default"}`;
+function registerPayCommands(program) {
+  program.command("pay").description("Send a payment to an address").argument("<to>", "Recipient address").argument("<amount>", "Amount to send (e.g., 1.5)").option("-n, --network <network>", "Network to use (e.g., eip155:8453)").option("-a, --asset <asset>", "Asset to send (default: usdt0)", "usdt0").option("-g, --gasless", "Use gasless transaction (ERC-4337)").action(
+    async (to, amount, options) => {
+      const encrypted = getEncryptedSeed();
+      if (!encrypted) {
+        printError("No wallet configured. Run 'wallet create' or 'wallet import' first.");
+        return;
+      }
+      const network = options.network || getConfig("defaultNetwork");
+      const testnet = getConfig("testnet");
+      const isTestnetNetwork = network.includes("sepolia") || network.includes("testnet") || network.includes("devnet") || network.includes("nile") || network === "ton:-3";
+      if (testnet !== isTestnetNetwork) {
+        printError(
+          `Network ${network} doesn't match testnet mode (${testnet ? "testnet" : "mainnet"}).`
+        );
+        printError(`Run 'config set testnet ${isTestnetNetwork}' to switch modes.`);
+        return;
+      }
+      try {
+        const seedPhrase = decryptSeed(encrypted, MACHINE_KEY2);
+        printHeader("Payment Details");
+        printTable({
+          To: formatAddress(to),
+          Amount: `${amount} ${options.asset.toUpperCase()}`,
+          Network: getNetworkName(network),
+          Mode: options.gasless ? "Gasless (ERC-4337)" : "Standard"
+        });
+        console.log();
+        const spinner = createSpinner("Preparing transaction...").start();
+        if (options.gasless) {
+          const wdkGasless = await import("@t402/wdk-gasless");
+          const { WdkGaslessClient } = wdkGasless;
+          spinner.text = "Initializing gasless client...";
+          const client = await WdkGaslessClient.create({
+            seedPhrase,
+            chain: network.replace("eip155:", "")
+          });
+          spinner.text = "Sending gasless payment...";
+          const result = await client.pay({
+            to,
+            amount: parseAmount(amount)
+          });
+          spinner.succeed("Payment sent!");
+          console.log();
+          printSuccess("Transaction submitted");
+          console.log(`  User Operation Hash: ${chalk3.cyan(result.userOpHash)}`);
+          if (result.txHash) {
+            console.log(`  Transaction Hash: ${chalk3.cyan(result.txHash)}`);
+          }
+        } else {
+          const wdk = await import("@t402/wdk");
+          const { createPaymentProcessor } = wdk;
+          spinner.text = "Initializing wallet...";
+          const processor = createPaymentProcessor({ seedPhrase });
+          await processor.initialize();
+          spinner.text = "Sending payment...";
+          const txHash = await processor.pay({
+            network,
+            asset: options.asset,
+            to,
+            amount: parseAmount(amount)
+          });
+          spinner.succeed("Payment sent!");
+          console.log();
+          printSuccess("Transaction submitted");
+          console.log(`  Transaction Hash: ${chalk3.cyan(txHash)}`);
+        }
+      } catch (error) {
+        printError(`Payment failed: ${error instanceof Error ? error.message : error}`);
+      }
+    }
+  );
+  program.command("pay-invoice").description("Pay a 402 Payment Required response").argument("<url>", "URL that returned 402").option("-g, --gasless", "Use gasless transaction (ERC-4337)").option("-i, --index <index>", "Payment option index (if multiple)", "0").action(async (url, options) => {
+    if (!isValidUrl(url)) {
+      printError("Invalid URL format");
+      return;
+    }
+    const encrypted = getEncryptedSeed();
+    if (!encrypted) {
+      printError("No wallet configured. Run 'wallet create' or 'wallet import' first.");
+      return;
+    }
+    try {
+      const spinner = createSpinner("Fetching payment requirements...").start();
+      const response = await fetch(url);
+      if (response.status !== 402) {
+        spinner.fail(`Expected 402 status, got ${response.status}`);
+        return;
+      }
+      const paymentRequired = await response.json();
+      if (!paymentRequired.accepts || !Array.isArray(paymentRequired.accepts)) {
+        spinner.fail("Invalid 402 response format");
+        return;
+      }
+      const index = parseInt(options.index, 10);
+      const requirement = paymentRequired.accepts[index];
+      if (!requirement) {
+        spinner.fail(`No payment option at index ${index}`);
+        return;
+      }
+      spinner.succeed("Payment requirements fetched");
+      printHeader("Payment Requirements");
+      printTable({
+        Resource: paymentRequired.resource?.description || url,
+        Amount: `${formatAmount(requirement.amount)} ${requirement.asset?.toUpperCase() || "USDT"}`,
+        Network: getNetworkName(requirement.network),
+        Recipient: formatAddress(requirement.payTo)
+      });
+      console.log();
+      const seedPhrase = decryptSeed(encrypted, MACHINE_KEY2);
+      const paySpinner = createSpinner("Processing payment...").start();
+      if (options.gasless) {
+        const wdkGasless = await import("@t402/wdk-gasless");
+        const { WdkGaslessClient } = wdkGasless;
+        paySpinner.text = "Initializing gasless client...";
+        const client = await WdkGaslessClient.create({
+          seedPhrase,
+          chain: requirement.network.replace("eip155:", "")
+        });
+        paySpinner.text = "Sending gasless payment...";
+        const result = await client.pay({
+          to: requirement.payTo,
+          amount: requirement.amount
+        });
+        paySpinner.succeed("Payment sent!");
+        console.log();
+        printSuccess("Payment completed");
+        console.log(`  User Operation Hash: ${chalk3.cyan(result.userOpHash)}`);
+        console.log();
+        const retrySpinner = createSpinner("Retrying request with payment...").start();
+        const retryResponse = await fetch(url, {
+          headers: {
+            "X-Payment": result.userOpHash
+          }
+        });
+        if (retryResponse.ok) {
+          retrySpinner.succeed("Request successful!");
+          console.log(`  Status: ${chalk3.green(retryResponse.status)}`);
+        } else {
+          retrySpinner.warn(`Request returned ${retryResponse.status}`);
+        }
+      } else {
+        const wdk = await import("@t402/wdk");
+        const { createPaymentProcessor } = wdk;
+        paySpinner.text = "Initializing wallet...";
+        const processor = createPaymentProcessor({ seedPhrase });
+        await processor.initialize();
+        paySpinner.text = "Sending payment...";
+        const txHash = await processor.pay({
+          network: requirement.network,
+          asset: requirement.asset || "usdt",
+          to: requirement.payTo,
+          amount: requirement.amount
+        });
+        paySpinner.succeed("Payment sent!");
+        console.log();
+        printSuccess("Payment completed");
+        console.log(`  Transaction Hash: ${chalk3.cyan(txHash)}`);
+      }
+    } catch (error) {
+      printError(`Failed to pay invoice: ${error instanceof Error ? error.message : error}`);
+    }
+  });
+}
+
+// src/commands/request.ts
+import chalk4 from "chalk";
+
+// src/version.ts
+var VERSION = "2.0.0";
+
+// src/commands/request.ts
+var MACHINE_KEY3 = `t402-cli-${process.env.USER || "default"}`;
+function registerRequestCommand(program) {
+  program.command("request").description("Make an HTTP request with automatic 402 payment handling").argument("<url>", "URL to request").option("-X, --method <method>", "HTTP method", "GET").option("-H, --header <header...>", "Additional headers (key:value)").option("-d, --data <data>", "Request body data").option("-g, --gasless", "Use gasless payments (ERC-4337)").option("-n, --network <network>", "Preferred network for payment").option("-o, --output <file>", "Save response to file").option("-v, --verbose", "Show detailed output").option("--dry-run", "Show what would be paid without executing").action(
+    async (url, options) => {
+      if (!isValidUrl(url)) {
+        printError("Invalid URL format");
+        return;
+      }
+      const encrypted = getEncryptedSeed();
+      if (!encrypted && !options.dryRun) {
+        printError("No wallet configured. Run 'wallet create' or 'wallet import' first.");
+        return;
+      }
+      const headers = {
+        "User-Agent": `t402-cli/${VERSION}`
+      };
+      if (options.header) {
+        for (const h of options.header) {
+          const [key, ...valueParts] = h.split(":");
+          if (key && valueParts.length > 0) {
+            headers[key.trim()] = valueParts.join(":").trim();
+          }
+        }
+      }
+      const fetchOptions = {
+        method: options.method,
+        headers
+      };
+      if (options.data) {
+        fetchOptions.body = options.data;
+        if (!headers["Content-Type"]) {
+          headers["Content-Type"] = "application/json";
+        }
+      }
+      try {
+        const spinner = createSpinner(`${options.method} ${url}`).start();
+        const response = await fetch(url, fetchOptions);
+        if (response.status === 402) {
+          spinner.info("Payment required (402)");
+          const paymentRequired = await response.json();
+          if (!paymentRequired.accepts || !Array.isArray(paymentRequired.accepts)) {
+            printError("Invalid 402 response format");
+            return;
+          }
+          const preferredNetwork = options.network || getConfig("defaultNetwork");
+          let requirement = paymentRequired.accepts.find(
+            (r) => r.network === preferredNetwork
+          );
+          if (!requirement) {
+            requirement = paymentRequired.accepts[0];
+          }
+          printHeader("Payment Required");
+          printTable({
+            Resource: paymentRequired.resource?.description || url,
+            Amount: `${formatAmount(requirement.amount)} ${requirement.asset?.toUpperCase() || "USDT"}`,
+            Network: getNetworkName(requirement.network),
+            Recipient: formatAddress(requirement.payTo)
+          });
+          console.log();
+          if (options.dryRun) {
+            printWarning("Dry run - no payment executed");
+            return;
+          }
+          if (!encrypted) {
+            printError("No wallet configured.");
+            return;
+          }
+          const seedPhrase = decryptSeed(encrypted, MACHINE_KEY3);
+          const paySpinner = createSpinner("Processing payment...").start();
+          let paymentProof;
+          if (options.gasless) {
+            const wdkGasless = await import("@t402/wdk-gasless");
+            const { WdkGaslessClient } = wdkGasless;
+            paySpinner.text = "Initializing gasless client...";
+            const client = await WdkGaslessClient.create({
+              seedPhrase,
+              chain: requirement.network.replace("eip155:", "")
+            });
+            paySpinner.text = "Sending gasless payment...";
+            const result = await client.pay({
+              to: requirement.payTo,
+              amount: requirement.amount
+            });
+            paymentProof = result.userOpHash;
+            paySpinner.succeed("Gasless payment sent");
+            if (options.verbose) {
+              console.log(`  User Operation Hash: ${chalk4.cyan(result.userOpHash)}`);
+            }
+          } else {
+            const wdk = await import("@t402/wdk");
+            const { createPaymentProcessor } = wdk;
+            paySpinner.text = "Initializing wallet...";
+            const processor = createPaymentProcessor({ seedPhrase });
+            await processor.initialize();
+            paySpinner.text = "Sending payment...";
+            const txHash = await processor.pay({
+              network: requirement.network,
+              asset: requirement.asset || "usdt",
+              to: requirement.payTo,
+              amount: requirement.amount
+            });
+            paymentProof = txHash;
+            paySpinner.succeed("Payment sent");
+            if (options.verbose) {
+              console.log(`  Transaction Hash: ${chalk4.cyan(txHash)}`);
+            }
+          }
+          console.log();
+          const retrySpinner = createSpinner("Retrying request with payment proof...").start();
+          const retryResponse = await fetch(url, {
+            ...fetchOptions,
+            headers: {
+              ...headers,
+              "X-Payment": paymentProof
+            }
+          });
+          if (retryResponse.ok) {
+            retrySpinner.succeed(`${retryResponse.status} ${retryResponse.statusText}`);
+            await handleResponse(retryResponse, options);
+          } else if (retryResponse.status === 402) {
+            retrySpinner.fail("Payment not accepted - still requires payment");
+            printError("The server did not accept the payment proof.");
+          } else {
+            retrySpinner.warn(`${retryResponse.status} ${retryResponse.statusText}`);
+            await handleResponse(retryResponse, options);
+          }
+        } else if (response.ok) {
+          spinner.succeed(`${response.status} ${response.statusText}`);
+          await handleResponse(response, options);
+        } else {
+          spinner.fail(`${response.status} ${response.statusText}`);
+          await handleResponse(response, options);
+        }
+      } catch (error) {
+        printError(`Request failed: ${error instanceof Error ? error.message : error}`);
+      }
+    }
+  );
+}
+async function handleResponse(response, options) {
+  const contentType = response.headers.get("content-type") || "";
+  if (options.verbose) {
+    console.log();
+    console.log(chalk4.gray("Response Headers:"));
+    response.headers.forEach((value, key) => {
+      console.log(chalk4.gray(`  ${key}: ${value}`));
+    });
+    console.log();
+  }
+  if (options.output) {
+    const { writeFile } = await import("fs/promises");
+    const buffer = await response.arrayBuffer();
+    await writeFile(options.output, Buffer.from(buffer));
+    printSuccess(`Response saved to ${options.output}`);
+  } else if (contentType.includes("application/json")) {
+    const json = await response.json();
+    console.log();
+    console.log(JSON.stringify(json, null, 2));
+  } else if (contentType.includes("text/")) {
+    const text = await response.text();
+    console.log();
+    console.log(text);
+  } else {
+    const size = response.headers.get("content-length") || "unknown";
+    console.log();
+    console.log(chalk4.gray(`Binary response (${size} bytes)`));
+    console.log(chalk4.gray("Use --output to save to file"));
+  }
+}
+
+// src/commands/config.ts
+import chalk5 from "chalk";
+function registerConfigCommands(program) {
+  const config2 = program.command("config").description("Configuration management");
+  config2.command("show").description("Show current configuration").action(() => {
+    const cfg = getAllConfig();
+    printHeader("T402 CLI Configuration");
+    const displayConfig = {
+      "Default Network": getNetworkName(cfg.defaultNetwork),
+      "Network ID": cfg.defaultNetwork,
+      "Facilitator URL": cfg.facilitatorUrl,
+      "Testnet Mode": cfg.testnet ? chalk5.yellow("Yes") : "No",
+      "Wallet Configured": cfg.encryptedSeed ? chalk5.green("Yes") : chalk5.gray("No"),
+      "Config File": getConfigPath()
+    };
+    printTable(displayConfig);
+    const endpoints = cfg.rpcEndpoints;
+    if (Object.keys(endpoints).length > 0) {
+      console.log();
+      console.log(chalk5.bold("Custom RPC Endpoints:"));
+      for (const [network, url] of Object.entries(endpoints)) {
+        console.log(`  ${getNetworkName(network)}: ${url}`);
+      }
+    }
+  });
+  config2.command("get").description("Get a configuration value").argument("<key>", "Configuration key (defaultNetwork, facilitatorUrl, testnet)").action((key) => {
+    const validKeys = ["defaultNetwork", "facilitatorUrl", "testnet", "rpcEndpoints"];
+    if (!validKeys.includes(key)) {
+      printError(`Invalid key. Valid keys: ${validKeys.join(", ")}`);
+      return;
+    }
+    const value = getConfig(key);
+    if (typeof value === "object") {
+      console.log(JSON.stringify(value, null, 2));
+    } else {
+      console.log(value);
+    }
+  });
+  config2.command("set").description("Set a configuration value").argument("<key>", "Configuration key").argument("<value>", "Value to set").action((key, value) => {
+    switch (key) {
+      case "defaultNetwork":
+        setConfig("defaultNetwork", value);
+        printSuccess(`Default network set to ${getNetworkName(value)}`);
+        break;
+      case "facilitatorUrl":
+        if (!isValidUrl(value)) {
+          printError("Invalid URL format");
+          return;
+        }
+        setConfig("facilitatorUrl", value);
+        printSuccess(`Facilitator URL set to ${value}`);
+        break;
+      case "testnet":
+        const isTestnet = value.toLowerCase() === "true" || value === "1";
+        setConfig("testnet", isTestnet);
+        printSuccess(`Testnet mode ${isTestnet ? "enabled" : "disabled"}`);
+        if (isTestnet) {
+          setConfig("defaultNetwork", "eip155:84532");
+          console.log(chalk5.gray("  Default network changed to Base Sepolia"));
+        } else {
+          setConfig("defaultNetwork", "eip155:8453");
+          console.log(chalk5.gray("  Default network changed to Base"));
+        }
+        break;
+      default:
+        printError(
+          `Unknown key: ${key}. Valid keys: defaultNetwork, facilitatorUrl, testnet`
+        );
+    }
+  });
+  config2.command("rpc").description("Set custom RPC endpoint for a network").argument("<network>", "Network ID (e.g., eip155:8453)").argument("<url>", "RPC endpoint URL").action((network, url) => {
+    if (!isValidUrl(url)) {
+      printError("Invalid URL format");
+      return;
+    }
+    setRpcEndpoint(network, url);
+    printSuccess(`RPC endpoint set for ${getNetworkName(network)}`);
+  });
+  config2.command("reset").description("Reset configuration to defaults").option("-f, --force", "Skip confirmation").action((options) => {
+    if (!options.force) {
+      printWarning("This will reset all configuration to defaults.");
+      printWarning("Your wallet will NOT be removed.");
+      console.log();
+      console.log("Run with --force to confirm.");
+      return;
+    }
+    const cfg = getAllConfig();
+    const encryptedSeed = cfg.encryptedSeed;
+    resetConfig();
+    if (encryptedSeed) {
+      setConfig("encryptedSeed", encryptedSeed);
+    }
+    printSuccess("Configuration reset to defaults");
+  });
+  config2.command("path").description("Show configuration file path").action(() => {
+    console.log(getConfigPath());
+  });
+}
+
+// src/commands/info.ts
+import chalk6 from "chalk";
+function registerInfoCommand(program) {
+  program.command("info").description("Show supported networks and assets").option("-a, --all", "Show all networks (mainnet and testnet)").option("-t, --testnet", "Show testnet networks only").action((options) => {
+    const showTestnet = options.testnet || getConfig("testnet");
+    const showAll = options.all;
+    printHeader("T402 Payment Protocol");
+    console.log(`  Version: ${VERSION}`);
+    console.log("  Facilitator: " + chalk6.cyan(getConfig("facilitatorUrl")));
+    console.log();
+    console.log(chalk6.bold("Supported Networks:"));
+    console.log();
+    const evmMainnets = NETWORKS.filter((n) => n.type === "evm" && !n.testnet);
+    const evmTestnets = NETWORKS.filter((n) => n.type === "evm" && n.testnet);
+    if (showAll || !showTestnet) {
+      console.log(chalk6.underline("  EVM (Mainnet):"));
+      for (const network of evmMainnets) {
+        console.log(
+          `    ${chalk6.green("\u25CF")} ${network.name.padEnd(16)} ${chalk6.gray(network.id)}`
+        );
+      }
+      console.log();
+    }
+    if (showAll || showTestnet) {
+      console.log(chalk6.underline("  EVM (Testnet):"));
+      for (const network of evmTestnets) {
+        console.log(
+          `    ${chalk6.yellow("\u25CF")} ${network.name.padEnd(16)} ${chalk6.gray(network.id)}`
+        );
+      }
+      console.log();
+    }
+    const solanaNetworks = NETWORKS.filter(
+      (n) => n.type === "solana" && (showAll || n.testnet === showTestnet)
+    );
+    if (solanaNetworks.length > 0) {
+      console.log(chalk6.underline("  Solana:"));
+      for (const network of solanaNetworks) {
+        const color = network.testnet ? chalk6.yellow : chalk6.green;
+        console.log(`    ${color("\u25CF")} ${network.name.padEnd(16)} ${chalk6.gray(network.id)}`);
+      }
+      console.log();
+    }
+    const tonNetworks = NETWORKS.filter(
+      (n) => n.type === "ton" && (showAll || n.testnet === showTestnet)
+    );
+    if (tonNetworks.length > 0) {
+      console.log(chalk6.underline("  TON:"));
+      for (const network of tonNetworks) {
+        const color = network.testnet ? chalk6.yellow : chalk6.green;
+        console.log(`    ${color("\u25CF")} ${network.name.padEnd(16)} ${chalk6.gray(network.id)}`);
+      }
+      console.log();
+    }
+    const tronNetworks = NETWORKS.filter(
+      (n) => n.type === "tron" && (showAll || n.testnet === showTestnet)
+    );
+    if (tronNetworks.length > 0) {
+      console.log(chalk6.underline("  TRON:"));
+      for (const network of tronNetworks) {
+        const color = network.testnet ? chalk6.yellow : chalk6.green;
+        console.log(`    ${color("\u25CF")} ${network.name.padEnd(16)} ${chalk6.gray(network.id)}`);
+      }
+      console.log();
+    }
+    console.log(chalk6.bold("Supported Assets:"));
+    console.log();
+    console.log(`  ${chalk6.cyan("USDT0")}  - Tether USD (OFT) on EVM chains`);
+    console.log(`  ${chalk6.cyan("USDT")}   - Tether USD on all chains`);
+    console.log();
+    console.log(chalk6.bold("Payment Schemes:"));
+    console.log();
+    console.log(`  ${chalk6.magenta("exact")}  - Exact amount payment (default)`);
+    console.log(`  ${chalk6.magenta("upto")}   - Payment up to specified amount`);
+    console.log();
+    console.log(chalk6.bold("Features:"));
+    console.log();
+    console.log(`  ${chalk6.green("\u2713")} Standard payments (all chains)`);
+    console.log(`  ${chalk6.green("\u2713")} Gasless payments via ERC-4337 (EVM chains)`);
+    console.log(`  ${chalk6.green("\u2713")} Cross-chain bridging via LayerZero`);
+    console.log(`  ${chalk6.green("\u2713")} WDK wallet integration`);
+    console.log();
+    console.log(chalk6.gray("Legend:"));
+    console.log(chalk6.gray(`  ${chalk6.green("\u25CF")} Mainnet  ${chalk6.yellow("\u25CF")} Testnet`));
+  });
+  program.command("version").description("Show CLI version").action(() => {
+    console.log(`t402 CLI v${VERSION}`);
+  });
+}
+
+// src/cli.ts
+function createCli() {
+  const program = new Command();
+  program.name("t402").description("Command-line interface for the T402 payment protocol").version(VERSION);
+  registerWalletCommands(program);
+  registerPayCommands(program);
+  registerRequestCommand(program);
+  registerConfigCommands(program);
+  registerInfoCommand(program);
+  return program;
+}
+async function runCli(args = process.argv) {
+  const program = createCli();
+  await program.parseAsync(args);
+}
+
+export {
+  DEFAULT_CONFIG,
+  NETWORKS,
+  getConfig,
+  setConfig,
+  getAllConfig,
+  resetConfig,
+  getConfigPath,
+  hasSeedConfigured,
+  setRpcEndpoint,
+  getRpcEndpoint,
+  createSpinner,
+  formatAddress,
+  formatAmount,
+  formatBalanceResult,
+  formatPaymentResult,
+  getNetworkInfo,
+  getNetworkName,
+  getAvailableNetworks,
+  printTable,
+  printSuccess,
+  printError,
+  printWarning,
+  printInfo,
+  printHeader,
+  isValidSeedPhrase,
+  parseAmount,
+  isValidUrl,
+  createCli,
+  runCli
+};
+//# sourceMappingURL=chunk-2A2UCRTK.js.map