four-flap-meme-sdk 2.2.8 → 2.2.10

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

@@ -1,8 +1,1503 @@
+import { ethers, Wallet } from 'ethers';
+import { getOptimizedGasPrice, NonceManager, buildProfitHopTransactions, PROFIT_HOP_COUNT, buildGasFields } from '../../utils/bundle-helpers.js';
+import { BLOCKRAZOR_BUILDER_EOA, calculateTransferFee } from '../../utils/constants.js';
+import { getTxType, getGasPriceConfig, shouldExtractProfit, getProfitRecipient, getBribeAmount } from './config.js';
+import { getErc20DecimalsMerkle as _getErc20DecimalsMerkle, generateHopWallets as _generateHopWallets, normalizeAmounts as _normalizeAmounts, batchGetBalances as _batchGetBalances, calculateGasLimit as _calculateGasLimit, isNativeTokenAddress as _isNativeTokenAddress } from './internal.js';
+// ==================== 钱包转账按地址收费 ====================
 /**
- * TokenManager Merkle 钱包工具（disperse / sweep / pairwise）
- *
- * 实现按域拆至 `utils-disperse.ts`、`utils-sweep.ts`、`utils-pairwise.ts`；本文件仅再导出，保持 `from './utils.js'` 与历史路径兼容。
+ * 分发（仅签名版本 - 不依赖 Merkle）
+ * ✅ 精简版：只负责签名交易，不提交到 Merkle
+ * ✅ 优化版：支持 startNonce 参数避免并行调用时的 nonce 冲突
  */
