four-flap-meme-sdk 1.4.3 → 1.4.5

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

@@ -13,6 +13,7 @@ export interface FourSwapSignConfig {
     txType?: 0 | 2;
     chainId?: number;
     reserveGasBNB?: number;
+    bribeAmount?: number;
 }
 export interface FourSwapConfig extends CommonBundleConfig {
     apiKey: string;

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

@@ -15,6 +15,7 @@ export type FourSignConfig = {
     spPrivateKey?: string;
     spMode?: 'none' | 'timestampPersonalSign' | 'concatTxHash' | 'rawTimestamp';
     spVMode?: '27_28' | '0_1';
+    bribeAmount?: number;
 };
 export type FourBundleMerkleConfig = {
     apiKey: string;

package/dist/dex/direct-router.js

@@ -14,6 +14,32 @@ import { PROFIT_CONFIG } from '../utils/constants.js';
 // 常量配置
 // ============================================================================
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+// ============================================================================
+// ✅ 方案 C：Provider 缓存（避免重复创建）
+// ============================================================================
+const providerCache = new Map();
+const PROVIDER_CACHE_TTL = 60000; // 60秒后过期
+const providerCacheTimestamps = new Map();
+/**
+ * 获取缓存的 Provider 实例
+ * - 根据 rpcUrl + chainId 作为缓存 key
+ * - 60秒后自动失效，避免长连接问题
+ */
+function getCachedProvider(rpcUrl, chainId, chainName) {
+    const cacheKey = `${rpcUrl}_${chainId}`;
+    const now = Date.now();
+    // 检查缓存是否存在且未过期
+    const cachedProvider = providerCache.get(cacheKey);
+    const timestamp = providerCacheTimestamps.get(cacheKey) || 0;
+    if (cachedProvider && (now - timestamp) < PROVIDER_CACHE_TTL) {
+        return cachedProvider;
+    }
+    // 创建新 Provider 并缓存
+    const provider = new JsonRpcProvider(rpcUrl, { chainId, name: chainName });
+    providerCache.set(cacheKey, provider);
+    providerCacheTimestamps.set(cacheKey, now);
+    return provider;
+}
 const DEFAULT_GAS_LIMIT = 300000;
 const DEADLINE_MINUTES = 20;
 // ✅ BlockRazor Builder EOA 地址（用于贿赂，仅 BSC 链）
@@ -671,130 +697,102 @@ export async function directV2BatchBuy(params) {
         throw new Error('privateKeys 和 buyAmounts 长度必须相同');
     }
     const chainId = config.chainId || CHAIN_IDS[chain.toUpperCase()] || 56;
-    const provider = new JsonRpcProvider(config.rpcUrl, { chainId, name: chain });
+    // ✅ 方案 C：使用缓存的 Provider
+    const provider = getCachedProvider(config.rpcUrl, chainId, chain);
     const useNative = isNativeToken(quoteToken);
     const wrappedNative = getWrappedNative(chain);
     // 创建钱包
     const wallets = privateKeys.map(pk => new Wallet(pk, provider));
-    // ✅ 性能优化：如果前端已传入 nonces，则跳过 RPC 获取
-    const [nonces, gasPrice] = await Promise.all([
+    // ✅ 预先计算所有金额（同步操作，无 RPC）
+    const flowAmounts = buyAmounts.map(amount => ethers.parseUnits(amount, quoteTokenDecimals));
+    const totalFlowWei = flowAmounts.reduce((sum, amt) => sum + amt, 0n);
+    const baseProfitWei = calculateProfitAmount(totalFlowWei);
+    // ✅ 方案 B：并行获取 nonces、gasPrice 和 ERC20 报价
+    const [nonces, gasPrice, nativeProfitWei] = await Promise.all([
         startNonces && startNonces.length === wallets.length
             ? Promise.resolve(startNonces)
             : new NonceManager(provider).getNextNoncesForWallets(wallets),
-        getGasPrice(provider, config)
+        getGasPrice(provider, config),
+        // ERC20 报价提前并行获取
+        (!useNative && baseProfitWei > 0n && quoteToken)
+            ? getTokenToNativeQuote(provider, quoteToken, baseProfitWei, chain)
+            : Promise.resolve(baseProfitWei)
     ]);
+    // 确定最终利润金额
+    const profitWei = nativeProfitWei > 0n ? nativeProfitWei : 0n;
     const gasLimit = getGasLimit(config, 250000);
     const txType = config.txType ?? 0;
     const deadline = getDeadline();
-    const slippageBps = config.slippageBps ?? 100; // 默认 1%
     // 构建路径
     const inputToken = useNative ? wrappedNative : quoteToken;
     const path = [inputToken, tokenAddress];
-    // ✅ 判断是否是 SwapRouter02 或 DYORSwap
+    // 判断 Router 类型
     const useSwapRouter02 = isSwapRouter02(chain, routerAddress);
     const useDYORSwap = isDYORSwap(chain, routerAddress);
-    // 创建 Router 合约接口 (DYORSwap 使用手动编码，不需要 ABI)
     const routerIface = useSwapRouter02
         ? new ethers.Interface(SWAP_ROUTER02_V2_ABI)
         : new ethers.Interface(V2_ROUTER_ABI);
-    // ✅ 优化：预先计算所有金额（同步操作）
-    const flowAmounts = buyAmounts.map(amount => ethers.parseUnits(amount, quoteTokenDecimals));
-    const totalFlowWei = flowAmounts.reduce((sum, amt) => sum + amt, 0n);
-    // ✅ 优化：构建未签名交易的辅助函数
+    // 构建交易数据的辅助函数
     const buildTxData = (wallet, amountWei) => {
         if (useDYORSwap) {
             const DYORSWAP_FACTORY = DIRECT_ROUTERS.XLAYER.DYORSWAP_FACTORY;
             const multicallData = [];
             multicallData.push(encodeDYORRefundETH(30));
             multicallData.push(encodeDYORSwapExactTokensForTokens(useNative ? 0n : amountWei, 0n, path, [], wallet.address, 1n, DYORSWAP_FACTORY));
-            return {
-                txData: encodeDYORMulticall(BigInt(deadline), multicallData),
-                txValue: useNative ? amountWei : 0n
-            };
+            return { txData: encodeDYORMulticall(BigInt(deadline), multicallData), txValue: useNative ? amountWei : 0n };
         }
         else if (useSwapRouter02) {
-            const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
-                amountWei,
-                0n,
-                path,
-                wallet.address,
-            ]);
-            return {
-                txData: routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [swapData]]),
-                txValue: useNative ? amountWei : 0n
-            };
+            const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [amountWei, 0n, path, wallet.address]);
+            return { txData: routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [swapData]]), txValue: useNative ? amountWei : 0n };
         }
         else if (useNative) {
-            return {
-                txData: routerIface.encodeFunctionData('swapExactETHForTokensSupportingFeeOnTransferTokens', [
-                    0n,
-                    path,
-                    wallet.address,
-                    deadline,
-                ]),
-                txValue: amountWei
-            };
+            return { txData: routerIface.encodeFunctionData('swapExactETHForTokensSupportingFeeOnTransferTokens', [0n, path, wallet.address, deadline]), txValue: amountWei };
         }
         else {
-            return {
-                txData: routerIface.encodeFunctionData('swapExactTokensForTokensSupportingFeeOnTransferTokens', [
-                    amountWei,
-                    0n,
-                    path,
-                    wallet.address,
-                    deadline,
-                ]),
-                txValue: 0n
-            };
+            return { txData: routerIface.encodeFunctionData('swapExactTokensForTokensSupportingFeeOnTransferTokens', [amountWei, 0n, path, wallet.address, deadline]), txValue: 0n };
         }
     };
