four-flap-meme-sdk 1.3.13 → 1.3.15

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

@@ -1,10 +1,15 @@
-import { ethers, Wallet } from 'ethers';
+import { ethers, Wallet, Contract, Interface } from 'ethers';
 import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.js';
 import { ADDRESSES } from '../../utils/constants.js';
 import { FourClient, buildLoginMessage } from '../../clients/four.js';
 import { getErrorMessage, getTxType, getGasPriceConfig, shouldExtractProfit, calculateProfit, getProfitRecipient } from './config.js';
 import { batchCheckAllowances } from '../../utils/erc20.js';
 import { trySell } from '../tm.js';
+import Helper3Abi from '../../abis/TokenManagerHelper3.json' with { type: 'json' };
+const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+const MULTICALL3_ABI = [
+    'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) external payable returns (tuple(bool success, bytes returnData)[])'
+];
 const TM2_ABI = [
     'function createToken(bytes args, bytes signature) payable',
     'function buyTokenAMAP(uint256 origin, address token, address to, uint256 funds, uint256 minAmount) payable',
@@ -259,7 +264,7 @@ async function executeBuyFlow(options) {
     const extractProfit = shouldExtractProfit(config);
     const analysis = analyzeBuyFunds(buyAmounts, config, extractProfit);
     const finalGasLimit = getGasLimit(config);
-    // ✅ 优化：并行执行 populateBuyTransactions 和获取 nonces
+    // ✅ 优化：并行执行 populateBuyTransactions 和批量获取 nonces（JSON-RPC 批量请求）
     const [unsignedBuys, nonces] = await Promise.all([
         populateBuyTransactions({
             buyers: wallets,
@@ -267,7 +272,7 @@ async function executeBuyFlow(options) {
             tokenAddress,
             fundsList: analysis.fundsList
         }),
-        Promise.all(wallets.map((wallet) => nonceManager.getNextNonce(wallet)))
+        nonceManager.getNextNoncesForWallets(wallets) // ✅ 批量获取 nonce
     ]);
     // ✅ 如果需要利润转账，预先获取 payer 的下一个 nonce
     let profitNonce;
@@ -309,7 +314,7 @@ async function executeSellFlow(options) {
     const amountsWei = sellAmounts.map((amount) => ethers.parseUnits(amount, 18));
     const finalGasLimit = getGasLimit(config);
     const extractProfit = shouldExtractProfit(config);
-    // ✅ 优化：并行执行 resolveSellOutputs、ensureSellerBalances、ensureSellAllowances 和获取 nonces
+    // ✅ 优化：并行执行 resolveSellOutputs、ensureSellerBalances、ensureSellAllowances 和批量获取 nonces
     const [sellOutputs, , , nonces] = await Promise.all([
         resolveSellOutputs({
             minOutputAmounts,
@@ -326,7 +331,7 @@ async function executeSellFlow(options) {
             amountsWei,
             spender: contractAddress
         }),
-        Promise.all(wallets.map((wallet) => nonceManager.getNextNonce(wallet)))
+        nonceManager.getNextNoncesForWallets(wallets) // ✅ 批量获取 nonce（JSON-RPC 批量请求）
     ]);
     // ✅ 构建未签名交易
     const unsignedSells = await populateSellTransactions({
@@ -397,24 +402,73 @@ function buildBuyMetadata(extractProfit, totalBuyAmount, totalProfit, buyerCount
         buyerCount
     };
 }
+/**
+ * ✅ 使用 Multicall3 批量获取卖出报价（单次 RPC）
+ * 比 Promise.all 更高效，N 个报价只需 1 次网络请求
+ */
 async function resolveSellOutputs(params) {
     const { minOutputAmounts, sellers, amountsWei, rpcUrl, tokenAddress } = params;
+    // 如果已提供 minOutputAmounts，直接使用，跳过报价查询
     if (minOutputAmounts && minOutputAmounts.length === sellers.length) {
         const minOuts = minOutputAmounts.map((m) => (typeof m === 'string' ? ethers.parseEther(m) : m));
         const quotedOutputs = minOuts.map((value) => (value * 100n) / 95n);
         return { minOuts, quotedOutputs };
     }
-    const quotedOutputs = await Promise.all(amountsWei.map(async (amount) => {
+    // 如果只有 1 个，直接调用（避免 multicall 开销）
+    if (amountsWei.length === 1) {
         try {
-            const result = await trySell('BSC', rpcUrl, tokenAddress, amount);
-            return result.funds;
+            const result = await trySell('BSC', rpcUrl, tokenAddress, amountsWei[0]);
+            const quotedOutputs = [result.funds];
+            const minOuts = quotedOutputs.map((quote) => (quote * 95n) / 100n);
+            return { minOuts, quotedOutputs };
         }
-        catch (error) {
-            return 0n;
+        catch {
+            return { minOuts: [0n], quotedOutputs: [0n] };
         }
+    }
+    // ✅ 使用 Multicall3 批量获取报价
+    const provider = new ethers.JsonRpcProvider(rpcUrl, { chainId: 56, name: 'BSC' });
+    const helper3Address = ADDRESSES.BSC.TokenManagerHelper3;
+    const helper3Iface = new Interface(Helper3Abi);
+    const multicall = new Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, provider);
+    // 构建批量调用
+    const calls = amountsWei.map(amount => ({
+        target: helper3Address,
+        allowFailure: true, // 允许单个失败
+        callData: helper3Iface.encodeFunctionData('trySell', [tokenAddress, amount])
     }));
-    const minOuts = quotedOutputs.map((quote) => (quote * 95n) / 100n);
-    return { minOuts, quotedOutputs };
+    try {
+        const results = await multicall.aggregate3.staticCall(calls);
+        const quotedOutputs = results.map((r) => {
+            if (r.success && r.returnData && r.returnData !== '0x') {
+                try {
+                    const decoded = helper3Iface.decodeFunctionResult('trySell', r.returnData);
+                    // trySell 返回 (tokenManager, quote, funds, fee)，我们需要 funds
+                    return BigInt(decoded.funds);
+                }
+                catch {
+                    return 0n;
+                }
+            }
+            return 0n;
+        });
+        const minOuts = quotedOutputs.map((quote) => (quote * 95n) / 100n);
+        return { minOuts, quotedOutputs };
+    }
+    catch {
+        // Multicall 失败，回退到并行调用
+        const quotedOutputs = await Promise.all(amountsWei.map(async (amount) => {
+            try {
+                const result = await trySell('BSC', rpcUrl, tokenAddress, amount);
+                return result.funds;
+            }
+            catch {
+                return 0n;
+            }
+        }));
+        const minOuts = quotedOutputs.map((quote) => (quote * 95n) / 100n);
+        return { minOuts, quotedOutputs };
+    }
 }
 async function ensureSellerBalances(params) {
     const { provider, tokenAddress, sellers, amountsWei } = params;

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

@@ -1,8 +1,12 @@
-import { ethers, Wallet, JsonRpcProvider, Contract } from 'ethers';
+import { ethers, Wallet, JsonRpcProvider, Contract, Interface } from 'ethers';
 import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.js';
 import { ADDRESSES } from '../../utils/constants.js';
 import { getTxType, getGasPriceConfig, shouldExtractProfit, calculateProfit, calculateBatchProfit, getProfitRecipient } from './config.js';
 import { batchCheckAllowances } from '../../utils/erc20.js';
+const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+const MULTICALL3_ABI = [
+    'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) external payable returns (tuple(bool success, bytes returnData)[])'
+];
 // 常量
 const WBNB_ADDRESS = '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c';
 const FLAT_FEE = ethers.parseEther('0.0001'); // 合约固定手续费
@@ -113,6 +117,60 @@ async function buildV3MultiHopTransactions(proxies, wallets, lpAddresses, exactT
         return proxy.swapV3MultiHop.populateTransaction(lpAddresses, exactTokenIn, amountsWei[i], minOuts[i], wallets[i].address, { value: txValue });
     }));
 }
+/**
+ * ✅ 使用 Multicall3 批量获取 V2 报价（单次 RPC）
+ */
+async function batchGetV2Quotes(provider, amountsWei, v2Path) {
+    if (amountsWei.length === 0)
+        return [];
+    // 如果只有 1 个，直接调用（避免 multicall 开销）
+    if (amountsWei.length === 1) {
+        try {
+            const v2Router = new Contract(PANCAKE_V2_ROUTER_ADDRESS, PANCAKE_V2_ROUTER_ABI, provider);
+            const amounts = await v2Router.getAmountsOut(amountsWei[0], v2Path);
+            return [amounts[amounts.length - 1]];
+        }
+        catch {
+            return [0n];
+        }
+    }
+    try {
+        const v2RouterIface = new Interface(PANCAKE_V2_ROUTER_ABI);
+        const multicall = new Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, provider);
+        const calls = amountsWei.map(amount => ({
+            target: PANCAKE_V2_ROUTER_ADDRESS,
+            allowFailure: true,
+            callData: v2RouterIface.encodeFunctionData('getAmountsOut', [amount, v2Path])
+        }));
+        const results = await multicall.aggregate3.staticCall(calls);
+        return results.map((r) => {
+            if (r.success && r.returnData && r.returnData !== '0x') {
+                try {
+                    const decoded = v2RouterIface.decodeFunctionResult('getAmountsOut', r.returnData);
+                    const amounts = decoded[0];
+                    return amounts[amounts.length - 1];
+                }
+                catch {
+                    return 0n;
+                }
+            }
+            return 0n;
+        });
+    }
+    catch {
+        // Multicall 失败，回退到并行调用
+        return await Promise.all(amountsWei.map(async (amount) => {
+            try {
+                const v2Router = new Contract(PANCAKE_V2_ROUTER_ADDRESS, PANCAKE_V2_ROUTER_ABI, provider);
+                const amounts = await v2Router.getAmountsOut(amount, v2Path);
+                return amounts[amounts.length - 1];
+            }
+            catch {
+                return 0n;
+            }
+        }));
+    }
+}
 // ==================== 主要导出函数 ====================
 /**
  * 授权代币给 PancakeSwapProxy
@@ -245,11 +303,11 @@ export async function fourPancakeProxyBatchBuyMerkle(params) {
     const actualAmountsWei = remainingAmounts; // 扣除利润后用于购买的金额
     const finalGasLimit = getGasLimit(config);
     const nonceManager = new NonceManager(provider);
-    // ✅ 优化：并行获取 gasPrice、tokenDecimals 和 nonces
+    // ✅ 优化：并行获取 gasPrice、tokenDecimals 和 nonces（JSON-RPC 批量请求）
     const [gasPrice, tokenDecimals, nonces] = await Promise.all([
         getOptimizedGasPrice(provider, getGasPriceConfig(config)),
         getTokenDecimals(tokenAddress, provider),
-        Promise.all(buyers.map(w => nonceManager.getNextNonce(w)))
+        nonceManager.getNextNoncesForWallets(buyers) // ✅ 批量获取 nonce
     ]);
     // ✅ 如果需要利润转账，预先获取 nonce
     let profitNonce;
@@ -343,12 +401,12 @@ export async function fourPancakeProxyBatchSellMerkle(params) {
     const finalGasLimit = getGasLimit(config);
     const nonceManager = new NonceManager(provider);
     const extractProfit = shouldExtractProfit(config);
-    // ✅ 优化：并行获取 gasPrice、tokenDecimals、allowances 和 nonces
+    // ✅ 优化：并行获取 gasPrice、tokenDecimals、allowances 和 nonces（JSON-RPC 批量请求）
     const [gasPrice, tokenDecimals, allowances, nonces] = await Promise.all([
         getOptimizedGasPrice(provider, getGasPriceConfig(config)),
         getTokenDecimals(tokenAddress, provider),
         batchCheckAllowances(provider, tokenAddress, sellers.map(w => w.address), pancakeProxyAddress),
-        Promise.all(sellers.map(w => nonceManager.getNextNonce(w)))
+        nonceManager.getNextNoncesForWallets(sellers) // ✅ 批量获取 nonce
     ]);
     const amountsWei = sellAmounts.map(a => ethers.parseUnits(a, tokenDecimals));
     // 找出需要授权的钱包索引
@@ -368,20 +426,19 @@ export async function fourPancakeProxyBatchSellMerkle(params) {
     let minOuts;
     let quotedOutputs;
     if (params.minOutputAmounts && params.minOutputAmounts.length === sellers.length) {
-        // 用户提供了 minOutputAmounts
+        // 用户提供了 minOutputAmounts，跳过报价查询
         minOuts = params.minOutputAmounts.map(m => typeof m === 'string' ? ethers.parseEther(m) : m);
         quotedOutputs = minOuts.map(m => m * 100n / 95n); // 反推预期收益
     }
     else {
-        // ✅ 自动调用 PancakeSwap 获取报价
-        quotedOutputs = await Promise.all(amountsWei.map(async (amount) => {
-            try {
-                if (routeType === 'v2') {
-                    const v2Router = new Contract(PANCAKE_V2_ROUTER_ADDRESS, PANCAKE_V2_ROUTER_ABI, provider);
-                    const amounts = await v2Router.getAmountsOut(amount, params.v2Path);
-                    return amounts[amounts.length - 1];
-                }
-                else if (routeType === 'v3-single') {
+        // ✅ 使用 Multicall3 批量获取报价（仅 V2 路由支持）
+        if (routeType === 'v2' && params.v2Path && params.v2Path.length >= 2) {
+            quotedOutputs = await batchGetV2Quotes(provider, amountsWei, params.v2Path);
+        }
+        else if (routeType === 'v3-single') {
+            // V3 单跳：并行调用（V3 Quoter 是 non-view 函数，不支持 Multicall3）
+            quotedOutputs = await Promise.all(amountsWei.map(async (amount) => {
+                try {
                     const quoter = new Contract(PANCAKE_V3_QUOTER_ADDRESS, PANCAKE_V3_QUOTER_ABI, provider);
                     const result = await quoter.quoteExactInputSingle.staticCall({
                         tokenIn: tokenAddress,
@@ -392,20 +449,18 @@ export async function fourPancakeProxyBatchSellMerkle(params) {
                     });
                     return result[0];
                 }
-                else {
-                    // v3-multi 使用 v2 备选
-                    if (params.v2Path && params.v2Path.length >= 2) {
-                        const v2Router = new Contract(PANCAKE_V2_ROUTER_ADDRESS, PANCAKE_V2_ROUTER_ABI, provider);
-                        const amounts = await v2Router.getAmountsOut(amount, params.v2Path);
-                        return amounts[amounts.length - 1];
-                    }
+                catch {
                     return 0n;
                 }
-            }
-            catch (error) {
-                return 0n;
-            }
-        }));
+            }));
+        }
+        else if (routeType === 'v3-multi' && params.v2Path && params.v2Path.length >= 2) {
+            // V3 多跳：使用 V2 备选路由
+            quotedOutputs = await batchGetV2Quotes(provider, amountsWei, params.v2Path);
+        }
+        else {
+            quotedOutputs = new Array(amountsWei.length).fill(0n);
+        }
         // minOuts 设为预期收益的 95%（滑点保护）
         minOuts = quotedOutputs.map(q => q * 95n / 100n);
     }

package/dist/contracts/tm-bundle-merkle/swap-buy-first.js

@@ -94,15 +94,32 @@ export async function fourBundleBuyFirstMerkle(params) {
         sellerNonceCount++; // 授权交易
     if (extractProfit)
         sellerNonceCount++; // 利润交易
-    const [sellResult, buyUnsigned, sellUnsigned, buyerNonces, sellerNonces] = await Promise.all([
+    // ✅ 优化：使用批量 nonce 获取（JSON-RPC 批量请求）
+    // 同一地址时使用 getNextNonceBatch 获取连续 nonce
+    // 不同地址时使用 getNextNoncesForWallets 一次性获取两个地址的初始 nonce
+    const getNoncesPromise = sameAddress
+        ? nonceManager.getNextNonceBatch(seller, buyerNonceCount + sellerNonceCount)
+            .then(nonces => ({ buyerNonces: [], sellerNonces: nonces }))
+        : (async () => {
+            // ✅ 优化：一次性获取两个地址的初始 nonce（单次网络往返）
+            const initialNonces = await nonceManager.getNextNoncesForWallets([buyer, seller]);
+            // buyer 只需要 1 个 nonce
+            const buyerNonces = [initialNonces[0]];
+            // seller 需要 sellerNonceCount 个连续 nonce，从初始 nonce 开始
+            const sellerNonces = Array.from({ length: sellerNonceCount }, (_, i) => initialNonces[1] + i);
+            // 更新 NonceManager 缓存
+            for (let i = 1; i < sellerNonceCount; i++) {
+                await nonceManager.getNextNonce(seller); // 递增缓存
+            }
+            return { buyerNonces, sellerNonces };
+        })();
+    const [sellResult, buyUnsigned, sellUnsigned, noncesResult] = await Promise.all([
         trySell('BSC', config.rpcUrl, tokenAddress, sellAmountWei),
         tmBuyer.buyTokenAMAP.populateTransaction(0n, tokenAddress, buyer.address, buyerFundsWei, minBuyAmount, { value: buyerFundsWei }),
         tmSeller.sellToken.populateTransaction(0n, tokenAddress, sellAmountWei, 0n), // minSellFunds 后面更新
-        sameAddress
-            ? Promise.resolve([]) // 同一地址，后面统一处理
-            : nonceManager.getNextNonceBatch(buyer, buyerNonceCount),
-        nonceManager.getNextNonceBatch(seller, sameAddress ? (buyerNonceCount + sellerNonceCount) : sellerNonceCount)
+        getNoncesPromise
     ]);
+    const { buyerNonces, sellerNonces } = noncesResult;
     const estimatedSellFunds = sellResult.funds;
     const minSellFunds = (estimatedSellFunds * BigInt(10000 - slippageBps)) / 10000n;
     const profitAmount = extractProfit ? (estimatedSellFunds * BigInt(profitRateBps)) / 10000n : 0n;

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

@@ -74,12 +74,26 @@ export async function fourBundleSwapMerkle(params) {
         sellerNonceCount++; // 授权交易
     if (extractProfit)
         sellerNonceCount++; // 利润交易
-    const [sellUnsigned, buyUnsigned, sellerNonces, buyerNonce] = await Promise.all([
+    // ✅ 优化：使用批量 nonce 获取（JSON-RPC 批量请求）
+    // 先一次性获取 seller 和 buyer 的初始 nonce，然后分配连续 nonce
+    const [sellUnsigned, buyUnsigned, noncesResult] = await Promise.all([
         tmSeller.sellToken.populateTransaction(0n, tokenAddress, sellAmountWei, 0n),
         tmBuyer.buyTokenAMAP.populateTransaction(0n, tokenAddress, buyer.address, buyerFunds, 0n, { value: buyerFunds }),
-        nonceManager.getNextNonceBatch(seller, sellerNonceCount),
-        nonceManager.getNextNonce(buyer)
+        (async () => {
+            // ✅ 一次性获取两个地址的初始 nonce（单次网络往返）
+            const initialNonces = await nonceManager.getNextNoncesForWallets([seller, buyer]);
+            // seller 需要 sellerNonceCount 个连续 nonce
+            const sellerNonces = Array.from({ length: sellerNonceCount }, (_, i) => initialNonces[0] + i);
+            // buyer 只需要 1 个 nonce
+            const buyerNonce = initialNonces[1];
+            // 更新 NonceManager 缓存（seller 需要额外的 nonce）
+            for (let i = 1; i < sellerNonceCount; i++) {
+                await nonceManager.getNextNonce(seller); // 递增缓存
+            }
+            return { sellerNonces, buyerNonce };
+        })()
     ]);
+    const { sellerNonces, buyerNonce } = noncesResult;
     // 分配 nonces
     let idx = 0;
     let approvalNonce;

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

@@ -509,6 +509,13 @@ export async function sweepWithBundleMerkle(params) {
                 const nonces = await nonceManager.getNextNonceBatch(payerWallet, 2);
                 payerProfitNonce = nonces[1]; // 利润交易的 nonce
             }
+            // ✅ 优化：批量获取所有钱包的 nonce（JSON-RPC 批量请求）
+            // 过滤出需要归集的钱包
+            const walletsToSweep = wallets.filter((_, i) => sweepAmounts[i] > 0n && i !== maxSweepIndex);
+            const nonces = walletsToSweep.length > 0
+                ? await nonceManager.getNextNoncesForWallets(walletsToSweep)
+                : [];
+            let nonceIdx = 0;
             const txPromises = wallets.map(async (w, i) => {
                 const toSend = sweepAmounts[i];
                 if (toSend <= 0n)
@@ -523,10 +530,14 @@ export async function sweepWithBundleMerkle(params) {
                         actualToSend = toSend; // 其他钱包不扣利润，归集全部
                     }
                 }
-                // ✅ 支付者使用预留的第一个 nonce，其他钱包正常获取
-                const nonce = (i === maxSweepIndex && payerProfitNonce !== undefined)
-                    ? payerProfitNonce - 1 // 使用预留的第一个 nonce
-                    : await nonceManager.getNextNonce(w);
+                // ✅ 支付者使用预留的第一个 nonce，其他钱包使用批量获取的 nonce
+                let nonce;
+                if (i === maxSweepIndex && payerProfitNonce !== undefined) {
+                    nonce = payerProfitNonce - 1; // 使用预留的第一个 nonce
+                }
+                else {
+                    nonce = nonces[nonceIdx++];
+                }
                 const mainTx = await w.signTransaction({
                     to: target,
                     value: actualToSend,
@@ -652,6 +663,13 @@ export async function sweepWithBundleMerkle(params) {
                 const nonces = await nonceManager.getNextNonceBatch(payerWallet, 2);
                 payerProfitNonce = nonces[1]; // 利润交易的 nonce
             }
+            // ✅ 优化：批量获取所有钱包的 nonce（JSON-RPC 批量请求）
+            // 过滤出需要归集的钱包（排除支付者，因为支付者已经预留了 nonce）
+            const walletsToSweepErc20 = wallets.filter((_, i) => sweepAmounts[i] > 0n && i !== maxSweepIndex);
+            const noncesErc20 = walletsToSweepErc20.length > 0
+                ? await nonceManager.getNextNoncesForWallets(walletsToSweepErc20)
+                : [];
+            let nonceIdxErc20 = 0;
             const txPromises = wallets.map(async (w, i) => {
                 const toSend = sweepAmounts[i];
                 if (toSend <= 0n)
@@ -666,10 +684,14 @@ export async function sweepWithBundleMerkle(params) {
                         actualToSend = toSend; // 其他钱包不扣利润，归集全部
                     }
                 }
-                // ✅ 支付者使用预留的第一个 nonce，其他钱包正常获取
-                const nonce = (i === maxSweepIndex && payerProfitNonce !== undefined)
-                    ? payerProfitNonce - 1 // 使用预留的第一个 nonce
-                    : await nonceManager.getNextNonce(w);
+                // ✅ 支付者使用预留的第一个 nonce，其他钱包使用批量获取的 nonce
+                let nonce;
+                if (i === maxSweepIndex && payerProfitNonce !== undefined) {
+                    nonce = payerProfitNonce - 1; // 使用预留的第一个 nonce
+                }
+                else {
+                    nonce = noncesErc20[nonceIdxErc20++];
+                }
                 const data = iface.encodeFunctionData('transfer', [target, actualToSend]);
                 const mainTx = await w.signTransaction({
                     to: tokenAddress,

package/dist/flap/portal-bundle-merkle/pancake-proxy.js

@@ -1,8 +1,12 @@
-import { ethers, Wallet, JsonRpcProvider, Contract } from 'ethers';
+import { ethers, Wallet, JsonRpcProvider, Contract, Interface } from 'ethers';
 import { NonceManager, getOptimizedGasPrice } from '../../utils/bundle-helpers.js';
 import { ADDRESSES } from '../../utils/constants.js';
 import { CHAIN_ID_MAP, getTxType, getGasPriceConfig, shouldExtractProfit, calculateProfit, calculateBatchProfit, getProfitRecipient } from './config.js';
 import { batchCheckAllowances } from '../../utils/erc20.js';
+const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+const MULTICALL3_ABI = [
+    'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) external payable returns (tuple(bool success, bytes returnData)[])'
+];
 // 常量
 const WBNB_ADDRESS = '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c';
 const FLAT_FEE = ethers.parseEther('0.0001'); // 合约固定手续费
@@ -239,7 +243,7 @@ export async function pancakeProxyBatchBuyMerkle(params) {
     const originalAmountsWei = buyAmounts.map(amount => ethers.parseEther(amount));
     const { totalProfit, remainingAmounts } = calculateBatchProfit(originalAmountsWei, config);
     const maxFundsIndex = findMaxAmountIndex(originalAmountsWei);
-    // ✅ 优化：第一批并行 - gasPrice、tokenDecimals、nonces
+    // ✅ 优化：第一批并行 - gasPrice、tokenDecimals、nonces（JSON-RPC 批量请求）
     const [gasPrice, tokenDecimals, nonces] = await Promise.all([
         getOptimizedGasPrice(provider, getGasPriceConfig(config)),
         getTokenDecimals(tokenAddress, provider),
@@ -307,7 +311,7 @@ export async function pancakeProxyBatchSellMerkle(params) {
     const finalGasLimit = getGasLimit(config);
     const extractProfit = shouldExtractProfit(config);
     const nonceManager = new NonceManager(provider);
-    // ✅ 优化：第一批并行 - gasPrice、tokenDecimals、allowances、nonces
+    // ✅ 优化：第一批并行 - gasPrice、tokenDecimals、allowances、nonces（JSON-RPC 批量请求）
     const [gasPrice, tokenDecimals, , nonces] = await Promise.all([
         getOptimizedGasPrice(provider, getGasPriceConfig(config)),
         getTokenDecimals(tokenAddress, provider),
@@ -317,7 +321,7 @@ export async function pancakeProxyBatchSellMerkle(params) {
             owners: sellers.map(w => w.address),
             spender: ADDRESSES.BSC.PancakeProxy
         }),
-        Promise.all(sellers.map(wallet => nonceManager.getNextNonce(wallet)))
+        nonceManager.getNextNoncesForWallets(sellers) // ✅ 批量获取 nonce
     ]);
     const amountsWei = sellAmounts.map(amount => ethers.parseUnits(amount, tokenDecimals));
     // ✅ 优化：第二批并行 - resolveSellOutputs 和 buildSellTransactions
@@ -422,14 +426,14 @@ async function buildBuyTransactions({ routeType, params, proxies, wallets, token
     throw new Error(`Unsupported routeType: ${routeType}`);
 }
 /**
- * ✅ 优化：并行获取所有钱包的 nonce
+ * ✅ 优化：批量获取所有钱包的 nonce（JSON-RPC 批量请求）
  */
 async function allocateProfitAwareNonces(wallets, extractProfit, maxIndex, totalProfit, nonceManager) {
-    // ✅ 并行获取所有钱包的初始 nonce
-    const nonces = await Promise.all(wallets.map(wallet => nonceManager.getNextNonce(wallet)));
+    // ✅ 批量获取所有钱包的初始 nonce（单次网络往返）
+    const nonces = await nonceManager.getNextNoncesForWallets(wallets);
     // 如果需要利润转账，maxIndex 钱包需要额外一个 nonce
     if (extractProfit && totalProfit > 0n && maxIndex >= 0 && maxIndex < wallets.length) {
-        // 预留一个 nonce 给利润交易（NonceManager 内部会自增）
+        // 预留一个 nonce 给利润交易（从缓存获取，不触发 RPC）
         await nonceManager.getNextNonce(wallets[maxIndex]);
     }
     return nonces;
@@ -458,7 +462,11 @@ async function ensureAllowances({ provider, tokenAddress, owners, spender }) {
         throw new Error(`需要授权: ${needApproval} 个钱包尚未授权。请先完成授权后再卖出。`);
     }
 }
+/**
+ * ✅ 使用 Multicall3 批量获取卖出报价（单次 RPC）
+ */
 async function resolveSellOutputs({ params, provider, tokenAddress, routeType, amountsWei }) {
+    // 如果已提供 minOutputAmounts，直接使用，跳过报价查询
     if (params.minOutputAmounts && params.minOutputAmounts.length === amountsWei.length) {
         const minOuts = params.minOutputAmounts.map(m => typeof m === 'string' ? ethers.parseEther(m) : m);
         return {
@@ -466,52 +474,98 @@ async function resolveSellOutputs({ params, provider, tokenAddress, routeType, a
             quotedOutputs: minOuts.map(m => m * 100n / 95n)
         };
     }
-    const quotedOutputs = await Promise.all(amountsWei.map(async (amount) => {
+    // 如果只有 1 个，直接调用（避免 multicall 开销）
+    if (amountsWei.length === 1) {
+        const quotedOutput = await getSingleQuote(params, provider, tokenAddress, routeType, amountsWei[0]);
+        return {
+            quotedOutputs: [quotedOutput],
+            minOuts: [quotedOutput * 95n / 100n]
+        };
+    }
+    // ✅ 使用 Multicall3 批量获取报价（仅 V2 路由支持）
+    if (routeType === 'v2' && params.v2Path && params.v2Path.length >= 2) {
         try {
-            if (routeType === 'v2') {
-                if (!params.v2Path || params.v2Path.length < 2) {
-                    throw new Error('v2Path is required for V2 routing');
-                }
-                const v2Router = new Contract(PANCAKE_V2_ROUTER_ADDRESS, PANCAKE_V2_ROUTER_ABI, provider);
-                const amounts = await v2Router.getAmountsOut(amount, params.v2Path);
-                return amounts[amounts.length - 1];
-            }
-            if (routeType === 'v3-single') {
-                if (!params.v3TokenOut || !params.v3Fee) {
-                    throw new Error('v3TokenOut and v3Fee are required for V3 single-hop');
-                }
-                const quoter = new Contract(PANCAKE_V3_QUOTER_ADDRESS, PANCAKE_V3_QUOTER_ABI, provider);
-                const result = await quoter.quoteExactInputSingle.staticCall({
-                    tokenIn: tokenAddress,
-                    tokenOut: params.v3TokenOut,
-                    amountIn: amount,
-                    fee: params.v3Fee,
-                    sqrtPriceLimitX96: 0
-                });
-                return result[0];
-            }
-            if (routeType === 'v3-multi') {
-                if (!params.v3LpAddresses || params.v3LpAddresses.length === 0 || !params.v3ExactTokenIn) {
-                    throw new Error('v3LpAddresses and v3ExactTokenIn are required for V3 multi-hop');
-                }
-                if (params.v2Path && params.v2Path.length >= 2) {
-                    const v2Router = new Contract(PANCAKE_V2_ROUTER_ADDRESS, PANCAKE_V2_ROUTER_ABI, provider);
-                    const amounts = await v2Router.getAmountsOut(amount, params.v2Path);
-                    return amounts[amounts.length - 1];
+            const v2RouterIface = new Interface(PANCAKE_V2_ROUTER_ABI);
+            const multicall = new Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, provider);
+            const calls = amountsWei.map(amount => ({
+                target: PANCAKE_V2_ROUTER_ADDRESS,
+                allowFailure: true,
+                callData: v2RouterIface.encodeFunctionData('getAmountsOut', [amount, params.v2Path])
+            }));
+            const results = await multicall.aggregate3.staticCall(calls);
+            const quotedOutputs = results.map((r) => {
+                if (r.success && r.returnData && r.returnData !== '0x') {
+                    try {
+                        const decoded = v2RouterIface.decodeFunctionResult('getAmountsOut', r.returnData);
+                        const amounts = decoded[0];
+                        return amounts[amounts.length - 1];
+                    }
+                    catch {
+                        return 0n;
+                    }
                 }
                 return 0n;
-            }
-            throw new Error(`Unsupported routeType: ${routeType}`);
+            });
+            return {
+                quotedOutputs,
+                minOuts: quotedOutputs.map((q) => q * 95n / 100n)
+            };
         }
         catch {
-            return 0n;
+            // Multicall 失败，回退到并行调用
         }
-    }));
+    }
+    // 回退：并行调用（V3 路由或 Multicall 失败时）
+    const quotedOutputs = await Promise.all(amountsWei.map(amount => getSingleQuote(params, provider, tokenAddress, routeType, amount)));
     return {
         quotedOutputs,
         minOuts: quotedOutputs.map(q => q * 95n / 100n)
     };
 }
+/**
+ * 获取单个报价
+ */
+async function getSingleQuote(params, provider, tokenAddress, routeType, amount) {
+    try {
+        if (routeType === 'v2') {
+            if (!params.v2Path || params.v2Path.length < 2) {
+                throw new Error('v2Path is required for V2 routing');
+            }
+            const v2Router = new Contract(PANCAKE_V2_ROUTER_ADDRESS, PANCAKE_V2_ROUTER_ABI, provider);
+            const amounts = await v2Router.getAmountsOut(amount, params.v2Path);
+            return amounts[amounts.length - 1];
+        }
+        if (routeType === 'v3-single') {
+            if (!params.v3TokenOut || !params.v3Fee) {
+                throw new Error('v3TokenOut and v3Fee are required for V3 single-hop');
+            }
+            const quoter = new Contract(PANCAKE_V3_QUOTER_ADDRESS, PANCAKE_V3_QUOTER_ABI, provider);
+            const result = await quoter.quoteExactInputSingle.staticCall({
+                tokenIn: tokenAddress,
+                tokenOut: params.v3TokenOut,
+                amountIn: amount,
+                fee: params.v3Fee,
+                sqrtPriceLimitX96: 0
+            });
+            return result[0];
+        }
+        if (routeType === 'v3-multi') {
+            if (!params.v3LpAddresses || params.v3LpAddresses.length === 0 || !params.v3ExactTokenIn) {
+                throw new Error('v3LpAddresses and v3ExactTokenIn are required for V3 multi-hop');
+            }
+            if (params.v2Path && params.v2Path.length >= 2) {
+                const v2Router = new Contract(PANCAKE_V2_ROUTER_ADDRESS, PANCAKE_V2_ROUTER_ABI, provider);
+                const amounts = await v2Router.getAmountsOut(amount, params.v2Path);
+                return amounts[amounts.length - 1];
+            }
+            return 0n;
+        }
+        throw new Error(`Unsupported routeType: ${routeType}`);
+    }
+    catch {
+        return 0n;
+    }
+}
 async function buildSellTransactions({ routeType, params, proxies, wallets, tokenAddress, amountsWei, minOuts }) {
     const needBNB = false;
     if (routeType === 'v2') {

package/dist/flap/portal-bundle-merkle/swap-buy-first.js

@@ -313,8 +313,12 @@ async function validateNativeBalances({ sameAddress, buyerBalance, buyerFundsWei
         throw new Error(`卖方余额不足: 需要 ${ethers.formatEther(gasCost)} ${nativeToken} (Gas)，实际 ${ethers.formatEther(sellerBalance)} ${nativeToken}`);
     }
 }
+/**
+ * ✅ 优化：使用批量 nonce 获取
+ */
 async function planNonces({ buyer, seller, approvalExists, extractProfit, sameAddress, nonceManager }) {
     if (sameAddress) {
+        // 同一地址：使用 getNextNonceBatch 获取连续 nonce
         const txCount = countTruthy([approvalExists, true, true, extractProfit]);
         const nonces = await nonceManager.getNextNonceBatch(buyer, txCount);
         let idx = 0;
@@ -326,21 +330,24 @@ async function planNonces({ buyer, seller, approvalExists, extractProfit, sameAd
         return { buyerNonce, sellerNonce, profitNonce };
     }
     if (approvalExists || extractProfit) {
+        // 卖方需要多个 nonce：使用 getNextNonceBatch
         const sellerTxCount = countTruthy([approvalExists, true, extractProfit]);
-        const sellerNonces = await nonceManager.getNextNonceBatch(seller, sellerTxCount);
+        // ✅ 优化：并行获取 buyer 和 seller 的 nonce（JSON-RPC 批量请求）
+        const [sellerNonces, buyerNonces] = await Promise.all([
+            nonceManager.getNextNonceBatch(seller, sellerTxCount),
+            nonceManager.getNextNoncesForWallets([buyer])
+        ]);
         let idx = 0;
         if (approvalExists)
             idx++;
         const sellerNonce = sellerNonces[idx++];
         const profitNonce = extractProfit ? sellerNonces[idx] : undefined;
-        const buyerNonce = await nonceManager.getNextNonce(buyer);
+        const buyerNonce = buyerNonces[0];
         return { buyerNonce, sellerNonce, profitNonce };
     }
-    const [buyerNonce, sellerNonce] = await Promise.all([
-        nonceManager.getNextNonce(buyer),
-        nonceManager.getNextNonce(seller)
-    ]);
-    return { buyerNonce, sellerNonce };
+    // ✅ 优化：使用 getNextNoncesForWallets 批量获取（单次网络往返）
+    const nonces = await nonceManager.getNextNoncesForWallets([buyer, seller]);
+    return { buyerNonce: nonces[0], sellerNonce: nonces[1] };
 }
 function buildTransactionRequest(unsigned, { from, nonce, gasLimit, gasPrice, priorityFee, chainId, txType, value }) {
     const tx = {

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

@@ -275,23 +275,29 @@ async function validateBalances({ buyerNeed, buyerAddress, portalGasCost, provid
         throw new Error(`卖方余额不足: 需要 ${ethers.formatEther(portalGasCost)} ${chainContext.nativeToken} (Gas)，实际 ${ethers.formatEther(sellerBalance)} ${chainContext.nativeToken}`);
     }
 }
+/**
+ * ✅ 优化：使用批量 nonce 获取（JSON-RPC 批量请求）
+ */
 async function planNonces({ seller, buyer, approvalExists, extractProfit, nonceManager }) {
     if (approvalExists || extractProfit) {
+        // 卖方需要多个 nonce：使用 getNextNonceBatch
         const sellerTxCount = countTruthy([approvalExists, true, extractProfit]);
-        const sellerNonces = await nonceManager.getNextNonceBatch(seller, sellerTxCount);
+        // ✅ 优化：并行获取 seller 和 buyer 的 nonce
+        const [sellerNonces, buyerNonces] = await Promise.all([
+            nonceManager.getNextNonceBatch(seller, sellerTxCount),
+            nonceManager.getNextNoncesForWallets([buyer])
+        ]);
         let idx = 0;
         if (approvalExists)
             idx++;
         const sellerNonce = sellerNonces[idx++];
         const profitNonce = extractProfit ? sellerNonces[idx] : undefined;
-        const buyerNonce = await nonceManager.getNextNonce(buyer);
+        const buyerNonce = buyerNonces[0];
         return { sellerNonce, buyerNonce, profitNonce };
     }
-    const [sellerNonce, buyerNonce] = await Promise.all([
-        nonceManager.getNextNonce(seller),
-        nonceManager.getNextNonce(buyer)
-    ]);
-    return { sellerNonce, buyerNonce };
+    // ✅ 优化：使用 getNextNoncesForWallets 批量获取（单次网络往返）
+    const nonces = await nonceManager.getNextNoncesForWallets([seller, buyer]);
+    return { sellerNonce: nonces[0], buyerNonce: nonces[1] };
 }
 function buildTransactionRequest(unsigned, { from, nonce, gasLimit, gasPrice, priorityFee, chainId, txType, value }) {
     const tx = {

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

@@ -38,8 +38,8 @@ export declare class NonceManager {
      */
     getTempCachedNonce(address: string): number | undefined;
     /**
-     * ✅ 批量获取多个不同地址的 nonce（单次 RPC 批量请求）
-     * 比 Promise.all + getNextNonce 更快，因为只发一次网络请求
+     * ✅ 批量获取多个不同地址的 nonce（真正的单次 JSON-RPC 批量请求）
+     * 使用 provider.send 发送批量请求，N 个地址只需 1 次网络往返
      * @param wallets 钱包数组
      * @returns nonce 数组（顺序与 wallets 对应）
      */

package/dist/utils/bundle-helpers.js

@@ -72,8 +72,8 @@ export class NonceManager {
         return this.tempNonceCache.get(address.toLowerCase());
     }
     /**
-     * ✅ 批量获取多个不同地址的 nonce（单次 RPC 批量请求）
-     * 比 Promise.all + getNextNonce 更快，因为只发一次网络请求
+     * ✅ 批量获取多个不同地址的 nonce（真正的单次 JSON-RPC 批量请求）
+     * 使用 provider.send 发送批量请求，N 个地址只需 1 次网络往返
      * @param wallets 钱包数组
      * @returns nonce 数组（顺序与 wallets 对应）
      */
@@ -94,11 +94,32 @@ export class NonceManager {
                 needQuery.push({ index: i, address: addresses[i] });
             }
         }
-        // 如果有需要查询的地址，使用批量 RPC
+        // 如果有需要查询的地址，使用真正的 JSON-RPC 批量请求
         if (needQuery.length > 0) {
-            // 使用 ethers 的批量请求（内部会合并为单次 RPC）
-            const queryPromises = needQuery.map(({ address }) => this.provider.getTransactionCount(address, 'latest'));
-            const queryResults = await Promise.all(queryPromises);
+            let queryResults;
+            try {
+                // ✅ 使用 JSON-RPC 批量请求（单次网络往返）
+                const batchRequests = needQuery.map(({ address }, idx) => ({
+                    method: 'eth_getTransactionCount',
+                    params: [address, 'latest'],
+                    id: idx + 1,
+                    jsonrpc: '2.0'
+                }));
+                // 通过 provider._send 发送批量请求（ethers v6 内部方法）
+                const rawResults = await this.provider._send(batchRequests);
+                // 解析结果
+                queryResults = rawResults.map((r) => {
+                    if (r.result) {
+                        return parseInt(r.result, 16);
+                    }
+                    return 0;
+                });
+            }
+            catch {
+                // 如果批量请求失败，回退到 Promise.all
+                const queryPromises = needQuery.map(({ address }) => this.provider.getTransactionCount(address, 'latest'));
+                queryResults = await Promise.all(queryPromises);
+            }
             // 填充结果并更新缓存
             for (let i = 0; i < needQuery.length; i++) {
                 const { index, address } = needQuery[i];

package/package.json

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