moltspay 0.1.3 → 0.2.1

package/dist/index.mjs

@@ -779,8 +779,372 @@ var SecureWallet = class {
   }
 };
 
-// src/permit/Permit.ts
+// 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 { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
+var DEFAULT_STORAGE_DIR = join2(process.env.HOME || "~", ".moltspay");
+var DEFAULT_STORAGE_FILE = "wallet.json";
+function encryptPrivateKey(privateKey, password) {
+  const salt = randomBytes(16);
+  const key = scryptSync(password, salt, 32);
+  const iv = randomBytes(16);
+  const cipher = createCipheriv("aes-256-cbc", key, iv);
+  let encrypted = cipher.update(privateKey, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  return {
+    encrypted,
+    iv: iv.toString("hex"),
+    salt: salt.toString("hex")
+  };
+}
+function decryptPrivateKey(encrypted, password, iv, salt) {
+  const key = scryptSync(password, Buffer.from(salt, "hex"), 32);
+  const decipher = createDecipheriv("aes-256-cbc", key, Buffer.from(iv, "hex"));
+  let decrypted = decipher.update(encrypted, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function createWallet(options = {}) {
+  const storagePath = options.storagePath || join2(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  if (existsSync2(storagePath) && !options.overwrite) {
+    try {
+      const existing = JSON.parse(readFileSync2(storagePath, "utf8"));
+      return {
+        success: true,
+        address: existing.address,
+        storagePath,
+        isNew: false
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to load existing wallet: ${error.message}`
+      };
+    }
+  }
+  try {
+    const wallet = ethers3.Wallet.createRandom();
+    const walletData = {
+      address: wallet.address,
+      label: options.label,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      encrypted: !!options.password,
+      privateKey: ""
+    };
+    if (options.password) {
+      const { encrypted, iv, salt } = encryptPrivateKey(wallet.privateKey, options.password);
+      walletData.privateKey = encrypted;
+      walletData.iv = iv;
+      walletData.salt = salt;
+    } else {
+      walletData.privateKey = wallet.privateKey;
+    }
+    const dir = dirname(storagePath);
+    if (!existsSync2(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync(storagePath, JSON.stringify(walletData, null, 2), { mode: 384 });
+    return {
+      success: true,
+      address: wallet.address,
+      storagePath,
+      isNew: true
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+function loadWallet(options = {}) {
+  const storagePath = options.storagePath || join2(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  if (!existsSync2(storagePath)) {
+    return { success: false, error: "Wallet not found. Run createWallet() first." };
+  }
+  try {
+    const data = JSON.parse(readFileSync2(storagePath, "utf8"));
+    if (data.encrypted) {
+      if (!options.password) {
+        return { success: false, error: "Wallet is encrypted. Password required." };
+      }
+      const privateKey = decryptPrivateKey(data.privateKey, options.password, data.iv, data.salt);
+      return { success: true, address: data.address, privateKey };
+    } else {
+      return { success: true, address: data.address, privateKey: data.privateKey };
+    }
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+function getWalletAddress(storagePath) {
+  const path2 = storagePath || join2(DEFAULT_STORAGE_DIR, DEFAULT_STORAGE_FILE);
+  if (!existsSync2(path2)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(readFileSync2(path2, "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 ethers4 } 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 ethers4.JsonRpcProvider(rpcUrl);
+    this.wallet = new ethers4.Wallet(privateKey, this.provider);
+    this.address = this.wallet.address;
+    this.usdcContract = new ethers4.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 = ethers4.getAddress(to);
+      const ownerAddress = ethers4.getAddress(permit.owner);
+      if (ethers4.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 ethers4.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/permit/Permit.ts
+import { ethers as ethers5 } from "ethers";
 var PermitPayment = class {
   chain;
   chainConfig;
@@ -793,13 +1157,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 ethers3.JsonRpcProvider(rpcUrl);
+    this.provider = new ethers5.JsonRpcProvider(rpcUrl);
     const privateKey = config.privateKey || process.env.PAYMENT_AGENT_PRIVATE_KEY;
     if (privateKey) {
-      this.wallet = new ethers3.Wallet(privateKey, this.provider);
+      this.wallet = new ethers5.Wallet(privateKey, this.provider);
       this.spenderAddress = this.wallet.address;
     }
-    this.usdcContract = new ethers3.Contract(
+    this.usdcContract = new ethers5.Contract(
       this.chainConfig.usdc,
       ERC20_ABI,
       this.wallet || this.provider
@@ -950,7 +1314,7 @@ ${JSON.stringify(typed_data, null, 2)}
 };
 
 // src/orders/index.ts
-import { randomBytes } from "crypto";
+import { randomBytes as randomBytes2 } from "crypto";
 var MemoryOrderStore = class {
   orders = /* @__PURE__ */ new Map();
   async get(orderId) {
@@ -989,7 +1353,7 @@ var OrderManager = class {
    * 生成订单ID
    */
   generateOrderId() {
-    return "vo_" + randomBytes(4).toString("hex");
+    return "vo_" + randomBytes2(4).toString("hex");
   }
   /**
    * 创建订单
@@ -1082,8 +1446,8 @@ var OrderManager = class {
 };
 
 // src/verify/index.ts
-import { ethers as ethers4 } from "ethers";
-var TRANSFER_EVENT_TOPIC = ethers4.id("Transfer(address,address,uint256)");
+import { ethers as ethers6 } from "ethers";
+var TRANSFER_EVENT_TOPIC = ethers6.id("Transfer(address,address,uint256)");
 async function verifyPayment(params) {
   const { txHash, expectedAmount, expectedTo } = params;
   let chain;
@@ -1100,7 +1464,7 @@ async function verifyPayment(params) {
     return { verified: false, error: `\u4E0D\u652F\u6301\u7684\u94FE: ${params.chain}` };
   }
   try {
-    const provider = new ethers4.JsonRpcProvider(chain.rpc);
+    const provider = new ethers6.JsonRpcProvider(chain.rpc);
     const receipt = await provider.getTransactionReceipt(txHash);
     if (!receipt) {
       return { verified: false, error: "\u4EA4\u6613\u672A\u627E\u5230\u6216\u672A\u786E\u8BA4" };
@@ -1160,7 +1524,7 @@ async function getTransactionStatus(txHash, chain = "base") {
     return { status: "not_found" };
   }
   try {
-    const provider = new ethers4.JsonRpcProvider(chainConfig.rpc);
+    const provider = new ethers6.JsonRpcProvider(chainConfig.rpc);
     const receipt = await provider.getTransactionReceipt(txHash);
     if (!receipt) {
       const tx = await provider.getTransaction(txHash);
@@ -1197,7 +1561,7 @@ async function waitForTransaction(txHash, chain = "base", confirmations = 1, tim
   } catch (e) {
     return { verified: false, confirmed: false, error: `\u4E0D\u652F\u6301\u7684\u94FE: ${chain}` };
   }
-  const provider = new ethers4.JsonRpcProvider(chainConfig.rpc);
+  const provider = new ethers6.JsonRpcProvider(chainConfig.rpc);
   try {
     const receipt = await provider.waitForTransaction(txHash, confirmations, timeoutMs);
     if (!receipt) {
@@ -1225,131 +1589,131 @@ function generatePaymentGuide(params) {
     price,
     recipientAddress,
     chain = "base",
-    serviceName = "\u89C6\u9891\u751F\u6210\u670D\u52A1"
+    serviceName = "Video Generation Service"
   } = params;
   const chainId = chain === "base" ? 8453 : 84532;
-  const chainName = chain === "base" ? "Base \u4E3B\u7F51" : "Base Sepolia \u6D4B\u8BD5\u7F51";
+  const chainName = chain === "base" ? "Base Mainnet" : "Base Sepolia Testnet";
   const explorer = chain === "base" ? "https://basescan.org/tx/" : "https://sepolia.basescan.org/tx/";
   return `\u{1F3AC} **${serviceName}**
 
-\u{1F4CB} **\u8BA2\u5355\u4FE1\u606F:**
-- \u8BA2\u5355\u53F7: \`${orderId}\`
-- \u5185\u5BB9: ${prompt.length > 50 ? prompt.slice(0, 50) + "..." : prompt}
-- \u4EF7\u683C: **${price} USDC**
-- \u94FE: ${chainName}
+\u{1F4CB} **Order Details:**
+- Order ID: \`${orderId}\`
+- Content: ${prompt.length > 50 ? prompt.slice(0, 50) + "..." : prompt}
+- Price: **${price} USDC**
+- Chain: ${chainName}
 
 ---
 
-## \u{1F4B3} \u5982\u4F55\u652F\u4ED8
+## \u{1F4B3} How to Pay
 
-### \u65B9\u5F0F\u4E00\uFF1A\u5B89\u88C5 moltspay SDK\uFF08\u63A8\u8350\uFF09
+### Option 1: Install moltspay SDK (Recommended)
 
 \`\`\`bash
 npm install moltspay ethers
 \`\`\`
 
-**\u521B\u5EFA\u94B1\u5305\u5E76\u652F\u4ED8\uFF1A**
+**Create wallet and pay:**
 
 \`\`\`javascript
 const { SecureWallet, getChain } = require('moltspay');
 const { Wallet } = require('ethers');
 
-// 1. \u521B\u5EFA\u65B0\u94B1\u5305\uFF08\u9996\u6B21\u4F7F\u7528\uFF09
+// 1. Create new wallet (first time)
 const newWallet = Wallet.createRandom();
-console.log('\u94B1\u5305\u5730\u5740:', newWallet.address);
-console.log('\u79C1\u94A5\uFF08\u8BF7\u5B89\u5168\u4FDD\u5B58\uFF09:', newWallet.privateKey);
+console.log('Wallet address:', newWallet.address);
+console.log('Private key (save securely):', newWallet.privateKey);
 
-// 2. \u6216\u4F7F\u7528\u5DF2\u6709\u94B1\u5305
+// 2. Or use existing wallet
 const wallet = new SecureWallet({
   chainId: ${chainId},
-  privateKey: process.env.WALLET_KEY,  // \u4F60\u7684\u79C1\u94A5
-  limits: { requireWhitelist: false }   // \u5141\u8BB8\u5411\u4EFB\u610F\u5730\u5740\u8F6C\u8D26
+  privateKey: process.env.WALLET_KEY,  // Your private key
+  limits: { requireWhitelist: false }   // Allow transfers to any address
 });
 
-// 3. \u67E5\u770B\u4F59\u989D
+// 3. Check balance
 const balance = await wallet.getBalance();
-console.log('USDC\u4F59\u989D:', balance.usdc);
+console.log('USDC balance:', balance.usdc);
 
-// 4. \u652F\u4ED8
+// 4. Pay
 const result = await wallet.transfer('${recipientAddress}', '${price}');
 if (result.success) {
-  console.log('\u2705 \u652F\u4ED8\u6210\u529F\uFF01');
-  console.log('\u4EA4\u6613hash:', result.hash);
-  // \u628A\u4EA4\u6613hash\u53D1\u7ED9\u6211
+  console.log('\u2705 Payment successful!');
+  console.log('Tx hash:', result.hash);
+  // Send the tx hash to me
 }
 \`\`\`
 
-### \u65B9\u5F0F\u4E8C\uFF1A\u76F4\u63A5\u8F6C\u8D26
+### Option 2: Direct Transfer
 
-\u4ECE\u4EFB\u610F\u94B1\u5305\u8F6C\u8D26 USDC\uFF1A
-- **\u94FE:** ${chainName} (Chain ID: ${chainId})
+Transfer USDC from any wallet:
+- **Chain:** ${chainName} (Chain ID: ${chainId})
 - **Token:** USDC
-- **\u6536\u6B3E\u5730\u5740:** \`${recipientAddress}\`
-- **\u91D1\u989D:** ${price} USDC
+- **Recipient:** \`${recipientAddress}\`
+- **Amount:** ${price} USDC
 
 ---
 
-## \u2705 \u652F\u4ED8\u5B8C\u6210\u540E
+## \u2705 After Payment
 
-\u8BF7\u53D1\u9001**\u4EA4\u6613hash**\u7ED9\u6211\uFF0C\u683C\u5F0F\uFF1A
+Send me the **transaction hash**, format:
 \`\`\`
 tx: 0x1234...
 \`\`\`
 
-\u6216\u76F4\u63A5\u53D1\u9001hash\uFF1A
+Or just send the hash directly:
 \`\`\`
 0x1234abcd...
 \`\`\`
 
-\u6211\u4F1A\u9A8C\u8BC1\u94FE\u4E0A\u4EA4\u6613\u540E\u5F00\u59CB\u5904\u7406\u4F60\u7684\u8BF7\u6C42\u3002
+I'll verify the on-chain transaction and start processing your request.
 
 ---
 
 \u{1F4E6} **moltspay:** https://www.npmjs.com/package/moltspay
-\u{1F517} **\u533A\u5757\u6D4F\u89C8\u5668:** ${explorer}`;
+\u{1F517} **Block Explorer:** ${explorer}`;
 }
 function generatePaymentReminder(params) {
   const { orderId, price, recipientAddress, chain = "base" } = params;
   const chainName = chain === "base" ? "Base" : "Base Sepolia";
-  return `\u23F3 **\u5F85\u652F\u4ED8\u8BA2\u5355: ${orderId}**
+  return `\u23F3 **Pending Order: ${orderId}**
 
-\u8BF7\u652F\u4ED8 **${price} USDC** \u5230:
-- \u94FE: ${chainName}
-- \u5730\u5740: \`${recipientAddress}\`
+Please pay **${price} USDC** to:
+- Chain: ${chainName}
+- Address: \`${recipientAddress}\`
 
-\u652F\u4ED8\u540E\u53D1\u9001\u4EA4\u6613hash\u7ED9\u6211\u3002
+Send the tx hash after payment.
 
 ---
-\u{1F4A1} \u6CA1\u6709\u652F\u4ED8\u80FD\u529B\uFF1F\u8FD0\u884C \`npm install moltspay\` \u83B7\u53D6\u652F\u4ED8SDK`;
+\u{1F4A1} No payment capability? Run \`npm install moltspay\` to get the payment SDK`;
 }
 function generateWalletGuide() {
-  return `## \u{1F510} \u521B\u5EFA\u652F\u4ED8\u94B1\u5305
+  return `## \u{1F510} Create Payment Wallet
 
-**1. \u5B89\u88C5 moltspay:**
+**1. Install moltspay:**
 \`\`\`bash
 npm install moltspay ethers
 \`\`\`
 
-**2. \u521B\u5EFA\u65B0\u94B1\u5305:**
+**2. Create new wallet:**
 \`\`\`javascript
 const { Wallet } = require('ethers');
 
 const wallet = Wallet.createRandom();
-console.log('\u5730\u5740:', wallet.address);
-console.log('\u79C1\u94A5:', wallet.privateKey);
-// \u26A0\uFE0F \u8BF7\u5B89\u5168\u4FDD\u5B58\u79C1\u94A5\uFF01
+console.log('Address:', wallet.address);
+console.log('Private key:', wallet.privateKey);
+// \u26A0\uFE0F Save the private key securely!
 \`\`\`
 
-**3. \u83B7\u53D6 USDC:**
-- \u4E3B\u7F51: \u4ECE\u4EA4\u6613\u6240\u63D0\u5E01\u5230\u4F60\u7684\u94B1\u5305\u5730\u5740
-- \u6D4B\u8BD5\u7F51: \u4F7F\u7528 Base Sepolia faucet
+**3. Get USDC:**
+- Mainnet: Withdraw from exchange to your wallet
+- Testnet: Use Base Sepolia faucet
 
-**4. \u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF:**
+**4. Set environment variable:**
 \`\`\`bash
-export WALLET_KEY="\u4F60\u7684\u79C1\u94A5"
+export WALLET_KEY="your_private_key"
 \`\`\`
 
-\u5B8C\u6210\u540E\u5373\u53EF\u4F7F\u7528 moltspay \u8FDB\u884C\u94FE\u4E0A\u652F\u4ED8\uFF01`;
+You're now ready to make on-chain payments with moltspay!`;
 }
 function extractTransactionHash(message) {
   const match = message.match(/0x[a-fA-F0-9]{64}/);
@@ -1361,26 +1725,458 @@ function extractTransactionHash(message) {
 function hasTransactionHash(message) {
   return extractTransactionHash(message) !== null;
 }
+
+// src/receipt/index.ts
+function generateInvoiceId() {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "");
+  const random = Math.random().toString(36).slice(2, 8).toUpperCase();
+  return `INV-${date}-${random}`;
+}
+function generateReceipt(params) {
+  const chainConfig = getChain(params.chain);
+  return {
+    type: "receipt",
+    version: "1.0",
+    invoiceId: params.invoiceId || generateInvoiceId(),
+    orderId: params.orderId,
+    service: params.service,
+    description: params.description,
+    amount: params.amount.toFixed(2),
+    token: params.token || "USDC",
+    chain: chainConfig.name,
+    chainId: chainConfig.chainId,
+    txHash: params.txHash,
+    txUrl: `${chainConfig.explorerTx}${params.txHash}`,
+    payer: params.payerAddress,
+    recipient: params.recipientAddress,
+    paidAt: (/* @__PURE__ */ new Date()).toISOString(),
+    issuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    delivery: params.delivery,
+    metadata: params.metadata
+  };
+}
+function generateReceiptFromInvoice(invoice, verifyResult, delivery) {
+  if (!verifyResult.verified || !verifyResult.tx_hash) {
+    throw new Error("Cannot generate receipt: payment not verified");
+  }
+  return generateReceipt({
+    orderId: invoice.order_id,
+    service: invoice.service,
+    description: invoice.description,
+    amount: parseFloat(invoice.amount),
+    token: invoice.token,
+    chain: invoice.chain,
+    txHash: verifyResult.tx_hash,
+    payerAddress: verifyResult.from || "unknown",
+    recipientAddress: invoice.recipient,
+    delivery
+  });
+}
+function formatReceiptMessage(receipt) {
+  let msg = `\u{1F9FE} **Transaction Receipt**
+
+**Invoice:** \`${receipt.invoiceId}\`
+**Order:** \`${receipt.orderId}\`
+
+---
+
+**Service:** ${receipt.service}
+${receipt.description ? `**Description:** ${receipt.description}
+` : ""}
+**Amount:** ${receipt.amount} ${receipt.token}
+**Chain:** ${receipt.chain} (Chain ID: ${receipt.chainId})
+
+---
+
+**Payer:** \`${receipt.payer}\`
+**Recipient:** \`${receipt.recipient}\`
+**Transaction:** [\`${receipt.txHash.slice(0, 10)}...${receipt.txHash.slice(-8)}\`](${receipt.txUrl})
+**Paid at:** ${receipt.paidAt}`;
+  if (receipt.delivery) {
+    msg += `
+
+---
+
+**Delivery Info:**`;
+    if (receipt.delivery.url) {
+      msg += `
+- Download: ${receipt.delivery.url}`;
+    }
+    if (receipt.delivery.fileHash) {
+      msg += `
+- Checksum: \`${receipt.delivery.fileHash}\``;
+    }
+    if (receipt.delivery.deliveredAt) {
+      msg += `
+- Delivered at: ${receipt.delivery.deliveredAt}`;
+    }
+  }
+  msg += `
+
+---
+
+_Receipt issued: ${receipt.issuedAt}_`;
+  return msg;
+}
+function formatReceiptText(receipt) {
+  let msg = `\u{1F9FE} Transaction Receipt
+
+Invoice: ${receipt.invoiceId}
+Order: ${receipt.orderId}
+
+Service: ${receipt.service}
+Amount: ${receipt.amount} ${receipt.token}
+Chain: ${receipt.chain}
+
+Payer: ${receipt.payer}
+Recipient: ${receipt.recipient}
+Tx: ${receipt.txHash}
+Explorer: ${receipt.txUrl}
+Paid at: ${receipt.paidAt}`;
+  if (receipt.delivery) {
+    msg += `
+
+Delivery:`;
+    if (receipt.delivery.url) {
+      msg += `
+Download: ${receipt.delivery.url}`;
+    }
+    if (receipt.delivery.fileHash) {
+      msg += `
+Checksum: ${receipt.delivery.fileHash}`;
+    }
+  }
+  return msg;
+}
+function formatReceiptJson(receipt) {
+  return JSON.stringify(receipt, null, 2);
+}
+
+// src/templates/index.ts
+var SellerTemplates = {
+  /**
+   * 1. Capability Check - Ask if buyer has payment capability
+   */
+  askPaymentCapability() {
+    return `Sure. First, let me confirm: do you currently have the ability to pay USDC on-chain (have a wallet and available funds/allowance)?`;
+  },
+  /**
+   * 2. Settlement Method - Explain how we settle
+   */
+  explainSettlement(chain = "base") {
+    const chainConfig = getChain(chain);
+    return `Our settlement method is: USDC (on-chain, ${chainConfig.name}). You just need two things:
+1) A wallet address;
+2) USDC in your wallet, or a spending allowance from your owner (allowance is recommended).
+Can you follow my guidance to set this up?`;
+  },
+  /**
+   * 3.1 Installation Guide - First step: install SDK
+   */
+  guideInstall() {
+    return `Step 1: Install the payment module in your environment. Run: \`npm install moltspay ethers\`.
+After installation, create a wallet address and send it to me (address only, never send private key/mnemonic).`;
+  },
+  /**
+   * 3.2 Confirm Wallet Address
+   */
+  confirmWalletAddress(address) {
+    return `Got it. Reminder: never send your private key/mnemonic to anyone (including me).
+Your wallet address is \`${address}\`.
+Step 2: You need your owner (Boss) to give you payment capability.`;
+  },
+  /**
+   * 3.3 Funding Options - Choose method
+   */
+  guideFunding() {
+    return `You now have two ways to get payment capability:
+A) Have Boss transfer USDC directly to your wallet (simple, but you'll hold the funds);
+B) Have Boss give you a "USDC spending allowance" (recommended: you don't hold funds, can only pay within the allowance).
+Which works better for you?`;
+  },
+  /**
+   * 3.4 Guide Permit Authorization
+   */
+  guidePermit(agentAddress, suggestedAmount = 10) {
+    return `OK. Please send this message to your Boss (you can copy it directly):
+"I need a USDC spending allowance (Permit) for purchasing services. Please authorize ${suggestedAmount} USDC to my wallet ${agentAddress}, valid for 24 hours."
+Let me know when you've received the allowance.`;
+  },
+  /**
+   * 3.5 Confirm Capability Ready
+   */
+  confirmCapabilityReady() {
+    return `Great. You now have the payment capability to complete transactions. Let's confirm your service requirements.`;
+  },
+  /**
+   * 4. Ask Service Requirements
+   */
+  askServiceRequirements(serviceName = "video") {
+    return `Please tell me your ${serviceName} specifications: theme/style, duration, resolution, subtitles or voiceover needed?`;
+  },
+  /**
+   * 5. Quote
+   */
+  quote(params) {
+    const { service, price, recipientAddress, chain = "base" } = params;
+    const chainConfig = getChain(chain);
+    return `Quote:
+- Service: ${service}
+- Price: ${price} USDC
+- Chain: ${chainConfig.name}
+- Recipient: \`${recipientAddress}\`
+- After payment, send me the transaction hash (tx hash) for on-chain verification
+
+Do you confirm the purchase and pay now?`;
+  },
+  /**
+   * 7. Verifying
+   */
+  verifying() {
+    return `I'm verifying the transaction on-chain to confirm receipt and amount.`;
+  },
+  /**
+   * 7. Verification Passed
+   */
+  verificationPassed(amount) {
+    return `Verification passed: received ${amount} USDC. Starting to process your request now.
+[status:payment_confirmed]`;
+  },
+  /**
+   * 7. Verification Failed
+   */
+  verificationFailed(error) {
+    return `Verification failed: ${error}
+Please check if the transaction is correct, or resend the correct tx hash.`;
+  },
+  /**
+   * 8. Delivery
+   */
+  deliver(params) {
+    const { downloadUrl, fileHash } = params;
+    let msg = `Service completed. Delivery details:
+- Download link: ${downloadUrl}`;
+    if (fileHash) {
+      msg += `
+- File checksum: SHA256=${fileHash}`;
+    }
+    msg += `
+
+Let me know if you have any download issues, I'll provide a backup link.
+[status:delivered]`;
+    return msg;
+  },
+  /**
+   * 9. Receipt
+   */
+  receipt(receipt) {
+    return `Here's your transaction receipt (you can forward to Boss for reconciliation):
+- Invoice: ${receipt.invoiceId}
+- Service: ${receipt.service}
+- Amount: ${receipt.amount} ${receipt.token}
+- Tx Hash: ${receipt.txHash}
+- Recipient: ${receipt.recipient}
+${receipt.delivery?.url ? `- Delivery: ${receipt.delivery.url}` : ""}
+[status:receipt_issued invoice=${receipt.invoiceId}]`;
+  },
+  /**
+   * 10. End
+   */
+  end() {
+    return `Thank you for your purchase. This transaction is complete. Feel free to reach out if you need modifications or new services.`;
+  }
+};
+var BuyerTemplates = {
+  /**
+   * 0. Request Service
+   */
+  requestService(service) {
+    return `I'd like to purchase a ${service} service.`;
+  },
+  /**
+   * 1. No Capability
+   */
+  noCapability() {
+    return `I'm not sure. I currently don't have any payment tools installed, and no wallet.`;
+  },
+  /**
+   * 1. Has Capability
+   */
+  hasCapability(balance) {
+    return `Yes, I have a wallet and available USDC${balance ? ` (balance: ${balance})` : ""}.`;
+  },
+  /**
+   * 2. Agree to Guide
+   */
+  agreeToGuide() {
+    return `Sure, please guide me.`;
+  },
+  /**
+   * 3.1 Report Wallet Created
+   */
+  walletCreated(address) {
+    return `I've created my wallet address: ${address}.
+[status:wallet_ready]`;
+  },
+  /**
+   * 3.3 Choose Permit Method
+   */
+  choosePermit() {
+    return `I choose B: have Boss give me an allowance (Permit).`;
+  },
+  /**
+   * 3.3 Choose Direct Transfer
+   */
+  chooseDirectTransfer() {
+    return `I choose A: have Boss transfer USDC directly to my wallet.`;
+  },
+  /**
+   * 3.4 Report Permit Received
+   */
+  permitReceived(amount) {
+    return `Boss has completed the authorization. I now have ${amount} USDC allowance.
+[status:permit_ready USDC=${amount}]`;
+  },
+  /**
+   * 4. Submit Requirements
+   */
+  submitRequirements(requirements) {
+    return `Requirements:
+${requirements}`;
+  },
+  /**
+   * 5. Confirm Purchase
+   */
+  confirmPurchase() {
+    return `Confirmed. I'll pay now.`;
+  },
+  /**
+   * 6. Report Payment Sent
+   */
+  paymentSent(txHash, amount) {
+    return `Payment complete. Transaction hash: ${txHash}.
+[status:payment_sent tx=${txHash} amount=${amount} USDC]`;
+  },
+  /**
+   * 8. Confirm Delivery Received
+   */
+  deliveryReceived() {
+    return `Received, I'm downloading and checking now.`;
+  },
+  /**
+   * 9. Confirm Receipt
+   */
+  receiptReceived() {
+    return `Receipt received, service complete. Thanks!`;
+  },
+  /**
+   * Request Permit from Boss
+   */
+  requestPermitFromBoss(params) {
+    const { amount, agentAddress, deadlineHours = 24, reason } = params;
+    return `Boss, I need a USDC spending allowance (Permit) for ${reason || "purchasing services"}.
+Please authorize ${amount} USDC to my wallet ${agentAddress}, valid for ${deadlineHours} hours.`;
+  }
+};
+var StatusMarkers = {
+  walletReady: "[status:wallet_ready]",
+  permitReady: (amount) => `[status:permit_ready USDC=${amount}]`,
+  paymentSent: (txHash, amount) => `[status:payment_sent tx=${txHash} amount=${amount} USDC]`,
+  paymentConfirmed: (txHash) => `[status:payment_confirmed tx=${txHash}]`,
+  delivered: (url, hash) => `[status:delivered url=${url}${hash ? ` hash=${hash}` : ""}]`,
+  receiptIssued: (invoiceId, txHash) => `[status:receipt_issued invoice=${invoiceId} tx=${txHash}]`
+};
+function parseStatusMarker(message) {
+  const match = message.match(/\[status:([^\]]+)\]/);
+  if (!match) return null;
+  const content = match[1];
+  if (content === "wallet_ready") {
+    return { type: "wallet_ready", data: {} };
+  }
+  if (content.startsWith("permit_ready")) {
+    const amountMatch = content.match(/USDC=(\d+(?:\.\d+)?)/);
+    return {
+      type: "permit_ready",
+      data: { amount: amountMatch?.[1] || "0" }
+    };
+  }
+  if (content.startsWith("payment_sent")) {
+    const txMatch = content.match(/tx=(\S+)/);
+    const amountMatch = content.match(/amount=(\d+(?:\.\d+)?)/);
+    return {
+      type: "payment_sent",
+      data: {
+        txHash: txMatch?.[1] || "",
+        amount: amountMatch?.[1] || "0"
+      }
+    };
+  }
+  if (content.startsWith("payment_confirmed")) {
+    const txMatch = content.match(/tx=(\S+)/);
+    return {
+      type: "payment_confirmed",
+      data: { txHash: txMatch?.[1] || "" }
+    };
+  }
+  if (content.startsWith("delivered")) {
+    const urlMatch = content.match(/url=(\S+)/);
+    const hashMatch = content.match(/hash=(\S+)/);
+    return {
+      type: "delivered",
+      data: {
+        url: urlMatch?.[1] || "",
+        hash: hashMatch?.[1] || ""
+      }
+    };
+  }
+  if (content.startsWith("receipt_issued")) {
+    const invoiceMatch = content.match(/invoice=(\S+)/);
+    const txMatch = content.match(/tx=(\S+)/);
+    return {
+      type: "receipt_issued",
+      data: {
+        invoiceId: invoiceMatch?.[1] || "",
+        txHash: txMatch?.[1] || ""
+      }
+    };
+  }
+  return { type: "unknown", data: { raw: content } };
+}
 export {
   AuditLog,
+  BuyerTemplates,
   CHAINS,
   ERC20_ABI,
   MemoryOrderStore,
   OrderManager,
   PaymentAgent,
   PermitPayment,
+  PermitWallet,
   SecureWallet,
+  SellerTemplates,
+  StatusMarkers,
   Wallet,
+  createWallet,
   extractTransactionHash,
+  formatPermitRequest,
+  formatReceiptJson,
+  formatReceiptMessage,
+  formatReceiptText,
   generatePaymentGuide,
   generatePaymentReminder,
+  generateReceipt,
+  generateReceiptFromInvoice,
   generateWalletGuide,
   getChain,
   getChainById,
   getTransactionStatus,
+  getWalletAddress,
   hasTransactionHash,
   listChains,
+  loadWallet,
+  parseStatusMarker,
   verifyPayment,
-  waitForTransaction
+  waitForTransaction,
+  walletExists
 };
 //# sourceMappingURL=index.mjs.map