four-flap-meme-sdk 1.3.73 → 1.3.76

package/dist/dex/direct-router.js

@@ -16,6 +16,25 @@ import { PROFIT_CONFIG } from '../utils/constants.js';
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 const DEFAULT_GAS_LIMIT = 300000;
 const DEADLINE_MINUTES = 20;
+// ✅ Router ABI（用于 ERC20 → 原生代币报价）
+const QUOTE_ROUTER_ABI = [
+    'function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts)'
+];
+// ✅ 各链的报价 Router 和包装代币地址
+const QUOTE_CONFIG = {
+    BSC: {
+        router: '0x10ED43C718714eb63d5aA57B78B54704E256024E', // PancakeSwap V2
+        wrappedNative: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', // WBNB
+    },
+    MONAD: {
+        router: '0xb1bc24c34e88f7d43d5923034e3a14b24daacff9', // PancakeSwap V2
+        wrappedNative: '0x3bd359c1119da7da1d913d1c4d2b7c461115433a', // WMON
+    },
+    XLAYER: {
+        router: '0x881fb2f98c13d521009464e7d1cbf16e1b394e8e', // PotatoSwap V2
+        wrappedNative: '0xe538905cf8410324e03a5a23c1c177a474d59b2b', // WOKB
+    },
+};
 /**
  * 截断小数位数，避免超过代币精度导致 parseUnits 报错
  * 例如：truncateDecimals("21906.025000000000000000", 1) => "21906.0"
@@ -504,6 +523,52 @@ async function getGasPrice(provider, config) {
 function isNativeToken(quoteToken) {
     return !quoteToken || quoteToken === ZERO_ADDRESS;
 }
+/**
+ * ✅ 获取 ERC20 代币 → 原生代币的报价
+ * 用于将 ERC20 利润转换为原生代币（和 core.ts 逻辑一致）
+ * @param provider - Provider 实例
+ * @param tokenAddress - ERC20 代币地址
+ * @param tokenAmount - 代币数量（wei）
+ * @param chain - 链名称
+ * @returns 等值的原生代币数量（wei），失败返回 0n
+ */
+async function getTokenToNativeQuote(provider, tokenAddress, tokenAmount, chain) {
+    if (tokenAmount <= 0n)
+        return 0n;
+    const chainUpper = chain.toUpperCase();
+    const config = QUOTE_CONFIG[chainUpper];
+    if (!config) {
+        console.warn(`[getTokenToNativeQuote] 不支持的链: ${chain}`);
+        return 0n;
+    }
+    try {
+        const router = new Contract(config.router, QUOTE_ROUTER_ABI, provider);
+        const amounts = await router.getAmountsOut(tokenAmount, [tokenAddress, config.wrappedNative]);
+        const nativeAmount = amounts[1];
+        console.log(`[getTokenToNativeQuote] ${ethers.formatEther(tokenAmount)} Token → ${ethers.formatEther(nativeAmount)} Native`);
+        return nativeAmount;
+    }
+    catch (error) {
+        console.warn(`[getTokenToNativeQuote] 报价失败，跳过利润提取:`, error);
+        return 0n; // 报价失败返回 0（可能是流动性不足或路径不存在）
+    }
+}
+/**
+ * ✅ 找到金额最大的钱包索引（和 core.ts 逻辑一致）
+ */
+function findMaxFlowIndex(amounts) {
+    if (amounts.length === 0)
+        return 0;
+    let maxIndex = 0;
+    let maxValue = amounts[0];
+    for (let i = 1; i < amounts.length; i++) {
+        if (amounts[i] > maxValue) {
+            maxValue = amounts[i];
+            maxIndex = i;
+        }
+    }
+    return maxIndex;
+}
 /** 计算利润金额 */
 function calculateProfitAmount(totalFlowWei) {
     return (totalFlowWei * BigInt(PROFIT_CONFIG.RATE_BPS)) / 10000n;
@@ -602,98 +667,61 @@ export async function directV2BatchBuy(params) {
     const routerIface = useSwapRouter02
         ? new ethers.Interface(SWAP_ROUTER02_V2_ABI)
         : new ethers.Interface(V2_ROUTER_ABI);
-    const signedTxs = [];
-    let totalFlowWei = 0n;
-    for (let i = 0; i < wallets.length; i++) {
-        const wallet = wallets[i];
-        const amountWei = ethers.parseUnits(buyAmounts[i], quoteTokenDecimals);
-        totalFlowWei += amountWei;
-        let txData;
-        let txValue;
+    // ✅ 优化：预先计算所有金额（同步操作）
+    const flowAmounts = buyAmounts.map(amount => ethers.parseUnits(amount, quoteTokenDecimals));
+    const totalFlowWei = flowAmounts.reduce((sum, amt) => sum + amt, 0n);
+    // ✅ 优化：构建未签名交易的辅助函数
+    const buildTxData = (wallet, amountWei) => {
         if (useDYORSwap) {
-            // ✅ DYORSwap: 使用手动编码的 calldata
-            // 
-            // 根据成功交易分析，买入流程:
-            // 1. refundETH - 用于退还多余的 ETH (使用固定的 ETHBack_Dividend 地址)
-            // 2. swapExactTokensForTokens - 执行交换
             const DYORSWAP_FACTORY = DIRECT_ROUTERS.XLAYER.DYORSWAP_FACTORY;
             const multicallData = [];
-            // 1. refundETH(fee) - 使用固定的 ETHBack_Dividend 地址
-            // fee = 30 (0x1e) 是成功交易中使用的值
-            const refundData = encodeDYORRefundETH(30);
-            multicallData.push(refundData);
-            // 2. swapExactTokensForTokens
-            // 参数: amountIn, amountOutMin, path, pools, to, flag, factory
-            const swapData = encodeDYORSwapExactTokensForTokens(useNative ? 0n : amountWei, // amountIn: ETH 买入时为 0
-            0n, // amountOutMin
-            path, // path: [WOKB, token]
-            [], // pools (不使用)
-            wallet.address, // to = 用户地址
-            1n, // flag = 1
-            DYORSWAP_FACTORY // factory
-            );
-            multicallData.push(swapData);
-            // 使用 multicall(uint256 deadline, bytes[])
-            txData = encodeDYORMulticall(BigInt(deadline), multicallData);
-            txValue = useNative ? amountWei : 0n;
+            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
+            };
         }
         else if (useSwapRouter02) {
-            // ✅ SwapRouter02: 使用 multicall(deadline, bytes[]) 组合调用
-            // ABI 中没有 swapExactETHForTokens，只有 swapExactTokensForTokens
-            if (useNative) {
-                // ETH -> 代币：直接用 swapExactTokensForTokens（参考之前成功的交易）
-                // 之前成功的交易只用了一个 swapExactTokensForTokens，没有 wrapETH
-                // SwapRouter02 会自动处理 msg.value 的 ETH
-                const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
-                    amountWei,
-                    0n, // amountOutMin
-                    path, // path: [WETH, ..., tokenOut]
-                    wallet.address, // to
-                ]);
-                // 使用 multicall(uint256 deadline, bytes[]) - 带 deadline 的版本
-                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
-                    deadline,
-                    [swapData],
-                ]);
-                txValue = amountWei;
-            }
-            else {
-                // 代币 -> 代币：也用 multicall 包装
-                const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
-                    amountWei,
-                    0n, // amountOutMin
-                    path,
-                    wallet.address, // to
-                ]);
-                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
-                    deadline,
-                    [swapData],
-                ]);
-                txValue = 0n;
-            }
-        }
-        else if (useNative) {
-            // 传统 V2 Router: 原生币 → Token
-            txData = routerIface.encodeFunctionData('swapExactETHForTokensSupportingFeeOnTransferTokens', [
-                0n, // amountOutMin
+            const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
+                amountWei,
+                0n,
                 path,
                 wallet.address,
-                deadline,
             ]);
-            txValue = amountWei;
+            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
+            };
         }
         else {
-            // 传统 V2 Router: ERC20 → Token (需要先授权)
-            txData = routerIface.encodeFunctionData('swapExactTokensForTokensSupportingFeeOnTransferTokens', [
-                amountWei,
-                0n, // amountOutMin
-                path,
-                wallet.address,
-                deadline,
-            ]);
-            txValue = 0n;
+            return {
+                txData: routerIface.encodeFunctionData('swapExactTokensForTokensSupportingFeeOnTransferTokens', [
+                    amountWei,
+                    0n,
+                    path,
+                    wallet.address,
+                    deadline,
+                ]),
+                txValue: 0n
+            };
         }
