four-flap-meme-sdk 1.3.70 → 1.3.73

package/dist/contracts/tm-bundle-merkle/swap.d.ts

@@ -59,3 +59,37 @@ export type FourSwapResult = {
  * Four内盘捆绑换手
  */
 export declare function fourBundleSwapMerkle(params: FourBundleSwapSignParams): Promise<FourSwapResult>;
+/**
+ * Four 批量换手参数（一卖多买）
+ */
+export interface FourBatchSwapSignParams {
+    sellerPrivateKey: string;
+    sellAmount?: string;
+    sellPercentage?: number;
+    buyerPrivateKeys: string[];
+    buyerRatios?: number[];
+    tokenAddress: string;
+    slippageTolerance?: number;
+    config: FourSwapSignConfig;
+}
+/**
+ * Four 批量换手结果
+ */
+export interface FourBatchSwapResult {
+    signedTransactions: string[];
+    metadata?: {
+        sellerAddress: string;
+        buyerAddresses: string[];
+        sellAmount: string;
+        buyAmounts: string[];
+        hasApproval?: boolean;
+        profitAmount?: string;
+    };
+}
+/**
+ * Four 内盘批量换手（一卖多买）
+ *
+ * 功能：主钱包一次卖出 → 多个子钱包同时买入 → 在同一个区块中完成
+ * 限制：最多 24 个买方（服务器限制 25 笔交易，包含 1 笔利润交易）
+ */
+export declare function fourBatchSwapMerkle(params: FourBatchSwapSignParams): Promise<FourBatchSwapResult>;

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

@@ -178,3 +178,201 @@ export async function fourBundleSwapMerkle(params) {
         }
     };
 }