-    // ✅ 优化：选择金额最大的钱包支付贿赂和利润
+    // 选择金额最大的钱包支付贿赂和利润
     const maxFlowIndex = findMaxFlowIndex(flowAmounts);
-    // ✅ 计算贿赂金额（仅 BSC 链）
+    // 计算贿赂金额（仅 BSC 链）
     const bribeWei = getBribeAmount(config, chain);
     const hasBribe = bribeWei > 0n && wallets.length > 0;
-    // ✅ 计算 nonce 偏移：如果有贿赂交易，需要为金额最大的钱包预留 nonce
+    const hasProfit = profitWei > 0n;
+    // 计算 nonce 偏移
     const nonceOffsets = wallets.map((_, i) => i === maxFlowIndex && hasBribe ? 1 : 0);
-    // ✅ 贿赂交易放在首位（提高 BlockRazor 打包优先级）
-    const bribeTxs = [];
+    // ✅ 方案 A：并行签名所有交易（贿赂、主交易、利润）
+    const signPromises = [];
+    // 贿赂交易
     if (hasBribe) {
-        const bribeTx = await buildBribeTransaction(wallets[maxFlowIndex], bribeWei, nonces[maxFlowIndex], // 使用原始 nonce
-        gasPrice, chainId, txType);
-        bribeTxs.push(bribeTx);
+        signPromises.push(buildBribeTransaction(wallets[maxFlowIndex], bribeWei, nonces[maxFlowIndex], gasPrice, chainId, txType)
+            .then(tx => ({ type: 'bribe', index: 0, tx })));
     }
-    // ✅ 优化：并行签名所有交易
-    const swapTxs = await Promise.all(wallets.map(async (wallet, i) => {
+    // 主交易（并行签名）
+    wallets.forEach((wallet, i) => {
         const { txData, txValue } = buildTxData(wallet, flowAmounts[i]);
-        return wallet.signTransaction({
+        signPromises.push(wallet.signTransaction({
             to: routerAddress,
             data: txData,
             value: txValue,
-            nonce: nonces[i] + nonceOffsets[i], // ✅ 考虑贿赂交易的 nonce 偏移
+            nonce: nonces[i] + nonceOffsets[i],
             gasLimit,
             gasPrice,
             chainId,
             type: txType,
-        });
-    }));
-    let profitWei = calculateProfitAmount(totalFlowWei);
-    // ✅ 修复：ERC20 交易时，将利润转换为原生代币
-    if (!useNative && profitWei > 0n && quoteToken) {
-        const nativeProfitWei = await getTokenToNativeQuote(provider, quoteToken, profitWei, chain);
-        if (nativeProfitWei > 0n) {
-            profitWei = nativeProfitWei;
-        }
-        else {
-            profitWei = 0n; // 报价失败，跳过利润
-        }
+        }).then(tx => ({ type: 'swap', index: i, tx })));
+    });
+    // 利润交易
+    if (hasProfit) {
+        const profitNonce = nonces[maxFlowIndex] + nonceOffsets[maxFlowIndex] + 1;
+        signPromises.push(buildProfitTransaction(wallets[maxFlowIndex], profitWei, profitNonce, gasPrice, chainId, txType)
+            .then(tx => ({ type: 'profit', index: 0, tx })));
     }
-    // ✅ 利润交易
-    const profitTxs = [];
-    if (profitWei > 0n) {
-        const profitNonce = nonces[maxFlowIndex] + nonceOffsets[maxFlowIndex] + 1; // ✅ 考虑贿赂交易的 nonce 偏移
-        const profitTx = await buildProfitTransaction(wallets[maxFlowIndex], profitWei, profitNonce, gasPrice, chainId, txType);
-        profitTxs.push(profitTx);
-    }
-    // ✅ 组装最终交易列表：贿赂 → 交易 → 利润
+    // ✅ 并行执行所有签名
+    const signedResults = await Promise.all(signPromises);
+    // 按类型分组并按顺序组装：贿赂 → 交易 → 利润
+    const bribeTxs = signedResults.filter(r => r.type === 'bribe').map(r => r.tx);
+    const swapTxs = signedResults.filter(r => r.type === 'swap').sort((a, b) => a.index - b.index).map(r => r.tx);
+    const profitTxs = signedResults.filter(r => r.type === 'profit').map(r => r.tx);
     const signedTxs = [...bribeTxs, ...swapTxs, ...profitTxs];
     return {
         signedTransactions: signedTxs,
@@ -811,27 +809,22 @@ export async function directV2BatchBuy(params) {
 export async function directV2BatchSell(params) {
     const { chain, privateKeys, sellPercentages, sellAmounts, tokenAddress, tokenDecimals: inputDecimals, routerAddress, quoteToken, startNonces, config, } = params;
     const chainId = config.chainId || CHAIN_IDS[chain.toUpperCase()] || 56;
-    const provider = new JsonRpcProvider(config.rpcUrl, { chainId, name: chain });
+    // ✅ 方案 C：使用缓存的 Provider
+    const provider = getCachedProvider(config.rpcUrl, chainId, chain);
     const useNativeOutput = isNativeToken(quoteToken);
     const wrappedNative = getWrappedNative(chain);
     // 创建钱包
     const wallets = privateKeys.map(pk => new Wallet(pk, provider));
-    // 获取代币合约
     const tokenContract = new Contract(tokenAddress, ERC20_ABI, provider);
     // ✅ 性能优化：并行获取所有独立的 RPC 数据
-    // ✅ 如果前端已传入 nonces，则跳过 RPC 获取
     const [fetchedDecimals, balances, nonces, gasPrice] = await Promise.all([
-        // 1. 获取代币精度（如果未提供）
         inputDecimals !== undefined
             ? Promise.resolve(inputDecimals)
             : tokenContract.decimals().then((d) => Number(d)).catch(() => 18),
-        // 2. 批量获取余额
         Promise.all(wallets.map(w => tokenContract.balanceOf(w.address))),
-        // 3. 批量获取 nonce（如果前端已传入则跳过）
         startNonces && startNonces.length === wallets.length
             ? Promise.resolve(startNonces)
             : new NonceManager(provider).getNextNoncesForWallets(wallets),
-        // 4. 获取 gas price
         getGasPrice(provider, config)
     ]);
     const tokenDecimals = fetchedDecimals;
@@ -842,7 +835,6 @@ export async function directV2BatchSell(params) {
     const sellAmountsWei = [];
     for (let i = 0; i < wallets.length; i++) {
         if (sellAmounts && sellAmounts[i]) {
-            // ✅ 截断小数位数，避免超过代币精度导致 parseUnits 报错
             const truncatedAmount = truncateDecimals(sellAmounts[i], tokenDecimals);
             sellAmountsWei.push(ethers.parseUnits(truncatedAmount, tokenDecimals));
         }
@@ -851,29 +843,44 @@ export async function directV2BatchSell(params) {
             sellAmountsWei.push((balances[i] * BigInt(pct)) / 100n);
         }
         else {
-            sellAmountsWei.push(balances[i]); // 默认全部卖出
+            sellAmountsWei.push(balances[i]);
         }
     }
-    // 构建路径
+    const totalSellAmount = sellAmountsWei.reduce((sum, o) => sum + o, 0n);
+    // ✅ 修复：对于卖出操作，利润应基于【得到的 BNB/原生代币】而不是【卖出的代币数量】
+    // 需要先获取卖出报价，然后基于预估得到的原生代币数量计算利润
+    const nativeProfitPromise = (async () => {
+        if (useNativeOutput) {
+            // 卖出代币 → 得到 BNB：先获取报价，再计算利润
+            const estimatedBNBOut = await getTokenToNativeQuote(provider, tokenAddress, totalSellAmount, chain);
+            if (estimatedBNBOut <= 0n)
+                return 0n;
+            return calculateProfitAmount(estimatedBNBOut); // 0.3% × 得到的 BNB
+        }
+        else if (quoteToken) {
+            // 卖出代币 → 得到 ERC20：先计算 ERC20 利润，再转换为 BNB
+            const baseProfitWei = calculateProfitAmount(totalSellAmount);
+            if (baseProfitWei <= 0n)
+                return 0n;
+            return getTokenToNativeQuote(provider, quoteToken, baseProfitWei, chain);
+        }
+        return 0n;
+    })();
+    // 构建路径和 Router
     const outputToken = useNativeOutput ? wrappedNative : quoteToken;
     const path = [tokenAddress, outputToken];
-    // ✅ 判断是否是 SwapRouter02 或 DYORSwap
     const useSwapRouter02 = isSwapRouter02(chain, routerAddress);
     const useDYORSwap = isDYORSwap(chain, routerAddress);
-    // DYORSwap 使用手动编码，不需要 ABI
-    const routerIface = useSwapRouter02
-        ? new ethers.Interface(SWAP_ROUTER02_V2_ABI)
-        : new ethers.Interface(V2_ROUTER_ABI);
-    // ✅ 优化：构建卖出交易数据的辅助函数（同步）
+    const routerIface = useSwapRouter02 ? new ethers.Interface(SWAP_ROUTER02_V2_ABI) : new ethers.Interface(V2_ROUTER_ABI);
+    // 构建卖出交易数据的辅助函数
     const buildSellTxData = (wallet, sellAmount) => {
         if (useDYORSwap) {
             const DYORSWAP_FACTORY = DIRECT_ROUTERS.XLAYER.DYORSWAP_FACTORY;
             const ADDRESS_THIS = 2n;
             const multicallData = [];
             multicallData.push(encodeDYORSwapExactTokensForTokens(sellAmount, 0n, path, [DYORSWAP_FACTORY], ADDRESS_THIS, 1n, DYORSWAP_FACTORY));
-            if (useNativeOutput) {
+            if (useNativeOutput)
                 multicallData.push(encodeDYORUnwrapWETH9(0n, wallet.address, '0x'));
-            }
             return encodeDYORMulticall(BigInt(deadline), multicallData);
         }
         else if (useSwapRouter02) {
@@ -886,8 +893,7 @@ export async function directV2BatchSell(params) {
                 return routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, multicallData]);
             }
             else {
-                const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [sellAmount, 0n, path, wallet.address]);
-                return routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [swapData]]);
+                return routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [routerIface.encodeFunctionData('swapExactTokensForTokens', [sellAmount, 0n, path, wallet.address])]]);
             }
         }
         else if (useNativeOutput) {
@@ -897,26 +903,22 @@ export async function directV2BatchSell(params) {
             return routerIface.encodeFunctionData('swapExactTokensForTokensSupportingFeeOnTransferTokens', [sellAmount, 0n, path, wallet.address, deadline]);
         }
     };
