four-flap-meme-sdk 1.5.19 → 1.5.20

package/dist/xlayer/aa-account.d.ts

@@ -85,6 +85,22 @@ export declare class AAAccountManager {
         userOp: UserOperation;
         prefundWei: bigint;
     }>;
+    /**
+     * 批量构建未签名的 UserOperation（使用 Bundler 批量估算 Gas）
+     *
+     * 目标：把 N 次 eth_estimateUserOperationGas 合并为 1 次（JSON-RPC batch），显著降低延迟。
+     */
+    buildUserOpsWithBundlerEstimateBatch(params: {
+        ops: Array<{
+            sender: string;
+            nonce: bigint;
+            callData: string;
+            initCode?: string;
+        }>;
+    }): Promise<{
+        userOps: UserOperation[];
+        prefundWeis: bigint[];
+    }>;
     /**
      * 构建未签名的 UserOperation（本地估算 Gas，不依赖 Bundler）
      *

package/dist/xlayer/aa-account.js

@@ -170,6 +170,60 @@ export class AAAccountManager {
         const prefundWei = paymasterAndData !== '0x' ? 0n : gasTotal * BigInt(userOp.maxFeePerGas);
         return { userOp, prefundWei };
     }
+    /**
+     * 批量构建未签名的 UserOperation（使用 Bundler 批量估算 Gas）
+     *
+     * 目标：把 N 次 eth_estimateUserOperationGas 合并为 1 次（JSON-RPC batch），显著降低延迟。
+     */
+    async buildUserOpsWithBundlerEstimateBatch(params) {
+        if (params.ops.length === 0) {
+            return { userOps: [], prefundWeis: [] };
+        }
+        const feeData = await this.provider.getFeeData();
+        const legacyGasPrice = feeData.gasPrice ?? feeData.maxFeePerGas ?? DEFAULT_GAS_PRICE;
+        const paymasterAndData = this.buildPaymasterAndData();
+        // 先构建 skeleton（Gas=0），然后批量估算
+        const skeletons = params.ops.map((p) => ({
+            sender: p.sender,
+            nonce: ethers.toBeHex(p.nonce),
+            initCode: p.initCode ?? '0x',
+            callData: p.callData,
+            callGasLimit: '0x0',
+            verificationGasLimit: '0x0',
+            preVerificationGas: '0x0',
+            maxFeePerGas: ethers.toBeHex(legacyGasPrice * 2n),
+            maxPriorityFeePerGas: ethers.toBeHex(legacyGasPrice),
+            paymasterAndData,
+            signature: '0x',
+        }));
+        const estimates = await this.bundler.estimateUserOperationGasBatch(skeletons);
+        const userOps = [];
+        const prefundWeis = [];
+        for (let i = 0; i < skeletons.length; i++) {
+            const estimate = estimates[i];
+            let userOp = {
+                ...skeletons[i],
+                callGasLimit: estimate.callGasLimit,
+                verificationGasLimit: estimate.verificationGasLimit,
+                preVerificationGas: estimate.preVerificationGas,
+            };
+            // 使用 Bundler 建议的费率（如果有）
+            if (estimate.maxFeePerGas && estimate.maxPriorityFeePerGas) {
+                userOp = {
+                    ...userOp,
+                    maxFeePerGas: estimate.maxFeePerGas,
+                    maxPriorityFeePerGas: estimate.maxPriorityFeePerGas,
+                };
+            }
+            const gasTotal = BigInt(userOp.callGasLimit) +
+                BigInt(userOp.verificationGasLimit) +
+                BigInt(userOp.preVerificationGas);
+            const prefundWei = paymasterAndData !== '0x' ? 0n : gasTotal * BigInt(userOp.maxFeePerGas);
+            userOps.push(userOp);
+            prefundWeis.push(prefundWei);
+        }
+        return { userOps, prefundWeis };
+    }
     /**
      * 构建未签名的 UserOperation（本地估算 Gas，不依赖 Bundler）
      *

package/dist/xlayer/bundle.js

@@ -7,9 +7,9 @@
  * - 买卖一体化：买入 -> 授权 -> 卖出 -> 归集
  * - OKB 归集：将 sender 的 OKB 转回 owner
  */
-import { Interface, Contract } from 'ethers';
+import { Wallet, Interface, Contract } from 'ethers';
 import { FLAP_PORTAL, ENTRYPOINT_ABI, DEFAULT_CALL_GAS_LIMIT_SELL, DEFAULT_WITHDRAW_RESERVE, } from './constants.js';
