four-flap-meme-sdk 2.2.19 → 2.2.20

package/dist/shared/flap/portal-bundle-merkle/swap-planning.js

@@ -0,0 +1,182 @@
+import { ethers, Contract } from 'ethers';
+import { NonceManager, getOptimizedGasPrice, buildProfitHopTransactions, PROFIT_HOP_COUNT, } from '../../../utils/bundle-helpers.js';
+import { FLAP_PORTAL_ADDRESSES } from '../constants.js';
+import { ZERO_ADDRESS } from '../../../shared/constants/index.js';
+import { ERC20_ALLOWANCE_ABI } from '../../abis/common.js';
+import { getGasPriceConfig, getTxType, getProfitRecipient, PORTAL_ABI } from './config.js';
+import { getProfitRateBps as getSharedProfitRateBps } from '../../constants/index.js';
+import { getErrorMessageFromUnknown } from '../../foundation/index.js';
+import { createSignProvider } from '../../../bundle-core/sign-context-helpers.js';
+import { APPROVE_INTERFACE, ERC20_BALANCE_OF_ABI, getChainId, getNativeTokenName, } from './swap-helpers.js';
+const providerCache = new Map();
+const PROVIDER_CACHE_TTL_MS = 60 * 1000;
+export function createChainContext(chain, config) {
+    const chainId = config.chainId ?? getChainId(chain);
+    const nativeToken = getNativeTokenName(chain);
+    const portalAddress = FLAP_PORTAL_ADDRESSES[chain.toUpperCase()];
+    const cacheKey = `${chain}-${config.rpcUrl}`;
+    const now = Date.now();
+    const cached = providerCache.get(cacheKey);
+    let provider;
+    if (cached && cached.expireAt > now) {
+        provider = cached.provider;
+    }
+    else {
+        provider = createSignProvider(config.rpcUrl, chainId, chain.toUpperCase());
+        providerCache.set(cacheKey, { provider, expireAt: now + PROVIDER_CACHE_TTL_MS });
+    }
+    return { chainId, nativeToken, portalAddress, provider };
+}
+export async function buildApprovalTransaction({ tokenAddress, seller, provider, decimals, portalAddress, chainId, config, }) {
+    const erc20 = new Contract(tokenAddress, ERC20_ALLOWANCE_ABI, provider);
+    const currentAllowance = await erc20.allowance(seller.address, portalAddress);
+    const threshold = ethers.parseUnits('1000000000', decimals);
+    if (currentAllowance >= threshold) {
+        return null;
+    }
+    const nonceManager = new NonceManager(provider);
+    const approvalNonce = await nonceManager.getNextNonce(seller);
+    const gasPrice = await getOptimizedGasPrice(provider, getGasPriceConfig(config));
+    const txType = getTxType(config);
+    return await seller.signTransaction({
+        to: tokenAddress,
+        data: APPROVE_INTERFACE.encodeFunctionData('approve', [portalAddress, ethers.MaxUint256]),
+        value: 0n,
+        nonce: approvalNonce,
+        gasLimit: 80000n,
+        gasPrice,
+        chainId,
+        type: txType,
+    });
+}
+export async function quoteSellOutput({ portalAddress, tokenAddress, sellAmountWei, provider, skipQuoteOnError, outputToken = ZERO_ADDRESS, }) {
+    const portal = new Contract(portalAddress, PORTAL_ABI, provider);
+    try {
+        const quotedNative = await portal.quoteExactInput.staticCall({
+            inputToken: tokenAddress,
+            outputToken,
+            inputAmount: sellAmountWei,
+        });
+        return { quotedNative, minOutNative: 0n };
+    }
+    catch (err) {
+        if (skipQuoteOnError ?? true) {
+            return { quotedNative: 0n, minOutNative: 0n };
+        }
+        throw new Error(`卖出报价失败: ${getErrorMessageFromUnknown(err)}`);
+    }
+}
+export async function calculateBuyerNeed({ buyer, quotedNative, reserveGasEth, nativeToken, useNativeToken = true, quoteToken, quoteTokenDecimals = 18, provider, }) {
+    const reserveGas = ethers.parseEther((reserveGasEth || 0.0005).toString());
+    let buyerBalance;
+    if (useNativeToken) {
+        buyerBalance = await buyer.provider.getBalance(buyer.address);
+    }
+    else {
+        const erc20 = new Contract(quoteToken, ERC20_BALANCE_OF_ABI, provider || buyer.provider);
+        buyerBalance = await erc20.balanceOf(buyer.address);
+    }
+    const estimatedBuyerNeed = quotedNative;
+    const buyerNeedTotal = useNativeToken ? estimatedBuyerNeed + reserveGas : estimatedBuyerNeed;
+    if (buyerBalance < buyerNeedTotal) {
+        if (useNativeToken) {
+            throw new Error(`买方余额不足:\n` +
+                `  - 需要: ${ethers.formatEther(buyerNeedTotal)} ${nativeToken}\n` +
+                `  - 实际: ${ethers.formatEther(buyerBalance)} ${nativeToken}`);
+        }
+        else {
+            throw new Error(`买方代币余额不足:\n` +
+                `  - 需要: ${ethers.formatUnits(buyerNeedTotal, quoteTokenDecimals)}\n` +
+                `  - 实际: ${ethers.formatUnits(buyerBalance, quoteTokenDecimals)}`);
+        }
+    }
+    const maxBuyerValue = estimatedBuyerNeed > 0n ? estimatedBuyerNeed : useNativeToken ? buyerBalance - reserveGas : buyerBalance;
+    return { reserveGas, buyerBalance, buyerNeedTotal, maxBuyerValue };
+}
+export async function validateBalances({ buyerAddress, portalGasCost, provider, chainContext, seller, useNativeToken, }) {
+    const sellerBalance = await provider.getBalance(seller.address);
+    if (!useNativeToken) {
+        const buyerBnbBalance = await provider.getBalance(buyerAddress);
+        const buyerGasCost = portalGasCost;
+        if (buyerBnbBalance < buyerGasCost) {
+            throw new Error(`买方 BNB 余额不足 (用于支付 Gas):\n` +
+                `  - 需要: ${ethers.formatEther(buyerGasCost)} ${chainContext.nativeToken}\n` +
+                `  - 实际: ${ethers.formatEther(buyerBnbBalance)} ${chainContext.nativeToken}`);
+        }
+    }
+    if (sellerBalance < portalGasCost) {
+        throw new Error(`卖方余额不足: 需要 ${ethers.formatEther(portalGasCost)} ${chainContext.nativeToken} (Gas)，实际 ${ethers.formatEther(sellerBalance)} ${chainContext.nativeToken}`);
+    }
+}
+export function buildNoncePlan(startNonces, approvalExists, extractProfit, needBribeTx) {
+    let sellerNonce = startNonces[0];
+    const buyerNonce = startNonces[1];
+    let bribeNonce;
+    let profitNonce;
+    if (needBribeTx)
+        bribeNonce = sellerNonce++;
+    if (approvalExists)
+        sellerNonce++;
+    const sellNonce = sellerNonce++;
+    if (extractProfit)
+        profitNonce = sellerNonce;
+    return { sellerNonce: sellNonce, buyerNonce, bribeNonce, profitNonce };
+}
+export async function planNonces({ seller, buyer, approvalExists, extractProfit, needBribeTx, nonceManager, }) {
+    if (needBribeTx || approvalExists || extractProfit) {
+        const sellerTxCount = countTruthy([needBribeTx, approvalExists, true, extractProfit]);
+        const [sellerNonces, buyerNonces] = await Promise.all([
+            nonceManager.getNextNonceBatch(seller, sellerTxCount),
+            nonceManager.getNextNoncesForWallets([buyer]),
+        ]);
+        let idx = 0;
+        const bribeNonce = needBribeTx ? sellerNonces[idx++] : undefined;
+        if (approvalExists)
+            idx++;
+        const sellerNonce = sellerNonces[idx++];
+        const profitNonce = extractProfit ? sellerNonces[idx] : undefined;
+        const buyerNonce = buyerNonces[0];
+        return { sellerNonce, buyerNonce, bribeNonce, profitNonce };
+    }
+    const nonces = await nonceManager.getNextNoncesForWallets([seller, buyer]);
+    return { sellerNonce: nonces[0], buyerNonce: nonces[1] };
+}
+export async function buildProfitTransaction({ provider, seller, profitAmount, profitNonce, gasPrice, chainId, txType, }) {
+    if (!profitNonce || profitAmount === 0n) {
+        return null;
+    }
+    const profitHopResult = await buildProfitHopTransactions({
+        provider,
+        payerWallet: seller,
+        profitAmount,
+        profitRecipient: getProfitRecipient(),
+        hopCount: PROFIT_HOP_COUNT,
+        gasPrice,
+        chainId,
+        txType,
+        startNonce: profitNonce,
+    });
+    return {
+        signedTransactions: profitHopResult.signedTransactions,
+        hopWallets: profitHopResult.hopWallets,
+    };
+}
+function getProfitRateBps(userType) {
+    if (userType === 'v0') {
+        return getSharedProfitRateBps('v0Single');
+    }
+    else if (userType === 'v1') {
+        return getSharedProfitRateBps('v1Single');
+    }
+    return getSharedProfitRateBps('v0Single');
+}
+export function calculateProfitAmount(quotedNative, userType) {
+    if (quotedNative <= 0n) {
+        return 0n;
+    }
+    const rateBps = getProfitRateBps(userType);
+    return (quotedNative * BigInt(rateBps)) / 10000n;
+}
+function countTruthy(values) {
+    return values.filter(Boolean).length;
+}