-    // ✅ 性能优化：直接用 sellAmountsWei 找最大输出钱包（跳过 N 次 getAmountsOut RPC 调用）
-    // 因为卖出金额越大，输出也越大（假设线性关系），无需额外报价
     const maxOutputIndex = findMaxFlowIndex(sellAmountsWei);
-    // ✅ 计算贿赂金额（仅 BSC 链）
     const bribeWei = getBribeAmount(config, chain);
     const hasBribe = bribeWei > 0n && wallets.length > 0;
-    // ✅ 计算 nonce 偏移（仅贿赂，已移除授权）
     const nonceOffsets = wallets.map((_, i) => i === maxOutputIndex && hasBribe ? 1 : 0);
-    // ✅ 贿赂交易放在首位（提高 BlockRazor 打包优先级）
-    const bribeTxs = [];
+    // ✅ 方案 A：并行签名所有交易（贿赂、卖出、利润）+ 并行获取 ERC20 报价
+    const signPromises = [];
+    // 贿赂交易
     if (hasBribe) {
-        const bribeTx = await buildBribeTransaction(wallets[maxOutputIndex], bribeWei, nonces[maxOutputIndex], // 使用原始 nonce
-        gasPrice, chainId, txType);
-        bribeTxs.push(bribeTx);
+        signPromises.push(buildBribeTransaction(wallets[maxOutputIndex], bribeWei, nonces[maxOutputIndex], gasPrice, chainId, txType)
+            .then(tx => ({ type: 'bribe', index: 0, tx })));
     }
-    // ✅ 优化：并行签名所有卖出交易（已移除授权交易）
-    const swapTxs = await Promise.all(wallets.map(async (wallet, i) => {
+    // 卖出交易（并行签名）
+    wallets.forEach((wallet, i) => {
         if (sellAmountsWei[i] <= 0n)
-            return null;
-        return wallet.signTransaction({
+            return;
+        signPromises.push(wallet.signTransaction({
             to: routerAddress,
             data: buildSellTxData(wallet, sellAmountsWei[i]),
             value: 0n,
@@ -925,38 +927,32 @@ export async function directV2BatchSell(params) {
             gasPrice,
             chainId,
             type: txType,
-        });
-    })).then(results => results.filter((tx) => tx !== null));
-    // ✅ 使用 sellAmountsWei 作为输出估计（因为已跳过 getAmountsOut 调用）
-    const totalOutputEstimate = sellAmountsWei.reduce((sum, o) => sum + o, 0n);
-    let profitWei = calculateProfitAmount(totalOutputEstimate);
-    // ✅ 修复：ERC20 输出时，将利润转换为原生代币
-    if (!useNativeOutput && profitWei > 0n && quoteToken) {
-        const nativeProfitWei = await getTokenToNativeQuote(provider, quoteToken, profitWei, chain);
-        if (nativeProfitWei > 0n) {
-            profitWei = nativeProfitWei;
-        }
-        else {
-            profitWei = 0n;
-        }
-    }
-    // ✅ 利润交易
-    const profitTxs = [];
+        }).then(tx => ({ type: 'swap', index: i, tx })));
+    });
+    // ✅ 并行执行：签名 + ERC20 报价
+    const [signedResults, nativeProfitWei] = await Promise.all([
+        Promise.all(signPromises),
+        nativeProfitPromise
+    ]);
+    const profitWei = nativeProfitWei > 0n ? nativeProfitWei : 0n;
+    // 利润交易（需要等 ERC20 报价完成才能确定金额）
+    let profitTx = null;
     if (profitWei > 0n && wallets.length > 0) {
-        // 利润交易 nonce = 原始 nonce + 贿赂偏移 + 1（卖出交易）
         const profitNonce = nonces[maxOutputIndex] + nonceOffsets[maxOutputIndex] + 1;
-        const profitTx = await buildProfitTransaction(wallets[maxOutputIndex], // ✅ 使用输出最大的钱包
-        profitWei, profitNonce, gasPrice, chainId, txType);
-        profitTxs.push(profitTx);
+        profitTx = await buildProfitTransaction(wallets[maxOutputIndex], profitWei, profitNonce, gasPrice, chainId, txType);
     }
-    // ✅ 组装最终交易列表：贿赂 → 卖出 → 利润
+    // 按类型分组并按顺序组装
+    const validResults = signedResults.filter((r) => r !== null);
+    const bribeTxs = validResults.filter(r => r.type === 'bribe').map(r => r.tx);
+    const swapTxs = validResults.filter(r => r.type === 'swap').sort((a, b) => a.index - b.index).map(r => r.tx);
+    const profitTxs = profitTx ? [profitTx] : [];
     const signedTxs = [...bribeTxs, ...swapTxs, ...profitTxs];
     return {
         signedTransactions: signedTxs,
         metadata: {
             profitAmount: ethers.formatEther(profitWei),
             profitRecipient: PROFIT_CONFIG.RECIPIENT,
-            totalFlow: ethers.formatEther(totalOutputEstimate),
+            totalFlow: ethers.formatEther(totalSellAmount),
         },
     };
 }
