pinpet-sdk 0.1.1

package/src/modules/simulator/sell.js_del

@@ -0,0 +1,323 @@
+
+const CurveAMM = require('../../utils/curve_amm');
+const { absoluteValue } = require('./utils');
+
+
+
+/**
+ * Simulate sell transaction analysis
+ * @param {string} mint - Token address
+ * @param {bigint|string|number} sellTokenAmount - Token amount to sell (u64 format, precision 10^6)
+ * @returns {Promise<Object>} Sell analysis result
+ */
+async function simulateSell(mint, sellTokenAmount) {
+    try {
+        // 1. Parameter validation
+        if (!mint || typeof mint !== 'string') {
+            return {
+                success: false,
+                errorCode: 'PARAM_ERROR',
+                errorMessage: 'Token address must be a valid string',
+                data: null
+            };
+        }
+
+        if (sellTokenAmount === undefined || sellTokenAmount === null) {
+            return {
+                success: false,
+                errorCode: 'PARAM_ERROR',
+                errorMessage: 'Sell token amount cannot be empty',
+                data: null
+            };
+        }
+
+        // Convert to bigint
+        let sellTokenAmountU64;
+        try {
+            sellTokenAmountU64 = typeof sellTokenAmount === 'bigint' ? sellTokenAmount : BigInt(sellTokenAmount);
+            if (sellTokenAmountU64 <= 0n) {
+                throw new Error('Amount must be greater than 0');
+            }
+        } catch (error) {
+            return {
+                success: false,
+                errorCode: 'PARAM_ERROR',
+                errorMessage: `Invalid token amount: ${error.message}`,
+                data: null
+            };
+        }
+
+
+        let currentPriceU64;
+        try {
+            const priceString = await this.sdk.data.price(mint);
+            currentPriceU64 = BigInt(priceString);
+        } catch (error) {
+            return {
+                success: false,
+                errorCode: 'API_ERROR',
+                errorMessage: `获取价格信息失败: ${error.message} / Failed to get price info: ${error.message}`,
+                data: null
+            };
+        }
+
+
+
+        // 3. 获取做多订单列表 / Get long order list (down_orders)
+        let ordersData;
+        try {
+            ordersData = await this.sdk.data.orders(mint, {
+                type: 'down_orders',
+                limit: 500
+            });
+            if (!ordersData.success) {
+                return {
+                    success: false,
+                    errorCode: 'API_ERROR',
+                    errorMessage: '无法获取做多订单数据 / Cannot get long order data',
+                    data: null
+                };
+            }
+        } catch (error) {
+            return {
+                success: false,
+                errorCode: 'API_ERROR',
+                errorMessage: `获取订单数据失败: ${error.message} / Failed to get order data: ${error.message}`,
+                data: null
+            };
+        }
+
+        // 4. 转换订单数据格式 / Convert order data format
+        const longOrderList = ordersData.data.orders.map(order => ({
+            ...order,
+            lockLpStartPrice: order.lock_lp_start_price,
+            lockLpEndPrice: order.lock_lp_end_price,
+            lockLpSolAmount: BigInt(order.lock_lp_sol_amount),
+            lockLpTokenAmount: BigInt(order.lock_lp_token_amount)
+        }));
+
+        // 如果没有订单，添加 null 表示无限制
+        if (longOrderList.length === 0) {
+            longOrderList.push(null);
+        }
+
+        // 5. 开始 AMM 计算 / Start AMM calculation
+        // 计算理想情况下的基准SOL数量（完全无滑点）
+        const idealTradeResult = CurveAMM.sellFromPriceWithTokenInput(currentPriceU64, sellTokenAmountU64);
+        let idealSolAmount = 0n;
+        if (idealTradeResult) {
+            idealSolAmount = idealTradeResult[1];
+        }
+        const idealTokenAmount = sellTokenAmountU64;
+
+        // 初始化价格区间和流动性相关变量
+        let totalPriceSpan = 0n;
+        let totalLiquiditySolAmount = 0n;
+        let totalLiquidityTokenAmount = 0n;
+        let targetReachedAtSegmentIndex = -1;
+        let minAllowedPrice = 0n;
+
+        // 构建价格区间分析列表
+        const priceSegmentAnalysisList = new Array(longOrderList.length);
+
+        // 遍历订单列表并计算每个价格区间的参数
+        for (let segmentIndex = 0; segmentIndex < longOrderList.length; segmentIndex++) {
+            let segmentStartPrice, segmentEndPrice;
+
+            // 根据区间位置确定起始和结束价格
+            if (segmentIndex === 0) {
+                // 第一个区间：从当前价格开始（向下卖出）
+                segmentStartPrice = currentPriceU64;
+
+                if (longOrderList[0] === null) {
+                    // 如果第一个订单就是null，表示没有任何订单
+                    segmentEndPrice = CurveAMM.MIN_U128_PRICE; // 最低价格
+                    minAllowedPrice = CurveAMM.MIN_U128_PRICE; // 无限制到最低价格
+                } else {
+                    // 到第一个订单结束价格的下一个单位
+                    segmentEndPrice = BigInt(longOrderList[0].lockLpStartPrice);
+                    minAllowedPrice = BigInt(longOrderList[0].lockLpStartPrice);
+                }
+            } else if (longOrderList[segmentIndex] === null) {
+                // 当前遍历到null（链表结束）
+                segmentStartPrice = BigInt(longOrderList[segmentIndex - 1].lockLpEndPrice);
+                segmentEndPrice = CurveAMM.MIN_U128_PRICE; // 到最低价格
+            } else {
+                // 普通情况：位于两个订单之间的空隙
+                segmentStartPrice = BigInt(longOrderList[segmentIndex - 1].lockLpEndPrice);
+                segmentEndPrice = BigInt(longOrderList[segmentIndex].lockLpStartPrice);
+            }
+
+            // 验证价格区间的有效性
+            if (segmentStartPrice < segmentEndPrice) {
+                // 价格区间无效，跳过（卖出时起始价格应该高于结束价格）
+                priceSegmentAnalysisList[segmentIndex] = {
+                    startPrice: segmentStartPrice,
+                    endPrice: segmentEndPrice,
+                    obtainedSolAmount: null,
+                    consumedTokenAmount: null,
+                    isValid: false
+                };
+                continue;
+            }
+
+            if (segmentStartPrice === segmentEndPrice) {
+                priceSegmentAnalysisList[segmentIndex] = {
+                    startPrice: segmentStartPrice,
+                    endPrice: segmentEndPrice,
+                    obtainedSolAmount: 0n,
+                    consumedTokenAmount: 0n,
+                    isValid: true
+                };
+                continue;
+            }
+
+            // 使用AMM计算该区间的交易参数（卖出：从高价格到低价格）
+            const segmentTradeResult = CurveAMM.sellFromPriceToPrice(segmentStartPrice, segmentEndPrice);
+
+            if (!segmentTradeResult) {
+                // AMM计算失败
+                priceSegmentAnalysisList[segmentIndex] = {
+                    startPrice: segmentStartPrice,
+                    endPrice: segmentEndPrice,
+                    obtainedSolAmount: null,
+                    consumedTokenAmount: null,
+                    isValid: false
+                };
+            } else {
+                // 计算成功，保存结果
+                const [consumedTokenAmount, obtainedSolAmount] = segmentTradeResult;
+                priceSegmentAnalysisList[segmentIndex] = {
+                    startPrice: segmentStartPrice,
+                    endPrice: segmentEndPrice,
+                    obtainedSolAmount,
+                    consumedTokenAmount,
+                    isValid: true
+                };
+            }
+        }
+
+        // 累计计算总流动性深度
+        for (let i = 0; i < priceSegmentAnalysisList.length; i++) {
+            const segment = priceSegmentAnalysisList[i];
+
+            if (segment.isValid && segment.obtainedSolAmount !== null && segment.consumedTokenAmount !== null) {
+                totalLiquiditySolAmount += BigInt(segment.obtainedSolAmount);
+                totalLiquidityTokenAmount += BigInt(segment.consumedTokenAmount);
+
+                // Token输入：检查累计的Token数量是否已经达到目标
+                if (totalLiquidityTokenAmount >= sellTokenAmountU64 && targetReachedAtSegmentIndex === -1) {
+                    targetReachedAtSegmentIndex = i;
+                }
+            }
+        }
+
+        // 计算实际交易参数
+        let actualObtainedSolAmount = 0n;
+        let actualConsumedTokenAmount = 0n;
+        let transactionCompletionRate = 0.0;
+
+        if (targetReachedAtSegmentIndex !== -1) {
+            // 可以100%完成交易
+            transactionCompletionRate = 100.0;
+
+            for (let i = 0; i <= targetReachedAtSegmentIndex; i++) {
+                const currentSegment = priceSegmentAnalysisList[i];
+
+                if (i === targetReachedAtSegmentIndex) {
+                    // 最后一个区间：可能只需要部分交易
+                    // Token输入：计算剩余需要卖出的Token
+                    const remainingTokenToSell = sellTokenAmountU64 - actualConsumedTokenAmount;
+                    const partialTradeResult = CurveAMM.sellFromPriceWithTokenInput(
+                        currentSegment.startPrice,
+                        remainingTokenToSell
+                    );
+
+                    if (partialTradeResult) {
+                        const [finalPrice, obtainedSolForPartial] = partialTradeResult;
+                        actualObtainedSolAmount += obtainedSolForPartial;
+                        actualConsumedTokenAmount += remainingTokenToSell;
+                        totalPriceSpan += absoluteValue(currentSegment.startPrice - finalPrice) + 1n;
+                    }
+                } else {
+                    // 完整使用该区间
+                    actualObtainedSolAmount += currentSegment.obtainedSolAmount;
+                    actualConsumedTokenAmount += currentSegment.consumedTokenAmount;
+                    totalPriceSpan += absoluteValue(currentSegment.startPrice - currentSegment.endPrice) + 1n;
+                }
+            }
+        } else {
+            // 无法完全完成交易，使用所有可用流动性
+            for (let i = 0; i < priceSegmentAnalysisList.length; i++) {
+                const segment = priceSegmentAnalysisList[i];
+                if (segment.isValid) {
+                    actualObtainedSolAmount += segment.obtainedSolAmount;
+                    actualConsumedTokenAmount += segment.consumedTokenAmount;
+                    totalPriceSpan += absoluteValue(segment.startPrice - segment.endPrice) + 1n;
+                }
+            }
+
+            // 计算交易完成率
+            if (sellTokenAmountU64 > 0n) {
+                transactionCompletionRate = parseFloat(
+                    CurveAMM.u64ToTokenDecimal(actualConsumedTokenAmount)
+                        .div(CurveAMM.u64ToTokenDecimal(sellTokenAmountU64))
+                        .mul(100)
+                        .toFixed(2)
+                );
+            }
+
+            // 重新计算理论参数（基于实际可达到的数量）
+            const theoreticalTradeResult = CurveAMM.sellFromPriceWithTokenInput(currentPriceU64, actualConsumedTokenAmount);
+            if (theoreticalTradeResult) {
+                const [, theoreticalSolObtained] = theoreticalTradeResult;
+                // 更新理论SOL数量
+            }
+        }
+
+        // 计算最小滑点百分比
+        const minimumSlippagePercentage = Math.abs(
+            100.0 * (
+                CurveAMM.u64ToSolDecimal(idealSolAmount)
+                    .minus(CurveAMM.u64ToSolDecimal(actualObtainedSolAmount))
+                    .div(CurveAMM.u64ToSolDecimal(idealSolAmount))
+                    .toNumber()
+            )
+        );
+
+        // 6. 返回分析结果 / Return analysis result
+        return {
+            success: true,
+            errorCode: null,
+            errorMessage: null,
+            data: {
+                inputType: 'token',
+                inputAmount: sellTokenAmountU64,
+                minAllowedPrice: minAllowedPrice,
+                totalPriceSpan: totalPriceSpan,
+                transactionCompletionRate: transactionCompletionRate,
+                idealSolAmount: idealSolAmount,
+                idealTokenAmount: idealTokenAmount,
+                actualObtainedSolAmount: actualObtainedSolAmount,
+                actualConsumedTokenAmount: actualConsumedTokenAmount,
+                theoreticalSolAmount: idealSolAmount, // 理论目标SOL数量
+                minimumSlippagePercentage: minimumSlippagePercentage,
+                totalLiquiditySolAmount: totalLiquiditySolAmount,
+                totalLiquidityTokenAmount: totalLiquidityTokenAmount
+            }
+        };
+
+    } catch (error) {
+        return {
+            success: false,
+            errorCode: 'DATA_ERROR',
+            errorMessage: `计算过程中发生错误: ${error.message} / Error during calculation: ${error.message}`,
+            data: null
+        };
+    }
+}
+
+
+module.exports = {
+    simulateSell
+};

