moltspay 0.5.4 → 0.7.1

package/dist/wallet/index.mjs

@@ -169,413 +169,12 @@ var Wallet = class {
   }
 };
 
-// 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();
-  }
-  /**
-   * Record audit log
-   */
-  async log(params) {
-    const now = /* @__PURE__ */ new Date();
-    const entry = {
-      timestamp: now.getTime() / 1e3,
-      datetime: now.toISOString(),
-      action: params.action,
-      request_id: params.request_id,
-      from: params.from,
-      to: params.to,
-      amount: params.amount,
-      tx_hash: params.tx_hash,
-      reason: params.reason,
-      requester: params.requester,
-      prev_hash: this.lastHash,
-      hash: "",
-      // Filled after calculation
-      metadata: params.metadata
-    };
-    entry.hash = this.calculateHash(entry);
-    this.lastHash = entry.hash;
-    const filePath = this.getFilePath(now);
-    const line = JSON.stringify(entry) + "\n";
-    fs.appendFileSync(filePath, line, "utf-8");
-    return entry;
-  }
-  /**
-   * Read logs for specified date
-   */
-  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 log integrity
-   */
-  verify(date) {
-    const entries = this.read(date);
-    const errors = [];
-    for (let i = 0; i < entries.length; i++) {
-      const entry = entries[i];
-      const expectedHash = this.calculateHash(entry);
-      if (entry.hash !== expectedHash) {
-        errors.push(`Entry ${i}: hash mismatch (expected ${expectedHash}, got ${entry.hash})`);
-      }
-      if (i > 0 && entry.prev_hash !== entries[i - 1].hash) {
-        errors.push(`Entry ${i}: prev_hash mismatch`);
-      }
-    }
-    return { valid: errors.length === 0, errors };
-  }
-  /**
-   * Search logs
-   */
-  search(filter) {
-    const results = [];
-    const startDate = filter.startDate || new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3);
-    const endDate = filter.endDate || /* @__PURE__ */ new Date();
-    const current = new Date(startDate);
-    while (current <= endDate) {
-      const entries = this.read(current);
-      for (const entry of entries) {
-        let match = true;
-        if (filter.action && entry.action !== filter.action) match = false;
-        if (filter.request_id && entry.request_id !== filter.request_id) match = false;
-        if (filter.from && entry.from?.toLowerCase() !== filter.from.toLowerCase()) match = false;
-        if (filter.to && entry.to?.toLowerCase() !== filter.to.toLowerCase()) match = false;
-        if (match) {
-          results.push(entry);
-        }
-      }
-      current.setDate(current.getDate() + 1);
-    }
-    return results;
-  }
-  /**
-   * Get log file path
-   */
-  getFilePath(date) {
-    const dateStr = date.toISOString().slice(0, 10);
-    return path.join(this.basePath, `audit_${dateStr}.jsonl`);
-  }
-  /**
-   * Calculate entry hash
-   */
-  calculateHash(entry) {
-    const data = {
-      timestamp: entry.timestamp,
-      action: entry.action,
-      request_id: entry.request_id,
-      from: entry.from,
-      to: entry.to,
-      amount: entry.amount,
-      tx_hash: entry.tx_hash,
-      prev_hash: entry.prev_hash
-    };
-    const str = JSON.stringify(data);
-    return crypto.createHash("sha256").update(str).digest("hex").slice(0, 16);
-  }
-  /**
-   * Load last log entry hash
-   */
-  loadLastHash() {
-    const today = /* @__PURE__ */ new Date();
-    for (let i = 0; i < 2; i++) {
-      const date = new Date(today);
-      date.setDate(date.getDate() - i);
-      const entries = this.read(date);
-      if (entries.length > 0) {
-        this.lastHash = entries[entries.length - 1].hash;
-        return;
-      }
-    }
-  }
-  /**
-   * Ensure directory exists
-   */
-  ensureDir() {
-    if (!fs.existsSync(this.basePath)) {
-      fs.mkdirSync(this.basePath, { recursive: true });
-    }
-  }
-};
-
-// src/wallet/SecureWallet.ts
-var DEFAULT_LIMITS = {
-  singleMax: 100,
-  // Single max $100
-  dailyMax: 1e3,
-  // Daily max $1000
-  requireWhitelist: true
-};
-var SecureWallet = class {
-  wallet;
-  limits;
-  whitelist;
-  auditLog;
-  dailyTotal = 0;
-  dailyDate = "";
-  pendingTransfers = /* @__PURE__ */ new Map();
-  constructor(config = {}) {
-    this.wallet = new Wallet({
-      chain: config.chain,
-      privateKey: config.privateKey
-    });
-    this.limits = { ...DEFAULT_LIMITS, ...config.limits };
-    this.whitelist = new Set((config.whitelist || []).map((a) => a.toLowerCase()));
-    this.auditLog = new AuditLog(config.auditPath);
-  }
-  /**
-   * Get wallet address
-   */
-  get address() {
-    return this.wallet.address;
-  }
-  /**
-   * Get balance
-   */
-  async getBalance() {
-    return this.wallet.getBalance();
-  }
-  /**
-   * Secure transfer (with limit and whitelist checks)
-   * 
-   * Supports two calling methods:
-   * - transfer({ to, amount, reason?, requester? })
-   * - transfer(to, amount)
-   */
-  async transfer(paramsOrTo, amountArg) {
-    let params;
-    if (typeof paramsOrTo === "string") {
-      params = {
-        to: paramsOrTo,
-        amount: typeof amountArg === "string" ? parseFloat(amountArg) : amountArg || 0
-      };
-    } else {
-      params = paramsOrTo;
-    }
-    const { to, amount, reason, requester } = params;
-    const toAddress = to.toLowerCase();
-    const requestId = `tr_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
-    await this.auditLog.log({
-      action: "transfer_request",
-      request_id: requestId,
-      from: this.wallet.address,
-      to,
-      amount,
-      reason,
-      requester
-    });
-    if (this.limits.requireWhitelist && !this.whitelist.has(toAddress)) {
-      await this.auditLog.log({
-        action: "transfer_failed",
-        request_id: requestId,
-        metadata: { error: "Address not in whitelist" }
-      });
-      return { success: false, error: `Address not in whitelist: ${to}` };
-    }
-    if (amount > this.limits.singleMax) {
-      const pending = {
-        id: requestId,
-        to,
-        amount,
-        reason,
-        requester,
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        status: "pending"
-      };
-      this.pendingTransfers.set(requestId, pending);
-      await this.auditLog.log({
-        action: "transfer_request",
-        request_id: requestId,
-        metadata: { pending: true, reason: "Exceeds single limit" }
-      });
-      return {
-        success: false,
-        error: `Amount ${amount} exceeds single limit ${this.limits.singleMax}. Pending approval: ${requestId}`
-      };
-    }
-    this.updateDailyTotal();
-    if (this.dailyTotal + amount > this.limits.dailyMax) {
-      const pending = {
-        id: requestId,
-        to,
-        amount,
-        reason,
-        requester,
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        status: "pending"
-      };
-      this.pendingTransfers.set(requestId, pending);
-      await this.auditLog.log({
-        action: "transfer_request",
-        request_id: requestId,
-        metadata: { pending: true, reason: "Exceeds daily limit" }
-      });
-      return {
-        success: false,
-        error: `Daily limit would be exceeded (${this.dailyTotal} + ${amount} > ${this.limits.dailyMax}). Pending approval: ${requestId}`
-      };
-    }
-    const result = await this.wallet.transfer(to, amount);
-    if (result.success) {
-      this.dailyTotal += amount;
-      await this.auditLog.log({
-        action: "transfer_executed",
-        request_id: requestId,
-        from: this.wallet.address,
-        to,
-        amount,
-        tx_hash: result.tx_hash,
-        reason,
-        requester
-      });
-    } else {
-      await this.auditLog.log({
-        action: "transfer_failed",
-        request_id: requestId,
-        metadata: { error: result.error }
-      });
-    }
-    return result;
-  }
-  /**
-   * Approve pending transfer
-   */
-  async approve(requestId, approver) {
-    const pending = this.pendingTransfers.get(requestId);
-    if (!pending) {
-      return { success: false, error: `Pending transfer not found: ${requestId}` };
-    }
-    if (pending.status !== "pending") {
-      return { success: false, error: `Transfer already ${pending.status}` };
-    }
-    await this.auditLog.log({
-      action: "transfer_approved",
-      request_id: requestId,
-      metadata: { approver }
-    });
-    pending.status = "approved";
-    const result = await this.wallet.transfer(pending.to, pending.amount);
-    if (result.success) {
-      pending.status = "executed";
-      this.dailyTotal += pending.amount;
-      await this.auditLog.log({
-        action: "transfer_executed",
-        request_id: requestId,
-        from: this.wallet.address,
-        to: pending.to,
-        amount: pending.amount,
-        tx_hash: result.tx_hash,
-        reason: pending.reason,
-        requester: pending.requester,
-        metadata: { approved_by: approver }
-      });
-    } else {
-      await this.auditLog.log({
-        action: "transfer_failed",
-        request_id: requestId,
-        metadata: { error: result.error }
-      });
-    }
-    return result;
-  }
-  /**
-   * Reject pending transfer
-   */
-  async reject(requestId, rejecter, reason) {
-    const pending = this.pendingTransfers.get(requestId);
-    if (!pending) {
-      throw new Error(`Pending transfer not found: ${requestId}`);
-    }
-    pending.status = "rejected";
-    await this.auditLog.log({
-      action: "transfer_rejected",
-      request_id: requestId,
-      metadata: { rejected_by: rejecter, reason }
-    });
-  }
-  /**
-   * Add to whitelist
-   */
-  async addToWhitelist(address, addedBy) {
-    const addr = address.toLowerCase();
-    this.whitelist.add(addr);
-    await this.auditLog.log({
-      action: "whitelist_add",
-      request_id: `wl_${Date.now()}`,
-      to: address,
-      metadata: { added_by: addedBy }
-    });
-  }
-  /**
-   * Remove from whitelist
-   */
-  async removeFromWhitelist(address, removedBy) {
-    const addr = address.toLowerCase();
-    this.whitelist.delete(addr);
-    await this.auditLog.log({
-      action: "whitelist_remove",
-      request_id: `wl_${Date.now()}`,
-      to: address,
-      metadata: { removed_by: removedBy }
-    });
-  }
-  /**
-   * Check if address is whitelisted
-   */
-  isWhitelisted(address) {
-    return this.whitelist.has(address.toLowerCase());
-  }
-  /**
-   * Get pending transfers list
-   */
-  getPendingTransfers() {
-    return Array.from(this.pendingTransfers.values()).filter((p) => p.status === "pending");
-  }
-  /**
-   * Get current limit config
-   */
-  getLimits() {
-    return { ...this.limits };
-  }
-  /**
-   * Get daily used amount
-   */
-  getDailyUsed() {
-    this.updateDailyTotal();
-    return this.dailyTotal;
-  }
-  /**
-   * Update daily limit counter
-   */
-  updateDailyTotal() {
-    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    if (this.dailyDate !== today) {
-      this.dailyDate = today;
-      this.dailyTotal = 0;
-    }
-  }
-};
-
 // src/wallet/createWallet.ts
 import { ethers as ethers2 } from "ethers";
-import { writeFileSync, readFileSync as readFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2, dirname } from "path";
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
-var DEFAULT_STORAGE_DIR = join2(process.env.HOME || "~", ".moltspay");
+var DEFAULT_STORAGE_DIR = join(process.env.HOME || "~", ".moltspay");
 var DEFAULT_STORAGE_FILE = "wallet.json";
 function encryptPrivateKey(privateKey, password) {
   const salt = randomBytes(16);
@@ -598,10 +197,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 || join(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  if (existsSync(storagePath) && !options.overwrite) {
     try {
-      const existing = JSON.parse(readFileSync2(storagePath, "utf8"));
+      const existing = JSON.parse(readFileSync(storagePath, "utf8"));
       return {
         success: true,
         address: existing.address,
@@ -633,8 +232,8 @@ function createWallet(options = {}) {
       walletData.privateKey = wallet.privateKey;
     }
     const dir = dirname(storagePath);
-    if (!existsSync2(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
     }
     writeFileSync(storagePath, JSON.stringify(walletData, null, 2), { mode: 384 });
     return {
@@ -651,12 +250,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 || join(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  if (!existsSync(storagePath)) {
     return { success: false, error: "Wallet not found. Run createWallet() first." };
   }
   try {
-    const data = JSON.parse(readFileSync2(storagePath, "utf8"));
+    const data = JSON.parse(readFileSync(storagePath, "utf8"));
     if (data.encrypted) {
       if (!options.password) {
         return { success: false, error: "Wallet is encrypted. Password required." };
@@ -671,624 +270,26 @@ function loadWallet(options = {}) {
   }
 }
 function getWalletAddress(storagePath) {
-  const path2 = storagePath || join2(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
-  if (!existsSync2(path2)) {
+  const path = storagePath || join(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  if (!existsSync(path)) {
     return null;
   }
   try {
-    const data = JSON.parse(readFileSync2(path2, "utf8"));
+    const data = JSON.parse(readFileSync(path, "utf8"));
     return data.address;
   } catch {
     return null;
   }
 }
 function walletExists(storagePath) {
-  const path2 = storagePath || join2(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
-  return existsSync2(path2);
-}
-
-// src/wallet/PermitWallet.ts
-import { ethers as ethers3 } from "ethers";
-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)"
-];
-var PermitWallet = class {
-  chain;
-  chainConfig;
-  address;
-  wallet;
-  provider;
-  usdcContract;
-  constructor(config = {}) {
-    this.chain = config.chain || "base_sepolia";
-    this.chainConfig = getChain(this.chain);
-    let privateKey = config.privateKey || process.env.PAYMENT_AGENT_PRIVATE_KEY;
-    if (!privateKey && config.walletPath) {
-      const loaded = loadWallet({
-        storagePath: config.walletPath,
-        password: config.walletPassword
-      });
-      if (!loaded.success || !loaded.privateKey) {
-        throw new Error(loaded.error || "Failed to load wallet");
-      }
-      privateKey = loaded.privateKey;
-    }
-    if (!privateKey) {
-      throw new Error("privateKey is required. Set via config, env var, or walletPath.");
-    }
-    const rpcUrl = config.rpcUrl || this.chainConfig.rpc;
-    this.provider = new ethers3.JsonRpcProvider(rpcUrl);
-    this.wallet = new ethers3.Wallet(privateKey, this.provider);
-    this.address = this.wallet.address;
-    this.usdcContract = new ethers3.Contract(
-      this.chainConfig.usdc,
-      PERMIT_ABI,
-      this.wallet
-    );
-  }
-  /**
-   * Check if Permit is valid (current allowance)
-   */
-  async checkPermitAllowance(owner) {
-    const allowance = await this.usdcContract.allowance(owner, this.address);
-    return (Number(allowance) / 1e6).toFixed(2);
-  }
-  /**
-   * Pay using Permit authorization
-   * 
-   * Flow:
-   * 1. Call permit() to record Boss's authorization in the contract
-   * 2. Call transferFrom() to transfer from Boss's wallet to recipient
-   * 
-   * @example
-   * ```typescript
-   * const wallet = new PermitWallet({ chain: 'base' });
-   * 
-   * // Boss-signed permit data
-   * const permit = {
-   *   owner: '0xBOSS...',
-   *   spender: wallet.address,
-   *   value: '10000000', // 10 USDC
-   *   deadline: 1234567890,
-   *   v: 27,
-   *   r: '0x...',
-   *   s: '0x...'
-   * };
-   * 
-   * const result = await wallet.transferWithPermit({
-   *   to: '0xSELLER...',
-   *   amount: 3.99,
-   *   permit
-   * });
-   * ```
-   */
-  async transferWithPermit(params) {
-    const { to, amount, permit } = params;
-    try {
-      const toAddress = ethers3.getAddress(to);
-      const ownerAddress = ethers3.getAddress(permit.owner);
-      if (ethers3.getAddress(permit.spender).toLowerCase() !== this.address.toLowerCase()) {
-        return {
-          success: false,
-          error: `Permit spender (${permit.spender}) doesn't match wallet address (${this.address})`
-        };
-      }
-      const now = Math.floor(Date.now() / 1e3);
-      if (permit.deadline < now) {
-        return {
-          success: false,
-          error: `Permit expired at ${new Date(permit.deadline * 1e3).toISOString()}`
-        };
-      }
-      const amountWei = BigInt(Math.floor(amount * 1e6));
-      const permitValue = BigInt(permit.value);
-      if (amountWei > permitValue) {
-        return {
-          success: false,
-          error: `Permit value (${Number(permitValue) / 1e6} USDC) < transfer amount (${amount} USDC)`
-        };
-      }
-      const currentAllowance = await this.usdcContract.allowance(ownerAddress, this.address);
-      let permitTxHash;
-      if (BigInt(currentAllowance) < amountWei) {
-        console.log("Executing permit...");
-        const permitTx = await this.usdcContract.permit(
-          ownerAddress,
-          this.address,
-          permitValue,
-          permit.deadline,
-          permit.v,
-          permit.r,
-          permit.s
-        );
-        const permitReceipt = await permitTx.wait();
-        if (permitReceipt.status !== 1) {
-          return {
-            success: false,
-            error: "Permit transaction failed",
-            permitTxHash: permitTx.hash
-          };
-        }
-        permitTxHash = permitTx.hash;
-        console.log("Permit executed:", permitTxHash);
-      }
-      console.log("Executing transferFrom...");
-      const transferTx = await this.usdcContract.transferFrom(
-        ownerAddress,
-        toAddress,
-        amountWei
-      );
-      const transferReceipt = await transferTx.wait();
-      if (transferReceipt.status === 1) {
-        return {
-          success: true,
-          tx_hash: transferTx.hash,
-          permitTxHash,
-          transferTxHash: transferTx.hash,
-          from: ownerAddress,
-          to: toAddress,
-          amount,
-          gas_used: Number(transferReceipt.gasUsed),
-          block_number: transferReceipt.blockNumber,
-          explorer_url: `${this.chainConfig.explorerTx}${transferTx.hash}`
-        };
-      } else {
-        return {
-          success: false,
-          error: "TransferFrom transaction failed",
-          tx_hash: transferTx.hash,
-          permitTxHash
-        };
-      }
-    } catch (error) {
-      const message = error.message;
-      if (message.includes("ERC20InsufficientAllowance")) {
-        return {
-          success: false,
-          error: "Insufficient allowance. Permit may have been used or expired."
-        };
-      }
-      if (message.includes("ERC20InsufficientBalance")) {
-        return {
-          success: false,
-          error: "Boss wallet has insufficient USDC balance."
-        };
-      }
-      if (message.includes("InvalidSignature") || message.includes("invalid signature")) {
-        return {
-          success: false,
-          error: "Invalid permit signature. Ask Boss to re-sign."
-        };
-      }
-      return {
-        success: false,
-        error: message
-      };
-    }
-  }
-  /**
-   * Get ETH balance (for gas)
-   */
-  async getGasBalance() {
-    const balance = await this.provider.getBalance(this.address);
-    return ethers3.formatEther(balance);
-  }
-  /**
-   * Check if there's enough gas
-   */
-  async hasEnoughGas(minEth = 1e-3) {
-    const balance = await this.getGasBalance();
-    return parseFloat(balance) >= minEth;
-  }
-};
-function formatPermitRequest(params) {
-  const { agentAddress, amount, deadlineHours = 24, chain = "base", reason } = params;
-  const chainConfig = getChain(chain);
-  const deadline = Math.floor(Date.now() / 1e3) + deadlineHours * 3600;
-  const value = BigInt(Math.floor(amount * 1e6)).toString();
-  return `\u{1F510} **USDC Spending Allowance Request**
-
-${reason ? `**Purpose:** ${reason}
-` : ""}
-**Authorization Details:**
-- Authorized address (Agent): \`${agentAddress}\`
-- Amount: ${amount} USDC
-- Valid for: ${deadlineHours} hours
-- Chain: ${chainConfig.name}
-
-**Please sign the following EIP-2612 Permit with your wallet:**
-
-\`\`\`json
-{
-  "types": {
-    "Permit": [
-      { "name": "owner", "type": "address" },
-      { "name": "spender", "type": "address" },
-      { "name": "value", "type": "uint256" },
-      { "name": "nonce", "type": "uint256" },
-      { "name": "deadline", "type": "uint256" }
-    ]
-  },
-  "primaryType": "Permit",
-  "domain": {
-    "name": "USD Coin",
-    "version": "2",
-    "chainId": ${chainConfig.chainId},
-    "verifyingContract": "${chainConfig.usdc}"
-  },
-  "message": {
-    "owner": "<YOUR_WALLET_ADDRESS>",
-    "spender": "${agentAddress}",
-    "value": "${value}",
-    "nonce": "<GET_FROM_CONTRACT>",
-    "deadline": ${deadline}
-  }
-}
-\`\`\`
-
-After signing, send { v, r, s, deadline } to the Agent.
-
-\u26A0\uFE0F Note: This authorization only allows the Agent to spend up to ${amount} USDC from your wallet. Your private key is never exposed.`;
-}
-
-// src/wallet/signPermit.ts
-import { ethers as ethers4 } from "ethers";
-async function signPermit(config, params) {
-  const chain = config.chain || "base";
-  const chainConfig = getChain(chain);
-  const privateKey = config.privateKey || process.env.PAYMENT_AGENT_PRIVATE_KEY;
-  if (!privateKey) {
-    throw new Error("privateKey is required");
-  }
-  const rpcUrl = config.rpcUrl || chainConfig.rpc;
-  const provider = new ethers4.JsonRpcProvider(rpcUrl);
-  const wallet = new ethers4.Wallet(privateKey, provider);
-  const usdcContract = new ethers4.Contract(chainConfig.usdc, ERC20_ABI, provider);
-  const nonce = Number(await usdcContract.nonces(wallet.address));
-  let deadline;
-  if (!params.deadline) {
-    deadline = Math.floor(Date.now() / 1e3) + 30 * 60;
-  } else if (params.deadline < 1e6) {
-    deadline = Math.floor(Date.now() / 1e3) + params.deadline * 60;
-  } else {
-    deadline = params.deadline;
-  }
-  const value = BigInt(Math.floor(params.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: wallet.address,
-    spender: params.spender,
-    value,
-    nonce,
-    deadline
-  };
-  const signature = await wallet.signTypedData(domain, types, message);
-  const sig = ethers4.Signature.from(signature);
-  return {
-    owner: wallet.address,
-    spender: params.spender,
-    value,
-    deadline,
-    nonce,
-    v: sig.v,
-    r: sig.r,
-    s: sig.s
-  };
-}
-var PermitSigner = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  async sign(params) {
-    return signPermit(this.config, params);
-  }
-};
-
-// src/wallet/AllowanceWallet.ts
-import { ethers as ethers5 } from "ethers";
-var PERMIT_ABI2 = [
-  ...ERC20_ABI,
-  "function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)",
-  "function transferFrom(address from, address to, uint256 amount) returns (bool)",
-  "function allowance(address owner, address spender) view returns (uint256)",
-  "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 ethers5.JsonRpcProvider(rpcUrl);
-    this.wallet = new ethers5.Wallet(config.privateKey, this.provider);
-    this.address = this.wallet.address;
-    this.usdcContract = new ethers5.Contract(
-      this.chainConfig.usdc,
-      PERMIT_ABI2,
-      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 = ethers5.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(ethers5.formatEther(agentGasBalance)) >= 1e-4;
-    return {
-      owner: ownerAddress,
-      agent: this.address,
-      allowance: allowanceNum.toFixed(2),
-      ownerBalance: (Number(ownerBalance) / 1e6).toFixed(2),
-      agentGasBalance: ethers5.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 = ethers5.getAddress(to);
-      const amountWei = BigInt(Math.floor(amount * 1e6));
-      let ownerPermit = permit;
-      let ownerAddress;
-      if (ownerPermit) {
-        ownerAddress = ethers5.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 = ethers5.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 ethers5.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 };
+  const path = storagePath || join(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  return existsSync(path);
 }
 export {
-  AllowanceWallet,
-  PermitSigner,
-  PermitWallet,
-  SecureWallet,
   Wallet,
   createWallet,
-  formatPermitRequest,
-  generatePermitInstructions,
   getWalletAddress,
   loadWallet,
-  signPermit,
   walletExists
 };
 //# sourceMappingURL=index.mjs.map