moltspay 0.2.3 → 0.2.5

package/dist/index.mjs

@@ -280,8 +280,317 @@ After payment, reply with your tx hash:
   }
 };
 
-// src/wallet/Wallet.ts
+// src/agent/AgentWallet.ts
 import { ethers as ethers2 } from "ethers";
+import * as fs from "fs";
+import * as path from "path";
+var 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)"
+];
+var 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 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 };
+  }
+};
+function getAgentAddress(config) {
+  const wallet = new AgentWallet(config);
+  return wallet.address;
+}
+
+// src/wallet/Wallet.ts
+import { ethers as ethers3 } from "ethers";
 var Wallet = class {
   chain;
   chainConfig;
@@ -297,10 +606,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 ethers2.JsonRpcProvider(rpcUrl);
-    this.wallet = new ethers2.Wallet(privateKey, this.provider);
+    this.provider = new ethers3.JsonRpcProvider(rpcUrl);
+    this.wallet = new ethers3.Wallet(privateKey, this.provider);
     this.address = this.wallet.address;
-    this.usdcContract = new ethers2.Contract(
+    this.usdcContract = new ethers3.Contract(
       this.chainConfig.usdc,
       ERC20_ABI,
       this.wallet
@@ -316,7 +625,7 @@ var Wallet = class {
     ]);
     return {
       address: this.address,
-      eth: ethers2.formatEther(ethBalance),
+      eth: ethers3.formatEther(ethBalance),
       usdc: (Number(usdcBalance) / 1e6).toFixed(2),
       chain: this.chain
     };
@@ -326,7 +635,7 @@ var Wallet = class {
    */
   async transfer(to, amount) {
     try {
-      to = ethers2.getAddress(to);
+      to = ethers3.getAddress(to);
       const amountWei = BigInt(Math.floor(amount * 1e6));
       const balance = await this.usdcContract.balanceOf(this.address);
       if (BigInt(balance) < amountWei) {
@@ -367,7 +676,7 @@ var Wallet = class {
    */
   async getEthBalance() {
     const balance = await this.provider.getBalance(this.address);
-    return ethers2.formatEther(balance);
+    return ethers3.formatEther(balance);
   }
   /**
    * Get USDC balance
@@ -379,14 +688,14 @@ var Wallet = class {
 };
 
 // src/audit/AuditLog.ts
-import * as fs from "fs";
-import * as path from "path";
+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 || path.join(process.cwd(), "data", "audit");
+    this.basePath = basePath || path2.join(process.cwd(), "data", "audit");
     this.ensureDir();
     this.loadLastHash();
   }
@@ -415,7 +724,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;
   }
   /**
@@ -423,10 +732,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));
   }
@@ -477,7 +786,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
@@ -515,8 +824,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 });
     }
   }
 };
@@ -780,11 +1089,11 @@ var SecureWallet = class {
 };
 
 // src/wallet/createWallet.ts
-import { ethers as ethers3 } from "ethers";
-import { writeFileSync, readFileSync as readFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2, dirname } from "path";
+import { ethers as ethers4 } from "ethers";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3, dirname } from "path";
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
-var DEFAULT_STORAGE_DIR = join2(process.env.HOME || "~", ".moltspay");
+var DEFAULT_STORAGE_DIR = join3(process.env.HOME || "~", ".moltspay");
 var DEFAULT_STORAGE_FILE = "wallet.json";
 function encryptPrivateKey(privateKey, password) {
   const salt = randomBytes(16);
@@ -807,10 +1116,10 @@ function decryptPrivateKey(encrypted, password, iv, salt) {
   return decrypted;
 }
 function createWallet(options = {}) {
-  const storagePath = options.storagePath || join2(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
-  if (existsSync2(storagePath) && !options.overwrite) {
+  const storagePath = options.storagePath || join3(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  if (existsSync3(storagePath) && !options.overwrite) {
     try {
-      const existing = JSON.parse(readFileSync2(storagePath, "utf8"));
+      const existing = JSON.parse(readFileSync3(storagePath, "utf8"));
       return {
         success: true,
         address: existing.address,
@@ -825,7 +1134,7 @@ function createWallet(options = {}) {
     }
   }
   try {
-    const wallet = ethers3.Wallet.createRandom();
+    const wallet = ethers4.Wallet.createRandom();
     const walletData = {
       address: wallet.address,
       label: options.label,
@@ -842,10 +1151,10 @@ function createWallet(options = {}) {
       walletData.privateKey = wallet.privateKey;
     }
     const dir = dirname(storagePath);
-    if (!existsSync2(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    if (!existsSync3(dir)) {
+      mkdirSync3(dir, { recursive: true });
     }
-    writeFileSync(storagePath, JSON.stringify(walletData, null, 2), { mode: 384 });
+    writeFileSync2(storagePath, JSON.stringify(walletData, null, 2), { mode: 384 });
     return {
       success: true,
       address: wallet.address,
@@ -860,12 +1169,12 @@ function createWallet(options = {}) {
   }
 }
 function loadWallet(options = {}) {
-  const storagePath = options.storagePath || join2(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
-  if (!existsSync2(storagePath)) {
+  const storagePath = options.storagePath || join3(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  if (!existsSync3(storagePath)) {
     return { success: false, error: "Wallet not found. Run createWallet() first." };
   }
   try {
-    const data = JSON.parse(readFileSync2(storagePath, "utf8"));
+    const data = JSON.parse(readFileSync3(storagePath, "utf8"));
     if (data.encrypted) {
       if (!options.password) {
         return { success: false, error: "Wallet is encrypted. Password required." };
@@ -880,25 +1189,25 @@ function loadWallet(options = {}) {
   }
 }
 function getWalletAddress(storagePath) {
-  const path2 = storagePath || join2(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
-  if (!existsSync2(path2)) {
+  const path3 = storagePath || join3(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  if (!existsSync3(path3)) {
     return null;
   }
   try {
-    const data = JSON.parse(readFileSync2(path2, "utf8"));
+    const data = JSON.parse(readFileSync3(path3, "utf8"));
     return data.address;
   } catch {
     return null;
   }
 }
 function walletExists(storagePath) {
-  const path2 = storagePath || join2(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
-  return existsSync2(path2);
+  const path3 = storagePath || join3(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  return existsSync3(path3);
 }
 
 // src/wallet/PermitWallet.ts
-import { ethers as ethers4 } from "ethers";
-var PERMIT_ABI = [
+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)",
@@ -929,12 +1238,12 @@ var PermitWallet = class {
       throw new Error("privateKey is required. Set via config, env var, or walletPath.");
     }
     const rpcUrl = config.rpcUrl || this.chainConfig.rpc;
-    this.provider = new ethers4.JsonRpcProvider(rpcUrl);
-    this.wallet = new ethers4.Wallet(privateKey, this.provider);
+    this.provider = new ethers5.JsonRpcProvider(rpcUrl);
+    this.wallet = new ethers5.Wallet(privateKey, this.provider);
     this.address = this.wallet.address;
-    this.usdcContract = new ethers4.Contract(
+    this.usdcContract = new ethers5.Contract(
       this.chainConfig.usdc,
-      PERMIT_ABI,
+      PERMIT_ABI2,
       this.wallet
     );
   }
@@ -977,9 +1286,9 @@ var PermitWallet = class {
   async transferWithPermit(params) {
     const { to, amount, permit } = params;
     try {
-      const toAddress = ethers4.getAddress(to);
-      const ownerAddress = ethers4.getAddress(permit.owner);
-      if (ethers4.getAddress(permit.spender).toLowerCase() !== this.address.toLowerCase()) {
+      const toAddress = ethers5.getAddress(to);
+      const ownerAddress = ethers5.getAddress(permit.owner);
+      if (ethers5.getAddress(permit.spender).toLowerCase() !== this.address.toLowerCase()) {
         return {
           success: false,
           error: `Permit spender (${permit.spender}) doesn't match wallet address (${this.address})`
@@ -1083,7 +1392,7 @@ var PermitWallet = class {
    */
   async getGasBalance() {
     const balance = await this.provider.getBalance(this.address);
-    return ethers4.formatEther(balance);
+    return ethers5.formatEther(balance);
   }
   /**
    * Check if there's enough gas
@@ -1144,7 +1453,7 @@ After signing, send { v, r, s, deadline } to the Agent.
 }
 
 // src/wallet/signPermit.ts
-import { ethers as ethers5 } from "ethers";
+import { ethers as ethers6 } from "ethers";
 async function signPermit(config, params) {
   const chain = config.chain || "base";
   const chainConfig = getChain(chain);
@@ -1153,9 +1462,9 @@ async function signPermit(config, params) {
     throw new Error("privateKey is required");
   }
   const rpcUrl = config.rpcUrl || chainConfig.rpc;
-  const provider = new ethers5.JsonRpcProvider(rpcUrl);
-  const wallet = new ethers5.Wallet(privateKey, provider);
-  const usdcContract = new ethers5.Contract(chainConfig.usdc, ERC20_ABI, provider);
+  const provider = new ethers6.JsonRpcProvider(rpcUrl);
+  const wallet = new ethers6.Wallet(privateKey, provider);
+  const usdcContract = new ethers6.Contract(chainConfig.usdc, ERC20_ABI, provider);
   const nonce = Number(await usdcContract.nonces(wallet.address));
   let deadline;
   if (!params.deadline) {
@@ -1189,7 +1498,7 @@ async function signPermit(config, params) {
     deadline
   };
   const signature = await wallet.signTypedData(domain, types, message);
-  const sig = ethers5.Signature.from(signature);
+  const sig = ethers6.Signature.from(signature);
   return {
     owner: wallet.address,
     spender: params.spender,
@@ -1211,8 +1520,284 @@ var PermitSigner = class {
   }
 };
 
+// src/wallet/AllowanceWallet.ts
+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)"
+];
+var AllowanceWallet = class {
+  chain;
+  chainConfig;
+  address;
+  // Agent's address
+  wallet;
+  provider;
+  usdcContract;
+  /** Stored permits from owners */
+  permits = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.chain = config.chain || "base_sepolia";
+    this.chainConfig = getChain(this.chain);
+    const rpcUrl = config.rpcUrl || this.chainConfig.rpc;
+    this.provider = new ethers7.JsonRpcProvider(rpcUrl);
+    this.wallet = new ethers7.Wallet(config.privateKey, this.provider);
+    this.address = this.wallet.address;
+    this.usdcContract = new ethers7.Contract(
+      this.chainConfig.usdc,
+      PERMIT_ABI3,
+      this.wallet
+    );
+  }
+  /**
+   * Store a Permit received from Owner
+   * Call this when Owner sends you a signed Permit
+   */
+  storePermit(permit) {
+    const ownerLower = permit.owner.toLowerCase();
+    this.permits.set(ownerLower, permit);
+  }
+  /**
+   * Get stored Permit for an owner
+   */
+  getPermit(owner) {
+    return this.permits.get(owner.toLowerCase());
+  }
+  /**
+   * Check allowance status with an owner
+   */
+  async checkAllowance(owner) {
+    const ownerAddress = ethers7.getAddress(owner);
+    const [allowance, ownerBalance, agentGasBalance] = await Promise.all([
+      this.usdcContract.allowance(ownerAddress, this.address),
+      this.usdcContract.balanceOf(ownerAddress),
+      this.provider.getBalance(this.address)
+    ]);
+    const allowanceNum = Number(allowance) / 1e6;
+    const hasGas = Number(ethers7.formatEther(agentGasBalance)) >= 1e-4;
+    return {
+      owner: ownerAddress,
+      agent: this.address,
+      allowance: allowanceNum.toFixed(2),
+      ownerBalance: (Number(ownerBalance) / 1e6).toFixed(2),
+      agentGasBalance: ethers7.formatEther(agentGasBalance),
+      canSpend: allowanceNum > 0 && hasGas,
+      chain: this.chainConfig.name
+    };
+  }
+  /**
+   * Spend from Owner's wallet using Permit allowance
+   * 
+   * @example
+   * ```typescript
+   * const agent = new AllowanceWallet({ 
+   *   chain: 'base',
+   *   privateKey: process.env.AGENT_KEY  // Only needs gas
+   * });
+   * 
+   * // Owner gave us a Permit
+   * agent.storePermit(ownerPermit);
+   * 
+   * // Spend to pay for a service
+   * const result = await agent.spend({
+   *   to: '0xServiceProvider...',
+   *   amount: 2.99,
+   * });
+   * ```
+   */
+  async spend(params) {
+    const { to, amount, permit } = params;
+    try {
+      const toAddress = ethers7.getAddress(to);
+      const amountWei = BigInt(Math.floor(amount * 1e6));
+      let ownerPermit = permit;
+      let ownerAddress;
+      if (ownerPermit) {
+        ownerAddress = ethers7.getAddress(ownerPermit.owner);
+        this.storePermit(ownerPermit);
+      } else {
+        for (const [owner, p] of this.permits) {
+          const allowance = await this.usdcContract.allowance(owner, this.address);
+          if (BigInt(allowance) >= amountWei) {
+            ownerAddress = ethers7.getAddress(owner);
+            ownerPermit = p;
+            break;
+          }
+        }
+        if (!ownerPermit) {
+          return {
+            success: false,
+            error: "No valid permit found. Ask Owner to sign a Permit first.",
+            from: "",
+            to: toAddress,
+            amount
+          };
+        }
+      }
+      const currentAllowance = await this.usdcContract.allowance(ownerAddress, this.address);
+      if (BigInt(currentAllowance) < amountWei) {
+        const now = Math.floor(Date.now() / 1e3);
+        if (ownerPermit.deadline < now) {
+          return {
+            success: false,
+            error: `Permit expired at ${new Date(ownerPermit.deadline * 1e3).toISOString()}. Ask Owner for a new Permit.`,
+            from: ownerAddress,
+            to: toAddress,
+            amount
+          };
+        }
+        const currentNonce = await this.usdcContract.nonces(ownerAddress);
+        if (Number(currentNonce) !== ownerPermit.nonce) {
+          return {
+            success: false,
+            error: `Permit nonce mismatch (expected ${ownerPermit.nonce}, got ${currentNonce}). Owner may have used this permit or signed a new one.`,
+            from: ownerAddress,
+            to: toAddress,
+            amount
+          };
+        }
+        console.log("[AllowanceWallet] Submitting permit on-chain...");
+        const permitTx = await this.usdcContract.permit(
+          ownerAddress,
+          this.address,
+          ownerPermit.value,
+          ownerPermit.deadline,
+          ownerPermit.v,
+          ownerPermit.r,
+          ownerPermit.s
+        );
+        await permitTx.wait();
+        console.log("[AllowanceWallet] Permit submitted:", permitTx.hash);
+      }
+      console.log("[AllowanceWallet] Executing transferFrom...");
+      const tx = await this.usdcContract.transferFrom(
+        ownerAddress,
+        toAddress,
+        amountWei
+      );
+      const receipt = await tx.wait();
+      const newAllowance = await this.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) {
+      const message = error.message;
+      if (message.includes("ERC20InsufficientAllowance")) {
+        return {
+          success: false,
+          error: "Insufficient allowance. Ask Owner to sign a new Permit with higher amount.",
+          from: "",
+          to,
+          amount
+        };
+      }
+      if (message.includes("ERC20InsufficientBalance")) {
+        return {
+          success: false,
+          error: "Owner's wallet has insufficient USDC balance.",
+          from: "",
+          to,
+          amount
+        };
+      }
+      return {
+        success: false,
+        error: message,
+        from: "",
+        to,
+        amount
+      };
+    }
+  }
+  /**
+   * Get Agent's gas balance (ETH)
+   */
+  async getGasBalance() {
+    const balance = await this.provider.getBalance(this.address);
+    return ethers7.formatEther(balance);
+  }
+};
+function generatePermitInstructions(params) {
+  const { ownerAddress, agentAddress, amount, deadlineHours = 24, chain = "base" } = params;
+  const chainConfig = getChain(chain);
+  const deadline = Math.floor(Date.now() / 1e3) + deadlineHours * 3600;
+  const value = BigInt(Math.floor(amount * 1e6)).toString();
+  const eip712Domain = {
+    name: "USD Coin",
+    version: "2",
+    chainId: chainConfig.chainId,
+    verifyingContract: chainConfig.usdc
+  };
+  const typedData = {
+    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" }
+      ]
+    },
+    primaryType: "Permit",
+    domain: eip712Domain,
+    message: {
+      owner: ownerAddress,
+      spender: agentAddress,
+      value,
+      nonce: "<GET_FROM_USDC_CONTRACT>",
+      // Owner needs to query this
+      deadline
+    }
+  };
+  const instructions = `
+\u{1F510} **Grant USDC Spending Allowance to Your Agent**
+
+Your Agent (${agentAddress}) is requesting permission to spend up to ${amount} USDC from your wallet.
+
+**What this does:**
+- Allows your Agent to pay for services on your behalf
+- Your USDC stays in YOUR wallet until spent
+- Agent can only spend up to the authorized amount
+- Expires in ${deadlineHours} hours
+- You can revoke anytime by moving your USDC
+
+**How to sign (MetaMask / any web3 wallet):**
+
+1. Go to https://etherscan.io/address/${chainConfig.usdc}#readContract
+2. Query \`nonces(${ownerAddress})\` to get your current nonce
+3. Use eth_signTypedData_v4 with the data below (replace nonce)
+4. Send the signature {v, r, s, deadline, nonce} to your Agent
+
+**Chain:** ${chainConfig.name}
+**USDC Contract:** ${chainConfig.usdc}
+
+**EIP-712 Typed Data:**
+\`\`\`json
+${JSON.stringify(typedData, null, 2)}
+\`\`\`
+
+\u26A0\uFE0F Never share your private key. This signature only authorizes spending, not wallet access.
+`;
+  return { instructions, typedData, eip712Domain };
+}
+
 // src/permit/Permit.ts
-import { ethers as ethers6 } from "ethers";
+import { ethers as ethers8 } from "ethers";
 var PermitPayment = class {
   chain;
   chainConfig;
@@ -1225,13 +1810,13 @@ var PermitPayment = class {
     this.chainConfig = getChain(this.chain);
     this.spenderAddress = config.spenderAddress || process.env.PAYMENT_AGENT_WALLET || "";
     const rpcUrl = config.rpcUrl || this.chainConfig.rpc;
-    this.provider = new ethers6.JsonRpcProvider(rpcUrl);
+    this.provider = new ethers8.JsonRpcProvider(rpcUrl);
     const privateKey = config.privateKey || process.env.PAYMENT_AGENT_PRIVATE_KEY;
     if (privateKey) {
-      this.wallet = new ethers6.Wallet(privateKey, this.provider);
+      this.wallet = new ethers8.Wallet(privateKey, this.provider);
       this.spenderAddress = this.wallet.address;
     }
-    this.usdcContract = new ethers6.Contract(
+    this.usdcContract = new ethers8.Contract(
       this.chainConfig.usdc,
       ERC20_ABI,
       this.wallet || this.provider
@@ -1514,8 +2099,8 @@ var OrderManager = class {
 };
 
 // src/verify/index.ts
-import { ethers as ethers7 } from "ethers";
-var TRANSFER_EVENT_TOPIC = ethers7.id("Transfer(address,address,uint256)");
+import { ethers as ethers9 } from "ethers";
+var TRANSFER_EVENT_TOPIC = ethers9.id("Transfer(address,address,uint256)");
 async function verifyPayment(params) {
   const { txHash, expectedAmount, expectedTo } = params;
   let chain;
@@ -1532,7 +2117,7 @@ async function verifyPayment(params) {
     return { verified: false, error: `Unsupported chain: ${params.chain}` };
   }
   try {
-    const provider = new ethers7.JsonRpcProvider(chain.rpc);
+    const provider = new ethers9.JsonRpcProvider(chain.rpc);
     const receipt = await provider.getTransactionReceipt(txHash);
     if (!receipt) {
       return { verified: false, error: "Transaction not found or not confirmed" };
@@ -1592,7 +2177,7 @@ async function getTransactionStatus(txHash, chain = "base") {
     return { status: "not_found" };
   }
   try {
-    const provider = new ethers7.JsonRpcProvider(chainConfig.rpc);
+    const provider = new ethers9.JsonRpcProvider(chainConfig.rpc);
     const receipt = await provider.getTransactionReceipt(txHash);
     if (!receipt) {
       const tx = await provider.getTransaction(txHash);
@@ -1629,7 +2214,7 @@ async function waitForTransaction(txHash, chain = "base", confirmations = 1, tim
   } catch (e) {
     return { verified: false, confirmed: false, error: `Unsupported chain: ${chain}` };
   }
-  const provider = new ethers7.JsonRpcProvider(chainConfig.rpc);
+  const provider = new ethers9.JsonRpcProvider(chainConfig.rpc);
   try {
     const receipt = await provider.waitForTransaction(txHash, confirmations, timeoutMs);
     if (!receipt) {
@@ -2316,6 +2901,8 @@ function parseStatusMarker(message) {
   return { type: "unknown", data: { raw: content } };
 }
 export {
+  AgentWallet,
+  AllowanceWallet,
   AuditLog,
   BuyerTemplates,
   CHAINS,
@@ -2338,9 +2925,11 @@ export {
   formatReceiptText,
   generatePaymentGuide,
   generatePaymentReminder,
+  generatePermitInstructions,
   generateReceipt,
   generateReceiptFromInvoice,
   generateWalletGuide,
+  getAgentAddress,
   getChain,
   getChainById,
   getTransactionStatus,