package/src/modules/simulator/stop_loss_utils.js

@@ -0,0 +1,223 @@
+
+
+// Liquidity reservation ratio - how much liquidity to reserve relative to the last locked liquidity
+const LIQUIDITY_RESERVATION = 100;  // 100%
+
+/**
+ * Transform orders data format
+ * @param {Object} ordersData - Raw orders data
+ * @returns {Array} Transformed orders array
+ */
+function transformOrdersData(ordersData) {
+  if (!ordersData || !ordersData.success || !ordersData.data || !ordersData.data.orders) {
+    throw new Error('Invalid orders data format');
+  }
+
+  return ordersData.data.orders.map(order => ({
+    order_type: order.order_type,
+    lock_lp_start_price: BigInt(order.lock_lp_start_price),
+    lock_lp_end_price: BigInt(order.lock_lp_end_price),
+    lock_lp_sol_amount: order.lock_lp_sol_amount,
+    lock_lp_token_amount: order.lock_lp_token_amount,
+    order_pda: order.order_pda
+  }));
+}
+
+/**
+ * @typedef {Object} Order
+ * @property {number} order_type - Order type (e.g., 1 for down_orders, 2 for up_orders).
+ * @property {bigint} lock_lp_start_price - Locked liquidity start price.
+ * @property {bigint} lock_lp_end_price - Locked liquidity end price.
+ * @property {number} lock_lp_sol_amount - 锁定的SOL数量。
+ * @property {number} lock_lp_token_amount - 锁定的代币数量。
+ * @property {string} order_pda - 订单的PDA地址。
+ */
+
+/**
+ * @typedef {Object} OverlapResult
+ * @property {boolean} no_overlap - 是否没有重叠。`true` 表示没有重叠（可以安全插入），`false` 表示有重叠。
+ * @property {string|null} prev_order_pda - 如果没有重叠，表示新区间逻辑上的前一个订单PDA。如果新区间是第一个，则为 `null`。
+ * @property {string|null} next_order_pda - 如果没有重叠，表示新区间逻辑上的后一个订单PDA。如果新区间是最后一个，则为 `null`。
+ * @property {string} overlap_reason - 重叠原因说明。当没有重叠时为空字符串，有重叠时说明具体原因。
+ */
+
+/**
+ * 检查给定价格区间是否与已排序的订单列表中的任何区间发生重叠。
+ * 此函数利用列表已排序的特性，通过优化的查找算法实现高性能。
+ *
+ * @param {'down_orders' | 'up_orders'} order_type - 订单类型。'down_orders' 表示价格从高到低排序，'up_orders' 表示价格从低到高排序。
+ * @param {Order[]} order_list - 已排序的订单对象数组。
+ * @param {bigint | number | string} lp_start_price - 需要检查的区间的起始价格。
+ * @param {bigint | number | string} lp_end_price - 需要检查的区间的结束价格。
+ * @returns {OverlapResult} - 返回一个包含重叠检查结果和相邻订单PDA的对象。
+ *
+ * @example
+ * // down_orders 示例 (价格从高到低)
+ * const downOrders = [
+ *   { lock_lp_start_price: 100n, lock_lp_end_price: 90n, order_pda: 'pda1' },
+ *   { lock_lp_start_price: 80n, lock_lp_end_price: 70n, order_pda: 'pda2' }
+ * ];
+ * // 无重叠，插入中间。逻辑上前一个是pda2(价格更低)，后一个是pda1(价格更高)
+ * checkPriceRangeOverlap('down_orders', downOrders, 85n, 82n);
+ * // 返回: { no_overlap: true, prev_order_pda: 'pda2', next_order_pda: 'pda1' }
+ *
+ * // 有重叠
+ * checkPriceRangeOverlap('down_orders', downOrders, 95n, 85n);
+ * // 返回: { no_overlap: false, prev_order_pda: null, next_order_pda: null }
+ *
+ * @example
+ * // up_orders 示例 (价格从低到高)
+ * const upOrders = [
+ *   { lock_lp_start_price: 70n, lock_lp_end_price: 80n, order_pda: 'pda2' },
+ *   { lock_lp_start_price: 90n, lock_lp_end_price: 100n, order_pda: 'pda1' }
+ * ];
+ * // 无重叠，插入末尾
+ * checkPriceRangeOverlap('up_orders', upOrders, 110n, 120n);
+ * // 返回: { no_overlap: true, prev_order_pda: 'pda1', next_order_pda: null }
+ */
+function checkPriceRangeOverlap(order_type, order_list, lp_start_price, lp_end_price) {
+  const startPrice = BigInt(lp_start_price);
+  const endPrice = BigInt(lp_end_price);
+
+  if (order_list.length === 0) {
+    return { no_overlap: true, prev_order_pda: null, next_order_pda: null, overlap_reason: "" };
+  }
+
+  const isDown = order_type === 'down_orders';
+
+  // 验证并规范化输入价格区间，确保 minPrice <= maxPrice
+  if ((isDown && startPrice < endPrice) || (!isDown && startPrice > endPrice)) {
+    throw new Error('输入的起始和结束价格与订单类型规则不匹配。');
+  }
+  const minPrice = isDown ? endPrice : startPrice;
+  const maxPrice = isDown ? startPrice : endPrice;
+
+  let low = 0;
+  let high = order_list.length - 1;
+  let insertionIndex = order_list.length; // 默认插入到最后
+
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const order = order_list[mid];
+    const orderStart = BigInt(order.lock_lp_start_price);
+    const orderEnd = BigInt(order.lock_lp_end_price);
+
+    const orderMin = isDown ? orderEnd : orderStart;
+    const orderMax = isDown ? orderStart : orderEnd;
+
+    // 核心重叠判断: (StartA < EndB) and (EndA > StartB)
+    if (minPrice < orderMax && maxPrice > orderMin) {
+      // 发生基础重叠，根据当前位置确定正确的插入位置和PDA
+      let overlapInsertionIndex;
+      if (isDown) {
+        overlapInsertionIndex = maxPrice > orderMax ? mid : mid + 1;
+      } else {
+        overlapInsertionIndex = minPrice < orderMin ? mid : mid + 1;
+      }
+      
+      const nextOrder = order_list[overlapInsertionIndex] || null;
+      const prevOrder = order_list[overlapInsertionIndex - 1] || null;
+      
+      return { 
+        no_overlap: false, 
+        prev_order_pda: prevOrder ? prevOrder.order_pda : null, 
+        next_order_pda: nextOrder ? nextOrder.order_pda : null, 
+        overlap_reason: "Overlaps with existing order range" 
+      };
+    }
+
+    if (isDown) {
+      // down_orders: 价格从大到小 (orderMax 递减)
+      if (maxPrice > orderMax) { // 新区间在当前区间的“左边”（价格更高）
+        insertionIndex = mid;
+        high = mid - 1;
+      } else {
+        low = mid + 1;
+      }
+    } else {
+      // up_orders: 价格从小到大 (orderMin 递增)
+      if (minPrice < orderMin) { // 新区间在当前区间的“左边”（价格更低）
+        insertionIndex = mid;
+        high = mid - 1;
+      } else {
+        low = mid + 1;
+      }
+    }
+  }
+
+  // 根据找到的插入点，确定逻辑上的前后 PDA
+  // insertionIndex 是新区间应该插入的位置，使得列表依然有序
+  const nextOrder = order_list[insertionIndex] || null;
+  const prevOrder = order_list[insertionIndex - 1] || null;
+
+  // 检查流动性预留重叠
+  function checkLiquidityReservationOverlap(checkOrder) {
+    if (!checkOrder) return false;
+    
+    const orderStart = BigInt(checkOrder.lock_lp_start_price);
+    const orderEnd = BigInt(checkOrder.lock_lp_end_price);
+    const orderMin = isDown ? orderEnd : orderStart;
+    const orderMax = isDown ? orderStart : orderEnd;
+    
+    // 计算扩大区间值
+    const expansionAmount = (orderMax - orderMin) * BigInt(Math.floor(LIQUIDITY_RESERVATION)) / 100n;
+    
+    let expandedStart, expandedEnd,hasOverlap;
+    if (isDown) {
+      // down_orders: start不变，end向下扩大
+      expandedStart = orderMax;
+      expandedEnd = orderMin - expansionAmount;
+      if (startPrice < expandedEnd){
+        hasOverlap = false;
+      }else{
+        hasOverlap = true;
+      }
+    } else {
+      // up_orders: start不变，end向上扩大  
+      expandedStart = orderMin;
+      expandedEnd = orderMax + expansionAmount;
+      if (startPrice > expandedEnd){
+        hasOverlap = false;
+      }else{
+        hasOverlap = true;
+      }
+    }
+    
+    
+    // if (hasOverlap) {
+    //   console.log(`  Order range: ${orderMin}-${orderMax}`);
+    //   console.log(`  Expanded range: ${expandedStart}-${expandedEnd}`);
+    //   console.log(`  New range: ${minPrice}-${maxPrice}`);
+    // }
+    
+    return hasOverlap;
+  }
+
+  // 检查与前一个订单的流动性预留重叠
+  if (prevOrder && checkLiquidityReservationOverlap(prevOrder)) {
+    return {
+      no_overlap: false,
+      prev_order_pda: prevOrder ? prevOrder.order_pda : null,
+      next_order_pda: nextOrder ? nextOrder.order_pda : null,
+      overlap_reason: "Overlaps with previous order's liquidity reservation range"
+    };
+  }
+
+
+
+  // 无重叠，返回正确的PDA值
+  // prev_order_pda: 插入位置的前一个节点 (索引更小)
+  // next_order_pda: 插入位置的后一个节点 (索引更大)
+  return {
+    no_overlap: true,
+    prev_order_pda: prevOrder ? prevOrder.order_pda : null,
+    next_order_pda: nextOrder ? nextOrder.order_pda : null,
+    overlap_reason: ""
+  };
+}
+
+
+module.exports = {
+  transformOrdersData,
+  checkPriceRangeOverlap
+};

