four-flap-meme-sdk 1.3.8 → 1.3.10

package/dist/clients/merkle.d.ts

@@ -78,6 +78,10 @@ export interface SendBundleOptions {
     autoRetry?: boolean;
     /** 最大重试次数（默认2） */
     maxRetries?: number;
+    /** ✅ 新增：使用时间戳模式（Merkle 会在时间范围内尽快打包） */
+    useTimestampMode?: boolean;
+    /** ✅ 新增：时间戳窗口秒数（默认15秒，仅在 useTimestampMode=true 时生效） */
+    timestampWindowSeconds?: number;
 }
 /**
  * Bundle 发送结果

package/dist/clients/merkle.js

@@ -133,7 +133,7 @@ export class MerkleClient {
         if (!options.transactions || options.transactions.length === 0) {
             throw new Error('Transactions array cannot be empty');
         }
-        const minBlockOffset = options.minBlockOffset ?? 3; // 默认至少3个区块的窗口
+        const minBlockOffset = options.minBlockOffset ?? 3;
         const autoRetry = options.autoRetry ?? false;
         const maxRetries = options.maxRetries ?? 2;
         let attempt = 0;
@@ -146,47 +146,47 @@ export class MerkleClient {
                 let targetBlock;
                 if (options.targetBlock) {
                     targetBlock = options.targetBlock;
-                    // 检查目标区块是否已经过期
                     if (targetBlock <= currentBlock) {
                         if (autoRetry && attempt < maxRetries) {
                             attempt++;
-                            await new Promise(resolve => setTimeout(resolve, 300)); // 短暂延迟
+                            await new Promise(resolve => setTimeout(resolve, 300));
                             continue;
                         }
                         throw new Error(`Target block ${targetBlock} has already passed (current block: ${currentBlock})`);
                     }
                 }
                 else {
-                    // 动态计算：确保至少有 minBlockOffset 个区块的窗口
                     const requestedOffset = options.blockOffset ?? 3;
                     const actualOffset = Math.max(requestedOffset, minBlockOffset);
                     targetBlock = currentBlock + actualOffset;
                 }
-                // 转换为十六进制
                 const targetBlockHex = '0x' + targetBlock.toString(16);
+                // ✅ 优化：时间戳模式 - Merkle 会在时间范围内尽快打包
+                let minTimestamp = options.minTimestamp;
+                let maxTimestamp = options.maxTimestamp;
+                if (options.useTimestampMode && !minTimestamp && !maxTimestamp) {
+                    const now = Math.floor(Date.now() / 1000);
+                    const windowSeconds = options.timestampWindowSeconds ?? 15;
+                    minTimestamp = now;
+                    maxTimestamp = now + windowSeconds;
+                }
                 // 发送 Bundle
                 const bundleHash = await this.sendBundleRaw({
                     txs: options.transactions,
                     blockNumber: targetBlockHex,
-                    minTimestamp: options.minTimestamp,
-                    maxTimestamp: options.maxTimestamp,
+                    minTimestamp,
+                    maxTimestamp,
                 });
-                // 提取交易哈希（添加异常处理）
-                const txHashes = [];
-                for (let i = 0; i < options.transactions.length; i++) {
+                // ✅ 优化：并行提取交易哈希
+                const txHashes = options.transactions.map(rawTx => {
                     try {
-                        const tx = Transaction.from(options.transactions[i]);
-                        if (tx.hash) {
-                            txHashes.push(tx.hash);
-                        }
-                        else {
-                            txHashes.push('');
-                        }
+                        const tx = Transaction.from(rawTx);
+                        return tx.hash || '';
                     }
-                    catch (error) {
-                        txHashes.push('');
+                    catch {
+                        return '';
                     }
-                }
+                });
                 return {
                     bundleHash,
                     txHashes,
@@ -196,19 +196,15 @@ export class MerkleClient {
             }
             catch (error) {
                 lastError = error;
-                // 如果启用了重试且还有重试次数
                 if (autoRetry && attempt < maxRetries) {
                     attempt++;
-                    // 等待一个区块时间再重试
                     const blockTime = this.chainId === 56 ? 3000 : 12000;
                     await new Promise(resolve => setTimeout(resolve, blockTime));
                     continue;
                 }
-                // 没有重试或已达最大重试次数
                 throw error;
             }
         }
-        // 如果执行到这里，说明所有重试都失败了
         throw lastError || new Error('Bundle submission failed after all retries');
     }
     /**

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

@@ -254,71 +254,52 @@ async function resolveTokenImage(fourClient, tokenInfo, accessToken) {
     }
     throw new Error(getErrorMessage('IMAGE_REQUIRED'));
 }
-function resolveTokenAddress(createResp) {
-    return (createResp?.tokenAddr ||
-        createResp?.address ||
-        createResp?.token ||
-        ZERO_ADDRESS);
-}
 async function executeBuyFlow(options) {
     const { wallets, buyAmounts, tokenAddress, config, nonceManager, contractAddress, gasPrice, chainId, profitMode, txType } = options;
     const extractProfit = shouldExtractProfit(config);
     const analysis = analyzeBuyFunds(buyAmounts, config, extractProfit);
-    const unsignedBuys = await populateBuyTransactions({
-        buyers: wallets,
-        contractAddress,
-        tokenAddress,
-        fundsList: analysis.fundsList
-    });
     const finalGasLimit = getGasLimit(config);
-    const signedBuys = await signBuyTransactions({
-        unsignedTxs: unsignedBuys,
-        wallets,
-        nonceManager,
+    // ✅ 优化：并行执行 populateBuyTransactions 和获取 nonces
+    const [unsignedBuys, nonces] = await Promise.all([
+        populateBuyTransactions({
+            buyers: wallets,
+            contractAddress,
+            tokenAddress,
+            fundsList: analysis.fundsList
+        }),
+        Promise.all(wallets.map((wallet) => nonceManager.getNextNonce(wallet)))
+    ]);
+    // ✅ 如果需要利润转账，预先获取 payer 的下一个 nonce
+    let profitNonce;
+    if (extractProfit && analysis.totalProfit > 0n && profitMode.type === 'aggregated') {
+        const payer = profitMode.payer ?? wallets[0];
+        profitNonce = await nonceManager.getNextNonce(payer);
+    }
+    // ✅ 并行签名所有买入交易
+    const signedBuys = await Promise.all(unsignedBuys.map((unsigned, index) => wallets[index].signTransaction({
+        ...unsigned,
+        from: wallets[index].address,
+        nonce: nonces[index],
         gasLimit: finalGasLimit,
         gasPrice,
         chainId,
-        txType,
-        valueList: analysis.fundsList
-    });
+        type: txType,
+        value: analysis.fundsList[index]
+    })));
     const signedTxs = [...signedBuys];
-    // ✅ 添加利润转账交易
-    if (extractProfit) {
-        if (profitMode.type === 'individual') {
-            // 每个买家单独支付利润
-            for (let i = 0; i < analysis.profitList.length; i++) {
-                if (analysis.profitList[i] > 0n) {
-                    const profitNonce = await nonceManager.getNextNonce(wallets[i]);
-                    const profitTx = await wallets[i].signTransaction({
-                        to: getProfitRecipient(),
-                        value: analysis.profitList[i],
-                        nonce: profitNonce,
-                        gasPrice,
-                        gasLimit: 21000n,
-                        chainId,
-                        type: txType
-                    });
-                    signedTxs.push(profitTx);
-                }
-            }
-        }
-        else {
-            // 聚合模式：由指定的 payer 支付总利润
-            if (analysis.totalProfit > 0n) {
-                const payer = profitMode.payer ?? wallets[0];
-                const profitNonce = await nonceManager.getNextNonce(payer);
-                const profitTx = await payer.signTransaction({
-                    to: getProfitRecipient(),
-                    value: analysis.totalProfit,
-                    nonce: profitNonce,
-                    gasPrice,
-                    gasLimit: 21000n,
-                    chainId,
-                    type: txType
-                });
-                signedTxs.push(profitTx);
-            }
-        }
+    // ✅ 添加利润转账交易（使用预先获取的 nonce）
+    if (extractProfit && profitNonce !== undefined && profitMode.type === 'aggregated') {
+        const payer = profitMode.payer ?? wallets[0];
+        const profitTx = await payer.signTransaction({
+            to: getProfitRecipient(),
+            value: analysis.totalProfit,
+            nonce: profitNonce,
+            gasPrice,
+            gasLimit: 21000n,
+            chainId,
+            type: txType
+        });
+        signedTxs.push(profitTx);
     }
     const metadata = buildBuyMetadata(extractProfit, analysis.totalBuyAmount, analysis.totalProfit, wallets.length);
     return { signedTxs, metadata };
@@ -326,21 +307,28 @@ async function executeBuyFlow(options) {
 async function executeSellFlow(options) {
     const { wallets, sellAmounts, tokenAddress, minOutputAmounts, config, provider, nonceManager, contractAddress, gasPrice, chainId, rpcUrl, txType } = options;
     const amountsWei = sellAmounts.map((amount) => ethers.parseUnits(amount, 18));
-    const sellOutputs = await resolveSellOutputs({
-        minOutputAmounts,
-        sellers: wallets,
-        amountsWei,
-        rpcUrl,
-        tokenAddress
-    });
-    await ensureSellerBalances({ provider, tokenAddress, sellers: wallets, amountsWei });
-    await ensureSellAllowances({
-        provider,
-        tokenAddress,
-        sellers: wallets,
-        amountsWei,
-        spender: contractAddress
-    });
+    const finalGasLimit = getGasLimit(config);
+    const extractProfit = shouldExtractProfit(config);
+    // ✅ 优化：并行执行 resolveSellOutputs、ensureSellerBalances、ensureSellAllowances 和获取 nonces
+    const [sellOutputs, , , nonces] = await Promise.all([
+        resolveSellOutputs({
+            minOutputAmounts,
+            sellers: wallets,
+            amountsWei,
+            rpcUrl,
+            tokenAddress
+        }),
+        ensureSellerBalances({ provider, tokenAddress, sellers: wallets, amountsWei }),
+        ensureSellAllowances({
+            provider,
+            tokenAddress,
+            sellers: wallets,
+            amountsWei,
+            spender: contractAddress
+        }),
+        Promise.all(wallets.map((wallet) => nonceManager.getNextNonce(wallet)))
+    ]);
+    // ✅ 构建未签名交易
     const unsignedSells = await populateSellTransactions({
         sellers: wallets,
         contractAddress,
@@ -348,18 +336,17 @@ async function executeSellFlow(options) {
         amountsWei,
         minOuts: sellOutputs.minOuts
     });
-    const finalGasLimit = getGasLimit(config);
-    const signedSells = await signSellTransactions({
-        unsignedTxs: unsignedSells,
-        wallets,
-        nonceManager,
+    // ✅ 并行签名所有卖出交易
+    const signedSells = await Promise.all(unsignedSells.map((unsigned, index) => wallets[index].signTransaction({
+        ...unsigned,
+        from: wallets[index].address,
+        nonce: nonces[index],
         gasLimit: finalGasLimit,
         gasPrice,
         chainId,
-        txType
-    });
+        type: txType
+    })));
     const signedTxs = [...signedSells];
-    const extractProfit = shouldExtractProfit(config);
     const { totalProfit, payer } = summarizeSellProfits(sellOutputs.quotedOutputs, wallets, config);
     await appendAggregatedProfitTransfer({
         extractProfit,
@@ -399,42 +386,6 @@ async function populateBuyTransactions(params) {
     const contracts = buyers.map((wallet) => new ethers.Contract(contractAddress, TM2_ABI, wallet));
     return Promise.all(contracts.map((contract, index) => contract.buyTokenAMAP.populateTransaction(0n, tokenAddress, buyers[index].address, fundsList[index], 0n, { value: fundsList[index] })));
 }
-async function signBuyTransactions(params) {
-    const { unsignedTxs, wallets, nonceManager, gasLimit, gasPrice, chainId, txType, valueList } = params;
-    const nonces = await Promise.all(wallets.map((wallet) => nonceManager.getNextNonce(wallet)));
-    return Promise.all(unsignedTxs.map((unsigned, index) => wallets[index].signTransaction({
-        ...unsigned,
-        from: wallets[index].address,
-        nonce: nonces[index],
-        gasLimit,
-        gasPrice,
-        chainId,
-        type: txType,
-        value: valueList[index]
-    })));
-}
-async function appendIndividualProfitTransfers(params) {
-    const { extractProfit, profitList, wallets, nonceManager, gasPrice, chainId, txType, signedTxs } = params;
-    if (!extractProfit || profitList.length === 0) {
-        return;
-    }
-    for (let i = 0; i < profitList.length; i++) {
-        if (profitList[i] <= 0n) {
-            continue;
-        }
-        const profitNonce = await nonceManager.getNextNonce(wallets[i]);
-        const profitTx = await wallets[i].signTransaction({
-            to: getProfitRecipient(),
-            value: profitList[i],
-            nonce: profitNonce,
-            gasPrice,
-            gasLimit: 21000n,
-            chainId,
-            type: txType
-        });
-        signedTxs.push(profitTx);
-    }
-}
 function buildBuyMetadata(extractProfit, totalBuyAmount, totalProfit, buyerCount) {
     if (!extractProfit || totalBuyAmount <= 0n || totalProfit <= 0n) {
         return undefined;
@@ -493,19 +444,6 @@ async function populateSellTransactions(params) {
     const contracts = sellers.map((wallet) => new ethers.Contract(contractAddress, TM2_ABI, wallet));
     return Promise.all(contracts.map((contract, index) => contract.sellToken.populateTransaction(0n, tokenAddress, amountsWei[index], minOuts[index])));
 }
-async function signSellTransactions(params) {
-    const { unsignedTxs, wallets, nonceManager, gasLimit, gasPrice, chainId, txType } = params;
-    const nonces = await Promise.all(wallets.map((wallet) => nonceManager.getNextNonce(wallet)));
-    return Promise.all(unsignedTxs.map((unsigned, index) => wallets[index].signTransaction({
-        ...unsigned,
-        from: wallets[index].address,
-        nonce: nonces[index],
-        gasLimit,
-        gasPrice,
-        chainId,
-        type: txType
-    })));
-}
 function summarizeSellProfits(quotedOutputs, sellers, config) {
     let totalProfit = 0n;
     let maxRevenue = 0n;

package/dist/contracts/tm-bundle-merkle/pancake-proxy.js

@@ -1,7 +1,7 @@
 import { ethers, Wallet, JsonRpcProvider, Contract } from 'ethers';
 import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.js';
 import { ADDRESSES } from '../../utils/constants.js';
-import { getTxType, getBundleOptions, getGasPriceConfig, shouldExtractProfit, calculateProfit, calculateBatchProfit, getProfitRecipient } from './config.js';
+import { getTxType, getGasPriceConfig, shouldExtractProfit, calculateProfit, calculateBatchProfit, getProfitRecipient } from './config.js';
 import { batchCheckAllowances } from '../../utils/erc20.js';
 // 常量
 const WBNB_ADDRESS = '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c';
@@ -113,66 +113,6 @@ async function buildV3MultiHopTransactions(proxies, wallets, lpAddresses, exactT
         return proxy.swapV3MultiHop.populateTransaction(lpAddresses, exactTokenIn, amountsWei[i], minOuts[i], wallets[i].address, { value: txValue });
     }));
 }
-/**
- * 签名并提交 Bundle
- */
-async function signAndSendBundle(merkle, wallets, unsignedTxs, gasPrice, gasLimit, chainId, config, blockOffset) {
-    const nonceManager = new NonceManager(merkle.getProvider());
-    const txType = getTxType(config);
-    try {
-        const nonces = await Promise.all(wallets.map(w => nonceManager.getNextNonce(w)));
-        const signedTxs = await Promise.all(unsignedTxs.map((unsigned, i) => wallets[i].signTransaction({
-            ...unsigned,
-            from: wallets[i].address,
-            nonce: nonces[i],
-            gasLimit,
-            gasPrice,
-            chainId,
-            type: txType,
-            value: unsigned.value // ✅ 显式保留 value（BNB 金额 + 手续费）
-        })));
-        const bundleResult = await merkle.sendBundle({
-            transactions: signedTxs,
-            ...getBundleOptions(config, blockOffset)
-        });
-        return bundleResult;
-    }
-    finally {
-        // 确保清理临时 nonce 缓存
-        nonceManager.clearTemp();
-    }
-}
-/**
- * 等待 Bundle 确认并返回状态
- */
-async function waitForBundleResult(merkle, bundleResult, waitForConfirmation, waitTimeoutMs) {
-    if (!waitForConfirmation) {
-        return {
-            bundleHash: bundleResult.bundleHash,
-            txHashes: bundleResult.txHashes,
-            results: [],
-            successCount: 0,
-            totalGasUsed: 0n,
-            targetBlock: bundleResult.targetBlock
-        };
-    }
-    const results = await merkle.waitForBundleConfirmation(bundleResult.txHashes, 1, waitTimeoutMs);
-    const successCount = results.filter(r => r.success).length;
-    const totalGasUsed = results.reduce((sum, r) => {
-        if (r.gasUsed) {
-            return sum + BigInt(r.gasUsed);
-        }
-        return sum;
-    }, 0n);
-    return {
-        bundleHash: bundleResult.bundleHash,
-        txHashes: bundleResult.txHashes,
-        results,
-        successCount,
-        totalGasUsed,
-        targetBlock: bundleResult.targetBlock
-    };
-}
 // ==================== 主要导出函数 ====================
 /**
  * 授权代币给 PancakeSwapProxy
@@ -303,11 +243,19 @@ export async function fourPancakeProxyBatchBuyMerkle(params) {
     const extractProfit = shouldExtractProfit(config);
     const { totalProfit, remainingAmounts } = calculateBatchProfit(originalAmountsWei, config);
     const actualAmountsWei = remainingAmounts; // 扣除利润后用于购买的金额
-    // ✅ 优化:并行获取 gasPrice 和 tokenDecimals
-    const [gasPrice, tokenDecimals] = await Promise.all([
+    const finalGasLimit = getGasLimit(config);
+    const nonceManager = new NonceManager(provider);
+    // ✅ 优化：并行获取 gasPrice、tokenDecimals 和 nonces
+    const [gasPrice, tokenDecimals, nonces] = await Promise.all([
         getOptimizedGasPrice(provider, getGasPriceConfig(config)),
-        getTokenDecimals(tokenAddress, provider)
+        getTokenDecimals(tokenAddress, provider),
+        Promise.all(buyers.map(w => nonceManager.getNextNonce(w)))
     ]);
+    // ✅ 如果需要利润转账，预先获取 nonce
+    let profitNonce;
+    if (extractProfit && totalProfit > 0n) {
+        profitNonce = await nonceManager.getNextNonce(buyers[0]);
+    }
     // 计算 minOutputAmounts
     let minOuts;
     if (params.minOutputAmounts && params.minOutputAmounts.length === buyers.length) {
@@ -342,11 +290,7 @@ export async function fourPancakeProxyBatchBuyMerkle(params) {
     else {
         throw new Error(`Unsupported routeType: ${routeType}`);
     }
-    // ✅ 使用前端传入的 gasLimit，否则使用默认值
-    const finalGasLimit = getGasLimit(config);
-    // ✅ 优化:并行获取 nonces（直接签名和提交以支持利润转账）
-    const nonceManager = new NonceManager(provider);
-    const nonces = await Promise.all(buyers.map(w => nonceManager.getNextNonce(w)));
+    // ✅ 并行签名所有买入交易
     const signedTxs = await Promise.all(unsignedBuys.map((unsigned, i) => buyers[i].signTransaction({
         ...unsigned,
         from: buyers[i].address,
@@ -357,9 +301,8 @@ export async function fourPancakeProxyBatchBuyMerkle(params) {
         type: txType,
         value: unsigned.value // ✅ 显式保留 value（BNB 金额 + 手续费）
     })));
-    // ✅ 添加利润转账（从第一个钱包转出总利润）
-    if (extractProfit && totalProfit > 0n) {
-        const profitNonce = await nonceManager.getNextNonce(buyers[0]);
+    // ✅ 添加利润转账（使用预先获取的 nonce）
+    if (extractProfit && totalProfit > 0n && profitNonce !== undefined) {
         const profitTx = await buyers[0].signTransaction({
             to: getProfitRecipient(),
             value: totalProfit,
@@ -397,14 +340,17 @@ export async function fourPancakeProxyBatchSellMerkle(params) {
     });
     const txType = getTxType(config);
     const sellers = privateKeys.map(k => new Wallet(k, provider));
-    // ✅ 优化:并行获取 gasPrice 和 tokenDecimals
-    const [gasPrice, tokenDecimals] = await Promise.all([
+    const finalGasLimit = getGasLimit(config);
+    const nonceManager = new NonceManager(provider);
+    const extractProfit = shouldExtractProfit(config);
+    // ✅ 优化：并行获取 gasPrice、tokenDecimals、allowances 和 nonces
+    const [gasPrice, tokenDecimals, allowances, nonces] = await Promise.all([
         getOptimizedGasPrice(provider, getGasPriceConfig(config)),
-        getTokenDecimals(tokenAddress, provider)
+        getTokenDecimals(tokenAddress, provider),
+        batchCheckAllowances(provider, tokenAddress, sellers.map(w => w.address), pancakeProxyAddress),
+        Promise.all(sellers.map(w => nonceManager.getNextNonce(w)))
     ]);
     const amountsWei = sellAmounts.map(a => ethers.parseUnits(a, tokenDecimals));
-    // ✅ Step 1: 使用 Multicall3 批量检查授权状态
-    const allowances = await batchCheckAllowances(provider, tokenAddress, sellers.map(w => w.address), pancakeProxyAddress);
     // 找出需要授权的钱包索引
     const needApprovalIndexes = [];
     const APPROVAL_THRESHOLD = ethers.MaxUint256 / 2n;
@@ -463,6 +409,27 @@ export async function fourPancakeProxyBatchSellMerkle(params) {
         // minOuts 设为预期收益的 95%（滑点保护）
         minOuts = quotedOutputs.map(q => q * 95n / 100n);
     }
+    // ✅ 计算利润并找出收益最多的钱包（提前计算，预先获取 nonce）
+    let totalProfit = 0n;
+    let maxRevenueIndex = 0;
+    let maxRevenue = 0n;
+    if (extractProfit && quotedOutputs.length > 0) {
+        for (let i = 0; i < sellers.length; i++) {
+            if (quotedOutputs[i] > 0n) {
+                const { profit } = calculateProfit(quotedOutputs[i], config);
+                totalProfit += profit;
+                if (quotedOutputs[i] > maxRevenue) {
+                    maxRevenue = quotedOutputs[i];
+                    maxRevenueIndex = i;
+                }
+            }
+        }
+    }
+    // ✅ 如果需要利润转账，预先获取 nonce
+    let profitNonce;
+    if (extractProfit && totalProfit > 0n && maxRevenue > 0n) {
+        profitNonce = await nonceManager.getNextNonce(sellers[maxRevenueIndex]);
+    }
     // 卖出不需要发送 BNB，只需要 flatFee
     const needBNB = false;
     // 构建交易
@@ -489,18 +456,7 @@ export async function fourPancakeProxyBatchSellMerkle(params) {
     else {
         throw new Error(`Unsupported routeType: ${routeType}`);
     }
-    // ✅ Step 4: 验证钱包余额（确保有足够 BNB 支付手续费）
-    const balances = await Promise.all(sellers.map(w => provider.getBalance(w.address)));
-    const minRequiredBNB = ethers.parseEther('0.001'); // 至少需要 0.001 BNB（包括 gas 和手续费）
-    const insufficientBalances = balances.filter(b => b < minRequiredBNB);
-    if (insufficientBalances.length > 0) {
-        throw new Error(`${insufficientBalances.length} 个钱包 BNB 余额不足 0.001 BNB`);
-    }
-    // ✅ 使用前端传入的 gasLimit，否则使用默认值
-    const finalGasLimit = getGasLimit(config);
-    // ✅ 直接签名和提交（内联处理以支持利润转账）
-    const nonceManager = new NonceManager(provider);
-    const nonces = await Promise.all(sellers.map(w => nonceManager.getNextNonce(w)));
+    // ✅ 并行签名所有卖出交易
     const signedTxs = await Promise.all(unsignedSells.map((unsigned, i) => sellers[i].signTransaction({
         ...unsigned,
         from: sellers[i].address,
@@ -511,38 +467,18 @@ export async function fourPancakeProxyBatchSellMerkle(params) {
         type: txType,
         value: unsigned.value // ✅ 显式保留 value（手续费）
     })));
-    // ✅ 汇总所有利润，由收益最多的钱包一次性转出（节省交易数）
-    const extractProfit = shouldExtractProfit(config);
-    if (extractProfit && quotedOutputs.length > 0) {
-        let totalProfit = 0n;
-        let maxRevenueIndex = 0;
-        let maxRevenue = 0n;
-        // 计算总利润并找出收益最多的钱包
-        for (let i = 0; i < sellers.length; i++) {
-            if (quotedOutputs[i] > 0n) {
-                const { profit } = calculateProfit(quotedOutputs[i], config);
-                totalProfit += profit;
-                // 记录收益最多的钱包索引
-                if (quotedOutputs[i] > maxRevenue) {
-                    maxRevenue = quotedOutputs[i];
-                    maxRevenueIndex = i;
-                }
-            }
-        }
-        // ✅ 由收益最多的钱包一次性转出总利润（该钱包最有能力支付）
-        if (totalProfit > 0n && maxRevenue > 0n) {
-            const profitNonce = await nonceManager.getNextNonce(sellers[maxRevenueIndex]);
-            const profitTx = await sellers[maxRevenueIndex].signTransaction({
-                to: getProfitRecipient(),
-                value: totalProfit,
-                nonce: profitNonce,
-                gasPrice,
-                gasLimit: 21000n,
-                chainId: 56,
-                type: txType
-            });
-            signedTxs.push(profitTx);
-        }
+    // ✅ 添加利润转账（使用预先获取的 nonce）
+    if (extractProfit && totalProfit > 0n && profitNonce !== undefined) {
+        const profitTx = await sellers[maxRevenueIndex].signTransaction({
+            to: getProfitRecipient(),
+            value: totalProfit,
+            nonce: profitNonce,
+            gasPrice,
+            gasLimit: 21000n,
+            chainId: 56,
+            type: txType
+        });
+        signedTxs.push(profitTx);
     }
     // ✅ 清理临时 nonce 缓存
     nonceManager.clearTemp();

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

@@ -22,6 +22,10 @@ export interface MerkleSubmitConfig {
     autoRetryBundle?: boolean;
     /** 最大重试次数（可选，默认2） */
     maxBundleRetries?: number;
