four-flap-meme-sdk 3.0.0 → 4.0.0

package/dist/chains/xlayer/eip7702/volume-bundle.js

@@ -0,0 +1,250 @@
+/**
+ * EIP-7702 捆绑刷量 (Bundle Mode)
+ *
+ * 多钱包批量买入 + 批量卖出
+ * 只生成签名，由调用方决定如何提交
+ */
+import { ethers } from 'ethers';
+import { truncateDecimals } from './volume-helpers.js';
+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, WOKB_ADDRESS, V3_FEE_TIERS, ERC20_ABI, V2_ROUTER_ABI, } from './constants.js';
+import { getDefaultRouter, buildBuyCall, buildSellCall, buildSellCallWithAmount } from './volume-internal.js';
+/**
+ * 捆绑刷量 - 多钱包批量买入 + 批量卖出
+ *
+ * 核心逻辑：[利润刮取] + [买入Ops...] + [卖出Ops...]
+ */
+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('没有有效的卖家私钥');
+    }
+    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 tokenContract = needBalanceQuery && sellerWallets.length > 0 ? new ethers.Contract(tokenAddress, ERC20_ABI, provider) : null;
+    const [nonces, feeData, sellerBalancesRaw] = await Promise.all([
+        batchGetNonces(allAddresses, provider),
+        provider.getFeeData(),
+        needBalanceQuery && sellerWallets.length > 0 && tokenContract
+            ? Promise.all(sellerWallets.map((w) => tokenContract.balanceOf(w.address)))
+            : Promise.resolve(null),
+    ]);
+    // 计算卖出金额
+    let sellAmountsWei;
+    if (sellAmounts && sellAmounts.length === sellerWallets.length) {
+        // ✅ 如果有指定卖出金额，直接使用
+        sellAmountsWei = sellAmounts.map((amt) => ethers.parseUnits(truncateDecimals(amt, tokenDecimals), tokenDecimals));
+    }
+    else if (needBalanceQuery && sellerBalancesRaw) {
+        // ✅ 根据 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);
+                }
+                catch {
+                    try {
+                        estimatedTokenAmount = await portalContract.quoteBuy(tokenAddress, totalBuyAmount);
+                    }
+                    catch {
+                        try {
+                            estimatedTokenAmount = await portalContract.quoteExactInput.staticCall({
+                                inputToken: ethers.ZeroAddress,
+                                outputToken: tokenAddress,
+                                inputAmount: totalBuyAmount,
+                            });
+                        }
+                        catch {
+                            try {
+                                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];
+                            }
+                            catch {
+                                // all quote paths failed
+                            }
+                        }
+                    }
+                }
+            }
+            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,
+                        });
+                    }
+                }
+                catch {
+                    // pool quote failed
+                }
+            }
+        }
+        catch {
+            // quote estimate failed
+        }
+        // ✅ 修正卖出数量计算逻辑：卖出数额仅基于本次交易买入的代币预估值，忽略原有余额
+        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;
+                    }
+                });
+            }
+        }
+        // ✅ 修复：不再重复应用 sellPercent，因为 totalToSell 已经按 sellPercent 计算过了
+        sellAmountsWei = walletSellAmounts;
+    }
+    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),
+        },
+    };
+}

package/dist/chains/xlayer/eip7702/volume-internal.d.ts

@@ -0,0 +1,13 @@
+/**
+ * volume 内部工具函数
+ *
+ * 供 volume-wash / volume-bundle 共享使用，不作为公共 API 导出。
+ */
+import { ethers, Wallet } from 'ethers';
+import type { Call3Value } from './types.js';
+import type { PoolType } from './volume-helpers.js';
+export declare function getDefaultRouter(poolType: PoolType): string;
+export declare function buildBuyCall(wallet: Wallet, amount: bigint, tokenAddress: string, poolType: PoolType, routerAddress: string, fee: number, delegateInterface: ethers.Interface, portalInterface: ethers.Interface): Call3Value;
+export declare function buildSellCall(wallet: Wallet, amount: bigint, // ✅ 传入具体数量，用于非 100% 卖出时的占位或精确值
+tokenAddress: string, sellPercent: number, tokenDecimals: number, poolType: PoolType, routerAddress: string, fee: number, delegateInterface: ethers.Interface, portalInterface: ethers.Interface): Call3Value;
+export declare function buildSellCallWithAmount(wallet: Wallet, amount: bigint, tokenAddress: string, poolType: PoolType, routerAddress: string, fee: number, delegateInterface: ethers.Interface, portalInterface: ethers.Interface): Call3Value;

package/dist/chains/xlayer/eip7702/volume-internal.js

