four-flap-meme-sdk 1.8.3 → 1.8.4

package/dist/chains/bsc/four/utils.js

@@ -1,6 +1,6 @@
 import { ethers, Wallet } from 'ethers';
 import { getOptimizedGasPrice, NonceManager, buildProfitHopTransactions, PROFIT_HOP_COUNT } from '../../../utils/bundle-helpers.js';
-import { PROFIT_CONFIG, ZERO_ADDRESS, BLOCKRAZOR_BUILDER_EOA } from '../../../utils/constants.js';
+import { BLOCKRAZOR_BUILDER_EOA, calculateTransferFee } from '../../../utils/constants.js';
 import { GAS_LIMITS, CHAINS } from '../../../shared/constants/index.js';
 import { getTxType, getGasPriceConfig, shouldExtractProfit, getProfitRecipient, getBribeAmount } from './config.js';
 // ==================== Gas 常量（使用统一常量） ====================
@@ -9,211 +9,14 @@ const ERC20_TRANSFER_GAS_LIMIT = GAS_LIMITS.ERC20_TRANSFER;
 const BRIBE_GAS_LIMIT = GAS_LIMITS.BRIBE;
 const PROFIT_HOP_GAS_LIMIT = GAS_LIMITS.NATIVE_TRANSFER; // 利润多跳使用 NATIVE_TRANSFER
 import { getErc20DecimalsMerkle as _getErc20DecimalsMerkle, generateHopWallets as _generateHopWallets, normalizeAmounts as _normalizeAmounts, batchGetBalances as _batchGetBalances, calculateGasLimit as _calculateGasLimit, isNativeTokenAddress as _isNativeTokenAddress } from './internal.js';