+/**
+ * Four 内盘批量换手（一卖多买）
+ *
+ * 功能：主钱包一次卖出 → 多个子钱包同时买入 → 在同一个区块中完成
+ * 限制：最多 24 个买方（服务器限制 25 笔交易，包含 1 笔利润交易）
+ */
+export async function fourBatchSwapMerkle(params) {
+    const { sellerPrivateKey, sellAmount, sellPercentage, buyerPrivateKeys, tokenAddress, slippageTolerance = 0.5, config } = params;
+    // ✅ 校验买方数量（最多 24 个）
+    const MAX_BUYERS = 24;
+    if (buyerPrivateKeys.length === 0) {
+        throw new Error('至少需要一个买方钱包');
+    }
+    if (buyerPrivateKeys.length > MAX_BUYERS) {
+        throw new Error(`买方钱包数量超过限制: ${buyerPrivateKeys.length} > ${MAX_BUYERS}`);
+    }
+    const chainIdNum = config.chainId ?? 56;
+    const provider = new ethers.JsonRpcProvider(config.rpcUrl, {
+        chainId: chainIdNum,
+        name: 'BSC'
+    });
+    const seller = new Wallet(sellerPrivateKey, provider);
+    const buyers = buyerPrivateKeys.map(pk => new Wallet(pk, provider));
+    const nonceManager = new NonceManager(provider);
+    console.log('🔍 Four BatchSwap - 买方数量:', buyerPrivateKeys.length);
+    // 创建适配的配置对象
+    const bundleConfig = {
+        minGasPriceGwei: config.minGasPriceGwei,
+        maxGasPriceGwei: config.maxGasPriceGwei,
+        gasLimit: typeof config.gasLimit === 'bigint' ? Number(config.gasLimit) : config.gasLimit,
+        gasLimitMultiplier: config.gasLimitMultiplier,
+        txType: config.txType,
+        chainId: config.chainId
+    };
+    const finalGasLimit = getGasLimit(bundleConfig);
+    const txType = getTxType(bundleConfig);
+    // ✅ 并行获取：卖出数量、gasPrice
+    const [sellAmountResult, gasPrice] = await Promise.all([
+        calculateSellAmount(provider, tokenAddress, seller.address, sellAmount, sellPercentage),
+        getOptimizedGasPrice(provider, getGasPriceConfig(bundleConfig))
+    ]);
+    const { amount: sellAmountWei, decimals } = sellAmountResult;
+    // ✅ 并行获取：sellQuote、allowance、所有买方余额
+    const helper3 = new Contract(ADDRESSES.BSC.TokenManagerHelper3, HELPER3_ABI, provider);
+    const erc20Contract = new Contract(tokenAddress, ['function allowance(address,address) view returns (uint256)'], provider);
+    const [sellQuote, currentAllowance, ...buyerBalances] = await Promise.all([
+        helper3.trySell(tokenAddress, sellAmountWei),
+        erc20Contract.allowance(seller.address, TM_ADDRESS),
+        ...buyers.map(buyer => provider.getBalance(buyer.address))
+    ]);
+    const totalBuyerFunds = sellQuote.funds;
+    // ✅ 计算每个买方的买入金额（按比例分配）
+    let buyAmountsWei;
+    if (params.buyerRatios && params.buyerRatios.length === buyers.length) {
+        // 按比例分配
+        console.log('📊 使用比例分配，卖出所得:', ethers.formatEther(totalBuyerFunds), 'BNB');
+        buyAmountsWei = params.buyerRatios.map((ratio, index) => {
+            const amount = (totalBuyerFunds * BigInt(Math.round(ratio * 10000))) / 10000n;
+            console.log(`   买方 ${index + 1}: ${(ratio * 100).toFixed(1)}% = ${ethers.formatEther(amount)} BNB`);
+            return amount;
+        });
+    }
+    else {
+        // 平均分配
+        const amountPerBuyer = totalBuyerFunds / BigInt(buyers.length);
+        buyAmountsWei = buyers.map(() => amountPerBuyer);
+    }
+    // ✅ 验证所有买方余额
+    const reserveGas = ethers.parseEther((config.reserveGasBNB || 0.0005).toString());
+    buyers.forEach((buyer, i) => {
+        const required = buyAmountsWei[i] + reserveGas;
+        if (buyerBalances[i] < required) {
+            throw new Error(`买方 ${i + 1} 余额不足: 需要 ${ethers.formatEther(required)} BNB, 实际 ${ethers.formatEther(buyerBalances[i])} BNB`);
+        }
+    });
+    // 检查是否需要授权
+    const APPROVAL_THRESHOLD = ethers.parseUnits('1000000000', decimals);
+    const needApproval = currentAllowance < APPROVAL_THRESHOLD;
+    // 利润配置
+    const profitRateBps = PROFIT_CONFIG.RATE_BPS;
+    const profitAmount = totalBuyerFunds > 0n
+        ? (totalBuyerFunds * BigInt(profitRateBps)) / 10000n
+        : 0n;
+    // ✅ 并行构建所有交易
+    const tmSeller = new Contract(TM_ADDRESS, TM_ABI, seller);
+    const [sellUnsigned, ...buyUnsignedList] = await Promise.all([
+        // 卖出交易
+        tmSeller.sellToken.populateTransaction(0n, tokenAddress, sellAmountWei, 0n),
+        // 所有买入交易
+        ...buyers.map((buyer, i) => {
+            const tmBuyer = new Contract(TM_ADDRESS, TM_ABI, buyer);
+            const buyAmount = buyAmountsWei[i];
+            return tmBuyer.buyTokenAMAP.populateTransaction(0n, tokenAddress, buyer.address, buyAmount, 0n, { value: buyAmount });
+        })
+    ]);
+    // ✅ 计算 nonce
+    // seller 需要的 nonce 数量
+    let sellerNonceCount = 1; // 卖出交易
+    if (needApproval)
+        sellerNonceCount++; // 授权交易
+    sellerNonceCount++; // 利润交易
+    // 并行获取所有初始 nonce
+    const allWallets = [seller, ...buyers];
+    const initialNonces = await nonceManager.getNextNoncesForWallets(allWallets);
+    // 分配 seller nonces
+    const sellerNonces = Array.from({ length: sellerNonceCount }, (_, i) => initialNonces[0] + i);
+    let idx = 0;
+    let approvalNonce;
+    if (needApproval)
+        approvalNonce = sellerNonces[idx++];
+    const sellerNonce = sellerNonces[idx++];
+    const profitNonce = sellerNonces[idx];
+    // buyer nonces
+    const buyerNonces = initialNonces.slice(1);
+    // ✅ 并行签名所有交易
+    const signPromises = [];
+    // 授权交易
+    if (needApproval && approvalNonce !== undefined) {
+        const approveInterface = new ethers.Interface(['function approve(address,uint256) returns (bool)']);
+        const approveData = approveInterface.encodeFunctionData('approve', [TM_ADDRESS, ethers.MaxUint256]);
+        signPromises.push(seller.signTransaction({
+            to: tokenAddress,
+            data: approveData,
+            value: 0n,
+            nonce: approvalNonce,
+            gasLimit: 80000n,
+            gasPrice,
+            chainId: chainIdNum,
+            type: txType
+        }));
+    }
+    // 卖出交易
+    signPromises.push(seller.signTransaction({
+        ...sellUnsigned,
+        from: seller.address,
+        nonce: sellerNonce,
+        gasLimit: finalGasLimit,
+        gasPrice,
+        chainId: chainIdNum,
+        type: txType
+    }));
+    // 所有买入交易
+    buyers.forEach((buyer, i) => {
+        signPromises.push(buyer.signTransaction({
+            ...buyUnsignedList[i],
+            from: buyer.address,
+            nonce: buyerNonces[i],
+            gasLimit: finalGasLimit,
+            gasPrice,
+            chainId: chainIdNum,
+            type: txType,
+            value: buyAmountsWei[i]
+        }));
+    });
+    // 利润交易
+    if (profitAmount > 0n) {
+        signPromises.push(seller.signTransaction({
+            to: PROFIT_CONFIG.RECIPIENT,
+            value: profitAmount,
+            nonce: profitNonce,
+            gasPrice,
+            gasLimit: 21000n,
+            chainId: chainIdNum,
+            type: txType
+        }));
+    }
+    const signedTxs = await Promise.all(signPromises);
+    // 解析签名结果
+    let signIdx = 0;
+    let approvalTx = null;
+    if (needApproval)
+        approvalTx = signedTxs[signIdx++];
+    const signedSell = signedTxs[signIdx++];
+    const signedBuys = signedTxs.slice(signIdx, signIdx + buyers.length);
+    signIdx += buyers.length;
+    const profitTx = profitAmount > 0n ? signedTxs[signIdx] : null;
+    nonceManager.clearTemp();
+    // ✅ 按顺序组装交易数组
+    const signedTransactions = [];
+    if (approvalTx)
+        signedTransactions.push(approvalTx);
+    signedTransactions.push(signedSell);
+    signedTransactions.push(...signedBuys);
+    if (profitTx)
+        signedTransactions.push(profitTx);
+    console.log(`✅ Four 批量换手签名完成: ${signedTransactions.length} 笔交易`);
+    return {
+        signedTransactions,
+        metadata: {
+            sellerAddress: seller.address,
+            buyerAddresses: buyers.map(b => b.address),
+            sellAmount: ethers.formatUnits(sellAmountWei, decimals),
+            buyAmounts: buyAmountsWei.map(amt => ethers.formatEther(amt)),
+            hasApproval: !!approvalTx,
+            profitAmount: ethers.formatEther(profitAmount)
+        }
+    };
+}

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