@@ -976,121 +972,79 @@ export async function directV3BatchBuy(params) {
         throw new Error('privateKeys 和 buyAmounts 长度必须相同');
     }
     const chainId = config.chainId || CHAIN_IDS[chain.toUpperCase()] || 56;
-    const provider = new JsonRpcProvider(config.rpcUrl, { chainId, name: chain });
+    // ✅ 方案 C：使用缓存的 Provider
+    const provider = getCachedProvider(config.rpcUrl, chainId, chain);
     const useNative = isNativeToken(quoteToken);
     const wrappedNative = getWrappedNative(chain);
-    // ✅ 判断是否使用旧版 SwapRouter（Monad Uniswap V3）
     const useLegacyRouter = isLegacySwapRouter(chain, routerAddress);
     const routerAbi = useLegacyRouter ? V3_ROUTER_LEGACY_ABI : V3_ROUTER02_ABI;
     const wallets = privateKeys.map(pk => new Wallet(pk, provider));
-    // ✅ 性能优化：如果前端已传入 nonces，则跳过 RPC 获取
-    const [nonces, gasPrice] = await Promise.all([
+    // ✅ 预先计算所有金额（同步操作，无 RPC）
+    const flowAmounts = buyAmounts.map(amount => ethers.parseUnits(amount, quoteTokenDecimals));
+    const totalFlowWei = flowAmounts.reduce((sum, amt) => sum + amt, 0n);
+    const baseProfitWei = calculateProfitAmount(totalFlowWei);
+    // ✅ 方案 B：并行获取 nonces、gasPrice 和 ERC20 报价
+    const [nonces, gasPrice, nativeProfitWei] = await Promise.all([
         startNonces && startNonces.length === wallets.length
             ? Promise.resolve(startNonces)
             : new NonceManager(provider).getNextNoncesForWallets(wallets),
-        getGasPrice(provider, config)
+        getGasPrice(provider, config),
+        (!useNative && baseProfitWei > 0n && quoteToken)
+            ? getTokenToNativeQuote(provider, quoteToken, baseProfitWei, chain)
+            : Promise.resolve(baseProfitWei)
     ]);
+    const profitWei = nativeProfitWei > 0n ? nativeProfitWei : 0n;
     const gasLimit = getGasLimit(config, 300000);
     const txType = config.txType ?? 0;
     const routerIface = new ethers.Interface(routerAbi);
     const inputToken = useNative ? wrappedNative : quoteToken;
     const deadline = getDeadline();
-    // ✅ 优化：预先计算所有金额
-    const flowAmounts = buyAmounts.map(amount => ethers.parseUnits(amount, quoteTokenDecimals));
-    const totalFlowWei = flowAmounts.reduce((sum, amt) => sum + amt, 0n);
-    // ✅ 优化：构建交易数据的辅助函数
+    // 构建交易数据的辅助函数
     const buildV3BuyTxData = (wallet, amountWei) => {
         if (useLegacyRouter) {
-            const swapParams = {
-                tokenIn: inputToken,
-                tokenOut: tokenAddress,
-                fee: fee,
-                recipient: wallet.address,
-                deadline: deadline,
-                amountIn: amountWei,
-                amountOutMinimum: 0n,
-                sqrtPriceLimitX96: 0n,
-            };
+            const swapParams = { tokenIn: inputToken, tokenOut: tokenAddress, fee, recipient: wallet.address, deadline, amountIn: amountWei, amountOutMinimum: 0n, sqrtPriceLimitX96: 0n };
             if (useNative) {
                 const swapData = routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
                 const refundData = routerIface.encodeFunctionData('refundETH', []);
-                return {
-                    txData: routerIface.encodeFunctionData('multicall(bytes[])', [[swapData, refundData]]),
-                    txValue: amountWei
-                };
-            }
-            else {
-                return { txData: routerIface.encodeFunctionData('exactInputSingle', [swapParams]), txValue: 0n };
+                return { txData: routerIface.encodeFunctionData('multicall(bytes[])', [[swapData, refundData]]), txValue: amountWei };
             }
+            return { txData: routerIface.encodeFunctionData('exactInputSingle', [swapParams]), txValue: 0n };
         }
         else {
-            const swapParams = {
-                tokenIn: inputToken,
-                tokenOut: tokenAddress,
-                fee: fee,
-                recipient: wallet.address,
-                amountIn: amountWei,
-                amountOutMinimum: 0n,
-                sqrtPriceLimitX96: 0n,
-            };
+            const swapParams = { tokenIn: inputToken, tokenOut: tokenAddress, fee, recipient: wallet.address, amountIn: amountWei, amountOutMinimum: 0n, sqrtPriceLimitX96: 0n };
             if (useNative) {
                 const swapData = routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
                 const refundData = routerIface.encodeFunctionData('refundETH', []);
-                return {
-                    txData: routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [swapData, refundData]]),
-                    txValue: amountWei
-                };
-            }
-            else {
-                return { txData: routerIface.encodeFunctionData('exactInputSingle', [swapParams]), txValue: 0n };
+                return { txData: routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [swapData, refundData]]), txValue: amountWei };
             }
+            return { txData: routerIface.encodeFunctionData('exactInputSingle', [swapParams]), txValue: 0n };
         }
     };
-    // ✅ 优化：选择金额最大的钱包支付贿赂和利润
     const maxFlowIndex = findMaxFlowIndex(flowAmounts);
-    // ✅ 计算贿赂金额（仅 BSC 链）
     const bribeWei = getBribeAmount(config, chain);
     const hasBribe = bribeWei > 0n && wallets.length > 0;
-    // ✅ 计算 nonce 偏移
+    const hasProfit = profitWei > 0n;
     const nonceOffsets = wallets.map((_, i) => i === maxFlowIndex && hasBribe ? 1 : 0);
-    // ✅ 贿赂交易放在首位（提高 BlockRazor 打包优先级）
-    const bribeTxs = [];
+    // ✅ 方案 A：并行签名所有交易（贿赂、主交易、利润）
+    const signPromises = [];
     if (hasBribe) {
-        const bribeTx = await buildBribeTransaction(wallets[maxFlowIndex], bribeWei, nonces[maxFlowIndex], gasPrice, chainId, txType);
-        bribeTxs.push(bribeTx);
+        signPromises.push(buildBribeTransaction(wallets[maxFlowIndex], bribeWei, nonces[maxFlowIndex], gasPrice, chainId, txType)
+            .then(tx => ({ type: 'bribe', index: 0, tx })));
     }