-        const tx = {
+    };
+    // ✅ 优化：并行签名所有交易
+    const signedTxs = await Promise.all(wallets.map(async (wallet, i) => {
+        const { txData, txValue } = buildTxData(wallet, flowAmounts[i]);
+        return wallet.signTransaction({
             to: routerAddress,
             data: txData,
             value: txValue,
@@ -702,15 +730,26 @@ export async function directV2BatchBuy(params) {
             gasPrice,
             chainId,
             type: txType,
-        };
-        const signedTx = await wallet.signTransaction(tx);
-        signedTxs.push(signedTx);
+        });
+    }));
+    // ✅ 优化：选择金额最大的钱包支付利润（和 core.ts 逻辑一致）
+    const maxFlowIndex = findMaxFlowIndex(flowAmounts);
+    let profitWei = calculateProfitAmount(totalFlowWei);
+    // ✅ 修复：ERC20 交易时，将利润转换为原生代币
+    if (!useNative && profitWei > 0n && quoteToken) {
+        const nativeProfitWei = await getTokenToNativeQuote(provider, quoteToken, profitWei, chain);
+        if (nativeProfitWei > 0n) {
+            profitWei = nativeProfitWei;
+            console.log(`[V2 Buy] ERC20 利润转换: ${ethers.formatEther(calculateProfitAmount(totalFlowWei))} Token → ${ethers.formatEther(profitWei)} Native`);
+        }
+        else {
+            console.log(`[V2 Buy] ERC20 利润报价失败，跳过利润提取`);
+            profitWei = 0n; // 报价失败，跳过利润
+        }
     }
