forgex-cli 1.0.0

package/dist/src/sol-sdk/batch/index.js

@@ -0,0 +1,1573 @@
+import { AnchorProvider } from '@coral-xyz/anchor';
+import { PublicKey, Keypair, Transaction, TransactionMessage, VersionedTransaction, LAMPORTS_PER_SOL, } from '@solana/web3.js';
+import { pumpBuySPLInstructions, pumpSellSPLInstructions, getPumpCurveState } from '../pump/index.js';
+import { raydiumBuyInstruction, raydiumSellInstruction, raydiumGetPoolInfo, raydiumGetCpmmPoolInfo, raydiumCpmmSwapBaseOutBuyInstruction, raydiumCpmmSwapBaseInBuyInstruction, raydiumCpmmSellInstruction, } from '../raydium/index.js';
+import { meteoraDlmmBuyInstructions, meteoraDlmmBuyExactOutInstructions, meteoraDlmmSellInstructions, getBinArray, } from '../meteora/index.js';
+import { pumpSwapBuyInstruction, pumpSwapSellInstruction, pumpSwapGetPoolInfo } from '../pumpswap/index.js';
+import { getLaunchlabReverseInfo, launchlabBuyExactInInstruction, launchlabBuyExactOutInstruction, launchlabSellExactInInstruction, } from '../launchlab/index.js';
+import { getNewWsolAccount } from '../account/index.js';
+import AmmCalc, { PumpAmmCalc, LaunchlabAmmCalc } from '../calc.js';
+import BigNumber from 'bignumber.js';
+import BN from 'bn.js';
+import { getCU } from '../rpc/index.js';
+import JitoJsonRpcClient from '../jito/index.js';
+import { NATIVE_MINT } from '@solana/spl-token';
+import { getWalletAddress, getWalletKeypair } from '../../utils/index.js';
+import { addCommission } from '../transfer/index.js';
+import { BundleBuyTime, VolumeType } from '../../types/index.js';
+import { METEORA_DLMM_PROGRAM } from '../../const/index.js';
+import MeteoraDLMM from '@meteora-ag/dlmm';
+let redis = {
+    pumpCache: {},
+    pumpAtaCache: {},
+    pumpSwapCache: {},
+    pumpSwapAtaCache: {},
+};
+export const batchTrade = async ({ connection, exchangeName, // dex名称
+tokenAddress, // 代币地址
+poolId, // 池子ID
+tradeType, // 交易类型
+slippage, // 滑点
+priorityFee, // 优先费
+priceInSol, // 价格
+decimals, // 小数位
+poolInfo, // 池子信息
+ammReverseInfo = undefined, // 深度信息
+launchlabReverseInfo = undefined, // 深度信息
+meteoraDLMMReverseInfo = undefined, // meteora 池子信息
+commissionWallet, // 佣金钱包
+commissionAmount, // 佣金数量
+creatorAddress, // 创建者地址
+walletAmounts, pumpfunReverseInfo, raydiumV4Keys = undefined, raydiumCpmmKeys = undefined, volumeType = VolumeType.ONE_BUY_ONE_SELL, // 刷量方式
+simulate = false, // 模拟交易
+ }) => {
+    slippage = slippage / 100;
+    if (!poolId || !tokenAddress || !priceInSol || !walletAmounts.length) {
+        console.log('参数错误', {
+            poolId,
+            tokenAddress,
+            priceInSol,
+            walletAmounts,
+        });
+        return undefined;
+    }
+    if (exchangeName === 'PumpSwap') {
+        return pumpswapBatchTrade({
+            connection,
+            poolInfo,
+            tradeType,
+            slippage,
+            priorityFee,
+            decimals,
+            reverseInfo: ammReverseInfo,
+            commissionWallet,
+            commissionAmount,
+            creator: new PublicKey(creatorAddress),
+            walletAmounts,
+            volumeType,
+            simulate,
+        });
+    }
+    else if (exchangeName === 'Pump') {
+        return pumpBatchTrade({
+            connection,
+            tokenAddress,
+            poolId: poolInfo.pairAddress,
+            tradeType,
+            slippage,
+            priorityFee,
+            priceInSol,
+            commissionWallet,
+            commissionAmount,
+            creator: new PublicKey(creatorAddress),
+            walletAmounts,
+            initialPoolData: pumpfunReverseInfo,
+            volumeType,
+            simulate,
+        });
+    }
+    else if (exchangeName === 'Raydium') {
+        if (!raydiumV4Keys)
+            return [];
+        return raydiumBatchTrade({
+            connection,
+            tokenAddress,
+            poolId,
+            tradeType: tradeType,
+            slippage,
+            priorityFee,
+            priceInSol,
+            commissionWallet,
+            commissionAmount,
+            walletAmounts,
+            decimals,
+            reverseInfo: ammReverseInfo,
+            raydiumV4Keys,
+            poolInfo,
+            volumeType,
+            simulate,
+        });
+    }
+    else if (exchangeName === 'Raydium CPMM') {
+        console.log('ammReverseInfo', ammReverseInfo);
+        console.log('raydiumCpmmKeys', raydiumCpmmKeys);
+        if (!raydiumCpmmKeys)
+            return [];
+        return raydiumCpmmBatchTrade({
+            connection,
+            tokenAddress,
+            poolId,
+            tradeType: tradeType,
+            slippage,
+            priorityFee,
+            priceInSol,
+            commissionWallet,
+            commissionAmount,
+            walletAmounts,
+            decimals,
+            raydiumCpmmKeys,
+            poolInfo,
+            volumeType,
+            simulate,
+            reverseInfo: ammReverseInfo,
+        });
+    }
+    else if (exchangeName === 'LaunchLab') {
+        return launchlabBatchTrade({
+            connection,
+            tokenAddress,
+            poolId,
+            tradeType,
+            slippage,
+            priorityFee,
+            decimals,
+            reverseInfo: launchlabReverseInfo,
+            commissionWallet,
+            commissionAmount,
+            creator: new PublicKey(creatorAddress),
+            walletAmounts,
+            volumeType,
+            simulate,
+        });
+    }
+    else if (exchangeName === 'Meteora') {
+        return meteoraDlmmBatchTrade({
+            connection,
+            tokenAddress,
+            poolId,
+            tradeType,
+            slippage,
+            priorityFee,
+            decimals,
+            reverseInfo: meteoraDLMMReverseInfo,
+            commissionWallet,
+            commissionAmount,
+            creator: new PublicKey(creatorAddress),
+            walletAmounts,
+            volumeType,
+            simulate,
+        });
+    }
+    console.log('exchangeName', exchangeName);
+    return [];
+};
+export const launchlabBatchTrade = async ({ connection, snipers, tokenAddress, poolId, tradeType, slippage, priorityFee, decimals, reverseInfo, commissionWallet, commissionAmount, lutAccount, creator, walletAmounts, bundleBuyTime, volumeType = VolumeType.ONE_BUY_ONE_SELL, simulate = false, }) => {
+    const provider = new AnchorProvider(connection, {
+        publicKey: Keypair.generate().publicKey,
+        signTransaction: async () => {
+            throw new Error('不支持签名');
+        },
+        signAllTransactions: async () => {
+            throw new Error('不支持签名');
+        },
+    }, {});
+    // 使用getPumpCurveState方法解析池子数据
+    const poolData = reverseInfo || (await getLaunchlabReverseInfo({ connection, poolId }));
+    console.log('poolData: ', poolData);
+    const parsedPoolData = {
+        supply: poolData.supply.toString(),
+        baseDecimals: poolData.baseDecimals,
+        quoteDecimals: poolData.quoteDecimals,
+        migrateType: poolData.migrateType,
+        totalBaseSell: poolData.totalBaseSell.toString(),
+        virtualBase: poolData.virtualBase.toString(),
+        virtualQuote: poolData.virtualQuote.toString(),
+        realBase: poolData.realBase.toString(),
+        realQuote: poolData.realQuote.toString(),
+    };
+    // 创建计算器实例
+    const launchlabCalc = new LaunchlabAmmCalc({
+        baseDecimals: parsedPoolData.baseDecimals,
+        quoteDecimals: parsedPoolData.quoteDecimals,
+        migrateType: parsedPoolData.migrateType,
+        supply: new BN(parsedPoolData.supply),
+        totalBaseSell: new BN(parsedPoolData.totalBaseSell),
+        virtualBase: new BN(parsedPoolData.virtualBase),
+        virtualQuote: new BN(parsedPoolData.virtualQuote),
+        realBase: new BN(parsedPoolData.realBase),
+        realQuote: new BN(parsedPoolData.realQuote),
+    });
+    const payers = walletAmounts.map(item => getWalletKeypair(item.privateKey));
+    const jito = new JitoJsonRpcClient();
+    const blockhash = (await connection.getLatestBlockhash()).blockhash;
+    const base64Txs = [];
+    // 处理交易逻辑
+    if (tradeType === 'buy') {
+        try {
+            for (const payer of walletAmounts) {
+                const currentPayer = getWalletKeypair(payer.privateKey);
+                const currentAmount = new BigNumber(payer.amount).times(LAMPORTS_PER_SOL).toFixed(0);
+                // let receiveAmount;
+                // try {
+                //   receiveAmount = launchlabCalc.calculateBuyAmountOut(currentAmount);
+                // } catch (err) {
+                //   console.log('err: ', err);
+                //   break;
+                // }
+                const buyTx = await launchlabBuyExactInInstruction({
+                    provider,
+                    owner: currentPayer.publicKey,
+                    baseMint: new PublicKey(tokenAddress),
+                    quoteMint: NATIVE_MINT,
+                    amountIn: BigInt(currentAmount),
+                    minAmountOut: BigInt(0),
+                    needCreateAtaAccount: true,
+                    needCloseTokenAccount: true,
+                });
+                const tx = getTx(buyTx, currentPayer, priorityFee, jito);
+                // addPriorityFee(tx, cu);
+                addCommission(tx, currentPayer, commissionWallet, new BigNumber(currentAmount).times(commissionAmount).toFixed(0));
+                const base64Tx = await getBase64Tx({
+                    tx,
+                    payer: currentPayer,
+                    signers: [currentPayer],
+                    blockhash,
+                    connection,
+                    lutAccount,
+                    simulate,
+                });
+                base64Txs.push(base64Tx);
+            }
+            return base64Txs;
+        }
+        catch (error) {
+            throw new Error(`构造交易指令失败: ${error.message}`);
+        }
+    }
+    else if (tradeType === 'sell') {
+        try {
+            for (const payer of walletAmounts) {
+                const currentPayer = getWalletKeypair(payer.privateKey);
+                const currentAmount = new BigNumber(payer.amount).times(10 ** decimals).toFixed(0);
+                const receiveAmount = launchlabCalc.calculateSellAmountOut(currentAmount);
+                const sellTx = await launchlabSellExactInInstruction({
+                    provider,
+                    owner: currentPayer.publicKey,
+                    baseMint: new PublicKey(tokenAddress),
+                    quoteMint: NATIVE_MINT,
+                    amountIn: BigInt(currentAmount),
+                    minAmountOut: BigInt(new BigNumber(receiveAmount).times(1 - slippage).toFixed(0)),
+                    needCreateAtaAccount: true,
+                    needCloseTokenAccount: true,
+                });
+                const tx = getTx(sellTx, currentPayer, priorityFee, jito);
+                // addPriorityFee(tx, cu);
+                addCommission(tx, currentPayer, commissionWallet, new BigNumber(receiveAmount).times(commissionAmount).toFixed(0));
+                const base64Tx = await getBase64Tx({
+                    tx,
+                    payer: currentPayer,
+                    signers: [currentPayer],
+                    blockhash,
+                    connection,
+                    simulate,
+                });
+                base64Txs.push(base64Tx);
+            }
+            return base64Txs;
+        }
+        catch (error) {
+            throw new Error(`构造交易指令失败: ${error.message}`);
+        }
+    }
+    else if (tradeType === 'buyWithSell') {
+        // 实现 Pump 的多买多卖逻辑
+        try {
+            for (const payer of walletAmounts) {
+                const currentPayer = getWalletKeypair(payer.privateKey);
+                const currentAmount = new BigNumber(payer.amount).times(LAMPORTS_PER_SOL).toFixed(0);
+                // 提前创建 wsolAccount
+                const { wsolAccount, createWsolAccount } = await getNewWsolAccount(currentPayer.publicKey, new BigNumber(currentAmount).times(1 + slippage).toFixed(0));
+                // 创建组合交易
+                const tx = new Transaction();
+                let totalBuyReceiveAmount = new BN(0);
+                // 根据 volumeType 确定买入和卖出次数
+                const { buyCount, sellCount } = getVolumeTypeConfig(volumeType);
+                // 执行多次买入
+                let remainingAmount = new BigNumber(currentAmount);
+                for (let i = 0; i < buyCount; i++) {
+                    let buyAmount;
+                    if (i === buyCount - 1) {
+                        // 最后一次买入时，使用所有剩余资金
+                        buyAmount = remainingAmount.toFixed(0);
+                    }
+                    else {
+                        // 前面几次按平均分配
+                        buyAmount = new BigNumber(currentAmount).div(buyCount).toFixed(0);
+                        remainingAmount = remainingAmount.minus(buyAmount);
+                    }
+                    let buyReceiveAmount;
+                    try {
+                        buyReceiveAmount = launchlabCalc.calculateBuyAmountOut(buyAmount);
+                    }
+                    catch (err) {
+                        console.log('err: ', err);
+                        break;
+                    }
+                    totalBuyReceiveAmount = totalBuyReceiveAmount.add(new BN(buyReceiveAmount.toString()));
+                    // 添加买入指令
+                    const buyTx = await launchlabBuyExactOutInstruction({
+                        provider,
+                        owner: currentPayer.publicKey,
+                        baseMint: new PublicKey(tokenAddress),
+                        quoteMint: NATIVE_MINT,
+                        amount: BigInt(buyReceiveAmount.toString()),
+                        maxSolCost: BigInt(new BigNumber(currentAmount).times(1 + slippage).toFixed(0)),
+                        needCreateAtaAccount: i === 0,
+                        needCloseTokenAccount: false,
+                        initialWsolAccount: wsolAccount,
+                        createWsolAccountInstruction: createWsolAccount,
+                    });
+                    tx.add(buyTx);
+                }
+                // 执行多次卖出
+                let remainingTokenAmount = totalBuyReceiveAmount;
+                for (let i = 0; i < sellCount; i++) {
+                    let sellTokenAmount;
+                    if (i === sellCount - 1) {
+                        // 最后一次卖出时，卖出所有剩余代币
+                        sellTokenAmount = remainingTokenAmount.toString();
+                    }
+                    else {
+                        // 前面几次按平均分配
+                        sellTokenAmount = totalBuyReceiveAmount.div(new BN(sellCount)).toString();
+                        remainingTokenAmount = remainingTokenAmount.sub(new BN(sellTokenAmount));
+                    }
+                    const sellReceiveAmount = launchlabCalc.calculateSellAmountOut(sellTokenAmount);
+                    // 添加卖出指令
+                    const sellTx = await launchlabSellExactInInstruction({
+                        provider,
+                        owner: currentPayer.publicKey,
+                        baseMint: new PublicKey(tokenAddress),
+                        quoteMint: NATIVE_MINT,
+                        amountIn: BigInt(sellTokenAmount),
+                        minAmountOut: BigInt(new BigNumber(sellReceiveAmount).times(1 - slippage).toFixed(0)),
+                        needCreateAtaAccount: false,
+                        needCloseTokenAccount: i === sellCount - 1,
+                        initialWsolAccount: wsolAccount,
+                        createWsolAccountInstruction: createWsolAccount,
+                    });
+                    tx.add(sellTx);
+                }
+                const finalTx = getTx(tx, currentPayer, priorityFee, jito);
+                addCommission(finalTx, currentPayer, commissionWallet, new BigNumber(currentAmount).times(commissionAmount).toFixed(0));
+                const base64Tx = await getBase64Tx({
+                    tx: finalTx,
+                    payer: currentPayer,
+                    signers: [currentPayer],
+                    blockhash,
+                    connection,
+                    lutAccount,
+                    simulate,
+                });
+                base64Txs.push(base64Tx);
+            }
+            return base64Txs;
+        }
+        catch (error) {
+            throw new Error(`构造交易指令失败: ${error.message}`);
+        }
+    }
+    else if (tradeType === 'sniperBuy') {
+        if (snipers) {
+            let txs = [];
+            let signers = [];
+            for (const [index, sniper] of snipers.entries()) {
+                const currentPayer = getWalletKeypair(sniper.wallet);
+                const currentAmount = new BigNumber(sniper.amount).times(10 ** 9).toString(10);
+                console.log('currentAmount: ', currentAmount);
+                let receiveAmount;
+                try {
+                    receiveAmount = launchlabCalc.calculateBuyAmountOut(currentAmount);
+                    console.log('receiveAmount: ', receiveAmount.toString());
+                }
+                catch (err) {
+                    console.log('err: ', err);
+                    break;
+                }
+                const buyTx = await launchlabBuyExactOutInstruction({
+                    provider,
+                    owner: currentPayer.publicKey,
+                    baseMint: new PublicKey(tokenAddress),
+                    quoteMint: NATIVE_MINT,
+                    amount: BigInt(receiveAmount.toString()),
+                    maxSolCost: BigInt(new BigNumber(currentAmount).times(1 + slippage).toFixed(0)),
+                    initialWsolAccount: undefined,
+                    needCreateAtaAccount: true,
+                    needCloseTokenAccount: true,
+                });
+                if (index % (lutAccount ? 5 : 2) === 0) {
+                    txs.push(new Transaction());
+                    signers.push([]);
+                }
+                txs[txs.length - 1].add(buyTx);
+                signers[signers.length - 1].push(currentPayer);
+            }
+            const tipTx = new Transaction();
+            tipTx.add(jito.getTipInstruction(new PublicKey(getWalletAddress(snipers[0].wallet)), priorityFee));
+            txs.push(tipTx);
+            signers.push([getWalletKeypair(snipers[0].wallet)]);
+            addCommission(txs[txs.length - 1], getWalletKeypair(snipers[0].wallet), commissionWallet, new BigNumber(snipers.length).times(commissionAmount).times(LAMPORTS_PER_SOL).toString(10));
+            for (const [index, tx] of txs.entries()) {
+                const base64Tx = await getBase64Tx({
+                    tx,
+                    payer: signers[0][0], // 第一个交易者作为 fee payer
+                    signers: [...signers[index]], // 当前交易的所有签名者
+                    blockhash,
+                    connection,
+                    lutAccount,
+                    simulate,
+                });
+                base64Txs.push(base64Tx);
+            }
+            return base64Txs;
+        }
+        else {
+            throw new Error('snipers 不能为空');
+        }
+    }
+};
+export const pumpswapBatchTrade = async ({ connection, poolInfo, tradeType, slippage, priorityFee, decimals, reverseInfo, commissionWallet, commissionAmount, creator, walletAmounts, volumeType = VolumeType.ONE_BUY_ONE_SELL, simulate = false, }) => {
+    let info = reverseInfo;
+    if (!info) {
+        info = await pumpSwapGetPoolInfo(connection, poolInfo.pairAddress);
+    }
+    const mintA = new PublicKey(info.mintA);
+    const mintB = new PublicKey(info.mintB);
+    const basereverse = info.poolBaseTokenInfo.amount.toString();
+    const quoteReserve = info.poolQuoteTokenInfo.amount.toString();
+    const pumpswapCalc = new AmmCalc({
+        baseReserve: basereverse,
+        quoteReserve: quoteReserve,
+        baseDecimals: mintA.toBase58() === NATIVE_MINT.toBase58() ? 9 : decimals,
+        quoteDecimals: mintB.toBase58() === NATIVE_MINT.toBase58() ? 9 : decimals,
+    });
+    const base64Txs = [];
+    const jito = new JitoJsonRpcClient();
+    const blockhash = (await connection.getLatestBlockhash()).blockhash;
+    if (tradeType === 'buy' || tradeType === 'sniperBuy') {
+        for (const [index, payer] of walletAmounts.entries()) {
+            const currentPayer = getWalletKeypair(payer.privateKey);
+            const currentAmount = new BigNumber(payer.amount).times(10 ** 9).toFixed(0);
+            if (Number(currentAmount) <= 0) {
+                continue;
+            }
+            let receiveAmount;
+            try {
+                receiveAmount = pumpswapCalc.swap(currentAmount, mintA.toBase58() === NATIVE_MINT.toBase58() ? true : false);
+            }
+            catch (err) {
+                console.log('err: ', err);
+                break;
+            }
+            const buyTx = await pumpSwapBuyInstruction({
+                owner: currentPayer,
+                poolInfo: {
+                    poolId: poolInfo.pairAddress,
+                    mintA: mintA.toBase58(),
+                    mintB: mintB.toBase58(),
+                },
+                wsolAmount: new BN(currentAmount),
+                tokenAmount: new BN(receiveAmount),
+                slippage,
+                creator,
+            });
+            let tx = getTx(buyTx, currentPayer, priorityFee, jito);
+            if (tradeType === 'sniperBuy' && index === 0) {
+                addCommission(tx, currentPayer, commissionWallet, new BigNumber(commissionAmount).times(LAMPORTS_PER_SOL).toFixed(0));
+            }
+            else {
+                addCommission(tx, currentPayer, commissionWallet, new BigNumber(currentAmount).times(commissionAmount).toFixed(0));
+            }
+            // console.log('tx: ', tx);
+            const base64Tx = await getBase64Tx({
+                tx,
+                payer: currentPayer,
+                signers: [currentPayer],
+                blockhash,
+                connection,
+                simulate,
+            });
+            base64Txs.push(base64Tx);
+        }
+    }
+    else if (tradeType === 'sell') {
+        for (const payer of walletAmounts) {
+            const currentPayer = getWalletKeypair(payer.privateKey);
+            const currentAmount = new BigNumber(payer.amount).times(10 ** decimals).toFixed(0);
+            let receiveAmount;
+            if (Number(currentAmount) <= 0) {
+                continue;
+            }
+            try {
+                receiveAmount = pumpswapCalc.swap(currentAmount, mintA.toBase58() === NATIVE_MINT.toBase58() ? false : true);
+            }
+            catch (err) {
+                console.log('err: ', err);
+                break;
+            }
+            const sellTx = await pumpSwapSellInstruction({
+                owner: currentPayer,
+                poolInfo: {
+                    poolId: poolInfo.pairAddress,
+                    mintA: mintA.toBase58(),
+                    mintB: mintB.toBase58(),
+                },
+                tokenAmount: new BN(currentAmount),
+                wsolAmount: new BN(receiveAmount),
+                slippage,
+                creator,
+            });
+            let tx = getTx(sellTx, currentPayer, priorityFee, jito);
+            addCommission(tx, currentPayer, commissionWallet, new BigNumber(receiveAmount).times(commissionAmount).toFixed(0));
+            const base64Tx = await getBase64Tx({
+                tx,
+                payer: currentPayer,
+                signers: [currentPayer],
+                blockhash,
+                connection,
+                simulate,
+            });
+            base64Txs.push(base64Tx);
+        }
+    }
+    else if (tradeType === 'buyWithSell') {
+        // 实现多买多卖逻辑
+        for (const payer of walletAmounts) {
+            const currentPayer = getWalletKeypair(payer.privateKey);
+            const currentAmount = new BigNumber(payer.amount).times(10 ** 9).toFixed(0);
+            if (Number(currentAmount) <= 0) {
+                continue;
+            }
+            // 提前创建 wsolAccount
+            const { wsolAccount, createWsolAccount } = await getNewWsolAccount(currentPayer.publicKey, new BigNumber(currentAmount).times(1 + slippage).toFixed(0));
+            try {
+                // 创建组合交易
+                const tx = new Transaction();
+                let totalBuyReceiveAmount = new BN(0);
+                // 根据 volumeType 确定买入和卖出次数
+                const { buyCount, sellCount } = getVolumeTypeConfig(volumeType);
+                // 执行多次买入
+                let remainingAmount = new BigNumber(currentAmount);
+                for (let i = 0; i < buyCount; i++) {
+                    let buyAmount;
+                    if (i === buyCount - 1) {
+                        // 最后一次买入时，使用所有剩余资金
+                        buyAmount = remainingAmount.toFixed(0);
+                    }
+                    else {
+                        // 前面几次按平均分配
+                        buyAmount = new BigNumber(currentAmount).div(buyCount).toFixed(0);
+                        remainingAmount = remainingAmount.minus(buyAmount);
+                    }
+                    let buyReceiveAmount = pumpswapCalc.swap(buyAmount, mintA.toBase58() === NATIVE_MINT.toBase58() ? true : false);
+                    totalBuyReceiveAmount = totalBuyReceiveAmount.add(new BN(buyReceiveAmount.toString()));
+                    const buyTx = await pumpSwapBuyInstruction({
+                        owner: currentPayer,
+                        poolInfo: {
+                            poolId: poolInfo.pairAddress,
+                            mintA: mintA.toBase58(),
+                            mintB: mintB.toBase58(),
+                        },
+                        wsolAmount: new BN(buyAmount),
+                        tokenAmount: new BN(buyReceiveAmount),
+                        slippage,
+                        creator,
+                        needCreateAtaAccount: i === 0,
+                        needCloseTokenAccount: false,
+                        needCloseWsolAccount: false,
+                        initialWsolAccount: wsolAccount,
+                        createWsolAccountInstruction: createWsolAccount,
+                    });
+                    tx.add(buyTx);
+                }
+                // 执行多次卖出
+                let remainingTokenAmount = totalBuyReceiveAmount;
+                for (let i = 0; i < sellCount; i++) {
+                    let sellTokenAmount;
+                    if (i === sellCount - 1) {
+                        // 最后一次卖出时，卖出所有剩余代币
+                        sellTokenAmount = remainingTokenAmount;
+                    }
+                    else {
+                        // 前面几次按平均分配
+                        sellTokenAmount = totalBuyReceiveAmount.div(new BN(sellCount));
+                        remainingTokenAmount = remainingTokenAmount.sub(sellTokenAmount);
+                    }
+                    let sellReceiveAmount = pumpswapCalc.swap(sellTokenAmount.toString(), mintA.toBase58() === NATIVE_MINT.toBase58() ? false : true);
+                    const sellTx = await pumpSwapSellInstruction({
+                        owner: currentPayer,
+                        poolInfo: {
+                            poolId: poolInfo.pairAddress,
+                            mintA: mintA.toBase58(),
+                            mintB: mintB.toBase58(),
+                        },
+                        tokenAmount: sellTokenAmount,
+                        wsolAmount: new BN(sellReceiveAmount),
+                        slippage,
+                        creator,
+                        needCreateAtaAccount: false,
+                        needCloseTokenAccount: i === sellCount - 1,
+                        needCloseWsolAccount: i === sellCount - 1,
+                        initialWsolAccount: wsolAccount,
+                    });
+                    tx.add(sellTx);
+                }
+                let finalTx = getTx(tx, currentPayer, priorityFee, jito, 400_000);
+                addCommission(finalTx, currentPayer, commissionWallet, commissionAmount);
+                const base64Tx = await getBase64Tx({
+                    tx: finalTx,
+                    payer: currentPayer,
+                    signers: [currentPayer],
+                    blockhash,
+                    connection,
+                    simulate,
+                });
+                base64Txs.push(base64Tx);
+            }
+            catch (err) {
+                console.log('buyWithSell err: ', err);
+                break;
+            }
+        }
+    }
+    return base64Txs;
+};
+export const pumpBatchTrade = async ({ connection, walletAmounts, snipers, tokenAddress, poolId, tradeType, slippage, priorityFee, priceInSol, initialPoolData, lutAccount, commissionWallet, commissionAmount, creator, bundleBuyTime, volumeType = VolumeType.ONE_BUY_ONE_SELL, simulate = false, }) => {
+    const provider = new AnchorProvider(connection, {
+        publicKey: Keypair.generate().publicKey,
+        signTransaction: async () => {
+            throw new Error('不支持签名');
+        },
+        signAllTransactions: async () => {
+            throw new Error('不支持签名');
+        },
+    }, {});
+    // 使用getPumpCurveState方法解析池子数据
+    const poolData = initialPoolData || (await getPumpCurveState(connection, poolId));
+    const parsedPoolData = {
+        virtual_sol_reserves: poolData.virtualSolReserves.toString(),
+        virtual_token_reserves: poolData.virtualTokenReserves.toString(),
+        real_token_reserves: poolData.realTokenReserves.toString(),
+        real_sol_reserves: poolData.realSolReserves.toString(),
+        token_total_supply: poolData.tokenTotalSupply.toString(),
+        complete: poolData.complete,
+    };
+    console.log('parsedPoolData: ', parsedPoolData);
+    // 创建计算器实例
+    const pumpCalc = new PumpAmmCalc({
+        initialVirtualSolReserves: new BN(parsedPoolData.virtual_sol_reserves),
+        tokenTotalSupply: new BN(parsedPoolData.token_total_supply),
+        initialRealSolReserves: new BN(parsedPoolData.real_sol_reserves),
+        initialVirtualTokenReserves: new BN(parsedPoolData.virtual_token_reserves),
+        initialRealTokenReserves: new BN(parsedPoolData.real_token_reserves),
+    });
+    const payers = walletAmounts.map(item => getWalletKeypair(item.privateKey));
+    const jito = new JitoJsonRpcClient();
+    const blockhash = (await connection.getLatestBlockhash()).blockhash;
+    const base64Txs = [];
+    // 处理交易逻辑
+    if (tradeType === 'buy') {
+        try {
+            for (const payer of walletAmounts) {
+                const currentPayer = getWalletKeypair(payer.privateKey);
+                const currentAmount = new BigNumber(payer.amount).times(LAMPORTS_PER_SOL).toFixed(0);
+                let receiveAmount;
+                try {
+                    receiveAmount = pumpCalc.calculateBuyAmountOut(currentAmount);
+                }
+                catch (err) {
+                    console.log('err: ', err);
+                    continue;
+                }
+                const [_, buyTx] = await pumpBuySPLInstructions(provider, currentPayer.publicKey, tokenAddress, currentAmount, slippage, new BigNumber(priceInSol).toString(10), creator, receiveAmount.toString());
+                const tx = getTx(buyTx, currentPayer, priorityFee, jito);
+                // addPriorityFee(tx, cu);
+                addCommission(tx, currentPayer, commissionWallet, new BigNumber(currentAmount).times(commissionAmount).toFixed(0));
+                const base64Tx = await getBase64Tx({
+                    tx,
+                    payer: currentPayer,
+                    signers: [currentPayer],
+                    blockhash,
+                    connection,
+                    lutAccount,
+                    simulate,
+                });
+                base64Txs.push(base64Tx);
+            }
+            return base64Txs;
+        }
+        catch (error) {
+            throw new Error(`构造交易指令失败: ${error.message}`);
+        }
+    }
+    else if (tradeType === 'sell') {
+        try {
+            for (const payer of walletAmounts) {
+                const currentPayer = getWalletKeypair(payer.privateKey);
+                const currentAmount = new BigNumber(payer.amount).times(10 ** 6).toFixed(0);
+                let receiveAmount;
+                try {
+                    receiveAmount = pumpCalc.calculateSellAmountOut(currentAmount);
+                }
+                catch (err) {
+                    console.log('err: ', err);
+                    continue;
+                }
+                const sellTx = await pumpSellSPLInstructions(provider, currentPayer, tokenAddress, new BigNumber(currentAmount).toString(10), slippage, receiveAmount, creator);
+                const tx = getTx(sellTx, currentPayer, priorityFee, jito);
+                // addPriorityFee(tx, cu);
+                addCommission(tx, currentPayer, commissionWallet, new BigNumber(receiveAmount).times(commissionAmount).toFixed(0));
+                const base64Tx = await getBase64Tx({
+                    tx,
+                    payer: currentPayer,
+                    signers: [currentPayer],
+                    blockhash,
+                    connection,
+                    simulate,
+                });
+                base64Txs.push(base64Tx);
+            }
+            return base64Txs;
+        }
+        catch (error) {
+            throw new Error(`构造交易指令失败: ${error.message}`);
+        }
+    }
+    else if (tradeType === 'buyWithSell') {
+        // 实现 Pump 的多买多卖逻辑
+        try {
+            for (const payer of walletAmounts) {
+                const currentPayer = getWalletKeypair(payer.privateKey);
+                const currentAmount = new BigNumber(payer.amount).times(LAMPORTS_PER_SOL).toFixed(0);
+                // 创建组合交易
+                const tx = new Transaction();
+                let totalBuyReceiveAmount = new BN(0);
+                // 根据 volumeType 确定买入和卖出次数
+                const { buyCount, sellCount } = getVolumeTypeConfig(volumeType);
+                // 执行多次买入
+                let remainingAmount = new BigNumber(currentAmount);
+                for (let i = 0; i < buyCount; i++) {
+                    let buyAmount;
+                    if (i === buyCount - 1) {
+                        // 最后一次买入时，使用所有剩余资金
+                        buyAmount = remainingAmount.toFixed(0);
+                    }
+                    else {
+                        // 前面几次按平均分配
+                        buyAmount = new BigNumber(currentAmount).div(buyCount).toFixed(0);
+                        remainingAmount = remainingAmount.minus(buyAmount);
+                    }
+                    let buyReceiveAmount;
+                    try {
+                        buyReceiveAmount = pumpCalc.calculateBuyAmountOut(buyAmount);
+                    }
+                    catch (err) {
+                        console.log('err: ', err);
+                        break;
+                    }
+                    totalBuyReceiveAmount = totalBuyReceiveAmount.add(new BN(buyReceiveAmount.toString()));
+                    // 添加买入指令
+                    const [_, buyTx] = await pumpBuySPLInstructions(provider, currentPayer.publicKey, tokenAddress, buyAmount, slippage, new BigNumber(priceInSol).toString(10), creator, buyReceiveAmount.toString());
+                    tx.add(buyTx);
+                }
+                // 执行多次卖出
+                let remainingTokenAmount = totalBuyReceiveAmount;
+                for (let i = 0; i < sellCount; i++) {
+                    let sellTokenAmount;
+                    if (i === sellCount - 1) {
+                        // 最后一次卖出时，卖出所有剩余代币
+                        sellTokenAmount = remainingTokenAmount.toString();
+                    }
+                    else {
+                        // 前面几次按平均分配
+                        sellTokenAmount = totalBuyReceiveAmount.div(new BN(sellCount)).toString();
+                        remainingTokenAmount = remainingTokenAmount.sub(new BN(sellTokenAmount));
+                    }
+                    let sellReceiveAmount;
+                    try {
+                        sellReceiveAmount = pumpCalc.calculateSellAmountOut(sellTokenAmount);
+                    }
+                    catch (err) {
+                        console.log('err: ', err);
+                        break;
+                    }
+                    // 添加卖出指令
+                    const sellTx = await pumpSellSPLInstructions(provider, currentPayer, tokenAddress, sellTokenAmount, slippage, sellReceiveAmount, creator);
+                    tx.add(sellTx);
+                }
+                const finalTx = getTx(tx, currentPayer, priorityFee, jito);
+                addCommission(finalTx, currentPayer, commissionWallet, new BigNumber(currentAmount).times(commissionAmount).toFixed(0));
+                const base64Tx = await getBase64Tx({
+                    tx: finalTx,
+                    payer: currentPayer,
+                    signers: [currentPayer],
+                    blockhash,
+                    connection,
+                    lutAccount,
+                    simulate,
+                });
+                base64Txs.push(base64Tx);
+            }
+            return base64Txs;
+        }
+        catch (error) {
+            throw new Error(`构造交易指令失败: ${error.message}`);
+        }
+    }
+    else if (tradeType === 'sniperBuy') {
+        if (snipers) {
+            let txs = [];
+            let signers = [];
+            for (const [index, sniper] of snipers.entries()) {
+                const currentPayer = getWalletKeypair(sniper.wallet);
+                const currentAmount = new BigNumber(sniper.amount).times(10 ** 9).toString(10);
+                console.log('currentAmount: ', currentAmount);
+                let receiveAmount;
+                try {
+                    receiveAmount = pumpCalc.calculateBuyAmountOut(currentAmount);
+                    console.log('receiveAmount: ', receiveAmount.toString());
+                }
+                catch (err) {
+                    continue;
+                }
+                const [_, buyTx] = await pumpBuySPLInstructions(provider, currentPayer.publicKey, tokenAddress, currentAmount, slippage, new BigNumber(priceInSol).toString(10), creator, receiveAmount.toString());
+                if (index % (lutAccount ? 4 : 3) === 0) {
+                    txs.push(new Transaction());
+                    signers.push([]);
+                }
+                txs[txs.length - 1].add(buyTx);
+                if (bundleBuyTime === BundleBuyTime.T1_T5 && index === 0) {
+                    txs[txs.length - 1].add(jito.getTipInstruction(currentPayer.publicKey, priorityFee));
+                    addCommission(txs[txs.length - 1], currentPayer, commissionWallet, new BigNumber(snipers.length)
+                        .times(commissionAmount)
+                        .times(LAMPORTS_PER_SOL)
+                        .toString(10));
+                }
+                signers[signers.length - 1].push(currentPayer);
+            }
+            for (const [index, tx] of txs.entries()) {
+                const base64Tx = await getBase64Tx({
+                    tx,
+                    payer: signers[0][0], // 第一个交易者作为 fee payer
+                    signers: [...signers[index]], // 当前交易的所有签名者
+                    blockhash,
+                    connection,
+                    lutAccount,
+                    simulate,
+                });
+                base64Txs.push(base64Tx);
+            }
+            return base64Txs;
+        }
+        else {
+            throw new Error('snipers 不能为空');
+        }
+    }
+};
+export const raydiumBatchTrade = async ({ connection, tokenAddress, poolId, tradeType, slippage, priorityFee, priceInSol, commissionWallet, commissionAmount, walletAmounts, reverseInfo, decimals, raydiumV4Keys, poolInfo, volumeType = VolumeType.ONE_BUY_ONE_SELL, simulate = false, }) => {
+    let info = reverseInfo;
+    if (!info) {
+        const { poolBaseTokenInfo, poolQuoteTokenInfo } = await raydiumGetPoolInfo(connection, poolId);
+        info = {
+            mintA: poolInfo.tokenA,
+            mintB: poolInfo.tokenB,
+            poolBaseTokenInfo: {
+                amount: poolBaseTokenInfo.amount.toString(),
+            },
+            poolQuoteTokenInfo: {
+                amount: poolQuoteTokenInfo.amount.toString(),
+            },
+        };
+    }
+    const mintA = new PublicKey(info.mintA);
+    const mintB = new PublicKey(info.mintB);
+    const basereverse = info.poolBaseTokenInfo.amount.toString();
+    const quoteReserve = info.poolQuoteTokenInfo.amount.toString();
+    const raydiumCalc = new AmmCalc({
+        baseReserve: basereverse,
+        quoteReserve: quoteReserve,
+        baseDecimals: mintA.toBase58() === NATIVE_MINT.toBase58() ? 9 : decimals,
+        quoteDecimals: mintB.toBase58() === NATIVE_MINT.toBase58() ? 9 : decimals,
+    });
+    const base64Txs = [];
+    const jito = new JitoJsonRpcClient();
+    const blockhash = (await connection.getLatestBlockhash()).blockhash;
+    if (tradeType === 'buy') {
+        for (const payer of walletAmounts) {
+            const currentPayer = getWalletKeypair(payer.privateKey);
+            const currentAmount = new BigNumber(payer.amount).times(10 ** 9).toFixed(0);
+            if (Number(currentAmount) <= 0) {
+                continue;
+            }
+            let receiveAmount;
+            try {
+                receiveAmount = raydiumCalc.swap(currentAmount, mintA.toBase58() === NATIVE_MINT.toBase58() ? true : false);
+            }
+            catch (err) {
+                console.log('err: ', err);
+                break;
+            }
+            const buyTx = await raydiumBuyInstruction({
+                amount: currentAmount,
+                owner: currentPayer.publicKey,
+                poolKeys: raydiumV4Keys,
+                mintA: mintA.toBase58(),
+                mintB: mintB.toBase58(),
+                minAmountOut: new BigNumber(receiveAmount).times(1 - slippage).toFixed(0),
+            });
+            let tx = getTx(buyTx, currentPayer, priorityFee, jito);
+            addCommission(tx, currentPayer, commissionWallet, new BigNumber(currentAmount).times(commissionAmount).toFixed(0));
+            // console.log('tx: ', tx);
+            const base64Tx = await getBase64Tx({
+                tx,
+                payer: currentPayer,
+                signers: [currentPayer],
+                blockhash,
+                connection,
+                simulate,
+            });
+            base64Txs.push(base64Tx);
+        }
+    }
+    else if (tradeType === 'sell') {
+        for (const payer of walletAmounts) {
+            const currentPayer = getWalletKeypair(payer.privateKey);
+            const currentAmount = new BigNumber(payer.amount).times(10 ** decimals).toFixed(0);
+            let receiveAmount;
+            if (Number(currentAmount) <= 0) {
+                continue;
+            }
+            try {
+                receiveAmount = raydiumCalc.swap(currentAmount, mintA.toBase58() === NATIVE_MINT.toBase58() ? false : true);
+            }
+            catch (err) {
+                console.log('err: ', err);
+                break;
+            }
+            const sellTx = await raydiumSellInstruction({
+                amount: currentAmount,
+                owner: currentPayer.publicKey,
+                poolKeys: raydiumV4Keys,
+                mintA: mintA.toBase58(),
+                mintB: mintB.toBase58(),
+                minAmountOut: new BigNumber(receiveAmount).times(1 - slippage).toFixed(0),
+            });
+            let tx = getTx(sellTx, currentPayer, priorityFee, jito);
+            addCommission(tx, currentPayer, commissionWallet, new BigNumber(receiveAmount).times(commissionAmount).toFixed(0));
+            const base64Tx = await getBase64Tx({
+                tx,
+                payer: currentPayer,
+                signers: [currentPayer],
+                blockhash,
+                connection,
+                simulate,
+            });
+            base64Txs.push(base64Tx);
+        }
+    }
+    else if (tradeType === 'buyWithSell') {
+        // 实现 Raydium 的多买多卖逻辑
+        for (const payer of walletAmounts) {
+            const currentPayer = getWalletKeypair(payer.privateKey);
+            const currentAmount = new BigNumber(payer.amount).times(10 ** 9).toFixed(0);
+            if (Number(currentAmount) <= 0) {
+                continue;
+            }
+            // 提前创建 wsolAccount
+            const { wsolAccount, createWsolAccount } = await getNewWsolAccount(currentPayer.publicKey, new BigNumber(currentAmount).times(1 + slippage).toFixed(0));
+            try {
+                // 创建组合交易
+                const tx = new Transaction();
+                let totalBuyReceiveAmount = new BigNumber(0);
+                // 根据 volumeType 确定买入和卖出次数
+                const { buyCount, sellCount } = getVolumeTypeConfig(volumeType);
+                // 执行多次买入
+                let remainingAmount = new BigNumber(currentAmount);
+                for (let i = 0; i < buyCount; i++) {
+                    let buyAmount;
+                    if (i === buyCount - 1) {
+                        // 最后一次买入时，使用所有剩余资金
+                        buyAmount = remainingAmount.toFixed(0);
+                    }
+                    else {
+                        // 前面几次按平均分配
+                        buyAmount = new BigNumber(currentAmount).div(buyCount).toFixed(0);
+                        remainingAmount = remainingAmount.minus(buyAmount);
+                    }
+                    let buyReceiveAmount = raydiumCalc.swap(buyAmount, mintA.toBase58() === NATIVE_MINT.toBase58() ? true : false);
+                    totalBuyReceiveAmount = totalBuyReceiveAmount.plus(buyReceiveAmount);
+                    // 添加买入指令
+                    const buyTx = await raydiumBuyInstruction({
+                        amount: buyAmount,
+                        owner: currentPayer.publicKey,
+                        poolKeys: raydiumV4Keys,
+                        mintA: mintA.toBase58(),
+                        mintB: mintB.toBase58(),
+                        minAmountOut: new BigNumber(buyReceiveAmount).times(1 - slippage).toFixed(0),
+                        needCreateAtaAccount: i === 0,
+                        needCloseTokenAccount: false,
+                        needCloseWsolAccount: false,
+                        initialWsolAccount: wsolAccount,
+                        createWsolAccountInstruction: createWsolAccount,
+                    });
+                    tx.add(buyTx);
+                }
+                // 执行多次卖出
+                let remainingTokenAmount = totalBuyReceiveAmount;
+                for (let i = 0; i < sellCount; i++) {
+                    let sellTokenAmount;
+                    if (i === sellCount - 1) {
+                        // 最后一次卖出时，卖出所有剩余代币
+                        sellTokenAmount = remainingTokenAmount.toFixed(0);
+                    }
+                    else {
+                        // 前面几次按平均分配
+                        sellTokenAmount = totalBuyReceiveAmount.div(sellCount).toFixed(0);
+                        remainingTokenAmount = remainingTokenAmount.minus(sellTokenAmount);
+                    }
+                    let sellReceiveAmount = raydiumCalc.swap(sellTokenAmount, mintA.toBase58() === NATIVE_MINT.toBase58() ? false : true);
+                    // 添加卖出指令
+                    const sellTx = await raydiumSellInstruction({
+                        amount: sellTokenAmount,
+                        owner: currentPayer.publicKey,
+                        poolKeys: raydiumV4Keys,
+                        mintA: mintA.toBase58(),
+                        mintB: mintB.toBase58(),
+                        minAmountOut: new BigNumber(sellReceiveAmount).times(1 - slippage).toFixed(0),
+                        needCreateAtaAccount: false,
+                        needCloseTokenAccount: i === sellCount - 1,
+                        needCloseWsolAccount: i === sellCount - 1,
+                        initialWsolAccount: wsolAccount,
+                    });
+                    tx.add(sellTx);
+                }
+                let finalTx = getTx(tx, currentPayer, priorityFee, jito);
+                addCommission(finalTx, currentPayer, commissionWallet, new BigNumber(currentAmount).times(commissionAmount).toFixed(0));
+                const base64Tx = await getBase64Tx({
+                    tx: finalTx,
+                    payer: currentPayer,
+                    signers: [currentPayer],
+                    blockhash,
+                    connection,
+                    simulate,
+                });
+                base64Txs.push(base64Tx);
+            }
+            catch (err) {
+                console.log('raydium buyWithSell err: ', err);
+                break;
+            }
+        }
+    }
+    return base64Txs;
+};
+export const raydiumCpmmBatchTrade = async ({ connection, tokenAddress, poolId, tradeType, slippage, priorityFee, priceInSol, commissionWallet, commissionAmount, walletAmounts, reverseInfo, decimals, raydiumCpmmKeys, poolInfo, volumeType = VolumeType.ONE_BUY_ONE_SELL, simulate = false, }) => {
+    let info = reverseInfo;
+    if (!info) {
+        const { poolBaseTokenInfo, poolQuoteTokenInfo } = await raydiumGetCpmmPoolInfo(connection, poolId);
+        info = {
+            mintA: poolInfo.tokenA,
+            mintB: poolInfo.tokenB,
+            poolBaseTokenInfo: {
+                amount: poolBaseTokenInfo.amount.toString(),
+            },
+            poolQuoteTokenInfo: {
+                amount: poolQuoteTokenInfo.amount.toString(),
+            },
+        };
+    }
+    const mintA = new PublicKey(info.mintA);
+    const mintB = new PublicKey(info.mintB);
+    const basereverse = info.poolBaseTokenInfo.amount.toString();
+    const quoteReserve = info.poolQuoteTokenInfo.amount.toString();
+    const raydiumCalc = new AmmCalc({
+        baseReserve: basereverse,
+        quoteReserve: quoteReserve,
+        baseDecimals: mintA.toBase58() === NATIVE_MINT.toBase58() ? 9 : decimals,
+        quoteDecimals: mintB.toBase58() === NATIVE_MINT.toBase58() ? 9 : decimals,
+    });
+    const base64Txs = [];
+    const jito = new JitoJsonRpcClient();
+    const blockhash = (await connection.getLatestBlockhash()).blockhash;
+    if (tradeType === 'buy' || tradeType === 'sniperBuy') {
+        for (const payer of walletAmounts) {
+            const currentPayer = getWalletKeypair(payer.privateKey);
+            const currentAmount = new BigNumber(payer.amount).times(10 ** 9).toFixed(0);
+            if (Number(currentAmount) <= 0) {
+                continue;
+            }
+            let receiveAmount;
+            try {
+                receiveAmount = raydiumCalc.swap(currentAmount, mintA.toBase58() === NATIVE_MINT.toBase58() ? true : false);
+            }
+            catch (err) {
+                console.log('err: ', err);
+                break;
+            }
+            const buyTx = await raydiumCpmmSwapBaseInBuyInstruction({
+                amountInMax: currentAmount,
+                owner: currentPayer.publicKey,
+                poolKeys: raydiumCpmmKeys,
+                poolId,
+                mintA: mintA.toBase58(),
+                mintB: mintB.toBase58(),
+                amountOutMin: new BigNumber(receiveAmount).times(1 - slippage).toFixed(0),
+                needCreateAtaAccount: true,
+                needCloseTokenAccount: true,
+            });
+            let tx = getTx(buyTx, currentPayer, priorityFee, jito);
+            addCommission(tx, currentPayer, commissionWallet, new BigNumber(currentAmount).times(commissionAmount).toFixed(0));
+            // console.log('tx: ', tx);
+            const base64Tx = await getBase64Tx({
+                tx,
+                payer: currentPayer,
+                signers: [currentPayer],
+                blockhash,
+                connection,
+                simulate,
+            });
+            base64Txs.push(base64Tx);
+        }
+    }
+    else if (tradeType === 'sell') {
+        for (const payer of walletAmounts) {
+            const currentPayer = getWalletKeypair(payer.privateKey);
+            const currentAmount = new BigNumber(payer.amount).times(10 ** decimals).toFixed(0);
+            let receiveAmount;
+            if (Number(currentAmount) <= 0) {
+                continue;
+            }
+            try {
+                receiveAmount = raydiumCalc.swap(currentAmount, mintA.toBase58() === NATIVE_MINT.toBase58() ? false : true);
+            }
+            catch (err) {
+                console.log('err: ', err);
+                break;
+            }
+            const sellTx = await raydiumCpmmSellInstruction({
+                amount: currentAmount,
+                owner: currentPayer.publicKey,
+                poolKeys: raydiumCpmmKeys,
+                poolId,
+                mintA: mintA.toBase58(),
+                mintB: mintB.toBase58(),
+                minAmountOut: new BigNumber(receiveAmount).times(1 - slippage).toFixed(0),
+                connection,
+                needCreateAtaAccount: true,
+                needCloseTokenAccount: false,
+                needCloseWsolAccount: true,
+            });
+            let tx = getTx(sellTx, currentPayer, priorityFee, jito);
+            addCommission(tx, currentPayer, commissionWallet, new BigNumber(receiveAmount).times(commissionAmount).toFixed(0));
+            const base64Tx = await getBase64Tx({
+                tx,
+                payer: currentPayer,
+                signers: [currentPayer],
+                blockhash,
+                connection,
+                simulate,
+            });
+            base64Txs.push(base64Tx);
+        }
+    }
+    else if (tradeType === 'buyWithSell') {
+        // 实现 Raydium 的多买多卖逻辑
+        for (const payer of walletAmounts) {
+            const currentPayer = getWalletKeypair(payer.privateKey);
+            const currentAmount = new BigNumber(payer.amount).times(10 ** 9).toFixed(0);
+            if (Number(currentAmount) <= 0) {
+                continue;
+            }
+            // 提前创建 wsolAccount
+            const { wsolAccount, createWsolAccount } = await getNewWsolAccount(currentPayer.publicKey, new BigNumber(currentAmount).times(1 + slippage).toFixed(0));
+            try {
+                // 创建组合交易
+                const tx = new Transaction();
+                let totalBuyReceiveAmount = new BigNumber(0);
+                // 根据 volumeType 确定买入和卖出次数
+                const { buyCount, sellCount } = getVolumeTypeConfig(volumeType);
+                // 执行多次买入
+                let remainingAmount = new BigNumber(currentAmount);
+                for (let i = 0; i < buyCount; i++) {
+                    let buyAmount;
+                    if (i === buyCount - 1) {
+                        // 最后一次买入时，使用所有剩余资金
+                        buyAmount = remainingAmount.toFixed(0);
+                    }
+                    else {
+                        // 前面几次按平均分配
+                        buyAmount = new BigNumber(currentAmount).div(buyCount).toFixed(0);
+                        remainingAmount = remainingAmount.minus(buyAmount);
+                    }
+                    let buyReceiveAmount = raydiumCalc.swap(buyAmount, mintA.toBase58() === NATIVE_MINT.toBase58() ? true : false);
+                    totalBuyReceiveAmount = totalBuyReceiveAmount.plus(buyReceiveAmount);
+                    // 添加买入指令
+                    const buyTx = await raydiumCpmmSwapBaseOutBuyInstruction({
+                        amountInMax: new BigNumber(buyAmount).times(1 + slippage).toFixed(0),
+                        owner: currentPayer.publicKey,
+                        poolKeys: raydiumCpmmKeys,
+                        poolId,
+                        mintA: mintA.toBase58(),
+                        mintB: mintB.toBase58(),
+                        amountOut: buyReceiveAmount,
+                        needCreateAtaAccount: i === 0,
+                        needCloseTokenAccount: false,
+                        initialWsolAccount: wsolAccount,
+                        createWsolAccountInstruction: createWsolAccount,
+                    });
+                    tx.add(buyTx);
+                }
+                // 执行多次卖出
+                let remainingTokenAmount = totalBuyReceiveAmount;
+                for (let i = 0; i < sellCount; i++) {
+                    let sellTokenAmount;
+                    if (i === sellCount - 1) {
+                        // 最后一次卖出时，卖出所有剩余代币
+                        sellTokenAmount = remainingTokenAmount.toFixed(0);
+                    }
+                    else {
+                        // 前面几次按平均分配
+                        sellTokenAmount = totalBuyReceiveAmount.div(sellCount).toFixed(0);
+                        remainingTokenAmount = remainingTokenAmount.minus(sellTokenAmount);
+                    }
+                    let sellReceiveAmount = raydiumCalc.swap(sellTokenAmount, mintA.toBase58() === NATIVE_MINT.toBase58() ? false : true);
+                    // 添加卖出指令
+                    const sellTx = await raydiumCpmmSellInstruction({
+                        amount: sellTokenAmount,
+                        owner: currentPayer.publicKey,
+                        poolKeys: raydiumCpmmKeys,
+                        poolId,
+                        mintA: mintA.toBase58(),
+                        mintB: mintB.toBase58(),
+                        minAmountOut: new BigNumber(sellReceiveAmount).times(1 - slippage).toFixed(0),
+                        connection,
+                        needCreateAtaAccount: false,
+                        needCloseTokenAccount: i === sellCount - 1,
+                        needCloseWsolAccount: i === sellCount - 1,
+                        initialWsolAccount: wsolAccount,
+                    });
+                    tx.add(sellTx);
+                }
+                let finalTx = getTx(tx, currentPayer, priorityFee, jito);
+                addCommission(finalTx, currentPayer, commissionWallet, commissionAmount);
+                const base64Tx = await getBase64Tx({
+                    tx: finalTx,
+                    payer: currentPayer,
+                    signers: [currentPayer],
+                    blockhash,
+                    connection,
+                    simulate,
+                });
+                base64Txs.push(base64Tx);
+            }
+            catch (err) {
+                console.log('raydium buyWithSell err: ', err);
+                break;
+            }
+        }
+    }
+    return base64Txs;
+};
+// 获取刷量类型配置
+const getVolumeTypeConfig = (volumeType) => {
+    switch (volumeType) {
+        case VolumeType.ONE_BUY_ONE_SELL:
+            return { buyCount: 1, sellCount: 1 };
+        case VolumeType.ONE_BUY_TWO_SELL:
+            return { buyCount: 1, sellCount: 2 };
+        case VolumeType.ONE_BUY_THREE_SELL:
+            return { buyCount: 1, sellCount: 3 };
+        case VolumeType.TWO_BUY_ONE_SELL:
+            return { buyCount: 2, sellCount: 1 };
+        case VolumeType.THREE_BUY_ONE_SELL:
+            return { buyCount: 3, sellCount: 1 };
+        default:
+            return { buyCount: 1, sellCount: 1 };
+    }
+};
+export const meteoraDlmmBatchTrade = async ({ connection, tokenAddress, poolId, tradeType, slippage, priorityFee, decimals, reverseInfo, commissionWallet, commissionAmount, creator, walletAmounts, bundleBuyTime, volumeType = VolumeType.ONE_BUY_ONE_SELL, simulate = false, }) => {
+    const provider = new AnchorProvider(connection, {
+        publicKey: Keypair.generate().publicKey,
+        signTransaction: async () => {
+            throw new Error('不支持签名');
+        },
+        signAllTransactions: async () => {
+            throw new Error('不支持签名');
+        },
+    }, {});
+    const binArray = await getBinArray({
+        connection,
+        poolId,
+    });
+    const dlmmPool = await MeteoraDLMM.create(connection, new PublicKey(poolId), {
+        programId: METEORA_DLMM_PROGRAM,
+    });
+    // 使用传入的reverseInfo或获取池子数据
+    if (!reverseInfo) {
+        throw new Error('缺少 Meteora DLMM 池子信息');
+    }
+    console.log('  binStep:', typeof reverseInfo.binStep, reverseInfo.binStep);
+    console.log('  activeId:', typeof reverseInfo.activeId, reverseInfo.activeId);
+    const payers = walletAmounts.map(item => getWalletKeypair(item.privateKey));
+    const jito = new JitoJsonRpcClient();
+    const blockhash = (await connection.getLatestBlockhash()).blockhash;
+    const base64Txs = [];
+    // 处理交易逻辑
+    if (tradeType === 'buy') {
+        // try {
+        for (const payer of walletAmounts) {
+            const currentPayer = getWalletKeypair(payer.privateKey);
+            const currentAmount = new BigNumber(payer.amount).times(LAMPORTS_PER_SOL).toFixed(0);
+            // 计算预期获得的代币数量
+            const swapQuote = dlmmPool.swapQuote(new BN(currentAmount), reverseInfo.reserveY == NATIVE_MINT.toBase58(), new BN(slippage), binArray);
+            const buyTx = await meteoraDlmmBuyInstructions({
+                provider,
+                owner: currentPayer,
+                mint: new PublicKey(tokenAddress),
+                poolInfo: {
+                    poolId: poolId,
+                    mintA: reverseInfo.mintA,
+                    mintB: reverseInfo.mintB,
+                    reverseX: reverseInfo.reserveX,
+                    reverseY: reverseInfo.reserveY,
+                    oracle: reverseInfo.oracle,
+                },
+                amount: BigInt(currentAmount),
+                tokenAmount: BigInt(swapQuote.minOutAmount.toString()),
+                slippage,
+                needCreateAtaAccount: true,
+                needCloseTokenAccount: false,
+                binArraysPubkey: swapQuote.binArraysPubkey,
+            });
+            const tx = getTx(buyTx, currentPayer, priorityFee, jito);
+            addCommission(tx, currentPayer, commissionWallet, new BigNumber(currentAmount).times(commissionAmount).toFixed(0));
+            const base64Tx = await getBase64Tx({
+                tx,
+                payer: currentPayer,
+                signers: [currentPayer],
+                blockhash,
+                connection,
+                simulate,
+            });
+            base64Txs.push(base64Tx);
+        }
+        return base64Txs;
+        // } catch (error: any) {
+        //   throw new Error(`构造买入交易指令失败: ${error.message}`);
+        // }
+    }
+    else if (tradeType === 'sell') {
+        try {
+            for (const payer of walletAmounts) {
+                const currentPayer = getWalletKeypair(payer.privateKey);
+                const currentAmount = new BigNumber(payer.amount).times(10 ** decimals).toFixed(0);
+                // 计算预期获得的SOL数量
+                const swapQuote = dlmmPool.swapQuote(new BN(currentAmount), reverseInfo.mintA == NATIVE_MINT.toBase58(), new BN(slippage), binArray);
+                const swapQuote2 = dlmmPool.swapQuote(new BN(currentAmount), reverseInfo.mintA == NATIVE_MINT.toBase58(), new BN(10), binArray);
+                const sellTx = await meteoraDlmmSellInstructions({
+                    provider,
+                    owner: currentPayer,
+                    mint: new PublicKey(tokenAddress),
+                    poolInfo: {
+                        poolId: poolId,
+                        mintA: reverseInfo.mintA,
+                        mintB: reverseInfo.mintB,
+                        reverseX: reverseInfo.reserveX,
+                        reverseY: reverseInfo.reserveY,
+                        oracle: reverseInfo.oracle,
+                    },
+                    amount: BigInt(currentAmount),
+                    minAmountOut: BigInt(new BigNumber(swapQuote.minOutAmount.toString()).toFixed(0)),
+                    needCreateAtaAccount: true,
+                    needCloseTokenAccount: true,
+                    binArraysPubkey: swapQuote.binArraysPubkey,
+                });
+                const tx = getTx(sellTx, currentPayer, priorityFee, jito);
+                addCommission(tx, currentPayer, commissionWallet, new BigNumber(swapQuote2.minOutAmount.toString()).times(commissionAmount).toFixed(0));
+                const base64Tx = await getBase64Tx({
+                    tx,
+                    payer: currentPayer,
+                    signers: [currentPayer],
+                    blockhash,
+                    connection,
+                    simulate: true,
+                });
+                base64Txs.push(base64Tx);
+            }
+            return base64Txs;
+        }
+        catch (error) {
+            throw new Error(`构造卖出交易指令失败: ${error.message}`);
+        }
+    }
+    else if (tradeType === 'buyWithSell') {
+        // 实现 Meteora DLMM 的多买多卖逻辑
+        try {
+            for (const payer of walletAmounts) {
+                const currentPayer = getWalletKeypair(payer.privateKey);
+                const currentAmount = new BigNumber(payer.amount).times(LAMPORTS_PER_SOL).toFixed(0);
+                // 提前创建 wsolAccount
+                const { wsolAccount, createWsolAccount } = await getNewWsolAccount(currentPayer.publicKey, new BigNumber(currentAmount).times(1 + slippage).toFixed(0));
+                // 创建组合交易
+                const tx = new Transaction();
+                let totalBuyReceiveAmount = new BN(0);
+                // 根据 volumeType 确定买入和卖出次数
+                const { buyCount, sellCount } = getVolumeTypeConfig(volumeType);
+                // 执行多次买入
+                let remainingAmount = new BigNumber(currentAmount);
+                for (let i = 0; i < buyCount; i++) {
+                    let buyAmount;
+                    if (i === buyCount - 1) {
+                        // 最后一次买入时，使用所有剩余资金
+                        buyAmount = remainingAmount.toFixed(0);
+                    }
+                    else {
+                        // 前面几次按平均分配
+                        buyAmount = new BigNumber(currentAmount).div(buyCount).toFixed(0);
+                        remainingAmount = remainingAmount.minus(buyAmount);
+                    }
+                    const swapQuote = dlmmPool.swapQuote(new BN(buyAmount), reverseInfo.reserveY == NATIVE_MINT.toBase58(), new BN(slippage), binArray);
+                    totalBuyReceiveAmount = totalBuyReceiveAmount.add(new BN(swapQuote.minOutAmount.toString()));
+                    // 添加买入指令
+                    const buyTx = await meteoraDlmmBuyExactOutInstructions({
+                        provider,
+                        owner: currentPayer,
+                        mint: new PublicKey(tokenAddress),
+                        poolInfo: {
+                            poolId: poolId,
+                            mintA: reverseInfo.mintA,
+                            mintB: reverseInfo.mintB,
+                            reverseX: reverseInfo.reserveX,
+                            reverseY: reverseInfo.reserveY,
+                            oracle: reverseInfo.oracle,
+                        },
+                        amountInMax: BigInt(buyAmount),
+                        tokenAmount: BigInt(swapQuote.minOutAmount.toString()),
+                        needCreateAtaAccount: i === 0, // 只在第一次创建ATA
+                        needCloseTokenAccount: false,
+                        needCloseWsolAccount: false,
+                        initialWsolAccount: wsolAccount,
+                        createWsolAccountInstruction: i === 0 ? createWsolAccount : undefined,
+                        binArraysPubkey: swapQuote.binArraysPubkey,
+                    });
+                    // 添加买入交易指令
+                    tx.add(...buyTx.instructions);
+                }
+                // 执行多次卖出
+                const avgSellAmount = totalBuyReceiveAmount.div(new BN(sellCount));
+                for (let i = 0; i < sellCount; i++) {
+                    let sellAmount;
+                    if (i === sellCount - 1) {
+                        // 最后一次卖出时，卖出所有剩余代币
+                        sellAmount = totalBuyReceiveAmount;
+                    }
+                    else {
+                        sellAmount = avgSellAmount;
+                        totalBuyReceiveAmount = totalBuyReceiveAmount.sub(avgSellAmount);
+                    }
+                    const swapQuote = dlmmPool.swapQuote(new BN(sellAmount), reverseInfo.mintA == NATIVE_MINT.toBase58(), new BN(10), binArray);
+                    // 添加卖出指令
+                    const sellTx = await meteoraDlmmSellInstructions({
+                        provider,
+                        owner: currentPayer,
+                        mint: new PublicKey(tokenAddress),
+                        poolInfo: {
+                            poolId: poolId,
+                            mintA: reverseInfo.mintA,
+                            mintB: reverseInfo.mintB,
+                            reverseX: reverseInfo.reserveX,
+                            reverseY: reverseInfo.reserveY,
+                            oracle: reverseInfo.oracle,
+                        },
+                        amount: BigInt(sellAmount.toString()),
+                        minAmountOut: BigInt(0),
+                        needCreateAtaAccount: false,
+                        needCloseTokenAccount: i === sellCount - 1, // 只在最后一次关闭Token账户
+                        needCloseWsolAccount: i === sellCount - 1, // 只在最后一次关闭WSOL账户
+                        initialWsolAccount: wsolAccount,
+                        binArraysPubkey: swapQuote.binArraysPubkey,
+                    });
+                    // 添加卖出交易指令
+                    tx.add(...sellTx.instructions);
+                }
+                const finalTx = getTx(tx, currentPayer, priorityFee, jito);
+                addCommission(finalTx, currentPayer, commissionWallet, new BigNumber(currentAmount).times(commissionAmount).toFixed(0));
+                const base64Tx = await getBase64Tx({
+                    tx: finalTx,
+                    payer: currentPayer,
+                    signers: [currentPayer],
+                    blockhash,
+                    connection,
+                    simulate,
+                });
+                base64Txs.push(base64Tx);
+            }
+            return base64Txs;
+        }
+        catch (error) {
+            throw new Error(`构造买卖组合交易指令失败: ${error.message}`);
+        }
+    }
+    throw new Error(`不支持的交易类型: ${tradeType}`);
+};
+const getBase64Tx = async ({ tx, payer, signers, blockhash, connection, lutAccount, simulate = false, }) => {
+    console.log('tx.instructions: ', tx.instructions);
+    const messageV0 = new TransactionMessage({
+        payerKey: signers[0].publicKey,
+        recentBlockhash: blockhash,
+        instructions: tx.instructions,
+    }).compileToV0Message(lutAccount ? [lutAccount] : []);
+    const versionedTx = new VersionedTransaction(messageV0);
+    versionedTx.sign(signers);
+    if (simulate) {
+        try {
+            const log = await connection.simulateTransaction(versionedTx);
+            console.log('simulate log: ', log);
+            if (log.value.logs?.includes('insufficient')) {
+                throw new Error('Insufficient funds');
+            }
+            if (log.value.err) {
+                throw new Error(log.value.err.toString());
+            }
+        }
+        catch (err) {
+            console.log('simulate err: ', err);
+            throw err;
+        }
+    }
+    const serializedTx = versionedTx.serialize();
+    const base64Tx = Buffer.from(serializedTx).toString('base64');
+    return base64Tx;
+};
+const getTx = (tx, payer, priorityFee, jito, cuLimit) => {
+    const transaction = new Transaction();
+    transaction.add(tx);
+    const cu = getCU(priorityFee, cuLimit);
+    transaction.add(cu.limitIx);
+    transaction.add(cu.priceIx);
+    if (jito) {
+        transaction.add(jito.getTipInstruction(payer.publicKey, priorityFee));
+    }
+    return transaction;
+};
+//# sourceMappingURL=index.js.map