pinpet-sdk 2.1.13 → 2.1.15

package/dist/pinpet-sdk.esm.js

@@ -30587,7 +30587,7 @@ const MAX_FEE_RATE = 10_000n;
  * 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}
@@ -31740,10 +31740,10 @@ class CurveAMM$7 {
     }
 }
 
-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
@@ -32235,7 +32235,7 @@ class FastModule$1 {
 
     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');
       }
@@ -33700,7 +33700,7 @@ jsonBigint.exports.stringify = json_stringify;
 
 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 });
@@ -33858,12 +33858,12 @@ async function simulateLongStopLoss$1(mint, buyTokenAmount, stopLossPrice, lastP
         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();
             }
         }
 
@@ -33908,7 +33908,7 @@ async function simulateLongStopLoss$1(mint, buyTokenAmount, stopLossPrice, lastP
             // 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);
 
@@ -33972,12 +33972,12 @@ async function simulateLongStopLoss$1(mint, buyTokenAmount, stopLossPrice, lastP
         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) {
@@ -34167,12 +34167,12 @@ async function simulateShortStopLoss$1(mint, sellTokenAmount, stopLossPrice, las
         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();
             }
         }
 
@@ -34215,7 +34215,7 @@ async function simulateShortStopLoss$1(mint, sellTokenAmount, stopLossPrice, las
             // 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);
 
@@ -34254,8 +34254,8 @@ async function simulateShortStopLoss$1(mint, sellTokenAmount, stopLossPrice, las
             //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}`);
             }
         }
 
@@ -34278,7 +34278,7 @@ async function simulateShortStopLoss$1(mint, sellTokenAmount, stopLossPrice, las
         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
                 
@@ -34402,17 +34402,17 @@ async function simulateLongSolStopLoss$1(mint, buySolAmount, stopLossPrice, last
 
         // 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');
         }
@@ -34569,17 +34569,17 @@ async function simulateShortSolStopLoss$1(mint, sellSolAmount, stopLossPrice, la
 
         // 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');
         }
@@ -34671,7 +34671,7 @@ var long_shrot_stop = {
     simulateShortSolStopLoss: simulateShortSolStopLoss$1
 };
 
-const CurveAMM$4 = curve_amm;
+const CurveAMM$5 = curve_amm;
 
 
 /**
@@ -34790,7 +34790,7 @@ function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrde
     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,
@@ -34804,7 +34804,7 @@ function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrde
 
   // 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
@@ -34852,7 +34852,7 @@ function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrde
     // 如果存在价格间隙，计算自由流动性
     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;
 
@@ -34874,7 +34874,7 @@ function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrde
               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}`);
@@ -34928,7 +34928,7 @@ function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrde
               // 从当前价格开始计算需要多少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;
@@ -34982,7 +34982,7 @@ function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrde
     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}`);
     }
@@ -34990,7 +34990,7 @@ function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrde
 
     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;
 
@@ -35009,7 +35009,7 @@ function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrde
               // 计算最后精确需要买多少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) {
@@ -35149,7 +35149,7 @@ function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOr
     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,
@@ -35164,9 +35164,9 @@ function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOr
   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
     );
@@ -35225,7 +35225,7 @@ function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOr
     // 如果存在价格间隙（卖出时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;
 
@@ -35245,7 +35245,7 @@ function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOr
               // 计算精确能获得多少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; // 强平订单数量
@@ -35294,7 +35294,7 @@ function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOr
               // 计算精确能获得多少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) {
@@ -35344,7 +35344,7 @@ function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOr
     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}`);
     }
@@ -35353,7 +35353,7 @@ function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOr
     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;
 
@@ -35373,7 +35373,7 @@ function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOr
               // 无限流动性够卖出需求了
               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) {
@@ -35431,7 +35431,7 @@ const { calcLiqTokenBuy, calcLiqTokenSell } = calcLiq;
 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) {
@@ -35476,17 +35476,20 @@ async function simulateTokenBuy$1(mint, buyTokenAmount, passOrder = null, lastPr
       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);
@@ -35942,11 +35945,268 @@ var close_indices = {
   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;
 
 
 
@@ -36152,6 +36412,12 @@ class SimulatorModule$1 {
             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,
@@ -36171,6 +36437,15 @@ class SimulatorModule$1 {
             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);
 
@@ -37993,7 +38268,7 @@ class OrderUtils$2 {
 
 var orderUtils = OrderUtils$2;
 
-var address = "AGpTikur4Sxf9xutmJrwVmyKWYQEsqzoiiEm2mvr82cp";
+var address = "F2FzigE1Z374iDvreiM6hZQe6oGXgomJfv8PyybvUXye";
 var metadata = {
 	name: "pinpet",
 	version: "0.1.0",
@@ -40478,7 +40753,7 @@ var errors = [
 	{
 		code: 6003,
 		name: "SellCalculationOverflow",
-		msg: "Sell trade calculation overflow"
+		msg: "Sell trade calculation  overflow"
 	},
 	{
 		code: 6004,
@@ -41795,7 +42070,7 @@ class PinPetSdk$1 {
     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;
 
@@ -41959,13 +42234,13 @@ const DEFAULT_NETWORKS = {
   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'
   }
 };