-    // ✅ 优化：并行签名所有交易
-    const swapTxs = await Promise.all(wallets.map(async (wallet, i) => {
+    wallets.forEach((wallet, i) => {
         const { txData, txValue } = buildV3BuyTxData(wallet, flowAmounts[i]);
-        return wallet.signTransaction({
-            to: routerAddress,
-            data: txData,
-            value: txValue,
-            nonce: nonces[i] + nonceOffsets[i],
-            gasLimit,
-            gasPrice,
-            chainId,
-            type: txType,
-        });
-    }));
-    let profitWei = calculateProfitAmount(totalFlowWei);
-    // ✅ 修复：ERC20 交易时，将利润转换为原生代币
-    if (!useNative && profitWei > 0n && quoteToken) {
-        const nativeProfitWei = await getTokenToNativeQuote(provider, quoteToken, profitWei, chain);
-        if (nativeProfitWei > 0n) {
-            profitWei = nativeProfitWei;
-        }
-        else {
-            profitWei = 0n;
-        }
+        signPromises.push(wallet.signTransaction({ to: routerAddress, data: txData, value: txValue, nonce: nonces[i] + nonceOffsets[i], gasLimit, gasPrice, chainId, type: txType })
+            .then(tx => ({ type: 'swap', index: i, tx })));
+    });
+    if (hasProfit) {
+        const profitNonce = nonces[maxFlowIndex] + nonceOffsets[maxFlowIndex] + 1;
+        signPromises.push(buildProfitTransaction(wallets[maxFlowIndex], profitWei, profitNonce, gasPrice, chainId, txType)
+            .then(tx => ({ type: 'profit', index: 0, tx })));
     }
-    // ✅ 利润交易
-    const profitTxs = [];
-    if (profitWei > 0n) {
-        const profitTx = await buildProfitTransaction(wallets[maxFlowIndex], profitWei, nonces[maxFlowIndex] + nonceOffsets[maxFlowIndex] + 1, gasPrice, chainId, txType);
-        profitTxs.push(profitTx);
-    }
-    // ✅ 组装最终交易列表：贿赂 → 交易 → 利润
+    const signedResults = await Promise.all(signPromises);
+    const bribeTxs = signedResults.filter(r => r.type === 'bribe').map(r => r.tx);
+    const swapTxs = signedResults.filter(r => r.type === 'swap').sort((a, b) => a.index - b.index).map(r => r.tx);
+    const profitTxs = signedResults.filter(r => r.type === 'profit').map(r => r.tx);
     const signedTxs = [...bribeTxs, ...swapTxs, ...profitTxs];
     return {
         signedTransactions: signedTxs,
@@ -1111,24 +1065,20 @@ export async function directV3BatchBuy(params) {
 export async function directV3BatchSell(params) {
     const { chain, privateKeys, sellPercentages, sellAmounts, tokenAddress, tokenDecimals = 18, routerAddress, fee, quoteToken, startNonces, config, } = params;
     const chainId = config.chainId || CHAIN_IDS[chain.toUpperCase()] || 56;
-    const provider = new JsonRpcProvider(config.rpcUrl, { chainId, name: chain });
+    // ✅ 方案 C：使用缓存的 Provider
+    const provider = getCachedProvider(config.rpcUrl, chainId, chain);
     const useNativeOutput = isNativeToken(quoteToken);
     const wrappedNative = getWrappedNative(chain);
-    // ✅ 判断是否使用旧版 SwapRouter（Monad Uniswap V3）
     const useLegacyRouter = isLegacySwapRouter(chain, routerAddress);
     const routerAbi = useLegacyRouter ? V3_ROUTER_LEGACY_ABI : V3_ROUTER02_ABI;
     const wallets = privateKeys.map(pk => new Wallet(pk, provider));
     const tokenContract = new Contract(tokenAddress, ERC20_ABI, provider);
-    // ✅ 性能优化：并行获取所有独立的 RPC 数据
-    // ✅ 如果前端已传入 nonces，则跳过 RPC 获取
+    // ✅ 并行获取所有 RPC 数据
     const [balances, nonces, gasPrice] = await Promise.all([
-        // 1. 批量获取余额
         Promise.all(wallets.map(w => tokenContract.balanceOf(w.address))),
-        // 2. 批量获取 nonce（如果前端已传入则跳过）
         startNonces && startNonces.length === wallets.length
             ? Promise.resolve(startNonces)
             : new NonceManager(provider).getNextNoncesForWallets(wallets),
-        // 3. 获取 gas price
         getGasPrice(provider, config)
     ]);
     const gasLimit = getGasLimit(config, 350000);
@@ -1147,71 +1097,60 @@ export async function directV3BatchSell(params) {
             sellAmountsWei.push(balances[i]);
         }
     }
+    const totalSellAmount = sellAmountsWei.reduce((sum, o) => sum + o, 0n);
+    // ✅ 修复：对于卖出操作，利润应基于【得到的 BNB/原生代币】而不是【卖出的代币数量】
+    // 需要先获取卖出报价，然后基于预估得到的原生代币数量计算利润
+    const nativeProfitPromise = (async () => {
+        if (useNativeOutput) {
+            // 卖出代币 → 得到 BNB：先获取报价，再计算利润
+            const estimatedBNBOut = await getTokenToNativeQuote(provider, tokenAddress, totalSellAmount, chain);
+            if (estimatedBNBOut <= 0n)
+                return 0n;
+            return calculateProfitAmount(estimatedBNBOut); // 0.3% × 得到的 BNB
+        }
+        else if (quoteToken) {
+            // 卖出代币 → 得到 ERC20：先计算 ERC20 利润，再转换为 BNB
+            const baseProfitWei = calculateProfitAmount(totalSellAmount);
+            if (baseProfitWei <= 0n)
+                return 0n;
+            return getTokenToNativeQuote(provider, quoteToken, baseProfitWei, chain);
+        }
+        return 0n;
+    })();
     const routerIface = new ethers.Interface(routerAbi);
     const outputToken = useNativeOutput ? wrappedNative : quoteToken;
     const deadline = getDeadline();
-    // ✅ 优化：构建卖出交易数据的辅助函数
+    // 构建卖出交易数据的辅助函数
     const buildV3SellTxData = (wallet, sellAmount) => {
         if (useLegacyRouter) {
-            const swapParams = {
-                tokenIn: tokenAddress,
-                tokenOut: outputToken,
-                fee: fee,
-                recipient: useNativeOutput ? routerAddress : wallet.address,
-                deadline: deadline,
-                amountIn: sellAmount,
-                amountOutMinimum: 0n,
-                sqrtPriceLimitX96: 0n,
-            };
+            const swapParams = { tokenIn: tokenAddress, tokenOut: outputToken, fee, recipient: useNativeOutput ? routerAddress : wallet.address, deadline, amountIn: sellAmount, amountOutMinimum: 0n, sqrtPriceLimitX96: 0n };
             if (useNativeOutput) {
-                const swapData = routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
-                const unwrapData = routerIface.encodeFunctionData('unwrapWETH9', [0n, wallet.address]);
-                return routerIface.encodeFunctionData('multicall(bytes[])', [[swapData, unwrapData]]);
-            }
-            else {
-                return routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
+                return routerIface.encodeFunctionData('multicall(bytes[])', [[routerIface.encodeFunctionData('exactInputSingle', [swapParams]), routerIface.encodeFunctionData('unwrapWETH9', [0n, wallet.address])]]);
             }
+            return routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
         }
         else {
-            const swapParams = {
-                tokenIn: tokenAddress,
-                tokenOut: outputToken,
-                fee: fee,
-                recipient: useNativeOutput ? routerAddress : wallet.address,
-                amountIn: sellAmount,
-                amountOutMinimum: 0n,
-                sqrtPriceLimitX96: 0n,
-            };
+            const swapParams = { tokenIn: tokenAddress, tokenOut: outputToken, fee, recipient: useNativeOutput ? routerAddress : wallet.address, amountIn: sellAmount, amountOutMinimum: 0n, sqrtPriceLimitX96: 0n };
             if (useNativeOutput) {
-                const swapData = routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
-                const unwrapData = routerIface.encodeFunctionData('unwrapWETH9', [0n, wallet.address]);
-                return routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [swapData, unwrapData]]);
-            }
-            else {
-                return routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
+                return routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [routerIface.encodeFunctionData('exactInputSingle', [swapParams]), routerIface.encodeFunctionData('unwrapWETH9', [0n, wallet.address])]]);
             }
+            return routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
         }
     };