+    /** ✅ 新增：使用时间戳模式（Merkle 会在时间范围内尽快打包） */
+    useTimestampMode?: boolean;
+    /** ✅ 新增：时间戳窗口秒数（默认15秒，仅在 useTimestampMode=true 时生效） */
+    timestampWindowSeconds?: number;
 }
 /**
  * Bundle提交结果

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

@@ -6,6 +6,21 @@
  */
 import { MerkleClient } from '../../clients/merkle.js';
 import { ethers } from 'ethers';
+// ✅ 优化：MerkleClient 缓存，避免重复创建
+const merkleClientCache = new Map();
+function getMerkleClient(config) {
+    const cacheKey = `${config.apiKey}-${config.chainId ?? 56}-${config.customRpcUrl ?? ''}`;
+    let client = merkleClientCache.get(cacheKey);
+    if (!client) {
+        client = new MerkleClient({
+            apiKey: config.apiKey,
+            chainId: config.chainId ?? 56,
+            customRpcUrl: config.customRpcUrl
+        });
+        merkleClientCache.set(cacheKey, client);
+    }
+    return client;
+}
 /**
  * 提交已签名的交易到Merkle（服务器端使用）
  *
@@ -52,19 +67,18 @@ export async function submitBundleToMerkle(signedTransactions, config) {
                 error: 'apiKey is required in config'
             };
         }
-        // 初始化Merkle客户端
-        const merkle = new MerkleClient({
-            apiKey: config.apiKey,
-            chainId: config.chainId ?? 56,
-            customRpcUrl: config.customRpcUrl
-        });
+        // ✅ 优化：使用缓存的 MerkleClient（避免重复创建 JsonRpcProvider）
+        const merkle = getMerkleClient(config);
         // 提交Bundle
         const bundleResult = await merkle.sendBundle({
             transactions: signedTransactions,
             blockOffset: config.bundleBlockOffset ?? 3,
             minBlockOffset: config.minBlockOffset ?? 3,
             autoRetry: config.autoRetryBundle ?? false,
-            maxRetries: config.maxBundleRetries ?? 2
+            maxRetries: config.maxBundleRetries ?? 2,
+            // ✅ 新增：时间戳模式
+            useTimestampMode: config.useTimestampMode,
+            timestampWindowSeconds: config.timestampWindowSeconds
         });
         // ✅ 提交成功
         return {