-    // 生成利润交易（使用第一个钱包支付）
-    const profitWei = calculateProfitAmount(totalFlowWei);
     if (profitWei > 0n) {
-        const profitNonce = nonces[0] + 1; // 第一个钱包的下一个 nonce
-        const profitTx = await buildProfitTransaction(wallets[0], profitWei, profitNonce, gasPrice, chainId, txType);
+        const profitNonce = nonces[maxFlowIndex] + 1; // ✅ 使用金额最大的钱包
+        const profitTx = await buildProfitTransaction(wallets[maxFlowIndex], profitWei, profitNonce, gasPrice, chainId, txType);
         signedTxs.push(profitTx);
     }
     return {
@@ -783,163 +822,129 @@ export async function directV2BatchSell(params) {
         ? new ethers.Interface(SWAP_ROUTER02_V2_ABI)
         : new ethers.Interface(V2_ROUTER_ABI);
     const approveIface = new ethers.Interface(ERC20_ABI);
-    const signedTxs = [];
-    let totalOutputEstimate = 0n;
-    let currentNonceOffset = new Array(wallets.length).fill(0);
-    // 检查授权并构建交易
-    for (let i = 0; i < wallets.length; i++) {
-        const wallet = wallets[i];
-        const sellAmount = sellAmountsWei[i];
-        if (sellAmount <= 0n)
-            continue;
-        // 检查授权
-        if (!config.skipApprovalCheck) {
-            const allowance = await tokenContract.allowance(wallet.address, routerAddress);
-            if (allowance < sellAmount) {
-                // 需要授权
-                const approveTx = {
-                    to: tokenAddress,
-                    data: approveIface.encodeFunctionData('approve', [routerAddress, ethers.MaxUint256]),
-                    value: 0n,
-                    nonce: nonces[i] + currentNonceOffset[i],
-                    gasLimit: 60000n,
-                    gasPrice,
-                    chainId,
-                    type: txType,
-                };
-                signedTxs.push(await wallet.signTransaction(approveTx));
-                currentNonceOffset[i]++;
-            }
-        }
-        // 卖出交易
-        let txData;
+    // ✅ 优化：构建卖出交易数据的辅助函数（同步）
+    const buildSellTxData = (wallet, sellAmount) => {
         if (useDYORSwap) {
-            // ✅ DYORSwap: 使用手动编码的 calldata
-            // 
-            // 卖出流程 (根据成功交易分析):
-            // 1. swapExactTokensForTokens - 代币换成 WOKB，发到 address(2) = Router
-            // 2. unwrapWETH9 - 将 WOKB 解包为 OKB 发给用户
             const DYORSWAP_FACTORY = DIRECT_ROUTERS.XLAYER.DYORSWAP_FACTORY;
-            const ADDRESS_THIS = 2n; // address(2) 作为 uint256
+            const ADDRESS_THIS = 2n;
             const multicallData = [];
-            // 1. swapExactTokensForTokens
-            // 参数: amountIn, amountOutMin, path, pools, to, flag, factory
-            const swapData = encodeDYORSwapExactTokensForTokens(sellAmount, // amountIn
-            0n, // amountOutMin
-            path, // path: [token, WOKB]
-            [DYORSWAP_FACTORY], // pools
-            ADDRESS_THIS, // to = address(2) - 让 Router 接收 WOKB
-            1n, // flag = 1
-            DYORSWAP_FACTORY // factory
-            );
-            multicallData.push(swapData);
+            multicallData.push(encodeDYORSwapExactTokensForTokens(sellAmount, 0n, path, [DYORSWAP_FACTORY], ADDRESS_THIS, 1n, DYORSWAP_FACTORY));
             if (useNativeOutput) {
-                // 2. unwrapWETH9 - 将 WOKB 解包为 OKB 发给用户
-                const unwrapData = encodeDYORUnwrapWETH9(0n, // amountMinimum = 0
-                wallet.address, // recipient = 用户
-                '0x' // pools = 空 bytes
-                );
-                multicallData.push(unwrapData);
+                multicallData.push(encodeDYORUnwrapWETH9(0n, wallet.address, '0x'));
             }
-            // 使用 multicall(uint256 deadline, bytes[])
-            txData = encodeDYORMulticall(BigInt(deadline), multicallData);
+            return encodeDYORMulticall(BigInt(deadline), multicallData);
         }
         else if (useSwapRouter02) {
-            // ✅ SwapRouter02: 使用 multicall(deadline, bytes[]) 组合调用
-            // 
-            // 重要：SwapRouter02 的 V2 swapExactTokensForTokens 直接把代币发给 to 地址
-            // 如果需要 ETH，把 WETH 发给 Router，然后调用 unwrapWETH9
-            // 
-            // 根据合约源码，address(2) = ADDRESS_THIS = Router 合约自己
             const ADDRESS_THIS = '0x0000000000000000000000000000000000000002';
             if (useNativeOutput) {
-                // 代币 -> ETH：
-                // 方案1：swapExactTokensForTokens(to=Router) + unwrapWETH9
-                // 方案2：直接发 WETH 给用户（用户需要手动 unwrap）
-                // 
-                // 使用方案1：发送到 Router 地址（真实地址，不是 address(2)）
-                const routerRealAddress = routerAddress; // SwapRouter02 的真实地址
-                const multicallData = [];
-                // 1. swapExactTokensForTokens - 从用户转代币，换成 WETH 发到 Router 真实地址
-                const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
-                    sellAmount,
-                    0n, // amountOutMin
-                    path, // path: [token, ..., WETH]
-                    ADDRESS_THIS, // to = address(2)，让 Router 接收 WETH
-                ]);
-                multicallData.push(swapData);
-                // 2. unwrapWETH9 - 将 Router 中的 WETH 解包为 ETH 发送给用户
-                const unwrapData = routerIface.encodeFunctionData('unwrapWETH9(uint256,address)', [
-                    0n, // amountMinimum = 0，接受任意数量
-                    wallet.address, // recipient = 用户
-                ]);
-                multicallData.push(unwrapData);
-                // 使用 multicall(uint256 deadline, bytes[]) - 带 deadline 的版本
-                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
-                    deadline,
-                    multicallData,
-                ]);
+                const multicallData = [
+                    routerIface.encodeFunctionData('swapExactTokensForTokens', [sellAmount, 0n, path, ADDRESS_THIS]),
+                    routerIface.encodeFunctionData('unwrapWETH9(uint256,address)', [0n, wallet.address]),
+                ];
+                return routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, multicallData]);
             }
             else {
-                // 代币 -> 代币：直接 swapExactTokensForTokens
-                const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [
-                    sellAmount,
-                    0n, // amountOutMin
-                    path,
-                    wallet.address, // to = 用户
-                ]);
-                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [
-                    deadline,
-                    [swapData],
-                ]);
+                const swapData = routerIface.encodeFunctionData('swapExactTokensForTokens', [sellAmount, 0n, path, wallet.address]);
+                return routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [swapData]]);
             }
         }
         else if (useNativeOutput) {
-            txData = routerIface.encodeFunctionData('swapExactTokensForETHSupportingFeeOnTransferTokens', [
-                sellAmount,
-                0n,
-                path,
-                wallet.address,
-                deadline,
-            ]);
+            return routerIface.encodeFunctionData('swapExactTokensForETHSupportingFeeOnTransferTokens', [sellAmount, 0n, path, wallet.address, deadline]);
         }
         else {
-            txData = routerIface.encodeFunctionData('swapExactTokensForTokensSupportingFeeOnTransferTokens', [
-                sellAmount,
-                0n,
-                path,
-                wallet.address,
-                deadline,
-            ]);
+            return routerIface.encodeFunctionData('swapExactTokensForTokensSupportingFeeOnTransferTokens', [sellAmount, 0n, path, wallet.address, deadline]);
         }
