anchor-sdk 0.1.36

package/dist/AnchorERC1155Client.d.ts

@@ -0,0 +1,85 @@
+import { Account, Address, Chain, Hex, PublicClient, TransactionReceipt, WalletClient } from "viem";
+import { SignedMintRequest } from "./types";
+/**
+ * AnchorERC1155 客户端
+ * 用于与 AnchorERC1155 合约交互
+ */
+export declare class AnchorERC1155Client {
+    private publicClient;
+    private walletClient?;
+    private account?;
+    private network;
+    private contracts;
+    /**
+     * 创建 AnchorERC1155 客户端
+     * @param publicClient 公共客户端（只读操作）
+     * @param network 网络配置
+     * @param walletClient 钱包客户端（写入操作）
+     * @param account 账户（可选，如果不提供则使用只读模式）
+     */
+    constructor(publicClient: PublicClient, network: Chain, walletClient?: WalletClient, account?: Account, contracts?: {
+        anchorPay?: string;
+        anchorERC1155?: string;
+        [key: string]: string | undefined;
+    });
+    /**
+     * 获取代币 URI
+     * @param tokenId 代币 ID
+     * @returns 代币 URI
+     */
+    getTokenURI(tokenId: bigint): Promise<string>;
+    /**
+     * 获取代币名称
+     * @returns 代币名称
+     */
+    getName(): Promise<string>;
+    /**
+     * 获取代币符号
+     * @returns 代币符号
+     */
+    getSymbol(): Promise<string>;
+    /**
+     * 使用签名铸造代币（免费代币）
+     * @param signedRequest 签名铸造请求
+     * @param options 选项，可以控制是否直接发送交易
+     * @returns 如果直接发送交易，返回交易收据；否则返回交易数据
+     */
+    mintWithSignature(signedRequest: SignedMintRequest, anchorERC1155Address?: Address, options?: {
+        sendTransaction?: boolean;
+    }): Promise<TransactionReceipt | {
+        to: string;
+        data: string;
+        value: bigint;
+    }>;
+    /**
+     * 编码签名铸造请求（用于通过 AnchorPay 支付）
+     * @param signedRequest 签名铸造请求
+     * @returns 编码后的数据
+     */
+    encodeTokenReceivedData(signedRequest: SignedMintRequest): Hex;
+    /**
+     * 编码签名铸造请求（用于通过 AnchorPay 支付），使用空接口字符串
+     * @param signedRequest 签名铸造请求
+     * @returns 编码后的数据
+     */
+    encodeTokenReceivedDataWithEmptyInterface(signedRequest: SignedMintRequest): Hex;
+    /**
+     * multicall 方法，用于批量执行交易
+     * @param data 编码后的交易数据数组
+     * @param options 选项，可以控制是否直接发送交易
+     * @returns 如果直接发送交易，返回交易收据；否则返回交易数据
+     */
+    multicall(data: Hex[], options?: {
+        sendTransaction?: boolean;
+    }): Promise<TransactionReceipt | {
+        to: string;
+        data: string;
+        value: bigint;
+    }>;
+    /**
+     * 格式化铸造请求，将 bigint 转换为字符串
+     * @param request 铸造请求
+     * @returns 格式化后的铸造请求
+     */
+    private formatMintRequest;
+}