@@ -66,3 +66,39 @@ export type FlapSwapResult = {
  * ✅ 支持 quoteToken：传入 USDT 等地址时，卖出得到该代币，买入使用该代币
  */
 export declare function flapBundleSwapMerkle(params: FlapBundleSwapSignParams): Promise<FlapSwapResult>;
+/**
+ * Flap 批量换手参数（一卖多买）
+ */
+export interface FlapBatchSwapSignParams {
+    chain: FlapChain;
+    sellerPrivateKey: string;
+    sellAmount?: string;
+    sellPercentage?: number;
+    buyerPrivateKeys: string[];
+    buyerRatios?: number[];
+    tokenAddress: string;
+    config: FlapSwapSignConfig;
+    quoteToken?: string;
+    quoteTokenDecimals?: number;
+}
+/**
+ * Flap 批量换手结果
+ */
+export interface FlapBatchSwapResult {
+    signedTransactions: string[];
+    metadata?: {
+        sellerAddress: string;
+        buyerAddresses: string[];
+        sellAmount: string;
+        buyAmounts: string[];
+        hasApproval?: boolean;
+        profitAmount?: string;
+    };
+}
+/**
+ * Flap 内盘批量换手（一卖多买）
+ *
+ * 功能：主钱包一次卖出 → 多个子钱包同时买入 → 在同一个区块中完成
+ * 限制：最多 24 个买方（服务器限制 25 笔交易，包含 1 笔利润交易）
+ */
+export declare function flapBatchSwapMerkle(params: FlapBatchSwapSignParams): Promise<FlapBatchSwapResult>;

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

@@ -454,3 +454,197 @@ function calculateProfitAmount(quotedNative) {
 function countTruthy(values) {
     return values.filter(Boolean).length;
 }
+/**
+ * Flap 内盘批量换手（一卖多买）
+ *
+ * 功能：主钱包一次卖出 → 多个子钱包同时买入 → 在同一个区块中完成
+ * 限制：最多 24 个买方（服务器限制 25 笔交易，包含 1 笔利润交易）
+ */
+export async function flapBatchSwapMerkle(params) {
+    const { chain, sellerPrivateKey, sellAmount, sellPercentage, buyerPrivateKeys, tokenAddress, config, quoteToken, quoteTokenDecimals = 18 } = params;
+    // ✅ 校验买方数量（最多 24 个）
+    const MAX_BUYERS = 24;
+    if (buyerPrivateKeys.length === 0) {
+        throw new Error('至少需要一个买方钱包');
+    }
+    if (buyerPrivateKeys.length > MAX_BUYERS) {
+        throw new Error(`买方钱包数量超过限制: ${buyerPrivateKeys.length} > ${MAX_BUYERS}`);
+    }
+    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);
+    // ✅ 判断是否使用原生代币
+    const useNativeToken = !quoteToken || quoteToken === ZERO_ADDRESS;
+    const outputToken = useNativeToken ? ZERO_ADDRESS : quoteToken;
+    console.log('🔍 Flap BatchSwap - 买方数量:', buyerPrivateKeys.length);
+    console.log('🔍 Flap BatchSwap - useNativeToken:', useNativeToken);
+    // ✅ 并行获取：卖出数量、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 [approvalTx, quote] = await Promise.all([
+        config.skipApprovalCheck
+            ? Promise.resolve(null)
+            : buildApprovalTransaction({
+                tokenAddress,
+                seller,
+                provider: chainContext.provider,
+                decimals,
+                portalAddress: chainContext.portalAddress,
+                chainId: chainContext.chainId,
+                config
+            }),
+        quoteSellOutput({
+            portalAddress: chainContext.portalAddress,
+            tokenAddress,
+            sellAmountWei,
+            provider: chainContext.provider,
+            slippageBps: config.slippageBps,
+            skipQuoteOnError: config.skipQuoteOnError,
+            outputToken
+        })
+    ]);
+    // ✅ 计算每个买方的买入金额（按比例分配）
+    const safeSlippage = Math.max(0, Math.min(5000, config.slippageBps ?? 100));
+    const increase = BigInt(10000 + safeSlippage);
+    const totalBuyAmount = (quote.quotedNative * increase) / 10000n;
+    let buyAmountsWei;
+    if (params.buyerRatios && params.buyerRatios.length === buyers.length) {
+        // 按比例分配
+        console.log('📊 使用比例分配，卖出所得:', ethers.formatEther(totalBuyAmount));
+        buyAmountsWei = params.buyerRatios.map((ratio, index) => {
+            const amount = (totalBuyAmount * BigInt(Math.round(ratio * 10000))) / 10000n;
+            console.log(`   买方 ${index + 1}: ${(ratio * 100).toFixed(1)}% = ${ethers.formatEther(amount)}`);
+            return amount;
+        });
+    }
+    else {
+        // 平均分配
+        const amountPerBuyer = totalBuyAmount / BigInt(buyers.length);
+        buyAmountsWei = buyers.map(() => amountPerBuyer);
+    }
+    // ✅ 并行验证所有买方余额
+    const reserveGas = ethers.parseEther((config.reserveGasETH || 0.0005).toString());
+    const erc20Contract = useNativeToken ? null : new Contract(quoteToken, ERC20_BALANCE_OF_ABI, chainContext.provider);
+    await Promise.all(buyers.map(async (buyer, i) => {
+        const buyAmount = buyAmountsWei[i];
+        if (useNativeToken) {
+            const buyerBalance = await buyer.provider.getBalance(buyer.address);
+            const required = buyAmount + reserveGas;
+            if (buyerBalance < required) {
+                throw new Error(`买方 ${i + 1} 余额不足: 需要 ${ethers.formatEther(required)} ${chainContext.nativeToken}, 实际 ${ethers.formatEther(buyerBalance)}`);
+            }
+        }
+        else {
+            const buyerBalance = await erc20Contract.balanceOf(buyer.address);
+            if (buyerBalance < buyAmount) {
+                throw new Error(`买方 ${i + 1} 代币余额不足: 需要 ${ethers.formatUnits(buyAmount, quoteTokenDecimals)}, 实际 ${ethers.formatUnits(buyerBalance, quoteTokenDecimals)}`);
+            }
+        }
+    }));
+    // ✅ 计算利润
+    const tokenProfitAmount = calculateProfitAmount(quote.quotedNative);
+    let nativeProfitAmount = tokenProfitAmount;
+    if (!useNativeToken && tokenProfitAmount > 0n) {
+        nativeProfitAmount = await getTokenToNativeQuote(chainContext.provider, quoteToken, tokenProfitAmount, chainContext.chainId);
+    }
+    // ✅ 并行构建所有买入交易
+    const portalSeller = new Contract(chainContext.portalAddress, PORTAL_ABI, seller);
+    const [sellUnsigned, ...buyUnsignedList] = await Promise.all([
+        // 卖出交易
+        portalSeller.swapExactInput.populateTransaction({
+            inputToken: tokenAddress,
+            outputToken,
+            inputAmount: sellAmountWei,
+            minOutputAmount: 0,
+            permitData: '0x'
+        }),
+        // 所有买入交易
+        ...buyers.map((buyer, i) => {
+            const portalBuyer = new Contract(chainContext.portalAddress, PORTAL_ABI, buyer);
+            const buyAmount = buyAmountsWei[i];
+            return portalBuyer.swapExactInput.populateTransaction({
+                inputToken: outputToken,
+                outputToken: tokenAddress,
+                inputAmount: buyAmount,
+                minOutputAmount: 0,
+                permitData: '0x'
+            }, useNativeToken ? { value: buyAmount } : {});
+        })
+    ]);
+    // ✅ 并行获取所有 nonce
+    const sellNonce = await nonceManager.getNextNonce(seller);
+    const buyerNonces = await Promise.all(buyers.map(buyer => nonceManager.getNextNonce(buyer)));
+    // 利润交易 nonce（从第一个买方发送）
+    let profitTx = null;
+    if (nativeProfitAmount > 0n) {
+        const profitPayer = buyers[0];
+        const profitNonce = await nonceManager.getNextNonce(profitPayer);
+        profitTx = await profitPayer.signTransaction({
+            to: getProfitRecipient(),
+            value: nativeProfitAmount,
+            nonce: profitNonce,
+            gasPrice,
+            gasLimit: 21000n,
+            chainId: chainContext.chainId,
+            type: txType
+        });
+    }
+    nonceManager.clearTemp();
+    // ✅ 并行签名所有交易
+    const sellTx = buildTransactionRequest(sellUnsigned, {
+        from: seller.address,
+        nonce: sellNonce,
+        gasLimit: finalGasLimit,
+        gasPrice,
+        priorityFee,
+        chainId: chainContext.chainId,
+        txType,
+        value: 0n
+    });
+    const [signedSell, ...signedBuys] = await Promise.all([
+        seller.signTransaction(sellTx),
+        ...buyers.map((buyer, i) => {
+            const buyTx = buildTransactionRequest(buyUnsignedList[i], {
+                from: buyer.address,
+                nonce: buyerNonces[i],
+                gasLimit: finalGasLimit,
+                gasPrice,
+                priorityFee,
+                chainId: chainContext.chainId,
+                txType,
+                value: useNativeToken ? buyAmountsWei[i] : 0n
+            });
+            return buyer.signTransaction(buyTx);
+        })
+    ]);
+    // ✅ 按顺序组装交易数组
+    const signedTransactions = [];
+    if (approvalTx)
+        signedTransactions.push(approvalTx);
+    signedTransactions.push(signedSell);
+    signedTransactions.push(...signedBuys);
+    if (profitTx)
+        signedTransactions.push(profitTx);
+    console.log(`✅ Flap 批量换手签名完成: ${signedTransactions.length} 笔交易`);
+    return {
+        signedTransactions,
+        metadata: {
+            sellerAddress: seller.address,
+            buyerAddresses: buyers.map(b => b.address),
+            sellAmount: ethers.formatUnits(sellAmountWei, decimals),
+            buyAmounts: buyAmountsWei.map(amt => useNativeToken
+                ? ethers.formatEther(amt)
+                : ethers.formatUnits(amt, quoteTokenDecimals)),
+            hasApproval: !!approvalTx,
+            profitAmount: nativeProfitAmount > 0n ? ethers.formatEther(nativeProfitAmount) : undefined
+        }
+    };
+}

