four-flap-meme-sdk 1.3.80 → 1.3.82

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 {