package/dist/AnchorERC1155Client.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnchorERC1155Client = void 0;
+const viem_1 = require("viem");
+const AnchorERC1155_1 = require("./abi/AnchorERC1155");
+const typechain_1 = require("./typechain");
+/**
+ * AnchorERC1155 客户端
+ * 用于与 AnchorERC1155 合约交互
+ */
+class AnchorERC1155Client {
+    /**
+     * 创建 AnchorERC1155 客户端
+     * @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 || {};
+    }
+    /**
+     * 获取代币 URI
+     * @param tokenId 代币 ID
+     * @returns 代币 URI
+     */
+    async getTokenURI(tokenId) {
+        if (!this.contracts?.anchorERC1155) {
+            throw new Error("AnchorERC1155 contract address not set, please check network configuration");
+        }
+        return (await this.publicClient.readContract({
+            address: this.contracts.anchorERC1155,
+            abi: AnchorERC1155_1.AnchorERC1155ABI,
+            functionName: "uri",
+            args: [tokenId],
+        }));
+    }
+    /**
+     * 获取代币名称
+     * @returns 代币名称
+     */
+    async getName() {
+        if (!this.contracts?.anchorERC1155) {
+            throw new Error("AnchorERC1155 contract address not set, please check network configuration");
+        }
+        return (await this.publicClient.readContract({
+            address: this.contracts.anchorERC1155,
+            abi: AnchorERC1155_1.AnchorERC1155ABI,
+            functionName: "name",
+        }));
+    }
+    /**
+     * 获取代币符号
+     * @returns 代币符号
+     */
+    async getSymbol() {
+        if (!this.contracts?.anchorERC1155) {
+            throw new Error("AnchorERC1155 contract address not set, please check network configuration");
+        }
+        return (await this.publicClient.readContract({
+            address: this.contracts.anchorERC1155,
+            abi: AnchorERC1155_1.AnchorERC1155ABI,
+            functionName: "symbol",
+        }));
+    }
+    /**
+     * 使用签名铸造代币（免费代币）
+     * @param signedRequest 签名铸造请求
+     * @param options 选项，可以控制是否直接发送交易
+     * @returns 如果直接发送交易，返回交易收据；否则返回交易数据
+     */
+    async mintWithSignature(signedRequest, anchorERC1155Address, options) {
+        if (BigInt(signedRequest.request.price) !== 0n) {
+            throw new Error("mintWithSignature method can only be used to mint free tokens");
+        }
+        const contractAddress = anchorERC1155Address || this.contracts?.anchorERC1155;
+        // 用 typechain encodeFunctionData，参数断言为 any 以兼容类型
+        const data = typechain_1.AnchorERC1155__factory.createInterface().encodeFunctionData("mintWithSignature", [
+            this.formatMintRequest(signedRequest.request),
+            signedRequest.signature,
+        ]);
+        // const data = encodeFunctionData({
+        //   abi: AnchorERC1155ABI,
+        //   functionName: "mintWithSignature",
+        //   args: [
+        //     this.formatMintRequest(signedRequest.request),
+        //     signedRequest.signature as `0x${string}`,
+        //   ],
+        // });
+        console.log(data, "data");
+        if (options?.sendTransaction === false) {
+            return {
+                to: contractAddress,
+                data,
+                value: 0n,
+            };
+        }
+        if (!this.walletClient || !this.account) {
+            throw new Error("Wallet client and account are required to send transactions");
+        }
+        const txHash = await this.walletClient.writeContract({
+            account: this.account,
+            address: contractAddress,
+            abi: typechain_1.AnchorERC1155__factory.abi,
+            functionName: "mintWithSignature",
+            args: [
+                this.formatMintRequest(signedRequest.request),
+                signedRequest.signature,
+            ],
+            chain: null,
+        });
+        const receipt = await this.publicClient.waitForTransactionReceipt({
+            hash: txHash,
+        });
+        return receipt;
+    }
+    /**
+     * 编码签名铸造请求（用于通过 AnchorPay 支付）
+     * @param signedRequest 签名铸造请求
+     * @returns 编码后的数据
+     */
+    encodeTokenReceivedData(signedRequest) {
+        // 计算接口哈希 - AnchorERC1155 接口标识
+        const interfaceHash = (0, viem_1.keccak256)((0, viem_1.stringToHex)("AnchorERC1155"));
+        // 准备签名数据
+        const signature = signedRequest.signature.startsWith("0x")
+            ? signedRequest.signature
+            : `0x${signedRequest.signature}`;
+        // 格式化请求数据
+        const formattedRequest = this.formatMintRequest(signedRequest.request);
+        console.log("Formatted request data:", JSON.stringify(formattedRequest, (_, v) => typeof v === "bigint" ? v.toString() : v));
+        console.log("Signature:", signature);
+        // 编码tokenReceived函数调用
+        // tokenReceived(address token, address from, address to, uint256 amount, bytes calldata userData)
+        // 其中userData是通过abi.encode(MintRequest, signature)编码的
+        // 1. 首先编码userData - 这是合约中通过abi.decode解码的部分
+        const userData = (0, viem_1.encodeAbiParameters)([
+            {
+                components: [
+                    { name: "to", type: "address" },
+                    { name: "tokenId", type: "uint256" },
+                    { name: "quantity", type: "uint256" },
+                    { name: "price", type: "uint256" },
+                    { name: "currency", type: "address" },
+                    { name: "validityStartTimestamp", type: "uint128" },
+                    { name: "validityEndTimestamp", type: "uint128" },
+                    { name: "uid", type: "bytes32" },
+                    { name: "chainId", type: "uint256" },
+                    { name: "projectHandle", type: "bytes32" },
+                ],
+                name: "req",
+                type: "tuple",
+            },
+            { name: "signature", type: "bytes" },
+        ], [formattedRequest, signature]);
+        console.log("Encoded userData:", userData);
+        // 返回完整的编码数据
+        return (0, viem_1.concat)([interfaceHash, userData]);
+    }
+    /**
+     * 编码签名铸造请求（用于通过 AnchorPay 支付），使用空接口字符串
+     * @param signedRequest 签名铸造请求
+     * @returns 编码后的数据
+     */
+    encodeTokenReceivedDataWithEmptyInterface(signedRequest) {
+        // 计算接口哈希 - 使用空字符串
+        const interfaceHash = (0, viem_1.keccak256)((0, viem_1.stringToHex)(""));
+        // 准备签名数据
+        const signature = signedRequest.signature.startsWith("0x")
+            ? signedRequest.signature
+            : `0x${signedRequest.signature}`;
+        // 格式化请求数据
+        const formattedRequest = this.formatMintRequest(signedRequest.request);
+        console.log("Formatted request data (empty interface):", JSON.stringify(formattedRequest, (_, v) => typeof v === "bigint" ? v.toString() : v));
+        console.log("Signature:", signature);
+        // 编码userData - 与标准方法相同，只是接口哈希不同
+        const userData = (0, viem_1.encodeAbiParameters)([
+            {
+                components: [
+                    { name: "to", type: "address" },
+                    { name: "tokenId", type: "uint256" },
+                    { name: "quantity", type: "uint256" },
+                    { name: "price", type: "uint256" },
+                    { name: "currency", type: "address" },
+                    { name: "validityStartTimestamp", type: "uint128" },
+                    { name: "validityEndTimestamp", type: "uint128" },
+                    { name: "uid", type: "bytes32" },
+                    { name: "chainId", type: "uint256" },
+                    { name: "projectHandle", type: "bytes32" },
+                ],
+                name: "req",
+                type: "tuple",
+            },
+            { name: "signature", type: "bytes" },
+        ], [formattedRequest, signature]);
+        console.log("Encoded userData (empty interface):", userData);
+        // 返回完整的编码数据
+        return (0, viem_1.concat)([interfaceHash, userData]);
+    }
+    /**
+     * multicall 方法，用于批量执行交易
+     * @param data 编码后的交易数据数组
+     * @param options 选项，可以控制是否直接发送交易
+     * @returns 如果直接发送交易，返回交易收据；否则返回交易数据
+     */
+    async multicall(data, options) {
+        if (!this.contracts?.anchorERC1155) {
+            throw new Error("AnchorERC1155 contract address not set, please check network configuration");
+        }
+        const contractAddress = this.contracts.anchorERC1155;
+        const calldata = (0, viem_1.encodeFunctionData)({
+            abi: AnchorERC1155_1.AnchorERC1155ABI,
+            functionName: "multicall",
+            args: [data],
+        });
+        if (options?.sendTransaction === false) {
+            return {
+                to: contractAddress,
+                data: calldata,
+                value: 0n,
+            };
+        }
+        if (!this.walletClient || !this.account) {
+            throw new Error("Wallet client and account are required to send transactions");
+        }
+        const txHash = await this.walletClient.writeContract({
+            account: this.account,
+            address: contractAddress,
+            abi: AnchorERC1155_1.AnchorERC1155ABI,
+            functionName: "multicall",
+            args: [data],
+            chain: null,
+        });
+        return await this.publicClient.waitForTransactionReceipt({ hash: txHash });
+    }
+    /**
+     * 格式化铸造请求，将 bigint 转换为字符串
+     * @param request 铸造请求
+     * @returns 格式化后的铸造请求
+     */
+    formatMintRequest(request) {
+        let uid;
+        if (typeof request.uid === "string") {
+            if (request.uid.startsWith("0x")) {
+                uid = request.uid;
+            }
+            else {
+                uid = (0, viem_1.keccak256)((0, viem_1.stringToHex)(request.uid));
+            }
+        }
+        else {
+            uid = request.uid;
+        }
+        // 计算当前时间戳（秒）
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        return {
+            to: request.to,
+            tokenId: BigInt(request.tokenId),
+            quantity: BigInt(request.quantity),
+            price: BigInt(request.price),
+            currency: request.currency,
+            validityStartTimestamp: request.validityStartTimestamp
+                ? BigInt(request.validityStartTimestamp)
+                : currentTimestamp,
+            validityEndTimestamp: request.validityEndTimestamp
+                ? BigInt(request.validityEndTimestamp)
+                : request.validUntil
+                    ? BigInt(request.validUntil)
+                    : currentTimestamp + 3600n, // 默认1小时后过期
+            uid: uid,
+            chainId: BigInt(request.chainId || this.network.id),
+            projectHandle: request.projectHandle,
+        };
+    }
+}
+exports.AnchorERC1155Client = AnchorERC1155Client;