package/dist/index.d.ts

@@ -35,8 +35,8 @@ export { validatePrivateKeys, type PrivateKeyValidation } from './utils/wallet.j
 export { stealthTransfer, type StealthTransferResult, type StealthTransferSimpleParams } from './utils/stealth-transfer.js';
 export { inspectTokenLP, getFactoryFromRouter, registerDYORSwap, registerDex, getChainConfig, type LPInfo, type LPPlatform, type InspectOptions, type DexConfig, type ChainDexConfig, } from './utils/lp-inspect.js';
 export { disperseWithBundle, sweepWithBundle, type DisperseSignParams, type SweepSignParams, type SignedTransactionsResult, type DisperseParams, type SweepParams, type BundleSubmitResult } from './utils/airdrop-sweep.js';
-export { fourBundleSwapMerkle, type FourSwapSignConfig, type FourSwapConfig, type FourBundleSwapSignParams, type FourBundleSwapParams, type FourSwapResult } from './contracts/tm-bundle-merkle/swap.js';
-export { flapBundleSwapMerkle, type FlapSwapSignConfig, type FlapSwapConfig, type FlapBundleSwapSignParams, type FlapBundleSwapParams, type FlapSwapResult } from './flap/portal-bundle-merkle/swap.js';
+export { fourBundleSwapMerkle, fourBatchSwapMerkle, type FourSwapSignConfig, type FourSwapConfig, type FourBundleSwapSignParams, type FourBundleSwapParams, type FourSwapResult, type FourBatchSwapSignParams, type FourBatchSwapResult } from './contracts/tm-bundle-merkle/swap.js';
+export { flapBundleSwapMerkle, flapBatchSwapMerkle, type FlapSwapSignConfig, type FlapSwapConfig, type FlapBundleSwapSignParams, type FlapBundleSwapParams, type FlapSwapResult, type FlapBatchSwapSignParams, type FlapBatchSwapResult } from './flap/portal-bundle-merkle/swap.js';
 export { pancakeBundleSwapMerkle, pancakeBatchSwapMerkle, type PancakeSwapSignConfig, type PancakeBundleSwapSignParams, type PancakeSwapConfig, type PancakeBundleSwapParams, type PancakeSwapResult, type PancakeBatchSwapSignParams, type PancakeBatchSwapResult, type SwapRouteType, type V2RouteParams, type V3SingleRouteParams, type V3MultiRouteParams, type RouteParams } from './pancake/bundle-swap.js';
 export { fourBundleBuyFirstMerkle, type FourBuyFirstConfig, type FourBundleBuyFirstParams, type FourBuyFirstSignConfig, type FourBundleBuyFirstSignParams, type FourBuyFirstResult } from './contracts/tm-bundle-merkle/swap-buy-first.js';
 export { flapBundleBuyFirstMerkle, type FlapBuyFirstSignConfig, type FlapBuyFirstConfig, type FlapBundleBuyFirstSignParams, type FlapBundleBuyFirstParams, type FlapBuyFirstResult } from './flap/portal-bundle-merkle/swap-buy-first.js';