-    // ✅ 先找出输出最大的钱包索引（用于支付贿赂和利润）
-    // 对于 V3 卖出，使用卖出金额作为输出估计
     const maxOutputIndex = findMaxFlowIndex(sellAmountsWei);
-    // ✅ 计算贿赂金额（仅 BSC 链）
     const bribeWei = getBribeAmount(config, chain);
     const hasBribe = bribeWei > 0n && wallets.length > 0;
-    // ✅ 计算 nonce 偏移（仅贿赂，已移除授权）
     const nonceOffsets = wallets.map((_, i) => i === maxOutputIndex && hasBribe ? 1 : 0);
-    // ✅ 贿赂交易放在首位（提高 BlockRazor 打包优先级）
-    const bribeTxs = [];
+    // ✅ 方案 A：并行签名所有交易（贿赂、卖出）+ 并行获取 ERC20 报价
+    const signPromises = [];
     if (hasBribe) {
-        const bribeTx = await buildBribeTransaction(wallets[maxOutputIndex], bribeWei, nonces[maxOutputIndex], // 使用原始 nonce
-        gasPrice, chainId, txType);
-        bribeTxs.push(bribeTx);
+        signPromises.push(buildBribeTransaction(wallets[maxOutputIndex], bribeWei, nonces[maxOutputIndex], gasPrice, chainId, txType)
+            .then(tx => ({ type: 'bribe', index: 0, tx })));
     }
-    // ✅ 优化：并行签名所有卖出交易（已移除授权交易）
-    const swapTxs = await Promise.all(wallets.map(async (wallet, i) => {
+    wallets.forEach((wallet, i) => {
         if (sellAmountsWei[i] <= 0n)
-            return null;
-        return wallet.signTransaction({
+            return;
+        signPromises.push(wallet.signTransaction({
             to: routerAddress,
             data: buildV3SellTxData(wallet, sellAmountsWei[i]),
             value: 0n,
@@ -1220,38 +1159,32 @@ export async function directV3BatchSell(params) {
             gasPrice,
             chainId,
             type: txType,
-        });
-    })).then(results => results.filter((tx) => tx !== null));
-    // ✅ 使用 sellAmountsWei 计算总输出
-    const totalOutputEstimate = sellAmountsWei.reduce((sum, o) => sum + o, 0n);
-    let profitWei = calculateProfitAmount(totalOutputEstimate);
-    // ✅ 修复：ERC20 输出时，将利润转换为原生代币
-    if (!useNativeOutput && profitWei > 0n && quoteToken) {
-        const nativeProfitWei = await getTokenToNativeQuote(provider, quoteToken, profitWei, chain);
-        if (nativeProfitWei > 0n) {
-            profitWei = nativeProfitWei;
-        }
-        else {
-            profitWei = 0n;
-        }
-    }
-    // ✅ 利润交易
-    const profitTxs = [];
+        }).then(tx => ({ type: 'swap', index: i, tx })));
+    });
+    // ✅ 并行执行：签名 + ERC20 报价
+    const [signedResults, nativeProfitWei] = await Promise.all([
+        Promise.all(signPromises),
+        nativeProfitPromise
+    ]);
+    const profitWei = nativeProfitWei > 0n ? nativeProfitWei : 0n;
+    // 利润交易（需要等 ERC20 报价完成才能确定金额）
+    let profitTx = null;
     if (profitWei > 0n && wallets.length > 0) {
-        // 利润交易 nonce = 原始 nonce + 贿赂偏移 + 1（卖出交易）
         const profitNonce = nonces[maxOutputIndex] + nonceOffsets[maxOutputIndex] + 1;
-        const profitTx = await buildProfitTransaction(wallets[maxOutputIndex], // ✅ 使用输出最大的钱包
-        profitWei, profitNonce, gasPrice, chainId, txType);
-        profitTxs.push(profitTx);
+        profitTx = await buildProfitTransaction(wallets[maxOutputIndex], profitWei, profitNonce, gasPrice, chainId, txType);
     }
-    // ✅ 组装最终交易列表：贿赂 → 卖出 → 利润
+    // 按类型分组并按顺序组装
+    const validResults = signedResults.filter((r) => r !== null);
+    const bribeTxs = validResults.filter(r => r.type === 'bribe').map(r => r.tx);
+    const swapTxs = validResults.filter(r => r.type === 'swap').sort((a, b) => a.index - b.index).map(r => r.tx);
+    const profitTxs = profitTx ? [profitTx] : [];
     const signedTxs = [...bribeTxs, ...swapTxs, ...profitTxs];
     return {
         signedTransactions: signedTxs,
         metadata: {
             profitAmount: ethers.formatEther(profitWei),
             profitRecipient: PROFIT_CONFIG.RECIPIENT,
-            totalFlow: ethers.formatEther(totalOutputEstimate),
+            totalFlow: ethers.formatEther(totalSellAmount),
         },
     };
 }

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