package/dist/AnchorPayClient.d.ts

@@ -0,0 +1,79 @@
+import { Address, Hex, PublicClient, WalletClient, Account, TransactionReceipt, Chain } from "viem";
+import { PaymentOptions } from "./types";
+/**
+ * AnchorPay 客户端
+ * 用于与 AnchorPay 合约交互
+ */
+export declare class AnchorPayClient {
+    private publicClient;
+    private walletClient?;
+    private account?;
+    private network;
+    private contracts;
+    /**
+     * 创建 AnchorPay 客户端
+     * @param publicClient 公共客户端（只读操作）
+     * @param network 网络配置
+     * @param walletClient 钱包客户端（写入操作）
+     * @param account 账户（可选，如果不提供则使用只读模式）
+     */
+    constructor(publicClient: PublicClient, network: Chain, walletClient?: WalletClient, account?: Account, contracts?: {
+        anchorPay?: string;
+        anchorERC1155?: string;
+        [key: string]: string | undefined;
+    });
+    /**
+     * 发送 ETH
+     * @param recipient 接收者地址
+     * @param amount 金额（单位：wei）
+     * @param data 附加数据
+     * @param options 交易选项
+     * @returns 交易收据或交易数据
+     */
+    sendETH(recipient: Address, amount: bigint, data?: Hex, options?: PaymentOptions): Promise<TransactionReceipt | {
+        to: string;
+        data: string;
+        value: bigint;
+    }>;
+    /**
+     * 发送 ERC20 代币
+     * @param recipient 接收者地址
+     * @param tokenAddress ERC20 代币地址
+     * @param amount 金额
+     * @param data 附加数据
+     * @param options 交易选项
+     * @returns 交易收据或交易数据
+     */
+    sendERC20(recipient: Address, tokenAddress: Address, amount: bigint, data?: Hex, options?: PaymentOptions): Promise<TransactionReceipt | {
+        to: string;
+        data: string;
+        value: bigint;
+    }>;
+    /**
+     * 获取接口实现者
+     * @param account 账户地址
+     * @param interfaceHash 接口哈希
+     * @returns 实现者地址
+     */
+    getInterfaceImplementer(account: Address, interfaceHash: Hex): Promise<Address>;
+    /**
+     * 设置接口实现者（仅限管理员）
+     * @param account 账户地址
+     * @param interfaceHash 接口哈希
+     * @param implementer 实现者地址
+     * @returns 交易收据
+     */
+    setInterfaceImplementer(account: Address, interfaceHash: Hex, implementer: Address): Promise<TransactionReceipt>;
+    /**
+     * 获取 ERC20 代币批准的交易数据（用于 AA 模式）
+     * @param tokenAddress ERC20 代币地址
+     * @param amount 批准金额
+     * @param spender 花费者地址（默认为 AnchorPay 合约地址）
+     * @returns 交易数据对象，包含 to、data 和 value 字段
+     */
+    getERC20ApprovalData(tokenAddress: Address, amount: bigint, spender?: Address): {
+        to: string;
+        data: string;
+        value: bigint;
+    };
+}