@@ -0,0 +1,169 @@
+/**
+ * volume 内部工具函数
+ *
+ * 供 volume-wash / volume-bundle 共享使用，不作为公共 API 导出。
+ */
+import { ethers } from 'ethers';
+import { FLAP_PORTAL_ADDRESS, POTATOSWAP_V2_ROUTER, POTATOSWAP_V3_ROUTER, WOKB_ADDRESS, } from './constants.js';
+export function getDefaultRouter(poolType) {
+    switch (poolType) {
+        case 'FLAP':
+            return FLAP_PORTAL_ADDRESS;
+        case 'V2':
+            return POTATOSWAP_V2_ROUTER;
+        case 'V3':
+            return POTATOSWAP_V3_ROUTER;
+    }
+}
+export 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,
+                ]),
+            };
+        }
+    }
+}
+export 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,
+                ]),
+            };
+        }
+    }
+}
+export 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,
+                ]),
+            };
+        }
+    }
+}

package/dist/chains/xlayer/eip7702/volume-make.d.ts

@@ -0,0 +1,8 @@
+/**
+ * EIP-7702 多轮刷量
+ *
+ * 由于 nonce 限制，仅预生成第一轮
+ */
+import type { MakeVolumeParams, MakeVolumeSignResult } from './volume-helpers.js';
+/** 生成多轮刷量签名（由于 nonce 限制，仅预生成第一轮） */
+export declare function makeVolume(params: MakeVolumeParams): Promise<MakeVolumeSignResult>;

package/dist/chains/xlayer/eip7702/volume-make.js

@@ -0,0 +1,38 @@
+/**
+ * EIP-7702 多轮刷量
+ *
+ * 由于 nonce 限制，仅预生成第一轮
+ */
+import { singleRoundVolume } from './volume-single-round.js';
+import { V3_FEE_TIERS } from './constants.js';
+/** 生成多轮刷量签名（由于 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,
+        },
+    };
+}

package/dist/chains/xlayer/eip7702/volume-single-round.d.ts

@@ -0,0 +1,17 @@
+/**
+ * EIP-7702 单轮刷量（买入+卖出分开签名）
+ */
+import type { TradeType, EIP7702Config } from './types.js';
+import type { SingleRoundVolumeResult } from './volume-helpers.js';
+/** 生成单轮刷量签名（买入 + 卖出分开，两笔独立交易） */
+export declare function singleRoundVolume(params: {
+    privateKeys: string[];
+    tokenAddress: string;
+    tokenDecimals?: number;
+    buyAmountPerWallet: string;
+    sellPercent?: number;
+    tradeType?: TradeType;
+    routerAddress?: string;
+    fee?: number;
+    config?: EIP7702Config;
+}): Promise<SingleRoundVolumeResult>;

package/dist/chains/xlayer/eip7702/volume-single-round.js

@@ -0,0 +1,44 @@
+/**
+ * EIP-7702 单轮刷量（买入+卖出分开签名）
+ */
+import { bundleBuy } from './bundle-buy.js';
+import { bundleSell } from './bundle-sell.js';
+import { V3_FEE_TIERS } from './constants.js';
+/** 生成单轮刷量签名（买入 + 卖出分开，两笔独立交易） */
+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,
+        },
+    };
+}

package/dist/chains/xlayer/eip7702/volume-swap.d.ts

@@ -0,0 +1,18 @@
+/**
+ * EIP-7702 换手刷量
+ */
+import type { TradeType, EIP7702Config } from './types.js';
+import type { SwapVolumeSignResult } from './volume-helpers.js';
+/** 生成换手刷量签名 */
+export declare function makeVolumeWithSwap(params: {
+    sellerPrivateKey: string;
+    buyerPrivateKey: string;
+    tokenAddress: string;
+    tokenDecimals?: number;
+    sellAmount: string;
+    hopCount?: number;
+    tradeType?: TradeType;
+    routerAddress?: string;
+    fee?: number;
+    config?: EIP7702Config;
+}): Promise<SwapVolumeSignResult>;

package/dist/chains/xlayer/eip7702/volume-swap.js

@@ -0,0 +1,30 @@
+/**
+ * EIP-7702 换手刷量
+ */
+import { bundleSwap } from './bundle-swap.js';
+import { V3_FEE_TIERS } from './constants.js';
+/** 生成换手刷量签名 */
+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,
+        },
+    };
+}

package/dist/chains/xlayer/eip7702/volume-wash.d.ts

@@ -0,0 +1,8 @@
+/**
+ * EIP-7702 无币刷量 (Wash Mode)
+ *
+ * 每个钱包执行买入 + 卖出，不需要预先持有代币
+ * 只生成签名，由调用方决定如何提交
+ */
+import { type WashVolumeParams, type WashVolumeResult } from './volume-helpers.js';
+export declare function washVolume(params: WashVolumeParams): Promise<WashVolumeResult>;