-        const sellTx = {
+    };
+    // ✅ 优化：并行检查所有授权
+    let allowances = [];
+    if (!config.skipApprovalCheck) {
+        allowances = await Promise.all(wallets.map(w => tokenContract.allowance(w.address, routerAddress)));
+    }
+    // ✅ 优化：计算每个钱包的 nonce 偏移（是否需要授权）
+    const currentNonceOffset = wallets.map((_, i) => {
+        if (config.skipApprovalCheck)
+            return 0;
+        return allowances[i] < sellAmountsWei[i] ? 1 : 0;
+    });
+    // ✅ 优化：并行签名所有授权交易
+    const approvalTxPromises = wallets.map(async (wallet, i) => {
+        if (config.skipApprovalCheck || sellAmountsWei[i] <= 0n)
+            return null;
+        if (allowances[i] >= sellAmountsWei[i])
+            return null;
+        return wallet.signTransaction({
+            to: tokenAddress,
+            data: approveIface.encodeFunctionData('approve', [routerAddress, ethers.MaxUint256]),
+            value: 0n,
+            nonce: nonces[i],
+            gasLimit: 60000n,
+            gasPrice,
+            chainId,
+            type: txType,
+        });
+    });
+    const approvalTxResults = await Promise.all(approvalTxPromises);
+    // ✅ 优化：并行签名所有卖出交易
+    const sellTxPromises = wallets.map(async (wallet, i) => {
+        if (sellAmountsWei[i] <= 0n)
+            return null;
+        return wallet.signTransaction({
             to: routerAddress,
-            data: txData,
+            data: buildSellTxData(wallet, sellAmountsWei[i]),
             value: 0n,
             nonce: nonces[i] + currentNonceOffset[i],
             gasLimit,
             gasPrice,
             chainId,
             type: txType,
-        };
-        signedTxs.push(await wallet.signTransaction(sellTx));
-        currentNonceOffset[i]++;
-        // 估算输出（用于计算利润）
+        });
+    });
+    const sellTxResults = await Promise.all(sellTxPromises);
+    // ✅ 优化：并行获取所有报价
+    const router = new Contract(routerAddress, V2_ROUTER_ABI, provider);
+    const quotePromises = wallets.map(async (_, i) => {
+        if (sellAmountsWei[i] <= 0n)
+            return sellAmountsWei[i];
         try {
-            const router = new Contract(routerAddress, V2_ROUTER_ABI, provider);
-            const amounts = await router.getAmountsOut(sellAmount, path);
-            totalOutputEstimate += amounts[amounts.length - 1];
+            const amounts = await router.getAmountsOut(sellAmountsWei[i], path);
+            return amounts[amounts.length - 1];
         }
         catch {
-            // 报价失败，使用 sellAmount 作为估算
-            totalOutputEstimate += sellAmount;
+            return sellAmountsWei[i];
+        }
+    });
+    const outputEstimates = await Promise.all(quotePromises);
+    // ✅ 按顺序组装签名交易：先授权，后卖出
+    const signedTxs = [];
+    for (let i = 0; i < wallets.length; i++) {
+        const approvalTx = approvalTxResults[i];
+        const sellTx = sellTxResults[i];
+        if (approvalTx)
+            signedTxs.push(approvalTx);
+        if (sellTx) {
+            signedTxs.push(sellTx);
+            currentNonceOffset[i]++; // 更新 offset 供利润交易使用
+        }
+    }
+    const totalOutputEstimate = outputEstimates.reduce((sum, o) => sum + o, 0n);
+    // ✅ 优化：选择输出最大的钱包支付利润（和 core.ts 逻辑一致）
+    const maxOutputIndex = findMaxFlowIndex(outputEstimates);
+    let profitWei = calculateProfitAmount(totalOutputEstimate);
+    // ✅ 修复：ERC20 输出时，将利润转换为原生代币
+    if (!useNativeOutput && profitWei > 0n && quoteToken) {
+        const nativeProfitWei = await getTokenToNativeQuote(provider, quoteToken, profitWei, chain);
+        if (nativeProfitWei > 0n) {
+            profitWei = nativeProfitWei;
+            console.log(`[V2 Sell] ERC20 利润转换: ${ethers.formatEther(calculateProfitAmount(totalOutputEstimate))} Token → ${ethers.formatEther(profitWei)} Native`);
+        }
+        else {
+            console.log(`[V2 Sell] ERC20 利润报价失败，跳过利润提取`);
+            profitWei = 0n;
         }
     }
