four-flap-meme-sdk 1.3.73 → 1.3.76

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

@@ -0,0 +1,1019 @@
+import { ethers, Wallet, Contract } from 'ethers';
+import { getOptimizedGasPrice, NonceManager } from '../../utils/bundle-helpers.js';
+import { getTxType, getGasPriceConfig, shouldExtractProfit, calculateProfit, getProfitRecipient } from './config.js';
+// ==================== 链配置 ====================
+const CHAIN_ID_MAP = {
+    'BSC': 56,
+    'MONAD': 143,
+    'XLAYER': 196
+};
+// ==================== ERC20 → 原生代币报价 ====================
+// BSC 链常量
+const BSC_PANCAKE_V2_ROUTER = '0x10ED43C718714eb63d5aA57B78B54704E256024E';
+const BSC_WBNB = '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c';
+// Monad 链常量
+const MONAD_PANCAKE_V2_ROUTER = '0xb1bc24c34e88f7d43d5923034e3a14b24daacff9';
+const MONAD_WMON = '0x3bd359c1119da7da1d913d1c4d2b7c461115433a';
+// XLayer 链常量（PotatoSwap V2 Router）
+const XLAYER_POTATOSWAP_V2_ROUTER = '0x881fb2f98c13d521009464e7d1cbf16e1b394e8e';
+const XLAYER_WOKB = '0xe538905cf8410324e03a5a23c1c177a474d59b2b';
+const ROUTER_ABI = [
+    'function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts)'
+];
+/**
+ * 获取 ERC20 代币 → 原生代币的报价
+ */
+async function getTokenToNativeQuote(provider, tokenAddress, tokenAmount, chainId) {
+    if (tokenAmount <= 0n)
+        return 0n;
+    try {
+        if (chainId === 56) {
+            const router = new Contract(BSC_PANCAKE_V2_ROUTER, ROUTER_ABI, provider);
+            const amounts = await router.getAmountsOut(tokenAmount, [tokenAddress, BSC_WBNB]);
+            return amounts[1];
+        }
+        if (chainId === 143) {
+            const router = new Contract(MONAD_PANCAKE_V2_ROUTER, ROUTER_ABI, provider);
+            const amounts = await router.getAmountsOut(tokenAmount, [tokenAddress, MONAD_WMON]);
+            return amounts[1];
+        }
+        if (chainId === 196) {
+            // XLayer: 使用 PotatoSwap V2 Router
+            const router = new Contract(XLAYER_POTATOSWAP_V2_ROUTER, ROUTER_ABI, provider);
+            const amounts = await router.getAmountsOut(tokenAmount, [tokenAddress, XLAYER_WOKB]);
+            return amounts[1];
+        }
+        return 0n;
+    }
+    catch {
+        return 0n;
+    }
+}
+// ==================== 内部辅助函数 ====================
+const decimalsCache = new Map();
+async function getErc20Decimals(provider, token) {
+    const network = await provider.getNetwork();
+    const key = `${network.chainId}_${token.toLowerCase()}`;
+    if (decimalsCache.has(key))
+        return decimalsCache.get(key);
+    try {
+        const erc20 = new ethers.Contract(token, ['function decimals() view returns (uint8)'], provider);
+        const d = await erc20.decimals();
+        if (!Number.isFinite(d) || d < 0 || d > 36)
+            return 18;
+        decimalsCache.set(key, d);
+        return d;
+    }
+    catch {
+        return 18;
+    }
+}
+function generateHopWallets(recipientCount, hopCount) {
+    const hopCounts = Array.isArray(hopCount) ? hopCount : new Array(recipientCount).fill(hopCount);
+    if (hopCounts.every(h => h <= 0))
+        return null;
+    const result = [];
+    for (let i = 0; i < recipientCount; i++) {
+        const chain = [];
+        for (let j = 0; j < hopCounts[i]; j++) {
+            chain.push(Wallet.createRandom().privateKey);
+        }
+        result.push(chain);
+    }
+    return result;
+}
+function normalizeAmounts(recipients, amount, amounts) {
+    if (amounts && amounts.length > 0) {
+        if (amounts.length !== recipients.length) {
+            throw new Error(`amounts length (${amounts.length}) must match recipients length (${recipients.length})`);
+        }
+        return amounts;
+    }
+    if (amount !== undefined && amount.trim().length > 0) {
+        return new Array(recipients.length).fill(amount);
+    }
+    throw new Error('Either amount or amounts must be provided');
+}
+async function batchGetBalances(provider, addresses, tokenAddress) {
+    if (addresses.length === 0)
+        return [];
+    if (!tokenAddress) {
+        return Promise.all(addresses.map(addr => provider.getBalance(addr).catch(() => 0n)));
+    }
+    else {
+        const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+        const MULTICALL3_ABI = [
+            'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) view returns (tuple(bool success, bytes returnData)[] returnData)'
+        ];
+        const multicall = new ethers.Contract(MULTICALL3_ADDRESS, MULTICALL3_ABI, provider);
+        const ERC20_ABI = ['function balanceOf(address) view returns (uint256)'];
+        const iface = new ethers.Interface(ERC20_ABI);
+        const calls = addresses.map(addr => ({
+            target: tokenAddress,
+            allowFailure: true,
+            callData: iface.encodeFunctionData('balanceOf', [addr])
+        }));
+        try {
+            const results = await multicall.aggregate3(calls);
+            return results.map((result) => {
+                if (result.success) {
+                    return iface.decodeFunctionResult('balanceOf', result.returnData)[0];
+                }
+                return 0n;
+            });
+        }
+        catch {
+            const fallbackCalls = addresses.map(addr => provider
+                .call({ to: tokenAddress, data: iface.encodeFunctionData('balanceOf', [addr]) })
+                .then(raw => iface.decodeFunctionResult('balanceOf', raw)[0])
+                .catch(() => 0n));
+            return Promise.all(fallbackCalls);
+        }
+    }
+}
+function calculateGasLimit(config, isNative, hasHops, hopCount = 0) {
+    if (config.gasLimit !== undefined) {
+        return BigInt(config.gasLimit);
+    }
+    let baseGas = isNative ? 21000 : 65000;
+    if (hasHops) {
+        baseGas += hopCount * (isNative ? 21000 : 65000);
+    }
+    const multiplier = config.gasLimitMultiplier ?? 1.2;
+    return BigInt(Math.ceil(baseGas * multiplier));
+}
+function isNativeTokenAddress(tokenAddress) {
+    if (!tokenAddress)
+        return true;
+    const v = tokenAddress.trim().toLowerCase();
+    if (!v)
+        return true;
+    if (v === 'native')
+        return true;
+    if (v === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee')
+        return true;
+    return false;
+}
+// ==================== 分散函数 ====================
+/**
+ * Flap Protocol: 分散（仅签名版本）
+ * ✅ 支持利润提取
+ * ✅ 支持多跳
+ * ✅ 支持 ERC20→原生代币报价
+ * ✅ 支持 Multicall3 批量获取余额
+ */
+export async function flapDisperseWithBundleMerkle(params) {
+    const { chain, fromPrivateKey, recipients, amount, amounts, tokenAddress, tokenDecimals, hopCount = 0, hopPrivateKeys, items, config, startNonce } = params;
+    if (!recipients || recipients.length === 0) {
+        return { signedTransactions: [], hopWallets: undefined };
+    }
+    const chainIdNum = CHAIN_ID_MAP[chain] ?? 56;
+    const provider = new ethers.JsonRpcProvider(config.rpcUrl, { chainId: chainIdNum, name: chain });
+    const mainWallet = new Wallet(fromPrivateKey, provider);
+    const isNative = isNativeTokenAddress(tokenAddress);
+    const txType = getTxType(config);
+    // 预处理数据
+    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 = 21000n;
+    const signedTxs = [];
+    const extractProfit = shouldExtractProfit(config);
+    let totalProfit = 0n;
+    let totalAmountBeforeProfit = 0n;
+    const nonceManager = new NonceManager(provider);
+    if (!preparedHops) {
+        // ========== 无多跳：直接批量转账 ==========
+        const extraTxCount = extractProfit ? 1 : 0;
+        const totalTxCount = recipients.length + extraTxCount;
+        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)
+        ]);
+        if (isNative) {
+            const txDataList = recipients.map((to, i) => {
+                const originalAmount = ethers.parseEther(normalizedAmounts[i]);
+                totalAmountBeforeProfit += originalAmount;
+                let actualAmount = originalAmount;
+                if (extractProfit) {
+                    const { profit, remaining } = calculateProfit(originalAmount, config);
+                    actualAmount = remaining;
+                    totalProfit += profit;
+                }
+                return { to, value: actualAmount, nonce: nonces[i] };
+            });
+            const txPromises = txDataList.map(({ to, value, nonce }) => mainWallet.signTransaction({
+                to,
+                value,
+                nonce,
+                gasPrice,
+                gasLimit: nativeGasLimit,
+                chainId: chainIdNum,
+                type: txType
+            }));
+            if (extractProfit && totalProfit > 0n) {
+                txPromises.push(mainWallet.signTransaction({
+                    to: getProfitRecipient(),
+                    value: totalProfit,
+                    nonce: nonces[recipients.length],
+                    gasPrice,
+                    gasLimit: 21000n,
+                    chainId: chainIdNum,
+                    type: txType
+                }));
+            }
+            signedTxs.push(...(await Promise.all(txPromises)));
+        }
+        else {
+            const decimals = tokenDecimals ?? (await getErc20Decimals(provider, tokenAddress));
+            const iface = new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
+            let totalTokenProfit = 0n;
+            const txDataList = recipients.map((to, i) => {
+                const originalAmount = ethers.parseUnits(normalizedAmounts[i], decimals);
+                totalAmountBeforeProfit += originalAmount;
+                let actualAmount = originalAmount;
+                if (extractProfit) {
+                    const { profit, remaining } = calculateProfit(originalAmount, config);
+                    actualAmount = remaining;
+                    totalTokenProfit += profit;
+                }
+                const data = iface.encodeFunctionData('transfer', [to, actualAmount]);
+                return { data, nonce: nonces[i] };
+            });
+            let nativeProfitAmount = 0n;
+            if (extractProfit && totalTokenProfit > 0n) {
+                nativeProfitAmount = await getTokenToNativeQuote(provider, tokenAddress, totalTokenProfit, chainIdNum);
+                totalProfit = nativeProfitAmount;
+            }
+            const txPromises = txDataList.map(({ data, nonce }) => mainWallet.signTransaction({
+                to: tokenAddress,
+                data,
+                value: 0n,
+                nonce,
+                gasPrice,
+                gasLimit: finalGasLimit,
+                chainId: chainIdNum,
+                type: txType
+            }));
+            if (extractProfit && nativeProfitAmount > 0n) {
+                txPromises.push(mainWallet.signTransaction({
+                    to: getProfitRecipient(),
+                    value: nativeProfitAmount,
+                    nonce: nonces[recipients.length],
+                    gasPrice,
+                    gasLimit: 21000n,
+                    chainId: chainIdNum,
+                    type: txType
+                }));
+            }
+            signedTxs.push(...(await Promise.all(txPromises)));
+        }
+    }
+    else {
+        // ========== 有多跳：构建跳转链 ==========
+        const [gasPrice, decimals] = await Promise.all([
+            getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+            isNative ? Promise.resolve(18) : Promise.resolve(tokenDecimals ?? await getErc20Decimals(provider, tokenAddress))
+        ]);
+        const iface = isNative ? null : new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
+        const gasFeePerHop = finalGasLimit * gasPrice;
+        let mainWalletNonceCount = 0;
+        for (let i = 0; i < recipients.length; i++) {
+            const hopChain = preparedHops[i];
+            if (hopChain.length === 0) {
+                mainWalletNonceCount += 1;
+            }
+            else {
+                const nonceNeed = isNative ? 1 : (hopChain.length + 1);
+                mainWalletNonceCount += nonceNeed;
+            }
+        }
+        if (extractProfit)
+            mainWalletNonceCount += 1;
+        const allMainNonces = startNonce !== undefined
+            ? Array.from({ length: mainWalletNonceCount }, (_, i) => startNonce + i)
+            : await nonceManager.getNextNonceBatch(mainWallet, mainWalletNonceCount);
+        let mainNonceIdx = 0;
+        const txsToSign = [];
+        let totalTokenProfit = 0n;
+        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, config);
+                amountWei = remaining;
+                if (isNative) {
+                    totalProfit += profit;
+                }
+                else {
+                    totalTokenProfit += profit;
+                }
+            }
+            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;
+            }
+            const fullChain = [mainWallet, ...hopChain.map(pk => new Wallet(pk, provider))];
+            const addresses = [...fullChain.map(w => w.address), finalRecipient];
+            if (!isNative) {
+                for (let j = 0; j < hopChain.length; j++) {
+                    const nonce = allMainNonces[mainNonceIdx++];
+                    txsToSign.push({
+                        wallet: mainWallet,
+                        tx: { to: fullChain[j + 1].address, value: gasFeePerHop, nonce, gasPrice, gasLimit: nativeGasLimit, chainId: chainIdNum, type: txType }
+                    });
+                }
+            }
+            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;
+                if (isNative) {
+                    const remainingHops = addresses.length - 2 - j;
+                    const additionalGas = gasFeePerHop * BigInt(remainingHops);
+                    const transferValue = amountWei + additionalGas;
+                    txsToSign.push({
+                        wallet: fromWallet,
+                        tx: { to: toAddress, value: transferValue, nonce, gasPrice, gasLimit: finalGasLimit, chainId: chainIdNum, type: txType }
+                    });
+                }
+                else {
+                    const data = iface.encodeFunctionData('transfer', [toAddress, amountWei]);
+                    txsToSign.push({
+                        wallet: fromWallet,
+                        tx: { to: tokenAddress, data, value: 0n, nonce, gasPrice, gasLimit: finalGasLimit, chainId: chainIdNum, type: txType }
+                    });
+                }
+            }
+        }
+        if (!isNative && extractProfit && totalTokenProfit > 0n) {
+            const nativeProfitAmount = await getTokenToNativeQuote(provider, tokenAddress, totalTokenProfit, chainIdNum);
+            totalProfit = nativeProfitAmount;
+        }
+        if (extractProfit && totalProfit > 0n) {
+            const profitNonce = allMainNonces[mainNonceIdx++];
+            txsToSign.push({
+                wallet: mainWallet,
+                tx: { to: getProfitRecipient(), value: totalProfit, nonce: profitNonce, gasPrice, gasLimit: 21000n, chainId: chainIdNum, type: txType }
+            });
+        }
+        const signedTxsResult = await Promise.all(txsToSign.map(({ wallet, tx }) => wallet.signTransaction(tx)));
+        signedTxs.push(...signedTxsResult);
+    }
+    return {
+        signedTransactions: signedTxs,
+        hopWallets: preparedHops || undefined,
+        metadata: extractProfit ? {
+            totalAmount: ethers.formatEther(totalAmountBeforeProfit),
+            profitAmount: ethers.formatEther(totalProfit),
+            profitRecipient: getProfitRecipient(),
+            recipientCount: recipients.length,
+            isNative,
+            tokenAddress: isNative ? undefined : tokenAddress
+        } : undefined
+    };
+}
+// ==================== 归集函数 ====================
+/**
+ * Flap Protocol: 归集（仅签名版本）
+ * ✅ 支持利润提取
+ * ✅ 查询余额最大的钱包支付利润
+ * ✅ 支持多跳
+ * ✅ 支持 ERC20→原生代币报价
+ * ✅ 支持 Multicall3 批量获取余额
+ */
+export async function flapSweepWithBundleMerkle(params) {
+    const { chain, sourcePrivateKeys, target, ratioPct, ratios, amount, amounts, tokenAddress, tokenDecimals, skipIfInsufficient = true, hopCount = 0, hopPrivateKeys, sources, config } = params;
+    if (!sourcePrivateKeys || sourcePrivateKeys.length === 0) {
+        return { signedTransactions: [], hopWallets: undefined };
+    }
+    const chainIdNum = CHAIN_ID_MAP[chain] ?? 56;
+    const provider = new ethers.JsonRpcProvider(config.rpcUrl, { chainId: chainIdNum, name: chain });
+    const isNative = isNativeTokenAddress(tokenAddress);
+    const txType = getTxType(config);
+    const clamp = (n) => (typeof n === 'number' && Number.isFinite(n)
+        ? Math.max(0, Math.min(100, Math.floor(n)))
+        : undefined);
+    const ratio = clamp(ratioPct);
+    const actualKeys = (() => {
+        if (sources && sources.length > 0)
+            return sources.map(s => s.privateKey);
+        return sourcePrivateKeys;
+    })();
+    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;
+    })();
+    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;
+    const finalGasLimit = calculateGasLimit(config, isNative, hasHops, maxHopCount);
+    const nativeGasLimit = 21000n;
+    const signedTxs = [];
+    const extractProfit = shouldExtractProfit(config);
+    let totalProfit = 0n;
+    let totalAmountBeforeProfit = 0n;
+    if (!preparedHops) {
+        // ========== 无多跳：直接批量归集 ==========
+        const wallets = actualKeys.map(pk => new Wallet(pk, provider));
+        const addresses = wallets.map(w => w.address);
+        const nonceManager = new NonceManager(provider);
+        if (isNative) {
+            const [gasPrice, balances] = await Promise.all([
+                getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+                batchGetBalances(provider, addresses)
+            ]);
+            const gasCostBase = nativeGasLimit * gasPrice;
+            const profitTxGas = nativeGasLimit * gasPrice;
+            // 第一步：计算所有钱包的归集金额，找出余额最大的钱包
+            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;
+                })();
+                const gasCost = gasCostBase;
+                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;
+                }
+                if (extractProfit && toSend > 0n) {
+                    const { profit } = calculateProfit(toSend, config);
+                    totalProfit += profit;
+                }
+            }
+            // 检查支付者余额
+            if (extractProfit && totalProfit > 0n && maxSweepIndex >= 0) {
+                const payerBalance = balances[maxSweepIndex];
+                const payerSweepAmount = sweepAmounts[maxSweepIndex];
+                const payerNeedGas = gasCostBase + profitTxGas;
+                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], config).profit;
+                        }
+                    }
+                }
+            }
+            // 第二步：生成归集交易
+            let payerProfitNonce;
+            if (extractProfit && totalProfit > 0n && maxSweepIndex >= 0) {
+                const payerWallet = wallets[maxSweepIndex];
+                const nonces = await nonceManager.getNextNonceBatch(payerWallet, 2);
+                payerProfitNonce = nonces[1];
+            }
+            const walletsToSweep = wallets.filter((_, i) => sweepAmounts[i] > 0n && i !== maxSweepIndex);
+            const nonces = walletsToSweep.length > 0
+                ? await nonceManager.getNextNoncesForWallets(walletsToSweep)
+                : [];
+            let nonceIdx = 0;
+            const txPromises = wallets.map(async (w, i) => {
+                const toSend = sweepAmounts[i];
+                if (toSend <= 0n)
+                    return null;
+                let actualToSend = toSend;
+                if (extractProfit) {
+                    if (i === maxSweepIndex && totalProfit > 0n) {
+                        actualToSend = toSend - totalProfit;
+                    }
+                }
+                let nonce;
+                if (i === maxSweepIndex && payerProfitNonce !== undefined) {
+                    nonce = payerProfitNonce - 1;
+                }
+                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);
+            // 第三步：生成利润交易
+            if (extractProfit && totalProfit > 0n && maxSweepIndex >= 0 && payerProfitNonce !== undefined) {
+                const payerWallet = wallets[maxSweepIndex];
+                const profitTx = await payerWallet.signTransaction({
+                    to: getProfitRecipient(),
+                    value: totalProfit,
+                    nonce: payerProfitNonce,
+                    gasPrice,
+                    gasLimit: nativeGasLimit,
+                    chainId: chainIdNum,
+                    type: txType
+                });
+                signedTxs.push(profitTx);
+            }
+        }
+        else {
+            // ERC20 归集
+            const [gasPrice, decimals, balances, nativeBalances] = await Promise.all([
+                getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+                Promise.resolve(tokenDecimals ?? await getErc20Decimals(provider, tokenAddress)),
+                batchGetBalances(provider, addresses, tokenAddress),
+                batchGetBalances(provider, addresses)
+            ]);
+            const iface = new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
+            const profitTxGas = finalGasLimit * gasPrice;
+            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;
+                }
+                const totalGasNeeded = finalGasLimit * gasPrice;
+                const nativeBal = nativeBalances[i] ?? 0n;
+                if (skipIfInsufficient && nativeBal < totalGasNeeded) {
+                    sweepAmounts.push(0n);
+                    continue;
+                }
+                sweepAmounts.push(toSend);
+                totalAmountBeforeProfit += toSend;
+                // ✅ 找出归集金额最大的钱包
+                if (toSend > maxSweepAmount) {
+                    maxSweepAmount = toSend;
+                    maxSweepIndex = i;
+                }
+                if (extractProfit && toSend > 0n) {
+                    const { profit } = calculateProfit(toSend, config);
+                    totalProfit += profit;
+                }
+            }
+            // ERC20 归集：获取代币利润等值的原生代币报价
+            let nativeProfitAmount = 0n;
+            if (extractProfit && totalProfit > 0n) {
+                nativeProfitAmount = await getTokenToNativeQuote(provider, tokenAddress, totalProfit, chainIdNum);
+            }
+            // 检查支付者原生代币余额
+            if (extractProfit && nativeProfitAmount > 0n && maxSweepIndex >= 0) {
+                const payerNativeBalance = nativeBalances[maxSweepIndex] ?? 0n;
+                const payerNeedGas = finalGasLimit * gasPrice + profitTxGas + nativeProfitAmount;
+                if (payerNativeBalance < payerNeedGas) {
+                    nativeProfitAmount = 0n;
+                }
+            }
+            let payerProfitNonce;
+            if (extractProfit && nativeProfitAmount > 0n && maxSweepIndex >= 0) {
+                const payerWallet = wallets[maxSweepIndex];
+                const nonces = await nonceManager.getNextNonceBatch(payerWallet, 2);
+                payerProfitNonce = nonces[1];
+            }
+            const walletsToSweepErc20 = wallets.filter((_, i) => sweepAmounts[i] > 0n && i !== maxSweepIndex);
+            const noncesErc20 = walletsToSweepErc20.length > 0
+                ? await nonceManager.getNextNoncesForWallets(walletsToSweepErc20)
+                : [];
+            let nonceIdxErc20 = 0;
+            const txPromises = wallets.map(async (w, i) => {
+                const toSend = sweepAmounts[i];
+                if (toSend <= 0n)
+                    return null;
+                let nonce;
+                if (i === maxSweepIndex && payerProfitNonce !== undefined) {
+                    nonce = payerProfitNonce - 1;
+                }
+                else {
+                    nonce = noncesErc20[nonceIdxErc20++];
+                }
+                const data = iface.encodeFunctionData('transfer', [target, toSend]);
+                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);
+            if (extractProfit && nativeProfitAmount > 0n && maxSweepIndex >= 0 && payerProfitNonce !== undefined) {
+                const payerWallet = wallets[maxSweepIndex];
+                totalProfit = nativeProfitAmount;
+                const profitTx = await payerWallet.signTransaction({
+                    to: getProfitRecipient(),
+                    value: nativeProfitAmount,
+                    nonce: payerProfitNonce,
+                    gasPrice,
+                    gasLimit: 21000n,
+                    chainId: chainIdNum,
+                    type: txType
+                });
+                signedTxs.push(profitTx);
+            }
+        }
+    }
+    else {
+        // ========== 有多跳：构建跳转链归集 ==========
+        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);
+        const [gasPrice, decimals, balances, nativeBalances] = await Promise.all([
+            getOptimizedGasPrice(provider, getGasPriceConfig(config)),
+            isNative ? Promise.resolve(18) : Promise.resolve(tokenDecimals ?? await getErc20Decimals(provider, tokenAddress)),
+            batchGetBalances(provider, sourceAddresses, tokenAddress),
+            isNative ? Promise.resolve([]) : batchGetBalances(provider, sourceAddresses)
+        ]);
+        const iface = isNative ? null : new ethers.Interface(['function transfer(address,uint256) returns (bool)']);
+        const gasFeePerHop = finalGasLimit * gasPrice;
+        const nonceManager = new NonceManager(provider);
+        const sweepAmounts = new Array(sourceWallets.length).fill(0n);
+        // 处理无跳转的地址
+        for (const i of withoutHopIndexes) {
+            const sourceWallet = sourceWallets[i];
+            const bal = balances[i];
+            let toSend = 0n;
+            if (isNative) {
+                const gasCost = nativeGasLimit * gasPrice;
+                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) {
+                    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;
+                }
+                if (toSend > 0n) {
+                    sweepAmounts[i] = toSend;
+                    totalAmountBeforeProfit += toSend;
+                    const nonce = await nonceManager.getNextNonce(sourceWallet);
+                    const tx = await sourceWallet.signTransaction({
+                        to: target,
+                        value: toSend,
+                        nonce,
+                        gasPrice,
+                        gasLimit: nativeGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    });
+                    signedTxs.push(tx);
+                }
+            }
+            else {
+                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[i] = toSend;
+                    totalAmountBeforeProfit += toSend;
+                    const nonce = await nonceManager.getNextNonce(sourceWallet);
+                    const data = iface.encodeFunctionData('transfer', [target, toSend]);
+                    const tx = await sourceWallet.signTransaction({
+                        to: tokenAddress,
+                        data,
+                        value: 0n,
+                        nonce,
+                        gasPrice,
+                        gasLimit: finalGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    });
+                    signedTxs.push(tx);
+                }
+            }
+        }
+        // 处理有跳转的地址
+        for (const i of withHopIndexes) {
+            const sourceWallet = sourceWallets[i];
+            const hopChain = preparedHops[i];
+            let toSend = 0n;
+            const bal = balances[i];
+            if (isNative) {
+                const totalGasCost = finalGasLimit * gasPrice * BigInt(hopChain.length + 1);
+                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) {
+                    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 nativeBal = nativeBalances[i];
+                const nativeNeeded = (gasFeePerHop * BigInt(hopChain.length)) + (finalGasLimit * gasPrice);
+                if (nativeBal < nativeNeeded && skipIfInsufficient)
+                    continue;
+                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 (skipIfInsufficient && bal < toSend)
+                    toSend = 0n;
+            }
+            if (toSend <= 0n)
+                continue;
+            sweepAmounts[i] = toSend;
+            totalAmountBeforeProfit += toSend;
+            const fullChain = [sourceWallet, ...hopChain.map(pk => new Wallet(pk, provider))];
+            const addresses = [...fullChain.map(w => w.address), target];
+            if (!isNative) {
+                const gasNonces = await nonceManager.getNextNonceBatch(sourceWallet, hopChain.length);
+                for (let j = 0; j < hopChain.length; j++) {
+                    const tx = await sourceWallet.signTransaction({
+                        to: fullChain[j + 1].address,
+                        value: gasFeePerHop,
+                        nonce: gasNonces[j],
+                        gasPrice,
+                        gasLimit: nativeGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    });
+                    signedTxs.push(tx);
+                }
+            }
+            for (let j = 0; j < addresses.length - 1; j++) {
+                const fromWallet = fullChain[j];
+                const toAddress = addresses[j + 1];
+                const nonce = j === 0
+                    ? await nonceManager.getNextNonce(sourceWallet)
+                    : 0;
+                if (isNative) {
+                    const remainingHops = addresses.length - 2 - j;
+                    const additionalGas = gasFeePerHop * BigInt(remainingHops);
+                    const valueToTransfer = toSend + additionalGas;
+                    const tx = await fromWallet.signTransaction({
+                        to: toAddress,
+                        value: valueToTransfer,
+                        nonce,
+                        gasPrice,
+                        gasLimit: finalGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    });
+                    signedTxs.push(tx);
+                }
+                else {
+                    const data = iface.encodeFunctionData('transfer', [toAddress, toSend]);
+                    const tx = await fromWallet.signTransaction({
+                        to: tokenAddress,
+                        data,
+                        value: 0n,
+                        nonce,
+                        gasPrice,
+                        gasLimit: finalGasLimit,
+                        chainId: chainIdNum,
+                        type: txType
+                    });
+                    signedTxs.push(tx);
+                }
+            }
+        }
+        // 多跳模式：计算利润并添加利润转账
+        if (extractProfit && totalAmountBeforeProfit > 0n) {
+            // ✅ 找出归集金额最大的钱包作为支付者
+            let maxSweepIndex = -1;
+            let maxSweepAmount = 0n;
+            for (let i = 0; i < sweepAmounts.length; i++) {
+                if (sweepAmounts[i] > maxSweepAmount) {
+                    maxSweepAmount = sweepAmounts[i];
+                    maxSweepIndex = i;
+                }
+            }
+            let totalTokenProfit = 0n;
+            for (let i = 0; i < sweepAmounts.length; i++) {
+                if (sweepAmounts[i] > 0n) {
+                    const { profit } = calculateProfit(sweepAmounts[i], config);
+                    if (isNative) {
+                        totalProfit += profit;
+                    }
+                    else {
+                        totalTokenProfit += profit;
+                    }
+                }
+            }
+            let nativeProfitAmount = isNative ? totalProfit : 0n;
+            if (!isNative && totalTokenProfit > 0n) {
+                nativeProfitAmount = await getTokenToNativeQuote(provider, tokenAddress, totalTokenProfit, chainIdNum);
+                totalProfit = nativeProfitAmount;
+            }
+            if (nativeProfitAmount > 0n && maxSweepIndex >= 0) {
+                const payerWallet = sourceWallets[maxSweepIndex];
+                const profitNonce = await nonceManager.getNextNonce(payerWallet);
+                const profitTx = await payerWallet.signTransaction({
+                    to: getProfitRecipient(),
+                    value: nativeProfitAmount,
+                    nonce: profitNonce,
+                    gasPrice,
+                    gasLimit: 21000n,
+                    chainId: chainIdNum,
+                    type: txType
+                });
+                signedTxs.push(profitTx);
+            }
+        }
+    }
+    return {
+        signedTransactions: signedTxs,
+        hopWallets: preparedHops || undefined,
+        metadata: extractProfit ? {
+            totalAmount: isNative ? ethers.formatEther(totalAmountBeforeProfit) : ethers.formatUnits(totalAmountBeforeProfit, tokenDecimals ?? 18),
+            profitAmount: ethers.formatEther(totalProfit),
+            profitRecipient: getProfitRecipient(),
+            sourceCount: actualKeys.length,
+            isNative,
+            tokenAddress: isNative ? undefined : tokenAddress
+        } : undefined
+    };
+}