anchor-sdk 0.1.43-beta.1 → 0.1.43-beta.4

package/dist/AnchorPayClient.js

@@ -1,908 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnchorPayClient = void 0;
-const viem_1 = require("viem");
-const constants_1 = require("./constants");
-const AnchorPay_json_1 = __importDefault(require("./abi/AnchorPay.json"));
-/**
- * AnchorPay 客户端
- * 用于与 AnchorPay 合约交互
- */
-class AnchorPayClient {
-    /**
-     * 创建 AnchorPay 客户端
-     * @param publicClient 公共客户端（只读操作）
-     * @param network 网络配置
-     * @param walletClient 钱包客户端（写入操作）
-     * @param account 账户（可选，如果不提供则使用只读模式）
-     */
-    constructor(publicClient, network, walletClient, account, contracts) {
-        this.publicClient = publicClient;
-        this.network = network;
-        this.walletClient = walletClient;
-        this.account = account;
-        this.contracts = contracts || {};
-    }
-    /**
-     * 发送 ETH
-     * @param recipient 接收者地址
-     * @param amount 金额（单位：wei）
-     * @param data 附加数据
-     * @param options 交易选项
-     * @returns 交易收据或交易数据
-     */
-    async sendETH(recipient, amount, data = "0x", options) {
-        // 如果需要发送交易，但没有钱包客户端或账户
-        if (options?.sendTransaction !== false &&
-            (!this.walletClient || !this.account)) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        // 准备交易数据
-        const calldata = (0, viem_1.encodeFunctionData)({
-            abi: AnchorPay_json_1.default,
-            functionName: "send",
-            args: [recipient, constants_1.NATIVE_TOKEN_ADDRESS, amount, data],
-        });
-        // 如果不需要发送交易，只返回交易数据（AA 模式）
-        if (options?.sendTransaction === false) {
-            return {
-                to: this.contracts?.anchorPay || "",
-                data: calldata,
-                value: amount,
-            };
-        }
-        // 估算 gas 和费用
-        const { maxFeePerGas, maxPriorityFeePerGas } = await this.publicClient.estimateFeesPerGas();
-        const gas = await this.publicClient.estimateGas({
-            to: this.contracts?.anchorPay || "",
-            data: calldata,
-            value: amount,
-            account: this.account,
-        });
-        // 发送交易（EOA 模式）
-        if (!this.walletClient || !this.account) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        const txHash = await this.walletClient.sendTransaction({
-            account: this.account,
-            to: this.contracts?.anchorPay || "",
-            data: calldata,
-            value: amount,
-            maxFeePerGas: options?.maxFeePerGas || maxFeePerGas,
-            maxPriorityFeePerGas: options?.maxPriorityFeePerGas || maxPriorityFeePerGas,
-            gas: options?.gas || gas,
-            chain: this.publicClient.chain,
-        });
-        // 等待交易确认并返回收据
-        const receipt = await this.publicClient.waitForTransactionReceipt({
-            hash: txHash,
-        });
-        return receipt;
-    }
-    /**
-     * 发送 ERC20 代币
-     * @param recipient 接收者地址
-     * @param tokenAddress ERC20 代币地址
-     * @param amount 金额
-     * @param data 附加数据
-     * @param options 交易选项
-     * @returns 交易收据或交易数据
-     */
-    async sendERC20(recipient, tokenAddress, amount, data = "0x", options) {
-        // 如果需要发送交易，但没有钱包客户端或账户
-        if (options?.sendTransaction !== false &&
-            (!this.walletClient || !this.account)) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        // 如果需要自动批准，则先批准代币（默认开启自动批准）
-        if (options?.autoApprove !== false && this.walletClient && this.account) {
-            try {
-                console.log(`Checking ERC20 token approval status: ${tokenAddress}`);
-                // 检查授权
-                const allowance = (await this.publicClient.readContract({
-                    address: tokenAddress,
-                    abi: constants_1.ERC20_ABI,
-                    functionName: "allowance",
-                    args: [this.account.address, this.contracts?.anchorPay],
-                }));
-                console.log(`Current allowance: ${allowance}, Required amount: ${amount}, AnchorPay contract address: ${this.contracts?.anchorPay}`);
-                if (allowance < amount) {
-                    console.log(`Approving ${amount} tokens to AnchorPay contract...`);
-                    // 批准代币 - 使用最大可能值进行授权，避免多次授权
-                    const maxApproveAmount = 2n ** 256n - 1n;
-                    // 估算 gas 和费用
-                    const { maxFeePerGas: approveMaxFeePerGas, maxPriorityFeePerGas: approveMaxPriorityFeePerGas, } = await this.publicClient.estimateFeesPerGas();
-                    const approveCalldata = (0, viem_1.encodeFunctionData)({
-                        abi: constants_1.ERC20_ABI,
-                        functionName: "approve",
-                        args: [this.contracts?.anchorPay, maxApproveAmount],
-                    });
-                    const approveGas = await this.publicClient.estimateGas({
-                        to: tokenAddress,
-                        data: approveCalldata,
-                        value: 0n,
-                        account: this.account,
-                    });
-                    const approveTxHash = await this.walletClient.writeContract({
-                        account: this.account,
-                        address: tokenAddress,
-                        abi: constants_1.ERC20_ABI,
-                        functionName: "approve",
-                        args: [this.contracts?.anchorPay, maxApproveAmount],
-                        chain: this.publicClient.chain,
-                        maxFeePerGas: approveMaxFeePerGas,
-                        maxPriorityFeePerGas: approveMaxPriorityFeePerGas,
-                        gas: approveGas,
-                    });
-                    console.log(`Approval transaction sent, hash: ${approveTxHash}`);
-                    // 等待交易确认
-                    await this.publicClient.waitForTransactionReceipt({
-                        hash: approveTxHash,
-                    });
-                    console.log(`Approval transaction confirmed`);
-                }
-                else {
-                    console.log(`Sufficient allowance already exists, no need for additional approval`);
-                }
-            }
-            catch (error) {
-                console.error(`Approval failed:`, error);
-                throw new Error(`ERC20 approval failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        // 准备交易数据
-        const calldata = (0, viem_1.encodeFunctionData)({
-            abi: AnchorPay_json_1.default,
-            functionName: "send",
-            args: [recipient, tokenAddress, amount, data],
-        });
-        // 如果不需要发送交易，只返回交易数据（AA 模式）
-        if (options?.sendTransaction === false) {
-            return {
-                to: this.contracts?.anchorPay || "",
-                data: calldata,
-                value: 0n,
-            };
-        }
-        // 估算 gas 和费用
-        const { maxFeePerGas, maxPriorityFeePerGas } = await this.publicClient.estimateFeesPerGas();
-        const gas = await this.publicClient.estimateGas({
-            to: this.contracts?.anchorPay || "",
-            data: calldata,
-            value: 0n,
-            account: this.account,
-        });
-        // 发送交易（EOA 模式）
-        if (!this.walletClient || !this.account) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        const txHash = await this.walletClient.sendTransaction({
-            account: this.account,
-            to: this.contracts?.anchorPay || "",
-            data: calldata,
-            // value: amount,
-            maxFeePerGas: options?.maxFeePerGas || maxFeePerGas,
-            maxPriorityFeePerGas: options?.maxPriorityFeePerGas || maxPriorityFeePerGas,
-            gas: options?.gas || gas,
-            chain: this.publicClient.chain,
-        });
-        // 等待交易确认并返回收据
-        const receipt = await this.publicClient.waitForTransactionReceipt({
-            hash: txHash,
-        });
-        return receipt;
-    }
-    /**
-     * 获取接口实现者
-     * @param account 账户地址
-     * @param interfaceHash 接口哈希
-     * @returns 实现者地址
-     */
-    async getInterfaceImplementer(account, interfaceHash) {
-        return (await this.publicClient.readContract({
-            address: this.contracts?.anchorPay || "",
-            abi: AnchorPay_json_1.default,
-            functionName: "getInterfaceImplementer",
-            args: [account, interfaceHash],
-        }));
-    }
-    /**
-     * 设置接口实现者（仅限管理员）
-     * @param account 账户地址
-     * @param interfaceHash 接口哈希
-     * @param implementer 实现者地址
-     * @returns 交易收据
-     */
-    async setInterfaceImplementer(account, interfaceHash, implementer) {
-        if (!this.walletClient || !this.account) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        // 估算 gas 和费用
-        const { maxFeePerGas, maxPriorityFeePerGas } = await this.publicClient.estimateFeesPerGas();
-        const calldata = (0, viem_1.encodeFunctionData)({
-            abi: AnchorPay_json_1.default,
-            functionName: "setInterfaceImplementer",
-            args: [account, interfaceHash, implementer],
-        });
-        const gas = await this.publicClient.estimateGas({
-            to: this.contracts?.anchorPay || "",
-            data: calldata,
-            value: 0n,
-            account: this.account,
-        });
-        const txHash = await this.walletClient.writeContract({
-            account: this.account,
-            address: this.contracts?.anchorPay || "",
-            abi: AnchorPay_json_1.default,
-            functionName: "setInterfaceImplementer",
-            args: [account, interfaceHash, implementer],
-            chain: this.publicClient.chain,
-            maxFeePerGas,
-            maxPriorityFeePerGas,
-            gas,
-        });
-        // 等待交易确认并返回收据
-        const receipt = await this.publicClient.waitForTransactionReceipt({
-            hash: txHash,
-        });
-        return receipt;
-    }
-    /**
-     * 获取 ERC20 代币批准的交易数据（用于 AA 模式）
-     * @param tokenAddress ERC20 代币地址
-     * @param amount 批准金额
-     * @param spender 花费者地址（默认为 AnchorPay 合约地址）
-     * @returns 交易数据对象，包含 to、data 和 value 字段
-     */
-    getERC20ApprovalData(tokenAddress, amount, spender) {
-        const approveSpender = spender || this.contracts?.anchorPay || "";
-        // 编码 approve 函数调用
-        const data = (0, viem_1.encodeFunctionData)({
-            abi: constants_1.ERC20_ABI,
-            functionName: "approve",
-            args: [approveSpender, amount],
-        });
-        return {
-            to: tokenAddress,
-            data,
-            value: 0n, // ERC20 批准不需要发送 ETH
-        };
-    }
-    /**
-     * 查询账户在 AnchorPay 合约中的代币余额
-     * @param account 账户地址
-     * @param token 代币地址（使用 NATIVE_TOKEN_ADDRESS 表示原生代币）
-     * @returns 余额
-     */
-    async balanceOf(account, token) {
-        return (await this.publicClient.readContract({
-            address: this.contracts?.anchorPay || "",
-            abi: AnchorPay_json_1.default,
-            functionName: "balanceOf",
-            args: [account, token],
-        }));
-    }
-    /**
-     * 为指定地址存入 ETH 到 AnchorPay 合约
-     * @param recipient 接收者地址
-     * @param amount 金额（单位：wei）
-     * @param options 交易选项
-     * @returns 交易收据或交易数据
-     */
-    async depositETH(recipient, amount, options) {
-        // 如果需要发送交易，但没有钱包客户端或账户
-        if (options?.sendTransaction !== false &&
-            (!this.walletClient || !this.account)) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        // 准备交易数据
-        const calldata = (0, viem_1.encodeFunctionData)({
-            abi: AnchorPay_json_1.default,
-            functionName: "depositFor",
-            args: [recipient, constants_1.NATIVE_TOKEN_ADDRESS, amount],
-        });
-        // 如果不需要发送交易，只返回交易数据（AA 模式）
-        if (options?.sendTransaction === false) {
-            return {
-                to: this.contracts?.anchorPay || "",
-                data: calldata,
-                value: amount,
-            };
-        }
-        // 估算 gas 和费用
-        const { maxFeePerGas, maxPriorityFeePerGas } = await this.publicClient.estimateFeesPerGas();
-        const gas = await this.publicClient.estimateGas({
-            to: this.contracts?.anchorPay || "",
-            data: calldata,
-            value: amount,
-            account: this.account,
-        });
-        // 发送交易（EOA 模式）
-        if (!this.walletClient || !this.account) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        const txHash = await this.walletClient.sendTransaction({
-            account: this.account,
-            to: this.contracts?.anchorPay || "",
-            data: calldata,
-            value: amount,
-            maxFeePerGas: options?.maxFeePerGas || maxFeePerGas,
-            maxPriorityFeePerGas: options?.maxPriorityFeePerGas || maxPriorityFeePerGas,
-            gas: options?.gas || gas,
-            chain: this.publicClient.chain,
-        });
-        // 等待交易确认并返回收据
-        const receipt = await this.publicClient.waitForTransactionReceipt({
-            hash: txHash,
-        });
-        return receipt;
-    }
-    /**
-     * 为指定地址存入 ERC20 代币到 AnchorPay 合约
-     * @param recipient 接收者地址
-     * @param tokenAddress ERC20 代币地址
-     * @param amount 金额
-     * @param options 交易选项
-     * @returns 交易收据或交易数据
-     */
-    async depositERC20(recipient, tokenAddress, amount, options) {
-        // 如果需要发送交易，但没有钱包客户端或账户
-        if (options?.sendTransaction !== false &&
-            (!this.walletClient || !this.account)) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        // 如果需要自动批准，则先批准代币（默认开启自动批准）
-        if (options?.autoApprove !== false && this.walletClient && this.account) {
-            try {
-                console.log(`Checking ERC20 token approval status: ${tokenAddress}`);
-                // 检查授权
-                const allowance = (await this.publicClient.readContract({
-                    address: tokenAddress,
-                    abi: constants_1.ERC20_ABI,
-                    functionName: "allowance",
-                    args: [this.account.address, this.contracts?.anchorPay],
-                }));
-                console.log(`Current allowance: ${allowance}, Required amount: ${amount}, AnchorPay contract address: ${this.contracts?.anchorPay}`);
-                if (allowance < amount) {
-                    console.log(`Approving ${amount} tokens to AnchorPay contract...`);
-                    // 批准代币 - 使用最大可能值进行授权，避免多次授权
-                    const maxApproveAmount = 2n ** 256n - 1n;
-                    // 估算 gas 和费用
-                    const { maxFeePerGas: approveMaxFeePerGas, maxPriorityFeePerGas: approveMaxPriorityFeePerGas, } = await this.publicClient.estimateFeesPerGas();
-                    const approveCalldata = (0, viem_1.encodeFunctionData)({
-                        abi: constants_1.ERC20_ABI,
-                        functionName: "approve",
-                        args: [this.contracts?.anchorPay, maxApproveAmount],
-                    });
-                    const approveGas = await this.publicClient.estimateGas({
-                        to: tokenAddress,
-                        data: approveCalldata,
-                        value: 0n,
-                        account: this.account,
-                    });
-                    const approveTxHash = await this.walletClient.writeContract({
-                        account: this.account,
-                        address: tokenAddress,
-                        abi: constants_1.ERC20_ABI,
-                        functionName: "approve",
-                        args: [this.contracts?.anchorPay, maxApproveAmount],
-                        chain: this.publicClient.chain,
-                        maxFeePerGas: approveMaxFeePerGas,
-                        maxPriorityFeePerGas: approveMaxPriorityFeePerGas,
-                        gas: approveGas,
-                    });
-                    console.log(`Approval transaction sent, hash: ${approveTxHash}`);
-                    // 等待交易确认
-                    await this.publicClient.waitForTransactionReceipt({
-                        hash: approveTxHash,
-                    });
-                    console.log(`Approval transaction confirmed`);
-                }
-                else {
-                    console.log(`Sufficient allowance already exists, no need for additional approval`);
-                }
-            }
-            catch (error) {
-                console.error(`Approval failed:`, error);
-                throw new Error(`ERC20 approval failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        // 准备交易数据
-        const calldata = (0, viem_1.encodeFunctionData)({
-            abi: AnchorPay_json_1.default,
-            functionName: "depositFor",
-            args: [recipient, tokenAddress, amount],
-        });
-        // 如果不需要发送交易，只返回交易数据（AA 模式）
-        if (options?.sendTransaction === false) {
-            return {
-                to: this.contracts?.anchorPay || "",
-                data: calldata,
-                value: 0n,
-            };
-        }
-        // 估算 gas 和费用
-        const { maxFeePerGas, maxPriorityFeePerGas } = await this.publicClient.estimateFeesPerGas();
-        const gas = await this.publicClient.estimateGas({
-            to: this.contracts?.anchorPay || "",
-            data: calldata,
-            value: 0n,
-            account: this.account,
-        });
-        // 发送交易（EOA 模式）
-        if (!this.walletClient || !this.account) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        const txHash = await this.walletClient.sendTransaction({
-            account: this.account,
-            to: this.contracts?.anchorPay || "",
-            data: calldata,
-            maxFeePerGas: options?.maxFeePerGas || maxFeePerGas,
-            maxPriorityFeePerGas: options?.maxPriorityFeePerGas || maxPriorityFeePerGas,
-            gas: options?.gas || gas,
-            chain: this.publicClient.chain,
-        });
-        // 等待交易确认并返回收据
-        const receipt = await this.publicClient.waitForTransactionReceipt({
-            hash: txHash,
-        });
-        return receipt;
-    }
-    /**
-     * 从 AnchorPay 合约提取代币
-     * @param tokenAddress 代币地址（使用 NATIVE_TOKEN_ADDRESS 表示原生代币）
-     * @param amount 金额
-     * @param options 交易选项
-     * @returns 交易收据
-     */
-    async withdraw(tokenAddress, amount, options) {
-        if (!this.walletClient || !this.account) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        // 估算 gas 和费用
-        const { maxFeePerGas, maxPriorityFeePerGas } = await this.publicClient.estimateFeesPerGas();
-        const calldata = (0, viem_1.encodeFunctionData)({
-            abi: AnchorPay_json_1.default,
-            functionName: "withdraw",
-            args: [tokenAddress, amount],
-        });
-        const gas = await this.publicClient.estimateGas({
-            to: this.contracts?.anchorPay || "",
-            data: calldata,
-            value: 0n,
-            account: this.account,
-        });
-        const txHash = await this.walletClient.sendTransaction({
-            account: this.account,
-            to: this.contracts?.anchorPay || "",
-            data: calldata,
-            maxFeePerGas: options?.maxFeePerGas || maxFeePerGas,
-            maxPriorityFeePerGas: options?.maxPriorityFeePerGas || maxPriorityFeePerGas,
-            gas: options?.gas || gas,
-            chain: this.publicClient.chain,
-        });
-        // 等待交易确认并返回收据
-        const receipt = await this.publicClient.waitForTransactionReceipt({
-            hash: txHash,
-        });
-        return receipt;
-    }
-    /**
-     * 批量存入 ETH（使用 Multicall3）
-     * @param deposits 批量存款参数数组，每项包含接收者地址和金额
-     * @param options 交易选项
-     * @returns 交易收据或交易数据
-     */
-    async batchDepositETH(deposits, options) {
-        if (deposits.length === 0) {
-            throw new Error("No deposits provided");
-        }
-        // 如果需要发送交易，但没有钱包客户端或账户
-        if (options?.sendTransaction !== false &&
-            (!this.walletClient || !this.account)) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        // 准备批量调用数据
-        const calls = deposits.map((deposit) => {
-            const calldata = (0, viem_1.encodeFunctionData)({
-                abi: AnchorPay_json_1.default,
-                functionName: "depositFor",
-                args: [deposit.recipient, constants_1.NATIVE_TOKEN_ADDRESS, deposit.amount],
-            });
-            return {
-                target: this.contracts?.anchorPay || "",
-                allowFailure: false,
-                value: deposit.amount,
-                callData: calldata,
-            };
-        });
-        // 计算总金额
-        const totalValue = deposits.reduce((sum, deposit) => sum + deposit.amount, 0n);
-        // 编码 Multicall3 调用
-        const multicallData = (0, viem_1.encodeFunctionData)({
-            abi: constants_1.MULTICALL3_ABI,
-            functionName: "aggregate3Value",
-            args: [calls],
-        });
-        // 如果不需要发送交易，只返回交易数据（AA 模式）
-        if (options?.sendTransaction === false) {
-            return {
-                to: constants_1.MULTICALL3_ADDRESS,
-                data: multicallData,
-                value: totalValue,
-            };
-        }
-        // 估算 gas 和费用
-        const { maxFeePerGas, maxPriorityFeePerGas } = await this.publicClient.estimateFeesPerGas();
-        const gas = await this.publicClient.estimateGas({
-            to: constants_1.MULTICALL3_ADDRESS,
-            data: multicallData,
-            value: totalValue,
-            account: this.account,
-        });
-        // 发送交易（EOA 模式）
-        if (!this.walletClient || !this.account) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        const txHash = await this.walletClient.sendTransaction({
-            account: this.account,
-            to: constants_1.MULTICALL3_ADDRESS,
-            data: multicallData,
-            value: totalValue,
-            maxFeePerGas: options?.maxFeePerGas || maxFeePerGas,
-            maxPriorityFeePerGas: options?.maxPriorityFeePerGas || maxPriorityFeePerGas,
-            gas: options?.gas || gas,
-            chain: this.publicClient.chain,
-        });
-        // 等待交易确认并返回收据
-        const receipt = await this.publicClient.waitForTransactionReceipt({
-            hash: txHash,
-        });
-        return receipt;
-    }
-    /**
-     * 批量存入 ERC20 代币（使用 Multicall3）
-     * @param tokenAddress ERC20 代币地址
-     * @param deposits 批量存款参数数组
-     * @param options 交易选项
-     * @returns 交易收据或交易数据
-     */
-    async batchDepositERC20(tokenAddress, deposits, options) {
-        if (deposits.length === 0) {
-            throw new Error("No deposits provided");
-        }
-        // 如果需要发送交易，但没有钱包客户端或账户
-        if (options?.sendTransaction !== false &&
-            (!this.walletClient || !this.account)) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        // 计算总金额（用于批准检查）
-        const totalAmount = deposits.reduce((sum, deposit) => sum + deposit.amount, 0n);
-        // 如果需要自动批准，则先批准代币（默认开启自动批准）
-        if (options?.autoApprove !== false && this.walletClient && this.account) {
-            try {
-                console.log(`Checking ERC20 token approval status: ${tokenAddress}`);
-                // 检查授权
-                const allowance = (await this.publicClient.readContract({
-                    address: tokenAddress,
-                    abi: constants_1.ERC20_ABI,
-                    functionName: "allowance",
-                    args: [this.account.address, this.contracts?.anchorPay],
-                }));
-                console.log(`Current allowance: ${allowance}, Required amount: ${totalAmount}, AnchorPay contract address: ${this.contracts?.anchorPay}`);
-                if (allowance < totalAmount) {
-                    console.log(`Approving ${totalAmount} tokens to AnchorPay contract...`);
-                    // 批准代币 - 使用最大可能值进行授权，避免多次授权
-                    const maxApproveAmount = 2n ** 256n - 1n;
-                    // 估算 gas 和费用
-                    const { maxFeePerGas: approveMaxFeePerGas, maxPriorityFeePerGas: approveMaxPriorityFeePerGas, } = await this.publicClient.estimateFeesPerGas();
-                    const approveCalldata = (0, viem_1.encodeFunctionData)({
-                        abi: constants_1.ERC20_ABI,
-                        functionName: "approve",
-                        args: [this.contracts?.anchorPay, maxApproveAmount],
-                    });
-                    const approveGas = await this.publicClient.estimateGas({
-                        to: tokenAddress,
-                        data: approveCalldata,
-                        value: 0n,
-                        account: this.account,
-                    });
-                    const approveTxHash = await this.walletClient.writeContract({
-                        account: this.account,
-                        address: tokenAddress,
-                        abi: constants_1.ERC20_ABI,
-                        functionName: "approve",
-                        args: [this.contracts?.anchorPay, maxApproveAmount],
-                        chain: this.publicClient.chain,
-                        maxFeePerGas: approveMaxFeePerGas,
-                        maxPriorityFeePerGas: approveMaxPriorityFeePerGas,
-                        gas: approveGas,
-                    });
-                    console.log(`Approval transaction sent, hash: ${approveTxHash}`);
-                    // 等待交易确认
-                    await this.publicClient.waitForTransactionReceipt({
-                        hash: approveTxHash,
-                    });
-                    console.log(`Approval transaction confirmed`);
-                }
-                else {
-                    console.log(`Sufficient allowance already exists, no need for additional approval`);
-                }
-            }
-            catch (error) {
-                console.error(`Approval failed:`, error);
-                throw new Error(`ERC20 approval failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        // 准备批量调用数据
-        const calls = deposits.map((deposit) => {
-            const calldata = (0, viem_1.encodeFunctionData)({
-                abi: AnchorPay_json_1.default,
-                functionName: "depositFor",
-                args: [deposit.recipient, tokenAddress, deposit.amount],
-            });
-            return {
-                target: this.contracts?.anchorPay || "",
-                allowFailure: false,
-                value: 0n,
-                callData: calldata,
-            };
-        });
-        // 编码 Multicall3 调用
-        const multicallData = (0, viem_1.encodeFunctionData)({
-            abi: constants_1.MULTICALL3_ABI,
-            functionName: "aggregate3Value",
-            args: [calls],
-        });
-        // 如果不需要发送交易，只返回交易数据（AA 模式）
-        if (options?.sendTransaction === false) {
-            return {
-                to: constants_1.MULTICALL3_ADDRESS,
-                data: multicallData,
-                value: 0n,
-            };
-        }
-        // 估算 gas 和费用
-        const { maxFeePerGas, maxPriorityFeePerGas } = await this.publicClient.estimateFeesPerGas();
-        const gas = await this.publicClient.estimateGas({
-            to: constants_1.MULTICALL3_ADDRESS,
-            data: multicallData,
-            value: 0n,
-            account: this.account,
-        });
-        // 发送交易（EOA 模式）
-        if (!this.walletClient || !this.account) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        const txHash = await this.walletClient.sendTransaction({
-            account: this.account,
-            to: constants_1.MULTICALL3_ADDRESS,
-            data: multicallData,
-            maxFeePerGas: options?.maxFeePerGas || maxFeePerGas,
-            maxPriorityFeePerGas: options?.maxPriorityFeePerGas || maxPriorityFeePerGas,
-            gas: options?.gas || gas,
-            chain: this.publicClient.chain,
-        });
-        // 等待交易确认并返回收据
-        const receipt = await this.publicClient.waitForTransactionReceipt({
-            hash: txHash,
-        });
-        return receipt;
-    }
-    /**
-     * 批量发送 ETH（使用 Multicall3）
-     * @param transfers 批量转账参数数组
-     * @param options 交易选项
-     * @returns 交易收据或交易数据
-     */
-    async batchSendETH(transfers, options) {
-        if (transfers.length === 0) {
-            throw new Error("No transfers provided");
-        }
-        // 如果需要发送交易，但没有钱包客户端或账户
-        if (options?.sendTransaction !== false &&
-            (!this.walletClient || !this.account)) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        // 准备批量调用数据
-        const calls = transfers.map((transfer) => {
-            const calldata = (0, viem_1.encodeFunctionData)({
-                abi: AnchorPay_json_1.default,
-                functionName: "send",
-                args: [
-                    transfer.recipient,
-                    constants_1.NATIVE_TOKEN_ADDRESS,
-                    transfer.amount,
-                    transfer.data || "0x",
-                ],
-            });
-            return {
-                target: this.contracts?.anchorPay || "",
-                allowFailure: false,
-                value: transfer.amount,
-                callData: calldata,
-            };
-        });
-        // 计算总金额
-        const totalValue = transfers.reduce((sum, transfer) => sum + transfer.amount, 0n);
-        // 编码 Multicall3 调用
-        const multicallData = (0, viem_1.encodeFunctionData)({
-            abi: constants_1.MULTICALL3_ABI,
-            functionName: "aggregate3Value",
-            args: [calls],
-        });
-        // 如果不需要发送交易，只返回交易数据（AA 模式）
-        if (options?.sendTransaction === false) {
-            return {
-                to: constants_1.MULTICALL3_ADDRESS,
-                data: multicallData,
-                value: totalValue,
-            };
-        }
-        // 估算 gas 和费用
-        const { maxFeePerGas, maxPriorityFeePerGas } = await this.publicClient.estimateFeesPerGas();
-        const gas = await this.publicClient.estimateGas({
-            to: constants_1.MULTICALL3_ADDRESS,
-            data: multicallData,
-            value: totalValue,
-            account: this.account,
-        });
-        // 发送交易（EOA 模式）
-        if (!this.walletClient || !this.account) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        const txHash = await this.walletClient.sendTransaction({
-            account: this.account,
-            to: constants_1.MULTICALL3_ADDRESS,
-            data: multicallData,
-            value: totalValue,
-            maxFeePerGas: options?.maxFeePerGas || maxFeePerGas,
-            maxPriorityFeePerGas: options?.maxPriorityFeePerGas || maxPriorityFeePerGas,
-            gas: options?.gas || gas,
-            chain: this.publicClient.chain,
-        });
-        // 等待交易确认并返回收据
-        const receipt = await this.publicClient.waitForTransactionReceipt({
-            hash: txHash,
-        });
-        return receipt;
-    }
-    /**
-     * 批量发送 ERC20 代币（使用 Multicall3）
-     * @param tokenAddress ERC20 代币地址
-     * @param transfers 批量转账参数数组
-     * @param options 交易选项
-     * @returns 交易收据或交易数据
-     */
-    async batchSendERC20(tokenAddress, transfers, options) {
-        if (transfers.length === 0) {
-            throw new Error("No transfers provided");
-        }
-        // 如果需要发送交易，但没有钱包客户端或账户
-        if (options?.sendTransaction !== false &&
-            (!this.walletClient || !this.account)) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        // 计算总金额（用于批准检查）
-        const totalAmount = transfers.reduce((sum, transfer) => sum + transfer.amount, 0n);
-        // 如果需要自动批准，则先批准代币（默认开启自动批准）
-        if (options?.autoApprove !== false && this.walletClient && this.account) {
-            try {
-                console.log(`Checking ERC20 token approval status: ${tokenAddress}`);
-                // 检查授权
-                const allowance = (await this.publicClient.readContract({
-                    address: tokenAddress,
-                    abi: constants_1.ERC20_ABI,
-                    functionName: "allowance",
-                    args: [this.account.address, this.contracts?.anchorPay],
-                }));
-                console.log(`Current allowance: ${allowance}, Required amount: ${totalAmount}, AnchorPay contract address: ${this.contracts?.anchorPay}`);
-                if (allowance < totalAmount) {
-                    console.log(`Approving ${totalAmount} tokens to AnchorPay contract...`);
-                    // 批准代币 - 使用最大可能值进行授权，避免多次授权
-                    const maxApproveAmount = 2n ** 256n - 1n;
-                    // 估算 gas 和费用
-                    const { maxFeePerGas: approveMaxFeePerGas, maxPriorityFeePerGas: approveMaxPriorityFeePerGas, } = await this.publicClient.estimateFeesPerGas();
-                    const approveCalldata = (0, viem_1.encodeFunctionData)({
-                        abi: constants_1.ERC20_ABI,
-                        functionName: "approve",
-                        args: [this.contracts?.anchorPay, maxApproveAmount],
-                    });
-                    const approveGas = await this.publicClient.estimateGas({
-                        to: tokenAddress,
-                        data: approveCalldata,
-                        value: 0n,
-                        account: this.account,
-                    });
-                    const approveTxHash = await this.walletClient.writeContract({
-                        account: this.account,
-                        address: tokenAddress,
-                        abi: constants_1.ERC20_ABI,
-                        functionName: "approve",
-                        args: [this.contracts?.anchorPay, maxApproveAmount],
-                        chain: this.publicClient.chain,
-                        maxFeePerGas: approveMaxFeePerGas,
-                        maxPriorityFeePerGas: approveMaxPriorityFeePerGas,
-                        gas: approveGas,
-                    });
-                    console.log(`Approval transaction sent, hash: ${approveTxHash}`);
-                    // 等待交易确认
-                    await this.publicClient.waitForTransactionReceipt({
-                        hash: approveTxHash,
-                    });
-                    console.log(`Approval transaction confirmed`);
-                }
-                else {
-                    console.log(`Sufficient allowance already exists, no need for additional approval`);
-                }
-            }
-            catch (error) {
-                console.error(`Approval failed:`, error);
-                throw new Error(`ERC20 approval failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        // 准备批量调用数据
-        const calls = transfers.map((transfer) => {
-            const calldata = (0, viem_1.encodeFunctionData)({
-                abi: AnchorPay_json_1.default,
-                functionName: "send",
-                args: [
-                    transfer.recipient,
-                    tokenAddress,
-                    transfer.amount,
-                    transfer.data || "0x",
-                ],
-            });
-            return {
-                target: this.contracts?.anchorPay || "",
-                allowFailure: false,
-                value: 0n,
-                callData: calldata,
-            };
-        });
-        // 编码 Multicall3 调用
-        const multicallData = (0, viem_1.encodeFunctionData)({
-            abi: constants_1.MULTICALL3_ABI,
-            functionName: "aggregate3Value",
-            args: [calls],
-        });
-        // 如果不需要发送交易，只返回交易数据（AA 模式）
-        if (options?.sendTransaction === false) {
-            return {
-                to: constants_1.MULTICALL3_ADDRESS,
-                data: multicallData,
-                value: 0n,
-            };
-        }
-        // 估算 gas 和费用
-        const { maxFeePerGas, maxPriorityFeePerGas } = await this.publicClient.estimateFeesPerGas();
-        const gas = await this.publicClient.estimateGas({
-            to: constants_1.MULTICALL3_ADDRESS,
-            data: multicallData,
-            value: 0n,
-            account: this.account,
-        });
-        // 发送交易（EOA 模式）
-        if (!this.walletClient || !this.account) {
-            throw new Error("Wallet client and account are required to send transactions");
-        }
-        const txHash = await this.walletClient.sendTransaction({
-            account: this.account,
-            to: constants_1.MULTICALL3_ADDRESS,
-            data: multicallData,
-            maxFeePerGas: options?.maxFeePerGas || maxFeePerGas,
-            maxPriorityFeePerGas: options?.maxPriorityFeePerGas || maxPriorityFeePerGas,
-            gas: options?.gas || gas,
-            chain: this.publicClient.chain,
-        });
-        // 等待交易确认并返回收据
-        const receipt = await this.publicClient.waitForTransactionReceipt({
-            hash: txHash,
-        });
-        return receipt;
-    }
-}
-exports.AnchorPayClient = AnchorPayClient;