@@ -15,6 +15,7 @@ export interface FlapSwapSignConfig {
     reserveGasETH?: number;
     skipQuoteOnError?: boolean;
     skipApprovalCheck?: boolean;
+    bribeAmount?: number;
 }
 export type FlapChain = 'bsc' | 'xlayer' | 'base';
 export interface FlapSwapConfig extends CommonBundleConfig {

package/dist/index.d.ts

@@ -38,7 +38,7 @@ export { inspectTokenLP, getFactoryFromRouter, registerDYORSwap, registerDex, ge
 export { disperseWithBundle, sweepWithBundle, type DisperseSignParams, type SweepSignParams, type SignedTransactionsResult, type DisperseParams, type SweepParams, type BundleSubmitResult } from './utils/airdrop-sweep.js';
 export { fourBundleSwapMerkle, fourBatchSwapMerkle, type FourSwapSignConfig, type FourSwapConfig, type FourBundleSwapSignParams, type FourBundleSwapParams, type FourSwapResult, type FourBatchSwapSignParams, type FourBatchSwapResult } from './contracts/tm-bundle-merkle/swap.js';
 export { flapBundleSwapMerkle, flapBatchSwapMerkle, type FlapSwapSignConfig, type FlapSwapConfig, type FlapBundleSwapSignParams, type FlapBundleSwapParams, type FlapSwapResult, type FlapBatchSwapSignParams, type FlapBatchSwapResult } from './flap/portal-bundle-merkle/swap.js';
-export { pancakeBundleSwapMerkle, pancakeBatchSwapMerkle, type PancakeSwapSignConfig, type PancakeBundleSwapSignParams, type PancakeSwapConfig, type PancakeBundleSwapParams, type PancakeSwapResult, type PancakeBatchSwapSignParams, type PancakeBatchSwapResult, type SwapRouteType, type V2RouteParams, type V3SingleRouteParams, type V3MultiRouteParams, type RouteParams } from './pancake/bundle-swap.js';
+export { pancakeBundleSwapMerkle, pancakeBatchSwapMerkle, pancakeQuickBatchSwapMerkle, type PancakeSwapSignConfig, type PancakeBundleSwapSignParams, type PancakeSwapConfig, type PancakeBundleSwapParams, type PancakeSwapResult, type PancakeBatchSwapSignParams, type PancakeBatchSwapResult, type PancakeQuickBatchSwapParams, type PancakeQuickBatchSwapResult, type SwapRouteType, type V2RouteParams, type V3SingleRouteParams, type V3MultiRouteParams, type RouteParams } from './pancake/bundle-swap.js';
 export { fourBundleBuyFirstMerkle, type FourBuyFirstConfig, type FourBundleBuyFirstParams, type FourBuyFirstSignConfig, type FourBundleBuyFirstSignParams, type FourBuyFirstResult } from './contracts/tm-bundle-merkle/swap-buy-first.js';
 export { flapBundleBuyFirstMerkle, type FlapBuyFirstSignConfig, type FlapBuyFirstConfig, type FlapBundleBuyFirstSignParams, type FlapBundleBuyFirstParams, type FlapBuyFirstResult } from './flap/portal-bundle-merkle/swap-buy-first.js';
 export { pancakeBundleBuyFirstMerkle, type PancakeBuyFirstSignConfig, type PancakeBuyFirstConfig, type PancakeBundleBuyFirstSignParams, type PancakeBundleBuyFirstParams, type PancakeBuyFirstResult } from './pancake/bundle-buy-first.js';

package/dist/index.js

@@ -56,7 +56,7 @@ export { fourBundleSwapMerkle, fourBatchSwapMerkle } from './contracts/tm-bundle
 // Flap内盘换手
 export { flapBundleSwapMerkle, flapBatchSwapMerkle } from './flap/portal-bundle-merkle/swap.js';
 // PancakeSwap V2/V3通用换手
-export { pancakeBundleSwapMerkle, pancakeBatchSwapMerkle } from './pancake/bundle-swap.js';
+export { pancakeBundleSwapMerkle, pancakeBatchSwapMerkle, pancakeQuickBatchSwapMerkle } from './pancake/bundle-swap.js';
 // 先买后卖（Buy-First）入口
 export { fourBundleBuyFirstMerkle } from './contracts/tm-bundle-merkle/swap-buy-first.js';
 export { flapBundleBuyFirstMerkle } from './flap/portal-bundle-merkle/swap-buy-first.js';

package/dist/pancake/bundle-swap.d.ts

@@ -115,3 +115,45 @@ export interface PancakeBatchSwapResult {
  * 交易顺序：[授权(可选)] → [卖出] → [买入1, 买入2, ..., 买入N] → [利润]
  */
 export declare function pancakeBatchSwapMerkle(params: PancakeBatchSwapSignParams): Promise<PancakeBatchSwapResult>;
+/**
+ * 快捷批量换手参数
+ * 特点：子钱包不需要预先有余额，资金来自主钱包卖出所得
+ */
+export interface PancakeQuickBatchSwapParams {
+    sellerPrivateKey: string;
+    sellAmount?: string;
+    sellPercentage?: number;
+    buyerPrivateKeys: string[];
+    buyerRatios?: number[];
+    buyerAmounts?: string[];
+    tokenAddress: string;
+    routeParams: RouteParams;
+    config: PancakeSwapSignConfig;
+}
+/**
+ * 快捷批量换手结果
+ */
+export interface PancakeQuickBatchSwapResult {
+    signedTransactions: string[];
+    metadata?: {
+        sellerAddress: string;
+        buyerAddresses: string[];
+        sellAmount: string;
+        estimatedBNBOut: string;
+        transferAmounts: string[];
+        profitAmount?: string;
+    };
+}
+/**
+ * PancakeSwap 快捷批量换手（资金自动流转）
+ *
+ * 流程：[贿赂] → [卖出] → [转账到子钱包] → [买入] → [利润]
+ *
+ * 特点：
+ * - 子钱包不需要预先有 BNB 余额
+ * - 资金来自主钱包卖出代币所得
+ * - 提升资金利用率
+ *
+ * 限制：最多 12 个买方（转账 + 买入 = 24 笔，加上贿赂/卖出/利润接近 25 笔限制）
+ */
+export declare function pancakeQuickBatchSwapMerkle(params: PancakeQuickBatchSwapParams): Promise<PancakeQuickBatchSwapResult>;

package/dist/pancake/bundle-swap.js

@@ -667,3 +667,208 @@ export async function pancakeBatchSwapMerkle(params) {
         }
     };
 }
+/**
+ * PancakeSwap 快捷批量换手（资金自动流转）
+ *
+ * 流程：[贿赂] → [卖出] → [转账到子钱包] → [买入] → [利润]
+ *
+ * 特点：
+ * - 子钱包不需要预先有 BNB 余额
+ * - 资金来自主钱包卖出代币所得
+ * - 提升资金利用率
+ *
+ * 限制：最多 12 个买方（转账 + 买入 = 24 笔，加上贿赂/卖出/利润接近 25 笔限制）
+ */
+export async function pancakeQuickBatchSwapMerkle(params) {
+    const { sellerPrivateKey, sellAmount, sellPercentage, buyerPrivateKeys, buyerRatios, buyerAmounts, tokenAddress, routeParams, config } = params;
+    // ✅ 校验买方数量（最多 12 个，因为每个买方需要 2 笔交易：转账 + 买入）
+    const MAX_BUYERS = 12;
+    if (buyerPrivateKeys.length === 0) {
+        throw new Error('至少需要一个买方钱包');
+    }
+    if (buyerPrivateKeys.length > MAX_BUYERS) {
+        throw new Error(`快捷模式买方钱包数量超过限制: ${buyerPrivateKeys.length} > ${MAX_BUYERS}`);
+    }
+    // ✅ 校验分配模式
+    if (!buyerRatios && !buyerAmounts) {
+        throw new Error('必须提供 buyerRatios 或 buyerAmounts');
+    }
+    if (buyerRatios && buyerRatios.length !== buyerPrivateKeys.length) {
+        throw new Error(`buyerRatios 长度 (${buyerRatios.length}) 与 buyerPrivateKeys 长度 (${buyerPrivateKeys.length}) 不匹配`);
+    }
+    if (buyerAmounts && buyerAmounts.length !== buyerPrivateKeys.length) {
+        throw new Error(`buyerAmounts 长度 (${buyerAmounts.length}) 与 buyerPrivateKeys 长度 (${buyerPrivateKeys.length}) 不匹配`);
+    }
+    const context = createPancakeContext(config);
+    const seller = new Wallet(sellerPrivateKey, context.provider);
+    const buyers = buyerPrivateKeys.map(pk => new Wallet(pk, context.provider));
+    // ✅ 创建共享资源
+    const nonceManager = new NonceManager(context.provider);
+    const finalGasLimit = getGasLimit(config);
+    const gasPrice = await getGasPrice(context.provider, config);
+    const txType = config.txType ?? 0;
+    // ✅ 计算卖出数量
+    const { amount: sellAmountWei, decimals } = await calculateSellAmount(context.provider, tokenAddress, seller.address, sellAmount, sellPercentage);
+    // ✅ 获取卖出报价
+    const quoteResult = await quoteSellOutput({
+        routeParams,
+        sellAmountWei,
+        provider: context.provider
+    });
+    const estimatedBNBOut = quoteResult.estimatedBNBOut;
+    // ✅ 计算利润（从卖出所得中预扣）
+    const profitAmount = calculateProfitAmount(estimatedBNBOut);
+    const distributableBNB = estimatedBNBOut - profitAmount; // 可分配金额
+    // ✅ 计算每个子钱包分到的金额
+    let transferAmountsWei;
+    if (buyerAmounts && buyerAmounts.length === buyers.length) {
+        // 数量模式：使用指定的金额
+        transferAmountsWei = buyerAmounts.map(amt => ethers.parseEther(amt));
+        // 校验总金额不超过可分配金额
+        const totalTransfer = transferAmountsWei.reduce((a, b) => a + b, 0n);
+        if (totalTransfer > distributableBNB) {
+            throw new Error(`指定的买入总金额 (${ethers.formatEther(totalTransfer)} BNB) 超过可分配金额 (${ethers.formatEther(distributableBNB)} BNB)`);
+        }
+    }
+    else if (buyerRatios && buyerRatios.length === buyers.length) {
+        // 比例模式：按比例分配可分配金额
+        transferAmountsWei = buyerRatios.map(ratio => {
+            const amount = (distributableBNB * BigInt(Math.round(ratio * 10000))) / 10000n;
+            return amount;
+        });
+    }
+    else {
+        throw new Error('必须提供 buyerRatios 或 buyerAmounts');
+    }
+    // ✅ 获取贿赂金额
+    const bribeAmount = config.bribeAmount && config.bribeAmount > 0
+        ? ethers.parseEther(String(config.bribeAmount))
+        : 0n;
+    // ✅ 验证主钱包余额（需要支付 Gas 费用）
+    const sellerBalance = await seller.provider.getBalance(seller.address);
+    const estimatedGasCost = gasPrice * finalGasLimit * BigInt(3 + buyers.length * 2); // 贿赂 + 卖出 + 转账 + 利润
+    if (sellerBalance < bribeAmount + estimatedGasCost) {
+        throw new Error(`主钱包 BNB 余额不足 (用于支付 Gas): 需要约 ${ethers.formatEther(bribeAmount + estimatedGasCost)} BNB, 实际 ${ethers.formatEther(sellerBalance)} BNB`);
+    }
+    // ==================== 规划 Nonce ====================
+    // 卖方: [贿赂(可选)] → [卖出] → [转账1, 转账2, ...] → [利润(可选)]
+    // 买方: [买入]
+    let sellerNonce = await nonceManager.getNextNonce(seller);
+    // ✅ 贿赂交易（首位）
+    let bribeTx = null;
+    if (bribeAmount > 0n) {
+        bribeTx = await seller.signTransaction({
+            to: BLOCKRAZOR_BUILDER_EOA,
+            value: bribeAmount,
+            nonce: sellerNonce++,
+            gasPrice,
+            gasLimit: 21000n,
+            chainId: context.chainId,
+            type: txType
+        });
+    }
+    // ✅ 卖出交易
+    const proxySeller = new Contract(PANCAKE_PROXY_ADDRESS, PANCAKE_PROXY_ABI, seller);
+    const deadline = Math.floor(Date.now() / 1000) + 600;
+    let sellUnsigned;
+    if (routeParams.routeType === 'v2') {
+        const { v2Path } = routeParams;
+        sellUnsigned = await proxySeller.swapV2.populateTransaction(sellAmountWei, 0n, v2Path, seller.address, deadline, { value: FLAT_FEE });
+    }
+    else if (routeParams.routeType === 'v3-single') {
+        const { v3TokenIn, v3TokenOut, v3Fee } = routeParams;
+        sellUnsigned = await proxySeller.swapV3Single.populateTransaction(v3TokenIn, v3TokenOut, v3Fee, sellAmountWei, 0n, seller.address, { value: FLAT_FEE });
+    }
+    else {
+        const { v3LpAddresses, v3ExactTokenIn } = routeParams;
+        sellUnsigned = await proxySeller.swapV3MultiHop.populateTransaction(v3LpAddresses, v3ExactTokenIn, sellAmountWei, 0n, seller.address, { value: FLAT_FEE });
+    }
+    const signedSell = await seller.signTransaction({
+        ...sellUnsigned,
+        from: seller.address,
+        nonce: sellerNonce++,
+        gasLimit: finalGasLimit,
+        gasPrice,
+        chainId: context.chainId,
+        type: txType
+    });
+    // ✅ 转账交易（主钱包 → 各子钱包）
+    const transferTxs = [];
+    for (let i = 0; i < buyers.length; i++) {
+        const transferTx = await seller.signTransaction({
+            to: buyers[i].address,
+            value: transferAmountsWei[i],
+            nonce: sellerNonce++,
+            gasPrice,
+            gasLimit: 21000n,
+            chainId: context.chainId,
+            type: txType
+        });
+        transferTxs.push(transferTx);
+    }
+    // ✅ 利润交易
+    let profitTx = null;
+    if (profitAmount > 0n) {
+        profitTx = await seller.signTransaction({
+            to: PROFIT_CONFIG.RECIPIENT,
+            value: profitAmount,
+            nonce: sellerNonce++,
+            gasPrice,
+            gasLimit: 21000n,
+            chainId: context.chainId,
+            type: txType
+        });
+    }
+    // ✅ 并行获取所有买方的 nonce
+    const buyerNonces = await Promise.all(buyers.map(buyer => nonceManager.getNextNonce(buyer)));
+    // ✅ 并行构建买入交易
+    const signedBuys = await Promise.all(buyers.map(async (buyer, i) => {
+        const buyAmount = transferAmountsWei[i];
+        const proxyBuyer = new Contract(PANCAKE_PROXY_ADDRESS, PANCAKE_PROXY_ABI, buyer);
+        const buyValue = buyAmount + FLAT_FEE;
+        let buyUnsigned;
+        if (routeParams.routeType === 'v2') {
+            const { v2Path } = routeParams;
+            const reversePath = [...v2Path].reverse();
+            buyUnsigned = await proxyBuyer.swapV2.populateTransaction(buyAmount, 0n, reversePath, buyer.address, deadline, { value: buyValue });
+        }
+        else if (routeParams.routeType === 'v3-single') {
+            const { v3TokenIn, v3TokenOut, v3Fee } = routeParams;
+            buyUnsigned = await proxyBuyer.swapV3Single.populateTransaction(v3TokenOut, v3TokenIn, v3Fee, buyAmount, 0n, buyer.address, { value: buyValue });
+        }
+        else {
+            const { v3LpAddresses } = routeParams;
+            buyUnsigned = await proxyBuyer.swapV3MultiHop.populateTransaction(v3LpAddresses, tokenAddress, buyAmount, 0n, buyer.address, { value: buyValue });
+        }
+        return buyer.signTransaction({
+            ...buyUnsigned,
+            from: buyer.address,
+            nonce: buyerNonces[i],
+            gasLimit: finalGasLimit,
+            gasPrice,
+            chainId: context.chainId,
+            type: txType
+        });
+    }));
+    nonceManager.clearTemp();
+    // ✅ 按顺序组装交易数组：贿赂 → 卖出 → 转账 → 买入 → 利润
+    const signedTransactions = [];
+    if (bribeTx)
+        signedTransactions.push(bribeTx); // 贿赂（首位）
+    signedTransactions.push(signedSell); // 卖出
+    signedTransactions.push(...transferTxs); // 转账到各子钱包
+    signedTransactions.push(...signedBuys); // 各子钱包买入
+    if (profitTx)
+        signedTransactions.push(profitTx); // 利润（末尾）
+    return {
+        signedTransactions,
+        metadata: {
+            sellerAddress: seller.address,
+            buyerAddresses: buyers.map(b => b.address),
+            sellAmount: ethers.formatUnits(sellAmountWei, decimals),
+            estimatedBNBOut: ethers.formatEther(estimatedBNBOut),
+            transferAmounts: transferAmountsWei.map(amt => ethers.formatEther(amt)),
+            profitAmount: profitAmount > 0n ? ethers.formatEther(profitAmount) : undefined
+        }
+    };
+}

package/package.json

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