moltspay 0.1.0

package/dist/cli.js

@@ -0,0 +1,881 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+
+// src/agent/PaymentAgent.ts
+var import_ethers = require("ethers");
+
+// src/chains/index.ts
+var CHAINS = {
+  // ============ 主网 ============
+  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
+  },
+  // ============ 测试网 ============
+  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
+  }
+};
+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);
+}
+var 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/PaymentAgent.ts
+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 import_ethers.ethers.JsonRpcProvider(rpcUrl);
+    this.usdcContract = new import_ethers.ethers.Contract(
+      this.chainConfig.usdc,
+      ERC20_ABI,
+      this.provider
+    );
+  }
+  /**
+   * 生成支付请求（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;
+  }
+  /**
+   * 生成钱包深度链接（支持 MetaMask 等）
+   */
+  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}`;
+  }
+  /**
+   * 验证链上支付
+   */
+  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 = import_ethers.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 = import_ethers.ethers.getAddress("0x" + log.topics[1].slice(-40));
+          const to = import_ethers.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 };
+    }
+  }
+  /**
+   * 扫描最近转账（按金额匹配）
+   */
+  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 = import_ethers.ethers.id("Transfer(address,address,uint256)");
+      const recipientTopic = import_ethers.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 = import_ethers.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 };
+    }
+  }
+  /**
+   * 获取钱包余额
+   */
+  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: import_ethers.ethers.formatEther(ethBalance),
+      usdc: (Number(usdcBalance) / 1e6).toFixed(2),
+      chain: this.chain
+    };
+  }
+  /**
+   * 格式化 Invoice 为人类可读消息
+   */
+  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/wallet/Wallet.ts
+var import_ethers2 = require("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 import_ethers2.ethers.JsonRpcProvider(rpcUrl);
+    this.wallet = new import_ethers2.ethers.Wallet(privateKey, this.provider);
+    this.address = this.wallet.address;
+    this.usdcContract = new import_ethers2.ethers.Contract(
+      this.chainConfig.usdc,
+      ERC20_ABI,
+      this.wallet
+    );
+  }
+  /**
+   * 获取钱包余额
+   */
+  async getBalance() {
+    const [ethBalance, usdcBalance] = await Promise.all([
+      this.provider.getBalance(this.address),
+      this.usdcContract.balanceOf(this.address)
+    ]);
+    return {
+      address: this.address,
+      eth: import_ethers2.ethers.formatEther(ethBalance),
+      usdc: (Number(usdcBalance) / 1e6).toFixed(2),
+      chain: this.chain
+    };
+  }
+  /**
+   * 发送 USDC 转账
+   */
+  async transfer(to, amount) {
+    try {
+      to = import_ethers2.ethers.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
+      };
+    }
+  }
+  /**
+   * 获取 ETH 余额
+   */
+  async getEthBalance() {
+    const balance = await this.provider.getBalance(this.address);
+    return import_ethers2.ethers.formatEther(balance);
+  }
+  /**
+   * 获取 USDC 余额
+   */
+  async getUsdcBalance() {
+    const balance = await this.usdcContract.balanceOf(this.address);
+    return (Number(balance) / 1e6).toFixed(2);
+  }
+};
+
+// src/audit/AuditLog.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var crypto = __toESM(require("crypto"));
+var AuditLog = class {
+  basePath;
+  lastHash = "0000000000000000";
+  constructor(basePath) {
+    this.basePath = basePath || path.join(process.cwd(), "data", "audit");
+    this.ensureDir();
+    this.loadLastHash();
+  }
+  /**
+   * 记录审计日志
+   */
+  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: "",
+      // 计算后填充
+      metadata: params.metadata
+    };
+    entry.hash = this.calculateHash(entry);
+    this.lastHash = entry.hash;
+    const filePath = this.getFilePath(now);
+    const line = JSON.stringify(entry) + "\n";
+    fs.appendFileSync(filePath, line, "utf-8");
+    return entry;
+  }
+  /**
+   * 读取指定日期的日志
+   */
+  read(date) {
+    const filePath = this.getFilePath(date || /* @__PURE__ */ new Date());
+    if (!fs.existsSync(filePath)) {
+      return [];
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    return lines.map((line) => JSON.parse(line));
+  }
+  /**
+   * 验证日志完整性
+   */
+  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(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;
+  }
+  /**
+   * 获取日志文件路径
+   */
+  getFilePath(date) {
+    const dateStr = date.toISOString().slice(0, 10);
+    return path.join(this.basePath, `audit_${dateStr}.jsonl`);
+  }
+  /**
+   * 计算条目哈希
+   */
+  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);
+  }
+  /**
+   * 加载最后一条日志的哈希
+   */
+  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;
+      }
+    }
+  }
+  /**
+   * 确保目录存在
+   */
+  ensureDir() {
+    if (!fs.existsSync(this.basePath)) {
+      fs.mkdirSync(this.basePath, { recursive: true });
+    }
+  }
+};
+
+// src/wallet/SecureWallet.ts
+var DEFAULT_LIMITS = {
+  singleMax: 100,
+  // 单笔最大 $100
+  dailyMax: 1e3,
+  // 日最大 $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 address() {
+    return this.wallet.address;
+  }
+  /**
+   * 获取余额
+   */
+  async getBalance() {
+    return this.wallet.getBalance();
+  }
+  /**
+   * 安全转账（带限额和白名单检查）
+   */
+  async transfer(params) {
+    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;
+  }
+  /**
+   * 审批待处理转账
+   */
+  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;
+  }
+  /**
+   * 拒绝待处理转账
+   */
+  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 }
+    });
+  }
+  /**
+   * 添加白名单地址
+   */
+  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 }
+    });
+  }
+  /**
+   * 移除白名单地址
+   */
+  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 }
+    });
+  }
+  /**
+   * 检查地址是否在白名单
+   */
+  isWhitelisted(address) {
+    return this.whitelist.has(address.toLowerCase());
+  }
+  /**
+   * 获取待处理转账列表
+   */
+  getPendingTransfers() {
+    return Array.from(this.pendingTransfers.values()).filter((p) => p.status === "pending");
+  }
+  /**
+   * 获取当前限额配置
+   */
+  getLimits() {
+    return { ...this.limits };
+  }
+  /**
+   * 获取今日已用额度
+   */
+  getDailyUsed() {
+    this.updateDailyTotal();
+    return this.dailyTotal;
+  }
+  /**
+   * 更新日限额计数器
+   */
+  updateDailyTotal() {
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (this.dailyDate !== today) {
+      this.dailyDate = today;
+      this.dailyTotal = 0;
+    }
+  }
+};
+
+// src/permit/Permit.ts
+var import_ethers3 = require("ethers");
+
+// src/cli.ts
+var program = new import_commander.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.parse();
+//# sourceMappingURL=cli.js.map