four-flap-meme-sdk 1.3.80 → 1.3.81

package/dist/contracts/tm-bundle-merkle/approve-tokenmanager.d.ts

@@ -21,5 +21,6 @@ export type ApproveFourTokenManagerBatchResult = {
  * ✅ 不需要 Merkle API Key，使用普通 RPC 即可
  * ✅ 专门用于授权给 TokenManagerOriginal 合约
  * ✅ 用于 fourBatchPrivateSell 和 fourBatchSellWithBundleMerkle
+ * ✅ 优化：并行获取 gasPrice、decimals、allowances
  */
 export declare function approveFourTokenManagerBatch(params: ApproveFourTokenManagerBatchParams): Promise<ApproveFourTokenManagerBatchResult>;

package/dist/contracts/tm-bundle-merkle/approve-tokenmanager.js

@@ -15,6 +15,7 @@ const ERC20_ABI = [
  * ✅ 不需要 Merkle API Key，使用普通 RPC 即可
  * ✅ 专门用于授权给 TokenManagerOriginal 合约
  * ✅ 用于 fourBatchPrivateSell 和 fourBatchSellWithBundleMerkle
+ * ✅ 优化：并行获取 gasPrice、decimals、allowances
  */
 export async function approveFourTokenManagerBatch(params) {
     const { privateKeys, tokenAddress, amounts, config } = params;
@@ -28,27 +29,25 @@ export async function approveFourTokenManagerBatch(params) {
         chainId: chainId,
         name: 'BSC'
     });
-    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
-    // ✅ 优化：如果所有金额都是 'max'，则不需要查询 decimals
-    const allMax = amounts.every(a => a === 'max');
-    let decimals = 18; // 默认值
-    if (!allMax) {
-        try {
-            const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
-            decimals = await tokenContract.decimals();
-        }
-        catch (error) {
-            throw new Error(`查询代币 decimals 失败: ${error.message}`);
-        }
-    }
     const wallets = privateKeys.map(k => new Wallet(k, provider));
+    const allMax = amounts.every(a => a === 'max');
+    // ✅ 优化：并行获取 gasPrice、decimals（如果需要）、allowances
+    const [gasPrice, decimals, allowances] = await Promise.all([
+        getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+        allMax
+            ? Promise.resolve(18) // 如果都是 'max'，不需要查询 decimals
+            : (async () => {
+                try {
+                    const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
+                    return await tokenContract.decimals();
+                }
+                catch (error) {
+                    throw new Error(`查询代币 decimals 失败: ${error.message}`);
+                }
+            })(),
+        batchCheckAllowances(provider, tokenAddress, wallets.map(w => w.address), tmAddr)
+    ]);
     const amountsBigInt = amounts.map(a => a === 'max' ? ethers.MaxUint256 : ethers.parseUnits(a, decimals));
-    // ✅ 检查是否有非 'max' 的授权
-    const hasNonMaxAmount = amounts.some(a => a !== 'max');
-    if (hasNonMaxAmount) {
-    }
-    // 检查现有授权，过滤掉已经足够的
-    const allowances = await batchCheckAllowances(provider, tokenAddress, wallets.map(w => w.address), tmAddr);
     // 只授权不足的
     // ✅ 策略：如果授权额度 < MaxUint256 / 2n，就重新授权（确保授权足够大）
     const APPROVAL_THRESHOLD = ethers.MaxUint256 / 2n;
@@ -64,10 +63,7 @@ export async function approveFourTokenManagerBatch(params) {
             message: '所有钱包已授权，无需重复授权'
         };
     }
-    // 构建授权交易
-    const needApprovalTokens = needApproval.map(w => new ethers.Contract(tokenAddress, ERC20_ABI, w));
-    const unsignedApprovals = await Promise.all(needApprovalTokens.map((token, i) => token.approve.populateTransaction(tmAddr, needApprovalAmounts[i])));
-    // 使用前端传入的 gasLimit，否则使用默认值
+    // ✅ 优化：计算 gasLimit（不需要 RPC）
     const getGasLimit = (cfg) => {
         if (cfg.gasLimit)
             return BigInt(cfg.gasLimit);
@@ -76,9 +72,15 @@ export async function approveFourTokenManagerBatch(params) {
         return 60000n; // 默认授权 gas limit
     };
     const finalGasLimit = getGasLimit(config);
-    // 签名授权交易
+    const txType = getTxType(config);
+    // ✅ 优化：并行获取 nonces 和构建未签名交易
     const nonceManager = new NonceManager(provider);
-    const nonces = await Promise.all(needApproval.map(w => nonceManager.getNextNonce(w)));
+    const needApprovalTokens = needApproval.map(w => new ethers.Contract(tokenAddress, ERC20_ABI, w));
+    const [nonces, unsignedApprovals] = await Promise.all([
+        nonceManager.getNextNoncesForWallets(needApproval), // ✅ 批量获取 nonces（JSON-RPC 批量请求）
+        Promise.all(needApprovalTokens.map((token, i) => token.approve.populateTransaction(tmAddr, needApprovalAmounts[i])))
+    ]);
+    // ✅ 并行签名所有授权交易
     const signedTxs = await Promise.all(unsignedApprovals.map((unsigned, i) => needApproval[i].signTransaction({
         ...unsigned,
         from: needApproval[i].address,
@@ -86,14 +88,14 @@ export async function approveFourTokenManagerBatch(params) {
         gasLimit: finalGasLimit,
         gasPrice,
         chainId,
-        type: getTxType(config)
+        type: txType
     })));
     nonceManager.clearTemp();
     try {
-        // 广播所有授权交易
+        // ✅ 并行广播所有授权交易
         const txResponses = await Promise.all(signedTxs.map(tx => provider.broadcastTransaction(tx)));
         const txHashes = txResponses.map(r => r.hash);
-        // 等待所有授权交易确认（至少1个确认）
+        // ✅ 并行等待所有授权交易确认（至少1个确认）
         await Promise.all(txResponses.map(tx => tx.wait(1)));
         return {
             success: true,

package/dist/contracts/tm-bundle-merkle/internal.d.ts

@@ -1,8 +1,16 @@
 import { JsonRpcProvider } from 'ethers';
 import type { AmountLike } from './types.js';
-export declare function getErc20DecimalsMerkle(provider: JsonRpcProvider, token: string): Promise<number>;
+/**
+ * 获取 ERC20 代币精度（带缓存）
+ * ✅ 优化：避免每次调用都获取 network，使用 provider._network 或传入 chainId
+ */
+export declare function getErc20DecimalsMerkle(provider: JsonRpcProvider, token: string, chainId?: number): Promise<number>;
 export declare function generateHopWallets(recipientCount: number, hopCount: number | number[]): string[][] | null;
 export declare function normalizeAmounts(recipients: string[], amount?: AmountLike, amounts?: AmountLike[]): string[];
+/**
+ * 批量获取余额（原生代币或 ERC20）
+ * ✅ 优化：原生代币也使用 Multicall3 批量获取，减少 RPC 调用
+ */
 export declare function batchGetBalances(provider: JsonRpcProvider, addresses: string[], tokenAddress?: string): Promise<bigint[]>;
 export declare function calculateGasLimit(config: any, isNative: boolean, hasHops: boolean, hopCount?: number): bigint;
 export declare function isNativeTokenAddress(tokenAddress?: string): boolean;

package/dist/contracts/tm-bundle-merkle/internal.js

@@ -1,9 +1,14 @@
 import { ethers, Wallet } from 'ethers';
 // 内部缓存：ERC20 小数位
 const decimalsCache = new Map();
-export async function getErc20DecimalsMerkle(provider, token) {
-    const network = await provider.getNetwork();
-    const key = `${network.chainId}_${token.toLowerCase()}`;
+/**
+ * 获取 ERC20 代币精度（带缓存）
+ * ✅ 优化：避免每次调用都获取 network，使用 provider._network 或传入 chainId
+ */
+export async function getErc20DecimalsMerkle(provider, token, chainId) {
+    // ✅ 优化：优先使用传入的 chainId，其次使用 provider 内部缓存的 network
+    const resolvedChainId = chainId ?? (provider._network?.chainId ? Number(provider._network.chainId) : 56);
+    const key = `${resolvedChainId}_${token.toLowerCase()}`;
     if (decimalsCache.has(key))
         return decimalsCache.get(key);
     try {
@@ -44,18 +49,49 @@ export function normalizeAmounts(recipients, amount, amounts) {
     }
     throw new Error('Either amount or amounts must be provided');
 }
+/**
+ * 批量获取余额（原生代币或 ERC20）
+ * ✅ 优化：原生代币也使用 Multicall3 批量获取，减少 RPC 调用
+ */
 export async function batchGetBalances(provider, addresses, tokenAddress) {
     if (addresses.length === 0)
         return [];
+    const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+    const MULTICALL3_ABI = [
+        'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) view returns (tuple(bool success, bytes returnData)[] returnData)',
+        'function getEthBalance(address addr) view returns (uint256 balance)' // ✅ 新增：原生代币余额查询
+    ];
+    const multicall = new ethers.Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, provider);
     if (!tokenAddress) {
-        return Promise.all(addresses.map(addr => provider.getBalance(addr).catch(() => 0n)));
+        // ✅ 优化：原生代币使用 Multicall3.getEthBalance 批量获取（单次 RPC 调用）
+        const multicallIface = new ethers.Interface(MULTICALL3_ABI);
+        const calls = addresses.map(addr => ({
+            target: MULTICALL3_ADDRESS,
+            allowFailure: true,
+            callData: multicallIface.encodeFunctionData('getEthBalance', [addr])
+        }));
+        try {
+            const results = await multicall.aggregate3(calls);
+            return results.map((result) => {
+                if (result.success && result.returnData && result.returnData !== '0x') {
+                    try {
+                        const decoded = multicallIface.decodeFunctionResult('getEthBalance', result.returnData);
+                        return decoded[0];
+                    }
+                    catch {
+                        return 0n;
+                    }
+                }
+                return 0n;
+            });
+        }
+        catch {
+            // ✅ 回退：并行调用（如果 Multicall3 失败）
+            return Promise.all(addresses.map(addr => provider.getBalance(addr).catch(() => 0n)));
+        }
     }
     else {
-        const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
-        const MULTICALL3_ABI = [
-            'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) view returns (tuple(bool success, bytes returnData)[] returnData)'
-        ];
-        const multicall = new ethers.Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, provider);
+        // ERC20 余额：使用 Multicall3 批量获取
         const ERC20_ABI = ['function balanceOf(address) view returns (uint256)'];
         const iface = new ethers.Interface(ERC20_ABI);
         const calls = addresses.map(addr => ({
@@ -66,13 +102,19 @@ export async function batchGetBalances(provider, addresses, tokenAddress) {
         try {
             const results = await multicall.aggregate3(calls);
             return results.map((result) => {
-                if (result.success) {
-                    return iface.decodeFunctionResult('balanceOf', result.returnData)[0];
+                if (result.success && result.returnData && result.returnData !== '0x') {
+                    try {
+                        return iface.decodeFunctionResult('balanceOf', result.returnData)[0];
+                    }
+                    catch {
+                        return 0n;
+                    }
                 }
                 return 0n;
             });
         }
         catch {
+            // ✅ 回退：并行调用（如果 Multicall3 失败）
             const fallbackCalls = addresses.map(addr => provider
                 .call({ to: tokenAddress, data: iface.encodeFunctionData('balanceOf', [addr]) })
                 .then(raw => iface.decodeFunctionResult('balanceOf', raw)[0])

package/dist/contracts/tm-bundle-merkle/private.d.ts

@@ -2,22 +2,26 @@ import { FourPrivateBuySignParams, FourPrivateSellSignParams, FourPrivateTransac
 /**
  * 私有购买（单笔）（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
+ * ✅ 优化：并行获取 gasPrice 和 nonce
  */
 export declare function fourPrivateBuyMerkle(params: FourPrivateBuySignParams): Promise<FourPrivateTransactionResult>;
 /**
  * 私有卖出（单笔）（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
  * ✅ 自动检查授权，智能处理授权+卖出
+ * ✅ 优化：并行获取 gasPrice、allowance、nonce
  */
 export declare function fourPrivateSellMerkle(params: FourPrivateSellSignParams): Promise<FourPrivateTransactionResult>;
 /**
  * 批量私有购买（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
+ * ✅ 优化：并行获取 gasPrice 和 nonces，批量构建交易
  */
 export declare function fourBatchPrivateBuyMerkle(params: FourBatchPrivateBuySignParams): Promise<FourBatchPrivateMerkleResult>;
 /**
  * 批量私有卖出（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
  * ✅ 自动包含授权交易，无需前端单独调用
+ * ✅ 优化：并行获取所有查询数据，批量获取 nonces
  */
 export declare function fourBatchPrivateSellMerkle(params: FourBatchPrivateSellSignParams): Promise<FourBatchPrivateMerkleResult>;

package/dist/contracts/tm-bundle-merkle/private.js

@@ -1,5 +1,4 @@
 import { ethers, Wallet } from 'ethers';
-// import { MerkleClient } from '../../clients/merkle.js';
 import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.js';
 import { ADDRESSES } from '../../utils/constants.js';
 import { getTxType, getGasPriceConfig, shouldExtractProfit, calculateProfit, calculateBatchProfit, getProfitRecipient } from './config.js';
@@ -29,6 +28,7 @@ function getGasLimit(config, defaultGas = DEFAULT_GAS_LIMIT) {
 /**
  * 私有购买（单笔）（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
+ * ✅ 优化：并行获取 gasPrice 和 nonce
  */
 export async function fourPrivateBuyMerkle(params) {
     const { privateKey, tokenAddress, funds, to, config } = params;
@@ -39,41 +39,40 @@ export async function fourPrivateBuyMerkle(params) {
     });
     const wallet = new Wallet(privateKey, provider);
     const tmAddr = ADDRESSES.BSC.TokenManagerOriginal;
-    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
     const txType = getTxType(config);
     const gasLimit = getGasLimit(config);
     const originalFundsWei = ethers.parseEther(funds);
-    // ✅ 利润提取配置
+    // ✅ 利润提取配置（同步计算）
     const extractProfit = shouldExtractProfit(config);
     let profitWei = 0n;
     let actualFundsWei = originalFundsWei;
     if (extractProfit) {
         const { profit, remaining } = calculateProfit(originalFundsWei, config);
         profitWei = profit;
-        actualFundsWei = remaining; // ✅ 扣除利润后的金额用于购买
+        actualFundsWei = remaining;
     }
-    const minAmount = 0n;
-    const signedTxs = [];
     const tm2 = new ethers.Contract(tmAddr, TM2_ABI, wallet);
-    // ✅ 使用 TokenManager2 原始方法：buyTokenAMAP
-    const unsigned = await tm2.buyTokenAMAP.populateTransaction(0n, tokenAddress, to ?? wallet.address, actualFundsWei, minAmount, { value: actualFundsWei } // ✅ 使用扣除利润后的金额
-    );
-    let currentNonce = await wallet.getNonce();
-    const req = {
-        ...unsigned,
-        from: wallet.address,
-        nonce: currentNonce,
-        gasLimit,
-        gasPrice,
-        chainId: CHAIN_ID,
-        type: txType,
-        value: actualFundsWei // ✅ funds = msg.value（合约要求两者相等）
-    };
-    const signed = await wallet.signTransaction(req);
-    signedTxs.push(signed);
-    // ✅ 添加利润转账
+    // ✅ 优化：并行获取 gasPrice、nonce 和构建未签名交易
+    const [gasPrice, currentNonce, unsigned] = await Promise.all([
+        getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+        wallet.getNonce(),
+        tm2.buyTokenAMAP.populateTransaction(0n, tokenAddress, to ?? wallet.address, actualFundsWei, 0n, { value: actualFundsWei })
+    ]);
+    // ✅ 并行签名主交易和利润交易
+    const signPromises = [
+        wallet.signTransaction({
+            ...unsigned,
+            from: wallet.address,
+            nonce: currentNonce,
+            gasLimit,
+            gasPrice,
+            chainId: CHAIN_ID,
+            type: txType,
+            value: actualFundsWei
+        })
+    ];
     if (extractProfit && profitWei > 0n) {
-        const profitTx = await wallet.signTransaction({
+        signPromises.push(wallet.signTransaction({
             to: getProfitRecipient(),
             value: profitWei,
             nonce: currentNonce + 1,
@@ -81,11 +80,9 @@ export async function fourPrivateBuyMerkle(params) {
             gasLimit: 21000n,
             chainId: CHAIN_ID,
             type: txType
-        });
-        signedTxs.push(profitTx);
+        }));
     }
-    // ✅ 直接返回签名交易（不提交到Merkle）
-    // ✅ 简化返回：只返回签名交易
+    const signedTxs = await Promise.all(signPromises);
     return {
         signedTransactions: signedTxs
     };
@@ -94,6 +91,7 @@ export async function fourPrivateBuyMerkle(params) {
  * 私有卖出（单笔）（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
  * ✅ 自动检查授权，智能处理授权+卖出
+ * ✅ 优化：并行获取 gasPrice、allowance、nonce
  */
 export async function fourPrivateSellMerkle(params) {
     const { privateKey, tokenAddress, amount, minFunds, config } = params;
@@ -104,64 +102,52 @@ export async function fourPrivateSellMerkle(params) {
     });
     const wallet = new Wallet(privateKey, provider);
     const tmAddr = ADDRESSES.BSC.TokenManagerOriginal;
-    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
     const txType = getTxType(config);
     const sellGasLimit = getGasLimit(config);
     const amountWei = ethers.parseUnits(amount, 18);
     const minOut = minFunds ?? 0n;
-    // ✅ Step 1: 检查授权状态
     const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
-    const currentAllowance = await tokenContract.allowance(wallet.address, tmAddr);
-    // 使用 MaxUint256 的一半作为阈值，确保能处理超大供应量代币
+    const tm2 = new ethers.Contract(tmAddr, TM2_ABI, wallet);
+    // ✅ 优化：并行获取 gasPrice、allowance、nonce 和构建未签名交易
+    const [gasPrice, currentAllowance, sellNonce, sellUnsigned] = await Promise.all([
+        getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+        tokenContract.allowance(wallet.address, tmAddr),
+        wallet.getNonce(),
+        tm2.sellToken.populateTransaction(0n, tokenAddress, amountWei, minOut)
+    ]);
+    // ✅ 检查授权状态
     const APPROVAL_THRESHOLD = ethers.MaxUint256 / 2n;
-    // ✅ Step 2: 如果需要授权，抛出错误提示
-    // ⚠️ SDK不再处理授权，需要前端先单独授权
     if (currentAllowance < APPROVAL_THRESHOLD) {
         throw new Error(`需要授权：钱包 ${wallet.address} 尚未授权。请先完成授权后再卖出。`);
     }
-    else {
-    }
-    // ✅ Step 3: 卖出交易
-    const nonceManager = new NonceManager(provider);
-    const signedTxs = [];
-    const tm2 = new ethers.Contract(tmAddr, TM2_ABI, wallet);
-    const sellUnsigned = await tm2.sellToken.populateTransaction(0n, tokenAddress, amountWei, minOut);
-    const sellNonce = await nonceManager.getNextNonce(wallet);
-    // ✅ 卖出交易 value 必须为 0，不能发送原生代币
-    const sellReq = {
-        ...sellUnsigned,
-        from: wallet.address,
-        nonce: sellNonce,
-        gasLimit: sellGasLimit,
-        gasPrice,
-        chainId: CHAIN_ID,
-        type: txType,
-        value: 0n // ✅ 卖出交易不发送原生代币
-    };
-    const signedSell = await wallet.signTransaction(sellReq);
-    signedTxs.push(signedSell);
-    // ✅ 基于 minFunds 计算利润
+    // ✅ 利润计算（同步）
     const extractProfit = shouldExtractProfit(config);
-    if (extractProfit) {
-        const { profit } = calculateProfit(minOut, config);
-        if (profit > 0n) {
-            const profitNonce = await nonceManager.getNextNonce(wallet);
-            const profitTx = await wallet.signTransaction({
-                to: getProfitRecipient(),
-                value: profit,
-                nonce: profitNonce,
-                gasPrice,
-                gasLimit: 21000n,
-                chainId: CHAIN_ID,
-                type: txType
-            });
-            signedTxs.push(profitTx);
-        }
+    const { profit } = extractProfit ? calculateProfit(minOut, config) : { profit: 0n };
+    // ✅ 并行签名主交易和利润交易
+    const signPromises = [
+        wallet.signTransaction({
+            ...sellUnsigned,
+            from: wallet.address,
+            nonce: sellNonce,
+            gasLimit: sellGasLimit,
+            gasPrice,
+            chainId: CHAIN_ID,
+            type: txType,
+            value: 0n
+        })
+    ];
+    if (extractProfit && profit > 0n) {
+        signPromises.push(wallet.signTransaction({
+            to: getProfitRecipient(),
+            value: profit,
+            nonce: sellNonce + 1,
+            gasPrice,
+            gasLimit: 21000n,
+            chainId: CHAIN_ID,
+            type: txType
+        }));
     }
-    // ✅ 清理临时 nonce 缓存
-    nonceManager.clearTemp();
-    // ✅ 直接返回签名交易（不提交到Merkle）
-    // ✅ 简化返回：只返回签名交易
+    const signedTxs = await Promise.all(signPromises);
     return {
         signedTransactions: signedTxs
     };
@@ -169,6 +155,7 @@ export async function fourPrivateSellMerkle(params) {
 /**
  * 批量私有购买（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
+ * ✅ 优化：并行获取 gasPrice 和 nonces，批量构建交易
  */
 export async function fourBatchPrivateBuyMerkle(params) {
     const { privateKeys, fundsList, tokenAddress, config } = params;
@@ -181,18 +168,15 @@ export async function fourBatchPrivateBuyMerkle(params) {
         name: 'BSC'
     });
     const tmAddr = ADDRESSES.BSC.TokenManagerOriginal;
-    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
     const txType = getTxType(config);
     const finalGasLimit = getGasLimit(config);
-    const signedTxs = [];
-    const nonceManager = new NonceManager(provider);
     const wallets = privateKeys.map((k) => new Wallet(k, provider));
     const originalAmountsWei = fundsList.map((a) => ethers.parseEther(a));
-    // ✅ 利润提取配置
+    // ✅ 利润提取配置（同步计算）
     const extractProfit = shouldExtractProfit(config);
     const { totalProfit, remainingAmounts } = calculateBatchProfit(originalAmountsWei, config);
-    const actualAmountsWei = remainingAmounts; // 扣除利润后用于购买的金额
-    // ✅ 找出投入金额最多的钱包（作为利润支付者）
+    const actualAmountsWei = remainingAmounts;
+    // ✅ 找出投入金额最多的钱包（作为利润支付者）- 同步计算
     let maxFundsIndex = 0;
     let maxFunds = originalAmountsWei[0];
     for (let i = 1; i < originalAmountsWei.length; i++) {
@@ -202,51 +186,69 @@ export async function fourBatchPrivateBuyMerkle(params) {
         }
     }
     const tm2Contracts = wallets.map((w) => new ethers.Contract(tmAddr, TM2_ABI, w));
-    // ✅ 使用 TokenManager2 原始方法：buyTokenAMAP（使用扣除利润后的金额）
-    const unsignedList = await Promise.all(tm2Contracts.map((c, i) => c.buyTokenAMAP.populateTransaction(0n, tokenAddress, wallets[i].address, actualAmountsWei[i], 0n, { value: actualAmountsWei[i] })));
-    const gasLimits = new Array(wallets.length).fill(finalGasLimit);
-    // ✅ Nonce 管理：如果有利润，支付者需要 2 个 nonce（买入 + 利润）
-    const nonces = [];
-    for (let i = 0; i < wallets.length; i++) {
-        if (extractProfit && i === maxFundsIndex && totalProfit > 0n) {
-            // 支付者需要 2 个 nonce
-            const [nonce] = await nonceManager.getNextNonceBatch(wallets[i], 2);
-            nonces.push(nonce);
-        }
-        else {
-            // 其他钱包只需要 1 个 nonce
-            const nonce = await nonceManager.getNextNonce(wallets[i]);
-            nonces.push(nonce);
-        }
-    }
+    const nonceManager = new NonceManager(provider);
+    const needProfitTx = extractProfit && totalProfit > 0n;
+    // ✅ 优化：并行获取 gasPrice、nonces 和构建未签名交易
+    // 支付者需要 2 个 nonce，其他钱包各需要 1 个 nonce
+    const [gasPrice, unsignedList, noncesResult] = await Promise.all([
+        getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+        Promise.all(tm2Contracts.map((c, i) => c.buyTokenAMAP.populateTransaction(0n, tokenAddress, wallets[i].address, actualAmountsWei[i], 0n, { value: actualAmountsWei[i] }))),
+        (async () => {
+            if (needProfitTx) {
+                // 支付者需要 2 个连续 nonce
+                const payerNonces = await nonceManager.getNextNonceBatch(wallets[maxFundsIndex], 2);
+                // 其他钱包各需要 1 个 nonce
+                const otherWallets = wallets.filter((_, i) => i !== maxFundsIndex);
+                const otherNonces = otherWallets.length > 0
+                    ? await nonceManager.getNextNoncesForWallets(otherWallets)
+                    : [];
+                // 组装最终的 nonces 数组（保持原顺序）
+                const nonces = [];
+                let otherIdx = 0;
+                for (let i = 0; i < wallets.length; i++) {
+                    if (i === maxFundsIndex) {
+                        nonces.push(payerNonces[0]);
+                    }
+                    else {
+                        nonces.push(otherNonces[otherIdx++]);
+                    }
+                }
+                return { nonces, profitNonce: payerNonces[1] };
+            }
+            else {
+                // 所有钱包各 1 个 nonce
+                const nonces = await nonceManager.getNextNoncesForWallets(wallets);
+                return { nonces, profitNonce: undefined };
+            }
+        })()
+    ]);
+    const { nonces, profitNonce } = noncesResult;
+    // ✅ 并行签名所有买入交易
     const signedList = await Promise.all(unsignedList.map((unsigned, i) => wallets[i].signTransaction({
         ...unsigned,
         from: wallets[i].address,
         nonce: nonces[i],
-        gasLimit: gasLimits[i],
+        gasLimit: finalGasLimit,
         gasPrice,
         chainId: CHAIN_ID,
         type: txType,
-        value: actualAmountsWei[i] // ✅ funds = msg.value（合约要求两者相等）
+        value: actualAmountsWei[i]
     })));
-    signedTxs.push(...signedList);
+    const signedTxs = [...signedList];
     // ✅ 聚合利润：由投入金额最多的钱包支付所有利润（1笔交易）
-    if (extractProfit && totalProfit > 0n) {
-        const profitNonce = nonces[maxFundsIndex] + 1;
+    if (needProfitTx && profitNonce !== undefined) {
         const profitTx = await wallets[maxFundsIndex].signTransaction({
             to: getProfitRecipient(),
             value: totalProfit,
             nonce: profitNonce,
             gasPrice,
             gasLimit: 21000n,
-            chainId: 56,
-            type: getTxType(config)
+            chainId: CHAIN_ID,
+            type: txType
         });
         signedTxs.push(profitTx);
     }
-    // ✅ 清理临时 nonce 缓存
     nonceManager.clearTemp();
-    // ✅ 简化返回：只返回签名交易
     return {
         signedTransactions: signedTxs
     };
@@ -255,6 +257,7 @@ export async function fourBatchPrivateBuyMerkle(params) {
  * 批量私有卖出（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
  * ✅ 自动包含授权交易，无需前端单独调用
+ * ✅ 优化：并行获取所有查询数据，批量获取 nonces
  */
 export async function fourBatchPrivateSellMerkle(params) {
     const { privateKeys, amounts, tokenAddress, config, minFundsEach } = params;
@@ -267,73 +270,64 @@ export async function fourBatchPrivateSellMerkle(params) {
         name: 'BSC'
     });
     const tmAddr = ADDRESSES.BSC.TokenManagerOriginal;
-    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
     const txType = getTxType(config);
     const sellGasLimit = getGasLimit(config);
-    const signedTxs = [];
-    const nonceManager = new NonceManager(provider);
     const wallets = privateKeys.map((k) => new Wallet(k, provider));
     const amountsWei = amounts.map((a) => ethers.parseUnits(a, 18));
-    // ✅ 自动获取每个钱包的预期收益（用于利润计算和滑点保护）
-    let quotedOutputs;
-    let minOuts;
-    if (minFundsEach !== undefined) {
-        // 用户提供了 minFundsEach，所有钱包使用相同的 minOut
-        const minOutWei = typeof minFundsEach === 'string' ? ethers.parseEther(minFundsEach) : minFundsEach;
-        minOuts = new Array(wallets.length).fill(minOutWei);
-        quotedOutputs = minOuts.map(m => m * 100n / 95n);
-    }
-    else {
-        // ✅ 自动调用 trySell 获取每个钱包的预期收益
-        const rpcUrl = config.rpcUrl;
-        quotedOutputs = await Promise.all(amountsWei.map(async (amount, i) => {
-            try {
-                const result = await trySell('BSC', rpcUrl, tokenAddress, amount);
-                return result.funds;
-            }
-            catch (error) {
-                return 0n;
-            }
-        }));
-        // ✅ minOuts = 0，不设置滑点限制（大额交易更稳定）
-        minOuts = quotedOutputs.map(() => 0n);
-    }
-    // ✅ Step 0: 检查代币余额
-    const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
-    const balances = await Promise.all(wallets.map(w => tokenContract.balanceOf(w.address)));
+    const rpcUrl = config.rpcUrl;
+    // ✅ 优化：第一批并行获取 - gasPrice、quotedOutputs、balances、allowances、bnbBalances
+    const [gasPrice, quotedOutputs, balances, allowances, bnbBalances] = await Promise.all([
+        getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+        // 获取预期收益
+        minFundsEach !== undefined
+            ? Promise.resolve((() => {
+                const minOutWei = typeof minFundsEach === 'string' ? ethers.parseEther(minFundsEach) : minFundsEach;
+                return new Array(wallets.length).fill(minOutWei * 100n / 95n);
+            })())
+            : Promise.all(amountsWei.map(async (amount) => {
+                try {
+                    const result = await trySell('BSC', rpcUrl, tokenAddress, amount);
+                    return result.funds;
+                }
+                catch {
+                    return 0n;
+                }
+            })),
+        // 检查代币余额
+        (async () => {
+            const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
+            return Promise.all(wallets.map(w => tokenContract.balanceOf(w.address)));
+        })(),
+        // 检查授权状态
+        batchCheckAllowances(provider, tokenAddress, wallets.map(w => w.address), tmAddr),
+        // 检查 BNB 余额
+        Promise.all(wallets.map(w => provider.getBalance(w.address)))
+    ]);
+    // 计算 minOuts
+    const minOuts = minFundsEach !== undefined
+        ? new Array(wallets.length).fill(typeof minFundsEach === 'string' ? ethers.parseEther(minFundsEach) : minFundsEach)
+        : quotedOutputs.map(() => 0n);
+    // ✅ 验证代币余额
     for (let i = 0; i < wallets.length; i++) {
         if (balances[i] < amountsWei[i]) {
-            throw new Error(`钱包 ${i} 代币余额不足：` +
-                `需要 ${ethers.formatUnits(amountsWei[i], 18)}，` +
-                `实际 ${ethers.formatUnits(balances[i], 18)}`);
-        }
-    }
-    // ✅ Step 1: 检查授权状态
-    const allowances = await batchCheckAllowances(provider, tokenAddress, wallets.map(w => w.address), tmAddr);
-    const needApprovalIndexes = [];
-    for (let i = 0; i < wallets.length; i++) {
-        if (allowances[i] < amountsWei[i]) {
-            needApprovalIndexes.push(i);
+            throw new Error(`钱包 ${i} 代币余额不足：需要 ${ethers.formatUnits(amountsWei[i], 18)}，实际 ${ethers.formatUnits(balances[i], 18)}`);
         }
     }
+    // ✅ 验证授权状态
+    const needApprovalIndexes = wallets
+        .map((_, i) => i)
+        .filter(i => allowances[i] < amountsWei[i]);
     if (needApprovalIndexes.length > 0) {
-        throw new Error(`${needApprovalIndexes.length} 个钱包需要授权。` +
-            `请先调用 approveFourTokenManagerBatch({ amounts: ['max', ...] })`);
+        throw new Error(`${needApprovalIndexes.length} 个钱包需要授权。请先调用 approveFourTokenManagerBatch({ amounts: ['max', ...] })`);
     }
-    // ✅ Step 2: 检查 BNB 余额（用于支付 gas）
-    const bnbBalances = await Promise.all(wallets.map(w => provider.getBalance(w.address)));
+    // ✅ 验证 BNB 余额
     const estimatedGasCost = sellGasLimit * gasPrice;
     for (let i = 0; i < wallets.length; i++) {
         if (bnbBalances[i] < estimatedGasCost) {
-            throw new Error(`钱包 ${i} BNB 不足：` +
-                `需要 ${ethers.formatEther(estimatedGasCost)} BNB，` +
-                `实际 ${ethers.formatEther(bnbBalances[i])} BNB`);
+            throw new Error(`钱包 ${i} BNB 不足：需要 ${ethers.formatEther(estimatedGasCost)} BNB，实际 ${ethers.formatEther(bnbBalances[i])} BNB`);
         }
     }
-    // ✅ Step 3: 构建卖出交易
-    const tm2Contracts = wallets.map((w) => new ethers.Contract(tmAddr, TM2_ABI, w));
-    const sellUnsigned = await Promise.all(tm2Contracts.map((c, i) => c.sellToken.populateTransaction(0n, tokenAddress, amountsWei[i], minOuts[i])));
-    // ✅ 计算总利润和找出收益最高的钱包
+    // ✅ 计算总利润和找出收益最高的钱包（同步计算）
     const extractProfit = shouldExtractProfit(config);
     let totalProfit = 0n;
     let maxRevenueIndex = 0;
@@ -350,37 +344,56 @@ export async function fourBatchPrivateSellMerkle(params) {
             }
         }
     }
-    // ✅ Nonce 管理：如果有利润，支付者需要 2 个 nonce（卖出 + 利润）
-    const sellNonces = [];
-    for (let i = 0; i < wallets.length; i++) {
-        if (extractProfit && i === maxRevenueIndex && totalProfit > 0n) {
-            // 支付者需要 2 个 nonce
-            const [nonce] = await nonceManager.getNextNonceBatch(wallets[i], 2);
-            sellNonces.push(nonce);
-        }
-        else {
-            // 其他钱包只需要 1 个 nonce
-            const nonce = await nonceManager.getNextNonce(wallets[i]);
-            sellNonces.push(nonce);
-        }
-    }
-    // ✅ 签名所有卖出交易
-    // ✅ 卖出交易 value 必须为 0，不能发送原生代币
-    const sellGasLimits = new Array(wallets.length).fill(sellGasLimit);
+    const tm2Contracts = wallets.map((w) => new ethers.Contract(tmAddr, TM2_ABI, w));
+    const nonceManager = new NonceManager(provider);
+    const needProfitTx = extractProfit && totalProfit > 0n;
+    // ✅ 优化：第二批并行获取 - nonces 和构建未签名交易
+    const [sellUnsigned, noncesResult] = await Promise.all([
+        Promise.all(tm2Contracts.map((c, i) => c.sellToken.populateTransaction(0n, tokenAddress, amountsWei[i], minOuts[i]))),
+        (async () => {
+            if (needProfitTx) {
+                // 支付者需要 2 个连续 nonce
+                const payerNonces = await nonceManager.getNextNonceBatch(wallets[maxRevenueIndex], 2);
+                // 其他钱包各需要 1 个 nonce
+                const otherWallets = wallets.filter((_, i) => i !== maxRevenueIndex);
+                const otherNonces = otherWallets.length > 0
+                    ? await nonceManager.getNextNoncesForWallets(otherWallets)
+                    : [];
+                // 组装最终的 nonces 数组（保持原顺序）
+                const nonces = [];
+                let otherIdx = 0;
+                for (let i = 0; i < wallets.length; i++) {
+                    if (i === maxRevenueIndex) {
+                        nonces.push(payerNonces[0]);
+                    }
+                    else {
+                        nonces.push(otherNonces[otherIdx++]);
+                    }
+                }
+                return { nonces, profitNonce: payerNonces[1] };
+            }
+            else {
+                // 所有钱包各 1 个 nonce
+                const nonces = await nonceManager.getNextNoncesForWallets(wallets);
+                return { nonces, profitNonce: undefined };
+            }
+        })()
+    ]);
+    const { nonces, profitNonce } = noncesResult;
+    // ✅ 并行签名所有卖出交易
     const signedSells = await Promise.all(sellUnsigned.map((unsigned, i) => wallets[i].signTransaction({
         ...unsigned,
         from: wallets[i].address,
-        nonce: sellNonces[i],
-        gasLimit: sellGasLimits[i],
+        nonce: nonces[i],
+        gasLimit: sellGasLimit,
         gasPrice,
         chainId: CHAIN_ID,
         type: txType,
-        value: 0n // ✅ 卖出交易不发送原生代币
+        value: 0n
     })));
-    signedTxs.push(...signedSells);
+    const signedTxs = [...signedSells];
     // ✅ 聚合利润：由收益最高的钱包支付所有利润（1笔交易）
-    if (extractProfit && totalProfit > 0n) {
-        const profitNonce = sellNonces[maxRevenueIndex] + 1;
+    if (needProfitTx && profitNonce !== undefined) {
         const profitTx = await wallets[maxRevenueIndex].signTransaction({
             to: getProfitRecipient(),
             value: totalProfit,
@@ -393,7 +406,6 @@ export async function fourBatchPrivateSellMerkle(params) {
         signedTxs.push(profitTx);
     }
     nonceManager.clearTemp();
-    // ✅ 简化返回：只返回签名交易
     return {
         signedTransactions: signedTxs
     };

package/dist/contracts/tm-bundle-merkle/submit.d.ts

@@ -224,9 +224,9 @@ export interface DirectSubmitResult {
     errorSummary?: string;
 }
 /**
- * 逐笔广播到 RPC（用于不支持 Bundle 的链，如 Monad）
+ * 并行广播到 RPC（用于不支持 Bundle 的链，如 Monad）
  *
- * 这个方法接收前端构建和签名好的交易，逐笔广播到 RPC 节点
+ * ✅ 优化：默认使用并行广播，速度更快
  *
  * @param signedTransactions 签名后的交易数组
  * @param config 直接广播配置

package/dist/contracts/tm-bundle-merkle/submit.js

@@ -251,9 +251,9 @@ export async function submitMultipleBundlesToBlockRazorParallel(bundles, config)
     return await Promise.all(promises);
 }
 /**
- * 逐笔广播到 RPC（用于不支持 Bundle 的链，如 Monad）
+ * 并行广播到 RPC（用于不支持 Bundle 的链，如 Monad）
  *
- * 这个方法接收前端构建和签名好的交易，逐笔广播到 RPC 节点
+ * ✅ 优化：默认使用并行广播，速度更快
  *
  * @param signedTransactions 签名后的交易数组
  * @param config 直接广播配置
@@ -308,21 +308,10 @@ export async function submitDirectToRpc(signedTransactions, config) {
         chainId,
         name: chainName
     });
-    const results = [];
-    const txHashes = [];
-    const errors = [];
-    // 逐笔广播
-    for (let i = 0; i < signedTransactions.length; i++) {
-        const signedTx = signedTransactions[i];
+    // ✅ 并行广播所有交易
+    const broadcastPromises = signedTransactions.map(async (signedTx, i) => {
         try {
-            // 广播交易
             const txResponse = await provider.broadcastTransaction(signedTx);
-            results.push({
-                index: i,
-                success: true,
-                txHash: txResponse.hash
-            });
-            txHashes.push(txResponse.hash);
             // 如果需要等待确认
             if (config.waitForConfirmation) {
                 try {
@@ -335,18 +324,27 @@ export async function submitDirectToRpc(signedTransactions, config) {
                     console.warn(`⚠️ [${chainName}] 等待交易确认超时: ${txResponse.hash}`);
                 }
             }
+            return {
+                index: i,
+                success: true,
+                txHash: txResponse.hash
+            };
         }
         catch (error) {
             const errorMessage = error?.message || String(error);
-            results.push({
+            console.error(`❌ [${chainName}] 交易 ${i + 1}/${totalTransactions} 广播失败:`, errorMessage);
+            return {
                 index: i,
                 success: false,
                 error: errorMessage
-            });
-            errors.push(`交易 ${i + 1}: ${errorMessage}`);
-            console.error(`❌ [${chainName}] 交易 ${i + 1}/${totalTransactions} 广播失败:`, errorMessage);
+            };
         }
-    }
+    });
+    const results = await Promise.all(broadcastPromises);
+    // 按索引排序结果
+    results.sort((a, b) => a.index - b.index);
+    const txHashes = results.filter(r => r.success && r.txHash).map(r => r.txHash);
+    const errors = results.filter(r => !r.success).map(r => `交易 ${r.index + 1}: ${r.error}`);
     const successCount = txHashes.length;
     const failedCount = totalTransactions - successCount;
     return {

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

@@ -229,7 +229,7 @@ export async function batchBuyWithBundleMerkle(params) {
         resolveGasPrice(provider, config),
         populateBuyTransactionsWithQuote(buyers, FLAP_PORTAL_ADDRESSES[chain], tokenAddress, adjustedFundsList, inputToken, useNativeToken),
         presetNonces && presetNonces.length === buyers.length
-            ? adjustNoncesForProfit(presetNonces, extractProfit, maxFundsIndex, nativeProfitAmount) // ✅ 调整 nonces 避免冲突
+            ? adjustNoncesForProfit(presetNonces) // ✅ 调整 nonces 避免冲突
             : allocateBuyerNonces(buyers, extractProfit, maxFundsIndex, nativeProfitAmount, nonceManager)
     ]);
     if (presetNonces) {
@@ -316,7 +316,7 @@ export async function batchSellWithBundleMerkle(params) {
     let profitNonce;
     if (presetNonces && presetNonces.length === wallets.length) {
         // ✅ 使用前端传入的 nonces，但需要调整避免利润交易冲突
-        nonces = adjustNoncesForProfit(presetNonces, extractProfit, maxRevenueIndex, totalTokenProfit);
+        nonces = adjustNoncesForProfit(presetNonces);
         profitNonce = needProfitTx ? presetNonces[maxRevenueIndex] + 1 : undefined;
     }
     else if (needProfitTx) {
@@ -488,7 +488,7 @@ function buildGasLimitList(length, config) {
  * - 每个钱包使用自己的 nonce 发送买入交易
  * - 利润交易使用 maxIndex 钱包的 nonce + 1（在构建利润交易时处理）
  */
-function adjustNoncesForProfit(presetNonces, extractProfit, maxIndex, totalProfit) {
+function adjustNoncesForProfit(presetNonces) {
     // ✅ 直接返回原始 nonces，不做任何调整
     // 不同钱包的 nonce 是独立的，不会冲突
     return presetNonces;

package/package.json

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