pinpet-sdk 2.1.13 → 2.1.15

package/src/idl/pinpet.json

@@ -1,5 +1,5 @@
 {
-  "address": "AGpTikur4Sxf9xutmJrwVmyKWYQEsqzoiiEm2mvr82cp",
+  "address": "F2FzigE1Z374iDvreiM6hZQe6oGXgomJfv8PyybvUXye",
   "metadata": {
     "name": "pinpet",
     "version": "0.1.0",
@@ -2481,7 +2481,7 @@
     {
       "code": 6003,
       "name": "SellCalculationOverflow",
-      "msg": "Sell trade calculation overflow"
+      "msg": "Sell trade calculation  overflow"
     },
     {
       "code": 6004,

package/src/modules/simulator/buy_sell_token.js

@@ -29,7 +29,7 @@ const { calcLiqTokenBuy, calcLiqTokenSell } = require('./calcLiq');
 async function simulateTokenBuy(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) {
@@ -74,17 +74,20 @@ async function simulateTokenBuy(mint, buyTokenAmount, passOrder = null, lastPric
       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);

package/src/modules/simulator/calc_sol_liq.js

@@ -0,0 +1,257 @@
+
+const CurveAMM = require('../../utils/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(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.INITIAL_SOL_RESERVE_DECIMAL;
+    const virtualToken = initialVirtualToken !== null ? initialVirtualToken : CurveAMM.INITIAL_TOKEN_RESERVE_DECIMAL;
+
+    // 3. 处理空订单情况（第一阶段）
+    if (!orders || orders.length === 0) {
+        // 直接计算完整流动性下的买入
+        const result = CurveAMM.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.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.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.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(price, sellSolAmount, orders, onceMaxOrder, passOrder = null, initialVirtualSol = null, initialVirtualToken = null) {
+
+
+}
+
+
+module.exports = {
+  calcLiqSolBuy,
+  calcLiqSolSell
+};

package/src/modules/simulator.js

@@ -2,7 +2,7 @@ const CurveAMM = require('../utils/curve_amm');
 const { simulateLongStopLoss, simulateShortStopLoss, simulateLongSolStopLoss, simulateShortSolStopLoss } = require('./simulator/long_shrot_stop');
 const { simulateTokenBuy, simulateTokenSell } = require('./simulator/buy_sell_token');
 const { simulateLongClose, simulateShortClose } = require('./simulator/close_indices');
-
+const {calcLiqSolBuy,calcLiqSolSell } = require('./simulator/calc_sol_liq');
 
 
 
@@ -208,6 +208,12 @@ class SimulatorModule {
             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,
@@ -227,6 +233,15 @@ class SimulatorModule {
             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);
 

package/src/sdk.js

@@ -62,7 +62,7 @@ class PinPetSdk {
     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
 

package/src/utils/constants.js

@@ -25,13 +25,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'
   }
 };