moltspay 0.1.0

package/dist/index.mjs

@@ -0,0 +1,950 @@
+// src/agent/PaymentAgent.ts
+import { ethers } from "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);
+}
+function getChainById(chainId) {
+  return Object.values(CHAINS).find((c) => c.chainId === chainId);
+}
+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 ethers.JsonRpcProvider(rpcUrl);
+    this.usdcContract = new 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 = 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 };
+    }
+  }
+  /**
+   * 扫描最近转账（按金额匹配）
+   */
+  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 };
+    }
+  }
+  /**
+   * 获取钱包余额
+   */
+  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
+    };
+  }
+  /**
+   * 格式化 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
+import { ethers as ethers2 } 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 ethers2.JsonRpcProvider(rpcUrl);
+    this.wallet = new ethers2.Wallet(privateKey, this.provider);
+    this.address = this.wallet.address;
+    this.usdcContract = new ethers2.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: ethers2.formatEther(ethBalance),
+      usdc: (Number(usdcBalance) / 1e6).toFixed(2),
+      chain: this.chain
+    };
+  }
+  /**
+   * 发送 USDC 转账
+   */
+  async transfer(to, amount) {
+    try {
+      to = ethers2.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 ethers2.formatEther(balance);
+  }
+  /**
+   * 获取 USDC 余额
+   */
+  async getUsdcBalance() {
+    const balance = await this.usdcContract.balanceOf(this.address);
+    return (Number(balance) / 1e6).toFixed(2);
+  }
+};
+
+// src/audit/AuditLog.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "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
+import { ethers as ethers3 } from "ethers";
+var PermitPayment = class {
+  chain;
+  chainConfig;
+  spenderAddress;
+  provider;
+  wallet;
+  usdcContract;
+  constructor(config = {}) {
+    this.chain = config.chain || "base_sepolia";
+    this.chainConfig = getChain(this.chain);
+    this.spenderAddress = config.spenderAddress || process.env.PAYMENT_AGENT_WALLET || "";
+    const rpcUrl = config.rpcUrl || this.chainConfig.rpc;
+    this.provider = new ethers3.JsonRpcProvider(rpcUrl);
+    const privateKey = config.privateKey || process.env.PAYMENT_AGENT_PRIVATE_KEY;
+    if (privateKey) {
+      this.wallet = new ethers3.Wallet(privateKey, this.provider);
+      this.spenderAddress = this.wallet.address;
+    }
+    this.usdcContract = new ethers3.Contract(
+      this.chainConfig.usdc,
+      ERC20_ABI,
+      this.wallet || this.provider
+    );
+  }
+  /**
+   * 获取用户当前 nonce
+   */
+  async getNonce(owner) {
+    return Number(await this.usdcContract.nonces(owner));
+  }
+  /**
+   * 生成 EIP-712 签名请求（发给前端/用户钱包）
+   */
+  async createPermitRequest(owner, amount, orderId, deadlineMinutes = 30) {
+    const nonce = await this.getNonce(owner);
+    const deadline = Math.floor(Date.now() / 1e3) + deadlineMinutes * 60;
+    const value = BigInt(Math.floor(amount * 1e6)).toString();
+    const domain = {
+      name: "USD Coin",
+      version: "2",
+      chainId: this.chainConfig.chainId,
+      verifyingContract: this.chainConfig.usdc
+    };
+    const types = {
+      EIP712Domain: [
+        { name: "name", type: "string" },
+        { name: "version", type: "string" },
+        { name: "chainId", type: "uint256" },
+        { name: "verifyingContract", type: "address" }
+      ],
+      Permit: [
+        { name: "owner", type: "address" },
+        { name: "spender", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" }
+      ]
+    };
+    const message = {
+      owner,
+      spender: this.spenderAddress,
+      value,
+      nonce,
+      deadline
+    };
+    const typedData = {
+      types,
+      primaryType: "Permit",
+      domain,
+      message
+    };
+    return {
+      type: "permit_request",
+      version: "1.0",
+      order_id: orderId,
+      typed_data: typedData
+    };
+  }
+  /**
+   * 执行 permit + transferFrom
+   * 
+   * @param owner 用户地址
+   * @param amount 金额
+   * @param signature 用户签名 {v, r, s, deadline}
+   */
+  async executePermitAndTransfer(owner, amount, signature) {
+    if (!this.wallet) {
+      return { success: false, error: "Wallet not configured. Private key required." };
+    }
+    try {
+      const value = BigInt(Math.floor(amount * 1e6));
+      const permitTx = await this.usdcContract.permit(
+        owner,
+        this.spenderAddress,
+        value,
+        signature.deadline,
+        signature.v,
+        signature.r,
+        signature.s
+      );
+      await permitTx.wait();
+      const transferTx = await this.usdcContract.transferFrom(owner, this.spenderAddress, value);
+      const receipt = await transferTx.wait();
+      return {
+        success: receipt.status === 1,
+        tx_hash: transferTx.hash
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+  /**
+   * 仅执行 permit（不 transfer）
+   */
+  async executePermit(owner, amount, signature) {
+    if (!this.wallet) {
+      return { success: false, error: "Wallet not configured. Private key required." };
+    }
+    try {
+      const value = BigInt(Math.floor(amount * 1e6));
+      const tx = await this.usdcContract.permit(
+        owner,
+        this.spenderAddress,
+        value,
+        signature.deadline,
+        signature.v,
+        signature.r,
+        signature.s
+      );
+      const receipt = await tx.wait();
+      return {
+        success: receipt.status === 1,
+        tx_hash: tx.hash
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+  /**
+   * 格式化 Permit 请求为用户消息
+   */
+  formatPermitMessage(request) {
+    const { typed_data } = request;
+    const { message } = typed_data;
+    return `\u{1F510} **\u7B7E\u540D\u6388\u6743\u8BF7\u6C42**
+
+\u6388\u6743 \`${(Number(message.value) / 1e6).toFixed(2)} USDC\` \u7ED9\u670D\u52A1\u65B9
+
+**\u7B7E\u540D\u4FE1\u606F\uFF1A**
+- Owner: \`${message.owner}\`
+- Spender: \`${message.spender}\`
+- Amount: ${(Number(message.value) / 1e6).toFixed(2)} USDC
+- Deadline: ${new Date(message.deadline * 1e3).toISOString()}
+
+\u8BF7\u5728\u94B1\u5305\u4E2D\u7B7E\u540D\u6B64\u8BF7\u6C42\uFF08\u4E0D\u6D88\u8017 Gas\uFF09\u3002
+
+\`\`\`json
+${JSON.stringify(typed_data, null, 2)}
+\`\`\``;
+  }
+};
+export {
+  AuditLog,
+  CHAINS,
+  ERC20_ABI,
+  PaymentAgent,
+  PermitPayment,
+  SecureWallet,
+  Wallet,
+  getChain,
+  getChainById,
+  listChains
+};
+//# sourceMappingURL=index.mjs.map