pinpet-sdk 2.1.8 → 2.1.9

package/dist/pinpet-sdk.cjs.js

@@ -41935,9 +41935,11 @@ class CurveAMM$7 {
 
     /**
      * Minimum price that can appear, below this price may cause overflow
+     * Note: With dynamic liquidity pools, prices can be much smaller (e.g., 3e-10)
+     * Reduced from 1e-9 to 1e-12 to support wider range of pool configurations
      * @type {Decimal}
      */
-    static INITIAL_MIN_PRICE_DECIMAL = new Decimal('0.000000001');
+    static INITIAL_MIN_PRICE_DECIMAL = new Decimal('0.000000000001'); // 1e-12
 
     /**
      * Decimal representation of precision factor = 10^23
@@ -42743,9 +42745,83 @@ class CurveAMM$7 {
         return [endPriceU128, solAmountU64];
     }
 
+    /**
+     * 基于起始价格和期望token输出量计算需要的SOL输入量和结束价格（带自定义流动池参数）
+     * Based on starting price and desired token output, calculate required SOL input and ending price (with custom pool params)
+     *
+     * @param {bigint|string|number} startLowPrice - Starting price (lower)
+     * @param {bigint|string|number} tokenOutputAmount - Desired token amount to obtain
+     * @param {string|number|Decimal} initialVirtualSol - Initial virtual SOL reserve
+     * @param {string|number|Decimal} initialVirtualToken - Initial virtual token reserve
+     * @returns {[bigint, bigint]|null} Returns [price after transaction, SOL amount to pay] on success, null on failure
+     * Price rounded down, SOL amount rounded up
+     */
+    static buyFromPriceWithTokenOutputWithParams(startLowPrice, tokenOutputAmount, initialVirtualSol, initialVirtualToken) {
+        // Convert to Decimal for calculation
+        const startPriceDec = this.u128ToDecimal(startLowPrice);
+        const tokenOutputDec = this.u64ToTokenDecimal(tokenOutputAmount);
+
+        // Check if input parameters are valid
+        if (startPriceDec.lte(0)) {
+            return null;
+        }
+
+        // If token output amount is 0, return unchanged price and SOL input of 0
+        if (tokenOutputDec.eq(0)) {
+            const endPriceU128 = this.decimalToU128(startPriceDec);
+            if (endPriceU128 === null) return null;
+            return [endPriceU128, 0n];
+        }
+
+        if (tokenOutputDec.lt(0)) {
+            return null;
+        }
+
+        // Use custom pool parameters to calculate k value
+        const k = this.calculateK(initialVirtualSol, initialVirtualToken);
+
+        // Calculate reserves for starting state
+        const startReserves = this.calculateReservesByPrice(startPriceDec, k);
+        if (!startReserves) return null;
+
+        const [startSolReserve, startTokenReserve] = startReserves;
+
+        // Calculate token reserves for ending state
+        const endTokenReserve = startTokenReserve.sub(tokenOutputDec);
+
+        // Check if token reserves are sufficient
+        if (endTokenReserve.lte(0)) {
+            return null;
+        }
+
+        // Calculate SOL reserve for ending state using AMM formula
+        const endSolReserve = k.div(endTokenReserve);
+
+        // Calculate required SOL input amount
+        const solInputAmount = endSolReserve.sub(startSolReserve);
+
+        // Calculate ending price
+        const endPrice = endSolReserve.div(endTokenReserve);
+
+        // Check if calculation results are valid
+        if (solInputAmount.lte(0) || endPrice.lte(0)) {
+            return null;
+        }
+
+        // Convert back to appropriate types with required rounding
+        const endPriceU128 = this.decimalToU128(endPrice); // Price rounded down
+        const solAmountU64 = this.solDecimalToU64Ceil(solInputAmount); // SOL rounded up
+
+        if (endPriceU128 === null || solAmountU64 === null) {
+            return null;
+        }
+
+        return [endPriceU128, solAmountU64];
+    }
+
     /**
      * Calculate required token input amount and ending price based on starting price and expected SOL output amount
-     * 
+     *
      * @param {bigint|string|number} startHighPrice - Starting price
      * @param {bigint|string|number} solOutputAmount - Desired SOL amount to obtain
      * @returns {[bigint, bigint]|null} Returns [price after transaction, token amount to pay] on success, null on failure
@@ -42814,9 +42890,83 @@ class CurveAMM$7 {
         return [endPriceU128, tokenAmountU64];
     }
 
+    /**
+     * 基于起始价格和期望SOL输出量计算需要的token输入量和结束价格（带自定义流动池参数）
+     * Based on starting price and desired SOL output, calculate required token input and ending price (with custom pool params)
+     *
+     * @param {bigint|string|number} startHighPrice - Starting price (higher)
+     * @param {bigint|string|number} solOutputAmount - Desired SOL amount to obtain
+     * @param {string|number|Decimal} initialVirtualSol - Initial virtual SOL reserve
+     * @param {string|number|Decimal} initialVirtualToken - Initial virtual token reserve
+     * @returns {[bigint, bigint]|null} Returns [price after transaction, token amount to pay] on success, null on failure
+     * Price rounded down, token amount rounded up
+     */
+    static sellFromPriceWithSolOutputWithParams(startHighPrice, solOutputAmount, initialVirtualSol, initialVirtualToken) {
+        // Convert to Decimal for calculation
+        const startPriceDec = this.u128ToDecimal(startHighPrice);
+        const solOutputDec = this.u64ToSolDecimal(solOutputAmount);
+
+        // Check if input parameters are valid
+        if (startPriceDec.lte(0)) {
+            return null;
+        }
+
+        // If SOL output amount is 0, return unchanged price and token input of 0
+        if (solOutputDec.eq(0)) {
+            const endPriceU128 = this.decimalToU128(startPriceDec);
+            if (endPriceU128 === null) return null;
+            return [endPriceU128, 0n];
+        }
+
+        if (solOutputDec.lt(0)) {
+            return null;
+        }
+
+        // Use custom pool parameters to calculate k value
+        const k = this.calculateK(initialVirtualSol, initialVirtualToken);
+
+        // Calculate reserves for starting state
+        const startReserves = this.calculateReservesByPrice(startPriceDec, k);
+        if (!startReserves) return null;
+
+        const [startSolReserve, startTokenReserve] = startReserves;
+
+        // Calculate SOL reserves for ending state
+        const endSolReserve = startSolReserve.sub(solOutputDec);
+
+        // Check if SOL reserves are sufficient
+        if (endSolReserve.lte(0)) {
+            return null;
+        }
+
+        // Calculate token reserves for ending state according to AMM formula
+        const endTokenReserve = k.div(endSolReserve);
+
+        // Calculate required token input amount
+        const tokenInputAmount = endTokenReserve.sub(startTokenReserve);
+
+        // Calculate ending price
+        const endPrice = endSolReserve.div(endTokenReserve);
+
+        // Check if calculation results are valid
+        if (tokenInputAmount.lte(0) || endPrice.lte(0)) {
+            return null;
+        }
+
+        // Convert back to appropriate types with required rounding
+        const endPriceU128 = this.decimalToU128(endPrice); // Price rounded down
+        const tokenAmountU64 = this.tokenDecimalToU64Ceil(tokenInputAmount); // Token rounded up
+
+        if (endPriceU128 === null || tokenAmountU64 === null) {
+            return null;
+        }
+
+        return [endPriceU128, tokenAmountU64];
+    }
+
     /**
      * Calculate remaining amount after deducting fees
-     * 
+     *
      * @param {bigint|string|number} amount - Original amount
      * @param {number} fee - Fee rate, expressed with FEE_DENOMINATOR as denominator
      *                       Example: 1000 represents 1% fee (1000/100000)
@@ -45915,7 +46065,7 @@ const CurveAMM$4 = curve_amm;
  * @throws {Error} 无限流动性计算失败：最大价格流动性计算异常 Infinite liquidity calculation failure: max price liquidity calculation exception
  * @throws {Error} 订单数据格式错误：订单对象缺少必需字段 Order data format error: order object missing required fields
  */
-function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrder = null) {
+function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrder = null, initialVirtualSol = null, initialVirtualToken = null) {
   // 由于是买入操作 肯定拿的是 up_orders 方向的 订单  lock_lp_start_price <  lock_lp_end_price
   // 并且 lock_lp_start_price 在 orders 中是从小到大排序的
 
@@ -45932,6 +46082,9 @@ function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrde
   if (!onceMaxOrder || onceMaxOrder <= 0) {
     throw new Error('参数验证错误：onceMaxOrder 必须是正数 Parameter validation error: onceMaxOrder must be a positive number');
   }
+  if (initialVirtualSol === null || initialVirtualToken === null) {
+    throw new Error('参数验证错误：initialVirtualSol 和 initialVirtualToken 不能为空 Parameter validation error: initialVirtualSol and initialVirtualToken cannot be null');
+  }
 
   const result = {
     free_lp_sol_amount_sum: 0n,  // 间隙中可使用的sol流动性数量
@@ -45962,7 +46115,14 @@ function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrde
 
   try {
     const priceBigInt = BigInt(price);
-    [, result.ideal_lp_sol_amount] = CurveAMM$4.buyFromPriceWithTokenOutput(priceBigInt, buyTokenAmountBigInt);
+    const initialVirtualSolBigInt = BigInt(initialVirtualSol.toString());
+    const initialVirtualTokenBigInt = BigInt(initialVirtualToken.toString());
+    [, result.ideal_lp_sol_amount] = CurveAMM$4.buyFromPriceWithTokenOutputWithParams(
+      priceBigInt,
+      buyTokenAmountBigInt,
+      initialVirtualSolBigInt,
+      initialVirtualTokenBigInt
+    );
     // console.log(`理想计算: 当前价格=${priceBigInt}, 目标代币=${buyTokenAmountBigInt}, 理想SOL=${result.ideal_lp_sol_amount}`);
   } catch (error) {
     throw new Error(`buy流动性计算错误：理想流动性计算失败 Liquidity calculation error: Ideal liquidity calculation failed - ${error.message}`);
@@ -46268,7 +46428,7 @@ function calcLiqTokenBuy$1(price, buyTokenAmount, orders, onceMaxOrder, passOrde
  * @throws {Error} 无限流动性计算失败：最小价格流动性计算异常 Infinite liquidity calculation failure: min price liquidity calculation exception
  * @throws {Error} 订单数据格式错误：订单对象缺少必需字段 Order data format error: order object missing required fields
  */
-function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOrder = null) {
+function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOrder = null, initialVirtualSol = null, initialVirtualToken = null) {
   // 由于是卖出操作 肯定拿的是 down_orders 方向的 订单  lock_lp_start_price >  lock_lp_end_price
   // 并且 lock_lp_start_price 在 orders 中是从大到小排序的
 
@@ -46285,6 +46445,9 @@ function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOr
   if (!onceMaxOrder || onceMaxOrder <= 0) {
     throw new Error('参数验证错误：onceMaxOrder 必须是正数 Parameter validation error: onceMaxOrder must be a positive number');
   }
+  if (initialVirtualSol === null || initialVirtualToken === null) {
+    throw new Error('参数验证错误：initialVirtualSol 和 initialVirtualToken 不能为空 Parameter validation error: initialVirtualSol and initialVirtualToken cannot be null');
+  }
 
   const result = {
     free_lp_sol_amount_sum: 0n,  // 间隙中可使用的sol流动性数量
@@ -46311,7 +46474,14 @@ function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOr
   // 计算理想情况下卖出能获得的SOL数量
   try {
     const priceBigInt = BigInt(price);
-    [, result.ideal_lp_sol_amount] = CurveAMM$4.sellFromPriceWithTokenInput(priceBigInt, sellTokenAmountBigInt);
+    const initialVirtualSolBigInt = BigInt(initialVirtualSol.toString());
+    const initialVirtualTokenBigInt = BigInt(initialVirtualToken.toString());
+    [, result.ideal_lp_sol_amount] = CurveAMM$4.sellFromPriceWithTokenInputWithParams(
+      priceBigInt,
+      sellTokenAmountBigInt,
+      initialVirtualSolBigInt,
+      initialVirtualTokenBigInt
+    );
     // console.log(`理想计算: 当前价格=${priceBigInt}, 卖出代币=${sellTokenAmountBigInt}, 理想SOL=${result.ideal_lp_sol_amount}`);
   } catch (error) {
     throw new Error(`sell流动性计算错误：理想流动性计算失败 Liquidity calculation error: Ideal liquidity calculation failed - ${error.message}`);
@@ -46319,7 +46489,14 @@ function calcLiqTokenSell$1(price, sellTokenAmount, orders, onceMaxOrder, passOr
 
   // orders 长度为0 时要单独计算
   if (orders.length === 0) {
-    const sellResult = CurveAMM$4.sellFromPriceToPrice(BigInt(price), CurveAMM$4.MIN_U128_PRICE);
+    const initialVirtualSolBigInt = BigInt(initialVirtualSol.toString());
+    const initialVirtualTokenBigInt = BigInt(initialVirtualToken.toString());
+    const sellResult = CurveAMM$4.sellFromPriceToPriceWithParams(
+      BigInt(price),
+      CurveAMM$4.MIN_U128_PRICE,
+      initialVirtualSolBigInt,
+      initialVirtualTokenBigInt
+    );
     if (sellResult) {
       [result.free_lp_token_amount_sum, result.free_lp_sol_amount_sum] = sellResult;
     } else {
@@ -46601,19 +46778,29 @@ async function simulateTokenBuy$1(mint, buyTokenAmount, passOrder = null, lastPr
     orders = ordersData.data.orders.slice(0, this.sdk.MAX_ORDERS_COUNT + 1);
   }
 
+  // 获取动态流动池参数
+  let curveData;
+  try {
+    curveData = await this.sdk.chain.getCurveAccount(mint);
+  } catch (error) {
+    throw new Error(`Failed to get curve account data: ${error.message}`);
+  }
+
   // console.log('simulateTokenBuy 获取的数据:');
   // console.log('价格:', price);
   // console.log('订单数量:', orders.length);
   // orders.forEach((order, i) => console.log(`订单${i}: start=${order.lock_lp_start_price}, end=${order.lock_lp_end_price}, sol=${order.lock_lp_sol_amount}, token=${order.lock_lp_token_amount}`));
 
-  // 调用 calcLiqTokenBuy 进行流动性计算
+  // 调用 calcLiqTokenBuy 进行流动性计算（传入动态流动池参数）
   try {
     const liqResult = calcLiqTokenBuy(
       price,
-      buyTokenAmount, 
+      buyTokenAmount,
       orders,
       this.sdk.MAX_ORDERS_COUNT,
-      passOrder
+      passOrder,
+      curveData.initialVirtualSol,
+      curveData.initialVirtualToken
     );
 
     // console.log('\n=== calcLiqTokenBuy 返回结果 ===');
@@ -46662,7 +46849,9 @@ async function simulateTokenBuy$1(mint, buyTokenAmount, passOrder = null, lastPr
         suggestedAmount,
         orders,
         this.sdk.MAX_ORDERS_COUNT,
-        passOrder
+        passOrder,
+        curveData.initialVirtualSol,
+        curveData.initialVirtualToken
       );
       
       const recalcRealSol = BigInt(recalcResult.real_lp_sol_amount);
@@ -46744,19 +46933,29 @@ async function simulateTokenSell$1(mint, sellTokenAmount, passOrder = null, last
     orders = ordersData.data.orders.slice(0, this.sdk.MAX_ORDERS_COUNT + 1);
   }
 
+  // 获取动态流动池参数
+  let curveData;
+  try {
+    curveData = await this.sdk.chain.getCurveAccount(mint);
+  } catch (error) {
+    throw new Error(`Failed to get curve account data: ${error.message}`);
+  }
+
   // console.log('simulateTokenSell 获取的数据:');
   // console.log('价格:', price);
   // console.log('订单数量:', orders.length);
   // orders.forEach((order, i) => console.log(`订单${i}: start=${order.lock_lp_start_price}, end=${order.lock_lp_end_price}, sol=${order.lock_lp_sol_amount}, token=${order.lock_lp_token_amount}`));
 
-  // 调用 calcLiqTokenSell 进行流动性计算
+  // 调用 calcLiqTokenSell 进行流动性计算（传入动态流动池参数）
   try {
     const liqResult = calcLiqTokenSell(
       price,
       sellTokenAmount,
       orders,
       this.sdk.MAX_ORDERS_COUNT,
-      passOrder
+      passOrder,
+      curveData.initialVirtualSol,
+      curveData.initialVirtualToken
     );
 
     // console.log('\n=== calcLiqTokenSell 返回结果 ===');
@@ -46805,7 +47004,9 @@ async function simulateTokenSell$1(mint, sellTokenAmount, passOrder = null, last
         suggestedAmount,
         orders,
         this.sdk.MAX_ORDERS_COUNT,
-        passOrder
+        passOrder,
+        curveData.initialVirtualSol,
+        curveData.initialVirtualToken
       );
       
       const recalcRealSol = BigInt(recalcResult.real_lp_sol_amount);