-/**
- * 根据用户类型获取利润费率（bps）
- * - v0: 万分之6 (6 bps = 0.06%)
- * - v1: 万分之5 (5 bps = 0.05%)
- */
-function getProfitRateBps(userType) {
-    if (userType === 'v1')
-        return PROFIT_CONFIG.RATE_BPS_V1_DOUBLE; // v1 用户：万分之5
-    return PROFIT_CONFIG.RATE_BPS_V0_DOUBLE; // v0 用户（默认）：万分之6
-}
-/**
- * 计算利润金额
- * ✅ 归集和分散专用：根据 userType 使用不同费率
- */
-function calculateProfit(amount, userType) {
-    const rateBps = getProfitRateBps(userType);
-    const profit = (amount * BigInt(rateBps)) / 10000n;
-    const remaining = amount - profit;
-    return { profit, remaining };
-}
-// ==================== ERC20 → 原生代币报价 ====================
-import { quote, QUOTE_CONFIG } from '../../../utils/quote-helpers.js';
-import { Helper3 } from '../../../contracts/helper3.js';
-import { FlapPortal } from '../../../shared/flap/portal.js';
-/** ✅ 不设置最低利润阈值，报价是多少就是多少 */
-/** 链 ID → 链名称 映射 */
-const CHAIN_ID_TO_NAME = {
-    56: 'BSC',
-    143: 'MONAD',
-    196: 'XLAYER',
-};
-/** 各链的稳定币地址 */
-const STABLE_COINS = {
-    BSC: {
-        usdt: '0x55d398326f99059fF775485246999027B3197955',
-        usdc: '0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d',
-    },
-    MONAD: {
-    // TODO: 添加 Monad 链的稳定币地址
-    },
-    XLAYER: {
-        usdt: '0x1E4a5963aBFD975d8c9021ce480b42188849D41d',
-    },
-};
-/**
- * 获取 FOUR 内盘代币 → BNB 的报价
- */
-async function getFourInnerQuote(rpcUrl, tokenAddress, tokenAmount) {
-    try {
-        const helper = Helper3.connectByChain('BSC', rpcUrl);
-        const result = await helper.trySell(tokenAddress, tokenAmount);
-        // result = { tokenManager, quote, funds, fee }
-        // funds 是卖出代币能获得的 BNB 数量
-        const funds = result.funds;
-        console.log(`[getFourInnerQuote] FOUR 内盘报价成功: ${funds} wei`);
-        return funds;
-    }
-    catch (error) {
-        console.warn(`[getFourInnerQuote] FOUR 内盘报价失败:`, error);
-        return 0n;
-    }
-}
-// ✅ ZERO_ADDRESS 从公共模块导入
-/**
- * 获取 FLAP 内盘代币 → 原生代币的报价
- * ✅ 与 portal-bundle-merkle/core.ts 使用相同的 quoteExactInput 方法
- */
-async function getFlapInnerQuote(rpcUrl, chainId, tokenAddress, tokenAmount) {
-    try {
-        // 根据链 ID 确定链名称
-        const chainName = chainId === CHAINS.BSC.chainId ? 'BSC'
-            : chainId === CHAINS.MONAD.chainId ? 'MONAD'
-                : chainId === CHAINS.XLAYER.chainId ? 'XLAYER'
-                    : null;
-        if (!chainName) {
-            console.warn(`[getFlapInnerQuote] 不支持的链 ID: ${chainId}`);
-            return 0n;
-        }
-        const portal = new FlapPortal({ chain: chainName, rpcUrl });
-        // ✅ 使用 quoteExactInput 与 core.ts 保持一致
-        const funds = await portal.quoteExactInput({
-            inputToken: tokenAddress,
-            outputToken: ZERO_ADDRESS, // 输出原生代币
-            inputAmount: tokenAmount
-        });
-        console.log(`[getFlapInnerQuote] FLAP 内盘报价成功: ${funds} wei`);
-        return funds;
-    }
-    catch (error) {
-        console.warn(`[getFlapInnerQuote] FLAP 内盘报价失败:`, error);
-        return 0n;
-    }
-}
-/**
- * 获取 ERC20 代币 → 原生代币的报价
- *
- * @param provider - Provider 实例
- * @param tokenAddress - ERC20 代币地址
- * @param tokenAmount - 代币数量（wei）
- * @param chainId - 链 ID（56=BSC, 143=Monad）
- * @param poolType - 池子类型：'flap'/'four' 内盘，'v2'/'v3' 外盘
- * @param quoteToken - 报价代币：'native'（BNB/MON），'usdt'，'usdc'
- * @param rpcUrl - RPC URL（内盘报价需要）
- * @returns 等值的原生代币数量（wei），失败返回 0n
- */
-async function getTokenToNativeQuote(provider, tokenAddress, tokenAmount, chainId, poolType = 'v2', quoteToken = 'native', rpcUrl) {
-    if (tokenAmount <= 0n)
-        return 0n;
-    // ✅ FOUR 内盘：通过 Helper3.trySell 获取真实报价
-    if (poolType === 'four') {
-        const url = rpcUrl || provider._getConnection?.()?.url || '';
-        if (!url) {
-            console.warn(`[getTokenToNativeQuote] FOUR 内盘需要 rpcUrl，报价失败`);
-            return 0n;
-        }
-        const funds = await getFourInnerQuote(url, tokenAddress, tokenAmount);
-        return funds > 0n ? funds : 0n;
-    }
-    // ✅ FLAP 内盘：通过 FlapPortal.previewSell 获取真实报价
-    if (poolType === 'flap') {
-        const url = rpcUrl || provider._getConnection?.()?.url || '';
-        if (!url) {
-            console.warn(`[getTokenToNativeQuote] FLAP 内盘需要 rpcUrl，报价失败`);
-            return 0n;
-        }
-        const funds = await getFlapInnerQuote(url, chainId, tokenAddress, tokenAmount);
-        return funds > 0n ? funds : 0n;
-    }
-    const chainName = CHAIN_ID_TO_NAME[chainId];
-    if (!chainName) {
-        console.warn(`[getTokenToNativeQuote] 不支持的链 ID: ${chainId}，报价失败`);
-        return 0n;
-    }
-    const chainConfig = QUOTE_CONFIG[chainName];
-    if (!chainConfig) {
-        console.warn(`[getTokenToNativeQuote] 不支持的链: ${chainName}，报价失败`);
-        return 0n;
-    }
-    try {
-        const version = poolType === 'v3' ? 'v3' : 'v2';
-        let nativeAmount = 0n;
-        if (quoteToken === 'native') {
-            // ✅ 直接路径：TOKEN → WBNB
-            console.log(`[getTokenToNativeQuote] 使用 ${version} 直接路径报价 (TOKEN → WBNB)`);
-            const result = await quote({
-                provider,
-                tokenIn: tokenAddress,
-                tokenOut: chainConfig.wrappedNative,
-                amountIn: tokenAmount,
-                chain: chainName,
-                version
-            });
-            nativeAmount = result.amountOut;
-        }
-        else {
-            // ✅ 稳定币路径：TOKEN → USDT/USDC → WBNB（两步报价）
-            const stableCoins = STABLE_COINS[chainName];
-            const stableCoinAddress = stableCoins?.[quoteToken];
-            if (!stableCoinAddress) {
-                console.warn(`[getTokenToNativeQuote] 链 ${chainName} 不支持 ${quoteToken}，报价失败`);
-                return 0n;
-            }
-            console.log(`[getTokenToNativeQuote] 使用 ${version} 稳定币路径报价 (TOKEN → ${quoteToken.toUpperCase()} → WBNB)`);
-            // 第一步：TOKEN → USDT/USDC
-            const step1 = await quote({
-                provider,
-                tokenIn: tokenAddress,
-                tokenOut: stableCoinAddress,
-                amountIn: tokenAmount,
-                chain: chainName,
-                version
-            });
-            if (step1.amountOut <= 0n) {
-                console.warn(`[getTokenToNativeQuote] TOKEN → ${quoteToken.toUpperCase()} 报价失败`);
-                return 0n;
-            }
-            // 第二步：USDT/USDC → WBNB
-            const step2 = await quote({
-                provider,
-                tokenIn: stableCoinAddress,
-                tokenOut: chainConfig.wrappedNative,
-                amountIn: step1.amountOut,
-                chain: chainName,
-                version
-            });
-            nativeAmount = step2.amountOut;
-        }
-        if (nativeAmount > 0n) {
-            console.log(`[getTokenToNativeQuote] 报价成功: ${nativeAmount} wei`);
-            return nativeAmount;
-        }
-    }
-    catch (error) {
-        console.warn(`[getTokenToNativeQuote] 报价失败:`, error);
-    }
-    // 报价失败，返回 0
-    return 0n;
-}
+// ==================== 钱包转账按地址收费 ====================
 /**
  * 分发（仅签名版本 - 不依赖 Merkle）
  * ✅ 精简版：只负责签名交易，不提交到 Merkle
  * ✅ 优化版：支持 startNonce 参数避免并行调用时的 nonce 冲突
  */
 export async function disperseWithBundleMerkle(params) {
-    const { fromPrivateKey, recipients, amount, amounts, tokenAddress, tokenDecimals, hopCount = 0, hopPrivateKeys, items, config, startNonce, tokenPoolType = 'v2', quoteToken = 'native', userType = 'v0' } = params;
+    const { fromPrivateKey, recipients, amount, amounts, tokenAddress, tokenDecimals, hopCount = 0, hopPrivateKeys, items, config, startNonce } = params;
     // 快速返回空结果
     if (!recipients || recipients.length === 0) {
         return {
@@ -297,17 +100,15 @@ export async function disperseWithBundleMerkle(params) {
             console.log(`[disperse] 贿赂交易已添加: ${ethers.formatEther(bribeAmount)} BNB`);
         }
         if (isNative) {
-            // ✅ 原生币：先计算所有金额和利润（同步），再并行签名
+            // ✅ 原生币：按地址数量收取固定费用，全额转账
+            if (extractProfit) {
+                totalProfit = calculateTransferFee(chainIdNum, recipients.length);
+                console.log(`[disperse Native] 按地址收费: ${recipients.length} 个地址 × ${ethers.formatEther(calculateTransferFee(chainIdNum, 1))} = ${ethers.formatEther(totalProfit)} 原生币`);
+            }
             const txDataList = recipients.map((to, i) => {
                 const originalAmount = ethers.parseEther(normalizedAmounts[i]);
                 totalAmountBeforeProfit += originalAmount;
-                let actualAmount = originalAmount;
-                if (extractProfit) {
-                    const { profit, remaining } = calculateProfit(originalAmount, userType);
-                    actualAmount = remaining;
-                    totalProfit += profit;
-                }
-                return { to, value: actualAmount, nonce: nonces[nonceOffset + i] };
+                return { to, value: originalAmount, nonce: nonces[nonceOffset + i] };
             });
             // ✅ 并行签名所有交易
             const txPromises = txDataList.map(({ to, value, nonce }) => mainWallet.signTransaction({
@@ -341,46 +142,24 @@ export async function disperseWithBundleMerkle(params) {
             // ✅ ERC20：并行获取 decimals（传入 chainIdNum 避免 NETWORK_ERROR）
             const decimals = tokenDecimals ?? (await _getErc20DecimalsMerkle(provider, tokenAddress, chainIdNum));
             const iface = new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
-            // ✅ 先计算所有原始金额和预估 ERC20 利润
-            let totalTokenProfit = 0n;
+            // ✅ 先计算所有原始金额
             const originalAmounts = [];
             for (let i = 0; i < recipients.length; i++) {
                 const originalAmount = ethers.parseUnits(normalizedAmounts[i], decimals);
                 originalAmounts.push(originalAmount);
                 totalAmountBeforeProfit += originalAmount;
-                if (extractProfit) {
-                    const { profit } = calculateProfit(originalAmount, userType);
-                    totalTokenProfit += profit; // 累计 ERC20 代币利润（用于报价）
-                }
             }
-            // ✅ 获取 ERC20 利润等值的原生代币（OKB/BNB）报价
+            // ✅ 按地址数量收取固定费用（原生代币）
             let nativeProfitAmount = 0n;
-            let profitIsNative = false; // 标记利润是否以原生代币扣除
-            if (extractProfit && totalTokenProfit > 0n) {
-                nativeProfitAmount = await getTokenToNativeQuote(provider, tokenAddress, totalTokenProfit, chainIdNum, tokenPoolType, quoteToken, config.rpcUrl);
-                // ✅ 判断报价是否成功（> 0n 即可，不设最低阈值）
-                profitIsNative = nativeProfitAmount > 0n;
-                if (profitIsNative) {
-                    totalProfit = nativeProfitAmount;
-                    console.log(`[disperse ERC20] 报价成功，以原生代币扣除利润: ${ethers.formatEther(nativeProfitAmount)} 原生币`);
-                }
-                else {
-                    console.log(`[disperse ERC20] 报价失败，以 ERC20 扣除利润: ${ethers.formatUnits(totalTokenProfit, decimals)} Token`);
-                }
+            if (extractProfit) {
+                nativeProfitAmount = calculateTransferFee(chainIdNum, recipients.length);
+                totalProfit = nativeProfitAmount;
+                console.log(`[disperse ERC20] 按地址收费: ${recipients.length} 个地址 × ${ethers.formatEther(calculateTransferFee(chainIdNum, 1))} = ${ethers.formatEther(nativeProfitAmount)} 原生币`);
             }
-            // ✅ 根据报价结果决定分发金额
-            // 报价成功：全额分发 ERC20，只扣 OKB
-            // 报价失败：扣 ERC20 利润
+            // ✅ ERC20 全额分发，费用以原生币单独支付
             const txDataList = recipients.map((to, i) => {
                 const originalAmount = originalAmounts[i];
-                let actualAmount = originalAmount;
-                if (extractProfit && !profitIsNative) {
-                    // 报价失败：从 ERC20 中扣除利润
-                    const { remaining } = calculateProfit(originalAmount, userType);
-                    actualAmount = remaining;
-                }
-                // 报价成功：全额分发 ERC20（不扣 ERC20）
-                const data = iface.encodeFunctionData('transfer', [to, actualAmount]);
+                const data = iface.encodeFunctionData('transfer', [to, originalAmount]);
                 return { data, nonce: nonces[nonceOffset + i] };
             });
             // ✅ 并行签名所有交易
@@ -395,8 +174,8 @@ export async function disperseWithBundleMerkle(params) {
                 type: txType
             }));
             signedTxs.push(...(await Promise.all(txPromises)));
-            // ✅ 利润多跳转账（强制 2 跳中转）- 仅在报价成功时扣 OKB/BNB
-            if (extractProfit && profitIsNative && nativeProfitAmount > 0n) {
+            // ✅ 费用多跳转账（强制 2 跳中转）
+            if (extractProfit && nativeProfitAmount > 0n) {
                 const profitHopResult = await buildProfitHopTransactions({
                     provider,
                     payerWallet: mainWallet,
@@ -478,25 +257,18 @@ export async function disperseWithBundleMerkle(params) {
             console.log(`[disperse with hops] 贿赂交易已添加: ${ethers.formatEther(bribeAmountHop)} BNB`);
         }
         const txsToSign = [];
-        // ✅ ERC20 多跳：累计代币利润，最后统一转换为原生代币
-        let totalTokenProfit = 0n;
+        // ✅ 按地址数量收取固定费用（原生代币），不再扣除转账金额
+        if (extractProfit) {
+            totalProfit = calculateTransferFee(chainIdNum, recipients.length);
+            console.log(`[disperse with hops] 按地址收费: ${recipients.length} 个地址 × ${ethers.formatEther(calculateTransferFee(chainIdNum, 1))} = ${ethers.formatEther(totalProfit)} 原生币`);
+        }
         for (let i = 0; i < recipients.length; i++) {
             const finalRecipient = recipients[i];
             const originalAmountWei = isNative
                 ? ethers.parseEther(normalizedAmounts[i])
                 : ethers.parseUnits(normalizedAmounts[i], decimals);
             totalAmountBeforeProfit += originalAmountWei;
-            let amountWei = originalAmountWei;
-            if (extractProfit) {
-                const { profit, remaining } = calculateProfit(originalAmountWei, userType);
-                amountWei = remaining;
-                if (isNative) {
-                    totalProfit += profit; // 原生币直接累加
-                }
-                else {
-                    totalTokenProfit += profit; // ERC20 累计代币利润
-                }
-            }
+            const amountWei = originalAmountWei; // 全额转账
             const hopChain = preparedHops[i];
             if (hopChain.length === 0) {
                 // 无跳转：直接转账
@@ -662,11 +434,6 @@ export async function disperseWithBundleMerkle(params) {
                 }
             }
         }
-        // ✅ ERC20 多跳：获取代币利润等值的原生代币报价
-        if (!isNative && extractProfit && totalTokenProfit > 0n) {
-            const nativeProfitAmount = await getTokenToNativeQuote(provider, tokenAddress, totalTokenProfit, chainIdNum, tokenPoolType, quoteToken, config.rpcUrl);
-            totalProfit = nativeProfitAmount; // 更新为原生代币利润
-        }
         // ✅ 并行签名所有交易
         const signedTxsResult = await Promise.all(txsToSign.map(({ wallet, tx }) => wallet.signTransaction(tx)));
         signedTxs.push(...signedTxsResult);
@@ -709,7 +476,7 @@ export async function disperseWithBundleMerkle(params) {
  * ✅ 优化版：支持 startNonce 参数避免并行调用时的 nonce 冲突
  */
 export async function sweepWithBundleMerkle(params) {
-    const { sourcePrivateKeys, target, targetPrivateKey, ratioPct, ratios, amount, amounts, tokenAddress, tokenDecimals, skipIfInsufficient = true, hopCount = 0, hopPrivateKeys, sources, config, startNonce, tokenPoolType = 'v2', quoteToken = 'native', userType = 'v0' } = params;
+    const { sourcePrivateKeys, target, targetPrivateKey, ratioPct, ratios, amount, amounts, tokenAddress, tokenDecimals, skipIfInsufficient = true, hopCount = 0, hopPrivateKeys, sources, config, startNonce } = params;
     // 快速返回空结果
     if (!sourcePrivateKeys || sourcePrivateKeys.length === 0) {
         return {
@@ -860,29 +627,22 @@ export async function sweepWithBundleMerkle(params) {
                     maxSweepAmount = toSend;
                     maxSweepIndex = i;
                 }
-                // 累计总利润
-                if (extractProfit && toSend > 0n) {
-                    const { profit } = calculateProfit(toSend, userType);
-                    totalProfit += profit;
-                }
             }
-            // ✅ 如果需要提取利润，检查支付者是否有足够余额支付利润转账的额外 gas
+            // ✅ 按地址数量收取固定费用（原生代币）
+            const activeNativeAddressCount = sweepAmounts.filter(a => a > 0n).length;
+            if (extractProfit && activeNativeAddressCount > 0) {
+                totalProfit = calculateTransferFee(chainIdNum, activeNativeAddressCount);
+                console.log(`[sweep Native] 按地址收费: ${activeNativeAddressCount} 个地址 × ${ethers.formatEther(calculateTransferFee(chainIdNum, 1))} = ${ethers.formatEther(totalProfit)} 原生币`);
+            }
+            // ✅ 如果需要提取费用，检查支付者是否有足够余额
             if (extractProfit && totalProfit > 0n && maxSweepIndex >= 0) {
                 const payerBalance = balances[maxSweepIndex];
                 const payerSweepAmount = sweepAmounts[maxSweepIndex];
-                const payerNeedGas = gasCostBase + profitTxGas; // 支付者需要 2 笔交易的 gas
-                // 如果支付者余额不足以支付 2 笔交易的 gas，减少其归集金额
+                const payerNeedGas = gasCostBase + profitTxGas + totalProfit;
                 if (payerBalance < payerSweepAmount + payerNeedGas) {
                     const maxPayerSweep = payerBalance > payerNeedGas ? payerBalance - payerNeedGas : 0n;
                     sweepAmounts[maxSweepIndex] = maxPayerSweep;
-                    // 重新计算总金额和总利润
                     totalAmountBeforeProfit = sweepAmounts.reduce((sum, amt) => sum + amt, 0n);
-                    totalProfit = 0n;
-                    for (let i = 0; i < sweepAmounts.length; i++) {
-                        if (sweepAmounts[i] > 0n) {
-                            totalProfit += calculateProfit(sweepAmounts[i], userType).profit;
-                        }
-                    }
                 }
             }
             // ✅ 第二步：生成归集交易
@@ -915,17 +675,8 @@ export async function sweepWithBundleMerkle(params) {
                 const toSend = sweepAmounts[i];
                 if (toSend <= 0n)
                     return null;
-                let actualToSend = toSend;
-                if (extractProfit && !useTargetAsPayer) {
-                    // ✅ 如果由源钱包支付利润，支付者扣除所有利润总和；其他钱包不扣利润，归集干净
-                    if (i === maxSweepIndex && totalProfit > 0n) {
-                        actualToSend = toSend - totalProfit; // 支付者扣除所有利润总和
-                    }
-                    else {
-                        actualToSend = toSend; // 其他钱包不扣利润，归集全部
-                    }
-                }
-                // ✅ 如果由 targetWallet 支付利润，所有源钱包都归集全部金额
+                // ✅ 全额归集，费用由支付者额外支付原生代币
+                const actualToSend = toSend;
                 // ✅ 支付者使用预留的第一个 nonce，其他钱包使用批量获取的 nonce
                 let nonce;
                 if (!useTargetAsPayer && i === maxSweepIndex && payerProfitNonce !== undefined) {
@@ -1022,42 +773,37 @@ export async function sweepWithBundleMerkle(params) {
                     maxSweepAmount = toSend;
                     maxSweepIndex = i;
                 }
-                // 累计总代币利润（ERC20 归集）
-                if (extractProfit && toSend > 0n) {
-                    const { profit } = calculateProfit(toSend, userType);
-                    totalProfit += profit; // 先累计代币利润
-                }
             }
-            // ✅ ERC20 归集：获取代币利润等值的原生代币（BNB）报价
+            // ✅ 按地址数量收取固定费用（原生代币支付，不受转账金额影响）
+            const activeAddressCountErc20 = sweepAmounts.filter(a => a > 0n).length;
             let nativeProfitAmount = 0n;
-            if (extractProfit && totalProfit > 0n) {
-                nativeProfitAmount = await getTokenToNativeQuote(provider, tokenAddress, totalProfit, chainIdNum, tokenPoolType, quoteToken, config.rpcUrl);
+            if (extractProfit && activeAddressCountErc20 > 0) {
+                nativeProfitAmount = calculateTransferFee(chainIdNum, activeAddressCountErc20);
+                totalProfit = nativeProfitAmount;
+                console.log(`[sweep ERC20] 按地址收费: ${activeAddressCountErc20} 个地址 × ${ethers.formatEther(calculateTransferFee(chainIdNum, 1))} = ${ethers.formatEther(nativeProfitAmount)} 原生币`);
             }
-            // ✅ 确定利润支付者：优先使用 targetWallet，否则使用归集金额最大的源钱包
+            // ✅ 确定费用支付者：优先使用 targetWallet，否则使用归集金额最大的源钱包
             const useTargetAsPayerErc20 = targetWallet !== null;
             const profitPayerWalletErc20 = useTargetAsPayerErc20 ? targetWallet : (maxSweepIndex >= 0 ? wallets[maxSweepIndex] : null);
-            // ✅ 如果需要提取利润，检查支付者是否有足够 BNB 支付利润转账的额外 gas
+            // ✅ 如果需要提取费用，检查支付者是否有足够原生代币支付
             if (extractProfit && nativeProfitAmount > 0n && profitPayerWalletErc20 && config.checkBnbForErc20NoHop) {
                 const payerBnbBalance = useTargetAsPayerErc20
                     ? await provider.getBalance(target)
                     : (bnbBalances[maxSweepIndex] ?? 0n);
                 const payerNeedGas = (useTargetAsPayerErc20 ? 0n : finalGasLimit * gasPrice) + profitTxGas + nativeProfitAmount;
-                // 如果支付者 BNB 余额不足，跳过利润提取
                 if (payerBnbBalance < payerNeedGas) {
-                    nativeProfitAmount = 0n; // 跳过利润提取
+                    nativeProfitAmount = 0n;
+                    totalProfit = 0n;
                 }
             }
-            // ✅ 第二步：生成归集交易（ERC20 归集不扣除代币，利润从 BNB 支付）
-            // ✅ 修复 nonce 冲突：统一管理 targetWallet 的 nonce
+            // ✅ 第二步：生成归集交易（ERC20 全额归集，费用以原生币单独支付）
             let payerProfitNonce;
             if (extractProfit && nativeProfitAmount > 0n && profitPayerWalletErc20) {
                 if (useTargetAsPayerErc20 && targetWalletNonceStart !== undefined) {
-                    // ✅ targetWallet：使用统一管理的 nonce（贿赂交易已使用 targetWalletNonceUsed 个）
                     payerProfitNonce = targetWalletNonceStart + targetWalletNonceUsed;
-                    console.log(`[sweep ERC20] targetWallet 利润交易 nonce: ${payerProfitNonce} (起点=${targetWalletNonceStart}, 已用=${targetWalletNonceUsed})`);
+                    console.log(`[sweep ERC20] targetWallet 费用交易 nonce: ${payerProfitNonce} (起点=${targetWalletNonceStart}, 已用=${targetWalletNonceUsed})`);
                 }
                 else {
-                    // ✅ 源钱包支付利润：使用 NonceManager 获取 2 个 nonce（归集 + 利润）
                     const nonces = await nonceManager.getNextNonceBatch(profitPayerWalletErc20, 2);
                     payerProfitNonce = nonces[1];
                 }
@@ -1098,9 +844,8 @@ export async function sweepWithBundleMerkle(params) {
             });
             const allTxs = (await Promise.all(txPromises)).filter(tx => tx !== null);
             signedTxs.push(...allTxs);
-            // ✅ 第三步：利润多跳转账（强制 2 跳中转）- ERC20 利润转等值原生代币
+            // ✅ 第三步：费用多跳转账（强制 2 跳中转）
             if (extractProfit && nativeProfitAmount > 0n && profitPayerWalletErc20 && payerProfitNonce !== undefined) {
-                totalProfit = nativeProfitAmount; // 更新为原生代币利润
                 const profitHopResult = await buildProfitHopTransactions({
                     provider,
                     payerWallet: profitPayerWalletErc20,
@@ -1442,9 +1187,10 @@ export async function sweepWithBundleMerkle(params) {
             const hopSignedTxs = await Promise.all(hopTxsToSign.map(({ wallet, tx }) => wallet.signTransaction(tx)));
             signedTxs.push(...hopSignedTxs);
         }
-        // ========== 第7步：计算利润并添加利润转账 ==========
-        if (extractProfit && totalAmountBeforeProfit > 0n) {
-            // ✅ 确定利润支付者：优先使用 targetWallet，否则使用归集金额最大的源钱包
+        // ========== 第7步：按地址数量收取固定费用（原生代币） ==========
+        const activeHopAddressCount = sweepAmounts.filter(a => a > 0n).length;
+        if (extractProfit && activeHopAddressCount > 0) {
+            // ✅ 确定费用支付者：优先使用 targetWallet，否则使用归集金额最大的源钱包
             let maxSweepIndex = -1;
             let maxSweepAmount = 0n;
             for (let i = 0; i < sweepAmounts.length; i++) {
@@ -1455,37 +1201,19 @@ export async function sweepWithBundleMerkle(params) {
             }
             const useTargetAsPayerHop = targetWallet !== null;
             const profitPayerWalletHop = useTargetAsPayerHop ? targetWallet : (maxSweepIndex >= 0 ? sourceWallets[maxSweepIndex] : null);
-            // 计算总代币利润
-            let totalTokenProfit = 0n;
-            for (let i = 0; i < sweepAmounts.length; i++) {
-                if (sweepAmounts[i] > 0n) {
-                    const { profit } = calculateProfit(sweepAmounts[i], userType);
-                    if (isNative) {
-                        totalProfit += profit;
-                    }
-                    else {
-                        totalTokenProfit += profit;
-                    }
-                }
-            }
-            // ✅ ERC20：获取代币利润等值的原生代币报价
-            let nativeProfitAmount = isNative ? totalProfit : 0n;
-            if (!isNative && totalTokenProfit > 0n) {
-                nativeProfitAmount = await getTokenToNativeQuote(provider, tokenAddress, totalTokenProfit, chainIdNum, tokenPoolType, quoteToken, config.rpcUrl);
-                totalProfit = nativeProfitAmount;
-            }
-            // ✅ 利润多跳转账（强制 2 跳中转）
+            // ✅ 按地址数量收取固定费用
+            const nativeProfitAmount = calculateTransferFee(chainIdNum, activeHopAddressCount);
+            totalProfit = nativeProfitAmount;
+            console.log(`[sweep with hops] 按地址收费: ${activeHopAddressCount} 个地址 × ${ethers.formatEther(calculateTransferFee(chainIdNum, 1))} = ${ethers.formatEther(nativeProfitAmount)} 原生币`);
+            // ✅ 费用多跳转账（强制 2 跳中转）
             if (nativeProfitAmount > 0n && profitPayerWalletHop) {
-                // ✅ 修复 nonce 冲突：如果利润支付者是 targetWallet，使用统一管理的 nonce
                 let profitNonce;
                 if (useTargetAsPayerHop && targetWalletNonceStart !== undefined) {
-                    // targetWallet：使用统一管理的 nonce（贿赂交易已使用 targetWalletNonceUsed 个）
                     profitNonce = targetWalletNonceStart + targetWalletNonceUsed;
-                    targetWalletNonceUsed += 1; // ✅ 递增 nonce 计数
-                    console.log(`[sweep with hops] targetWallet 利润交易 nonce: ${profitNonce} (起点=${targetWalletNonceStart}, 已用=${targetWalletNonceUsed})`);
+                    targetWalletNonceUsed += 1;
+                    console.log(`[sweep with hops] targetWallet 费用交易 nonce: ${profitNonce} (起点=${targetWalletNonceStart}, 已用=${targetWalletNonceUsed})`);
                 }
                 else {
-                    // 源钱包支付利润：使用 NonceManager 获取 nonce
                     profitNonce = await nonceManager.getNextNonce(profitPayerWalletHop);
                 }
                 const profitHopResult = await buildProfitHopTransactions({
@@ -1500,7 +1228,7 @@ export async function sweepWithBundleMerkle(params) {
                     startNonce: profitNonce
                 });
                 signedTxs.push(...profitHopResult.signedTransactions);
-                profitHopWallets = profitHopResult.hopWallets; // ✅ 收集利润多跳钱包
+                profitHopWallets = profitHopResult.hopWallets;
             }
         }
     }
@@ -1528,7 +1256,7 @@ export async function sweepWithBundleMerkle(params) {
  * - 支持利润刮取：利润由第一个 sender 支付（作为额外费用，不扣减每对转账金额）
  */
 export async function pairwiseTransferWithBundleMerkle(params) {
-    const { senderPrivateKeys, receiverAddresses, amount, amounts, tokenAddress, tokenDecimals, hopCount = 0, hopPrivateKeys, config, startNonce, tokenPoolType = 'v2', quoteToken = 'native', userType = 'v0', } = params;
+    const { senderPrivateKeys, receiverAddresses, amount, amounts, tokenAddress, tokenDecimals, hopCount = 0, hopPrivateKeys, config, startNonce, } = params;
     if (!senderPrivateKeys || senderPrivateKeys.length === 0) {
         return { signedTransactions: [], hopWallets: undefined };
     }
@@ -1581,25 +1309,19 @@ export async function pairwiseTransferWithBundleMerkle(params) {
         isNative ? Promise.resolve(18) : Promise.resolve(tokenDecimals ?? await _getErc20DecimalsMerkle(provider, tokenAddress, chainIdNum))
     ]);
     const iface = isNative ? null : new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
-    // 利润：按每对金额计算，但由第一个 sender 支付（额外费用）
+    // ✅ 费用：按地址数量收取固定费用（原生代币），由第一个 sender 支付
     const extractProfit = shouldExtractProfit(config);
     let totalAmountBeforeProfit = 0n;
-    let totalTokenProfit = 0n;
     let totalProfitNative = 0n;
     const parsedAmountsWei = normalizedAmounts.map(v => {
         const amt = isNative ? ethers.parseEther(v) : ethers.parseUnits(v, decimals);
         totalAmountBeforeProfit += amt;
-        if (extractProfit && amt > 0n) {
-            const { profit } = calculateProfit(amt, userType);
-            if (isNative)
-                totalProfitNative += profit;
-            else
-                totalTokenProfit += profit;
-        }
         return amt;
     });
-    if (!isNative && extractProfit && totalTokenProfit > 0n) {
-        totalProfitNative = await getTokenToNativeQuote(provider, tokenAddress, totalTokenProfit, chainIdNum, tokenPoolType, quoteToken, config.rpcUrl);
+    // ✅ 按地址数量收取固定费用
+    if (extractProfit && pairCount > 0) {
+        totalProfitNative = calculateTransferFee(chainIdNum, pairCount);
+        console.log(`[pairwise] 按地址收费: ${pairCount} 个地址 × ${ethers.formatEther(calculateTransferFee(chainIdNum, 1))} = ${ethers.formatEther(totalProfitNative)} 原生币`);
     }
     // ✅ BSC 链贿赂支持（由第一个 sender 支付）
     const bribeAmount = chainIdNum === CHAINS.BSC.chainId ? getBribeAmount(config) : 0n;