four-flap-meme-sdk 1.5.18 → 1.5.19

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

@@ -0,0 +1,16 @@
+/**
+ * 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

@@ -0,0 +1,146 @@
+/**
+ * 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;
+    }
+}

package/dist/utils/bundle-helpers.d.ts

@@ -16,7 +16,9 @@ import { type GeneratedWallet } from './wallet.js';
 export declare class NonceManager {
     private provider;
     private tempNonceCache;
+    private chainIdPromise?;
     constructor(provider: JsonRpcProvider);
+    private getChainId;
     /**
      * 获取下一个可用的 nonce
      * @param wallet 钱包对象或地址

package/dist/utils/bundle-helpers.js

@@ -4,6 +4,47 @@
  */
 import { ethers, Wallet } from 'ethers';
 import { generateWallets } from './wallet.js';
+const GLOBAL_NONCE_TTL_MS = 60 * 1000; // 1 分钟：只用于短时间“pending 不同步”兜底，避免长时间缓存造成 nonce 过高
+const globalNonceCursorByChain = new Map();
+function isFlakyNonceChain(chainId) {
+    // ✅ XLayer: 196（OKX X Layer）
+    return Number(chainId) === 196;
+}
+function getCursorMap(chainId) {
+    let m = globalNonceCursorByChain.get(chainId);
+    if (!m) {
+        m = new Map();
+        globalNonceCursorByChain.set(chainId, m);
+    }
+    return m;
+}
+function getGlobalNextNonce(chainId, addrLower) {
+    const m = globalNonceCursorByChain.get(chainId);
+    if (!m)
+        return undefined;
+    const e = m.get(addrLower);
+    if (!e)
+        return undefined;
+    if (Date.now() - e.updatedAt > GLOBAL_NONCE_TTL_MS) {
+        m.delete(addrLower);
+        return undefined;
+    }
+    return e.nextNonce;
+}
+function setGlobalNextNonce(chainId, addrLower, nextNonce) {
+    const m = getCursorMap(chainId);
+    const cur = m.get(addrLower);
+    const next = Number(nextNonce);
+    if (!Number.isFinite(next) || next < 0)
+        return;
+    if (!cur || next > cur.nextNonce || (Date.now() - cur.updatedAt > GLOBAL_NONCE_TTL_MS)) {
+        m.set(addrLower, { nextNonce: next, updatedAt: Date.now() });
+    }
+    else {
+        // 刷新时间戳，避免短时间内频繁淘汰
+        cur.updatedAt = Date.now();
+    }
+}
 /**
  * Nonce 管理器
  * 用于在 bundle 交易中管理多个钱包的 nonce
@@ -19,6 +60,12 @@ export class NonceManager {
         this.tempNonceCache = new Map();
         this.provider = provider;
     }
+    async getChainId() {
+        if (!this.chainIdPromise) {
+            this.chainIdPromise = this.provider.getNetwork().then(n => Number(n.chainId)).catch(() => 0);
+        }
+        return this.chainIdPromise;
+    }
     /**
      * 获取下一个可用的 nonce
      * @param wallet 钱包对象或地址
@@ -27,18 +74,34 @@ export class NonceManager {
     async getNextNonce(wallet) {
         const address = typeof wallet === 'string' ? wallet : wallet.address;
         const key = address.toLowerCase();
+        const chainId = await this.getChainId();
+        const flaky = isFlakyNonceChain(chainId);
         // 检查临时缓存
         if (this.tempNonceCache.has(key)) {
             const cachedNonce = this.tempNonceCache.get(key);
             this.tempNonceCache.set(key, cachedNonce + 1);
+            if (flaky)
+                setGlobalNextNonce(chainId, key, cachedNonce + 1);
             return cachedNonce;
         }
         // ✅ 使用 'pending' 获取 nonce（包含待处理交易）
         // 由于前端已移除 nonce 缓存，SDK 每次都从链上获取最新状态
         const onchainNonce = await this.provider.getTransactionCount(address, 'pending');
+        // ✅ XLayer：如果链上 pending nonce 暂时没跟上，短时间内允许使用“全局游标”兜底（只允许小幅领先）
+        let effectiveNonce = onchainNonce;
+        if (flaky) {
+            const globalNext = getGlobalNextNonce(chainId, key);
+            if (globalNext !== undefined) {
+                const delta = globalNext - onchainNonce;
+                if (delta > 0 && delta <= 10) {
+                    effectiveNonce = globalNext;
+                }
+            }
+            setGlobalNextNonce(chainId, key, effectiveNonce + 1);
+        }
         // 缓存下一个值（仅在当前批次内有效）
-        this.tempNonceCache.set(key, onchainNonce + 1);
-        return onchainNonce;
+        this.tempNonceCache.set(key, effectiveNonce + 1);
+        return effectiveNonce;
     }
     /**
      * 批量获取连续 nonce（推荐用于同一地址的批量交易）
@@ -49,6 +112,8 @@ export class NonceManager {
     async getNextNonceBatch(wallet, count) {
         const address = typeof wallet === 'string' ? wallet : wallet.address;
         const key = address.toLowerCase();
+        const chainId = await this.getChainId();
+        const flaky = isFlakyNonceChain(chainId);
         let startNonce;
         if (this.tempNonceCache.has(key)) {
             startNonce = this.tempNonceCache.get(key);
@@ -56,8 +121,18 @@ export class NonceManager {
         else {
             startNonce = await this.provider.getTransactionCount(address, 'pending');
         }
+        if (flaky) {
+            const globalNext = getGlobalNextNonce(chainId, key);
+            if (globalNext !== undefined) {
+                const delta = globalNext - startNonce;
+                if (delta > 0 && delta <= 10)
+                    startNonce = globalNext;
+            }
+        }
         // 更新缓存
         this.tempNonceCache.set(key, startNonce + count);
+        if (flaky)
+            setGlobalNextNonce(chainId, key, startNonce + count);
         // 返回连续 nonce 数组
         return Array.from({ length: count }, (_, i) => startNonce + i);
     }
@@ -82,6 +157,8 @@ export class NonceManager {
     async getNextNoncesForWallets(wallets) {
         const addresses = wallets.map(w => typeof w === 'string' ? w : w.address);
         const keys = addresses.map(a => a.toLowerCase());
+        const chainId = await this.getChainId();
+        const flaky = isFlakyNonceChain(chainId);
         // 分离：已缓存的 vs 需要查询的
         const needQuery = [];
         const results = new Array(wallets.length);
@@ -91,6 +168,8 @@ export class NonceManager {
                 const cachedNonce = this.tempNonceCache.get(key);
                 results[i] = cachedNonce;
                 this.tempNonceCache.set(key, cachedNonce + 1);
+                if (flaky)
+                    setGlobalNextNonce(chainId, key, cachedNonce + 1);
             }
             else {
                 needQuery.push({ index: i, address: addresses[i] });
@@ -127,9 +206,20 @@ export class NonceManager {
             // 填充结果并更新缓存
             for (let i = 0; i < needQuery.length; i++) {
                 const { index, address } = needQuery[i];
-                const nonce = queryResults[i];
-                results[index] = nonce;
-                this.tempNonceCache.set(address.toLowerCase(), nonce + 1);
+                const key = address.toLowerCase();
+                const onchainNonce = queryResults[i];
+                let effectiveNonce = onchainNonce;
+                if (flaky) {
+                    const globalNext = getGlobalNextNonce(chainId, key);
+                    if (globalNext !== undefined) {
+                        const delta = globalNext - onchainNonce;
+                        if (delta > 0 && delta <= 10)
+                            effectiveNonce = globalNext;
+                    }
+                    setGlobalNextNonce(chainId, key, effectiveNonce + 1);
+                }
+                results[index] = effectiveNonce;
+                this.tempNonceCache.set(key, effectiveNonce + 1);
             }
         }
         return results;

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

@@ -85,22 +85,6 @@ 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,60 +170,6 @@ 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 { Wallet, Interface, Contract } from 'ethers';
+import { Interface, Contract } from 'ethers';
 import { FLAP_PORTAL, ENTRYPOINT_ABI, DEFAULT_CALL_GAS_LIMIT_SELL, DEFAULT_WITHDRAW_RESERVE, } from './constants.js';
-import { AAAccountManager, encodeExecute } from './aa-account.js';
+import { AAAccountManager, encodeExecute, createWallet } from './aa-account.js';
 import { encodeBuyCall, encodeSellCall, encodeApproveCall, encodeTransferCall, PortalQuery, parseOkb, formatOkb, } from './portal-ops.js';
 // ============================================================================
 // 捆绑交易执行器
@@ -249,75 +249,40 @@ export class BundleExecutor {
             throw new Error('私钥数量和购买金额数量必须一致');
         }
         // 使用第一个 owner 作为 bundler signer
-        const sharedProvider = this.aaManager.getProvider();
-        const wallets = privateKeys.map((pk) => new Wallet(pk, sharedProvider));
+        const wallets = privateKeys.map((pk) => createWallet(pk, this.config));
         const bundlerSigner = wallets[0];
         const beneficiary = bundlerSigner.address;
         console.log('=== XLayer Bundle Buy ===');
         console.log('token:', tokenAddress);
         console.log('owners:', wallets.length);
-        // 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);
+        // 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);
+        }
         // 2. 执行买入
         const buyResult = await this.runHandleOps('buyBundle', buyOps, bundlerSigner, beneficiary);
         if (!buyResult) {
             throw new Error('买入交易失败');
         }
         // 3. 获取代币余额
-        const senders = accountInfos.map((ai) => ai.sender);
+        const senders = await Promise.all(wallets.map((w) => this.aaManager.predictSenderAddress(w.address)));
         const tokenBalances = await this.portalQuery.getMultipleTokenBalances(tokenAddress, senders);
         // 4. 可选：转账代币回 owner
         let transferResult;
         if (transferBackToOwner) {
-            const idxs = [];
-            const transferCallDatas = [];
+            const transferOps = [];
             for (let i = 0; i < wallets.length; i++) {
-                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));
+                const signed = await this.buildTransferTokenUserOp(wallets[i], tokenAddress, `owner${i + 1}`);
+                if (signed) {
+                    transferOps.push(signed.userOp);
+                }
             }
-            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;
+            if (transferOps.length > 0) {
+                transferResult = await this.runHandleOps('transferBundle', transferOps, bundlerSigner, beneficiary) ?? undefined;
             }
         }
         return { buyResult, transferResult, tokenBalances };
@@ -329,8 +294,7 @@ export class BundleExecutor {
      */
     async bundleSell(params) {
         const { tokenAddress, privateKeys, sellPercent = 100, withdrawToOwner = true, withdrawReserve = DEFAULT_WITHDRAW_RESERVE, } = params;
-        const sharedProvider = this.aaManager.getProvider();
-        const wallets = privateKeys.map((pk) => new Wallet(pk, sharedProvider));
+        const wallets = privateKeys.map((pk) => createWallet(pk, this.config));
         const bundlerSigner = wallets[0];
         const beneficiary = bundlerSigner.address;
         const reserveWei = parseOkb(withdrawReserve);
@@ -406,8 +370,7 @@ export class BundleExecutor {
         if (privateKeys.length !== buyAmounts.length) {
             throw new Error('私钥数量和购买金额数量必须一致');
         }
-        const sharedProvider = this.aaManager.getProvider();
-        const wallets = privateKeys.map((pk) => new Wallet(pk, sharedProvider));
+        const wallets = privateKeys.map((pk) => createWallet(pk, this.config));
         const bundlerSigner = wallets[0];
         const beneficiary = bundlerSigner.address;
         const reserveWei = parseOkb(withdrawReserve);

package/dist/xlayer/bundler.d.ts

@@ -56,13 +56,6 @@ export declare class BundlerClient {
      * 发送 JSON-RPC 请求到 Bundler
      */
     private rpc;
-    /**
-     * 发送 JSON-RPC Batch 请求到 Bundler
-     *
-     * 注意：JSON-RPC batch 是一个数组；Particle bundler 通常也支持该格式。
-     * 为兼容其非标准字段，这里为每个 request 也附带 chainId 字段。
-     */
-    private rpcBatch;
     /**
      * 获取支持的 EntryPoint 列表
      */
@@ -74,10 +67,6 @@ 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,64 +69,6 @@ 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 列表
      */
@@ -145,24 +87,6 @@ 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.18",
+  "version": "1.5.19",
   "description": "SDK for Flap bonding curve and four.meme TokenManager",
   "type": "module",
   "main": "dist/index.js",