package/dist/index.js

@@ -51,9 +51,9 @@ export { disperseWithBundle, sweepWithBundle } from './utils/airdrop-sweep.js';
 // 捆绑换手功能（Bundle Swap）
 // ============================================================
 // Four内盘换手
-export { fourBundleSwapMerkle } from './contracts/tm-bundle-merkle/swap.js';
+export { fourBundleSwapMerkle, fourBatchSwapMerkle } from './contracts/tm-bundle-merkle/swap.js';
 // Flap内盘换手
-export { flapBundleSwapMerkle } from './flap/portal-bundle-merkle/swap.js';
+export { flapBundleSwapMerkle, flapBatchSwapMerkle } from './flap/portal-bundle-merkle/swap.js';
 // PancakeSwap V2/V3通用换手
 export { pancakeBundleSwapMerkle, pancakeBatchSwapMerkle } from './pancake/bundle-swap.js';
 // 先买后卖（Buy-First）入口

package/dist/pancake/bundle-swap.d.ts

@@ -87,6 +87,7 @@ export interface PancakeBatchSwapSignParams {
     sellPercentage?: number;
     buyerPrivateKeys: string[];
     buyerAmounts?: string[];
+    buyerRatios?: number[];
     tokenAddress: string;
     routeParams: RouteParams;
     slippageTolerance?: number;

package/dist/pancake/bundle-swap.js

@@ -458,40 +458,50 @@ export async function pancakeBatchSwapMerkle(params) {
     console.log('📊 预估卖出所得:', ethers.formatEther(estimatedBNBOut), 'BNB');
     // ✅ 计算每个买方的买入金额
     let buyAmountsWei;
+    const totalBuyAmount = applySlippage(estimatedBNBOut, slippageTolerance);
     if (buyerAmounts && buyerAmounts.length === buyers.length) {
-        // 使用指定的买入金额
+        // 方式1：使用指定的买入金额（USDT）
         buyAmountsWei = buyerAmounts.map(amt => useNativeToken
             ? ethers.parseEther(amt)
             : ethers.parseUnits(amt, quoteTokenDecimals));
     }
+    else if (params.buyerRatios && params.buyerRatios.length === buyers.length) {
+        // ✅ 方式2：按比例分配卖出所得
+        // buyerRatios 如 [0.3, 0.5, 0.2] 表示第一个买方分 30%，第二个 50%，第三个 20%
+        console.log('📊 使用比例分配，卖出所得:', ethers.formatEther(totalBuyAmount), 'BNB');
+        console.log('📊 买方比例:', params.buyerRatios);
+        buyAmountsWei = params.buyerRatios.map((ratio, index) => {
+            // 按比例计算每个买方的金额
+            const amount = (totalBuyAmount * BigInt(Math.round(ratio * 10000))) / 10000n;
+            console.log(`   买方 ${index + 1}: ${(ratio * 100).toFixed(1)}% = ${ethers.formatEther(amount)} BNB`);
+            return amount;
+        });
+    }
     else {
-        // 平均分配（考虑滑点）
-        const totalBuyAmount = applySlippage(estimatedBNBOut, slippageTolerance);
+        // 方式3：平均分配
         const amountPerBuyer = totalBuyAmount / BigInt(buyers.length);
         buyAmountsWei = buyers.map(() => amountPerBuyer);
     }
-    // ✅ 验证所有买方余额
+    // ✅ 并行验证所有买方余额
     const reserveGas = ethers.parseEther((config.reserveGasBNB ?? 0.0005).toString());
-    for (let i = 0; i < buyers.length; i++) {
-        const buyer = buyers[i];
+    const erc20Contract = useNativeToken ? null : new Contract(quoteToken, ERC20_BALANCE_OF_ABI, context.provider);
+    await Promise.all(buyers.map(async (buyer, i) => {
         const buyAmount = buyAmountsWei[i];
-        let buyerBalance;
         if (useNativeToken) {
-            buyerBalance = await buyer.provider.getBalance(buyer.address);
+            const buyerBalance = await buyer.provider.getBalance(buyer.address);
             const required = buyAmount + FLAT_FEE + reserveGas;
             if (buyerBalance < required) {
                 throw new Error(`买方 ${i + 1} 余额不足: 需要 ${ethers.formatEther(required)} BNB, 实际 ${ethers.formatEther(buyerBalance)} BNB`);
             }
         }
         else {
-            const erc20 = new Contract(quoteToken, ERC20_BALANCE_OF_ABI, context.provider);
-            buyerBalance = await erc20.balanceOf(buyer.address);
+            const buyerBalance = await erc20Contract.balanceOf(buyer.address);
             const required = buyAmount + FLAT_FEE;
             if (buyerBalance < required) {
                 throw new Error(`买方 ${i + 1} 代币余额不足: 需要 ${ethers.formatUnits(required, quoteTokenDecimals)}, 实际 ${ethers.formatUnits(buyerBalance, quoteTokenDecimals)}`);
             }
         }
-    }
+    }));
     // ✅ 构建卖出交易
     const proxySeller = new Contract(PANCAKE_PROXY_ADDRESS, PANCAKE_PROXY_ABI, seller);
     const deadline = Math.floor(Date.now() / 1000) + 600;
@@ -508,49 +518,35 @@ export async function pancakeBatchSwapMerkle(params) {
         const { v3LpAddresses, v3ExactTokenIn } = routeParams;
         sellUnsigned = await proxySeller.swapV3MultiHop.populateTransaction(v3LpAddresses, v3ExactTokenIn, sellAmountWei, 0n, seller.address, { value: FLAT_FEE });
     }
-    // ✅ 构建多个买入交易
-    const buyUnsignedList = [];
-    for (let i = 0; i < buyers.length; i++) {
-        const buyer = buyers[i];
+    // ✅ 并行构建多个买入交易
+    const buyUnsignedList = await Promise.all(buyers.map(async (buyer, i) => {
         const buyAmount = buyAmountsWei[i];
         const proxyBuyer = new Contract(PANCAKE_PROXY_ADDRESS, PANCAKE_PROXY_ABI, buyer);
         const buyValue = useNativeToken ? buyAmount + FLAT_FEE : FLAT_FEE;
-        let buyUnsigned;
         if (routeParams.routeType === 'v2') {
             const { v2Path } = routeParams;
             const reversePath = [...v2Path].reverse();
-            buyUnsigned = await proxyBuyer.swapV2.populateTransaction(buyAmount, 0n, reversePath, buyer.address, deadline, { value: buyValue });
+            return await proxyBuyer.swapV2.populateTransaction(buyAmount, 0n, reversePath, buyer.address, deadline, { value: buyValue });
         }
         else if (routeParams.routeType === 'v3-single') {
             const { v3TokenIn, v3TokenOut, v3Fee } = routeParams;
-            buyUnsigned = await proxyBuyer.swapV3Single.populateTransaction(v3TokenOut, // 买入时反向
+            return await proxyBuyer.swapV3Single.populateTransaction(v3TokenOut, // 买入时反向
             v3TokenIn, v3Fee, buyAmount, 0n, buyer.address, { value: buyValue });
         }
         else {
             const { v3LpAddresses } = routeParams;
             const exactTokenOut = tokenAddress;
-            buyUnsigned = await proxyBuyer.swapV3MultiHop.populateTransaction(v3LpAddresses, exactTokenOut, buyAmount, 0n, buyer.address, { value: buyValue });
+            return await proxyBuyer.swapV3MultiHop.populateTransaction(v3LpAddresses, exactTokenOut, buyAmount, 0n, buyer.address, { value: buyValue });
         }
-        buyUnsignedList.push(buyUnsigned);
-    }
-    // ✅ 规划 Nonce
+    }));
+    // ✅ 规划 Nonce（并行获取所有钱包的 nonce）
     // 卖方: [授权(可选)] → [卖出]
-    const sellerNonces = [];
-    if (approvalTx) {
-        // 授权已经在 ensureSellerApproval 中消耗了一个 nonce
-    }
     const sellNonce = await nonceManager.getNextNonce(seller);
-    sellerNonces.push(sellNonce);
-    // 买方: 每个买方一个 nonce
-    const buyerNonces = [];
-    for (const buyer of buyers) {
-        const nonce = await nonceManager.getNextNonce(buyer);
-        buyerNonces.push(nonce);
-    }
-    // 利润交易：从第一个买方发送（或卖方，取决于谁有足够余额）
+    // ✅ 并行获取所有买方的 nonce
+    const buyerNonces = await Promise.all(buyers.map(buyer => nonceManager.getNextNonce(buyer)));
+    // 利润交易：从第一个买方发送
     const profitAmount = calculateProfitAmount(estimatedBNBOut);
     let profitTx = null;
-    let profitPayerIndex = 0; // 默认第一个买方支付利润
     if (profitAmount > 0n) {
         // 选择第一个买方作为利润支付者
         const profitPayer = buyers[0];
@@ -566,14 +562,9 @@ export async function pancakeBatchSwapMerkle(params) {
         });
     }
     nonceManager.clearTemp();
-    // ✅ 签名所有交易
-    const signedTransactions = [];
-    // 1. 授权交易（如果有）
-    if (approvalTx) {
-        signedTransactions.push(approvalTx);
-    }
-    // 2. 卖出交易
-    const signedSell = await seller.signTransaction({
+    // ✅ 并行签名所有交易
+    // 1. 签名卖出交易
+    const signedSellPromise = seller.signTransaction({
         ...sellUnsigned,
         from: seller.address,
         nonce: sellNonce,
@@ -582,27 +573,29 @@ export async function pancakeBatchSwapMerkle(params) {
         chainId: context.chainId,
         type: txType
     });
-    signedTransactions.push(signedSell);
-    // 3. 多个买入交易
-    for (let i = 0; i < buyers.length; i++) {
-        const buyer = buyers[i];
-        const buyUnsigned = buyUnsignedList[i];
-        const buyNonce = buyerNonces[i];
-        const signedBuy = await buyer.signTransaction({
-            ...buyUnsigned,
-            from: buyer.address,
-            nonce: buyNonce,
-            gasLimit: finalGasLimit,
-            gasPrice,
-            chainId: context.chainId,
-            type: txType
-        });
-        signedTransactions.push(signedBuy);
-    }
-    // 4. 利润交易（最后）
-    if (profitTx) {
-        signedTransactions.push(profitTx);
-    }
+    // 2. 并行签名所有买入交易
+    const signedBuyPromises = buyers.map((buyer, i) => buyer.signTransaction({
+        ...buyUnsignedList[i],
+        from: buyer.address,
+        nonce: buyerNonces[i],
+        gasLimit: finalGasLimit,
+        gasPrice,
+        chainId: context.chainId,
+        type: txType
+    }));
+    // 3. 等待所有签名完成
+    const [signedSell, ...signedBuys] = await Promise.all([
+        signedSellPromise,
+        ...signedBuyPromises
+    ]);
+    // 4. 按顺序组装交易数组
+    const signedTransactions = [];
+    if (approvalTx)
+        signedTransactions.push(approvalTx); // 授权（如果有）
+    signedTransactions.push(signedSell); // 卖出
+    signedTransactions.push(...signedBuys); // 多个买入
+    if (profitTx)
+        signedTransactions.push(profitTx); // 利润（最后）
     console.log(`✅ 批量换手签名完成: ${signedTransactions.length} 笔交易`);
     console.log(`   - 授权: ${approvalTx ? 1 : 0}, 卖出: 1, 买入: ${buyers.length}, 利润: ${profitTx ? 1 : 0}`);
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "four-flap-meme-sdk",
-  "version": "1.3.70",
+  "version": "1.3.73",
   "description": "SDK for Flap bonding curve and four.meme TokenManager",
   "type": "module",
   "main": "dist/index.js",
@@ -36,4 +36,4 @@
   "devDependencies": {
     "typescript": "^5.6.3"
   }
-}
+}