-import { AAAccountManager, encodeExecute, createWallet } from './aa-account.js';
+import { AAAccountManager, encodeExecute } from './aa-account.js';
 import { encodeBuyCall, encodeSellCall, encodeApproveCall, encodeTransferCall, PortalQuery, parseOkb, formatOkb, } from './portal-ops.js';
 // ============================================================================
 // 捆绑交易执行器
@@ -249,40 +249,75 @@ export class BundleExecutor {
             throw new Error('私钥数量和购买金额数量必须一致');
         }
         // 使用第一个 owner 作为 bundler signer
-        const wallets = privateKeys.map((pk) => createWallet(pk, this.config));
+        const sharedProvider = this.aaManager.getProvider();
+        const wallets = privateKeys.map((pk) => new Wallet(pk, sharedProvider));
         const bundlerSigner = wallets[0];
         const beneficiary = bundlerSigner.address;
         console.log('=== XLayer Bundle Buy ===');
         console.log('token:', tokenAddress);
         console.log('owners:', wallets.length);
-        // 1. 构建买入 UserOps
-        const buyOps = [];
-        for (let i = 0; i < wallets.length; i++) {
-            const wallet = wallets[i];
-            const buyWei = parseOkb(buyAmounts[i]);
-            const signed = await this.buildBuyUserOp(wallet, tokenAddress, buyWei, `owner${i + 1}`);
-            buyOps.push(signed.userOp);
-        }
+        // 1. 预取账户信息（并行），并批量估算 gas（减少对 bundler 的 N 次请求）
+        const accountInfos = await this.aaManager.getMultipleAccountInfo(wallets.map((w) => w.address));
+        const buyWeis = buyAmounts.map((a) => parseOkb(a));
+        // 估算前确保 sender 有足够余额（用于 bundler 模拟；paymaster 场景会自动跳过）
+        await Promise.all(accountInfos.map((ai, i) => this.aaManager.ensureSenderBalance(wallets[i], ai.sender, buyWeis[i] + parseOkb('0.0003'), `owner${i + 1}/buy-prefund-before-estimate`)));
+        const buyCallDatas = buyWeis.map((buyWei) => {
+            const swapData = encodeBuyCall(tokenAddress, buyWei, 0n);
+            return encodeExecute(this.portalAddress, buyWei, swapData);
+        });
+        const initCodes = accountInfos.map((ai, i) => ai.deployed ? '0x' : this.aaManager.generateInitCode(wallets[i].address));
+        const { userOps: buyUserOps, prefundWeis } = await this.aaManager.buildUserOpsWithBundlerEstimateBatch({
+            ops: accountInfos.map((ai, i) => ({
+                sender: ai.sender,
+                nonce: ai.nonce,
+                callData: buyCallDatas[i],
+                initCode: initCodes[i],
+            })),
+        });
+        // 补足 prefund + 买入金额（多数情况下上一步的 0.0003 已足够，这里通常不会再转账）
+        await Promise.all(accountInfos.map((ai, i) => this.aaManager.ensureSenderBalance(wallets[i], ai.sender, buyWeis[i] + prefundWeis[i] + parseOkb('0.0002'), `owner${i + 1}/buy-fund`)));
+        // 签名
+        const signedBuy = await Promise.all(buyUserOps.map((op, i) => this.aaManager.signUserOp(op, wallets[i])));
+        const buyOps = signedBuy.map((s) => s.userOp);
         // 2. 执行买入
         const buyResult = await this.runHandleOps('buyBundle', buyOps, bundlerSigner, beneficiary);
         if (!buyResult) {
             throw new Error('买入交易失败');
         }
         // 3. 获取代币余额