package/src/modules/simulator/utils.js

@@ -0,0 +1,44 @@
+
+
+// Liquidity reservation ratio - how much liquidity to reserve relative to the last locked liquidity
+const LIQUIDITY_RESERVATION = 100;  // 100%
+
+// Price adjustment percentage
+const PRICE_ADJUSTMENT_PERCENTAGE = 15; //  5就是 0.5%
+
+
+/**
+ * Convert API order format to expected format
+ * @param {Array} apiOrders - Orders returned from API
+ * @returns {Array} Converted order list
+ */
+function convertApiOrdersFormat(apiOrders) {
+    if (!apiOrders || !Array.isArray(apiOrders)) {
+        return [];
+    }
+
+    return apiOrders.map(order => ({
+        ...order,
+        lockLpStartPrice: order.lock_lp_start_price,
+        lockLpEndPrice: order.lock_lp_end_price
+    }));
+}
+
+
+/**
+ * Handle BigInt absolute value
+ * @param {BigInt} value - BigInt value to calculate absolute value
+ * @returns {BigInt} Absolute value result
+ */
+function absoluteValue(value) {
+    return value < 0n ? -value : value;
+}
+
+
+
+module.exports = {
+    convertApiOrdersFormat,
+    absoluteValue,
+    LIQUIDITY_RESERVATION,
+    PRICE_ADJUSTMENT_PERCENTAGE
+};