-export { disperseWithBundleMerkle } from './utils-disperse.js';
-export { sweepWithBundleMerkle } from './utils-sweep.js';
-export { pairwiseTransferWithBundleMerkle } from './utils-pairwise.js';
+export async function disperseWithBundleMerkle(params) {
+    const { fromPrivateKey, recipients, amount, amounts, tokenAddress, tokenDecimals, hopCount = 0, hopPrivateKeys, items, config, startNonce } = params;
+    // 快速返回空结果
+    if (!recipients || recipients.length === 0) {
+        return {
+            signedTransactions: [],
+            hopWallets: undefined
+        };
+    }
+    // 初始化
+    const chainIdNum = config.chainId ?? 56;
+    const chainName = chainIdNum === 143 ? 'Monad' : chainIdNum === 56 ? 'BSC' : `Chain-${chainIdNum}`;
+    const provider = new ethers.JsonRpcProvider(config.rpcUrl, {
+        chainId: chainIdNum,
+        name: chainName
+    });
+    const mainWallet = new Wallet(fromPrivateKey, provider);
+    const isNative = _isNativeTokenAddress(tokenAddress);
+    const txType = getTxType(config);
+    // ✅ 优化：预处理数据（不需要 RPC）
+    const normalizedAmounts = items && items.length > 0
+        ? items.map(it => (typeof it.amount === 'bigint' ? it.amount.toString() : String(it.amount)))
+        : _normalizeAmounts(recipients, amount, amounts);
+    const providedHops = (() => {
+        if (hopPrivateKeys && hopPrivateKeys.length > 0) {
+            if (hopPrivateKeys.length !== recipients.length) {
+                throw new Error(`hopPrivateKeys length (${hopPrivateKeys.length}) must match recipients length (${recipients.length})`);
+            }
+            return hopPrivateKeys.every(h => h.length === 0) ? null : hopPrivateKeys;
+        }
+        if (items && items.length > 0) {
+            const hops = items.map(it => it.hopPrivateKeys ?? []);
+            return hops.every(h => h.length === 0) ? null : hops;
+        }
+        return null;
+    })();
+    const hopCountInput = (() => {
+        if (items && items.length > 0) {
+            const baseArray = Array.isArray(hopCount) ? hopCount : new Array(recipients.length).fill(hopCount);
+            return items.map((it, i) => (typeof it.hopCount === 'number' ? it.hopCount : (baseArray[i] ?? 0)));
+        }
+        return hopCount;
+    })();
+    const preparedHops = providedHops ?? _generateHopWallets(recipients.length, hopCountInput);
+    const hasHops = preparedHops !== null;
+    const maxHopCount = hasHops ? Math.max(...preparedHops.map(h => h.length)) : 0;
+    const finalGasLimit = _calculateGasLimit(config, isNative, hasHops, maxHopCount);
+    const nativeGasLimit = (config.prefer21000ForNative ?? false) ? 21000n : finalGasLimit;
+    const signedTxs = [];
+    const extractProfit = shouldExtractProfit(config);
+    const profitAddr = getProfitRecipient();
+    let totalProfit = 0n;
+    let totalAmountBeforeProfit = 0n;
+    let profitHopWallets; // ✅ 收集利润多跳钱包
+    // ✅ 优化：并行获取 gasPrice 和 nonces（或使用传入的 startNonce）
+    const nonceManager = new NonceManager(provider);
+    if (!preparedHops) {
+        // ========== 无多跳：直接批量转账 ==========
+        // ✅ BSC 链贿赂支持
+        const bribeAmount = chainIdNum === 56 ? getBribeAmount(config) : 0n;
+        const needBribeTx = bribeAmount > 0n;
+        const extraTxCount = (extractProfit ? 1 : 0) + (needBribeTx ? 1 : 0);
+        const totalTxCount = recipients.length + extraTxCount;
+        // ✅ 优化：并行获取 gasPrice 和 nonces
+        const [gasPrice, nonces] = await Promise.all([
+            getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+            startNonce !== undefined
+                ? Promise.resolve(Array.from({ length: totalTxCount }, (_, i) => startNonce + i))
+                : nonceManager.getNextNonceBatch(mainWallet, totalTxCount)
+        ]);
+        // ✅ 贿赂交易放在最前面
+        let nonceOffset = 0;
+        if (needBribeTx) {
+            const bribeTx = await mainWallet.signTransaction({
+                to: BLOCKRAZOR_BUILDER_EOA,
+                value: bribeAmount,
+                nonce: nonces[nonceOffset++],
+                gasPrice,
+                gasLimit: 21000n,
+                chainId: chainIdNum,
+                type: txType
+            });
+            signedTxs.push(bribeTx);
+            console.log(`[disperse] 贿赂交易已添加: ${ethers.formatEther(bribeAmount)} BNB`);
+        }
+        // ✅ 按地址数量收取固定费用（不受转账金额和中转次数影响）
+        if (extractProfit) {
+            totalProfit = calculateTransferFee(chainIdNum, recipients.length);
+            console.log(`[disperse] 按地址收费: ${recipients.length} 个地址 × ${ethers.formatEther(calculateTransferFee(chainIdNum, 1))} = ${ethers.formatEther(totalProfit)} 原生币`);
+        }
+        if (isNative) {
+            // ✅ 原生币：全额转账（不扣利润），再并行签名
+            const txDataList = recipients.map((to, i) => {
+                const originalAmount = ethers.parseEther(normalizedAmounts[i]);
+                totalAmountBeforeProfit += originalAmount;
+                return { to, value: originalAmount, nonce: nonces[nonceOffset + i] };
+            });
+            // ✅ 并行签名所有交易
+            const txPromises = txDataList.map(({ to, value, nonce }) => mainWallet.signTransaction({
+                to,
+                value,
+                nonce,
+                gasPrice,
+                gasLimit: nativeGasLimit,
+                chainId: chainIdNum,
+                type: txType
+            }));
+            signedTxs.push(...(await Promise.all(txPromises)));
+        }
+        else {
+            // ✅ ERC20：全额转账（费用以原生币单独收取）
+            const decimals = tokenDecimals ?? (await _getErc20DecimalsMerkle(provider, tokenAddress, chainIdNum));
+            const iface = new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
+            const txDataList = recipients.map((to, i) => {
+                const originalAmount = ethers.parseUnits(normalizedAmounts[i], decimals);
+                totalAmountBeforeProfit += originalAmount;
+                const data = iface.encodeFunctionData('transfer', [to, originalAmount]);
+                return { data, nonce: nonces[nonceOffset + i] };
+            });
+            // ✅ 并行签名所有交易
+            const txPromises = txDataList.map(({ data, nonce }) => mainWallet.signTransaction({
+                to: tokenAddress,
+                data,
+                value: 0n,
+                nonce,
+                gasPrice,
+                gasLimit: finalGasLimit,
+                chainId: chainIdNum,
+                type: txType
+            }));
+            signedTxs.push(...(await Promise.all(txPromises)));
+        }
+        // ✅ 费用多跳转账（强制 2 跳中转）
+        if (extractProfit && totalProfit > 0n) {
+            const profitHopResult = await buildProfitHopTransactions({
+                provider,
+                payerWallet: mainWallet,
+                profitAmount: totalProfit,
+                profitRecipient: profitAddr,
+                hopCount: PROFIT_HOP_COUNT,
+                gasPrice,
+                chainId: chainIdNum,
+                txType,
+                startNonce: nonces[nonceOffset + recipients.length]
+            });
+            signedTxs.push(...profitHopResult.signedTransactions);
+            profitHopWallets = profitHopResult.hopWallets;
+        }
+    }
+    else {
+        // ========== 有多跳：构建跳转链 ==========
+        // ✅ BSC 链贿赂支持
+        const bribeAmountHop = chainIdNum === 56 ? getBribeAmount(config) : 0n;
+        const needBribeTxHop = bribeAmountHop > 0n;
+        // ✅ 优化：并行获取 gasPrice 和 decimals
+        const [gasPrice, decimals] = await Promise.all([
+            getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+            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)']);
+        // ✅ Gas limit 设置
+        // - 原生代币转账：21000（固定）
+        // - ERC20 转账：65000（固定，因为 gas 波动较大，不再使用模拟预估）
+        const nativeTransferGasLimit = 21000n;
+        const erc20TransferGasLimit = 65000n;
+        // ✅ 原生代币多跳的 gas 费（每跳只需要 21000）
+        const nativeHopGasFee = nativeTransferGasLimit * gasPrice;
+        // ✅ ERC20 多跳时，中转钱包需要执行 2 笔交易（转 gas + 转 ERC20）
+        const erc20HopGasFee = erc20TransferGasLimit * gasPrice;
+        const nativeHopGasFeeForErc20 = nativeTransferGasLimit * gasPrice;
+        // ✅ 优化：预先计算主钱包需要的总 nonce 数量
+        // - 原生代币多跳：主钱包只需要 1 个 nonce（一笔转账包含后续所有 gas）
+        // - ERC20 多跳：主钱包需要 2 个 nonce（转 gas + 转 ERC20）
+        let mainWalletNonceCount = 0;
+        // 贿赂交易需要 1 个额外的 nonce
+        if (needBribeTxHop)
+            mainWalletNonceCount += 1;
+        for (let i = 0; i < recipients.length; i++) {
+            const hopChain = preparedHops[i];
+            if (hopChain.length === 0) {
+                // 无跳转：1 个 nonce
+                mainWalletNonceCount += 1;
+            }
+            else {
+                // 有跳转：
+                // - Native: 1（一笔转账）
+                // - ERC20: 2（转 gas + 转 ERC20）
+                mainWalletNonceCount += isNative ? 1 : 2;
+            }
+        }
+        // 利润交易需要额外 1 个 nonce
+        if (extractProfit)
+            mainWalletNonceCount += 1;
+        // ✅ 一次性获取所有主钱包的 nonces
+        const allMainNonces = startNonce !== undefined
+            ? Array.from({ length: mainWalletNonceCount }, (_, i) => startNonce + i)
+            : await nonceManager.getNextNonceBatch(mainWallet, mainWalletNonceCount);
+        let mainNonceIdx = 0;
+        // ✅ 贿赂交易放在最前面（多跳场景）
+        if (needBribeTxHop) {
+            const bribeTx = await mainWallet.signTransaction({
+                to: BLOCKRAZOR_BUILDER_EOA,
+                value: bribeAmountHop,
+                nonce: allMainNonces[mainNonceIdx++],
+                gasPrice,
+                gasLimit: 21000n,
+                chainId: chainIdNum,
+                type: txType
+            });
+            signedTxs.push(bribeTx);
+            console.log(`[disperse with hops] 贿赂交易已添加: ${ethers.formatEther(bribeAmountHop)} BNB`);
+        }
+        const txsToSign = [];
+        // ✅ 按地址数量收取固定费用（不受转账金额和中转次数影响）
+        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;
+            const amountWei = originalAmountWei; // ✅ 全额转账，不扣利润
+            const hopChain = preparedHops[i];
+            if (hopChain.length === 0) {
+                // 无跳转：直接转账
+                const nonce = allMainNonces[mainNonceIdx++];
+                if (isNative) {
+                    txsToSign.push({
+                        wallet: mainWallet,
+                        tx: {
+                            to: finalRecipient,
+                            value: amountWei,
+                            nonce,
+                            gasPrice,
+                            gasLimit: nativeGasLimit,
+                            chainId: chainIdNum,
+                            type: txType
+                        }
+                    });
+                }
+                else {
+                    const data = iface.encodeFunctionData('transfer', [finalRecipient, amountWei]);
+                    txsToSign.push({
+                        wallet: mainWallet,
+                        tx: {
+                            to: tokenAddress,
+                            data,
+                            value: 0n,
+                            nonce,
+                            gasPrice,
+                            gasLimit: finalGasLimit,
+                            chainId: chainIdNum,
+                            type: txType
+                        }
+                    });
+                }
+                continue;
+            }
+            // 有跳转
+            // ✅ 支持 string 和 GeneratedWallet 两种类型
+            const fullChain = [mainWallet, ...hopChain.map(w => new Wallet(typeof w === 'string' ? w : w.privateKey, provider))];
+            const addresses = [...fullChain.map(w => w.address), finalRecipient];
+            if (isNative) {
+                // ========== 原生代币多跳：gas 包含在转账金额中逐层传递 ==========
+                for (let j = 0; j < addresses.length - 1; j++) {
+                    const fromWallet = fullChain[j];
+                    const toAddress = addresses[j + 1];
+                    const nonce = j === 0 ? allMainNonces[mainNonceIdx++] : 0;
+                    const remainingHops = addresses.length - 2 - j;
+                    const additionalGas = nativeHopGasFee * BigInt(remainingHops);
+                    const transferValue = amountWei + additionalGas;
+                    txsToSign.push({
+                        wallet: fromWallet,
+                        tx: {
+                            to: toAddress,
+                            value: transferValue,
+                            nonce,
+                            gasPrice,
+                            gasLimit: nativeTransferGasLimit,
+                            chainId: chainIdNum,
+                            type: txType
+                        }
+                    });
+                }
+            }
+            else {
+                // ========== ERC20 多跳：gas 也逐层传递（保护隐私）==========
+                // 计算每个中转钱包需要的 gas（从后往前）
+                // - 最后一个中转钱包：只需要 ERC20 转账的 gas
+                // - 其他中转钱包：需要 转 gas 的 gas + ERC20 转账的 gas + 后续所有的 gas
+                const hopGasNeeds = [];
+                for (let j = hopChain.length - 1; j >= 0; j--) {
+                    if (j === hopChain.length - 1) {
+                        // 最后一个中转钱包：只需要 ERC20 转账的 gas
+                        hopGasNeeds.unshift(erc20HopGasFee);
+                    }
+                    else {
+                        // 其他中转钱包：转 gas(21000) + 转 ERC20 + 后续的 gas
+                        const nextHopGas = hopGasNeeds[0];
+                        hopGasNeeds.unshift(nativeHopGasFeeForErc20 + erc20HopGasFee + nextHopGas);
+                    }
+                }
+                // 第一步：主钱包给第一个中转钱包转 gas（包含所有后续的 gas）
+                const totalGasForFirstHop = hopGasNeeds[0];
+                txsToSign.push({
+                    wallet: mainWallet,
+                    tx: {
+                        to: fullChain[1].address,
+                        value: totalGasForFirstHop,
+                        nonce: allMainNonces[mainNonceIdx++],
+                        gasPrice,
+                        gasLimit: nativeTransferGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    }
+                });
+                // 第二步：主钱包给第一个中转钱包转 ERC20
+                const mainToFirstHopData = iface.encodeFunctionData('transfer', [fullChain[1].address, amountWei]);
+                txsToSign.push({
+                    wallet: mainWallet,
+                    tx: {
+                        to: tokenAddress,
+                        data: mainToFirstHopData,
+                        value: 0n,
+                        nonce: allMainNonces[mainNonceIdx++],
+                        gasPrice,
+                        gasLimit: erc20TransferGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    }
+                });
+                // 第三步：中转钱包逐层传递（gas 和 ERC20）
+                for (let j = 1; j < fullChain.length; j++) {
+                    const fromWallet = fullChain[j];
+                    const toAddress = addresses[j + 1]; // 下一个地址（可能是中转钱包或最终接收者）
+                    const isLastHop = j === fullChain.length - 1;
+                    if (!isLastHop) {
+                        // 非最后一个中转钱包：先转 gas 给下一个中转钱包
+                        const gasToTransfer = hopGasNeeds[j]; // 下一个中转钱包需要的 gas
+                        txsToSign.push({
+                            wallet: fromWallet,
+                            tx: {
+                                to: toAddress,
+                                value: gasToTransfer,
+                                nonce: 0, // 中转钱包的第一笔交易
+                                gasPrice,
+                                gasLimit: nativeTransferGasLimit,
+                                chainId: chainIdNum,
+                                type: txType
+                            }
+                        });
+                        // 再转 ERC20
+                        const erc20Data = iface.encodeFunctionData('transfer', [toAddress, amountWei]);
+                        txsToSign.push({
+                            wallet: fromWallet,
+                            tx: {
+                                to: tokenAddress,
+                                data: erc20Data,
+                                value: 0n,
+                                nonce: 1, // 中转钱包的第二笔交易
+                                gasPrice,
+                                gasLimit: erc20TransferGasLimit,
+                                chainId: chainIdNum,
+                                type: txType
+                            }
+                        });
+                    }
+                    else {
+                        // 最后一个中转钱包：只转 ERC20 给最终接收者
+                        const erc20Data = iface.encodeFunctionData('transfer', [toAddress, amountWei]);
+                        txsToSign.push({
+                            wallet: fromWallet,
+                            tx: {
+                                to: tokenAddress,
+                                data: erc20Data,
+                                value: 0n,
+                                nonce: 0, // 最后一个中转钱包只有一笔交易
+                                gasPrice,
+                                gasLimit: erc20TransferGasLimit,
+                                chainId: chainIdNum,
+                                type: txType
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        // ✅ 并行签名所有交易
+        const signedTxsResult = await Promise.all(txsToSign.map(({ wallet, tx }) => wallet.signTransaction(tx)));
+        signedTxs.push(...signedTxsResult);
+        // ✅ 利润多跳转账（强制 2 跳中转）
+        if (extractProfit && totalProfit > 0n) {
+            const profitNonce = allMainNonces[mainNonceIdx++];
+            const profitHopResult = await buildProfitHopTransactions({
+                provider,
+                payerWallet: mainWallet,
+                profitAmount: totalProfit,
+                profitRecipient: profitAddr,
+                hopCount: PROFIT_HOP_COUNT,
+                gasPrice,
+                chainId: chainIdNum,
+                txType,
+                startNonce: profitNonce
+            });
+            signedTxs.push(...profitHopResult.signedTransactions);
+            profitHopWallets = profitHopResult.hopWallets; // ✅ 收集利润多跳钱包
+        }
+    }
+    // ✅ 简化返回：只返回签名交易、多跳钱包和元数据
+    return {
+        signedTransactions: signedTxs,
+        hopWallets: preparedHops || undefined,
+        profitHopWallets, // ✅ 返回利润多跳钱包
+        metadata: extractProfit ? {
+            totalAmount: ethers.formatEther(totalAmountBeforeProfit),
+            profitAmount: ethers.formatEther(totalProfit),
+            profitRecipient: profitAddr,
+            recipientCount: recipients.length,
+            isNative,
+            tokenAddress: isNative ? undefined : tokenAddress
+        } : undefined
+    };
+}
+/**
+ * 归集（仅签名版本 - 不依赖 Merkle）
+ * ✅ 精简版：只负责签名交易，不提交到 Merkle
+ * ✅ 优化版：支持 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 } = params;
+    // 快速返回空结果
+    if (!sourcePrivateKeys || sourcePrivateKeys.length === 0) {
+        return {
+            signedTransactions: [],
+            hopWallets: undefined
+        };
+    }
+    // 初始化
+    const chainIdNum = config.chainId ?? 56;
+    const chainName = chainIdNum === 143 ? 'Monad' : chainIdNum === 56 ? 'BSC' : `Chain-${chainIdNum}`;
+    const provider = new ethers.JsonRpcProvider(config.rpcUrl, {
+        chainId: chainIdNum,
+        name: chainName
+    });
+    const isNative = _isNativeTokenAddress(tokenAddress);
+    const txType = getTxType(config);
+    // ✅ 如果提供了 targetPrivateKey，创建 targetWallet 用于支付利润
+    const targetWallet = targetPrivateKey ? new Wallet(targetPrivateKey, provider) : null;
+    // 归集比例处理
+    const clamp = (n) => (typeof n === 'number' && Number.isFinite(n)
+        ? Math.max(0, Math.min(100, Math.floor(n)))
+        : undefined);
+    const ratio = clamp(ratioPct);
+    // 生成跳转钱包
+    // 统一 sources 输入
+    const actualKeys = (() => {
+        if (sources && sources.length > 0)
+            return sources.map(s => s.privateKey);
+        return sourcePrivateKeys;
+    })();
+    // hop 私钥链优先使用传入
+    const providedHops = (() => {
+        if (hopPrivateKeys && hopPrivateKeys.length > 0) {
+            if (hopPrivateKeys.length !== actualKeys.length) {
+                throw new Error(`hopPrivateKeys length (${hopPrivateKeys.length}) must match sourcePrivateKeys length (${actualKeys.length})`);
+            }
+            return hopPrivateKeys.every(h => h.length === 0) ? null : hopPrivateKeys;
+        }
+        if (sources && sources.length > 0) {
+            const hops = sources.map(s => s.hopPrivateKeys ?? []);
+            return hops.every(h => h.length === 0) ? null : hops;
+        }
+        return null;
+    })();
+    // hop 数量数组
+    const hopCountInput = (() => {
+        if (sources && sources.length > 0) {
+            const baseArray = Array.isArray(hopCount) ? hopCount : new Array(actualKeys.length).fill(hopCount);
+            return sources.map((s, i) => (typeof s.hopCount === 'number' ? s.hopCount : (baseArray[i] ?? 0)));
+        }
+        return hopCount;
+    })();
+    const preparedHops = providedHops ?? _generateHopWallets(actualKeys.length, hopCountInput);
+    const hasHops = preparedHops !== null;
+    const maxHopCount = hasHops ? Math.max(...preparedHops.map(h => h.length)) : 0;
+    // 智能计算 Gas Limit
+    const finalGasLimit = _calculateGasLimit(config, isNative, hasHops, maxHopCount);
+    const nativeGasLimit = (config.prefer21000ForNative ?? false) ? 21000n : finalGasLimit;
+    const signedTxs = [];
+    // ✅ 利润提取配置
+    const extractProfit = shouldExtractProfit(config);
+    const profitAddr = getProfitRecipient();
+    let totalProfit = 0n;
+    let totalAmountBeforeProfit = 0n;
+    let profitHopWallets; // ✅ 收集利润多跳钱包
+    // ✅ BSC 链贿赂支持（由 targetWallet 支付，如果提供了 targetPrivateKey）
+    const bribeAmount = chainIdNum === 56 ? getBribeAmount(config) : 0n;
+    const needBribeTx = bribeAmount > 0n && targetWallet !== null;
+    const bribeSignedTx = [];
+    // ✅ 贿赂交易放在最前面（由 targetWallet 签名）
+    if (needBribeTx && targetWallet) {
+        const [bribeGasPrice, bribeNonce] = await Promise.all([
+            getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+            provider.getTransactionCount(targetWallet.address)
+        ]);
+        const bribeTx = await targetWallet.signTransaction({
+            to: BLOCKRAZOR_BUILDER_EOA,
+            value: bribeAmount,
+            nonce: bribeNonce,
+            gasPrice: bribeGasPrice,
+            gasLimit: 21000n,
+            chainId: chainIdNum,
+            type: txType
+        });
+        bribeSignedTx.push(bribeTx);
+        console.log(`[sweep] 贿赂交易已添加: ${ethers.formatEther(bribeAmount)} BNB (by targetWallet)`);
+    }
+    if (!preparedHops) {
+        // ========== 无多跳：直接批量归集 ==========
+        const wallets = actualKeys.map(pk => new Wallet(pk, provider));
+        const addresses = wallets.map(w => w.address);
+        const nonceManager = new NonceManager(provider);
+        // ✅ 优化：并行获取 gasPrice 和余额
+        if (isNative) {
+            // ✅ 原生币：并行获取 gasPrice 和余额
+            const [gasPrice, balances] = await Promise.all([
+                getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+                _batchGetBalances(provider, addresses)
+            ]);
+            const gasCostBase = nativeGasLimit * gasPrice;
+            // ✅ 修复：利润多跳需要 PROFIT_HOP_COUNT + 1 笔交易的 gas（payer → hop1 → hop2 → 利润地址）
+            // ✅ 统一使用 21055n 作为利润多跳的 gas limit
+            const PROFIT_HOP_GAS_LIMIT = 21055n;
+            const profitTxGas = PROFIT_HOP_GAS_LIMIT * gasPrice * BigInt(PROFIT_HOP_COUNT + 1);
+            // ✅ 第一步：计算所有钱包的归集金额和利润，找出归集金额最大的钱包
+            const sweepAmounts = [];
+            let maxSweepIndex = -1;
+            let maxSweepAmount = 0n;
+            for (let i = 0; i < wallets.length; i++) {
+                const bal = balances[i];
+                let toSend = 0n;
+                const ratioForI = (() => {
+                    if (sources && sources[i] && sources[i].ratioPct !== undefined)
+                        return clamp(sources[i].ratioPct);
+                    if (ratios && ratios[i] !== undefined)
+                        return clamp(ratios[i]);
+                    return ratio;
+                })();
+                const amountStrForI = (() => {
+                    if (sources && sources[i] && sources[i].amount !== undefined)
+                        return String(sources[i].amount);
+                    if (amounts && amounts[i] !== undefined)
+                        return String(amounts[i]);
+                    return amount !== undefined ? String(amount) : undefined;
+                })();
+                // ✅ 只有支付者需要 2 笔交易的 gas，其他钱包只需要 1 笔
+                const gasCost = gasCostBase; // 所有钱包都只计算主转账的 gas
+                if (ratioForI !== undefined) {
+                    const want = (bal * BigInt(ratioForI)) / 100n;
+                    const maxSendable = bal > gasCost ? (bal - gasCost) : 0n;
+                    toSend = want > maxSendable ? maxSendable : want;
+                }
+                else if (amountStrForI && amountStrForI.trim().length > 0) {
+                    const amt = ethers.parseEther(amountStrForI);
+                    const need = amt + gasCost;
+                    if (!skipIfInsufficient || bal >= need)
+                        toSend = amt;
+                }
+                sweepAmounts.push(toSend);
+                totalAmountBeforeProfit += toSend;
+                // 找出归集金额最大的钱包
+                if (toSend > maxSweepAmount) {
+                    maxSweepAmount = toSend;
+                    maxSweepIndex = i;
+                }
+            }
+            // ✅ 按地址数量收取固定费用（不受转账金额和中转次数影响）
+            const activeAddressCount = sweepAmounts.filter(a => a > 0n).length;
+            if (extractProfit && activeAddressCount > 0) {
+                totalProfit = calculateTransferFee(chainIdNum, activeAddressCount);
+                console.log(`[sweep native] 按地址收费: ${activeAddressCount} 个地址 × ${ethers.formatEther(calculateTransferFee(chainIdNum, 1))} = ${ethers.formatEther(totalProfit)} 原生币`);
+            }
+            // ✅ 如果需要提取费用，检查支付者是否有足够余额支付费用转账的额外 gas
+            if (extractProfit && totalProfit > 0n && maxSweepIndex >= 0) {
+                const payerBalance = balances[maxSweepIndex];
+                const payerSweepAmount = sweepAmounts[maxSweepIndex];
+                const payerNeedGas = gasCostBase + profitTxGas; // 支付者需要 2 笔交易的 gas
+                // 如果支付者余额不足以支付 2 笔交易的 gas + 费用，减少其归集金额
+                if (payerBalance < payerSweepAmount + payerNeedGas + totalProfit) {
+                    const maxPayerSweep = payerBalance > (payerNeedGas + totalProfit) ? payerBalance - payerNeedGas - totalProfit : 0n;
+                    sweepAmounts[maxSweepIndex] = maxPayerSweep;
+                    totalAmountBeforeProfit = sweepAmounts.reduce((sum, amt) => sum + amt, 0n);
+                }
+            }
+            // ✅ 第二步：生成归集交易
+            // ✅ 确定利润支付者：优先使用 targetWallet，否则使用归集金额最大的源钱包
+            const useTargetAsPayer = targetWallet !== null;
+            const profitPayerWallet = useTargetAsPayer ? targetWallet : (maxSweepIndex >= 0 ? wallets[maxSweepIndex] : null);
+            // ✅ 先为支付者预留 nonce，确保 nonce 连续
+            let payerProfitNonce;
+            if (extractProfit && totalProfit > 0n && profitPayerWallet) {
+                const nonces = await nonceManager.getNextNonceBatch(profitPayerWallet, useTargetAsPayer ? 1 : 2);
+                payerProfitNonce = useTargetAsPayer ? nonces[0] : nonces[1]; // targetWallet 只需要 1 个 nonce
+            }
+            // ✅ 优化：批量获取所有钱包的 nonce（JSON-RPC 批量请求）
+            // 过滤出需要归集的钱包（如果用 targetWallet 支付利润，则不排除 maxSweepIndex）
+            const walletsToSweep = wallets.filter((_, i) => sweepAmounts[i] > 0n && (useTargetAsPayer || i !== maxSweepIndex));
+            const nonces = walletsToSweep.length > 0
+                ? await nonceManager.getNextNoncesForWallets(walletsToSweep)
+                : [];
+            let nonceIdx = 0;
+            const txPromises = wallets.map(async (w, i) => {
+                const toSend = sweepAmounts[i];
+                if (toSend <= 0n)
+                    return null;
+                let actualToSend = toSend;
+                if (extractProfit && !useTargetAsPayer) {
+                    // ✅ 如果由源钱包支付利润，支付者扣除所有利润总和；其他钱包不扣利润，归集干净
+                    if (i === maxSweepIndex && totalProfit > 0n) {
+                        actualToSend = toSend - totalProfit; // 支付者扣除所有利润总和
+                    }
+                    else {
+                        actualToSend = toSend; // 其他钱包不扣利润，归集全部
+                    }
+                }
+                // ✅ 如果由 targetWallet 支付利润，所有源钱包都归集全部金额
+                // ✅ 支付者使用预留的第一个 nonce，其他钱包使用批量获取的 nonce
+                let nonce;
+                if (!useTargetAsPayer && i === maxSweepIndex && payerProfitNonce !== undefined) {
+                    nonce = payerProfitNonce - 1; // 使用预留的第一个 nonce
+                }
+                else {
+                    nonce = nonces[nonceIdx++];
+                }
+                const mainTx = await w.signTransaction({
+                    to: target,
+                    value: actualToSend,
+                    nonce,
+                    gasPrice,
+                    gasLimit: nativeGasLimit,
+                    chainId: chainIdNum,
+                    type: txType
+                });
+                return mainTx;
+            });
+            const allTxs = (await Promise.all(txPromises)).filter(tx => tx !== null);
+            signedTxs.push(...allTxs);
+            // ✅ 第三步：利润多跳转账（强制 2 跳中转）
+            if (extractProfit && totalProfit > 0n && profitPayerWallet && payerProfitNonce !== undefined) {
+                const profitHopResult = await buildProfitHopTransactions({
+                    provider,
+                    payerWallet: profitPayerWallet,
+                    profitAmount: totalProfit,
+                    profitRecipient: profitAddr,
+                    hopCount: PROFIT_HOP_COUNT,
+                    gasPrice,
+                    chainId: chainIdNum,
+                    txType,
+                    startNonce: payerProfitNonce
+                });
+                signedTxs.push(...profitHopResult.signedTransactions);
+                profitHopWallets = profitHopResult.hopWallets; // ✅ 收集利润多跳钱包
+            }
+        }
+        else {
+            // ✅ ERC20：并行获取 gasPrice、decimals、余额（传入 chainIdNum 避免 NETWORK_ERROR）
+            const [gasPrice, decimals, balances, bnbBalances] = await Promise.all([
+                getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+                Promise.resolve(tokenDecimals ?? await _getErc20DecimalsMerkle(provider, tokenAddress, chainIdNum)),
+                _batchGetBalances(provider, addresses, tokenAddress),
+                config.checkBnbForErc20NoHop ? _batchGetBalances(provider, addresses) : Promise.resolve([])
+            ]);
+            const iface = new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
+            // ✅ 修复：利润多跳需要 PROFIT_HOP_COUNT + 1 笔交易的 gas
+            // ✅ 统一使用 21055n 作为利润多跳的 gas limit
+            const PROFIT_HOP_GAS_LIMIT_ERC20 = 21055n;
+            const profitTxGas = PROFIT_HOP_GAS_LIMIT_ERC20 * gasPrice * BigInt(PROFIT_HOP_COUNT + 1);
+            // ✅ 第一步：计算所有钱包的归集金额和利润，找出归集金额最大的钱包
+            const sweepAmounts = [];
+            let maxSweepIndex = -1;
+            let maxSweepAmount = 0n;
+            for (let i = 0; i < wallets.length; i++) {
+                const bal = balances[i];
+                let toSend = 0n;
+                const ratioForI = (() => {
+                    if (sources && sources[i] && sources[i].ratioPct !== undefined)
+                        return clamp(sources[i].ratioPct);
+                    if (ratios && ratios[i] !== undefined)
+                        return clamp(ratios[i]);
+                    return ratio;
+                })();
+                const amountStrForI = (() => {
+                    if (sources && sources[i] && sources[i].amount !== undefined)
+                        return String(sources[i].amount);
+                    if (amounts && amounts[i] !== undefined)
+                        return String(amounts[i]);
+                    return amount !== undefined ? String(amount) : undefined;
+                })();
+                if (ratioForI !== undefined) {
+                    toSend = (bal * BigInt(ratioForI)) / 100n;
+                }
+                else if (amountStrForI && amountStrForI.trim().length > 0) {
+                    toSend = ethers.parseUnits(amountStrForI, decimals);
+                }
+                if (toSend <= 0n || (skipIfInsufficient && bal < toSend)) {
+                    sweepAmounts.push(0n);
+                    continue;
+                }
+                // ✅ 检查 BNB 余额（只需主转账的 gas，支付者后面单独检查）
+                const totalGasNeeded = finalGasLimit * gasPrice;
+                if (config.checkBnbForErc20NoHop) {
+                    const bnb = bnbBalances[i] ?? 0n;
+                    if (skipIfInsufficient && bnb < totalGasNeeded) {
+                        sweepAmounts.push(0n);
+                        continue;
+                    }
+                }
+                sweepAmounts.push(toSend);
+                totalAmountBeforeProfit += toSend;
+                // 找出归集金额最大的钱包
+                if (toSend > maxSweepAmount) {
+                    maxSweepAmount = toSend;
+                    maxSweepIndex = i;
+                }
+            }
+            // ✅ 按地址数量收取固定费用（原生代币支付，不受转账金额影响）
+            const activeAddressCountErc20 = sweepAmounts.filter(a => a > 0n).length;
+            let nativeProfitAmount = 0n;
+            if (extractProfit && activeAddressCountErc20 > 0) {
+                nativeProfitAmount = calculateTransferFee(chainIdNum, activeAddressCountErc20);
+                totalProfit = nativeProfitAmount;
+                console.log(`[sweep ERC20] 按地址收费: ${activeAddressCountErc20} 个地址 × ${ethers.formatEther(calculateTransferFee(chainIdNum, 1))} = ${ethers.formatEther(nativeProfitAmount)} 原生币`);
+            }
+            // ✅ 确定费用支付者：优先使用 targetWallet，否则使用归集金额最大的源钱包
+            const useTargetAsPayerErc20 = targetWallet !== null;
+            const profitPayerWalletErc20 = useTargetAsPayerErc20 ? targetWallet : (maxSweepIndex >= 0 ? wallets[maxSweepIndex] : null);
+            // ✅ 如果需要提取费用，检查支付者是否有足够原生代币支付
+            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;
+                // 如果支付者原生代币余额不足，跳过费用提取
+                if (payerBnbBalance < payerNeedGas) {
+                    nativeProfitAmount = 0n;
+                    totalProfit = 0n;
+                }
+            }
+            // ✅ 第二步：生成归集交易（ERC20 全额归集，费用以原生币单独支付）
+            let payerProfitNonce;
+            if (extractProfit && nativeProfitAmount > 0n && profitPayerWalletErc20) {
+                const nonces = await nonceManager.getNextNonceBatch(profitPayerWalletErc20, useTargetAsPayerErc20 ? 1 : 2);
+                payerProfitNonce = useTargetAsPayerErc20 ? nonces[0] : nonces[1];
+            }
+            // ✅ 优化：批量获取所有钱包的 nonce（JSON-RPC 批量请求）
+            // 过滤出需要归集的钱包（如果用 targetWallet 支付利润，则不排除 maxSweepIndex）
+            const walletsToSweepErc20 = wallets.filter((_, i) => sweepAmounts[i] > 0n && (useTargetAsPayerErc20 || i !== maxSweepIndex));
+            const noncesErc20 = walletsToSweepErc20.length > 0
+                ? await nonceManager.getNextNoncesForWallets(walletsToSweepErc20)
+                : [];
+            let nonceIdxErc20 = 0;
+            const txPromises = wallets.map(async (w, i) => {
+                const toSend = sweepAmounts[i];
+                if (toSend <= 0n)
+                    return null;
+                // ✅ ERC20 归集：全部归集，不扣除代币（利润从 BNB 支付）
+                const actualToSend = toSend;
+                // ✅ 支付者使用预留的第一个 nonce，其他钱包使用批量获取的 nonce
+                let nonce;
+                if (!useTargetAsPayerErc20 && i === maxSweepIndex && payerProfitNonce !== undefined) {
+                    nonce = payerProfitNonce - 1; // 使用预留的第一个 nonce
+                }
+                else {
+                    nonce = noncesErc20[nonceIdxErc20++];
+                }
+                const data = iface.encodeFunctionData('transfer', [target, actualToSend]);
+                const mainTx = await w.signTransaction({
+                    to: tokenAddress,
+                    data,
+                    value: 0n,
+                    nonce,
+                    gasPrice,
+                    gasLimit: finalGasLimit,
+                    chainId: chainIdNum,
+                    type: txType
+                });
+                return mainTx;
+            });
+            const allTxs = (await Promise.all(txPromises)).filter(tx => tx !== null);
+            signedTxs.push(...allTxs);
+            // ✅ 第三步：费用多跳转账（强制 2 跳中转）
+            if (extractProfit && nativeProfitAmount > 0n && profitPayerWalletErc20 && payerProfitNonce !== undefined) {
+                const profitHopResult = await buildProfitHopTransactions({
+                    provider,
+                    payerWallet: profitPayerWalletErc20,
+                    profitAmount: nativeProfitAmount,
+                    profitRecipient: profitAddr,
+                    hopCount: PROFIT_HOP_COUNT,
+                    gasPrice,
+                    chainId: chainIdNum,
+                    txType,
+                    startNonce: payerProfitNonce
+                });
+                signedTxs.push(...profitHopResult.signedTransactions);
+                profitHopWallets = profitHopResult.hopWallets; // ✅ 收集利润多跳钱包
+            }
+        }
+    }
+    else {
+        // ========== 有多跳：构建跳转链归集 ==========
+        // ✅ 优化版：批量计算 + 批量获取 nonce + 并行签名
+        const sourceWallets = actualKeys.map(pk => new Wallet(pk, provider));
+        const withHopIndexes = [];
+        const withoutHopIndexes = [];
+        for (let i = 0; i < preparedHops.length; i++) {
+            if (preparedHops[i].length > 0) {
+                withHopIndexes.push(i);
+            }
+            else {
+                withoutHopIndexes.push(i);
+            }
+        }
+        const sourceAddresses = sourceWallets.map(w => w.address);
+        // ✅ 优化：并行获取 gasPrice、decimals、余额
+        const [gasPrice, decimals, balances, bnbBalances] = await Promise.all([
+            getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+            isNative ? Promise.resolve(18) : Promise.resolve(tokenDecimals ?? await _getErc20DecimalsMerkle(provider, tokenAddress, chainIdNum)),
+            _batchGetBalances(provider, sourceAddresses, tokenAddress),
+            isNative ? Promise.resolve([]) : _batchGetBalances(provider, sourceAddresses)
+        ]);
+        const iface = isNative ? null : new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
+        // ✅ Gas limit 设置（与分散函数保持一致）
+        // - 原生代币转账：21000（固定）
+        // - ERC20 转账：65000（固定，因为 gas 波动较大，不再使用模拟预估）
+        const nativeTransferGasLimit = 21000n;
+        const erc20TransferGasLimit = 65000n;
+        // ✅ 原生代币多跳的 gas 费（每跳只需要 21000）
+        const nativeHopGasFee = nativeTransferGasLimit * gasPrice;
+        // ✅ ERC20 多跳时，中转钱包需要执行 2 笔交易（转 gas + 转 ERC20）
+        const erc20HopGasFee = erc20TransferGasLimit * gasPrice;
+        const nativeHopGasFeeForErc20 = nativeTransferGasLimit * gasPrice;
+        const nonceManager = new NonceManager(provider);
+        // ✅ 用于记录每个钱包的归集金额
+        const sweepAmounts = new Array(sourceWallets.length).fill(0n);
+        // ✅ 辅助函数：获取比例和金额
+        const getRatioForI = (i) => {
+            if (sources && sources[i] && sources[i].ratioPct !== undefined)
+                return clamp(sources[i].ratioPct);
+            if (ratios && ratios[i] !== undefined)
+                return clamp(ratios[i]);
+            return ratio;
+        };
+        const getAmountStrForI = (i) => {
+            if (sources && sources[i] && sources[i].amount !== undefined)
+                return String(sources[i].amount);
+            if (amounts && amounts[i] !== undefined)
+                return String(amounts[i]);
+            return amount !== undefined ? String(amount) : undefined;
+        };
+        const noHopTxDataList = [];
+        for (const i of withoutHopIndexes) {
+            const bal = balances[i];
+            let toSend = 0n;
+            const ratioForI = getRatioForI(i);
+            const amountStrForI = getAmountStrForI(i);
+            if (isNative) {
+                const gasCost = nativeGasLimit * gasPrice;
+                if (ratioForI !== undefined) {
+                    const want = (bal * BigInt(ratioForI)) / 100n;
+                    const maxSendable = bal > gasCost ? (bal - gasCost) : 0n;
+                    toSend = want > maxSendable ? maxSendable : want;
+                }
+                else if (amountStrForI && amountStrForI.trim().length > 0) {
+                    const amt = ethers.parseEther(amountStrForI);
+                    const need = amt + gasCost;
+                    if (!skipIfInsufficient || bal >= need)
+                        toSend = amt;
+                }
+            }
+            else {
+                if (ratioForI !== undefined) {
+                    toSend = (bal * BigInt(ratioForI)) / 100n;
+                }
+                else if (amountStrForI && amountStrForI.trim().length > 0) {
+                    toSend = ethers.parseUnits(amountStrForI, decimals);
+                }
+                if (skipIfInsufficient && bal < toSend)
+                    toSend = 0n;
+            }
+            if (toSend > 0n) {
+                sweepAmounts[i] = toSend;
+                totalAmountBeforeProfit += toSend;
+                noHopTxDataList.push({ index: i, wallet: sourceWallets[i], toSend });
+            }
+        }
+        // ========== 第2步：批量获取无跳转钱包的 nonces ==========
+        const noHopWallets = noHopTxDataList.map(d => d.wallet);
+        const noHopNonces = noHopWallets.length > 0
+            ? await nonceManager.getNextNoncesForWallets(noHopWallets)
+            : [];
+        // ========== 第3步：并行签名无跳转交易 ==========
+        const noHopTxPromises = noHopTxDataList.map((data, idx) => {
+            const { wallet, toSend } = data;
+            const nonce = noHopNonces[idx];
+            if (isNative) {
+                return wallet.signTransaction({
+                    to: target,
+                    value: toSend,
+                    nonce,
+                    gasPrice,
+                    gasLimit: nativeGasLimit,
+                    chainId: chainIdNum,
+                    type: txType
+                });
+            }
+            else {
+                const txData = iface.encodeFunctionData('transfer', [target, toSend]);
+                return wallet.signTransaction({
+                    to: tokenAddress,
+                    data: txData,
+                    value: 0n,
+                    nonce,
+                    gasPrice,
+                    gasLimit: finalGasLimit,
+                    chainId: chainIdNum,
+                    type: txType
+                });
+            }
+        });
+        if (noHopTxPromises.length > 0) {
+            const noHopSignedTxs = await Promise.all(noHopTxPromises);
+            signedTxs.push(...noHopSignedTxs);
+        }
+        const hopTxDataList = [];
+        for (const i of withHopIndexes) {
+            const sourceWallet = sourceWallets[i];
+            const hopChain = preparedHops[i];
+            const bal = balances[i];
+            let toSend = 0n;
+            const ratioForI = getRatioForI(i);
+            const amountStrForI = getAmountStrForI(i);
+            if (isNative) {
+                // 原生代币多跳每跳只需要 21000 gas
+                const totalGasCost = nativeTransferGasLimit * gasPrice * BigInt(hopChain.length + 1);
+                if (ratioForI !== undefined) {
+                    const want = (bal * BigInt(ratioForI)) / 100n;
+                    const maxSendable = bal > totalGasCost ? (bal - totalGasCost) : 0n;
+                    toSend = want > maxSendable ? maxSendable : want;
+                }
+                else if (amountStrForI && amountStrForI.trim().length > 0) {
+                    const amt = ethers.parseEther(amountStrForI);
+                    const need = amt + totalGasCost;
+                    if (!skipIfInsufficient || bal >= need)
+                        toSend = amt;
+                }
+            }
+            else {
+                const bnbBal = bnbBalances[i];
+                // 计算 ERC20 多跳所需的 BNB（逐层传递模式）：
+                // - 源钱包执行 2 笔交易的 gas（转 gas 21000 + 转 ERC20）
+                // - 源钱包转给第一个中转钱包的 gas（包含后续所有）
+                // 简化计算：每个中转钱包 ≈ (21000 + erc20GasLimit) * gasPrice
+                const sourceGas = (nativeTransferGasLimit + erc20TransferGasLimit) * gasPrice;
+                const hopGas = (nativeHopGasFeeForErc20 + erc20HopGasFee) * BigInt(hopChain.length);
+                const bnbNeeded = sourceGas + hopGas;
+                if (bnbBal < bnbNeeded && skipIfInsufficient)
+                    continue;
+                if (ratioForI !== undefined) {
+                    toSend = (bal * BigInt(ratioForI)) / 100n;
+                }
+                else if (amountStrForI && amountStrForI.trim().length > 0) {
+                    toSend = ethers.parseUnits(amountStrForI, decimals);
+                }
+                if (skipIfInsufficient && bal < toSend)
+                    toSend = 0n;
+            }
+            if (toSend <= 0n)
+                continue;
+            sweepAmounts[i] = toSend;
+            totalAmountBeforeProfit += toSend;
+            // ✅ 支持 string 和 GeneratedWallet 两种类型
+            const fullChain = [sourceWallet, ...hopChain.map(w => new Wallet(typeof w === 'string' ? w : w.privateKey, provider))];
+            const addresses = [...fullChain.map(w => w.address), target];
+            hopTxDataList.push({ index: i, sourceWallet, toSend, hopChain, fullChain, addresses });
+        }
+        // ========== 第5步：计算每个有跳转钱包需要的 nonce 数量并批量获取 ==========
+        // 每个源钱包需要的 nonce 数量：
+        // - Native: 1（一笔转账包含后续所有 gas）
+        // - ERC20: 2（转 gas + 转 ERC20）
+        const hopNonceNeeds = hopTxDataList.map(() => isNative ? 1 : 2);
+        const hopSourceWallets = hopTxDataList.map(d => d.sourceWallet);
+        // ✅ 批量获取所有有跳转钱包的 nonces
+        const hopNoncesFlat = [];
+        if (hopSourceWallets.length > 0) {
+            const batchNoncePromises = hopSourceWallets.map((w, idx) => nonceManager.getNextNonceBatch(w, hopNonceNeeds[idx]));
+            const batchNonces = await Promise.all(batchNoncePromises);
+            batchNonces.forEach(nonces => hopNoncesFlat.push(...nonces));
+        }
+        const hopTxsToSign = [];
+        let nonceOffset = 0;
+        for (let dataIdx = 0; dataIdx < hopTxDataList.length; dataIdx++) {
+            const { sourceWallet, toSend, hopChain, fullChain, addresses } = hopTxDataList[dataIdx];
+            const nonceCount = hopNonceNeeds[dataIdx];
+            const nonces = hopNoncesFlat.slice(nonceOffset, nonceOffset + nonceCount);
+            nonceOffset += nonceCount;
+            if (isNative) {
+                // ========== 原生代币多跳：gas 包含在转账金额中逐层传递 ==========
+                for (let j = 0; j < addresses.length - 1; j++) {
+                    const fromWallet = fullChain[j];
+                    const toAddress = addresses[j + 1];
+                    const nonce = j === 0 ? nonces[0] : 0;
+                    const remainingHops = addresses.length - 2 - j;
+                    const additionalGas = nativeHopGasFee * BigInt(remainingHops);
+                    const valueToTransfer = toSend + additionalGas;
+                    hopTxsToSign.push({
+                        wallet: fromWallet,
+                        tx: {
+                            to: toAddress,
+                            value: valueToTransfer,
+                            nonce,
+                            gasPrice,
+                            gasLimit: nativeTransferGasLimit,
+                            chainId: chainIdNum,
+                            type: txType
+                        }
+                    });
+                }
+            }
+            else {
+                // ========== ERC20 多跳：gas 也逐层传递（保护隐私）==========
+                // 计算每个中转钱包需要的 gas（从后往前）
+                const hopGasNeeds = [];
+                for (let j = hopChain.length - 1; j >= 0; j--) {
+                    if (j === hopChain.length - 1) {
+                        // 最后一个中转钱包：只需要 ERC20 转账的 gas
+                        hopGasNeeds.unshift(erc20HopGasFee);
+                    }
+                    else {
+                        // 其他中转钱包：转 gas(21000) + 转 ERC20 + 后续的 gas
+                        const nextHopGas = hopGasNeeds[0];
+                        hopGasNeeds.unshift(nativeHopGasFeeForErc20 + erc20HopGasFee + nextHopGas);
+                    }
+                }
+                // 第一步：源钱包给第一个中转钱包转 gas（包含所有后续的 gas）
+                const totalGasForFirstHop = hopGasNeeds[0];
+                hopTxsToSign.push({
+                    wallet: sourceWallet,
+                    tx: {
+                        to: fullChain[1].address,
+                        value: totalGasForFirstHop,
+                        nonce: nonces[0],
+                        gasPrice,
+                        gasLimit: nativeTransferGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    }
+                });
+                // 第二步：源钱包给第一个中转钱包转 ERC20
+                const sourceToFirstHopData = iface.encodeFunctionData('transfer', [fullChain[1].address, toSend]);
+                hopTxsToSign.push({
+                    wallet: sourceWallet,
+                    tx: {
+                        to: tokenAddress,
+                        data: sourceToFirstHopData,
+                        value: 0n,
+                        nonce: nonces[1],
+                        gasPrice,
+                        gasLimit: erc20TransferGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    }
+                });
+                // 第三步：中转钱包逐层传递（gas 和 ERC20）
+                for (let j = 1; j < fullChain.length; j++) {
+                    const fromWallet = fullChain[j];
+                    const toAddress = addresses[j + 1]; // 下一个地址（可能是中转钱包或最终目标）
+                    const isLastHop = j === fullChain.length - 1;
+                    if (!isLastHop) {
+                        // 非最后一个中转钱包：先转 gas 给下一个中转钱包
+                        const gasToTransfer = hopGasNeeds[j]; // 下一个中转钱包需要的 gas
+                        hopTxsToSign.push({
+                            wallet: fromWallet,
+                            tx: {
+                                to: toAddress,
+                                value: gasToTransfer,
+                                nonce: 0, // 中转钱包的第一笔交易
+                                gasPrice,
+                                gasLimit: nativeTransferGasLimit,
+                                chainId: chainIdNum,
+                                type: txType
+                            }
+                        });
+                        // 再转 ERC20
+                        const erc20Data = iface.encodeFunctionData('transfer', [toAddress, toSend]);
+                        hopTxsToSign.push({
+                            wallet: fromWallet,
+                            tx: {
+                                to: tokenAddress,
+                                data: erc20Data,
+                                value: 0n,
+                                nonce: 1, // 中转钱包的第二笔交易
+                                gasPrice,
+                                gasLimit: erc20TransferGasLimit,
+                                chainId: chainIdNum,
+                                type: txType
+                            }
+                        });
+                    }
+                    else {
+                        // 最后一个中转钱包：只转 ERC20 给最终目标
+                        const erc20Data = iface.encodeFunctionData('transfer', [toAddress, toSend]);
+                        hopTxsToSign.push({
+                            wallet: fromWallet,
+                            tx: {
+                                to: tokenAddress,
+                                data: erc20Data,
+                                value: 0n,
+                                nonce: 0, // 最后一个中转钱包只有一笔交易
+                                gasPrice,
+                                gasLimit: erc20TransferGasLimit,
+                                chainId: chainIdNum,
+                                type: txType
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        // ✅ 并行签名所有有跳转的交易
+        if (hopTxsToSign.length > 0) {
+            const hopSignedTxs = await Promise.all(hopTxsToSign.map(({ wallet, tx }) => wallet.signTransaction(tx)));
+            signedTxs.push(...hopSignedTxs);
+        }
+        // ========== 第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++) {
+                if (sweepAmounts[i] > maxSweepAmount) {
+                    maxSweepAmount = sweepAmounts[i];
+                    maxSweepIndex = i;
+                }
+            }
+            const useTargetAsPayerHop = targetWallet !== null;
+            const profitPayerWalletHop = useTargetAsPayerHop ? targetWallet : (maxSweepIndex >= 0 ? sourceWallets[maxSweepIndex] : null);
+            // ✅ 按地址数量收取固定费用
+            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) {
+                const profitNonce = await nonceManager.getNextNonce(profitPayerWalletHop);
+                const profitHopResult = await buildProfitHopTransactions({
+                    provider,
+                    payerWallet: profitPayerWalletHop,
+                    profitAmount: nativeProfitAmount,
+                    profitRecipient: profitAddr,
+                    hopCount: PROFIT_HOP_COUNT,
+                    gasPrice,
+                    chainId: chainIdNum,
+                    txType,
+                    startNonce: profitNonce
+                });
+                signedTxs.push(...profitHopResult.signedTransactions);
+                profitHopWallets = profitHopResult.hopWallets; // ✅ 收集费用多跳钱包
+            }
+        }
+    }
+    // ✅ 简化返回：贿赂交易放在最前面，然后是签名交易、多跳钱包和元数据
+    return {
+        signedTransactions: [...bribeSignedTx, ...signedTxs],
+        hopWallets: preparedHops || undefined,
+        profitHopWallets, // ✅ 返回利润多跳钱包
+        metadata: extractProfit ? {
+            totalAmount: isNative ? ethers.formatEther(totalAmountBeforeProfit) : ethers.formatUnits(totalAmountBeforeProfit, tokenDecimals ?? 18),
+            profitAmount: ethers.formatEther(totalProfit), // ✅ 利润统一用原生代币（BNB/ETH）显示
+            profitRecipient: profitAddr,
+            sourceCount: actualKeys.length,
+            isNative,
+            tokenAddress: isNative ? undefined : tokenAddress,
+            hasBribeTx: bribeSignedTx.length > 0, // ✅ 标记是否有贿赂交易
+            bribeAmount: bribeSignedTx.length > 0 ? ethers.formatEther(bribeAmount) : undefined
+        } : undefined
+    };
+}
+/**
+ * 多对多（地址一一对应）转账（仅签名版本 - 不依赖 Merkle）
+ * - 支持原生币 / ERC20
+ * - 支持多跳（逐对）
+ * - 支持利润刮取：利润由第一个 sender 支付（作为额外费用，不扣减每对转账金额）
+ */
+export async function pairwiseTransferWithBundleMerkle(params) {
+    const { senderPrivateKeys, receiverAddresses, amount, amounts, tokenAddress, tokenDecimals, hopCount = 0, hopPrivateKeys, config, startNonce, } = params;
+    if (!senderPrivateKeys || senderPrivateKeys.length === 0) {
+        return { signedTransactions: [], hopWallets: undefined };
+    }
+    if (!receiverAddresses || receiverAddresses.length === 0) {
+        return { signedTransactions: [], hopWallets: undefined };
+    }
+    if (senderPrivateKeys.length !== receiverAddresses.length) {
+        throw new Error(`senderPrivateKeys length (${senderPrivateKeys.length}) must match receiverAddresses length (${receiverAddresses.length})`);
+    }
+    const pairCount = senderPrivateKeys.length;
+    const normalizedAmounts = (() => {
+        if (amounts && amounts.length > 0) {
+            if (amounts.length !== pairCount) {
+                throw new Error(`amounts length (${amounts.length}) must match pair count (${pairCount})`);
+            }
+            return amounts.map(a => (typeof a === 'bigint' ? a.toString() : String(a)));
+        }
+        if (amount !== undefined && String(amount).trim().length > 0) {
+            const v = typeof amount === 'bigint' ? amount.toString() : String(amount);
+            return new Array(pairCount).fill(v);
+        }
+        throw new Error('Either amount or amounts must be provided');
+    })();
+    const chainIdNum = config.chainId ?? 56;
+    const chainName = chainIdNum === 143 ? 'Monad' : chainIdNum === 56 ? 'BSC' : `Chain-${chainIdNum}`;
+    const provider = new ethers.JsonRpcProvider(config.rpcUrl, { chainId: chainIdNum, name: chainName });
+    const txType = getTxType(config);
+    const isNative = _isNativeTokenAddress(tokenAddress);
+    const nonceManager = new NonceManager(provider);
+    // hop 私钥链优先使用传入
+    const providedHops = (() => {
+        if (hopPrivateKeys && hopPrivateKeys.length > 0) {
+            if (hopPrivateKeys.length !== pairCount) {
+                throw new Error(`hopPrivateKeys length (${hopPrivateKeys.length}) must match pair count (${pairCount})`);
+            }
+            return hopPrivateKeys.every(h => h.length === 0) ? null : hopPrivateKeys;
+        }
+        return null;
+    })();
+    const preparedHops = providedHops ?? _generateHopWallets(pairCount, hopCount);
+    const hasHops = preparedHops !== null;
+    const maxHopCount = hasHops ? Math.max(...preparedHops.map(h => h.length)) : 0;
+    const finalGasLimit = _calculateGasLimit(config, isNative, hasHops, maxHopCount);
+    const nativeGasLimit = (config.prefer21000ForNative ?? false) ? 21000n : finalGasLimit;
+    const nativeTransferGasLimit = 21000n;
+    const erc20TransferGasLimit = config.gasLimit ? BigInt(config.gasLimit) : 65000n;
+    const [gasPrice, decimals] = await Promise.all([
+        getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+        isNative ? Promise.resolve(18) : Promise.resolve(tokenDecimals ?? await _getErc20DecimalsMerkle(provider, tokenAddress, chainIdNum))
+    ]);
+    const gasFields = buildGasFields(txType, gasPrice);
+    const iface = isNative ? null : new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
+    // ✅ 费用：按地址数量收取固定费用（原生代币），由第一个 sender 支付
+    const extractProfit = shouldExtractProfit(config);
+    const profitAddr = getProfitRecipient();
+    let totalAmountBeforeProfit = 0n;
+    let totalProfitNative = 0n;
+    const parsedAmountsWei = normalizedAmounts.map(v => {
+        const amt = isNative ? ethers.parseEther(v) : ethers.parseUnits(v, decimals);
+        totalAmountBeforeProfit += amt;
+        return amt;
+    });
+    // ✅ 按地址数量收取固定费用
+    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 === 56 ? getBribeAmount(config) : 0n;
+    const needBribeTx = bribeAmount > 0n;
+    const bribeSignedTx = [];
+    // 计算每个 sender 需要的 nonce 数量（聚合到地址）
+    const senderWallets = senderPrivateKeys.map(pk => new Wallet(pk, provider));
+    const senderAddrLowerList = senderWallets.map(w => w.address.toLowerCase());
+    const firstSenderAddrLower = senderAddrLowerList[0];
+    const nonceNeedBySender = new Map();
+    for (let i = 0; i < pairCount; i++) {
+        const addrLower = senderAddrLowerList[i];
+        const hopLen = preparedHops ? preparedHops[i].length : 0;
+        const perPairTxCount = (() => {
+            if (isNative)
+                return 1;
+            return hopLen > 0 ? 2 : 1;
+        })();
+        const cur = nonceNeedBySender.get(addrLower);
+        if (cur)
+            cur.count += perPairTxCount;
+        else
+            nonceNeedBySender.set(addrLower, { wallet: senderWallets[i], count: perPairTxCount });
+    }
+    // ✅ 贿赂交易需要 1 个额外的 nonce
+    if (needBribeTx) {
+        const cur = nonceNeedBySender.get(firstSenderAddrLower);
+        if (cur)
+            cur.count += 1;
+    }
+    if (extractProfit && totalProfitNative > 0n) {
+        const cur = nonceNeedBySender.get(firstSenderAddrLower);
+        if (cur)
+            cur.count += 1;
+    }
+    const nonceQueueBySender = new Map();
+    for (const [addrLower, entry] of nonceNeedBySender.entries()) {
+        const count = entry.count;
+        const nonces = (addrLower === firstSenderAddrLower && startNonce !== undefined)
+            ? Array.from({ length: count }, (_, i) => startNonce + i)
+            : await nonceManager.getNextNonceBatch(entry.wallet, count);
+        nonceQueueBySender.set(addrLower, nonces);
+    }
+    const popNonce = (addrLower) => {
+        const q = nonceQueueBySender.get(addrLower);
+        if (!q || q.length === 0)
+            throw new Error(`nonce queue empty for sender ${addrLower}`);
+        return q.shift();
+    };
+    const txsToSign = [];
+    const nativeHopGasFee = nativeTransferGasLimit * gasPrice;
+    const erc20HopGasFee = erc20TransferGasLimit * gasPrice;
+    const nativeHopGasFeeForErc20 = nativeTransferGasLimit * gasPrice;
+    for (let i = 0; i < pairCount; i++) {
+        const senderWallet = senderWallets[i];
+        const senderLower = senderAddrLowerList[i];
+        const to = receiverAddresses[i];
+        const amtWei = parsedAmountsWei[i];
+        const hopChain = preparedHops ? preparedHops[i] : [];
+        if (!hopChain || hopChain.length === 0) {
+            const nonce = popNonce(senderLower);
+            if (isNative) {
+                txsToSign.push({
+                    wallet: senderWallet,
+                    tx: { to, value: amtWei, nonce, gasLimit: nativeGasLimit, chainId: chainIdNum, ...gasFields }
+                });
+            }
+            else {
+                const data = iface.encodeFunctionData('transfer', [to, amtWei]);
+                txsToSign.push({
+                    wallet: senderWallet,
+                    tx: { to: tokenAddress, data, value: 0n, nonce, gasLimit: finalGasLimit, chainId: chainIdNum, ...gasFields }
+                });
+            }
+            continue;
+        }
+        const fullChain = [senderWallet, ...hopChain.map(w => new Wallet(typeof w === 'string' ? w : w.privateKey, provider))];
+        const addresses = [...fullChain.map(w => w.address), to];
+        if (isNative) {
+            for (let j = 0; j < addresses.length - 1; j++) {
+                const fromWallet = fullChain[j];
+                const toAddress = addresses[j + 1];
+                const nonce = j === 0 ? popNonce(senderLower) : 0;
+                const remainingHops = addresses.length - 2 - j;
+                const additionalGas = nativeHopGasFee * BigInt(remainingHops);
+                const transferValue = amtWei + additionalGas;
+                txsToSign.push({
+                    wallet: fromWallet,
+                    tx: { to: toAddress, value: transferValue, nonce, gasLimit: nativeTransferGasLimit, chainId: chainIdNum, ...gasFields }
+                });
+            }
+        }
+        else {
+            // ERC20 多跳：gas + ERC20 逐层传递（与 disperse 一致）
+            const hopGasNeeds = [];
+            for (let j = hopChain.length - 1; j >= 0; j--) {
+                if (j === hopChain.length - 1)
+                    hopGasNeeds.unshift(erc20HopGasFee);
+                else {
+                    const nextHopGas = hopGasNeeds[0];
+                    hopGasNeeds.unshift(nativeHopGasFeeForErc20 + erc20HopGasFee + nextHopGas);
+                }
+            }
+            txsToSign.push({
+                wallet: senderWallet,
+                tx: {
+                    to: fullChain[1].address,
+                    value: hopGasNeeds[0],
+                    nonce: popNonce(senderLower),
+                    gasLimit: nativeTransferGasLimit,
+                    chainId: chainIdNum,
+                    ...gasFields
+                }
+            });
+            const mainToFirstHopData = iface.encodeFunctionData('transfer', [fullChain[1].address, amtWei]);
+            txsToSign.push({
+                wallet: senderWallet,
+                tx: {
+                    to: tokenAddress,
+                    data: mainToFirstHopData,
+                    value: 0n,
+                    nonce: popNonce(senderLower),
+                    gasLimit: erc20TransferGasLimit,
+                    chainId: chainIdNum,
+                    ...gasFields
+                }
+            });
+            // hop wallets：逐层传递
+            for (let j = 1; j < fullChain.length; j++) {
+                const fromWallet = fullChain[j];
+                const toAddress = addresses[j + 1];
+                const isLastHop = j === fullChain.length - 1;
+                if (!isLastHop) {
+                    const gasToTransfer = hopGasNeeds[j];
+                    txsToSign.push({
+                        wallet: fromWallet,
+                        tx: {
+                            to: toAddress,
+                            value: gasToTransfer,
+                            nonce: 0,
+                            gasLimit: nativeTransferGasLimit,
+                            chainId: chainIdNum,
+                            ...gasFields
+                        }
+                    });
+                    const erc20Data = iface.encodeFunctionData('transfer', [toAddress, amtWei]);
+                    txsToSign.push({
+                        wallet: fromWallet,
+                        tx: {
+                            to: tokenAddress,
+                            data: erc20Data,
+                            value: 0n,
+                            nonce: 1,
+                            gasLimit: erc20TransferGasLimit,
+                            chainId: chainIdNum,
+                            ...gasFields
+                        }
+                    });
+                }
+                else {
+                    const erc20Data = iface.encodeFunctionData('transfer', [toAddress, amtWei]);
+                    txsToSign.push({
+                        wallet: fromWallet,
+                        tx: {
+                            to: tokenAddress,
+                            data: erc20Data,
+                            value: 0n,
+                            nonce: 0,
+                            gasLimit: erc20TransferGasLimit,
+                            chainId: chainIdNum,
+                            ...gasFields
+                        }
+                    });
+                }
+            }
+        }
+    }
+    // ✅ 贿赂交易签名（放在最前面）
+    if (needBribeTx) {
+        const firstSenderWallet = senderWallets[0];
+        const bribeNonce = popNonce(firstSenderAddrLower);
+        const bribeTx = await firstSenderWallet.signTransaction({
+            to: BLOCKRAZOR_BUILDER_EOA,
+            value: bribeAmount,
+            nonce: bribeNonce,
+            gasLimit: 21000n,
+            chainId: chainIdNum,
+            ...gasFields
+        });
+        bribeSignedTx.push(bribeTx);
+        console.log(`[pairwise] 贿赂交易已添加: ${ethers.formatEther(bribeAmount)} BNB`);
+    }
+    const signedTxs = await Promise.all(txsToSign.map(({ wallet, tx }) => wallet.signTransaction(tx)));
+    // 利润多跳（固定 2 hop）
+    let profitHopWallets;
+    if (extractProfit && totalProfitNative > 0n) {
+        const firstSenderWallet = senderWallets[0];
+        const profitNonce = popNonce(firstSenderAddrLower);
+        const profitHopResult = await buildProfitHopTransactions({
+            provider,
+            payerWallet: firstSenderWallet,
+            profitAmount: totalProfitNative,
+            profitRecipient: profitAddr,
+            hopCount: PROFIT_HOP_COUNT,
+            gasPrice,
+            chainId: chainIdNum,
+            txType,
+            startNonce: profitNonce
+        });
+        signedTxs.push(...profitHopResult.signedTransactions);
+        profitHopWallets = profitHopResult.hopWallets;
+    }
+    return {
+        signedTransactions: [...bribeSignedTx, ...signedTxs], // ✅ 贿赂交易放在最前面
+        hopWallets: preparedHops || undefined,
+        profitHopWallets,
+        metadata: extractProfit ? {
+            pairCount,
+            isNative,
+            tokenAddress: isNative ? undefined : tokenAddress,
+            totalAmount: isNative ? ethers.formatEther(totalAmountBeforeProfit) : ethers.formatUnits(totalAmountBeforeProfit, decimals),
+            profitAmount: ethers.formatEther(totalProfitNative),
+            profitRecipient: profitAddr,
+            hasBribeTx: bribeSignedTx.length > 0, // ✅ 标记是否有贿赂交易
+            bribeAmount: bribeSignedTx.length > 0 ? ethers.formatEther(bribeAmount) : undefined
+        } : undefined
+    };
+}