-        const senders = await Promise.all(wallets.map((w) => this.aaManager.predictSenderAddress(w.address)));
+        const senders = accountInfos.map((ai) => ai.sender);
         const tokenBalances = await this.portalQuery.getMultipleTokenBalances(tokenAddress, senders);
         // 4. 可选：转账代币回 owner
         let transferResult;
         if (transferBackToOwner) {
-            const transferOps = [];
+            const idxs = [];
+            const transferCallDatas = [];
             for (let i = 0; i < wallets.length; i++) {
-                const signed = await this.buildTransferTokenUserOp(wallets[i], tokenAddress, `owner${i + 1}`);
-                if (signed) {
-                    transferOps.push(signed.userOp);
-                }
+                const sender = senders[i];
+                const bal = tokenBalances.get(sender) ?? 0n;
+                if (bal === 0n)
+                    continue;
+                idxs.push(i);
+                const transferData = encodeTransferCall(wallets[i].address, bal);
+                transferCallDatas.push(encodeExecute(tokenAddress, 0n, transferData));
             }
-            if (transferOps.length > 0) {
-                transferResult = await this.runHandleOps('transferBundle', transferOps, bundlerSigner, beneficiary) ?? undefined;
+            if (idxs.length > 0) {
+                // 估算前补一点余额（paymaster 会自动跳过）
+                await Promise.all(idxs.map((i) => this.aaManager.ensureSenderBalance(wallets[i], senders[i], parseOkb('0.0002'), `owner${i + 1}/transfer-prefund`)));
+                // buy 已经成功过一次，因此 transfer 的 nonce = 原 nonce + 1，且 initCode = 0x
+                const { userOps: transferUserOps, prefundWeis: transferPrefunds } = await this.aaManager.buildUserOpsWithBundlerEstimateBatch({
+                    ops: idxs.map((i, k) => ({
+                        sender: senders[i],
+                        nonce: accountInfos[i].nonce + 1n,
+                        callData: transferCallDatas[k],
+                        initCode: '0x',
+                    })),
+                });
+                await Promise.all(idxs.map((i, k) => this.aaManager.ensureSenderBalance(wallets[i], senders[i], transferPrefunds[k] + parseOkb('0.00005'), `owner${i + 1}/transfer-fund`)));
+                const signedTransfer = await Promise.all(transferUserOps.map((op, k) => this.aaManager.signUserOp(op, wallets[idxs[k]])));
+                const transferOps = signedTransfer.map((s) => s.userOp);
+                transferResult =
+                    (await this.runHandleOps('transferBundle', transferOps, bundlerSigner, beneficiary)) ?? undefined;
             }
         }
         return { buyResult, transferResult, tokenBalances };
@@ -294,7 +329,8 @@ export class BundleExecutor {
      */
     async bundleSell(params) {
         const { tokenAddress, privateKeys, sellPercent = 100, withdrawToOwner = true, withdrawReserve = DEFAULT_WITHDRAW_RESERVE, } = params;
-        const wallets = privateKeys.map((pk) => createWallet(pk, this.config));
+        const sharedProvider = this.aaManager.getProvider();
+        const wallets = privateKeys.map((pk) => new Wallet(pk, sharedProvider));
         const bundlerSigner = wallets[0];
         const beneficiary = bundlerSigner.address;
         const reserveWei = parseOkb(withdrawReserve);
@@ -370,7 +406,8 @@ export class BundleExecutor {
         if (privateKeys.length !== buyAmounts.length) {
             throw new Error('私钥数量和购买金额数量必须一致');
         }
-        const wallets = privateKeys.map((pk) => createWallet(pk, this.config));
+        const sharedProvider = this.aaManager.getProvider();
+        const wallets = privateKeys.map((pk) => new Wallet(pk, sharedProvider));
         const bundlerSigner = wallets[0];
         const beneficiary = bundlerSigner.address;
         const reserveWei = parseOkb(withdrawReserve);

package/dist/xlayer/bundler.d.ts

@@ -56,6 +56,13 @@ export declare class BundlerClient {
      * 发送 JSON-RPC 请求到 Bundler
      */
     private rpc;
+    /**
+     * 发送 JSON-RPC Batch 请求到 Bundler
+     *
+     * 注意：JSON-RPC batch 是一个数组；Particle bundler 通常也支持该格式。
+     * 为兼容其非标准字段，这里为每个 request 也附带 chainId 字段。
+     */
+    private rpcBatch;
     /**
      * 获取支持的 EntryPoint 列表
      */
@@ -67,6 +74,10 @@ export declare class BundlerClient {
      * @returns Gas 估算结果
      */
     estimateUserOperationGas(userOp: UserOperation): Promise<GasEstimate>;
+    /**
+     * 批量估算多个 UserOperation Gas（优先使用 JSON-RPC batch；失败则回退）
+     */
+    estimateUserOperationGasBatch(userOps: UserOperation[]): Promise<GasEstimate[]>;
     /**
      * 发送 UserOperation
      *

package/dist/xlayer/bundler.js

@@ -69,6 +69,64 @@ export class BundlerClient {
             clearTimeout(timer);
         }
     }
+    /**
+     * 发送 JSON-RPC Batch 请求到 Bundler
+     *
+     * 注意：JSON-RPC batch 是一个数组；Particle bundler 通常也支持该格式。
+     * 为兼容其非标准字段，这里为每个 request 也附带 chainId 字段。
+     */
+    async rpcBatch(calls) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        // 为每个 call 分配独立 id，便于按 id 回填结果
+        const ids = calls.map(() => nextRpcId++);
+        const body = calls.map((c, i) => ({
+            jsonrpc: '2.0',
+            id: ids[i],
+            method: c.method,
+            params: c.params ?? [],
+            chainId: this.chainId,
+        }));
+        try {
+            const res = await fetch(this.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    ...this.headers,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            const text = await res.text();
+            let data;
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                throw new Error(`非 JSON 响应 (HTTP ${res.status}): ${text.slice(0, 400)}`);
+            }
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status}: ${JSON.stringify(data).slice(0, 800)}`);
+            }
+            if (!Array.isArray(data)) {
+                throw new Error(`RPC batch 非数组响应: ${JSON.stringify(data).slice(0, 800)}`);
+            }
+            // 建立 id -> result 映射，确保按 calls 顺序返回
+            const byId = new Map();
+            for (const item of data) {
+                if (item?.error) {
+                    throw new Error(`RPC batch error: ${JSON.stringify(item.error)}`);
+                }
+                if (typeof item?.id === 'number') {
+                    byId.set(item.id, item.result);
+                }
+            }
+            return ids.map((id) => byId.get(id));
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
     /**
      * 获取支持的 EntryPoint 列表
      */
@@ -87,6 +145,24 @@ export class BundlerClient {
             this.entryPoint,
         ]);
     }
+    /**
+     * 批量估算多个 UserOperation Gas（优先使用 JSON-RPC batch；失败则回退）
+     */
+    async estimateUserOperationGasBatch(userOps) {
+        if (userOps.length === 0)
+            return [];
+        // 先尝试 batch（显著降低 HTTP 往返次数）
+        try {
+            return await this.rpcBatch(userOps.map((op) => ({
+                method: 'eth_estimateUserOperationGas',
+                params: [op, this.entryPoint],
+            })));
+        }
+        catch {
+            // fallback：并发单请求（比串行快，但可能触发限流）
+            return await Promise.all(userOps.map((op) => this.estimateUserOperationGas(op)));
+        }
+    }
     /**
      * 发送 UserOperation
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "four-flap-meme-sdk",
-  "version": "1.5.19",
+  "version": "1.5.20",
   "description": "SDK for Flap bonding curve and four.meme TokenManager",
   "type": "module",
   "main": "dist/index.js",

package/dist/flap/portal-bundle-merkle/encryption.d.ts

@@ -1,16 +0,0 @@
-/**
- * ECDH + AES-GCM 加密工具（浏览器兼容）
- * 用于将签名交易用服务器公钥加密
- */
-/**
- * 用服务器公钥加密签名交易（ECDH + AES-GCM）
- *
- * @param signedTransactions 签名后的交易数组
- * @param publicKeyBase64 服务器提供的公钥（Base64 格式）
- * @returns JSON 字符串 {e: 临时公钥, i: IV, d: 密文}
- */
-export declare function encryptWithPublicKey(signedTransactions: string[], publicKeyBase64: string): Promise<string>;
-/**
- * 验证公钥格式（Base64）
- */
-export declare function validatePublicKey(publicKeyBase64: string): boolean;

package/dist/flap/portal-bundle-merkle/encryption.js

@@ -1,146 +0,0 @@
-/**
- * ECDH + AES-GCM 加密工具（浏览器兼容）
- * 用于将签名交易用服务器公钥加密
- */
-/**
- * 获取全局 crypto 对象（最简单直接的方式）
- */
-function getCryptoAPI() {
-    // 尝试所有可能的全局对象，优先浏览器环境
-    const cryptoObj = (typeof window !== 'undefined' && window.crypto) ||
-        (typeof self !== 'undefined' && self.crypto) ||
-        (typeof global !== 'undefined' && global.crypto) ||
-        (typeof globalThis !== 'undefined' && globalThis.crypto);
-    if (!cryptoObj) {
-        const env = typeof window !== 'undefined' ? 'Browser' : 'Node.js';
-        const protocol = typeof location !== 'undefined' ? location.protocol : 'unknown';
-        throw new Error(`❌ Crypto API 不可用。环境: ${env}, 协议: ${protocol}. ` +
-            '请确保在 HTTPS 或 localhost 下运行');
-    }
-    return cryptoObj;
-}
-/**
- * 获取 SubtleCrypto（用于加密操作）
- */
-function getSubtleCrypto() {
-    const crypto = getCryptoAPI();
-    if (!crypto.subtle) {
-        const protocol = typeof location !== 'undefined' ? location.protocol : 'unknown';
-        const hostname = typeof location !== 'undefined' ? location.hostname : 'unknown';
-        throw new Error(`❌ SubtleCrypto API 不可用。协议: ${protocol}, 主机: ${hostname}. ` +
-            '请确保：1) 使用 HTTPS (或 localhost)；2) 浏览器支持 Web Crypto API；' +
-            '3) 不在无痕/隐私浏览模式下');
-    }
-    return crypto.subtle;
-}
-/**
- * Base64 转 ArrayBuffer（优先使用浏览器 API）
- */
-function base64ToArrayBuffer(base64) {
-    // 浏览器环境（优先）
-    if (typeof atob !== 'undefined') {
-        const binaryString = atob(base64);
-        const bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-        }
-        return bytes.buffer;
-    }
-    // Node.js 环境（fallback）
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(base64, 'base64').buffer;
-    }
-    throw new Error('❌ Base64 解码不可用');
-}
-/**
- * ArrayBuffer 转 Base64（优先使用浏览器 API）
- */
-function arrayBufferToBase64(buffer) {
-    // 浏览器环境（优先）
-    if (typeof btoa !== 'undefined') {
-        const bytes = new Uint8Array(buffer);
-        let binary = '';
-        for (let i = 0; i < bytes.length; i++) {
-            binary += String.fromCharCode(bytes[i]);
-        }
-        return btoa(binary);
-    }
-    // Node.js 环境（fallback）
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(buffer).toString('base64');
-    }
-    throw new Error('❌ Base64 编码不可用');
-}
-/**
- * 生成随机 Hex 字符串
- */
-function randomHex(length) {
-    const crypto = getCryptoAPI();
-    const array = new Uint8Array(length);
-    crypto.getRandomValues(array);
-    return Array.from(array)
-        .map(b => b.toString(16).padStart(2, '0'))
-        .join('');
-}
-/**
- * 用服务器公钥加密签名交易（ECDH + AES-GCM）
- *
- * @param signedTransactions 签名后的交易数组
- * @param publicKeyBase64 服务器提供的公钥（Base64 格式）
- * @returns JSON 字符串 {e: 临时公钥, i: IV, d: 密文}
- */
-export async function encryptWithPublicKey(signedTransactions, publicKeyBase64) {
-    try {
-        // 0. 获取 SubtleCrypto 和 Crypto API
-        const subtle = getSubtleCrypto();
-        const crypto = getCryptoAPI();
-        // 1. 准备数据
-        const payload = {
-            signedTransactions,
-            timestamp: Date.now(),
-            nonce: randomHex(8)
-        };
-        const plaintext = JSON.stringify(payload);
-        // 2. 生成临时 ECDH 密钥对
-        const ephemeralKeyPair = await subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveKey']);
-        // 3. 导入服务器公钥
-        const publicKeyBuffer = base64ToArrayBuffer(publicKeyBase64);
-        const publicKey = await subtle.importKey('raw', publicKeyBuffer, { name: 'ECDH', namedCurve: 'P-256' }, false, []);
-        // 4. 派生共享密钥（AES-256）
-        const sharedKey = await subtle.deriveKey({ name: 'ECDH', public: publicKey }, ephemeralKeyPair.privateKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt']);
-        // 5. AES-GCM 加密
-        const iv = crypto.getRandomValues(new Uint8Array(12));
-        const encrypted = await subtle.encrypt({ name: 'AES-GCM', iv }, sharedKey, new TextEncoder().encode(plaintext));
-        // 6. 导出临时公钥
-        const ephemeralPublicKeyRaw = await subtle.exportKey('raw', ephemeralKeyPair.publicKey);
-        // 7. 返回加密包（JSON 格式）
-        return JSON.stringify({
-            e: arrayBufferToBase64(ephemeralPublicKeyRaw), // 临时公钥
-            i: arrayBufferToBase64(iv.buffer), // IV
-            d: arrayBufferToBase64(encrypted) // 密文
-        });
-    }
-    catch (error) {
-        throw new Error(`加密失败: ${error?.message || String(error)}`);
-    }
-}
-/**
- * 验证公钥格式（Base64）
- */
-export function validatePublicKey(publicKeyBase64) {
-    try {
-        if (!publicKeyBase64)
-            return false;
-        // Base64 字符集验证
-        if (!/^[A-Za-z0-9+/=]+$/.test(publicKeyBase64))
-            return false;
-        // ECDH P-256 公钥固定长度 65 字节（未压缩）
-        // Base64 编码后约 88 字符
-        if (publicKeyBase64.length < 80 || publicKeyBase64.length > 100)
-            return false;
-        return true;
-    }
-    catch {
-        return false;
-    }
-}