-    // 生成利润交易
-    const profitWei = calculateProfitAmount(totalOutputEstimate);
     if (profitWei > 0n && wallets.length > 0) {
-        // 使用第一个有足够余额的钱包支付利润
-        const profitTx = await buildProfitTransaction(wallets[0], profitWei, nonces[0] + currentNonceOffset[0], gasPrice, chainId, txType);
+        const profitTx = await buildProfitTransaction(wallets[maxOutputIndex], // ✅ 使用输出最大的钱包
+        profitWei, nonces[maxOutputIndex] + currentNonceOffset[maxOutputIndex], gasPrice, chainId, txType);
         signedTxs.push(profitTx);
     }
     return {
@@ -982,41 +987,36 @@ export async function directV3BatchBuy(params) {
     const txType = config.txType ?? 0;
     const routerIface = new ethers.Interface(routerAbi);
     const inputToken = useNative ? wrappedNative : quoteToken;
-    const signedTxs = [];
-    let totalFlowWei = 0n;
     const deadline = getDeadline();
-    for (let i = 0; i < wallets.length; i++) {
-        const wallet = wallets[i];
-        const amountWei = ethers.parseUnits(buyAmounts[i], quoteTokenDecimals);
-        totalFlowWei += amountWei;
-        let txData;
-        let txValue;
+    // ✅ 优化：预先计算所有金额
+    const flowAmounts = buyAmounts.map(amount => ethers.parseUnits(amount, quoteTokenDecimals));
+    const totalFlowWei = flowAmounts.reduce((sum, amt) => sum + amt, 0n);
+    // ✅ 优化：构建交易数据的辅助函数
+    const buildV3BuyTxData = (wallet, amountWei) => {
         if (useLegacyRouter) {
-            // ✅ 旧版 SwapRouter: exactInputSingle 包含 deadline
             const swapParams = {
                 tokenIn: inputToken,
                 tokenOut: tokenAddress,
                 fee: fee,
                 recipient: wallet.address,
-                deadline: deadline, // ✅ 旧版在 struct 内部
+                deadline: deadline,
                 amountIn: amountWei,
-                amountOutMinimum: 0n, // 设为 0，依赖 MEV 保护
+                amountOutMinimum: 0n,
                 sqrtPriceLimitX96: 0n,
             };
             if (useNative) {
-                // 旧版 multicall 不带 deadline
                 const swapData = routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
                 const refundData = routerIface.encodeFunctionData('refundETH', []);
-                txData = routerIface.encodeFunctionData('multicall(bytes[])', [[swapData, refundData]]);
-                txValue = amountWei;
+                return {
+                    txData: routerIface.encodeFunctionData('multicall(bytes[])', [[swapData, refundData]]),
+                    txValue: amountWei
+                };
             }
             else {
-                txData = routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
-                txValue = 0n;
+                return { txData: routerIface.encodeFunctionData('exactInputSingle', [swapParams]), txValue: 0n };
             }
         }
         else {
-            // ✅ SwapRouter02: exactInputSingle 不含 deadline
             const swapParams = {
                 tokenIn: inputToken,
                 tokenOut: tokenAddress,
@@ -1027,18 +1027,22 @@ export async function directV3BatchBuy(params) {
                 sqrtPriceLimitX96: 0n,
             };
             if (useNative) {
-                // SwapRouter02 的 multicall 带 deadline
                 const swapData = routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
                 const refundData = routerIface.encodeFunctionData('refundETH', []);
-                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [swapData, refundData]]);
-                txValue = amountWei;
+                return {
+                    txData: routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [swapData, refundData]]),
+                    txValue: amountWei
+                };
             }
             else {
-                txData = routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
-                txValue = 0n;
+                return { txData: routerIface.encodeFunctionData('exactInputSingle', [swapParams]), txValue: 0n };
             }
         }
-        const tx = {
+    };
+    // ✅ 优化：并行签名所有交易
+    const signedTxs = await Promise.all(wallets.map(async (wallet, i) => {
+        const { txData, txValue } = buildV3BuyTxData(wallet, flowAmounts[i]);
+        return wallet.signTransaction({
             to: routerAddress,
             data: txData,
             value: txValue,
@@ -1047,13 +1051,26 @@ export async function directV3BatchBuy(params) {
             gasPrice,
             chainId,
             type: txType,
-        };
-        signedTxs.push(await wallet.signTransaction(tx));
+        });
+    }));
+    // ✅ 优化：选择金额最大的钱包支付利润
+    const maxFlowIndex = findMaxFlowIndex(flowAmounts);
+    let profitWei = calculateProfitAmount(totalFlowWei);
+    // ✅ 修复：ERC20 交易时，将利润转换为原生代币
+    if (!useNative && profitWei > 0n && quoteToken) {
+        const nativeProfitWei = await getTokenToNativeQuote(provider, quoteToken, profitWei, chain);
+        if (nativeProfitWei > 0n) {
+            profitWei = nativeProfitWei;
+            console.log(`[V3 Buy] ERC20 利润转换: ${ethers.formatEther(calculateProfitAmount(totalFlowWei))} Token → ${ethers.formatEther(profitWei)} Native`);
+        }
+        else {
+            console.log(`[V3 Buy] ERC20 利润报价失败，跳过利润提取`);
+            profitWei = 0n;
+        }
     }
-    // 利润交易
-    const profitWei = calculateProfitAmount(totalFlowWei);
     if (profitWei > 0n) {
-        const profitTx = await buildProfitTransaction(wallets[0], profitWei, nonces[0] + 1, gasPrice, chainId, txType);
+        const profitTx = await buildProfitTransaction(wallets[maxFlowIndex], // ✅ 使用金额最大的钱包
+        profitWei, nonces[maxFlowIndex] + 1, gasPrice, chainId, txType);
         signedTxs.push(profitTx);
     }
     return {
@@ -1108,58 +1125,30 @@ export async function directV3BatchSell(params) {
     const routerIface = new ethers.Interface(routerAbi);
     const approveIface = new ethers.Interface(ERC20_ABI);
     const outputToken = useNativeOutput ? wrappedNative : quoteToken;
-    const signedTxs = [];
-    let totalOutputEstimate = 0n;
-    const currentNonceOffset = new Array(wallets.length).fill(0);
     const deadline = getDeadline();
-    for (let i = 0; i < wallets.length; i++) {
-        const wallet = wallets[i];
-        const sellAmount = sellAmountsWei[i];
-        if (sellAmount <= 0n)
-            continue;
-        // 检查授权
-        if (!config.skipApprovalCheck) {
-            const allowance = await tokenContract.allowance(wallet.address, routerAddress);
-            if (allowance < sellAmount) {
-                const approveTx = {
-                    to: tokenAddress,
-                    data: approveIface.encodeFunctionData('approve', [routerAddress, ethers.MaxUint256]),
-                    value: 0n,
-                    nonce: nonces[i] + currentNonceOffset[i],
-                    gasLimit: 60000n,
-                    gasPrice,
-                    chainId,
-                    type: txType,
-                };
-                signedTxs.push(await wallet.signTransaction(approveTx));
-                currentNonceOffset[i]++;
-            }
-        }
-        let txData;
+    // ✅ 优化：构建卖出交易数据的辅助函数
+    const buildV3SellTxData = (wallet, sellAmount) => {
         if (useLegacyRouter) {
-            // ✅ 旧版 SwapRouter: exactInputSingle 包含 deadline
             const swapParams = {
                 tokenIn: tokenAddress,
                 tokenOut: outputToken,
                 fee: fee,
                 recipient: useNativeOutput ? routerAddress : wallet.address,
-                deadline: deadline, // ✅ 旧版在 struct 内部
+                deadline: deadline,
                 amountIn: sellAmount,
-                amountOutMinimum: 0n, // 设为 0，依赖 MEV 保护
+                amountOutMinimum: 0n,
                 sqrtPriceLimitX96: 0n,
             };
             if (useNativeOutput) {
-                // 旧版 multicall 不带 deadline
                 const swapData = routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
                 const unwrapData = routerIface.encodeFunctionData('unwrapWETH9', [0n, wallet.address]);
-                txData = routerIface.encodeFunctionData('multicall(bytes[])', [[swapData, unwrapData]]);
+                return routerIface.encodeFunctionData('multicall(bytes[])', [[swapData, unwrapData]]);
             }
             else {
-                txData = routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
+                return routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
             }
         }
         else {
-            // ✅ SwapRouter02: exactInputSingle 不含 deadline
             const swapParams = {
                 tokenIn: tokenAddress,
                 tokenOut: outputToken,
@@ -1170,34 +1159,96 @@ export async function directV3BatchSell(params) {
                 sqrtPriceLimitX96: 0n,
             };
             if (useNativeOutput) {
-                // SwapRouter02 的 multicall 带 deadline
                 const swapData = routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
                 const unwrapData = routerIface.encodeFunctionData('unwrapWETH9', [0n, wallet.address]);
-                txData = routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [swapData, unwrapData]]);
+                return routerIface.encodeFunctionData('multicall(uint256,bytes[])', [deadline, [swapData, unwrapData]]);
             }
             else {
-                txData = routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
+                return routerIface.encodeFunctionData('exactInputSingle', [swapParams]);
             }
         }
-        const sellTx = {
+    };
+    // ✅ 优化：并行检查所有授权
+    let allowances = [];
+    if (!config.skipApprovalCheck) {
+        allowances = await Promise.all(wallets.map(w => tokenContract.allowance(w.address, routerAddress)));
+    }
+    // ✅ 优化：计算每个钱包的 nonce 偏移
+    const currentNonceOffset = wallets.map((_, i) => {
+        if (config.skipApprovalCheck || sellAmountsWei[i] <= 0n)
+            return 0;
+        return allowances[i] < sellAmountsWei[i] ? 1 : 0;
+    });
+    // ✅ 优化：并行签名所有授权交易
+    const approvalTxPromises = wallets.map(async (wallet, i) => {
+        if (config.skipApprovalCheck || sellAmountsWei[i] <= 0n)
+            return null;
+        if (allowances[i] >= sellAmountsWei[i])
+            return null;
+        return wallet.signTransaction({
+            to: tokenAddress,
+            data: approveIface.encodeFunctionData('approve', [routerAddress, ethers.MaxUint256]),
+            value: 0n,
+            nonce: nonces[i],
+            gasLimit: 60000n,
+            gasPrice,
+            chainId,
+            type: txType,
+        });
+    });
+    const approvalTxResults = await Promise.all(approvalTxPromises);
+    // ✅ 优化：并行签名所有卖出交易
+    const sellTxPromises = wallets.map(async (wallet, i) => {
+        if (sellAmountsWei[i] <= 0n)
+            return null;
+        return wallet.signTransaction({
             to: routerAddress,
-            data: txData,
+            data: buildV3SellTxData(wallet, sellAmountsWei[i]),
             value: 0n,
             nonce: nonces[i] + currentNonceOffset[i],
             gasLimit,
             gasPrice,
             chainId,
             type: txType,
-        };
-        signedTxs.push(await wallet.signTransaction(sellTx));
-        currentNonceOffset[i]++;
-        // 估算输出
-        totalOutputEstimate += sellAmount; // 简化处理，实际可调用 QuoterV2
+        });
+    });
+    const sellTxResults = await Promise.all(sellTxPromises);
+    // ✅ 按顺序组装签名交易：先授权，后卖出
+    const signedTxs = [];
+    const outputEstimates = [];
+    for (let i = 0; i < wallets.length; i++) {
+        const approvalTx = approvalTxResults[i];
+        const sellTx = sellTxResults[i];
+        if (approvalTx)
+            signedTxs.push(approvalTx);
+        if (sellTx) {
+            signedTxs.push(sellTx);
+            outputEstimates.push(sellAmountsWei[i]);
+            currentNonceOffset[i]++;
+        }
+        else {
+            outputEstimates.push(0n);
+        }
+    }
+    const totalOutputEstimate = outputEstimates.reduce((sum, o) => sum + o, 0n);
+    // ✅ 优化：选择输出最大的钱包支付利润
+    const maxOutputIndex = findMaxFlowIndex(outputEstimates);
+    let profitWei = calculateProfitAmount(totalOutputEstimate);
+    // ✅ 修复：ERC20 输出时，将利润转换为原生代币
+    if (!useNativeOutput && profitWei > 0n && quoteToken) {
+        const nativeProfitWei = await getTokenToNativeQuote(provider, quoteToken, profitWei, chain);
+        if (nativeProfitWei > 0n) {
+            profitWei = nativeProfitWei;
+            console.log(`[V3 Sell] ERC20 利润转换: ${ethers.formatEther(calculateProfitAmount(totalOutputEstimate))} Token → ${ethers.formatEther(profitWei)} Native`);
+        }
+        else {
+            console.log(`[V3 Sell] ERC20 利润报价失败，跳过利润提取`);
+            profitWei = 0n;
+        }
     }
-    // 利润交易
-    const profitWei = calculateProfitAmount(totalOutputEstimate);
     if (profitWei > 0n && wallets.length > 0) {
-        const profitTx = await buildProfitTransaction(wallets[0], profitWei, nonces[0] + currentNonceOffset[0], gasPrice, chainId, txType);
+        const profitTx = await buildProfitTransaction(wallets[maxOutputIndex], // ✅ 使用输出最大的钱包
+        profitWei, nonces[maxOutputIndex] + currentNonceOffset[maxOutputIndex], gasPrice, chainId, txType);
         signedTxs.push(profitTx);
     }
     return {