package/dist/shared/flap/portal-bundle-merkle/swap-quick-batch.d.ts

@@ -0,0 +1,16 @@
+import type { FlapQuickBatchSwapSignParams, FlapQuickBatchSwapResult } from './swap-types.js';
+/**
+ * Flap 内盘快捷批量换手（资金利用率模式）
+ *
+ * 流程：[贿赂] → [卖出] → [转账多跳...] → [买入1, 买入2, ...] → [利润]
+ *
+ * 特点：
+ * - 子钱包不需要预先有余额
+ * - 资金来自主钱包卖出代币所得
+ * - 提升资金利用率
+ * - 支持原生代币（BNB/OKB/ETH）和 ERC20（如 USDT）两种模式
+ * - ✅ 支持转账多跳，隐藏资金流向
+ *
+ * 限制：根据多跳数动态计算最大买方数量
+ */
+export declare function flapQuickBatchSwapMerkle(params: FlapQuickBatchSwapSignParams): Promise<FlapQuickBatchSwapResult>;

package/dist/shared/flap/portal-bundle-merkle/swap-quick-batch.js

@@ -0,0 +1,327 @@
+/**
+ * swap-quick-batch - 快捷批量换手（资金利用率模式）
+ */
+import { ethers, Contract, Wallet } from 'ethers';
+import { calculateSellAmount } from '../../../utils/swap-helpers.js';
+import { NonceManager, getOptimizedGasPrice, PROFIT_HOP_COUNT } from '../../../utils/bundle-helpers.js';
+import { ZERO_ADDRESS } from '../../../shared/constants/index.js';
+import { ERC20_ABI } from '../../abis/common.js';
+import { getGasPriceConfig, getTxType, getBribeAmount, BLOCKRAZOR_BUILDER_EOA, PORTAL_ABI, } from './config.js';
+import { buildTransactionRequest } from '../../foundation/tx/build-request.js';
+import { GAS_LIMITS } from '../../constants/index.js';
+import { BRIBE_GAS_LIMIT, NATIVE_TRANSFER_GAS_LIMIT, buildBNBHopChainForERC20, buildERC20HopChain, buildNativeHopChain, generateDisperseHopPaths, getGasLimit, getTokenToNativeQuote, } from './swap-helpers.js';
+import { buildProfitTransaction, calculateProfitAmount, createChainContext, quoteSellOutput, } from './swap-planning.js';
+/**
+ * Flap 内盘快捷批量换手（资金利用率模式）
+ *
+ * 流程：[贿赂] → [卖出] → [转账多跳...] → [买入1, 买入2, ...] → [利润]
+ *
+ * 特点：
+ * - 子钱包不需要预先有余额
+ * - 资金来自主钱包卖出代币所得
+ * - 提升资金利用率
+ * - 支持原生代币（BNB/OKB/ETH）和 ERC20（如 USDT）两种模式
+ * - ✅ 支持转账多跳，隐藏资金流向
+ *
+ * 限制：根据多跳数动态计算最大买方数量
+ */
+export async function flapQuickBatchSwapMerkle(params) {
+    const { chain, sellerPrivateKey, sellAmount, sellPercentage, buyerPrivateKeys, buyerRatios, buyerAmounts, tokenAddress, config, quoteToken, quoteTokenDecimals = 18, disperseHopCount = 0, // ✅ 转账多跳数（默认0=直接转账）
+    startNonces, // ✅ 可选：前端预获取的 nonces
+     } = params;
+    // ✅ 判断是否使用原生代币
+    const useNativeToken = !quoteToken || quoteToken === ZERO_ADDRESS;
+    // ✅ 动态计算最大买方数量（根据多跳数）
+    // 固定开销: 贿赂(1) + 卖出(1) + 利润多跳(PROFIT_HOP_COUNT + 1)
+    const fixedOverhead = 1 + 1 + PROFIT_HOP_COUNT + 1;
+    const maxTxs = 50 - fixedOverhead;
+    let MAX_BUYERS;
+    if (useNativeToken) {
+        // 原生代币模式: N*(H+2) <= maxTxs
+        MAX_BUYERS = Math.floor(maxTxs / (disperseHopCount + 2));
+    }
+    else {
+        // ERC20 模式: N*(2H+3) <= maxTxs
+        MAX_BUYERS = Math.floor(maxTxs / (2 * disperseHopCount + 3));
+    }
+    MAX_BUYERS = Math.max(1, MAX_BUYERS);
+    if (buyerPrivateKeys.length === 0) {
+        throw new Error('至少需要一个买方钱包');
+    }
+    if (buyerPrivateKeys.length > MAX_BUYERS) {
+        const mode = useNativeToken ? '原生代币' : 'ERC20';
+        throw new Error(`资金利用率模式(${mode}, ${disperseHopCount}跳)买方钱包数量超过限制: ${buyerPrivateKeys.length} > ${MAX_BUYERS}`);
+    }
+    // ✅ 校验分配模式
+    if (!buyerRatios && !buyerAmounts) {
+        throw new Error('必须提供 buyerRatios 或 buyerAmounts');
+    }
+    if (buyerRatios && buyerRatios.length !== buyerPrivateKeys.length) {
+        throw new Error(`buyerRatios 长度 (${buyerRatios.length}) 与 buyerPrivateKeys 长度 (${buyerPrivateKeys.length}) 不匹配`);
+    }
+    if (buyerAmounts && buyerAmounts.length !== buyerPrivateKeys.length) {
+        throw new Error(`buyerAmounts 长度 (${buyerAmounts.length}) 与 buyerPrivateKeys 长度 (${buyerPrivateKeys.length}) 不匹配`);
+    }
+    const outputToken = useNativeToken ? ZERO_ADDRESS : quoteToken;
+    const ERC20_TRANSFER_GAS = GAS_LIMITS.ERC20_TRANSFER;
+    const chainContext = createChainContext(chain, config);
+    const seller = new Wallet(sellerPrivateKey, chainContext.provider);
+    const buyers = buyerPrivateKeys.map((pk) => new Wallet(pk, chainContext.provider));
+    const nonceManager = new NonceManager(chainContext.provider);
+    const finalGasLimit = getGasLimit(config);
+    const txType = getTxType(config);
+    // ✅ 并行获取：卖出数量、gasPrice
+    const [sellAmountResult, gasPrice] = await Promise.all([
+        calculateSellAmount(chainContext.provider, tokenAddress, seller.address, sellAmount, sellPercentage),
+        getOptimizedGasPrice(chainContext.provider, getGasPriceConfig(config)),
+    ]);
+    const { amount: sellAmountWei, decimals } = sellAmountResult;
+    const priorityFee = gasPrice / 10n === 0n ? 1n : gasPrice / 10n;
+    // ✅ 获取卖出报价
+    const quote = await quoteSellOutput({
+        portalAddress: chainContext.portalAddress,
+        tokenAddress,
+        sellAmountWei,
+        provider: chainContext.provider,
+        skipQuoteOnError: config.skipQuoteOnError,
+        outputToken,
+    });
+    const estimatedOutput = quote.quotedNative;
+    // ✅ 计算利润（根据 userType 动态调整）
+    const tokenProfitAmount = calculateProfitAmount(estimatedOutput, config.userType);
+    let nativeProfitAmount = tokenProfitAmount;
+    if (!useNativeToken && tokenProfitAmount > 0n) {
+        // ERC20 模式：将代币利润转换为等值原生代币
+        nativeProfitAmount = await getTokenToNativeQuote(chainContext.provider, quoteToken, tokenProfitAmount, chainContext.chainId);
+    }
+    const distributableAmount = useNativeToken ? estimatedOutput - tokenProfitAmount : estimatedOutput; // ERC20 模式利润从原生代币扣
+    // ✅ 计算每个买方分到的金额
+    let transferAmountsWei;
+    if (buyerAmounts && buyerAmounts.length === buyers.length) {
+        // 数量模式
+        transferAmountsWei = buyerAmounts.map((amt) => useNativeToken ? ethers.parseEther(amt) : ethers.parseUnits(amt, quoteTokenDecimals));
+        const totalTransfer = transferAmountsWei.reduce((a, b) => a + b, 0n);
+        if (totalTransfer > distributableAmount) {
+            const formatted = useNativeToken
+                ? ethers.formatEther(distributableAmount)
+                : ethers.formatUnits(distributableAmount, quoteTokenDecimals);
+            throw new Error(`指定的买入总金额超过可分配金额 (${formatted})`);
+        }
+    }
+    else if (buyerRatios && buyerRatios.length === buyers.length) {
+        // 比例模式
+        transferAmountsWei = buyerRatios.map((ratio) => {
+            return (distributableAmount * BigInt(Math.round(ratio * 10000))) / 10000n;
+        });
+    }
+    else {
+        throw new Error('必须提供 buyerRatios 或 buyerAmounts');
+    }
+    // ✅ 获取贿赂金额
+    const bribeAmount = getBribeAmount(config);
+    // ✅ 验证主钱包余额
+    const sellerBalance = await seller.provider.getBalance(seller.address);
+    let sellerGasCost;
+    let sellerRequired;
+    if (useNativeToken) {
+        // 原生代币模式：贿赂 + Gas（卖出 + 转账 + 利润）
+        sellerGasCost =
+            gasPrice * (BRIBE_GAS_LIMIT + finalGasLimit + BRIBE_GAS_LIMIT * BigInt(buyers.length) + BRIBE_GAS_LIMIT);
+        sellerRequired = bribeAmount + sellerGasCost;
+    }
+    else {
+        // ERC20 模式：贿赂 + Gas（卖出 + ERC20转账 + 利润）
+        sellerGasCost =
+            gasPrice * (BRIBE_GAS_LIMIT + finalGasLimit + ERC20_TRANSFER_GAS * BigInt(buyers.length) + BRIBE_GAS_LIMIT);
+        sellerRequired = bribeAmount + sellerGasCost;
+    }
+    if (sellerBalance < sellerRequired) {
+        throw new Error(`主钱包 ${chainContext.nativeToken} 余额不足: 需要约 ${ethers.formatEther(sellerRequired)} (贿赂: ${ethers.formatEther(bribeAmount)}, Gas: ${ethers.formatEther(sellerGasCost)}), 实际 ${ethers.formatEther(sellerBalance)}`);
+    }
+    // ==================== 规划 Nonce ====================
+    // ✅ 如果前端传入了 startNonces，直接使用（性能优化）
+    let sellerNonce = startNonces && startNonces.length > 0 ? startNonces[0] : await nonceManager.getNextNonce(seller);
+    // ==================== 1. 贿赂交易 ====================
+    let bribeTx = null;
+    if (bribeAmount > 0n) {
+        bribeTx = await seller.signTransaction({
+            to: BLOCKRAZOR_BUILDER_EOA,
+            value: bribeAmount,
+            nonce: sellerNonce++,
+            gasPrice,
+            gasLimit: BRIBE_GAS_LIMIT,
+            chainId: chainContext.chainId,
+            type: txType,
+        });
+    }
+    // ==================== 2. 卖出交易 ====================
+    const portalSeller = new Contract(chainContext.portalAddress, PORTAL_ABI, seller);
+    const sellUnsigned = await portalSeller.swapExactInput.populateTransaction({
+        inputToken: tokenAddress,
+        outputToken,
+        inputAmount: sellAmountWei,
+        minOutputAmount: 0,
+        permitData: '0x',
+    });
+    const sellTx = buildTransactionRequest(sellUnsigned, {
+        from: seller.address,
+        nonce: sellerNonce++,
+        gasLimit: finalGasLimit,
+        gasPrice,
+        priorityFee,
+        chainId: chainContext.chainId,
+        txType,
+        value: 0n,
+    });
+    const signedSell = await seller.signTransaction(sellTx);
+    // ==================== 3. 转账交易（支持多跳）====================
+    const reserveGas = ethers.parseEther((config.reserveGasETH || 0.0005).toString());
+    const buyerGasCost = gasPrice * finalGasLimit;
+    // ✅ 生成多跳路径
+    const hopPaths = generateDisperseHopPaths(buyers.map((b) => b.address), disperseHopCount, chainContext.provider);
+    // 收集所有中间钱包信息
+    const allHopWallets = [];
+    hopPaths.forEach((path) => {
+        allHopWallets.push(...path.hopWalletsInfo);
+    });
+    let transferTxs;
+    if (disperseHopCount === 0) {
+        // ✅ 无多跳：直接转账
+        const transferNonces = buyers.map((_, i) => sellerNonce + i);
+        sellerNonce += buyers.length;
+        if (useNativeToken) {
+            transferTxs = await Promise.all(buyers.map((buyer, i) => {
+                const transferValue = transferAmountsWei[i] + reserveGas + buyerGasCost;
+                return seller.signTransaction({
+                    to: buyer.address,
+                    value: transferValue,
+                    nonce: transferNonces[i],
+                    gasPrice,
+                    gasLimit: NATIVE_TRANSFER_GAS_LIMIT,
+                    chainId: chainContext.chainId,
+                    type: txType,
+                });
+            }));
+        }
+        else {
+            const erc20Interface = new ethers.Interface(ERC20_ABI);
+            transferTxs = await Promise.all(buyers.map((buyer, i) => {
+                const transferData = erc20Interface.encodeFunctionData('transfer', [buyer.address, transferAmountsWei[i]]);
+                return seller.signTransaction({
+                    to: quoteToken,
+                    data: transferData,
+                    value: 0n,
+                    nonce: transferNonces[i],
+                    gasPrice,
+                    gasLimit: ERC20_TRANSFER_GAS,
+                    chainId: chainContext.chainId,
+                    type: txType,
+                });
+            }));
+        }
+    }
+    else {
+        // ✅ 有多跳：构建多跳转账链
+        if (useNativeToken) {
+            // 原生代币多跳转账
+            // ✅ 修复：payer 每次只发送 1 笔交易（到第一个hop钱包），hop钱包用自己的nonce=0
+            const hopChains = await Promise.all(hopPaths.map((path, i) => {
+                const finalAmount = transferAmountsWei[i] + reserveGas + buyerGasCost;
+                const payerNonce = sellerNonce + i; // ✅ payer 每个 buyer 只用 1 个 nonce
+                return buildNativeHopChain(seller, path, finalAmount, gasPrice, chainContext.chainId, txType, payerNonce);
+            }));
+            transferTxs = hopChains.flat();
+            sellerNonce += buyers.length; // ✅ payer 只增加 buyers.length 个 nonce
+        }
+        else {
+            // ERC20 多跳转账：先转 BNB（给中间钱包 gas），再转 ERC20
+            // ✅ 修复：payer 每次只发送 1 笔交易（到第一个hop钱包），hop钱包用自己的nonce=0/1
+            // 1. 构建 BNB 多跳链
+            const bnbHopChains = await Promise.all(hopPaths.map((path, i) => {
+                const finalGasAmount = buyerGasCost;
+                const payerNonce = sellerNonce + i; // ✅ payer 每个 buyer 只用 1 个 nonce
+                return buildBNBHopChainForERC20(seller, path, finalGasAmount, gasPrice, chainContext.chainId, txType, payerNonce);
+            }));
+            const bnbTxs = bnbHopChains.flat();
+            sellerNonce += buyers.length; // ✅ payer 只增加 buyers.length 个 nonce
+            // 2. 构建 ERC20 多跳链
+            const erc20HopChains = await Promise.all(hopPaths.map((path, i) => {
+                const payerNonce = sellerNonce + i; // ✅ payer 每个 buyer 只用 1 个 nonce
+                return buildERC20HopChain(seller, path, quoteToken, transferAmountsWei[i], gasPrice, chainContext.chainId, txType, payerNonce);
+            }));
+            const erc20Txs = erc20HopChains.flat();
+            sellerNonce += buyers.length; // ✅ payer 只增加 buyers.length 个 nonce
+            transferTxs = [...bnbTxs, ...erc20Txs];
+        }
+    }
+    // ==================== 4. 买入交易 ====================
+    // ✅ 如果前端传入了 startNonces，使用 buyer 部分（从索引 1 开始）
+    const buyerNonces = startNonces && startNonces.length > 1
+        ? startNonces.slice(1)
+        : await Promise.all(buyers.map((buyer) => nonceManager.getNextNonce(buyer)));
+    const signedBuys = await Promise.all(buyers.map(async (buyer, i) => {
+        const buyAmount = transferAmountsWei[i];
+        const portalBuyer = new Contract(chainContext.portalAddress, PORTAL_ABI, buyer);
+        const buyUnsigned = await portalBuyer.swapExactInput.populateTransaction({
+            inputToken: outputToken,
+            outputToken: tokenAddress,
+            inputAmount: buyAmount,
+            minOutputAmount: 0,
+            permitData: '0x',
+        }, useNativeToken ? { value: buyAmount } : {});
+        const buyTx = buildTransactionRequest(buyUnsigned, {
+            from: buyer.address,
+            nonce: buyerNonces[i],
+            gasLimit: finalGasLimit,
+            gasPrice,
+            priorityFee,
+            chainId: chainContext.chainId,
+            txType,
+            value: useNativeToken ? buyAmount : 0n,
+        });
+        return buyer.signTransaction(buyTx);
+    }));
+    nonceManager.clearTemp();
+    // ==================== 组装交易数组 ====================
+    const signedTransactions = [];
+    if (bribeTx)
+        signedTransactions.push(bribeTx);
+    signedTransactions.push(signedSell);
+    signedTransactions.push(...transferTxs);
+    signedTransactions.push(...signedBuys);
+    // ==================== 5. 利润多跳转账（强制 2 跳中转）====================
+    let profitHopWallets;
+    if (nativeProfitAmount > 0n) {
+        const profitResult = await buildProfitTransaction({
+            provider: chainContext.provider,
+            seller,
+            profitAmount: nativeProfitAmount,
+            profitNonce: sellerNonce++,
+            gasPrice,
+            chainId: chainContext.chainId,
+            txType,
+        });
+        if (profitResult) {
+            signedTransactions.push(...profitResult.signedTransactions);
+            profitHopWallets = profitResult.hopWallets; // ✅ 收集利润多跳钱包
+        }
+        // 多跳交易已签名
+    }
+    return {
+        signedTransactions,
+        disperseHopWallets: allHopWallets.length > 0 ? allHopWallets : undefined, // ✅ 返回转账多跳钱包
+        profitHopWallets, // ✅ 返回利润多跳钱包
+        metadata: {
+            sellerAddress: seller.address,
+            buyerAddresses: buyers.map((b) => b.address),
+            sellAmount: ethers.formatUnits(sellAmountWei, decimals),
+            estimatedOutput: useNativeToken
+                ? ethers.formatEther(estimatedOutput)
+                : ethers.formatUnits(estimatedOutput, quoteTokenDecimals),
+            transferAmounts: transferAmountsWei.map((amt) => useNativeToken ? ethers.formatEther(amt) : ethers.formatUnits(amt, quoteTokenDecimals)),
+            profitAmount: nativeProfitAmount > 0n ? ethers.formatEther(nativeProfitAmount) : undefined,
+            useNativeToken,
+            disperseHopCount: disperseHopCount > 0 ? disperseHopCount : undefined, // ✅ 返回多跳数
+        },
+    };
+}

package/dist/shared/flap/portal-bundle-merkle/swap-single.d.ts

@@ -0,0 +1,2 @@
+import { FlapBundleSwapSignParams, FlapSwapResult } from './swap-helpers.js';
+export declare function flapBundleSwapMerkle(params: FlapBundleSwapSignParams): Promise<FlapSwapResult>;