pinpet-sdk 2.1.13 → 2.1.15

package/dist/pinpet-sdk.js

@@ -30595,7 +30595,7 @@
 	 * Implements constant product (xy=k) algorithm for automated market maker functionality
 	 * Usage when importing: const CurveAMM = require("../tools/curve_amm");
 	 */
-	class CurveAMM$7 {
+	class CurveAMM$8 {
 	    /**
 	     * Initial SOL reserve amount, represented as Decimal
 	     * @type {Decimal}
@@ -31748,10 +31748,10 @@
 	    }
 	}
 
-	var curve_amm = CurveAMM$7;
+	var curve_amm = CurveAMM$8;
 
 	const axios = axios_1;
-	const CurveAMM$6 = curve_amm;
+	const CurveAMM$7 = curve_amm;
 
 	/**
 	 * Fast API Module
@@ -32243,7 +32243,7 @@
 
 	    if (!latestPrice) {
 	      // If no price data, calculate initial price
-	      const initialPrice = CurveAMM$6.getInitialPrice();
+	      const initialPrice = CurveAMM$7.getInitialPrice();
 	      if (initialPrice === null) {
 	        throw new Error('price: 无法计算初始价格 Unable to calculate initial price');
 	      }
@@ -33708,7 +33708,7 @@
 
 	var jsonBigintExports = jsonBigint.exports;
 
-	const CurveAMM$5 = curve_amm;
+	const CurveAMM$6 = curve_amm;
 	const {transformOrdersData , checkPriceRangeOverlap} = stop_loss_utils;
 	const { PRICE_ADJUSTMENT_PERCENTAGE, MIN_STOP_LOSS_PERCENT } = utils$2;
 	jsonBigintExports({ storeAsString: false });
@@ -33866,12 +33866,12 @@
 	        let currentPrice;
 	        if (lastPrice === null || lastPrice === undefined || lastPrice === '0') {
 	            console.log('Current price is empty, using initial price');
-	            currentPrice = CurveAMM$5.getInitialPrice();
+	            currentPrice = CurveAMM$6.getInitialPrice();
 	        } else {
 	            currentPrice = BigInt(lastPrice);
 	            if (!currentPrice || currentPrice === 0n) {
 	                console.log('Current price is 0, using initial price');
-	                currentPrice = CurveAMM$5.getInitialPrice();
+	                currentPrice = CurveAMM$6.getInitialPrice();
 	            }
 	        }
 
@@ -33916,7 +33916,7 @@
 	            // console.log(`  - buyTokenAmount: ${buyTokenAmount.toString()}`);
 	            // console.log(`  - Calling CurveAMM.sellFromPriceWithTokenInput...`);
 
-	            const tradeResult = CurveAMM$5.sellFromPriceWithTokenInput(stopLossStartPrice, buyTokenAmount);
+	            const tradeResult = CurveAMM$6.sellFromPriceWithTokenInput(stopLossStartPrice, buyTokenAmount);
 
 	            //console.log(`  - tradeResult:`, tradeResult);
 
@@ -33980,12 +33980,12 @@
 	        let estimatedMargin = 0n;
 	        try {
 	            // 1. 计算从当前价格买入所需的SOL
-	            const buyResult = CurveAMM$5.buyFromPriceWithTokenOutput(currentPrice, buyTokenAmount);
+	            const buyResult = CurveAMM$6.buyFromPriceWithTokenOutput(currentPrice, buyTokenAmount);
 	            if (buyResult) {
 	                const requiredSol = buyResult[1]; // SOL input amount
 	                
 	                // 2. 计算平仓时扣除手续费后的收益
-	                const closeOutputSolAfterFee = CurveAMM$5.calculateAmountAfterFee(finalTradeAmount, borrowFee);
+	                const closeOutputSolAfterFee = CurveAMM$6.calculateAmountAfterFee(finalTradeAmount, borrowFee);
 	                
 	                // 3. 计算保证金 = 买入成本 - 平仓收益(扣费后)
 	                if (closeOutputSolAfterFee !== null && requiredSol > closeOutputSolAfterFee) {
@@ -34175,12 +34175,12 @@
 	        let currentPrice;
 	        if (lastPrice === null || lastPrice === undefined || lastPrice === '0') {
 	            console.log('Current price is empty, using initial price');
-	            currentPrice = CurveAMM$5.getInitialPrice();
+	            currentPrice = CurveAMM$6.getInitialPrice();
 	        } else {
 	            currentPrice = BigInt(lastPrice);
 	            if (!currentPrice || currentPrice === 0n) {
 	                console.log('Current price is 0, using initial price');
-	                currentPrice = CurveAMM$5.getInitialPrice();
+	                currentPrice = CurveAMM$6.getInitialPrice();
 	            }
 	        }
 
@@ -34223,7 +34223,7 @@
 	            // console.log(`  - sellTokenAmount: ${sellTokenAmount.toString()}`);
 	            // console.log(`  - Calling CurveAMM.buyFromPriceWithTokenOutput...`);
 
-	            const tradeResult = CurveAMM$5.buyFromPriceWithTokenOutput(stopLossStartPrice, sellTokenAmount);
+	            const tradeResult = CurveAMM$6.buyFromPriceWithTokenOutput(stopLossStartPrice, sellTokenAmount);
 
 	            //console.log(`  - tradeResult:`, tradeResult);
 
@@ -34262,8 +34262,8 @@
 	            //console.log(`调整后起始价格: ${stopLossStartPrice} / Adjusted start price: ${stopLossStartPrice}`);
 
 	            // 安全检查：确保价格不会超过最大值 / Safety check: ensure price doesn't exceed maximum
-	            if (stopLossStartPrice >= CurveAMM$5.MAX_U128_PRICE) {
-	                throw new Error(`Stop loss price exceeded maximum after adjustment: ${stopLossStartPrice} >= ${CurveAMM$5.MAX_U128_PRICE}`);
+	            if (stopLossStartPrice >= CurveAMM$6.MAX_U128_PRICE) {
+	                throw new Error(`Stop loss price exceeded maximum after adjustment: ${stopLossStartPrice} >= ${CurveAMM$6.MAX_U128_PRICE}`);
 	            }
 	        }
 
@@ -34286,7 +34286,7 @@
 	        let estimatedMargin = 0n;
 	        try {
 	            // 1. 计算从当前价格卖出代币获得的SOL（开仓收益，不含手续费）
-	            const sellResult = CurveAMM$5.sellFromPriceWithTokenInput(currentPrice, sellTokenAmount);
+	            const sellResult = CurveAMM$6.sellFromPriceWithTokenInput(currentPrice, sellTokenAmount);
 	            if (sellResult) {
 	                const openingSolGain = sellResult[1]; // 卖出获得的SOL
 	                
@@ -34410,17 +34410,17 @@
 
 	        // Calculate current price
 	        if (lastPrice === null || lastPrice === undefined || lastPrice === '0') {
-	            currentPrice = CurveAMM$5.getInitialPrice();
+	            currentPrice = CurveAMM$6.getInitialPrice();
 	        } else {
 	            currentPrice = BigInt(lastPrice);
 	            if (!currentPrice || currentPrice === 0n) {
-	                currentPrice = CurveAMM$5.getInitialPrice();
+	                currentPrice = CurveAMM$6.getInitialPrice();
 	            }
 	        }
 
 	        // Calculate initial token amount from SOL amount using sellFromPriceWithSolOutput
 	        // This gives us how many tokens we can get when we later sell for buySolAmount SOL
-	        const initialResult = CurveAMM$5.sellFromPriceWithSolOutput(currentPrice, buySolAmount);
+	        const initialResult = CurveAMM$6.sellFromPriceWithSolOutput(currentPrice, buySolAmount);
 	        if (!initialResult) {
 	            throw new Error('Failed to calculate token amount from SOL amount');
 	        }
@@ -34577,17 +34577,17 @@
 
 	        // Calculate current price
 	        if (lastPrice === null || lastPrice === undefined || lastPrice === '0') {
-	            currentPrice = CurveAMM$5.getInitialPrice();
+	            currentPrice = CurveAMM$6.getInitialPrice();
 	        } else {
 	            currentPrice = BigInt(lastPrice);
 	            if (!currentPrice || currentPrice === 0n) {
-	                currentPrice = CurveAMM$5.getInitialPrice();
+	                currentPrice = CurveAMM$6.getInitialPrice();
 	            }
 	        }
 
 	        // Calculate initial token amount from SOL amount using buyFromPriceWithSolInput
 	        // This gives us how many tokens we need to buy later using sellSolAmount SOL
-	        const initialResult = CurveAMM$5.buyFromPriceWithSolInput(currentPrice, sellSolAmount);
+	        const initialResult = CurveAMM$6.buyFromPriceWithSolInput(currentPrice, sellSolAmount);
 	        if (!initialResult) {
 	            throw new Error('Failed to calculate token amount from SOL amount');
 	        }
@@ -34679,7 +34679,7 @@
 	    simulateShortSolStopLoss: simulateShortSolStopLoss$1
 	};
 
-	const CurveAMM$4 = curve_amm;
+	const CurveAMM$5 = curve_amm;
 
 
 	/**
@@ -34798,7 +34798,7 @@
 	    const priceBigInt = BigInt(price);
 	    const initialVirtualSolBigInt = BigInt(initialVirtualSol.toString());
 	    const initialVirtualTokenBigInt = BigInt(initialVirtualToken.toString());
-	    [, result.ideal_lp_sol_amount] = CurveAMM$4.buyFromPriceWithTokenOutputWithParams(
+	    [, result.ideal_lp_sol_amount] = CurveAMM$5.buyFromPriceWithTokenOutputWithParams(
 	      priceBigInt,
 	      buyTokenAmountBigInt,
 	      initialVirtualSolBigInt,
@@ -34812,7 +34812,7 @@
 
 	  // orders 长度为0 时要单独计算
 	  if (orders.length === 0) {
-	    [result.free_lp_sol_amount_sum, result.free_lp_token_amount_sum] = CurveAMM$4.buyFromPriceToPrice(BigInt(price), CurveAMM$4.MAX_U128_PRICE);
+	    [result.free_lp_sol_amount_sum, result.free_lp_token_amount_sum] = CurveAMM$5.buyFromPriceToPrice(BigInt(price), CurveAMM$5.MAX_U128_PRICE);
 	    result.has_infinite_lp = true;
 	    result.real_lp_sol_amount = result.ideal_lp_sol_amount;
 	    return result
@@ -34860,7 +34860,7 @@
 	    // 如果存在价格间隙，计算自由流动性
 	    if (endPrice > startPrice) {
 	      try {
-	        const gapLiquidity = CurveAMM$4.buyFromPriceToPrice(startPrice, endPrice);
+	        const gapLiquidity = CurveAMM$5.buyFromPriceToPrice(startPrice, endPrice);
 	        if (gapLiquidity && Array.isArray(gapLiquidity) && gapLiquidity.length === 2) {
 	          const [solAmount, tokenAmount] = gapLiquidity;
 
@@ -34882,7 +34882,7 @@
 	              try {
 	                const actualBuyAmount = buyTokenAmountBigInt - (result.free_lp_token_amount_sum - BigInt(tokenAmount));
 	                // console.log("actualBuyAmount",actualBuyAmount)
-	                const [, preciseSol] = CurveAMM$4.buyFromPriceWithTokenOutput(startPrice, actualBuyAmount);
+	                const [, preciseSol] = CurveAMM$5.buyFromPriceWithTokenOutput(startPrice, actualBuyAmount);
 	                result.real_lp_sol_amount = prev_free_lp_sol_amount_sum + BigInt(preciseSol);
 
 	                // console.log(`实际计算[${i}]: 自由流动性已足够, actualBuyAmount=${actualBuyAmount}, preciseSol=${preciseSol}, 实际SOL=${result.real_lp_sol_amount}`);
@@ -34936,7 +34936,7 @@
 	              // 从当前价格开始计算需要多少SOL来买到精确的token数量
 	              const targetPrice = i === 0 ? BigInt(price) : BigInt(orders[i - 1].lock_lp_end_price);
 	              const actualBuyAmount = buyTokenAmountBigInt - (result.free_lp_token_amount_sum - BigInt(order.lock_lp_token_amount));
-	              const [, preciseSol] = CurveAMM$4.buyFromPriceWithTokenOutput(targetPrice, actualBuyAmount);
+	              const [, preciseSol] = CurveAMM$5.buyFromPriceWithTokenOutput(targetPrice, actualBuyAmount);
 	              result.real_lp_sol_amount = prevFreeSolSum + BigInt(preciseSol);
 	              // console.log(`实际计算[${i}]: 跳过订单后足够, targetPrice=${targetPrice}, preciseSol=${preciseSol}, 实际SOL=${result.real_lp_sol_amount}`);
 	              result.force_close_num = counti;
@@ -34990,7 +34990,7 @@
 	    let lastEndPrice, maxPrice;
 	    try {
 	      lastEndPrice = BigInt(lastOrder.lock_lp_end_price);
-	      maxPrice = CurveAMM$4.MAX_U128_PRICE;
+	      maxPrice = CurveAMM$5.MAX_U128_PRICE;
 	    } catch (error) {
 	      throw new Error(`价格转换错误：无法转换最后订单价格或最大价格 Price conversion error: Cannot convert last order price or max price - ${error.message}`);
 	    }
@@ -34998,7 +34998,7 @@
 
 	    if (maxPrice > lastEndPrice) {
 	      try {
-	        const infiniteLiquidity = CurveAMM$4.buyFromPriceToPrice(lastEndPrice, maxPrice);
+	        const infiniteLiquidity = CurveAMM$5.buyFromPriceToPrice(lastEndPrice, maxPrice);
 	        if (infiniteLiquidity && Array.isArray(infiniteLiquidity) && infiniteLiquidity.length === 2) {
 	          const [solAmount, tokenAmount] = infiniteLiquidity;
 
@@ -35017,7 +35017,7 @@
 	              // 计算最后精确需要买多少token
 	              try {
 	                const actualBuyAmount = buyTokenAmountBigInt - (result.free_lp_token_amount_sum - BigInt(tokenAmount));
-	                const [, preciseSol] = CurveAMM$4.buyFromPriceWithTokenOutput(lastEndPrice, actualBuyAmount);
+	                const [, preciseSol] = CurveAMM$5.buyFromPriceWithTokenOutput(lastEndPrice, actualBuyAmount);
 	                result.real_lp_sol_amount += BigInt(preciseSol);
 	                result.force_close_num = counti; // 强平订单数量
 	              } catch (error) {
@@ -35157,7 +35157,7 @@
 	    const priceBigInt = BigInt(price);
 	    const initialVirtualSolBigInt = BigInt(initialVirtualSol.toString());
 	    const initialVirtualTokenBigInt = BigInt(initialVirtualToken.toString());
-	    [, result.ideal_lp_sol_amount] = CurveAMM$4.sellFromPriceWithTokenInputWithParams(
+	    [, result.ideal_lp_sol_amount] = CurveAMM$5.sellFromPriceWithTokenInputWithParams(
 	      priceBigInt,
 	      sellTokenAmountBigInt,
 	      initialVirtualSolBigInt,
@@ -35172,9 +35172,9 @@
 	  if (orders.length === 0) {
 	    const initialVirtualSolBigInt = BigInt(initialVirtualSol.toString());
 	    const initialVirtualTokenBigInt = BigInt(initialVirtualToken.toString());
-	    const sellResult = CurveAMM$4.sellFromPriceToPriceWithParams(
+	    const sellResult = CurveAMM$5.sellFromPriceToPriceWithParams(
 	      BigInt(price),
-	      CurveAMM$4.MIN_U128_PRICE,
+	      CurveAMM$5.MIN_U128_PRICE,
 	      initialVirtualSolBigInt,
 	      initialVirtualTokenBigInt
 	    );
@@ -35233,7 +35233,7 @@
 	    // 如果存在价格间隙（卖出时startPrice应该大于endPrice）
 	    if (startPrice > endPrice) {
 	      try {
-	        const gapLiquidity = CurveAMM$4.sellFromPriceToPrice(startPrice, endPrice);
+	        const gapLiquidity = CurveAMM$5.sellFromPriceToPrice(startPrice, endPrice);
 	        if (gapLiquidity && Array.isArray(gapLiquidity) && gapLiquidity.length === 2) {
 	          const [tokenAmount, solAmount] = gapLiquidity;
 
@@ -35253,7 +35253,7 @@
 	              // 计算精确能获得多少SOL
 	              try {
 	                const actualSellAmount = sellTokenAmountBigInt - (result.free_lp_token_amount_sum - BigInt(tokenAmount));
-	                const [, preciseSol] = CurveAMM$4.sellFromPriceWithTokenInput(startPrice, actualSellAmount);
+	                const [, preciseSol] = CurveAMM$5.sellFromPriceWithTokenInput(startPrice, actualSellAmount);
 	                result.real_lp_sol_amount = prev_free_lp_sol_amount_sum + preciseSol;
 	                // console.log(`卖出实际计算[${i}]: 自由流动性已足够, actualSellAmount=${actualSellAmount}, preciseSol=${preciseSol}, 实际SOL=${result.real_lp_sol_amount}`);
 	                result.force_close_num = counti; // 强平订单数量
@@ -35302,7 +35302,7 @@
 	              // 计算精确能获得多少SOL
 	              const targetPrice = i === 0 ? BigInt(price) : BigInt(orders[i - 1].lock_lp_end_price);
 	              const actualSellAmount = sellTokenAmountBigInt - (result.free_lp_token_amount_sum - BigInt(order.lock_lp_token_amount));
-	              const [, preciseSol] = CurveAMM$4.sellFromPriceWithTokenInput(targetPrice, actualSellAmount);
+	              const [, preciseSol] = CurveAMM$5.sellFromPriceWithTokenInput(targetPrice, actualSellAmount);
 	              result.real_lp_sol_amount = prevFreeSolSum + preciseSol;
 	              result.force_close_num = counti;
 	            } catch (error) {
@@ -35352,7 +35352,7 @@
 	    let lastEndPrice, minPrice;
 	    try {
 	      lastEndPrice = BigInt(lastOrder.lock_lp_end_price);
-	      minPrice = CurveAMM$4.MIN_U128_PRICE;
+	      minPrice = CurveAMM$5.MIN_U128_PRICE;
 	    } catch (error) {
 	      throw new Error(`价格转换错误：无法转换最后订单价格或最小价格 Price conversion error: Cannot convert last order price or min price - ${error.message}`);
 	    }
@@ -35361,7 +35361,7 @@
 	    if (lastEndPrice > minPrice) {
 
 	      try {
-	        const infiniteLiquidity = CurveAMM$4.sellFromPriceToPrice(lastEndPrice, minPrice);
+	        const infiniteLiquidity = CurveAMM$5.sellFromPriceToPrice(lastEndPrice, minPrice);
 	        if (infiniteLiquidity && Array.isArray(infiniteLiquidity) && infiniteLiquidity.length === 2) {
 	          const [tokenAmount, solAmount] = infiniteLiquidity;
 
@@ -35381,7 +35381,7 @@
 	              // 无限流动性够卖出需求了
 	              try {
 	                const actualSellAmount = sellTokenAmountBigInt - (result.free_lp_token_amount_sum - BigInt(tokenAmount));
-	                const [, preciseSol] = CurveAMM$4.sellFromPriceWithTokenInput(lastEndPrice, actualSellAmount);
+	                const [, preciseSol] = CurveAMM$5.sellFromPriceWithTokenInput(lastEndPrice, actualSellAmount);
 	                result.real_lp_sol_amount = prevFreeSolSum + preciseSol;
 	                result.force_close_num = counti; // 强平订单数量
 	              } catch (error) {
@@ -35439,7 +35439,7 @@
 	async function simulateTokenBuy$1(mint, buyTokenAmount, passOrder = null, lastPrice = null, ordersData = null) {
 	  // 获取价格和订单数据
 
-	  //console.log('simulateTokenBuy', mint, buyTokenAmount, passOrder, lastPrice, ordersData);
+	  console.log('simulateTokenBuy', mint, buyTokenAmount, passOrder, lastPrice, ordersData);
 
 	  let price = lastPrice;
 	  if (!price) {
@@ -35484,17 +35484,20 @@
 	      curveData.initialVirtualToken
 	    );
 
-	    // console.log('\n=== calcLiqTokenBuy 返回结果 ===');
-	    // console.log('自由流动性 SOL 总量:', liqResult.free_lp_sol_amount_sum.toString());
-	    // console.log('自由流动性 Token 总量:', liqResult.free_lp_token_amount_sum.toString());
-	    // console.log('锁定流动性 SOL 总量:', liqResult.lock_lp_sol_amount_sum.toString());
-	    // console.log('锁定流动性 Token 总量:', liqResult.lock_lp_token_amount_sum.toString());
-	    // console.log('是否包含无限流动性:', liqResult.has_infinite_lp);
-	    // console.log('跳过的订单索引:', liqResult.pass_order_id);
-	    // console.log('需要强平的订单数量:', liqResult.force_close_num);
-	    // console.log('理想 SOL 使用量:', liqResult.ideal_lp_sol_amount.toString());
-	    // console.log('实际 SOL 使用量:', liqResult.real_lp_sol_amount.toString());
-	    // console.log('===============================\n');
+	    console.log("liqResult:",liqResult);
+
+
+	    console.log('\n=== calcLiqTokenBuy 返回结果 ===');
+	    console.log('自由流动性 SOL 总量:', liqResult.free_lp_sol_amount_sum.toString());
+	    console.log('自由流动性 Token 总量:', liqResult.free_lp_token_amount_sum.toString());
+	    console.log('锁定流动性 SOL 总量:', liqResult.lock_lp_sol_amount_sum.toString());
+	    console.log('锁定流动性 Token 总量:', liqResult.lock_lp_token_amount_sum.toString());
+	    console.log('是否包含无限流动性:', liqResult.has_infinite_lp);
+	    console.log('跳过的订单索引:', liqResult.pass_order_id);
+	    console.log('需要强平的订单数量:', liqResult.force_close_num);
+	    console.log('理想 SOL 使用量:', liqResult.ideal_lp_sol_amount.toString());
+	    console.log('实际 SOL 使用量:', liqResult.real_lp_sol_amount.toString());
+	    console.log('===============================\n');
 
 	    // Convert to BigInt for calculations
 	    const buyTokenAmountBig = BigInt(buyTokenAmount);
@@ -35950,11 +35953,268 @@
 	  simulateShortClose: simulateShortClose$1
 	};
 
+	const CurveAMM$4 = curve_amm;
+
+	/**
+	 * 计算使用指定SOL数量买入时能获得的Token数量
+	 * @param {bigint|string} price - 当前交易价格 (u128格式)
+	 * @param {bigint|string|number} buySolAmount - 需要花费的SOL数量 (lamports, 9位精度)
+	 * @param {Array} orders - 锁定流动性的订单数组
+	 * @param {number} onceMaxOrder - 单次循环最大订单数
+	 * @param {string|number|null} passOrderID - 需要跳过的订单ID（与order_id字段比较）
+	 * @param {string|number|Decimal|null} initialVirtualSol - 流动池SOL数量
+	 * @param {string|number|Decimal|null} initialVirtualToken - 流动池Token数量
+	 * @returns {Object} { tokenAmount: bigint, msg: string, closedOrdersCount: number }
+	 */
+	function calcLiqSolBuy$1(price, buySolAmount, orders, onceMaxOrder, passOrderID = null, initialVirtualSol = null, initialVirtualToken = null){
+
+	    // 1. 参数验证
+	    // 转换为 bigint 以便比较
+	    let priceBigInt;
+	    let buySolAmountBigInt;
+
+	    try {
+	        priceBigInt = typeof price === 'bigint' ? price : BigInt(price);
+	        buySolAmountBigInt = typeof buySolAmount === 'bigint' ? buySolAmount : BigInt(buySolAmount);
+	    } catch (error) {
+	        return {
+	            tokenAmount: 0n,
+	            msg: '参数格式错误：无法转换为bigint',
+	            closedOrdersCount: 0
+	        };
+	    }
+
+	    // 检查价格和金额是否有效
+	    if (priceBigInt <= 0n) {
+	        return {
+	            tokenAmount: 0n,
+	            msg: '计算失败：价格必须大于0',
+	            closedOrdersCount: 0
+	        };
+	    }
+
+	    if (buySolAmountBigInt <= 0n) {
+	        return {
+	            tokenAmount: 0n,
+	            msg: '计算失败：买入金额必须大于0',
+	            closedOrdersCount: 0
+	        };
+	    }
+
+	    // 2. 设置默认流动池参数
+	    const virtualSol = initialVirtualSol !== null ? initialVirtualSol : CurveAMM$4.INITIAL_SOL_RESERVE_DECIMAL;
+	    const virtualToken = initialVirtualToken !== null ? initialVirtualToken : CurveAMM$4.INITIAL_TOKEN_RESERVE_DECIMAL;
+
+	    // 3. 处理空订单情况（第一阶段）
+	    if (!orders || orders.length === 0) {
+	        // 直接计算完整流动性下的买入
+	        const result = CurveAMM$4.buyFromPriceWithSolInputWithParams(
+	            price,
+	            buySolAmount,
+	            virtualSol,
+	            virtualToken
+	        );
+
+	        if (result === null) {
+	            return {
+	                tokenAmount: 0n,
+	                msg: '计算失败：价格或参数无效',
+	                closedOrdersCount: 0
+	            };
+	        }
+
+	        const [endPrice, tokenAmount] = result;
+	        return {
+	            tokenAmount: tokenAmount,
+	            msg: '流动性完整，无锁定订单',
+	            closedOrdersCount: 0
+	        };
+	    }
+
+	    // 4. 处理有订单的情况（第二阶段：分段流动性计算）
+
+	    // 初始化变量
+	    let currentPrice = priceBigInt;           // 当前价格指针
+	    let remainingSol = buySolAmountBigInt;    // 剩余可用 SOL
+	    let totalTokenAmount = 0n;                // 累计获得的 token
+	    let closedOrdersCount = 0;                // 平仓订单数量
+	    let processedOrders = 0;                  // 已处理订单数
+
+	    // 检查当前价格是否高于第一个订单的结束价格
+	    if (orders.length > 0) {
+	        const firstOrderEndPrice = typeof orders[0].lock_lp_end_price === 'bigint'
+	            ? orders[0].lock_lp_end_price
+	            : BigInt(orders[0].lock_lp_end_price);
+
+	        if (currentPrice >= firstOrderEndPrice) {
+	            return {
+	                tokenAmount: 0n,
+	                msg: '错误：当前价格已高于第一个订单的结束价格',
+	                closedOrdersCount: 0
+	            };
+	        }
+	    }
+
+	    // 遍历订单（最多 onceMaxOrder 个）
+	    for (let i = 0; i < orders.length && processedOrders < onceMaxOrder; i++) {
+	        const order = orders[i];
+
+	        // 检查是否需要跳过此订单
+	        if (passOrderID !== null && order.order_id !== undefined) {
+	            // 将两者都转换为字符串进行比较
+	            const orderIdStr = String(order.order_id);
+	            const passOrderIdStr = String(passOrderID);
+
+	            if (orderIdStr === passOrderIdStr) {
+	                // 跳过此订单，不处理其锁定区间，继续下一个订单
+	                continue;
+	            }
+	        }
+
+	        // 转换订单价格为 bigint
+	        let lockStartPrice, lockEndPrice;
+	        try {
+	            lockStartPrice = typeof order.lock_lp_start_price === 'bigint'
+	                ? order.lock_lp_start_price
+	                : BigInt(order.lock_lp_start_price);
+	            lockEndPrice = typeof order.lock_lp_end_price === 'bigint'
+	                ? order.lock_lp_end_price
+	                : BigInt(order.lock_lp_end_price);
+	        } catch (error) {
+	            return {
+	                tokenAmount: 0n,
+	                msg: `错误：订单${i}的价格格式无效`,
+	                closedOrdersCount: closedOrdersCount
+	            };
+	        }
+
+	        // 步骤1：计算可用区间（currentPrice → lockStartPrice）
+	        if (currentPrice < lockStartPrice) {
+	            // 1.1 计算这段区间需要多少 SOL 和能获得多少 token
+	            const result = CurveAMM$4.buyFromPriceToPriceWithParams(
+	                currentPrice,
+	                lockStartPrice,
+	                virtualSol,
+	                virtualToken
+	            );
+
+	            // 检查计算是否成功
+	            if (result === null) {
+	                return {
+	                    tokenAmount: 0n,
+	                    msg: `错误：计算价格区间失败（订单${i}）`,
+	                    closedOrdersCount: closedOrdersCount
+	                };
+	            }
+
+	            const [solNeeded, tokenGained] = result;
+
+	            // 1.2 判断剩余 SOL 是否足够
+	            if (remainingSol >= solNeeded) {
+	                // 足够：买完这段区间，继续下一段
+	                remainingSol -= solNeeded;
+	                totalTokenAmount += tokenGained;
+	                currentPrice = lockStartPrice;
+	            } else {
+	                // 不够：用完剩余 SOL，计算能买多少，然后返回
+	                const finalResult = CurveAMM$4.buyFromPriceWithSolInputWithParams(
+	                    currentPrice,
+	                    remainingSol,
+	                    virtualSol,
+	                    virtualToken
+	                );
+
+	                if (finalResult === null) {
+	                    return {
+	                        tokenAmount: 0n,
+	                        msg: '错误：计算最终买入失败',
+	                        closedOrdersCount: closedOrdersCount
+	                    };
+	                }
+
+	                const [finalPrice, finalTokenGained] = finalResult;
+	                totalTokenAmount += finalTokenGained;
+
+	                return {
+	                    tokenAmount: totalTokenAmount,
+	                    msg: `SOL用完，最终价格: ${finalPrice.toString()}`,
+	                    closedOrdersCount: closedOrdersCount
+	                };
+	            }
+	        }
+
+	        // 步骤2：跳过锁定区间（lockStartPrice → lockEndPrice）
+	        currentPrice = lockEndPrice;
+	        processedOrders++;
+
+	        // 步骤3：判断是否平仓
+	        // 如果价格到达 lockEndPrice，说明这个订单被平仓
+	        closedOrdersCount++;
+
+	        // 检查 SOL 是否已用完
+	        if (remainingSol === 0n) {
+	            return {
+	                tokenAmount: totalTokenAmount,
+	                msg: `SOL刚好用完，最终价格: ${currentPrice.toString()}`,
+	                closedOrdersCount: closedOrdersCount
+	            };
+	        }
+	    }
+
+	    // 步骤4：处理最后的无限流动性区间
+	    // 所有订单处理完后，用剩余 SOL 继续买入
+	    if (remainingSol > 0n) {
+	        const finalResult = CurveAMM$4.buyFromPriceWithSolInputWithParams(
+	            currentPrice,
+	            remainingSol,
+	            virtualSol,
+	            virtualToken
+	        );
+
+	        if (finalResult === null) {
+	            return {
+	                tokenAmount: 0n,
+	                msg: '错误：计算无限流动性区间失败',
+	                closedOrdersCount: closedOrdersCount
+	            };
+	        }
+
+	        const [finalPrice, finalTokenGained] = finalResult;
+	        totalTokenAmount += finalTokenGained;
+
+	        return {
+	            tokenAmount: totalTokenAmount,
+	            msg: `买入完成，最终价格: ${finalPrice.toString()}`,
+	            closedOrdersCount: closedOrdersCount
+	        };
+	    }
+
+	    // 步骤5：SOL 刚好用完
+	    return {
+	        tokenAmount: totalTokenAmount,
+	        msg: `SOL刚好用完，最终价格: ${currentPrice.toString()}`,
+	        closedOrdersCount: closedOrdersCount
+	    };
+
+	}
+
+
+	function calcLiqSolSell$1(price, sellSolAmount, orders, onceMaxOrder, passOrder = null, initialVirtualSol = null, initialVirtualToken = null) {
+
+
+	}
+
+
+	var calc_sol_liq = {
+	  calcLiqSolBuy: calcLiqSolBuy$1,
+	  calcLiqSolSell: calcLiqSolSell$1
+	};
+
 	const CurveAMM$3 = curve_amm;
 	const { simulateLongStopLoss, simulateShortStopLoss, simulateLongSolStopLoss, simulateShortSolStopLoss } = long_shrot_stop;
 	const { simulateTokenBuy, simulateTokenSell } = buy_sell_token;
 	const { simulateLongClose, simulateShortClose } = close_indices;
-
+	const {calcLiqSolBuy,calcLiqSolSell } = calc_sol_liq;
 
 
 
@@ -36160,6 +36420,12 @@
 	            const priceResult = await this.sdk.data.price(mint);
 	            const ordersResult = await this.sdk.data.orders(mint, { type: 'down_orders' });
 
+	            console.log("ordersResult:",ordersResult);
+
+	            const upOrdersResult = await this.sdk.data.orders(mint, { type: 'up_orders' });
+	            console.log("upOrdersResult:",upOrdersResult);
+	            console.log("upOrdersResult:",upOrdersResult.data.orders);
+
 	            if (!priceResult || !ordersResult) {
 	                return {
 	                    success: false,
@@ -36179,6 +36445,15 @@
 	            const solInDecimal = Number(solAmountBigInt) / 1e9; // Convert lamports to SOL
 	            const estimatedTokenAmount = BigInt(Math.floor((solInDecimal / priceDecimal) * 1e9)); // Convert to token lamports (9-digit precision)
 
+	            // Get curve account data for initialVirtualSol and initialVirtualToken
+	            const curveAccount = await this.sdk.chain.getCurveAccount(mint);
+	            const initialVirtualSol = curveAccount.initialVirtualSol;
+	            const initialVirtualToken = curveAccount.initialVirtualToken;
+
+	            const reSolBuy = calcLiqSolBuy(currentPrice, buySolAmount, upOrdersResult.data.orders, 50, null, initialVirtualSol, initialVirtualToken);
+
+
+
 	            // Call simulateTokenBuy with estimated amount
 	            const tokenBuyResult = await this.simulateTokenBuy(mint, estimatedTokenAmount, null, priceResult, ordersResult);
 
@@ -38001,7 +38276,7 @@
 
 	var orderUtils = OrderUtils$2;
 
-	var address = "AGpTikur4Sxf9xutmJrwVmyKWYQEsqzoiiEm2mvr82cp";
+	var address = "F2FzigE1Z374iDvreiM6hZQe6oGXgomJfv8PyybvUXye";
 	var metadata = {
 		name: "pinpet",
 		version: "0.1.0",
@@ -40486,7 +40761,7 @@
 		{
 			code: 6003,
 			name: "SellCalculationOverflow",
-			msg: "Sell trade calculation overflow"
+			msg: "Sell trade calculation  overflow"
 		},
 		{
 			code: 6004,
@@ -41803,7 +42078,7 @@
 	    this.pinPetFastApiUrl = this.options.pinPetFastApiUrl;
 
 	    // Maximum number of orders that can be processed at once in the contract
-	    this.MAX_ORDERS_COUNT = 9;
+	    this.MAX_ORDERS_COUNT = 50;
 	    // Maximum number of orders to fetch during queries
 	    this.FIND_MAX_ORDERS_COUNT = 1000;
 
@@ -41967,13 +42242,13 @@
 	  LOCALNET: {
 	    name: 'localnet',
 	    defaultDataSource: 'fast', // 'fast' or 'chain'
-	    // solanaEndpoint: 'http://127.0.0.1:8899',
-	    // pinPetFastApiUrl: 'http://127.0.0.1:3000',
-	    solanaEndpoint: 'http://162.250.124.66:8899',
-	    pinPetFastApiUrl: 'http://162.250.124.66:3000',
+	    solanaEndpoint: 'http://127.0.0.1:8899',
+	    pinPetFastApiUrl: 'http://127.0.0.1:3000',
+	    // solanaEndpoint: 'http://162.250.124.66:8899',
+	    // pinPetFastApiUrl: 'http://162.250.124.66:3000',
 	    feeRecipient: 'GesAj2dTn2wdNcxj4x8qsqS9aNRVPBPkE76aaqg7skxu',
 	    baseFeeRecipient: '5YHi1HsxobLiTD6NQfHJQpoPoRjMuNyXp4RroTvR6dKi',
-	    paramsAccount: 'BvChe3C88ezFvcSutX5TsTUnUdToHAHqwfSQ85cmNq1A'
+	    paramsAccount: '8tn4XdqWAAh97WwfLrDrwnagRsQp7Nu5nrUmXVBJvgMU'
 	  }
 	};