package/dist/AnchorPayClient.js

@@ -0,0 +1,217 @@
+"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 AnchorPay_json_1 = __importDefault(require("./abi/AnchorPay.json"));
+const constants_1 = require("./constants");
+/**
+ * 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
+            };
+        }
+        // 发送交易（EOA 模式）
+        const txHash = await this.walletClient.sendTransaction({
+            account: this.account,
+            to: this.contracts?.anchorPay || "",
+            data: calldata,
+            value: amount,
+            maxFeePerGas: options?.maxFeePerGas,
+            maxPriorityFeePerGas: options?.maxPriorityFeePerGas,
+            gas: options?.gas,
+            chain: null
+        });
+        // 等待交易确认并返回收据
+        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;
+                    const approveTxHash = await this.walletClient.writeContract({
+                        account: this.account,
+                        address: tokenAddress,
+                        abi: constants_1.ERC20_ABI,
+                        functionName: 'approve',
+                        args: [this.contracts?.anchorPay, maxApproveAmount],
+                        chain: null
+                    });
+                    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
+            };
+        }
+        // 发送交易（EOA 模式）
+        const txHash = await this.walletClient.sendTransaction({
+            account: this.account,
+            to: this.contracts?.anchorPay || "",
+            data: calldata,
+            // value: amount,
+            maxFeePerGas: options?.maxFeePerGas,
+            maxPriorityFeePerGas: options?.maxPriorityFeePerGas,
+            gas: options?.gas,
+            chain: null
+        });
+        // 等待交易确认并返回收据
+        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");
+        }
+        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: null
+        });
+        // 等待交易确认并返回收据
+        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
+        };
+    }
+}
+exports.AnchorPayClient = AnchorPayClient;