four-flap-meme-sdk 2.0.0 → 2.2.0

package/dist/chains/xlayer/eip7702/volume/index.js

@@ -1,793 +0,0 @@
-/**
- * EIP-7702 XLayer 刷量功能
- *
- * 支持两种模式：
- * 1. 无币模式 (Wash): 单钱包买入+卖出，不需要预先持有代币
- * 2. 捆绑模式 (Bundle): 多钱包批量买入 + 批量卖出
- *
- * 支持池子类型：
- * - FLAP: 内盘 (Flap Portal)
- * - V2: PotatoSwap V2 外盘
- * - V3: PotatoSwap V3 外盘
- *
- * 只生成签名，由调用方决定如何提交
- */
-import { ethers, Contract } from 'ethers';
-import { getCachedProvider, createWallet, signAuthorizationsWithNonces, batchGetNonces, buildEIP7702TransactionSync, calculateProfitAmountByTxCount, getProfitRecipient, } from '../utils.js';
-import { UNIFIED_DELEGATE_ADDRESS, UNIFIED_DELEGATE_ABI, FLAP_PORTAL_ABI, FLAP_PORTAL_ADDRESS, POTATOSWAP_V2_ROUTER, POTATOSWAP_V3_ROUTER, WOKB_ADDRESS, V3_FEE_TIERS, ERC20_ABI, V2_ROUTER_ABI, } from '../constants.js';
-import { bundleBuy } from '../bundle-buy.js';
-import { bundleSell } from '../bundle-sell.js';
-import { bundleSwap } from '../bundle-swap.js';
-// ========================================
-// 类型定义
-// ========================================
-/**
- * 截断小数位数，避免 parseEther/parseUnits 报错
- * @param value 数值字符串
- * @param decimals 保留的小数位数（默认 18）
- */
-function truncateDecimals(value, decimals = 18) {
-    if (!value || value === '0')
-        return value;
-    const parts = String(value).split('.');
-    if (parts.length === 1)
-        return value;
-    const intPart = parts[0] || '0';
-    const decPart = (parts[1] || '').slice(0, decimals);
-    return decPart ? `${intPart}.${decPart}` : intPart;
-}
-// ========================================
-// 无币刷量 (Wash Mode)
-// ========================================
-/**
- * 无币刷量 - 每个钱包执行买入+卖出
- *
- * 核心逻辑：[利润刮取] + [钱包1买入] + [钱包1卖出] + [钱包2买入] + [钱包2卖出] + ...
- *
- * 特点：
- * - 钱包不需要预先持有代币
- * - 每个钱包在同一笔交易中完成买入和卖出
- * - 利润从主钱包统一支付
- *
- * @example
- * const result = await washVolume({
- *   privateKeys: ['0x...', '0x...'],
- *   tokenAddress: '0x...',
- *   buyAmountPerWallet: '0.01',
- *   sellPercent: 100,
- *   poolType: 'V3',
- * });
- */
-export async function washVolume(params) {
-    const { mainPrivateKey, privateKeys, tokenAddress, tokenDecimals = 18, buyAmountPerWallet, sellPercent = 100, poolType = 'V3', routerAddress, fee = V3_FEE_TIERS.MEDIUM, userType = 'v0', // ✅ 用户类型（影响利润率）
-    config, } = params;
-    if (!mainPrivateKey) {
-        throw new Error('必须提供 mainPrivateKey（Payer 钱包私钥）');
-    }
-    if (privateKeys.length === 0) {
-        throw new Error('至少需要一个钱包');
-    }
-    // ✅ 验证私钥格式
-    const isValidPrivateKey = (pk) => {
-        const trimmed = (pk || '').trim();
-        return trimmed.length >= 64 && (trimmed.startsWith('0x') || /^[0-9a-fA-F]{64}$/.test(trimmed));
-    };
-    if (!isValidPrivateKey(mainPrivateKey)) {
-        throw new Error('mainPrivateKey 格式无效');
-    }
-    const validPrivateKeys = privateKeys.filter(pk => isValidPrivateKey(pk));
-    if (validPrivateKeys.length === 0) {
-        throw new Error('没有有效的私钥（私钥必须是 0x 开头的 66 位或 64 位十六进制字符串）');
-    }
-    if (validPrivateKeys.length !== privateKeys.length) {
-        console.warn(`[washVolume] 跳过 ${privateKeys.length - validPrivateKeys.length} 个无效私钥`);
-    }
-    // 使用验证后的私钥
-    const actualPrivateKeys = validPrivateKeys;
-    const provider = getCachedProvider(config?.rpcUrl);
-    // ✅ 空字符串也使用默认值
-    const delegateAddress = (config?.delegateAddress && config.delegateAddress.trim()) || UNIFIED_DELEGATE_ADDRESS;
-    const delegateInterface = new ethers.Interface(UNIFIED_DELEGATE_ABI);
-    const portalInterface = new ethers.Interface(FLAP_PORTAL_ABI);
-    // 获取实际路由地址
-    const actualRouter = routerAddress ?? getDefaultRouter(poolType);
-    // ✅ 创建 Payer 钱包（支付 Gas 费）
-    const mainWallet = createWallet(mainPrivateKey, provider);
-    // 创建交易钱包（使用验证后的私钥）
-    const wallets = actualPrivateKeys.map(pk => createWallet(pk, provider));
-    // 计算金额（无币刷量：每个钱包 1买 + 1卖 = 2笔交易）
-    const buyAmountWei = ethers.parseEther(truncateDecimals(buyAmountPerWallet));
-    const totalBuyAmount = buyAmountWei * BigInt(wallets.length);
-    const totalTxCount = wallets.length * 2; // 每个钱包 1买 + 1卖
-    const profitAmount = calculateProfitAmountByTxCount(totalBuyAmount, totalTxCount, userType);
-    const profitRecipient = getProfitRecipient(config);
-    // ========================================
-    // 合并所有钱包（去重）
-    // mainWallet 需要参与授权签名（因为它执行利润刮取的 delegate 调用）
-    // ========================================
-    const allWalletsMap = new Map();
-    allWalletsMap.set(mainWallet.address.toLowerCase(), mainWallet);
-    wallets.forEach(w => allWalletsMap.set(w.address.toLowerCase(), w));
-    const allWallets = Array.from(allWalletsMap.values());
-    // 找出 mainWallet 在 allWallets 中的索引
-    const mainWalletIndex = allWallets.findIndex(w => w.address.toLowerCase() === mainWallet.address.toLowerCase());
-    // ========================================
-    // 并行获取数据
-    // ========================================
-    const allAddresses = allWallets.map(w => w.address);
-    // ✅ 对所有模式，使用【总金额报价 + 按比例分配】
-    // 因为所有钱包在同一笔交易中执行，会累积影响价格
-    // 这确保了「买多少就卖多少」，避免清空钱包预存代币
-    let estimatedTokenAmounts = [];
-    const totalBuyWei = buyAmountWei * BigInt(wallets.length);
-    if (poolType === 'FLAP') {
-        console.log(`[washVolume] FLAP 总金额报价: ${wallets.length} 个钱包, 每个 ${buyAmountWei} wei, 总计 ${totalBuyWei} wei`);
-        try {
-            const portalContract = new Contract(FLAP_PORTAL_ADDRESS, FLAP_PORTAL_ABI, provider);
-            // ✅ 使用 previewBuy（与 AA 模式一致），降级到 quoteExactInput
-            // 某些代币的 previewBuy 会 revert (0xac5f6092)，降级到 quoteExactInput
-            let totalTokenAmount = 0n;
-            try {
-                totalTokenAmount = await portalContract.previewBuy(tokenAddress, totalBuyWei);
-                console.log(`[washVolume] FLAP previewBuy 总预估: ${totalBuyWei} wei OKB -> ${totalTokenAmount} wei 代币`);
-            }
-            catch (previewErr) {
-                console.warn(`[washVolume] previewBuy 失败，尝试 quoteExactInput:`, previewErr);
-                try {
-                    // ✅ 降级到 quoteExactInput（与 AA 模式相同的降级策略）
-                    totalTokenAmount = await portalContract.quoteExactInput.staticCall({
-                        inputToken: ethers.ZeroAddress, // OKB
-                        outputToken: tokenAddress, // Token
-                        inputAmount: totalBuyWei,
-                    });
-                    console.log(`[washVolume] FLAP quoteExactInput 总预估: ${totalBuyWei} wei OKB -> ${totalTokenAmount} wei 代币`);
-                }
-                catch (quoteErr) {
-                    console.warn(`[washVolume] quoteExactInput 也失败:`, quoteErr);
-                    totalTokenAmount = 0n;
-                }
-            }
-            // 按每个钱包的买入金额比例分配（由于每个钱包金额相同，均分即可）
-            if (totalBuyWei > 0n && totalTokenAmount > 0n) {
-                const sharePerWallet = totalTokenAmount / BigInt(wallets.length);
-                let allocated = 0n;
-                estimatedTokenAmounts = wallets.map((_, i) => {
-                    if (i === wallets.length - 1) {
-                        // 最后一个钱包分配剩余的全部（避免精度损失）
-                        return totalTokenAmount - allocated;
-                    }
-                    allocated += sharePerWallet;
-                    return sharePerWallet;
-                });
-            }
-            console.log(`[washVolume] FLAP 代币分配:`, estimatedTokenAmounts.map(a => a.toString()));
-        }
-        catch (e) {
-            console.warn(`[washVolume] FLAP 报价失败:`, e);
-        }
-    }
-    else if (poolType === 'V2' || poolType === 'V3') {
-        // ✅ V2/V3 外盘模式：通过报价获取预估代币数量，确保买卖对等
-        console.log(`[washVolume] ${poolType} 总金额报价: ${wallets.length} 个钱包, 每个 ${buyAmountWei} wei, 总计 ${totalBuyWei} wei`);
-        try {
-            const { quoteV2, quoteV3 } = await import('../../../../utils/quote-helpers.js');
-            let totalTokenAmount = 0n;
-            if (poolType === 'V3') {
-                const result = await quoteV3(provider, WOKB_ADDRESS, tokenAddress, totalBuyWei, 'XLAYER', fee);
-                totalTokenAmount = result.amountOut;
-                console.log(`[washVolume] V3 报价成功: ${totalBuyWei} wei OKB -> ${totalTokenAmount} wei 代币 (fee: ${fee})`);
-            }
-            else {
-                const result = await quoteV2(provider, WOKB_ADDRESS, tokenAddress, totalBuyWei, 'XLAYER');
-                totalTokenAmount = result.amountOut;
-                console.log(`[washVolume] V2 报价成功: ${totalBuyWei} wei OKB -> ${totalTokenAmount} wei 代币`);
-            }
-            // 均分到每个钱包
-            if (totalBuyWei > 0n && totalTokenAmount > 0n) {
-                const sharePerWallet = totalTokenAmount / BigInt(wallets.length);
-                let allocated = 0n;
-                estimatedTokenAmounts = wallets.map((_, i) => {
-                    if (i === wallets.length - 1) {
-                        return totalTokenAmount - allocated;
-                    }
-                    allocated += sharePerWallet;
-                    return sharePerWallet;
-                });
-                console.log(`[washVolume] ${poolType} 代币分配:`, estimatedTokenAmounts.map(a => a.toString()));
-            }
-        }
-        catch (e) {
-            console.warn(`[washVolume] ${poolType} 报价失败，将使用 sellPercent 模式:`, e);
-        }
-    }
-    const [nonces, feeData] = await Promise.all([
-        batchGetNonces(allAddresses, provider),
-        provider.getFeeData(),
-    ]);
-    // ========================================
-    // 同步签署授权
-    // ========================================
-    const authorizations = signAuthorizationsWithNonces(allWallets, nonces, delegateAddress, mainWalletIndex // mainWallet 是交易发起者
-    );
-    // ========================================
-    // 构建调用
-    // ========================================
-    const calls = [];
-    // ✅ 修复：先执行买卖，最后执行利润转账（与 bundleBuy 调用顺序一致）
-    // 每个钱包执行买入 + 卖出
-    for (let i = 0; i < wallets.length; i++) {
-        const wallet = wallets[i];
-        // 买入调用
-        const buyCall = buildBuyCall(wallet, buyAmountWei, tokenAddress, poolType, actualRouter, fee, delegateInterface, portalInterface);
-        calls.push(buyCall);
-        // 卖出调用（使用预估的代币数量）
-        // ✅ 统一所有模式：当有预估数量时使用精确卖出，确保买卖对等
-        const estimatedAmount = estimatedTokenAmounts[i] || 0n;
-        const sellCall = estimatedAmount > 0n
-            ? buildSellCallWithAmount(wallet, estimatedAmount, tokenAddress, poolType, actualRouter, fee, delegateInterface, portalInterface)
-            : buildSellCall(wallet, 0n, tokenAddress, sellPercent, tokenDecimals, poolType, actualRouter, fee, delegateInterface, portalInterface);
-        calls.push(sellCall);
-    }
-    // ✅ 修复：利润刮取从第一个参与刷量的钱包扣取（卖出后有OKB）
-    // 使用 transferAmount 从钱包余额转账，不需要通过 msg.value
-    if (profitAmount > 0n && wallets.length > 0) {
-        calls.push({
-            target: wallets[0].address, // 从第一个刷量钱包扣利润
-            allowFailure: false,
-            value: 0n,
-            callData: delegateInterface.encodeFunctionData('transferAmount', [profitRecipient, profitAmount]),
-        });
-    }
-    // ========================================
-    // 构建交易
-    // ========================================
-    // ✅ 修复：利润使用 transferAmount 从钱包余额转账，不需要通过 msg.value
-    const totalValue = 0n;
-    // ✅ 使用 mainWallet 的 nonce（mainWallet 是交易发起者和 Gas 支付者）
-    const signedTransaction = buildEIP7702TransactionSync(mainWallet, authorizations, calls, totalValue, nonces[mainWalletIndex], feeData, config);
-    return {
-        signedTransaction,
-        metadata: {
-            walletCount: wallets.length,
-            buyAmountPerWallet,
-            totalBuyAmount: ethers.formatEther(totalBuyAmount),
-            sellPercent,
-            poolType,
-            profitAmount: ethers.formatEther(profitAmount),
-        },
-    };
-}
-// ========================================
-// 捆绑刷量 (Bundle Mode)
-// ========================================
-/**
- * 捆绑刷量 - 多钱包批量买入 + 批量卖出
- *
- * 核心逻辑：[利润刮取] + [买入Ops...] + [卖出Ops...]
- *
- * 特点：
- * - 买入和卖出可以使用不同的钱包
- * - 所有操作在一笔交易中原子执行
- * - 卖出钱包需要预先持有代币
- *
- * @example
- * const result = await bundleVolume({
- *   buyerPrivateKeys: ['0x...', '0x...'],
- *   buyAmounts: ['0.01', '0.02'],
- *   sellerPrivateKeys: ['0x...'],
- *   sellPercent: 100,
- *   tokenAddress: '0x...',
- *   poolType: 'FLAP',
- * });
- */
-export async function bundleVolume(params) {
-    const { mainPrivateKey, buyerPrivateKeys, buyAmounts, sellerPrivateKeys, sellAmounts, sellPercent = 100, tokenAddress, tokenDecimals = 18, poolType = 'V3', routerAddress, fee = V3_FEE_TIERS.MEDIUM, userType = 'v0', // ✅ 用户类型（影响利润率）
-    config, } = params;
-    // ✅ 验证私钥格式的辅助函数
-    const isValidPrivateKey = (pk) => {
-        const trimmed = (pk || '').trim();
-        return trimmed.length >= 64 && (trimmed.startsWith('0x') || /^[0-9a-fA-F]{64}$/.test(trimmed));
-    };
-    if (!mainPrivateKey || !isValidPrivateKey(mainPrivateKey)) {
-        throw new Error('必须提供有效的 mainPrivateKey（Payer 钱包私钥）');
-    }
-    // ✅ 验证买家私钥
-    const validBuyerIndices = [];
-    const validBuyerPrivateKeys = [];
-    const validBuyAmounts = [];
-    buyerPrivateKeys.forEach((pk, i) => {
-        if (isValidPrivateKey(pk)) {
-            validBuyerIndices.push(i);
-            validBuyerPrivateKeys.push(pk);
-            validBuyAmounts.push(buyAmounts[i] || '0');
-        }
-    });
-    if (validBuyerPrivateKeys.length === 0) {
-        throw new Error('没有有效的买家私钥');
-    }
-    // ✅ 验证卖家私钥
-    const validSellerPrivateKeys = sellerPrivateKeys.filter(pk => isValidPrivateKey(pk));
-    if (validSellerPrivateKeys.length === 0) {
-        throw new Error('没有有效的卖家私钥');
-    }
-    if (validBuyerPrivateKeys.length !== buyerPrivateKeys.length || validSellerPrivateKeys.length !== sellerPrivateKeys.length) {
-        console.warn(`[bundleVolume] 跳过无效私钥: 买家 ${buyerPrivateKeys.length - validBuyerPrivateKeys.length} 个, 卖家 ${sellerPrivateKeys.length - validSellerPrivateKeys.length} 个`);
-    }
-    const provider = getCachedProvider(config?.rpcUrl);
-    // ✅ 空字符串也使用默认值
-    const delegateAddress = (config?.delegateAddress && config.delegateAddress.trim()) || UNIFIED_DELEGATE_ADDRESS;
-    const delegateInterface = new ethers.Interface(UNIFIED_DELEGATE_ABI);
-    const portalInterface = new ethers.Interface(FLAP_PORTAL_ABI);
-    const actualRouter = routerAddress ?? getDefaultRouter(poolType);
-    // ✅ 创建 Payer 钱包（支付 Gas 费）
-    const mainWallet = createWallet(mainPrivateKey, provider);
-    // 创建钱包（使用验证后的私钥）
-    const buyerWallets = validBuyerPrivateKeys.map(pk => createWallet(pk, provider));
-    const sellerWallets = validSellerPrivateKeys.map(pk => createWallet(pk, provider));
-    // 合并所有钱包（去重，包括 mainWallet）
-    const allWalletsMap = new Map();
-    allWalletsMap.set(mainWallet.address.toLowerCase(), mainWallet);
-    buyerWallets.forEach(w => allWalletsMap.set(w.address.toLowerCase(), w));
-    sellerWallets.forEach(w => allWalletsMap.set(w.address.toLowerCase(), w));
-    const allWallets = Array.from(allWalletsMap.values());
-    // 找出 mainWallet 在 allWallets 中的索引
-    const mainWalletIndex = allWallets.findIndex(w => w.address.toLowerCase() === mainWallet.address.toLowerCase());
-    // 计算买入金额（使用验证后的金额数组）
-    const buyAmountsWei = validBuyAmounts.map(amt => ethers.parseEther(truncateDecimals(amt)));
-    const totalBuyAmount = buyAmountsWei.reduce((sum, amt) => sum + amt, 0n);
-    // ✅ 计算利润（捆绑刷量：买家数 + 卖家数 = 总交易数）
-    const totalTxCount = buyerWallets.length + sellerWallets.length;
-    const profitAmount = calculateProfitAmountByTxCount(totalBuyAmount, totalTxCount, userType);
-    const profitRecipient = getProfitRecipient(config);
-    // ========================================
-    // 并行获取数据
-    // ========================================
-    const allAddresses = allWallets.map(w => w.address);
-    // 获取卖出钱包的代币余额（如果需要）
-    const needBalanceQuery = !sellAmounts || sellAmounts.length !== sellerWallets.length;
-    const parallelPromises = [
-        batchGetNonces(allAddresses, provider),
-        provider.getFeeData(),
-    ];
-    if (needBalanceQuery && sellerWallets.length > 0) {
-        const tokenContract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
-        parallelPromises.push(Promise.all(sellerWallets.map(w => tokenContract.balanceOf(w.address))));
-    }
-    const results = await Promise.all(parallelPromises);
-    const nonces = results[0];
-    const feeData = results[1];
-    // 计算卖出金额
-    let sellAmountsWei;
-    if (sellAmounts && sellAmounts.length === sellerWallets.length) {
-        // ✅ 如果有指定卖出金额，直接使用
-        sellAmountsWei = sellAmounts.map(amt => ethers.parseUnits(truncateDecimals(amt, tokenDecimals), tokenDecimals));
-    }
-    else if (needBalanceQuery && results[2]) {
-        // ✅ 没有指定卖出金额，需要根据买入金额预估应卖出的代币数量
-        const balances = results[2].map(b => typeof b === 'bigint' ? b : BigInt(b.toString()));
-        const totalSellerBalance = balances.reduce((sum, b) => sum + b, 0n);
-        // ✅ 根据 poolType 预估买入能获得的代币数量
-        let estimatedTokenAmount = 0n;
-        try {
-            if (poolType === 'FLAP') {
-                // FLAP 内盘：使用 previewBuy，降级到 quoteExactInput
-                const portalContract = new ethers.Contract(FLAP_PORTAL_ADDRESS, FLAP_PORTAL_ABI, provider);
-                try {
-                    estimatedTokenAmount = await portalContract.previewBuy(tokenAddress, totalBuyAmount);
-                    console.log(`[bundleVolume] FLAP previewBuy: ${totalBuyAmount} wei OKB -> ${estimatedTokenAmount} wei 代币`);
-                }
-                catch (previewErr) {
-                    console.warn(`[bundleVolume] previewBuy 失败，尝试 quoteBuy:`, previewErr);
-                    try {
-                        estimatedTokenAmount = await portalContract.quoteBuy(tokenAddress, totalBuyAmount);
-                        console.log(`[bundleVolume] FLAP quoteBuy: ${totalBuyAmount} wei OKB -> ${estimatedTokenAmount} wei 代币`);
-                    }
-                    catch (quoteBuyErr) {
-                        console.warn(`[bundleVolume] quoteBuy 失败，尝试 quoteExactInput:`, quoteBuyErr);
-                        try {
-                            estimatedTokenAmount = await portalContract.quoteExactInput.staticCall({
-                                inputToken: ethers.ZeroAddress,
-                                outputToken: tokenAddress,
-                                inputAmount: totalBuyAmount,
-                            });
-                            console.log(`[bundleVolume] FLAP quoteExactInput: ${totalBuyAmount} wei OKB -> ${estimatedTokenAmount} wei 代币`);
-                        }
-                        catch (quoteErr) {
-                            console.warn(`[bundleVolume] quoteExactInput 也失败，尝试 V2 路由作为终极兜底:`, quoteErr);
-                            try {
-                                // 终极兜底：当内盘接口全部失效时，尝试使用 V2 代码进行报价
-                                const v2Router = new ethers.Contract(POTATOSWAP_V2_ROUTER, V2_ROUTER_ABI, provider);
-                                const path = [WOKB_ADDRESS, tokenAddress];
-                                const amounts = await v2Router.getAmountsOut(totalBuyAmount, path);
-                                estimatedTokenAmount = amounts[amounts.length - 1];
-                                console.log(`[bundleVolume] FLAP 终极回退 V2 quote: ${totalBuyAmount} wei OKB -> ${estimatedTokenAmount} wei 代币`);
-                            }
-                            catch (v2Err) {
-                                console.warn(`[bundleVolume] 终极回退 V2 quote 也失败:`, v2Err);
-                            }
-                        }
-                    }
-                }
-            }
-            else if (poolType === 'V2' || poolType === 'V3') {
-                // V2/V3 外盘：使用 Router 报价
-                const v2Router = new ethers.Contract(POTATOSWAP_V2_ROUTER, V2_ROUTER_ABI, provider);
-                const path = [WOKB_ADDRESS, tokenAddress];
-                try {
-                    if (poolType === 'V2') {
-                        const amounts = await v2Router.getAmountsOut(totalBuyAmount, path);
-                        estimatedTokenAmount = amounts[amounts.length - 1];
-                    }
-                    else {
-                        // V3: 使用 V3 Quoter
-                        const v3Quoter = new ethers.Contract('0x27d52F6D9Ed2eBb3E6a4c0Af6b1f5dc85A4d5b2C', [
-                            'function quoteExactInputSingle((address tokenIn, address tokenOut, uint256 amountIn, uint24 fee, uint160 sqrtPriceLimitX96)) external returns (uint256 amountOut)'
-                        ], provider);
-                        estimatedTokenAmount = await v3Quoter.quoteExactInputSingle.staticCall({
-                            tokenIn: WOKB_ADDRESS,
-                            tokenOut: tokenAddress,
-                            amountIn: totalBuyAmount,
-                            fee: fee,
-                            sqrtPriceLimitX96: 0n,
-                        });
-                    }
-                    console.log(`[bundleVolume] ${poolType} quote: ${totalBuyAmount} wei OKB -> ${estimatedTokenAmount} wei 代币`);
-                }
-                catch (quoteErr) {
-                    console.warn(`[bundleVolume] ${poolType} 报价失败:`, quoteErr);
-                }
-            }
-        }
-        catch (e) {
-            console.warn(`[bundleVolume] 报价预估失败:`, e);
-        }
-        // ✅ 修正卖出数量计算逻辑：卖出数额仅基于本次交易买入的代币预估值，忽略原有余额
-        const percentBigInt = BigInt(Math.min(100, Math.max(0, sellPercent)));
-        // 1. 初始化每个钱包的预期卖出数量为 0n
-        const walletSellAmounts = sellerWallets.map(() => 0n);
-        // 2. 将本次预估买入的代币分配给卖家
-        if (estimatedTokenAmount > 0n && totalBuyAmount > 0n && sellerWallets.length > 0) {
-            // ✅ 修正逻辑：将本次买入预估产生的总代币量随机分配给所有指定的卖家
-            const totalToSell = (estimatedTokenAmount * percentBigInt) / 100n;
-            if (sellerWallets.length === 1) {
-                walletSellAmounts[0] = totalToSell;
-            }
-            else {
-                // ✅ 多卖家场景：随机权重分配 (50% - 150%)，差异更明显
-                const weights = sellerWallets.map(() => 50 + Math.random() * 100);
-                const totalWeight = weights.reduce((sum, w) => sum + w, 0);
-                let allocated = 0n;
-                sellerWallets.forEach((_, i) => {
-                    if (i === sellerWallets.length - 1) {
-                        // 最后一个钱包分配剩余的全部（避免精度损失）
-                        walletSellAmounts[i] = totalToSell - allocated;
-                    }
-                    else {
-                        const share = (totalToSell * BigInt(Math.round(weights[i] * 1000))) / BigInt(Math.round(totalWeight * 1000));
-                        walletSellAmounts[i] = share;
-                        allocated += share;
-                    }
-                });
-            }
-            console.log(`[bundleVolume] 每个卖家随机分配的卖出量:`, walletSellAmounts.map(a => a.toString()));
-        }
-        // ✅ 修复：不再重复应用 sellPercent，因为 totalToSell 已经按 sellPercent 计算过了
-        sellAmountsWei = walletSellAmounts;
-        console.log(`[bundleVolume] 最终卖出数量 (sellPercent=${sellPercent}%):`, sellAmountsWei.map(a => a.toString()));
-    }
-    else {
-        // ✅ 即使没有余额查询结果，也初始化数组
-        sellAmountsWei = sellerWallets.map(() => 0n);
-    }
-    const totalSellAmount = sellAmountsWei.reduce((sum, amt) => sum + amt, 0n);
-    // ========================================
-    // 同步签署授权
-    // ========================================
-    const authorizations = signAuthorizationsWithNonces(allWallets, nonces, delegateAddress, mainWalletIndex);
-    // ========================================
-    // 构建调用
-    // ========================================
-    const calls = [];
-    // ✅ 修复：先执行买卖，最后执行利润转账（与 bundleBuy 调用顺序一致）
-    // 买入调用
-    for (let i = 0; i < buyerWallets.length; i++) {
-        const buyCall = buildBuyCall(buyerWallets[i], buyAmountsWei[i], tokenAddress, poolType, actualRouter, fee, delegateInterface, portalInterface);
-        calls.push(buyCall);
-    }
-    // 卖出调用
-    for (let i = 0; i < sellerWallets.length; i++) {
-        const amount = sellAmountsWei[i];
-        // ✅ 修复：即使 amount 为 0，只要 sellPercent 为 100，也应该尝试卖出全部，防止刷量缺失 Sell
-        if (amount <= 0n && sellPercent !== 100)
-            continue;
-        const sellCall = amount > 0n
-            ? buildSellCallWithAmount(sellerWallets[i], amount, tokenAddress, poolType, actualRouter, fee, delegateInterface, portalInterface)
-            : buildSellCall(sellerWallets[i], 0n, // amount = 0n 配合 sellPercent = 100 会执行卖出全部
-            tokenAddress, sellPercent, tokenDecimals, poolType, actualRouter, fee, delegateInterface, portalInterface);
-        calls.push(sellCall);
-    }
-    // ✅ 修复：利润刮取从第一个卖方钱包扣取（卖出后有OKB）
-    // 使用 transferAmount 从钱包余额转账，不需要通过 msg.value
-    if (profitAmount > 0n && sellerWallets.length > 0) {
-        calls.push({
-            target: sellerWallets[0].address, // 从第一个卖方钱包扣利润
-            allowFailure: false,
-            value: 0n,
-            callData: delegateInterface.encodeFunctionData('transferAmount', [profitRecipient, profitAmount]),
-        });
-    }
-    // ========================================
-    // 构建交易
-    // ========================================
-    // ✅ 修复：利润使用 transferAmount 从钱包余额转账，不需要通过 msg.value
-    const totalValue = 0n;
-    const signedTransaction = buildEIP7702TransactionSync(mainWallet, authorizations, calls, totalValue, nonces[mainWalletIndex], feeData, config);
-    return {
-        signedTransaction,
-        metadata: {
-            buyerCount: buyerWallets.length,
-            sellerCount: sellerWallets.filter((_, i) => sellAmountsWei[i] > 0n).length,
-            totalBuyAmount: ethers.formatEther(totalBuyAmount),
-            totalSellAmount: ethers.formatUnits(totalSellAmount, tokenDecimals),
-            poolType,
-            profitAmount: ethers.formatEther(profitAmount),
-        },
-    };
-}
-// ========================================
-// 单轮刷量（买入+卖出分开签名）
-// ========================================
-/**
- * 生成单轮刷量签名（买入 + 卖出分开）
- *
- * 注意：买入和卖出是两笔独立交易
- */
-export async function singleRoundVolume(params) {
-    const { privateKeys, tokenAddress, tokenDecimals = 18, buyAmountPerWallet, sellPercent = 100, tradeType = 'V3', routerAddress, fee = V3_FEE_TIERS.MEDIUM, config, } = params;
-    const mainPrivateKey = privateKeys[0];
-    // 并行生成买入和卖出签名
-    const [buyResult, sellResult] = await Promise.all([
-        bundleBuy({
-            mainPrivateKey,
-            privateKeys,
-            buyAmounts: privateKeys.map(() => buyAmountPerWallet),
-            tokenAddress,
-            tradeType,
-            routerAddress,
-            fee,
-            config,
-        }),
-        bundleSell({
-            mainPrivateKey,
-            privateKeys,
-            sellPercent,
-            tokenAddress,
-            tokenDecimals,
-            tradeType,
-            routerAddress,
-            fee,
-            config,
-        }),
-    ]);
-    return {
-        buySignedTransaction: buyResult.signedTransaction,
-        sellSignedTransaction: sellResult.signedTransaction,
-        metadata: {
-            buyAmount: buyAmountPerWallet,
-            sellPercent,
-            walletCount: privateKeys.length,
-        },
-    };
-}
-// ========================================
-// 多轮刷量
-// ========================================
-/**
- * 生成多轮刷量签名
- *
- * 注意：由于 nonce 问题，只能预生成第一轮
- * 后续轮次需要在前一轮交易确认后才能生成
- */
-export async function makeVolume(params) {
-    const { privateKeys, tokenAddress, tokenDecimals = 18, buyAmountPerRound, rounds, tradeType = 'V3', routerAddress, fee = V3_FEE_TIERS.MEDIUM, onProgress, config, } = params;
-    const buyAmountPerWallet = (parseFloat(buyAmountPerRound) / privateKeys.length).toString();
-    const roundResults = [];
-    // 只生成第一轮签名
-    const firstRound = await singleRoundVolume({
-        privateKeys,
-        tokenAddress,
-        tokenDecimals,
-        buyAmountPerWallet,
-        tradeType,
-        routerAddress,
-        fee,
-        config,
-    });
-    roundResults.push(firstRound);
-    onProgress?.({
-        currentRound: 1,
-        totalRounds: rounds,
-        status: 'completed',
-    });
-    return {
-        rounds: roundResults,
-        metadata: {
-            totalRounds: rounds,
-            totalBuyAmount: (parseFloat(buyAmountPerRound) * rounds).toString(),
-            walletCount: privateKeys.length,
-        },
-    };
-}
-// ========================================
-// 换手刷量
-// ========================================
-/**
- * 生成换手刷量签名
- */
-export async function makeVolumeWithSwap(params) {
-    const { sellerPrivateKey, buyerPrivateKey, tokenAddress, tokenDecimals = 18, sellAmount, hopCount = 2, tradeType = 'V3', routerAddress, fee = V3_FEE_TIERS.MEDIUM, config, } = params;
-    const result = await bundleSwap({
-        sellerPrivateKey,
-        buyerPrivateKey,
-        tokenAddress,
-        tokenDecimals,
-        sellAmount,
-        hopCount,
-        tradeType,
-        routerAddress,
-        fee,
-        config,
-    });
-    return {
-        signedTransaction: result.signedTransaction,
-        hopWallets: result.hopWallets || [],
-        metadata: {
-            sellerAddress: result.metadata.sellerAddress,
-            buyerAddress: result.metadata.buyerAddresses[0],
-            sellAmount: result.metadata.sellAmount,
-        },
-    };
-}
-// ========================================
-// 工具函数
-// ========================================
-function getDefaultRouter(poolType) {
-    switch (poolType) {
-        case 'FLAP':
-            return FLAP_PORTAL_ADDRESS;
-        case 'V2':
-            return POTATOSWAP_V2_ROUTER;
-        case 'V3':
-            return POTATOSWAP_V3_ROUTER;
-    }
-}
-function buildBuyCall(wallet, amount, tokenAddress, poolType, routerAddress, fee, delegateInterface, portalInterface) {
-    switch (poolType) {
-        case 'FLAP': {
-            // ✅ 修复：使用 swapExactInput 代替 buy 函数，明确指定 inputAmount
-            // buy(token) 依赖 msg.value，当 value=0n 时会失败
-            const portalCallData = portalInterface.encodeFunctionData('swapExactInput', [{
-                    inputToken: ethers.ZeroAddress, // 0x0 = OKB (原生代币)
-                    outputToken: tokenAddress,
-                    inputAmount: amount,
-                    minOutputAmount: 0n,
-                    permitData: '0x',
-                }]);
-            const batchCalls = [{ target: FLAP_PORTAL_ADDRESS, value: amount, data: portalCallData }];
-            return {
-                target: wallet.address,
-                allowFailure: false,
-                value: 0n,
-                callData: delegateInterface.encodeFunctionData('executeBatch', [batchCalls]),
-            };
-        }
-        case 'V2': {
-            const path = [WOKB_ADDRESS, tokenAddress];
-            // ✅ 修复：value 设为 0n，让钱包使用自己余额买入；传入正确的 amount
-            return {
-                target: wallet.address,
-                allowFailure: false,
-                value: 0n,
-                callData: delegateInterface.encodeFunctionData('executeBuyV2', [routerAddress, path, amount]),
-            };
-        }
-        case 'V3': {
-            // ✅ 修复：value 设为 0n，让钱包使用自己余额买入；传入正确的 amount
-            return {
-                target: wallet.address,
-                allowFailure: false,
-                value: 0n,
-                callData: delegateInterface.encodeFunctionData('executeBuy', [
-                    routerAddress, WOKB_ADDRESS, tokenAddress, fee, amount
-                ]),
-            };
-        }
-    }
-}
-function buildSellCall(wallet, amount, // ✅ 传入具体数量，用于非 100% 卖出时的占位或精确值
-tokenAddress, sellPercent, tokenDecimals, poolType, routerAddress, fee, delegateInterface, portalInterface) {
-    // 使用 executeTransferAll 卖出全部（sellPercent=100）
-    // 或者使用 executeSell 指定百分比
-    switch (poolType) {
-        case 'FLAP': {
-            // ✅ 使用 swapExactInput 卖出（与 AA 模式保持一致）
-            // 注意：inputAmount=0 会失败，FLAP 需要先获取余额再调用
-            // 这里需要传入实际的代币余额，外层调用者应该提前查询
-            const portalCallData = portalInterface.encodeFunctionData('swapExactInput', [{
-                    inputToken: tokenAddress,
-                    outputToken: ethers.ZeroAddress, // 0x0 = OKB
-                    inputAmount: 1n, // 占位符，如果调用 buildSellCall 时不指定 amount，通常意味逻辑上有问题
-                    minOutputAmount: 0n,
-                    permitData: '0x',
-                }]);
-            const batchCalls = [{ target: FLAP_PORTAL_ADDRESS, value: 0n, data: portalCallData }];
-            return {
-                target: wallet.address,
-                allowFailure: false,
-                value: 0n,
-                callData: delegateInterface.encodeFunctionData('executeBatch', [batchCalls]),
-            };
-        }
-        case 'V2': {
-            const path = [tokenAddress, WOKB_ADDRESS];
-            // ✅ 修复：传入实际数量，避免卖出全部
-            return {
-                target: wallet.address,
-                allowFailure: false,
-                value: 0n,
-                callData: delegateInterface.encodeFunctionData('executeSellV2', [routerAddress, path, sellPercent === 100 ? 0 : amount]),
-            };
-        }
-        case 'V3': {
-            // ✅ 修复：传入实际数量，避免卖出全部
-            return {
-                target: wallet.address,
-                allowFailure: false,
-                value: 0n,
-                callData: delegateInterface.encodeFunctionData('executeSell', [
-                    routerAddress, tokenAddress, WOKB_ADDRESS, fee, sellPercent === 100 ? 0 : amount
-                ]),
-            };
-        }
-    }
-}
-function buildSellCallWithAmount(wallet, amount, tokenAddress, poolType, routerAddress, fee, delegateInterface, portalInterface) {
-    switch (poolType) {
-        case 'FLAP': {
-            // ✅ 使用 swapExactInput 卖出（与 AA 模式保持一致）
-            const portalCallData = portalInterface.encodeFunctionData('swapExactInput', [{
-                    inputToken: tokenAddress,
-                    outputToken: ethers.ZeroAddress, // 0x0 = OKB
-                    inputAmount: amount,
-                    minOutputAmount: 0n,
-                    permitData: '0x',
-                }]);
-            const batchCalls = [{ target: FLAP_PORTAL_ADDRESS, value: 0n, data: portalCallData }];
-            return {
-                target: wallet.address,
-                allowFailure: false,
-                value: 0n,
-                callData: delegateInterface.encodeFunctionData('executeBatch', [batchCalls]),
-            };
-        }
-        case 'V2': {
-            const path = [tokenAddress, WOKB_ADDRESS];
-            return {
-                target: wallet.address,
-                allowFailure: false,
-                value: 0n,
-                callData: delegateInterface.encodeFunctionData('executeSellV2', [routerAddress, path, amount]),
-            };
-        }
-        case 'V3': {
-            return {
-                target: wallet.address,
-                allowFailure: false,
-                value: 0n,
-                callData: delegateInterface.encodeFunctionData('executeSell', [
-                    routerAddress, tokenAddress, WOKB_ADDRESS, fee, amount
-                ]),
-            };
-        }
-    }
-}