moltspay 0.2.3 → 0.2.5

package/dist/cli.js

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,62 +30,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/cli.ts
-var import_commander = require("commander");
-
-// src/agent/PaymentAgent.ts
-var import_ethers = require("ethers");
-
 // src/chains/index.ts
-var 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
-  }
-};
+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) {
@@ -89,21 +49,405 @@ function getChain(name) {
 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)"
-];
+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
+});
+function getAgentAddress(config) {
+  const wallet = new AgentWallet(config);
+  return wallet.address;
+}
+var import_ethers2, fs, path, PERMIT_ABI, AgentWallet;
+var init_AgentWallet = __esm({
+  "src/agent/AgentWallet.ts"() {
+    "use strict";
+    import_ethers2 = require("ethers");
+    fs = __toESM(require("fs"));
+    path = __toESM(require("path"));
+    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 = import_ethers2.ethers.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 import_ethers2.ethers.Wallet(this._privateKey, this.provider);
+        }
+        return this._wallet;
+      }
+      get provider() {
+        if (!this._provider) {
+          this._provider = new import_ethers2.ethers.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 import_ethers2.ethers.Contract(
+          this.chainConfig.usdc,
+          PERMIT_ABI,
+          this.provider
+        );
+        const ownerAddress = import_ethers2.ethers.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 = import_ethers2.ethers.getAddress(to);
+        const amountWei = BigInt(Math.floor(amount * 1e6));
+        let usePermit = permit;
+        let ownerAddress;
+        if (usePermit) {
+          ownerAddress = import_ethers2.ethers.getAddress(usePermit.owner);
+          this.storePermit(usePermit);
+        } else {
+          const usdcContract = new import_ethers2.ethers.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 = import_ethers2.ethers.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 import_ethers2.ethers.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 gas balance (ETH needed for transactions)
+       */
+      async getGasBalance() {
+        const balance = await this.provider.getBalance(this.address);
+        return import_ethers2.ethers.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 import_ethers2.ethers.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/cli.ts
+var import_commander = require("commander");
 
 // src/agent/PaymentAgent.ts
+var import_ethers = require("ethers");
+init_chains();
 var PaymentAgent = class _PaymentAgent {
   chain;
   chainConfig;
@@ -305,8 +649,12 @@ After payment, reply with your tx hash:
   }
 };
 
+// src/index.ts
+init_AgentWallet();
+
 // src/wallet/Wallet.ts
-var import_ethers2 = require("ethers");
+var import_ethers3 = require("ethers");
+init_chains();
 var Wallet = class {
   chain;
   chainConfig;
@@ -322,10 +670,10 @@ var Wallet = class {
       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.provider = new import_ethers3.ethers.JsonRpcProvider(rpcUrl);
+    this.wallet = new import_ethers3.ethers.Wallet(privateKey, this.provider);
     this.address = this.wallet.address;
-    this.usdcContract = new import_ethers2.ethers.Contract(
+    this.usdcContract = new import_ethers3.ethers.Contract(
       this.chainConfig.usdc,
       ERC20_ABI,
       this.wallet
@@ -341,7 +689,7 @@ var Wallet = class {
     ]);
     return {
       address: this.address,
-      eth: import_ethers2.ethers.formatEther(ethBalance),
+      eth: import_ethers3.ethers.formatEther(ethBalance),
       usdc: (Number(usdcBalance) / 1e6).toFixed(2),
       chain: this.chain
     };
@@ -351,7 +699,7 @@ var Wallet = class {
    */
   async transfer(to, amount) {
     try {
-      to = import_ethers2.ethers.getAddress(to);
+      to = import_ethers3.ethers.getAddress(to);
       const amountWei = BigInt(Math.floor(amount * 1e6));
       const balance = await this.usdcContract.balanceOf(this.address);
       if (BigInt(balance) < amountWei) {
@@ -392,7 +740,7 @@ var Wallet = class {
    */
   async getEthBalance() {
     const balance = await this.provider.getBalance(this.address);
-    return import_ethers2.ethers.formatEther(balance);
+    return import_ethers3.ethers.formatEther(balance);
   }
   /**
    * Get USDC balance
@@ -404,14 +752,14 @@ var Wallet = class {
 };
 
 // src/audit/AuditLog.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
+var path2 = __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.basePath = basePath || path2.join(process.cwd(), "data", "audit");
     this.ensureDir();
     this.loadLastHash();
   }
@@ -440,7 +788,7 @@ var AuditLog = class {
     this.lastHash = entry.hash;
     const filePath = this.getFilePath(now);
     const line = JSON.stringify(entry) + "\n";
-    fs.appendFileSync(filePath, line, "utf-8");
+    fs2.appendFileSync(filePath, line, "utf-8");
     return entry;
   }
   /**
@@ -448,10 +796,10 @@ var AuditLog = class {
    */
   read(date) {
     const filePath = this.getFilePath(date || /* @__PURE__ */ new Date());
-    if (!fs.existsSync(filePath)) {
+    if (!fs2.existsSync(filePath)) {
       return [];
     }
-    const content = fs.readFileSync(filePath, "utf-8");
+    const content = fs2.readFileSync(filePath, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     return lines.map((line) => JSON.parse(line));
   }
@@ -502,7 +850,7 @@ var AuditLog = class {
    */
   getFilePath(date) {
     const dateStr = date.toISOString().slice(0, 10);
-    return path.join(this.basePath, `audit_${dateStr}.jsonl`);
+    return path2.join(this.basePath, `audit_${dateStr}.jsonl`);
   }
   /**
    * Calculate entry hash
@@ -540,8 +888,8 @@ var AuditLog = class {
    * Ensure directory exists
    */
   ensureDir() {
-    if (!fs.existsSync(this.basePath)) {
-      fs.mkdirSync(this.basePath, { recursive: true });
+    if (!fs2.existsSync(this.basePath)) {
+      fs2.mkdirSync(this.basePath, { recursive: true });
     }
   }
 };
@@ -805,13 +1153,14 @@ var SecureWallet = class {
 };
 
 // src/wallet/createWallet.ts
-var import_ethers3 = require("ethers");
+var import_ethers4 = require("ethers");
 var import_path = require("path");
 var DEFAULT_STORAGE_DIR = (0, import_path.join)(process.env.HOME || "~", ".moltspay");
 
 // src/wallet/PermitWallet.ts
-var import_ethers4 = require("ethers");
-var PERMIT_ABI = [
+var import_ethers5 = require("ethers");
+init_chains();
+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)",
@@ -819,14 +1168,37 @@ var PERMIT_ABI = [
 ];
 
 // src/wallet/signPermit.ts
-var import_ethers5 = require("ethers");
+var import_ethers6 = require("ethers");
+init_chains();
+
+// src/wallet/AllowanceWallet.ts
+var import_ethers7 = require("ethers");
+init_chains();
+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
-var import_ethers6 = require("ethers");
+var import_ethers8 = require("ethers");
+init_chains();
 
 // src/verify/index.ts
-var import_ethers7 = require("ethers");
-var TRANSFER_EVENT_TOPIC = import_ethers7.ethers.id("Transfer(address,address,uint256)");
+var import_ethers9 = require("ethers");
+init_chains();
+var TRANSFER_EVENT_TOPIC = import_ethers9.ethers.id("Transfer(address,address,uint256)");
+
+// src/receipt/index.ts
+init_chains();
+
+// src/templates/index.ts
+init_chains();
+
+// src/index.ts
+init_chains();
 
 // src/cli.ts
 var program = new import_commander.Command();
@@ -911,5 +1283,123 @@ program.command("chains").description("List supported chains").action(() => {
     console.log(`  ${name}: ${config.name} (chainId: ${config.chainId})`);
   }
 });
+program.command("init").description("Initialize agent wallet (auto-generates address, no gas needed)").option("-c, --chain <chain>", "Chain name", "base").option("-d, --dir <directory>", "Storage directory", "~/.moltspay").action(async (options) => {
+  const { AgentWallet: AgentWallet2 } = await Promise.resolve().then(() => (init_AgentWallet(), AgentWallet_exports));
+  const storageDir = options.dir.replace("~", process.env.HOME || ".");
+  const wallet = new AgentWallet2({
+    chain: options.chain,
+    storageDir
+  });
+  console.log("\u2705 Agent wallet initialized");
+  console.log(`   Address: ${wallet.address}`);
+  console.log(`   Chain: ${options.chain}`);
+  console.log(`   Storage: ${storageDir}`);
+  console.log("");
+  console.log("Next: Ask your Owner to authorize spending with:");
+  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: ethers10 } = 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 ethers10.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 = ethers10.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("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.js.map