100x-sdk 1.0.1

package/src/modules/simulator/calc_sol_liq.js

@@ -0,0 +1,268 @@
+
+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|null} initialVirtualSol - 流动池SOL数量
+ * @param {string|number|null} initialVirtualToken - 流动池Token数量
+ * @returns {Object} { tokenAmount: bigint, msg: string, closedOrdersCount: number }
+ */
+function calcLiqSolBuy(price, buySolAmount, orders, onceMaxOrder, passOrderID = null, initialVirtualSol = null, initialVirtualToken = null){
+
+
+    //console.log("calcLiqSolBuy: , price, buySolAmount, orders, onceMaxOrder, passOrderID , initialVirtualSol, initialVirtualToken=", price, buySolAmount, orders, onceMaxOrder, passOrderID , initialVirtualSol , initialVirtualToken);
+
+    // 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 Decimal = require('decimal.js');
+    const virtualSol = initialVirtualSol !== null
+        ? new Decimal(initialVirtualSol.toString()).div(CurveAMM.SOL_PRECISION_FACTOR_DECIMAL)
+        : CurveAMM.INITIAL_SOL_RESERVE_DECIMAL;
+    const virtualToken = initialVirtualToken !== null
+        ? new Decimal(initialVirtualToken.toString()).div(CurveAMM.TOKEN_PRECISION_FACTOR_DECIMAL)
+        : CurveAMM.INITIAL_TOKEN_RESERVE_DECIMAL;
+
+    //console.log("calcLiqSolBuy: virtualSol,virtualToken=",virtualSol,virtualToken)
+
+
+    // 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/close_indices.js

@@ -0,0 +1,217 @@
+const { MAX_CANDIDATE_INDICES } = require('./utils');
+
+// Calculate number of nodes to include before and after the main position
+const CANDIDATE_NODES_EACH_SIDE = Math.floor((MAX_CANDIDATE_INDICES - 1) / 2);
+
+// Special value indicating no prev/next order in the linked list
+const NO_ORDER = 65535;
+
+/**
+ * 根据 index 在订单数组中查找订单
+ * Find order in array by its index field
+ *
+ * @param {Array} orders - 订单数组 / Orders array
+ * @param {number} index - 订单的 index 字段值 / Order's index field value
+ * @returns {Object|null} 找到的订单对象，找不到返回 null / Found order object or null
+ */
+function findOrderByIndex(orders, index) {
+  for (let i = 0; i < orders.length; i++) {
+    if (orders[i].index === index) {
+      return orders[i];
+    }
+  }
+  return null;
+}
+
+/**
+ * 为做多平仓生成候选插入索引
+ * Generate candidate insertion indices for closing long position
+ *
+ * @param {string} mint - 代币地址 / Token address
+ * @param {number|string|anchor.BN} closeOrderId - 要平仓的订单ID (order_id, 不是 index) / Order ID to close (order_id, not index)
+ * @param {Object|null} ordersData - 订单数据（可选，如果不提供会自动获取）/ Orders data (optional, will fetch if not provided)
+ * @returns {Promise<Object>} 返回包含候选索引数组的对象 / Returns object containing candidate indices array
+ *   - closeOrderIndices: {number[]} 候选插入位置索引数组 / Candidate insertion position indices array
+ *
+ * @throws {Error} 如果找不到对应的 closeOrderId / If closeOrderId is not found
+ *
+ * @example
+ * // 平仓做多订单
+ * const result = await sdk.simulator.simulateLongClose(
+ *   'HG9R8CE9N18U8zYqo6cqS4bFaCAzHbAhaAe1zq8Hq7PF',
+ *   1090  // order_id
+ * );
+ * console.log('候选索引:', result.closeOrderIndices);
+ * // 输出: { closeOrderIndices: [25, 15, 35, 5, 45, ...] }
+ */
+async function simulateLongClose(mint, closeOrderId, ordersData = null) {
+  // 1. 获取 down_orders 数据（做多订单在 down_orders 中）
+  if (!ordersData) {
+    ordersData = await this.sdk.data.orders(mint, { type: 'down_orders' });
+  }
+
+  if (!ordersData || !ordersData.success || !ordersData.data || !ordersData.data.orders) {
+    throw new Error('Failed to fetch down_orders data');
+  }
+
+  const orders = ordersData.data.orders;
+
+  // 2. 将 closeOrderId 转换为字符串（因为 API 返回的 order_id 是字符串）
+  const targetOrderId = closeOrderId.toString();
+
+  // 3. 在订单列表中查找匹配的订单
+  let targetOrderIndex = -1;
+  for (let i = 0; i < orders.length; i++) {
+    if (orders[i].order_id === targetOrderId) {
+      targetOrderIndex = i;
+      break;
+    }
+  }
+
+  // 4. 如果找不到订单，抛出错误
+  if (targetOrderIndex === -1) {
+    throw new Error(`Order with order_id ${targetOrderId} not found in down_orders`);
+  }
+
+  // 5. 获取目标订单的 OrderBook index
+  const targetOrder = orders[targetOrderIndex];
+  const mainIndex = targetOrder.index;
+
+  // 6. 生成候选索引数组（通过链表结构遍历前后节点）
+  const indices = [];
+
+  // 添加主位置
+  indices.push(mainIndex);
+
+  // 通过链表结构添加前后节点的索引
+  let prevNode = targetOrder;
+  let nextNode = targetOrder;
+
+  for (let offset = 1; offset <= CANDIDATE_NODES_EACH_SIDE; offset++) {
+    // 添加前面第 offset 个节点（通过 prev_order 链表指针）
+    if (prevNode.prev_order !== NO_ORDER) {
+      const prevOrder = findOrderByIndex(orders, prevNode.prev_order);
+      if (prevOrder && prevOrder.index !== undefined) {
+        indices.push(prevOrder.index);
+        prevNode = prevOrder; // 继续向前遍历
+      } else {
+        prevNode = { prev_order: NO_ORDER }; // 找不到则停止
+      }
+    }
+
+    // 添加后面第 offset 个节点（通过 next_order 链表指针）
+    if (nextNode.next_order !== NO_ORDER) {
+      const nextOrder = findOrderByIndex(orders, nextNode.next_order);
+      if (nextOrder && nextOrder.index !== undefined) {
+        indices.push(nextOrder.index);
+        nextNode = nextOrder; // 继续向后遍历
+      } else {
+        nextNode = { next_order: NO_ORDER }; // 找不到则停止
+      }
+    }
+  }
+
+  // 7. 返回结果
+  return {
+    closeOrderIndices: indices
+  };
+}
+
+/**
+ * 为做空平仓生成候选插入索引
+ * Generate candidate insertion indices for closing short position
+ *
+ * @param {string} mint - 代币地址 / Token address
+ * @param {number|string|anchor.BN} closeOrderId - 要平仓的订单ID (order_id, 不是 index) / Order ID to close (order_id, not index)
+ * @param {Object|null} ordersData - 订单数据（可选，如果不提供会自动获取）/ Orders data (optional, will fetch if not provided)
+ * @returns {Promise<Object>} 返回包含候选索引数组的对象 / Returns object containing candidate indices array
+ *   - closeOrderIndices: {number[]} 候选插入位置索引数组 / Candidate insertion position indices array
+ *
+ * @throws {Error} 如果找不到对应的 closeOrderId / If closeOrderId is not found
+ *
+ * @example
+ * // 平仓做空订单
+ * const result = await sdk.simulator.simulateShortClose(
+ *   'HG9R8CE9N18U8zYqo6cqS4bFaCAzHbAhaAe1zq8Hq7PF',
+ *   1090  // order_id
+ * );
+ * console.log('候选索引:', result.closeOrderIndices);
+ * // 输出: { closeOrderIndices: [25, 15, 35, 5, 45, ...] }
+ */
+async function simulateShortClose(mint, closeOrderId, ordersData = null) {
+  // 1. 获取 up_orders 数据（做空订单在 up_orders 中）
+  if (!ordersData) {
+    ordersData = await this.sdk.data.orders(mint, { type: 'up_orders' });
+  }
+
+  if (!ordersData || !ordersData.success || !ordersData.data || !ordersData.data.orders) {
+    throw new Error('Failed to fetch up_orders data');
+  }
+
+  const orders = ordersData.data.orders;
+
+  // 2. 将 closeOrderId 转换为字符串（因为 API 返回的 order_id 是字符串）
+  const targetOrderId = closeOrderId.toString();
+
+  // 3. 在订单列表中查找匹配的订单
+  let targetOrderIndex = -1;
+  for (let i = 0; i < orders.length; i++) {
+    if (orders[i].order_id === targetOrderId) {
+      targetOrderIndex = i;
+      break;
+    }
+  }
+
+  // 4. 如果找不到订单，抛出错误
+  if (targetOrderIndex === -1) {
+    throw new Error(`Order with order_id ${targetOrderId} not found in up_orders`);
+  }
+
+  // 5. 获取目标订单的 OrderBook index
+  const targetOrder = orders[targetOrderIndex];
+  const mainIndex = targetOrder.index;
+
+  // 6. 生成候选索引数组（通过链表结构遍历前后节点）
+  const indices = [];
+
+  // 添加主位置
+  indices.push(mainIndex);
+
+  // 通过链表结构添加前后节点的索引
+  let prevNode = targetOrder;
+  let nextNode = targetOrder;
+
+  for (let offset = 1; offset <= CANDIDATE_NODES_EACH_SIDE; offset++) {
+    // 添加前面第 offset 个节点（通过 prev_order 链表指针）
+    if (prevNode.prev_order !== NO_ORDER) {
+      const prevOrder = findOrderByIndex(orders, prevNode.prev_order);
+      if (prevOrder && prevOrder.index !== undefined) {
+        indices.push(prevOrder.index);
+        prevNode = prevOrder; // 继续向前遍历
+      } else {
+        prevNode = { prev_order: NO_ORDER }; // 找不到则停止
+      }
+    }
+
+    // 添加后面第 offset 个节点（通过 next_order 链表指针）
+    if (nextNode.next_order !== NO_ORDER) {
+      const nextOrder = findOrderByIndex(orders, nextNode.next_order);
+      if (nextOrder && nextOrder.index !== undefined) {
+        indices.push(nextOrder.index);
+        nextNode = nextOrder; // 继续向后遍历
+      } else {
+        nextNode = { next_order: NO_ORDER }; // 找不到则停止
+      }
+    }
+  }
+
+  // 7. 返回结果
+  return {
+    closeOrderIndices: indices
+  };
+}
+
+module.exports = {
+  simulateLongClose,
+  simulateShortClose
+};