moltspay 0.5.4 → 0.7.1

package/dist/cli.mjs

@@ -1,1969 +0,0 @@
-#!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/chains/index.ts
-var chains_exports = {};
-__export(chains_exports, {
-  CHAINS: () => CHAINS,
-  ERC20_ABI: () => ERC20_ABI,
-  getChain: () => getChain,
-  getChainById: () => getChainById,
-  listChains: () => listChains
-});
-function getChain(name) {
-  const config = CHAINS[name];
-  if (!config) {
-    throw new Error(`Unsupported chain: ${name}. Supported: ${Object.keys(CHAINS).join(", ")}`);
-  }
-  return config;
-}
-function listChains() {
-  return Object.keys(CHAINS);
-}
-function getChainById(chainId) {
-  return Object.values(CHAINS).find((c) => c.chainId === chainId);
-}
-var CHAINS, ERC20_ABI;
-var init_chains = __esm({
-  "src/chains/index.ts"() {
-    "use strict";
-    CHAINS = {
-      // ============ Mainnet ============
-      base: {
-        name: "Base",
-        chainId: 8453,
-        rpc: "https://mainnet.base.org",
-        usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-        explorer: "https://basescan.org/address/",
-        explorerTx: "https://basescan.org/tx/",
-        avgBlockTime: 2
-      },
-      polygon: {
-        name: "Polygon",
-        chainId: 137,
-        rpc: "https://polygon-rpc.com",
-        usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
-        explorer: "https://polygonscan.com/address/",
-        explorerTx: "https://polygonscan.com/tx/",
-        avgBlockTime: 2
-      },
-      ethereum: {
-        name: "Ethereum",
-        chainId: 1,
-        rpc: "https://eth.llamarpc.com",
-        usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-        explorer: "https://etherscan.io/address/",
-        explorerTx: "https://etherscan.io/tx/",
-        avgBlockTime: 12
-      },
-      // ============ Testnet ============
-      base_sepolia: {
-        name: "Base Sepolia",
-        chainId: 84532,
-        rpc: "https://sepolia.base.org",
-        usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
-        explorer: "https://sepolia.basescan.org/address/",
-        explorerTx: "https://sepolia.basescan.org/tx/",
-        avgBlockTime: 2
-      },
-      sepolia: {
-        name: "Sepolia",
-        chainId: 11155111,
-        rpc: "https://rpc.sepolia.org",
-        usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
-        explorer: "https://sepolia.etherscan.io/address/",
-        explorerTx: "https://sepolia.etherscan.io/tx/",
-        avgBlockTime: 12
-      }
-    };
-    ERC20_ABI = [
-      "function balanceOf(address owner) view returns (uint256)",
-      "function transfer(address to, uint256 amount) returns (bool)",
-      "function approve(address spender, uint256 amount) returns (bool)",
-      "function allowance(address owner, address spender) view returns (uint256)",
-      "function decimals() view returns (uint8)",
-      "function symbol() view returns (string)",
-      "function name() view returns (string)",
-      "function nonces(address owner) view returns (uint256)",
-      "function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)",
-      "event Transfer(address indexed from, address indexed to, uint256 value)",
-      "event Approval(address indexed owner, address indexed spender, uint256 value)"
-    ];
-  }
-});
-
-// src/agent/AgentWallet.ts
-var AgentWallet_exports = {};
-__export(AgentWallet_exports, {
-  AgentWallet: () => AgentWallet,
-  getAgentAddress: () => getAgentAddress
-});
-import { ethers as ethers2 } from "ethers";
-import * as fs from "fs";
-import * as path from "path";
-function getAgentAddress(config) {
-  const wallet = new AgentWallet(config);
-  return wallet.address;
-}
-var PERMIT_ABI, AgentWallet;
-var init_AgentWallet = __esm({
-  "src/agent/AgentWallet.ts"() {
-    "use strict";
-    init_chains();
-    PERMIT_ABI = [
-      ...ERC20_ABI,
-      "function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)",
-      "function transferFrom(address from, address to, uint256 amount) returns (bool)",
-      "function allowance(address owner, address spender) view returns (uint256)",
-      "function nonces(address owner) view returns (uint256)"
-    ];
-    AgentWallet = class {
-      chain;
-      chainConfig;
-      storageDir;
-      _address = null;
-      _privateKey = null;
-      _wallet = null;
-      _provider = null;
-      _permits = /* @__PURE__ */ new Map();
-      constructor(config = {}) {
-        this.chain = config.chain || "base";
-        this.chainConfig = getChain(this.chain);
-        this.storageDir = config.storageDir || this.getDefaultStorageDir();
-        this.ensureInitialized();
-      }
-      getDefaultStorageDir() {
-        const home = process.env.HOME || process.env.USERPROFILE || ".";
-        return path.join(home, ".moltspay");
-      }
-      getWalletPath() {
-        return path.join(this.storageDir, "wallet.json");
-      }
-      getPermitsPath() {
-        return path.join(this.storageDir, "permits.json");
-      }
-      /**
-       * Auto-initialize: create wallet if not exists
-       * This is called automatically in constructor
-       */
-      ensureInitialized() {
-        if (!fs.existsSync(this.storageDir)) {
-          fs.mkdirSync(this.storageDir, { recursive: true });
-        }
-        const walletPath = this.getWalletPath();
-        if (fs.existsSync(walletPath)) {
-          const data = JSON.parse(fs.readFileSync(walletPath, "utf-8"));
-          this._address = data.address;
-          this._privateKey = data.privateKey;
-        } else {
-          const wallet = ethers2.Wallet.createRandom();
-          this._address = wallet.address;
-          this._privateKey = wallet.privateKey;
-          fs.writeFileSync(walletPath, JSON.stringify({
-            address: this._address,
-            privateKey: this._privateKey,
-            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-            chain: this.chain
-          }, null, 2), { mode: 384 });
-        }
-        const permitsPath = this.getPermitsPath();
-        if (fs.existsSync(permitsPath)) {
-          const permits = JSON.parse(fs.readFileSync(permitsPath, "utf-8"));
-          for (const [owner, permit] of Object.entries(permits)) {
-            this._permits.set(owner.toLowerCase(), permit);
-          }
-        }
-      }
-      /** Agent's address (auto-generated on first use) */
-      get address() {
-        return this._address;
-      }
-      get wallet() {
-        if (!this._wallet) {
-          this._wallet = new ethers2.Wallet(this._privateKey, this.provider);
-        }
-        return this._wallet;
-      }
-      get provider() {
-        if (!this._provider) {
-          this._provider = new ethers2.JsonRpcProvider(this.chainConfig.rpc);
-        }
-        return this._provider;
-      }
-      /**
-       * Store a Permit from Owner
-       */
-      storePermit(permit) {
-        const ownerLower = permit.owner.toLowerCase();
-        this._permits.set(ownerLower, permit);
-        const permitsPath = this.getPermitsPath();
-        const permits = {};
-        for (const [owner, p] of this._permits) {
-          permits[owner] = p;
-        }
-        fs.writeFileSync(permitsPath, JSON.stringify(permits, null, 2));
-      }
-      /**
-       * Get stored permit for an owner
-       */
-      getPermit(owner) {
-        return this._permits.get(owner.toLowerCase());
-      }
-      /**
-       * Check allowance from an owner
-       */
-      async checkAllowance(owner) {
-        const usdcContract = new ethers2.Contract(
-          this.chainConfig.usdc,
-          PERMIT_ABI,
-          this.provider
-        );
-        const ownerAddress = ethers2.getAddress(owner);
-        const [allowance, balance] = await Promise.all([
-          usdcContract.allowance(ownerAddress, this.address),
-          usdcContract.balanceOf(ownerAddress)
-        ]);
-        return {
-          allowance: (Number(allowance) / 1e6).toFixed(2),
-          ownerBalance: (Number(balance) / 1e6).toFixed(2),
-          canSpend: Number(allowance) > 0
-        };
-      }
-      /**
-       * Spend USDC from Owner's wallet
-       * 
-       * @param to - Recipient (service provider)
-       * @param amount - Amount in USDC
-       * @param permit - Optional, uses stored permit if not provided
-       */
-      async spend(to, amount, permit) {
-        const toAddress = ethers2.getAddress(to);
-        const amountWei = BigInt(Math.floor(amount * 1e6));
-        let usePermit = permit;
-        let ownerAddress;
-        if (usePermit) {
-          ownerAddress = ethers2.getAddress(usePermit.owner);
-          this.storePermit(usePermit);
-        } else {
-          const usdcContract = new ethers2.Contract(
-            this.chainConfig.usdc,
-            PERMIT_ABI,
-            this.provider
-          );
-          for (const [owner, p] of this._permits) {
-            const allowance = await usdcContract.allowance(owner, this.address);
-            if (BigInt(allowance) >= amountWei) {
-              ownerAddress = ethers2.getAddress(owner);
-              usePermit = p;
-              break;
-            }
-          }
-          if (!usePermit) {
-            return {
-              success: false,
-              error: "No valid permit. Ask Owner to authorize spending first.",
-              from: "",
-              to: toAddress,
-              amount
-            };
-          }
-        }
-        try {
-          const usdcContract = new ethers2.Contract(
-            this.chainConfig.usdc,
-            PERMIT_ABI,
-            this.wallet
-          );
-          const currentAllowance = await usdcContract.allowance(ownerAddress, this.address);
-          if (BigInt(currentAllowance) < amountWei) {
-            const now = Math.floor(Date.now() / 1e3);
-            if (usePermit.deadline < now) {
-              return {
-                success: false,
-                error: "Permit expired. Ask Owner for a new authorization.",
-                from: ownerAddress,
-                to: toAddress,
-                amount
-              };
-            }
-            const permitTx = await usdcContract.permit(
-              ownerAddress,
-              this.address,
-              usePermit.value,
-              usePermit.deadline,
-              usePermit.v,
-              usePermit.r,
-              usePermit.s
-            );
-            await permitTx.wait();
-          }
-          const tx = await usdcContract.transferFrom(ownerAddress, toAddress, amountWei);
-          await tx.wait();
-          const newAllowance = await usdcContract.allowance(ownerAddress, this.address);
-          return {
-            success: true,
-            txHash: tx.hash,
-            from: ownerAddress,
-            to: toAddress,
-            amount,
-            remainingAllowance: (Number(newAllowance) / 1e6).toFixed(2),
-            explorerUrl: `${this.chainConfig.explorerTx}${tx.hash}`
-          };
-        } catch (error) {
-          return {
-            success: false,
-            error: error.message,
-            from: ownerAddress,
-            to: toAddress,
-            amount
-          };
-        }
-      }
-      /**
-       * Get USDC balance
-       */
-      async getBalance() {
-        const usdcContract = new ethers2.Contract(
-          this.chainConfig.usdc,
-          PERMIT_ABI,
-          this.provider
-        );
-        const [usdcBalance, ethBalance] = await Promise.all([
-          usdcContract.balanceOf(this.address),
-          this.provider.getBalance(this.address)
-        ]);
-        return {
-          usdc: (Number(usdcBalance) / 1e6).toFixed(2),
-          eth: ethers2.formatEther(ethBalance)
-        };
-      }
-      /**
-       * Transfer USDC to a recipient (direct payment)
-       * 
-       * This is the simplest payment method - Agent pays directly from its wallet.
-       * Requires Agent wallet to have USDC (funded by Owner).
-       * 
-       * @example
-       * ```typescript
-       * const wallet = new AgentWallet({ chain: 'base' });
-       * 
-       * // Check balance
-       * const balance = await wallet.getBalance();
-       * console.log('USDC:', balance.usdc);
-       * 
-       * // Pay for service
-       * const result = await wallet.transfer({
-       *   to: '0xServiceProvider...',
-       *   amount: 0.99
-       * });
-       * console.log('Tx:', result.txHash);
-       * ```
-       */
-      async transfer(params) {
-        const { to, amount } = params;
-        try {
-          const toAddress = ethers2.getAddress(to);
-          const amountWei = BigInt(Math.floor(amount * 1e6));
-          const usdcContract = new ethers2.Contract(
-            this.chainConfig.usdc,
-            PERMIT_ABI,
-            this.wallet
-          );
-          const balance = await usdcContract.balanceOf(this.address);
-          if (BigInt(balance) < amountWei) {
-            return {
-              success: false,
-              error: `Insufficient USDC: have ${(Number(balance) / 1e6).toFixed(2)}, need ${amount}`
-            };
-          }
-          if (!await this.hasGas()) {
-            return {
-              success: false,
-              error: "Insufficient ETH for gas. Need at least 0.0005 ETH."
-            };
-          }
-          const tx = await usdcContract.transfer(toAddress, amountWei);
-          const receipt = await tx.wait();
-          if (receipt.status === 1) {
-            return {
-              success: true,
-              txHash: tx.hash,
-              from: this.address,
-              to: toAddress,
-              amount,
-              explorerUrl: `${this.chainConfig.explorerTx}${tx.hash}`
-            };
-          } else {
-            return {
-              success: false,
-              txHash: tx.hash,
-              error: "Transaction reverted"
-            };
-          }
-        } catch (error) {
-          return {
-            success: false,
-            error: error.message
-          };
-        }
-      }
-      /**
-       * Pay for a service (transfer USDC to service provider)
-       * 
-       * This is the main method for Agent-to-Agent payments.
-       * Returns payment data ready to submit to service API.
-       * 
-       * @example
-       * ```typescript
-       * const wallet = new AgentWallet({ chain: 'base' });
-       * 
-       * // Pay for Zen7 video service
-       * const payment = await wallet.payService({
-       *   provider: '0xb8d6f2441e8f8dfB6288A74Cf73804cDd0484E0C',
-       *   amount: 0.99,
-       *   service: 'video_generation'
-       * });
-       * 
-       * if (payment.success) {
-       *   // Submit to service API
-       *   await fetch('/v1/video/generate', {
-       *     body: JSON.stringify({
-       *       prompt: "...",
-       *       payment: payment.paymentData  // Ready to use!
-       *     })
-       *   });
-       * }
-       * ```
-       */
-      async payService(params) {
-        const result = await this.transfer({
-          to: params.provider,
-          amount: params.amount
-        });
-        if (result.success && result.txHash) {
-          return {
-            success: true,
-            txHash: result.txHash,
-            explorerUrl: result.explorerUrl,
-            paymentData: {
-              method: "transfer",
-              chain: this.chain,
-              tx_hash: result.txHash
-            }
-          };
-        } else {
-          return {
-            success: false,
-            error: result.error
-          };
-        }
-      }
-      /**
-       * Get gas balance (ETH needed for transactions)
-       */
-      async getGasBalance() {
-        const balance = await this.provider.getBalance(this.address);
-        return ethers2.formatEther(balance);
-      }
-      /**
-       * Check if agent has enough gas
-       */
-      async hasGas(minEth = 5e-4) {
-        const balance = await this.getGasBalance();
-        return parseFloat(balance) >= minEth;
-      }
-      /**
-       * Generate authorization request for Owner
-       * Owner can sign this with CLI (ethers) or MetaMask
-       */
-      async generateAuthRequest(params) {
-        const { ownerAddress, amount, expiresInHours = 168 } = params;
-        const deadline = Math.floor(Date.now() / 1e3) + expiresInHours * 3600;
-        const value = BigInt(Math.floor(amount * 1e6)).toString();
-        const usdcContract = new ethers2.Contract(
-          this.chainConfig.usdc,
-          PERMIT_ABI,
-          this.provider
-        );
-        const nonce = Number(await usdcContract.nonces(ownerAddress));
-        const domain = {
-          name: "USD Coin",
-          version: "2",
-          chainId: this.chainConfig.chainId,
-          verifyingContract: this.chainConfig.usdc
-        };
-        const types = {
-          Permit: [
-            { name: "owner", type: "address" },
-            { name: "spender", type: "address" },
-            { name: "value", type: "uint256" },
-            { name: "nonce", type: "uint256" },
-            { name: "deadline", type: "uint256" }
-          ]
-        };
-        const permitMessage = {
-          owner: ownerAddress,
-          spender: this.address,
-          value,
-          nonce,
-          deadline
-        };
-        const typedData = {
-          types: { ...types, EIP712Domain: [
-            { name: "name", type: "string" },
-            { name: "version", type: "string" },
-            { name: "chainId", type: "uint256" },
-            { name: "verifyingContract", type: "address" }
-          ] },
-          primaryType: "Permit",
-          domain,
-          message: permitMessage
-        };
-        const cliCommand = `npx moltspay sign-permit \\
-  --owner ${ownerAddress} \\
-  --spender ${this.address} \\
-  --amount ${amount} \\
-  --deadline ${deadline} \\
-  --nonce ${nonce} \\
-  --chain ${this.chain}`;
-        const message = `\u{1F510} Authorization Request
-
-I need permission to spend up to ${amount} USDC from your wallet.
-
-**Details:**
-- Your wallet: ${ownerAddress}
-- My address: ${this.address}
-- Amount: ${amount} USDC
-- Expires: ${new Date(deadline * 1e3).toISOString()}
-- Chain: ${this.chainConfig.name}
-
-**Option 1: Sign with CLI** (if you have the private key)
-\`\`\`
-${cliCommand}
-\`\`\`
-
-**Option 2: Sign with MetaMask**
-Visit: https://moltspay.vercel.app/permit?data=${encodeURIComponent(JSON.stringify(typedData))}
-
-After signing, send me the signature (v, r, s).`;
-        return { message, typedData, cliCommand };
-      }
-    };
-  }
-});
-
-// src/cdp/index.ts
-var cdp_exports = {};
-__export(cdp_exports, {
-  CDPWallet: () => CDPWallet,
-  getCDPWalletAddress: () => getCDPWalletAddress,
-  initCDPWallet: () => initCDPWallet,
-  isCDPAvailable: () => isCDPAvailable,
-  loadCDPWallet: () => loadCDPWallet
-});
-import * as fs3 from "fs";
-import * as path3 from "path";
-function isCDPAvailable() {
-  try {
-    __require.resolve("@coinbase/cdp-sdk");
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getCDPCredentials(config) {
-  const apiKeyId = config.apiKeyId || process.env.CDP_API_KEY_ID;
-  const apiKeySecret = config.apiKeySecret || process.env.CDP_API_KEY_SECRET;
-  const walletSecret = config.walletSecret || process.env.CDP_WALLET_SECRET;
-  if (!apiKeyId || !apiKeySecret) {
-    return null;
-  }
-  return { apiKeyId, apiKeySecret, walletSecret };
-}
-async function initCDPWallet(config = {}) {
-  const storageDir = config.storageDir || DEFAULT_STORAGE_DIR2;
-  const chain = config.chain || "base";
-  const storagePath = path3.join(storageDir, CDP_CONFIG_FILE);
-  if (fs3.existsSync(storagePath)) {
-    try {
-      const data = JSON.parse(fs3.readFileSync(storagePath, "utf-8"));
-      return {
-        success: true,
-        address: data.address,
-        walletId: data.walletId,
-        isNew: false,
-        storagePath
-      };
-    } catch (error) {
-    }
-  }
-  if (!isCDPAvailable()) {
-    return {
-      success: false,
-      error: "CDP SDK not installed. Run: npm install @coinbase/cdp-sdk"
-    };
-  }
-  const creds = getCDPCredentials(config);
-  if (!creds) {
-    return {
-      success: false,
-      error: "CDP credentials not found. Set CDP_API_KEY_ID and CDP_API_KEY_SECRET environment variables."
-    };
-  }
-  try {
-    const { CdpClient } = await import("@coinbase/cdp-sdk");
-    const cdp = new CdpClient({
-      apiKeyId: creds.apiKeyId,
-      apiKeySecret: creds.apiKeySecret,
-      walletSecret: creds.walletSecret
-    });
-    const account = await cdp.evm.createAccount();
-    if (!fs3.existsSync(storageDir)) {
-      fs3.mkdirSync(storageDir, { recursive: true });
-    }
-    const walletData = {
-      address: account.address,
-      walletId: account.address,
-      // CDP uses address as ID for EVM
-      chain,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    fs3.writeFileSync(storagePath, JSON.stringify(walletData, null, 2), { mode: 384 });
-    return {
-      success: true,
-      address: account.address,
-      walletId: account.address,
-      isNew: true,
-      storagePath
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error.message
-    };
-  }
-}
-function loadCDPWallet(config = {}) {
-  const storageDir = config.storageDir || DEFAULT_STORAGE_DIR2;
-  const storagePath = path3.join(storageDir, CDP_CONFIG_FILE);
-  if (!fs3.existsSync(storagePath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(fs3.readFileSync(storagePath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function getCDPWalletAddress(storageDir) {
-  const data = loadCDPWallet({ storageDir });
-  return data?.address || null;
-}
-var DEFAULT_STORAGE_DIR2, CDP_CONFIG_FILE, CDPWallet;
-var init_cdp = __esm({
-  "src/cdp/index.ts"() {
-    "use strict";
-    init_chains();
-    DEFAULT_STORAGE_DIR2 = path3.join(process.env.HOME || ".", ".moltspay");
-    CDP_CONFIG_FILE = "cdp-wallet.json";
-    CDPWallet = class {
-      address;
-      chain;
-      chainConfig;
-      storageDir;
-      constructor(config = {}) {
-        this.storageDir = config.storageDir || DEFAULT_STORAGE_DIR2;
-        this.chain = config.chain || "base";
-        this.chainConfig = getChain(this.chain);
-        const data = loadCDPWallet(config);
-        if (!data) {
-          throw new Error("CDP wallet not initialized. Run: npx moltspay init --cdp");
-        }
-        this.address = data.address;
-      }
-      /**
-       * Get USDC balance
-       */
-      async getBalance() {
-        const { ethers: ethers11 } = await import("ethers");
-        const provider = new ethers11.JsonRpcProvider(this.chainConfig.rpc);
-        const usdcContract = new ethers11.Contract(
-          this.chainConfig.usdc,
-          ["function balanceOf(address) view returns (uint256)"],
-          provider
-        );
-        const [usdcBalance, ethBalance] = await Promise.all([
-          usdcContract.balanceOf(this.address),
-          provider.getBalance(this.address)
-        ]);
-        return {
-          usdc: (Number(usdcBalance) / 1e6).toFixed(2),
-          eth: ethers11.formatEther(ethBalance)
-        };
-      }
-      /**
-       * Transfer USDC to a recipient
-       * 
-       * Requires CDP SDK and credentials to sign transactions.
-       */
-      async transfer(params) {
-        if (!isCDPAvailable()) {
-          return { success: false, error: "CDP SDK not installed" };
-        }
-        const creds = getCDPCredentials({});
-        if (!creds) {
-          return { success: false, error: "CDP credentials not found" };
-        }
-        try {
-          const { CdpClient } = await import("@coinbase/cdp-sdk");
-          const { ethers: ethers11 } = await import("ethers");
-          const cdp = new CdpClient({
-            apiKeyId: creds.apiKeyId,
-            apiKeySecret: creds.apiKeySecret,
-            walletSecret: creds.walletSecret
-          });
-          const account = await cdp.evm.getAccount({ address: this.address });
-          const amountWei = BigInt(Math.floor(params.amount * 1e6));
-          const iface = new ethers11.Interface([
-            "function transfer(address to, uint256 amount) returns (bool)"
-          ]);
-          const callData = iface.encodeFunctionData("transfer", [params.to, amountWei]);
-          const txOptions = {
-            to: this.chainConfig.usdc,
-            data: callData
-          };
-          const tx = await account.sendTransaction(txOptions);
-          return {
-            success: true,
-            txHash: tx.transactionHash,
-            explorerUrl: `${this.chainConfig.explorerTx}${tx.transactionHash}`
-          };
-        } catch (error) {
-          return {
-            success: false,
-            error: error.message
-          };
-        }
-      }
-      /**
-       * Create viem-compatible signer for x402
-       * 
-       * This allows using CDP wallet with x402 protocol.
-       */
-      async getViemAccount() {
-        if (!isCDPAvailable()) {
-          throw new Error("CDP SDK not installed");
-        }
-        const creds = getCDPCredentials({});
-        if (!creds) {
-          throw new Error("CDP credentials not found");
-        }
-        const { CdpClient } = await import("@coinbase/cdp-sdk");
-        const { toAccount } = await import("viem/accounts");
-        const cdp = new CdpClient({
-          apiKeyId: creds.apiKeyId,
-          apiKeySecret: creds.apiKeySecret,
-          walletSecret: creds.walletSecret
-        });
-        const account = await cdp.evm.getAccount({ address: this.address });
-        return toAccount(account);
-      }
-    };
-  }
-});
-
-// src/x402/client.ts
-var client_exports = {};
-__export(client_exports, {
-  createX402Client: () => createX402Client,
-  isX402Available: () => isX402Available,
-  x402Fetch: () => x402Fetch
-});
-function isX402Available() {
-  try {
-    __require.resolve("@x402/fetch");
-    __require.resolve("@x402/evm");
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function createLocalX402Client(config) {
-  const { AgentWallet: AgentWallet2 } = await Promise.resolve().then(() => (init_AgentWallet(), AgentWallet_exports));
-  const { ethers: ethers11 } = await import("ethers");
-  const wallet = new AgentWallet2({
-    chain: config.chain,
-    storageDir: config.storageDir
-  });
-  const fs4 = await import("fs");
-  const path4 = await import("path");
-  const storageDir = config.storageDir || path4.join(process.env.HOME || ".", ".moltspay");
-  const walletPath = path4.join(storageDir, "wallet.json");
-  const walletData = JSON.parse(fs4.readFileSync(walletPath, "utf-8"));
-  const privateKey = config.privateKey || walletData.privateKey;
-  const { privateKeyToAccount } = await import("viem/accounts");
-  const signer = privateKeyToAccount(privateKey);
-  const { x402Client, wrapFetchWithPayment } = await import("@x402/fetch");
-  const { registerExactEvmScheme } = await import("@x402/evm/exact/client");
-  const client = new x402Client();
-  registerExactEvmScheme(client, { signer });
-  const fetchWithPayment = wrapFetchWithPayment(fetch, client);
-  return {
-    fetch: fetchWithPayment,
-    address: wallet.address,
-    chain: config.chain || "base"
-  };
-}
-async function createCDPX402Client(config) {
-  const { CDPWallet: CDPWallet2 } = await Promise.resolve().then(() => (init_cdp(), cdp_exports));
-  const wallet = new CDPWallet2({
-    chain: config.chain,
-    storageDir: config.storageDir
-  });
-  const signer = await wallet.getViemAccount();
-  const { x402Client, wrapFetchWithPayment } = await import("@x402/fetch");
-  const { registerExactEvmScheme } = await import("@x402/evm/exact/client");
-  const client = new x402Client();
-  registerExactEvmScheme(client, { signer });
-  const fetchWithPayment = wrapFetchWithPayment(fetch, client);
-  return {
-    fetch: fetchWithPayment,
-    address: wallet.address,
-    chain: config.chain || "base"
-  };
-}
-async function createX402Client(config = {}) {
-  if (!isX402Available()) {
-    throw new Error("x402 packages not installed. Run: npm install @x402/fetch @x402/evm");
-  }
-  if (config.useCDP) {
-    return createCDPX402Client(config);
-  } else {
-    return createLocalX402Client(config);
-  }
-}
-async function x402Fetch(input, init, config) {
-  const client = await createX402Client(config);
-  return client.fetch(input, init);
-}
-var init_client = __esm({
-  "src/x402/client.ts"() {
-    "use strict";
-  }
-});
-
-// src/cli.ts
-import { Command } from "commander";
-
-// src/agent/PaymentAgent.ts
-init_chains();
-import { ethers } from "ethers";
-var PaymentAgent = class _PaymentAgent {
-  chain;
-  chainConfig;
-  walletAddress;
-  provider;
-  usdcContract;
-  static PROTOCOL_VERSION = "1.0";
-  constructor(config = {}) {
-    this.chain = config.chain || "base_sepolia";
-    this.chainConfig = getChain(this.chain);
-    this.walletAddress = config.walletAddress || process.env.PAYMENT_AGENT_WALLET || "";
-    if (!this.walletAddress) {
-      throw new Error("walletAddress is required. Set via config or PAYMENT_AGENT_WALLET env var.");
-    }
-    const rpcUrl = config.rpcUrl || this.chainConfig.rpc;
-    this.provider = new ethers.JsonRpcProvider(rpcUrl);
-    this.usdcContract = new ethers.Contract(
-      this.chainConfig.usdc,
-      ERC20_ABI,
-      this.provider
-    );
-  }
-  /**
-   * Generate payment request（Invoice）
-   */
-  createInvoice(params) {
-    const expiresMinutes = params.expiresMinutes || 30;
-    const expiresAt = new Date(Date.now() + expiresMinutes * 60 * 1e3).toISOString();
-    const invoice = {
-      type: "payment_request",
-      version: _PaymentAgent.PROTOCOL_VERSION,
-      order_id: params.orderId,
-      service: params.service,
-      description: params.description || `${params.service} service`,
-      amount: params.amount.toFixed(2),
-      token: "USDC",
-      chain: this.chain,
-      chain_id: this.chainConfig.chainId,
-      recipient: this.walletAddress,
-      memo: params.orderId,
-      expires_at: expiresAt,
-      deep_link: this.generateDeepLink(params.amount, params.orderId),
-      explorer_url: `${this.chainConfig.explorer}${this.walletAddress}`
-    };
-    if (params.metadata) {
-      invoice.metadata = params.metadata;
-    }
-    return invoice;
-  }
-  /**
-   * Generate wallet deep link（supports MetaMask etc）
-   */
-  generateDeepLink(amount, memo) {
-    const amountWei = Math.floor(amount * 1e6);
-    return `https://metamask.app.link/send/${this.chainConfig.usdc}@${this.chainConfig.chainId}/transfer?address=${this.walletAddress}&uint256=${amountWei}`;
-  }
-  /**
-   * Verify on-chain payment
-   */
-  async verifyPayment(txHash, options = {}) {
-    try {
-      if (!txHash.startsWith("0x")) {
-        txHash = "0x" + txHash;
-      }
-      const receipt = await this.provider.getTransactionReceipt(txHash);
-      if (!receipt) {
-        return { verified: false, error: "Transaction not found", pending: true };
-      }
-      if (receipt.status !== 1) {
-        return { verified: false, error: "Transaction failed" };
-      }
-      const transferTopic = ethers.id("Transfer(address,address,uint256)");
-      const usdcAddress = this.chainConfig.usdc.toLowerCase();
-      for (const log of receipt.logs) {
-        if (log.address.toLowerCase() === usdcAddress && log.topics.length >= 3 && log.topics[0] === transferTopic) {
-          const from = ethers.getAddress("0x" + log.topics[1].slice(-40));
-          const to = ethers.getAddress("0x" + log.topics[2].slice(-40));
-          const amountWei = BigInt(log.data);
-          const amount = Number(amountWei) / 1e6;
-          if (to.toLowerCase() !== this.walletAddress.toLowerCase()) {
-            continue;
-          }
-          const tolerance = options.tolerance ?? 0.01;
-          if (options.expectedAmount) {
-            const diff = Math.abs(amount - options.expectedAmount);
-            if (diff > options.expectedAmount * tolerance) {
-              return {
-                verified: false,
-                error: `Amount mismatch: expected ${options.expectedAmount}, got ${amount}`
-              };
-            }
-          }
-          const currentBlock = await this.provider.getBlockNumber();
-          return {
-            verified: true,
-            tx_hash: txHash,
-            amount: amount.toFixed(2),
-            token: "USDC",
-            from,
-            to,
-            block_number: receipt.blockNumber,
-            confirmations: currentBlock - receipt.blockNumber,
-            explorer_url: `${this.chainConfig.explorerTx}${txHash}`
-          };
-        }
-      }
-      return { verified: false, error: "No USDC transfer to recipient found in transaction" };
-    } catch (error) {
-      return { verified: false, error: error.message };
-    }
-  }
-  /**
-   * Scan recent transfers (match by amount)
-   */
-  async scanRecentTransfers(expectedAmount, timeoutMinutes = 30) {
-    try {
-      const currentBlock = await this.provider.getBlockNumber();
-      const blocksPerMinute = Math.ceil(60 / this.chainConfig.avgBlockTime);
-      const fromBlock = currentBlock - timeoutMinutes * blocksPerMinute;
-      const transferTopic = ethers.id("Transfer(address,address,uint256)");
-      const recipientTopic = ethers.zeroPadValue(this.walletAddress, 32);
-      const logs = await this.provider.getLogs({
-        address: this.chainConfig.usdc,
-        topics: [transferTopic, null, recipientTopic],
-        fromBlock,
-        toBlock: "latest"
-      });
-      for (const log of logs) {
-        const amountWei = BigInt(log.data);
-        const amount = Number(amountWei) / 1e6;
-        if (Math.abs(amount - expectedAmount) < 0.01) {
-          const from = ethers.getAddress("0x" + log.topics[1].slice(-40));
-          return {
-            verified: true,
-            tx_hash: log.transactionHash,
-            amount: amount.toFixed(2),
-            token: "USDC",
-            from,
-            to: this.walletAddress,
-            block_number: log.blockNumber,
-            explorer_url: `${this.chainConfig.explorerTx}${log.transactionHash}`
-          };
-        }
-      }
-      return { verified: false, error: "No matching payment found" };
-    } catch (error) {
-      return { verified: false, error: error.message };
-    }
-  }
-  /**
-   * Get wallet balance
-   */
-  async getBalance(address) {
-    const addr = address || this.walletAddress;
-    const [ethBalance, usdcBalance] = await Promise.all([
-      this.provider.getBalance(addr),
-      this.usdcContract.balanceOf(addr)
-    ]);
-    return {
-      address: addr,
-      eth: ethers.formatEther(ethBalance),
-      usdc: (Number(usdcBalance) / 1e6).toFixed(2),
-      chain: this.chain
-    };
-  }
-  /**
-   * Format Invoice as human-readable message
-   */
-  formatInvoiceMessage(invoice, includeJson = true) {
-    let msg = `\u{1F3AC} **Payment Request**
-
-**Service:** ${invoice.service}
-**Price:** ${invoice.amount} USDC (${this.chainConfig.name})
-
-**\u{1F4B3} Payment Options:**
-
-1\uFE0F\u20E3 **Direct Transfer:**
-   Send exactly \`${invoice.amount} USDC\` to:
-   \`${invoice.recipient}\`
-   (Network: ${this.chainConfig.name})
-
-2\uFE0F\u20E3 **One-Click Pay (MetaMask):**
-   ${invoice.deep_link}
-
-\u23F1\uFE0F Expires: ${invoice.expires_at}`;
-    if (includeJson) {
-      msg += `
-
-3\uFE0F\u20E3 **For AI Agents:**
-\`\`\`json
-${JSON.stringify(invoice, null, 2)}
-\`\`\``;
-    }
-    msg += `
-
-After payment, reply with your tx hash:
-\`paid: 0x...\``;
-    return msg;
-  }
-};
-
-// src/index.ts
-init_AgentWallet();
-
-// src/wallet/Wallet.ts
-init_chains();
-import { ethers as ethers3 } from "ethers";
-var Wallet = class {
-  chain;
-  chainConfig;
-  address;
-  wallet;
-  provider;
-  usdcContract;
-  constructor(config = {}) {
-    this.chain = config.chain || "base_sepolia";
-    this.chainConfig = getChain(this.chain);
-    const privateKey = config.privateKey || process.env.PAYMENT_AGENT_PRIVATE_KEY;
-    if (!privateKey) {
-      throw new Error("privateKey is required. Set via config or PAYMENT_AGENT_PRIVATE_KEY env var.");
-    }
-    const rpcUrl = config.rpcUrl || this.chainConfig.rpc;
-    this.provider = new ethers3.JsonRpcProvider(rpcUrl);
-    this.wallet = new ethers3.Wallet(privateKey, this.provider);
-    this.address = this.wallet.address;
-    this.usdcContract = new ethers3.Contract(
-      this.chainConfig.usdc,
-      ERC20_ABI,
-      this.wallet
-    );
-  }
-  /**
-   * Get wallet balance
-   */
-  async getBalance() {
-    const [ethBalance, usdcBalance] = await Promise.all([
-      this.provider.getBalance(this.address),
-      this.usdcContract.balanceOf(this.address)
-    ]);
-    return {
-      address: this.address,
-      eth: ethers3.formatEther(ethBalance),
-      usdc: (Number(usdcBalance) / 1e6).toFixed(2),
-      chain: this.chain
-    };
-  }
-  /**
-   * Send USDC transfer
-   */
-  async transfer(to, amount) {
-    try {
-      to = ethers3.getAddress(to);
-      const amountWei = BigInt(Math.floor(amount * 1e6));
-      const balance = await this.usdcContract.balanceOf(this.address);
-      if (BigInt(balance) < amountWei) {
-        return {
-          success: false,
-          error: `Insufficient USDC balance: ${Number(balance) / 1e6} < ${amount}`
-        };
-      }
-      const tx = await this.usdcContract.transfer(to, amountWei);
-      const receipt = await tx.wait();
-      if (receipt.status === 1) {
-        return {
-          success: true,
-          tx_hash: tx.hash,
-          from: this.address,
-          to,
-          amount,
-          gas_used: Number(receipt.gasUsed),
-          block_number: receipt.blockNumber,
-          explorer_url: `${this.chainConfig.explorerTx}${tx.hash}`
-        };
-      } else {
-        return {
-          success: false,
-          tx_hash: tx.hash,
-          error: "Transaction reverted"
-        };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-  /**
-   * Get ETH balance
-   */
-  async getEthBalance() {
-    const balance = await this.provider.getBalance(this.address);
-    return ethers3.formatEther(balance);
-  }
-  /**
-   * Get USDC balance
-   */
-  async getUsdcBalance() {
-    const balance = await this.usdcContract.balanceOf(this.address);
-    return (Number(balance) / 1e6).toFixed(2);
-  }
-};
-
-// src/audit/AuditLog.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as crypto from "crypto";
-var AuditLog = class {
-  basePath;
-  lastHash = "0000000000000000";
-  constructor(basePath) {
-    this.basePath = basePath || path2.join(process.cwd(), "data", "audit");
-    this.ensureDir();
-    this.loadLastHash();
-  }
-  /**
-   * Record audit log
-   */
-  async log(params) {
-    const now = /* @__PURE__ */ new Date();
-    const entry = {
-      timestamp: now.getTime() / 1e3,
-      datetime: now.toISOString(),
-      action: params.action,
-      request_id: params.request_id,
-      from: params.from,
-      to: params.to,
-      amount: params.amount,
-      tx_hash: params.tx_hash,
-      reason: params.reason,
-      requester: params.requester,
-      prev_hash: this.lastHash,
-      hash: "",
-      // Filled after calculation
-      metadata: params.metadata
-    };
-    entry.hash = this.calculateHash(entry);
-    this.lastHash = entry.hash;
-    const filePath = this.getFilePath(now);
-    const line = JSON.stringify(entry) + "\n";
-    fs2.appendFileSync(filePath, line, "utf-8");
-    return entry;
-  }
-  /**
-   * Read logs for specified date
-   */
-  read(date) {
-    const filePath = this.getFilePath(date || /* @__PURE__ */ new Date());
-    if (!fs2.existsSync(filePath)) {
-      return [];
-    }
-    const content = fs2.readFileSync(filePath, "utf-8");
-    const lines = content.trim().split("\n").filter(Boolean);
-    return lines.map((line) => JSON.parse(line));
-  }
-  /**
-   * Verify log integrity
-   */
-  verify(date) {
-    const entries = this.read(date);
-    const errors = [];
-    for (let i = 0; i < entries.length; i++) {
-      const entry = entries[i];
-      const expectedHash = this.calculateHash(entry);
-      if (entry.hash !== expectedHash) {
-        errors.push(`Entry ${i}: hash mismatch (expected ${expectedHash}, got ${entry.hash})`);
-      }
-      if (i > 0 && entry.prev_hash !== entries[i - 1].hash) {
-        errors.push(`Entry ${i}: prev_hash mismatch`);
-      }
-    }
-    return { valid: errors.length === 0, errors };
-  }
-  /**
-   * Search logs
-   */
-  search(filter) {
-    const results = [];
-    const startDate = filter.startDate || new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3);
-    const endDate = filter.endDate || /* @__PURE__ */ new Date();
-    const current = new Date(startDate);
-    while (current <= endDate) {
-      const entries = this.read(current);
-      for (const entry of entries) {
-        let match = true;
-        if (filter.action && entry.action !== filter.action) match = false;
-        if (filter.request_id && entry.request_id !== filter.request_id) match = false;
-        if (filter.from && entry.from?.toLowerCase() !== filter.from.toLowerCase()) match = false;
-        if (filter.to && entry.to?.toLowerCase() !== filter.to.toLowerCase()) match = false;
-        if (match) {
-          results.push(entry);
-        }
-      }
-      current.setDate(current.getDate() + 1);
-    }
-    return results;
-  }
-  /**
-   * Get log file path
-   */
-  getFilePath(date) {
-    const dateStr = date.toISOString().slice(0, 10);
-    return path2.join(this.basePath, `audit_${dateStr}.jsonl`);
-  }
-  /**
-   * Calculate entry hash
-   */
-  calculateHash(entry) {
-    const data = {
-      timestamp: entry.timestamp,
-      action: entry.action,
-      request_id: entry.request_id,
-      from: entry.from,
-      to: entry.to,
-      amount: entry.amount,
-      tx_hash: entry.tx_hash,
-      prev_hash: entry.prev_hash
-    };
-    const str = JSON.stringify(data);
-    return crypto.createHash("sha256").update(str).digest("hex").slice(0, 16);
-  }
-  /**
-   * Load last log entry hash
-   */
-  loadLastHash() {
-    const today = /* @__PURE__ */ new Date();
-    for (let i = 0; i < 2; i++) {
-      const date = new Date(today);
-      date.setDate(date.getDate() - i);
-      const entries = this.read(date);
-      if (entries.length > 0) {
-        this.lastHash = entries[entries.length - 1].hash;
-        return;
-      }
-    }
-  }
-  /**
-   * Ensure directory exists
-   */
-  ensureDir() {
-    if (!fs2.existsSync(this.basePath)) {
-      fs2.mkdirSync(this.basePath, { recursive: true });
-    }
-  }
-};
-
-// src/wallet/SecureWallet.ts
-var DEFAULT_LIMITS = {
-  singleMax: 100,
-  // Single max $100
-  dailyMax: 1e3,
-  // Daily max $1000
-  requireWhitelist: true
-};
-var SecureWallet = class {
-  wallet;
-  limits;
-  whitelist;
-  auditLog;
-  dailyTotal = 0;
-  dailyDate = "";
-  pendingTransfers = /* @__PURE__ */ new Map();
-  constructor(config = {}) {
-    this.wallet = new Wallet({
-      chain: config.chain,
-      privateKey: config.privateKey
-    });
-    this.limits = { ...DEFAULT_LIMITS, ...config.limits };
-    this.whitelist = new Set((config.whitelist || []).map((a) => a.toLowerCase()));
-    this.auditLog = new AuditLog(config.auditPath);
-  }
-  /**
-   * Get wallet address
-   */
-  get address() {
-    return this.wallet.address;
-  }
-  /**
-   * Get balance
-   */
-  async getBalance() {
-    return this.wallet.getBalance();
-  }
-  /**
-   * Secure transfer (with limit and whitelist checks)
-   * 
-   * Supports two calling methods:
-   * - transfer({ to, amount, reason?, requester? })
-   * - transfer(to, amount)
-   */
-  async transfer(paramsOrTo, amountArg) {
-    let params;
-    if (typeof paramsOrTo === "string") {
-      params = {
-        to: paramsOrTo,
-        amount: typeof amountArg === "string" ? parseFloat(amountArg) : amountArg || 0
-      };
-    } else {
-      params = paramsOrTo;
-    }
-    const { to, amount, reason, requester } = params;
-    const toAddress = to.toLowerCase();
-    const requestId = `tr_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
-    await this.auditLog.log({
-      action: "transfer_request",
-      request_id: requestId,
-      from: this.wallet.address,
-      to,
-      amount,
-      reason,
-      requester
-    });
-    if (this.limits.requireWhitelist && !this.whitelist.has(toAddress)) {
-      await this.auditLog.log({
-        action: "transfer_failed",
-        request_id: requestId,
-        metadata: { error: "Address not in whitelist" }
-      });
-      return { success: false, error: `Address not in whitelist: ${to}` };
-    }
-    if (amount > this.limits.singleMax) {
-      const pending = {
-        id: requestId,
-        to,
-        amount,
-        reason,
-        requester,
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        status: "pending"
-      };
-      this.pendingTransfers.set(requestId, pending);
-      await this.auditLog.log({
-        action: "transfer_request",
-        request_id: requestId,
-        metadata: { pending: true, reason: "Exceeds single limit" }
-      });
-      return {
-        success: false,
-        error: `Amount ${amount} exceeds single limit ${this.limits.singleMax}. Pending approval: ${requestId}`
-      };
-    }
-    this.updateDailyTotal();
-    if (this.dailyTotal + amount > this.limits.dailyMax) {
-      const pending = {
-        id: requestId,
-        to,
-        amount,
-        reason,
-        requester,
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        status: "pending"
-      };
-      this.pendingTransfers.set(requestId, pending);
-      await this.auditLog.log({
-        action: "transfer_request",
-        request_id: requestId,
-        metadata: { pending: true, reason: "Exceeds daily limit" }
-      });
-      return {
-        success: false,
-        error: `Daily limit would be exceeded (${this.dailyTotal} + ${amount} > ${this.limits.dailyMax}). Pending approval: ${requestId}`
-      };
-    }
-    const result = await this.wallet.transfer(to, amount);
-    if (result.success) {
-      this.dailyTotal += amount;
-      await this.auditLog.log({
-        action: "transfer_executed",
-        request_id: requestId,
-        from: this.wallet.address,
-        to,
-        amount,
-        tx_hash: result.tx_hash,
-        reason,
-        requester
-      });
-    } else {
-      await this.auditLog.log({
-        action: "transfer_failed",
-        request_id: requestId,
-        metadata: { error: result.error }
-      });
-    }
-    return result;
-  }
-  /**
-   * Approve pending transfer
-   */
-  async approve(requestId, approver) {
-    const pending = this.pendingTransfers.get(requestId);
-    if (!pending) {
-      return { success: false, error: `Pending transfer not found: ${requestId}` };
-    }
-    if (pending.status !== "pending") {
-      return { success: false, error: `Transfer already ${pending.status}` };
-    }
-    await this.auditLog.log({
-      action: "transfer_approved",
-      request_id: requestId,
-      metadata: { approver }
-    });
-    pending.status = "approved";
-    const result = await this.wallet.transfer(pending.to, pending.amount);
-    if (result.success) {
-      pending.status = "executed";
-      this.dailyTotal += pending.amount;
-      await this.auditLog.log({
-        action: "transfer_executed",
-        request_id: requestId,
-        from: this.wallet.address,
-        to: pending.to,
-        amount: pending.amount,
-        tx_hash: result.tx_hash,
-        reason: pending.reason,
-        requester: pending.requester,
-        metadata: { approved_by: approver }
-      });
-    } else {
-      await this.auditLog.log({
-        action: "transfer_failed",
-        request_id: requestId,
-        metadata: { error: result.error }
-      });
-    }
-    return result;
-  }
-  /**
-   * Reject pending transfer
-   */
-  async reject(requestId, rejecter, reason) {
-    const pending = this.pendingTransfers.get(requestId);
-    if (!pending) {
-      throw new Error(`Pending transfer not found: ${requestId}`);
-    }
-    pending.status = "rejected";
-    await this.auditLog.log({
-      action: "transfer_rejected",
-      request_id: requestId,
-      metadata: { rejected_by: rejecter, reason }
-    });
-  }
-  /**
-   * Add to whitelist
-   */
-  async addToWhitelist(address, addedBy) {
-    const addr = address.toLowerCase();
-    this.whitelist.add(addr);
-    await this.auditLog.log({
-      action: "whitelist_add",
-      request_id: `wl_${Date.now()}`,
-      to: address,
-      metadata: { added_by: addedBy }
-    });
-  }
-  /**
-   * Remove from whitelist
-   */
-  async removeFromWhitelist(address, removedBy) {
-    const addr = address.toLowerCase();
-    this.whitelist.delete(addr);
-    await this.auditLog.log({
-      action: "whitelist_remove",
-      request_id: `wl_${Date.now()}`,
-      to: address,
-      metadata: { removed_by: removedBy }
-    });
-  }
-  /**
-   * Check if address is whitelisted
-   */
-  isWhitelisted(address) {
-    return this.whitelist.has(address.toLowerCase());
-  }
-  /**
-   * Get pending transfers list
-   */
-  getPendingTransfers() {
-    return Array.from(this.pendingTransfers.values()).filter((p) => p.status === "pending");
-  }
-  /**
-   * Get current limit config
-   */
-  getLimits() {
-    return { ...this.limits };
-  }
-  /**
-   * Get daily used amount
-   */
-  getDailyUsed() {
-    this.updateDailyTotal();
-    return this.dailyTotal;
-  }
-  /**
-   * Update daily limit counter
-   */
-  updateDailyTotal() {
-    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    if (this.dailyDate !== today) {
-      this.dailyDate = today;
-      this.dailyTotal = 0;
-    }
-  }
-};
-
-// src/wallet/createWallet.ts
-import { ethers as ethers4 } from "ethers";
-import { join as join3, dirname } from "path";
-var DEFAULT_STORAGE_DIR = join3(process.env.HOME || "~", ".moltspay");
-
-// src/wallet/PermitWallet.ts
-init_chains();
-import { ethers as ethers5 } from "ethers";
-var PERMIT_ABI2 = [
-  ...ERC20_ABI,
-  "function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)",
-  "function transferFrom(address from, address to, uint256 amount) returns (bool)",
-  "function allowance(address owner, address spender) view returns (uint256)"
-];
-
-// src/wallet/signPermit.ts
-init_chains();
-import { ethers as ethers6 } from "ethers";
-
-// src/wallet/AllowanceWallet.ts
-init_chains();
-import { ethers as ethers7 } from "ethers";
-var PERMIT_ABI3 = [
-  ...ERC20_ABI,
-  "function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)",
-  "function transferFrom(address from, address to, uint256 amount) returns (bool)",
-  "function allowance(address owner, address spender) view returns (uint256)",
-  "function nonces(address owner) view returns (uint256)"
-];
-
-// src/permit/Permit.ts
-init_chains();
-import { ethers as ethers8 } from "ethers";
-
-// src/verify/index.ts
-init_chains();
-import { ethers as ethers9 } from "ethers";
-var TRANSFER_EVENT_TOPIC = ethers9.id("Transfer(address,address,uint256)");
-
-// src/receipt/index.ts
-init_chains();
-
-// src/templates/index.ts
-init_chains();
-
-// src/index.ts
-init_chains();
-
-// src/x402/index.ts
-init_client();
-init_chains();
-import { ethers as ethers10 } from "ethers";
-
-// src/index.ts
-init_cdp();
-
-// src/cli.ts
-var program = new Command();
-program.name("payment-agent").description("Blockchain payment infrastructure for AI Agents").version("0.1.0");
-program.command("balance").description("Get wallet balance").option("-c, --chain <chain>", "Chain name", "base_sepolia").option("-a, --address <address>", "Wallet address").action(async (options) => {
-  try {
-    const agent = new PaymentAgent({
-      chain: options.chain,
-      walletAddress: options.address || process.env.PAYMENT_AGENT_WALLET
-    });
-    const balance = await agent.getBalance();
-    console.log(JSON.stringify(balance, null, 2));
-  } catch (error) {
-    console.error("Error:", error.message);
-    process.exit(1);
-  }
-});
-program.command("invoice").description("Generate payment invoice").requiredOption("-o, --order <orderId>", "Order ID").requiredOption("-a, --amount <amount>", "Amount in USDC").option("-s, --service <service>", "Service type", "payment").option("-c, --chain <chain>", "Chain name", "base_sepolia").option("--json", "Output raw JSON").action(async (options) => {
-  try {
-    const agent = new PaymentAgent({
-      chain: options.chain,
-      walletAddress: process.env.PAYMENT_AGENT_WALLET
-    });
-    const invoice = agent.createInvoice({
-      orderId: options.order,
-      amount: parseFloat(options.amount),
-      service: options.service
-    });
-    if (options.json) {
-      console.log(JSON.stringify(invoice, null, 2));
-    } else {
-      console.log(agent.formatInvoiceMessage(invoice));
-    }
-  } catch (error) {
-    console.error("Error:", error.message);
-    process.exit(1);
-  }
-});
-program.command("verify").description("Verify a payment transaction").requiredOption("-t, --tx <txHash>", "Transaction hash").option("-a, --amount <amount>", "Expected amount").option("-c, --chain <chain>", "Chain name", "base_sepolia").action(async (options) => {
-  try {
-    const agent = new PaymentAgent({
-      chain: options.chain,
-      walletAddress: process.env.PAYMENT_AGENT_WALLET
-    });
-    const result = await agent.verifyPayment(options.tx, {
-      expectedAmount: options.amount ? parseFloat(options.amount) : void 0
-    });
-    console.log(JSON.stringify(result, null, 2));
-    process.exit(result.verified ? 0 : 1);
-  } catch (error) {
-    console.error("Error:", error.message);
-    process.exit(1);
-  }
-});
-program.command("transfer").description("Transfer USDC (requires private key)").requiredOption("--to <address>", "Recipient address").requiredOption("-a, --amount <amount>", "Amount in USDC").option("-r, --reason <reason>", "Transfer reason").option("-c, --chain <chain>", "Chain name", "base_sepolia").option("--secure", "Use secure wallet with limits").action(async (options) => {
-  try {
-    if (options.secure) {
-      const wallet = new SecureWallet({ chain: options.chain });
-      const result = await wallet.transfer({
-        to: options.to,
-        amount: parseFloat(options.amount),
-        reason: options.reason
-      });
-      console.log(JSON.stringify(result, null, 2));
-      process.exit(result.success ? 0 : 1);
-    } else {
-      const wallet = new Wallet({ chain: options.chain });
-      const result = await wallet.transfer(options.to, parseFloat(options.amount));
-      console.log(JSON.stringify(result, null, 2));
-      process.exit(result.success ? 0 : 1);
-    }
-  } catch (error) {
-    console.error("Error:", error.message);
-    process.exit(1);
-  }
-});
-program.command("chains").description("List supported chains").action(() => {
-  const chains = listChains();
-  console.log("Supported chains:");
-  for (const name of chains) {
-    const config = CHAINS[name];
-    console.log(`  ${name}: ${config.name} (chainId: ${config.chainId})`);
-  }
-});
-program.command("init").description("Initialize agent wallet").option("-c, --chain <chain>", "Chain name", "base").option("-d, --dir <directory>", "Storage directory", "~/.moltspay").option("--cdp", "Use CDP (Coinbase Developer Platform) wallet").option("--local", "Use local wallet (default)").action(async (options) => {
-  const storageDir = options.dir.replace("~", process.env.HOME || ".");
-  if (options.cdp) {
-    const { initCDPWallet: initCDPWallet2 } = await Promise.resolve().then(() => (init_cdp(), cdp_exports));
-    console.log("\u{1F504} Initializing CDP wallet...");
-    const result = await initCDPWallet2({
-      chain: options.chain,
-      storageDir
-    });
-    if (!result.success) {
-      console.error("\u274C Failed:", result.error);
-      console.log("");
-      console.log("To use CDP wallet, set these environment variables:");
-      console.log("  export CDP_API_KEY_ID=your-key-id");
-      console.log("  export CDP_API_KEY_SECRET=your-key-secret");
-      console.log("  export CDP_WALLET_SECRET=your-wallet-secret  # optional");
-      console.log("");
-      console.log("Get credentials at: https://cdp.coinbase.com/");
-      process.exit(1);
-    }
-    console.log("\u2705 CDP wallet initialized");
-    console.log(`   Address: ${result.address}`);
-    console.log(`   Chain: ${options.chain}`);
-    console.log(`   Storage: ${result.storagePath}`);
-    console.log(`   New wallet: ${result.isNew ? "Yes" : "No (loaded existing)"}`);
-    console.log("");
-    console.log("Next steps:");
-    console.log(`  1. Fund your wallet: Send USDC to ${result.address}`);
-    console.log("  2. Use x402 to pay for services automatically");
-    console.log("");
-    console.log("Example:");
-    console.log('  import { createX402Client } from "moltspay/x402";');
-    console.log('  const client = await createX402Client({ chain: "base", useCDP: true });');
-    console.log('  const response = await client.fetch("https://api.example.com/paid-resource");');
-  } else {
-    const { AgentWallet: AgentWallet2 } = await Promise.resolve().then(() => (init_AgentWallet(), AgentWallet_exports));
-    const wallet = new AgentWallet2({
-      chain: options.chain,
-      storageDir
-    });
-    console.log("\u2705 Local wallet initialized");
-    console.log(`   Address: ${wallet.address}`);
-    console.log(`   Chain: ${options.chain}`);
-    console.log(`   Storage: ${storageDir}`);
-    console.log("");
-    console.log("Next steps:");
-    console.log(`  1. Fund your wallet: Send USDC to ${wallet.address}`);
-    console.log(`  2. Send a small amount of ETH for gas (~0.001 ETH)`);
-    console.log("");
-    console.log("Or use Permit (no gas needed):");
-    console.log(`  npx moltspay auth-request --owner <OWNER_ADDRESS> --amount <USDC_AMOUNT>`);
-  }
-});
-program.command("auth-request").description("Generate authorization request for Owner").requiredOption("-o, --owner <address>", "Owner wallet address (e.g., MetaMask)").requiredOption("-a, --amount <amount>", "Amount in USDC to authorize").option("-c, --chain <chain>", "Chain name", "base").option("-e, --expires <hours>", "Expiration in hours", "168").option("--json", "Output as JSON").action(async (options) => {
-  const { AgentWallet: AgentWallet2 } = await Promise.resolve().then(() => (init_AgentWallet(), AgentWallet_exports));
-  const wallet = new AgentWallet2({ chain: options.chain });
-  const request = await wallet.generateAuthRequest({
-    ownerAddress: options.owner,
-    amount: parseFloat(options.amount),
-    expiresInHours: parseInt(options.expires)
-  });
-  if (options.json) {
-    console.log(JSON.stringify({
-      agentAddress: wallet.address,
-      typedData: request.typedData,
-      cliCommand: request.cliCommand
-    }, null, 2));
-  } else {
-    console.log(request.message);
-  }
-});
-program.command("sign-permit").description("Sign a permit (Owner uses this to authorize Agent)").requiredOption("-o, --owner <address>", "Owner address").requiredOption("-s, --spender <address>", "Spender address (Agent)").requiredOption("-a, --amount <amount>", "Amount in USDC").requiredOption("-d, --deadline <timestamp>", "Deadline timestamp").requiredOption("-n, --nonce <nonce>", "Nonce from contract").option("-c, --chain <chain>", "Chain name", "base").option("-k, --private-key <key>", "Private key (or set OWNER_PRIVATE_KEY env)").action(async (options) => {
-  const { ethers: ethers11 } = await import("ethers");
-  const { getChain: getChain2 } = await Promise.resolve().then(() => (init_chains(), chains_exports));
-  const privateKey = options.privateKey || process.env.OWNER_PRIVATE_KEY;
-  if (!privateKey) {
-    console.error("Error: Private key required. Use --private-key or set OWNER_PRIVATE_KEY env");
-    process.exit(1);
-  }
-  const chainConfig = getChain2(options.chain);
-  const wallet = new ethers11.Wallet(privateKey);
-  if (wallet.address.toLowerCase() !== options.owner.toLowerCase()) {
-    console.error(`Error: Private key doesn't match owner address`);
-    console.error(`  Expected: ${options.owner}`);
-    console.error(`  Got: ${wallet.address}`);
-    process.exit(1);
-  }
-  const value = BigInt(Math.floor(parseFloat(options.amount) * 1e6)).toString();
-  const domain = {
-    name: "USD Coin",
-    version: "2",
-    chainId: chainConfig.chainId,
-    verifyingContract: chainConfig.usdc
-  };
-  const types = {
-    Permit: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" },
-      { name: "value", type: "uint256" },
-      { name: "nonce", type: "uint256" },
-      { name: "deadline", type: "uint256" }
-    ]
-  };
-  const message = {
-    owner: options.owner,
-    spender: options.spender,
-    value,
-    nonce: parseInt(options.nonce),
-    deadline: parseInt(options.deadline)
-  };
-  const signature = await wallet.signTypedData(domain, types, message);
-  const sig = ethers11.Signature.from(signature);
-  const permit = {
-    owner: options.owner,
-    value,
-    deadline: parseInt(options.deadline),
-    nonce: parseInt(options.nonce),
-    v: sig.v,
-    r: sig.r,
-    s: sig.s
-  };
-  console.log("\u2705 Permit signed successfully!");
-  console.log("");
-  console.log("Send this to your Agent:");
-  console.log(JSON.stringify(permit, null, 2));
-});
-program.command("spend").description("Spend USDC from Owner wallet (requires permit)").requiredOption("--to <address>", "Recipient address").requiredOption("-a, --amount <amount>", "Amount in USDC").option("-c, --chain <chain>", "Chain name", "base").option("-p, --permit <json>", "Permit JSON (or stored permit is used)").action(async (options) => {
-  const { AgentWallet: AgentWallet2 } = await Promise.resolve().then(() => (init_AgentWallet(), AgentWallet_exports));
-  const wallet = new AgentWallet2({ chain: options.chain });
-  let permit;
-  if (options.permit) {
-    permit = JSON.parse(options.permit);
-  }
-  console.log(`Spending ${options.amount} USDC to ${options.to}...`);
-  const result = await wallet.spend(options.to, parseFloat(options.amount), permit);
-  console.log(JSON.stringify(result, null, 2));
-  process.exit(result.success ? 0 : 1);
-});
-program.command("x402").description("Make HTTP request with automatic x402 payment").argument("<url>", "URL to request").option("-X, --method <method>", "HTTP method", "GET").option("-d, --data <json>", "Request body (JSON)").option("-i, --image <path>", "Image file to include (reads file and sends as base64)").option("-H, --header <header...>", "Additional headers (key:value)").option("-c, --chain <chain>", "Chain name", "base").option("--cdp", "Use CDP wallet").option("-o, --output <file>", "Save response to file").option("-v, --verbose", "Show payment details").action(async (url, options) => {
-  const { createX402Client: createX402Client2, isX402Available: isX402Available2 } = await Promise.resolve().then(() => (init_client(), client_exports));
-  if (!isX402Available2()) {
-    console.error("\u274C x402 packages not installed.");
-    console.error("");
-    console.error("Install them with:");
-    console.error("  npm install @x402/fetch @x402/evm viem");
-    process.exit(1);
-  }
-  try {
-    if (options.verbose) {
-      console.error(`\u{1F504} Initializing x402 client (chain: ${options.chain})...`);
-    }
-    const client = await createX402Client2({
-      chain: options.chain,
-      useCDP: options.cdp
-    });
-    if (options.verbose) {
-      console.error(`   Wallet: ${client.address}`);
-      console.error(`   Chain: ${client.chain}`);
-      console.error("");
-    }
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (options.header) {
-      for (const h of options.header) {
-        const [key, ...valueParts] = h.split(":");
-        headers[key.trim()] = valueParts.join(":").trim();
-      }
-    }
-    const init = {
-      method: options.method.toUpperCase(),
-      headers
-    };
-    let bodyData = {};
-    if (options.data) {
-      try {
-        bodyData = JSON.parse(options.data);
-      } catch {
-        bodyData = { data: options.data };
-      }
-    }
-    if (options.image) {
-      const fs4 = await import("fs");
-      const path4 = await import("path");
-      const imagePath = path4.resolve(options.image);
-      if (!fs4.existsSync(imagePath)) {
-        console.error(`\u274C Image file not found: ${imagePath}`);
-        process.exit(1);
-      }
-      const imageBuffer = fs4.readFileSync(imagePath);
-      const imageBase64 = imageBuffer.toString("base64");
-      if (options.verbose) {
-        console.error(`\u{1F4F7} Image: ${imagePath} (${Math.round(imageBuffer.length / 1024)}KB)`);
-      }
-      bodyData.image_base64 = imageBase64;
-    }
-    if (["POST", "PUT", "PATCH"].includes(init.method) && Object.keys(bodyData).length > 0) {
-      init.body = JSON.stringify(bodyData);
-    }
-    if (options.verbose) {
-      console.error(`\u{1F4E4} ${init.method} ${url}`);
-      if (options.data) {
-        console.error(`   Body: ${options.data.substring(0, 100)}${options.data.length > 100 ? "..." : ""}`);
-      }
-      console.error("");
-    }
-    const response = await client.fetch(url, init);
-    if (options.verbose) {
-      console.error(`\u{1F4E5} Response: ${response.status} ${response.statusText}`);
-      console.error("");
-    }
-    const contentType = response.headers.get("content-type") || "";
-    let body;
-    if (contentType.includes("application/json")) {
-      const json = await response.json();
-      body = JSON.stringify(json, null, 2);
-    } else {
-      body = await response.text();
-    }
-    if (options.output) {
-      const fs4 = await import("fs");
-      fs4.writeFileSync(options.output, body);
-      console.error(`\u2705 Saved to ${options.output}`);
-    } else {
-      console.log(body);
-    }
-    process.exit(response.ok ? 0 : 1);
-  } catch (error) {
-    console.error("\u274C Error:", error.message);
-    process.exit(1);
-  }
-});
-program.command("status").description("Show agent wallet status").option("-c, --chain <chain>", "Chain name", "base").option("-o, --owner <address>", "Check allowance from specific owner").action(async (options) => {
-  const { AgentWallet: AgentWallet2 } = await Promise.resolve().then(() => (init_AgentWallet(), AgentWallet_exports));
-  const wallet = new AgentWallet2({ chain: options.chain });
-  console.log("Agent Wallet Status");
-  console.log("==================");
-  console.log(`Address: ${wallet.address}`);
-  console.log(`Chain: ${options.chain}`);
-  console.log(`Gas balance: ${await wallet.getGasBalance()} ETH`);
-  console.log(`Has gas: ${await wallet.hasGas() ? "Yes \u2705" : "No \u274C (need ~0.0005 ETH)"}`);
-  if (options.owner) {
-    const allowance = await wallet.checkAllowance(options.owner);
-    console.log("");
-    console.log(`Allowance from ${options.owner}:`);
-    console.log(`  Allowance: ${allowance.allowance} USDC`);
-    console.log(`  Owner balance: ${allowance.ownerBalance} USDC`);
-    console.log(`  Can spend: ${allowance.canSpend ? "Yes \u2705" : "No \u274C"}`);
-  }
-});
-program.parse();
-//# sourceMappingURL=cli.mjs.map