@orderly.network/perp 4.8.9-alpha.0 → 4.8.10-alpha.0

package/dist/index.js

@@ -31,9 +31,9 @@ module.exports = __toCommonJS(src_exports);
 // src/version.ts
 if (typeof window !== "undefined") {
   window.__ORDERLY_VERSION__ = window.__ORDERLY_VERSION__ || {};
-  window.__ORDERLY_VERSION__["@orderly.network/perp"] = "4.8.9-alpha.0";
+  window.__ORDERLY_VERSION__["@orderly.network/perp"] = "4.8.10-alpha.0";
 }
-var version_default = "4.8.9-alpha.0";
+var version_default = "4.8.10-alpha.0";
 
 // src/positions.ts
 var positions_exports = {};
@@ -56,14 +56,34 @@ __export(positions_exports, {
   unrealizedPnLROI: () => unrealizedPnLROI,
   unsettlementPnL: () => unsettlementPnL
 });
-var import_utils = require("@orderly.network/utils");
+var import_utils2 = require("@orderly.network/utils");
 
 // src/constants.ts
 var IMRFactorPower = 4 / 5;
 
+// src/utils.ts
+var import_utils = require("@orderly.network/utils");
+var DMax = (...values) => {
+  if (values.length === 0) {
+    throw new Error("DMax requires at least one argument");
+  }
+  const decimals = values.map(
+    (val) => val instanceof import_utils.Decimal ? val : new import_utils.Decimal(val)
+  );
+  let max = decimals[0];
+  for (let i = 1; i < decimals.length; i++) {
+    if (decimals[i].gte(max)) {
+      max = decimals[i];
+    }
+  }
+  return max;
+};
+
 // src/positions.ts
+var MaxIterates = 30;
+var CONVERGENCE_THRESHOLD = 1e-4;
 function notional(qty, mark_price) {
-  return new import_utils.Decimal(qty).mul(mark_price).abs().toNumber();
+  return new import_utils2.Decimal(qty).mul(mark_price).abs().toNumber();
 }
 function totalNotional(positions) {
   return positions.reduce((acc, cur) => {
@@ -71,13 +91,13 @@ function totalNotional(positions) {
   }, 0);
 }
 function unrealizedPnL(inputs) {
-  return new import_utils.Decimal(inputs.qty).mul(inputs.markPrice - inputs.openPrice).toNumber();
+  return new import_utils2.Decimal(inputs.qty).mul(inputs.markPrice - inputs.openPrice).toNumber();
 }
 function unrealizedPnLROI(inputs) {
   const { openPrice, IMR: IMR2 } = inputs;
   if (inputs.unrealizedPnL === 0 || inputs.positionQty === 0 || openPrice === 0 || IMR2 === 0)
     return 0;
-  return new import_utils.Decimal(inputs.unrealizedPnL).div(new import_utils.Decimal(Math.abs(inputs.positionQty)).mul(openPrice).mul(IMR2)).toNumber();
+  return new import_utils2.Decimal(inputs.unrealizedPnL).div(new import_utils2.Decimal(Math.abs(inputs.positionQty)).mul(openPrice).mul(IMR2)).toNumber();
 }
 function totalUnrealizedPnL(positions) {
   return positions.reduce((acc, cur) => {
@@ -88,26 +108,147 @@ function totalUnrealizedPnL(positions) {
     });
   }, 0);
 }
-function liqPrice(inputs) {
-  const { markPrice, totalCollateral: totalCollateral2, positions, positionQty, MMR: MMR3 } = inputs;
+var mmForOtherSymbols = (positions) => {
+  return positions.reduce((acc, cur) => {
+    return acc.add(
+      new import_utils2.Decimal(cur.position_qty).abs().mul(cur.mark_price).mul(cur.mmr)
+    );
+  }, import_utils2.zero);
+};
+var calculateLiqPrice = (markPrice, positionQty, MMR3, totalCollateral2, positions) => {
+  const decimalMarkPrice = new import_utils2.Decimal(markPrice);
+  const absQty = new import_utils2.Decimal(positionQty).abs();
+  const denominator = absQty.mul(MMR3).sub(positionQty);
+  const liqPrice2 = new import_utils2.Decimal(totalCollateral2).sub(absQty.mul(decimalMarkPrice).mul(MMR3)).sub(mmForOtherSymbols(positions)).div(denominator).add(decimalMarkPrice);
+  return DMax(liqPrice2, import_utils2.zero);
+};
+var compareCollateralWithMM = (inputs) => {
+  return (price) => {
+    const {
+      totalCollateral: totalCollateral2,
+      positionQty,
+      markPrice,
+      baseMMR,
+      baseIMR,
+      IMRFactor,
+      positions
+    } = inputs;
+    const decimalPositionQty = new import_utils2.Decimal(positionQty);
+    const collateral = new import_utils2.Decimal(totalCollateral2).sub(decimalPositionQty.mul(markPrice)).add(decimalPositionQty.mul(price));
+    const mm = decimalPositionQty.abs().mul(price).mul(
+      Math.max(
+        baseMMR,
+        new import_utils2.Decimal(baseMMR).div(baseIMR).mul(IMRFactor).mul(decimalPositionQty.mul(price).abs().toPower(IMRFactorPower)).toNumber()
+      )
+    ).add(mmForOtherSymbols(positions));
+    return collateral.gte(mm);
+  };
+};
+var liqPrice = (inputs) => {
+  const {
+    positionQty,
+    markPrice,
+    totalCollateral: totalCollateral2,
+    positions,
+    MMR: MMR3,
+    baseMMR,
+    baseIMR,
+    IMRFactor,
+    symbol
+  } = inputs;
   if (positionQty === 0 || totalCollateral2 === 0) {
     return null;
   }
-  const totalNotional2 = positions.reduce((acc, cur) => {
-    return acc.add(
-      new import_utils.Decimal(notional(cur.position_qty, cur.mark_price)).mul(cur.mmr)
+  const isLONG = positionQty > 0;
+  const otherPositions = positions.filter((item) => item.symbol !== symbol);
+  if (isLONG) {
+    let liqPriceLeft = calculateLiqPrice(
+      markPrice,
+      positionQty,
+      baseMMR,
+      totalCollateral2,
+      otherPositions
     );
-  }, import_utils.zero);
-  return Math.max(
-    new import_utils.Decimal(markPrice).add(
-      new import_utils.Decimal(totalCollateral2).sub(totalNotional2).div(new import_utils.Decimal(positionQty).abs().mul(MMR3).sub(positionQty))
-    ).toNumber(),
-    0
-  );
-}
+    let liqPriceRight = calculateLiqPrice(
+      markPrice,
+      positionQty,
+      MMR3,
+      totalCollateral2,
+      otherPositions
+    );
+    const compareCollateralWithMMFunc = compareCollateralWithMM({
+      totalCollateral: totalCollateral2,
+      positionQty,
+      markPrice,
+      baseIMR,
+      baseMMR,
+      IMRFactor,
+      positions: otherPositions
+    });
+    for (let i = 0; i < MaxIterates; i++) {
+      if (liqPriceLeft.gte(liqPriceRight)) {
+        return liqPriceRight.toNumber();
+      }
+      const mid = new import_utils2.Decimal(liqPriceLeft).add(liqPriceRight).div(2);
+      if (compareCollateralWithMMFunc(mid)) {
+        liqPriceRight = mid;
+      } else {
+        liqPriceLeft = mid;
+      }
+      if (liqPriceRight.sub(liqPriceLeft).div(liqPriceLeft.add(liqPriceRight)).mul(2).lte(CONVERGENCE_THRESHOLD)) {
+        break;
+      }
+    }
+    return liqPriceRight.toNumber();
+  } else {
+    let liqPriceRight = calculateLiqPrice(
+      markPrice,
+      positionQty,
+      MMR3,
+      totalCollateral2,
+      otherPositions
+    );
+    let liqPriceLeft = calculateLiqPrice(
+      markPrice,
+      positionQty,
+      Math.max(
+        baseIMR,
+        new import_utils2.Decimal(baseMMR).div(baseIMR).mul(IMRFactor).mul(
+          new import_utils2.Decimal(positionQty).mul(liqPriceRight).abs().toPower(IMRFactorPower)
+        ).toNumber()
+      ),
+      totalCollateral2,
+      otherPositions
+    );
+    const compareCollateralWithMMFunc = compareCollateralWithMM({
+      totalCollateral: totalCollateral2,
+      positionQty,
+      markPrice,
+      baseMMR,
+      baseIMR,
+      IMRFactor,
+      positions: otherPositions
+    });
+    for (let i = 0; i < MaxIterates; i++) {
+      if (liqPriceLeft.gte(liqPriceRight)) {
+        return liqPriceLeft.toNumber();
+      }
+      const mid = liqPriceLeft.add(liqPriceRight).div(2);
+      if (compareCollateralWithMMFunc(mid)) {
+        liqPriceLeft = mid;
+      } else {
+        liqPriceRight = mid;
+      }
+      if (liqPriceRight.sub(liqPriceLeft).div(liqPriceLeft.add(liqPriceRight)).mul(2).lte(CONVERGENCE_THRESHOLD)) {
+        break;
+      }
+    }
+    return liqPriceLeft.toNumber();
+  }
+};
 function maintenanceMargin(inputs) {
   const { positionQty, markPrice, MMR: MMR3 } = inputs;
-  return new import_utils.Decimal(positionQty).mul(markPrice).mul(MMR3).abs().toNumber();
+  return new import_utils2.Decimal(positionQty).mul(markPrice).mul(MMR3).abs().toNumber();
 }
 function unsettlementPnL(inputs) {
   const {
@@ -117,8 +258,8 @@ function unsettlementPnL(inputs) {
     sumUnitaryFunding,
     lastSumUnitaryFunding
   } = inputs;
-  const qty = new import_utils.Decimal(positionQty);
-  return qty.mul(markPrice).sub(costPosition).sub(qty.mul(new import_utils.Decimal(sumUnitaryFunding).sub(lastSumUnitaryFunding))).toNumber();
+  const qty = new import_utils2.Decimal(positionQty);
+  return qty.mul(markPrice).sub(costPosition).sub(qty.mul(new import_utils2.Decimal(sumUnitaryFunding).sub(lastSumUnitaryFunding))).toNumber();
 }
 function totalUnsettlementPnL(positions) {
   if (!Array.isArray(positions) || positions.length === 0) {
@@ -144,31 +285,31 @@ function MMR(inputs) {
   } = inputs;
   return Math.max(
     baseMMR,
-    new import_utils.Decimal(baseMMR).div(baseIMR).mul(IMRFactor).mul(Math.pow(Math.abs(positionNotional), IMR_factor_power)).toNumber()
+    new import_utils2.Decimal(baseMMR).div(baseIMR).mul(IMRFactor).mul(Math.pow(Math.abs(positionNotional), IMR_factor_power)).toNumber()
   );
 }
 function estPnLForTP(inputs) {
-  return new import_utils.Decimal(inputs.positionQty).mul(new import_utils.Decimal(inputs.price).sub(inputs.entryPrice)).toNumber();
+  return new import_utils2.Decimal(inputs.positionQty).mul(new import_utils2.Decimal(inputs.price).sub(inputs.entryPrice)).toNumber();
 }
 function estPriceForTP(inputs) {
-  return new import_utils.Decimal(inputs.pnl).add(inputs.entryPrice).div(inputs.positionQty).toNumber();
+  return new import_utils2.Decimal(inputs.pnl).div(inputs.positionQty).add(inputs.entryPrice).toNumber();
 }
 function estOffsetForTP(inputs) {
-  return new import_utils.Decimal(inputs.price).div(inputs.entryPrice).toNumber();
+  return new import_utils2.Decimal(inputs.price).div(inputs.entryPrice).toNumber();
 }
 function estPriceFromOffsetForTP(inputs) {
-  return new import_utils.Decimal(inputs.offset).add(inputs.entryPrice).toNumber();
+  return new import_utils2.Decimal(inputs.offset).add(inputs.entryPrice).toNumber();
 }
 function estPnLForSL(inputs) {
   return 0;
 }
 function maxPositionNotional(inputs) {
   const { leverage, IMRFactor } = inputs;
-  return new import_utils.Decimal(1).div(new import_utils.Decimal(leverage).mul(IMRFactor)).pow(1 / 0.8).toNumber();
+  return new import_utils2.Decimal(1).div(new import_utils2.Decimal(leverage).mul(IMRFactor)).pow(1 / 0.8).toNumber();
 }
 function maxPositionLeverage(inputs) {
   const { IMRFactor, notional: notional2 } = inputs;
-  return new import_utils.Decimal(1).div(new import_utils.Decimal(IMRFactor).mul(new import_utils.Decimal(notional2).pow(0.8))).toNumber();
+  return new import_utils2.Decimal(1).div(new import_utils2.Decimal(IMRFactor).mul(new import_utils2.Decimal(notional2).pow(0.8))).toNumber();
 }
 
 // src/account.ts
@@ -208,35 +349,35 @@ __export(account_exports, {
   totalValue: () => totalValue
 });
 var import_types = require("@orderly.network/types");
-var import_utils2 = require("@orderly.network/utils");
+var import_utils4 = require("@orderly.network/utils");
 function totalValue(inputs) {
   const { totalUnsettlementPnL: totalUnsettlementPnL2, USDCHolding, nonUSDCHolding } = inputs;
   const nonUSDCHoldingValue = nonUSDCHolding.reduce((acc, cur) => {
-    return new import_utils2.Decimal(cur.holding).mul(cur.indexPrice).add(acc);
-  }, import_utils2.zero);
+    return new import_utils4.Decimal(cur.holding).mul(cur.indexPrice).add(acc);
+  }, import_utils4.zero);
   return nonUSDCHoldingValue.add(USDCHolding).add(totalUnsettlementPnL2);
 }
 function freeCollateral(inputs) {
   const value = inputs.totalCollateral.sub(inputs.totalInitialMarginWithOrders);
-  return value.isNegative() ? import_utils2.zero : value;
+  return value.isNegative() ? import_utils4.zero : value;
 }
 function totalCollateral(inputs) {
   const { USDCHolding, nonUSDCHolding, unsettlementPnL: unsettlementPnL2 } = inputs;
   const nonUSDCHoldingValue = nonUSDCHolding.reduce((acc, cur) => {
     const finalHolding = Math.min(cur.holding, cur.collateralCap);
-    const value = new import_utils2.Decimal(finalHolding).mul(cur.collateralRatio).mul(cur.indexPrice);
+    const value = new import_utils4.Decimal(finalHolding).mul(cur.collateralRatio).mul(cur.indexPrice);
     return acc.add(value);
-  }, import_utils2.zero);
-  return new import_utils2.Decimal(USDCHolding).add(nonUSDCHoldingValue).add(unsettlementPnL2);
+  }, import_utils4.zero);
+  return new import_utils4.Decimal(USDCHolding).add(nonUSDCHoldingValue).add(unsettlementPnL2);
 }
 function initialMarginWithOrder() {
 }
 function positionNotionalWithOrder_by_symbol(inputs) {
-  return new import_utils2.Decimal(inputs.markPrice).mul(inputs.positionQtyWithOrders);
+  return new import_utils4.Decimal(inputs.markPrice).mul(inputs.positionQtyWithOrders);
 }
 function positionQtyWithOrders_by_symbol(inputs) {
   const { positionQty, buyOrdersQty, sellOrdersQty } = inputs;
-  const positionQtyDecimal = new import_utils2.Decimal(positionQty);
+  const positionQtyDecimal = new import_utils4.Decimal(positionQty);
   const qty = Math.max(
     positionQtyDecimal.add(buyOrdersQty).abs().toNumber(),
     positionQtyDecimal.sub(sellOrdersQty).abs().toNumber()
@@ -255,8 +396,8 @@ function IMR(inputs) {
   return Math.max(
     1 / maxLeverage2,
     baseIMR,
-    new import_utils2.Decimal(IMR_Factor).mul(
-      new import_utils2.Decimal(positionNotional).add(orderNotional).abs().toPower(IMR_factor_power)
+    new import_utils4.Decimal(IMR_Factor).mul(
+      new import_utils4.Decimal(positionNotional).add(orderNotional).abs().toPower(IMR_factor_power)
     ).toNumber()
   );
 }
@@ -288,8 +429,8 @@ function getPositonsAndOrdersNotionalBySymbol(inputs) {
   const positionQty = getQtyFromPositions(positions, symbol);
   const buyOrdersQty = getQtyFromOrdersBySide(orders, symbol, import_types.OrderSide.BUY);
   const sellOrdersQty = getQtyFromOrdersBySide(orders, symbol, import_types.OrderSide.SELL);
-  const markPriceDecimal = new import_utils2.Decimal(markPrice);
-  return markPriceDecimal.mul(positionQty).add(markPriceDecimal.mul(new import_utils2.Decimal(buyOrdersQty).add(sellOrdersQty))).abs().toNumber();
+  const markPriceDecimal = new import_utils4.Decimal(markPrice);
+  return markPriceDecimal.mul(positionQty).add(markPriceDecimal.mul(new import_utils4.Decimal(buyOrdersQty).add(sellOrdersQty))).abs().toNumber();
 }
 function totalInitialMarginWithOrders(inputs) {
   const {
@@ -320,10 +461,10 @@ function totalInitialMarginWithOrders(inputs) {
       markPrice,
       positionQtyWithOrders
     });
-    const markPriceDecimal = new import_utils2.Decimal(markPrice);
+    const markPriceDecimal = new import_utils4.Decimal(markPrice);
     const imr = IMR({
       positionNotional: markPriceDecimal.mul(positionQty).toNumber(),
-      ordersNotional: markPriceDecimal.mul(new import_utils2.Decimal(buyOrdersQty).add(sellOrdersQty)).toNumber(),
+      ordersNotional: markPriceDecimal.mul(new import_utils4.Decimal(buyOrdersQty).add(sellOrdersQty)).toNumber(),
       maxLeverage: maxLeverage2,
       IMR_Factor: IMR_Factors[symbol],
       baseIMR: symbolInfo[symbol]("base_imr", 0)
@@ -352,10 +493,10 @@ function totalInitialMarginWithQty(inputs) {
       markPrice,
       positionQtyWithOrders
     });
-    const markPriceDecimal = new import_utils2.Decimal(markPrice);
+    const markPriceDecimal = new import_utils4.Decimal(markPrice);
     const imr = IMR({
       positionNotional: markPriceDecimal.mul(positionQty).toNumber(),
-      ordersNotional: markPriceDecimal.mul(new import_utils2.Decimal(buyOrdersQty).add(sellOrdersQty)).toNumber(),
+      ordersNotional: markPriceDecimal.mul(new import_utils4.Decimal(buyOrdersQty).add(sellOrdersQty)).toNumber(),
       maxLeverage: maxLeverage({
         symbolLeverage: (_a = position == null ? void 0 : position.leverage) != null ? _a : inputs.maxLeverage,
         accountLeverage: inputs.maxLeverage
@@ -402,13 +543,13 @@ function otherIMs(inputs) {
       console.warn("markPrices[%s] is undefined", symbol);
       return acc;
     }
-    const markPriceDecimal = new import_utils2.Decimal(markPrices[symbol] || 0);
+    const markPriceDecimal = new import_utils4.Decimal(markPrices[symbol] || 0);
     const position = positions.find((item) => item.symbol === symbol);
     const positionQty = getQtyFromPositions(positions, symbol);
     const positionNotional = markPriceDecimal.mul(positionQty).toNumber();
     const buyOrdersQty = position.pending_long_qty;
     const sellOrdersQty = position.pending_short_qty;
-    const ordersNotional = markPriceDecimal.mul(new import_utils2.Decimal(buyOrdersQty).add(sellOrdersQty)).toNumber();
+    const ordersNotional = markPriceDecimal.mul(new import_utils4.Decimal(buyOrdersQty).add(sellOrdersQty)).toNumber();
     const IMR_Factor = IMR_Factors[symbol];
     if (typeof IMR_Factor === "undefined") {
       console.warn("IMR_Factor is not found:", symbol);
@@ -434,7 +575,7 @@ function otherIMs(inputs) {
       positionQtyWithOrders
     });
     return acc.add(positionNotionalWithOrders.mul(imr));
-  }, import_utils2.zero).toNumber();
+  }, import_utils4.zero).toNumber();
 }
 function maxQty(side, inputs, options) {
   if (side === import_types.OrderSide.BUY) {
@@ -459,10 +600,10 @@ function maxQtyByLong(inputs, options) {
     if (totalCollateral2 === 0) {
       return 0;
     }
-    const totalCollateralDecimal = new import_utils2.Decimal(totalCollateral2);
+    const totalCollateralDecimal = new import_utils4.Decimal(totalCollateral2);
     const factor_1 = totalCollateralDecimal.sub(otherIMs2).div(
-      new import_utils2.Decimal(takerFeeRate).mul(2).mul(1e-4).add(Math.max(1 / maxLeverage2, baseIMR))
-    ).div(markPrice).mul(0.995).sub(new import_utils2.Decimal(positionQty).add(buyOrdersQty)).toNumber();
+      new import_utils4.Decimal(takerFeeRate).mul(2).mul(1e-4).add(Math.max(1 / maxLeverage2, baseIMR))
+    ).div(markPrice).mul(0.995).sub(new import_utils4.Decimal(positionQty).add(buyOrdersQty)).toNumber();
     if (positionQty === 0 && buyOrdersQty === 0) {
       return Math.min(baseMaxQty, factor_1);
     }
@@ -470,10 +611,10 @@ function maxQtyByLong(inputs, options) {
       return Math.min(baseMaxQty, factor_1);
     }
     const factor_2 = totalCollateralDecimal.sub(otherIMs2).div(IMR_Factor).toPower(1 / 1.8).div(markPrice).sub(
-      new import_utils2.Decimal(positionQty).add(buyOrdersQty)
+      new import_utils4.Decimal(positionQty).add(buyOrdersQty)
       // .abs()
       // .div(new Decimal(takerFeeRate).mul(2).mul(0.0001).add(1))
-    ).div(new import_utils2.Decimal(takerFeeRate).mul(2).mul(1e-4).add(1)).mul(0.995).toNumber();
+    ).div(new import_utils4.Decimal(takerFeeRate).mul(2).mul(1e-4).add(1)).mul(0.995).toNumber();
     return Math.min(baseMaxQty, factor_1, factor_2);
   } catch (error) {
     return 0;
@@ -494,9 +635,9 @@ function maxQtyByShort(inputs, options) {
       sellOrdersQty,
       takerFeeRate
     } = inputs;
-    const totalCollateralDecimal = new import_utils2.Decimal(totalCollateral2);
+    const totalCollateralDecimal = new import_utils4.Decimal(totalCollateral2);
     const factor_1 = totalCollateralDecimal.sub(otherIMs2).div(
-      new import_utils2.Decimal(takerFeeRate).mul(2).mul(1e-4).add(Math.max(1 / maxLeverage2, baseIMR))
+      new import_utils4.Decimal(takerFeeRate).mul(2).mul(1e-4).add(Math.max(1 / maxLeverage2, baseIMR))
     ).div(markPrice).mul(0.995).add(positionQty).sub(Math.abs(sellOrdersQty)).toNumber();
     if (positionQty === 0 && sellOrdersQty === 0) {
       return Math.min(baseMaxQty, factor_1);
@@ -504,7 +645,7 @@ function maxQtyByShort(inputs, options) {
     if (IMR_Factor === 0) {
       return Math.min(baseMaxQty, factor_1);
     }
-    const factor_2 = totalCollateralDecimal.sub(otherIMs2).div(IMR_Factor).toPower(1 / 1.8).div(markPrice).add(positionQty).sub(sellOrdersQty).div(new import_utils2.Decimal(takerFeeRate).mul(2).mul(1e-4).add(1)).mul(0.995).toNumber();
+    const factor_2 = totalCollateralDecimal.sub(otherIMs2).div(IMR_Factor).toPower(1 / 1.8).div(markPrice).add(positionQty).sub(sellOrdersQty).div(new import_utils4.Decimal(takerFeeRate).mul(2).mul(1e-4).add(1)).mul(0.995).toNumber();
     return Math.min(baseMaxQty, factor_1, factor_2);
   } catch (error) {
     return 0;
@@ -515,19 +656,19 @@ function totalMarginRatio(inputs, dp) {
   if (totalCollateral2 === 0) {
     return 0;
   }
-  const totalCollateralDecimal = new import_utils2.Decimal(totalCollateral2);
+  const totalCollateralDecimal = new import_utils4.Decimal(totalCollateral2);
   const totalPositionNotional = positions.reduce((acc, cur) => {
     const markPrice = markPrices[cur.symbol] || 0;
-    return acc.add(new import_utils2.Decimal(cur.position_qty).mul(markPrice).abs());
-  }, import_utils2.zero);
-  if (totalPositionNotional.eq(import_utils2.zero)) {
+    return acc.add(new import_utils4.Decimal(cur.position_qty).mul(markPrice).abs());
+  }, import_utils4.zero);
+  if (totalPositionNotional.eq(import_utils4.zero)) {
     return 0;
   }
   return totalCollateralDecimal.div(totalPositionNotional).toNumber();
 }
 function totalUnrealizedROI(inputs) {
   const { totalUnrealizedPnL: totalUnrealizedPnL2, totalValue: totalValue2 } = inputs;
-  return new import_utils2.Decimal(totalUnrealizedPnL2).div(totalValue2 - totalUnrealizedPnL2).toNumber();
+  return new import_utils4.Decimal(totalUnrealizedPnL2).div(totalValue2 - totalUnrealizedPnL2).toNumber();
 }
 function currentLeverage(totalMarginRatio2) {
   if (totalMarginRatio2 === 0) {
@@ -537,7 +678,7 @@ function currentLeverage(totalMarginRatio2) {
 }
 function availableBalance(inputs) {
   const { USDCHolding, unsettlementPnL: unsettlementPnL2 } = inputs;
-  return new import_utils2.Decimal(USDCHolding).add(unsettlementPnL2).toNumber();
+  return new import_utils4.Decimal(USDCHolding).add(unsettlementPnL2).toNumber();
 }
 function MMR2(inputs) {
   if (inputs.positionsNotional === 0) {
@@ -546,7 +687,7 @@ function MMR2(inputs) {
   if (inputs.positionsMMR === 0) {
     return null;
   }
-  return new import_utils2.Decimal(inputs.positionsMMR).div(inputs.positionsNotional).toNumber();
+  return new import_utils4.Decimal(inputs.positionsMMR).div(inputs.positionsNotional).toNumber();
 }
 var collateralRatio = (params) => {
   const {
@@ -557,30 +698,30 @@ var collateralRatio = (params) => {
     indexPrice
   } = params;
   const cap = collateralCap === -1 ? collateralQty : collateralCap;
-  const K = new import_utils2.Decimal(1.2);
-  const DCF = new import_utils2.Decimal(discountFactor || 0);
-  const qty = new import_utils2.Decimal(Math.min(collateralQty, cap));
+  const K = new import_utils4.Decimal(1.2);
+  const DCF = new import_utils4.Decimal(discountFactor || 0);
+  const qty = new import_utils4.Decimal(Math.min(collateralQty, cap));
   const notionalAbs = qty.mul(indexPrice).abs();
   const dynamicWeight = DCF.mul(notionalAbs.toPower(IMRFactorPower));
-  const result = K.div(new import_utils2.Decimal(1).add(dynamicWeight));
-  return result.lt(baseWeight) ? result : new import_utils2.Decimal(baseWeight);
+  const result = K.div(new import_utils4.Decimal(1).add(dynamicWeight));
+  return result.lt(baseWeight) ? result : new import_utils4.Decimal(baseWeight);
 };
 var collateralContribution = (params) => {
   const { collateralQty, collateralCap, collateralRatio: collateralRatio2, indexPrice } = params;
   const cap = collateralCap === -1 ? collateralQty : collateralCap;
-  return new import_utils2.Decimal(Math.min(collateralQty, cap)).mul(collateralRatio2).mul(indexPrice).toNumber();
+  return new import_utils4.Decimal(Math.min(collateralQty, cap)).mul(collateralRatio2).mul(indexPrice).toNumber();
 };
 var LTV = (params) => {
   const { usdcBalance, upnl, assets } = params;
-  const usdcLoss = new import_utils2.Decimal(Math.min(usdcBalance, 0)).abs();
-  const upnlLoss = new import_utils2.Decimal(Math.min(upnl, 0)).abs();
+  const usdcLoss = new import_utils4.Decimal(Math.min(usdcBalance, 0)).abs();
+  const upnlLoss = new import_utils4.Decimal(Math.min(upnl, 0)).abs();
   const numerator = usdcLoss.add(upnlLoss);
   const collateralSum = assets.reduce((acc, asset) => {
     return acc.add(
-      new import_utils2.Decimal(Math.max(asset.qty, 0)).mul(new import_utils2.Decimal(asset.indexPrice)).mul(new import_utils2.Decimal(asset.weight))
+      new import_utils4.Decimal(Math.max(asset.qty, 0)).mul(new import_utils4.Decimal(asset.indexPrice)).mul(new import_utils4.Decimal(asset.weight))
     );
-  }, import_utils2.zero);
-  const denominator = collateralSum.add(new import_utils2.Decimal(Math.max(upnl, 0)));
+  }, import_utils4.zero);
+  const denominator = collateralSum.add(new import_utils4.Decimal(Math.max(upnl, 0)));
   if (numerator.isZero() || denominator.isZero()) {
     return 0;
   }
@@ -589,26 +730,26 @@ var LTV = (params) => {
 var maxWithdrawalUSDC = (inputs) => {
   const { USDCBalance, freeCollateral: freeCollateral2, upnl } = inputs;
   const value = Math.min(
-    new import_utils2.Decimal(USDCBalance).toNumber(),
-    new import_utils2.Decimal(freeCollateral2).sub(Math.max(upnl, 0)).toNumber()
+    new import_utils4.Decimal(USDCBalance).toNumber(),
+    new import_utils4.Decimal(freeCollateral2).sub(Math.max(upnl, 0)).toNumber()
   );
   return Math.max(0, value);
 };
 var maxWithdrawalOtherCollateral = (inputs) => {
   const { USDCBalance, collateralQty, freeCollateral: freeCollateral2, indexPrice, weight } = inputs;
-  const usdcBalance = new import_utils2.Decimal(USDCBalance);
-  const denominator = usdcBalance.isNegative() ? new import_utils2.Decimal(indexPrice).mul(weight).mul(new import_utils2.Decimal(1).add(2e-3)) : new import_utils2.Decimal(indexPrice).mul(weight);
+  const usdcBalance = new import_utils4.Decimal(USDCBalance);
+  const denominator = usdcBalance.isNegative() ? new import_utils4.Decimal(indexPrice).mul(weight).mul(new import_utils4.Decimal(1).add(2e-3)) : new import_utils4.Decimal(indexPrice).mul(weight);
   if (denominator.isZero()) {
-    return import_utils2.zero;
+    return import_utils4.zero;
   }
-  const qty = new import_utils2.Decimal(collateralQty);
-  const maxQtyByValue = new import_utils2.Decimal(freeCollateral2).div(denominator);
+  const qty = new import_utils4.Decimal(collateralQty);
+  const maxQtyByValue = new import_utils4.Decimal(freeCollateral2).div(denominator);
   return maxQtyByValue.lt(qty) ? maxQtyByValue : qty;
 };
 var calcMinimumReceived = (inputs) => {
   const { amount, slippage } = inputs;
-  const slippageRatio = new import_utils2.Decimal(slippage).div(100);
-  return new import_utils2.Decimal(amount).mul(new import_utils2.Decimal(1).minus(slippageRatio)).toNumber();
+  const slippageRatio = new import_utils4.Decimal(slippage).div(100);
+  return new import_utils4.Decimal(amount).mul(new import_utils4.Decimal(1).minus(slippageRatio)).toNumber();
 };
 var maxLeverage = (inputs) => {
   const { symbolLeverage, accountLeverage } = inputs;
@@ -626,7 +767,7 @@ __export(order_exports, {
   scopePrice: () => scopePrice,
   tpslROI: () => tpslROI
 });
-var import_utils3 = require("@orderly.network/utils");
+var import_utils5 = require("@orderly.network/utils");
 function maxPrice(markprice, range) {
   return markprice * (1 + range);
 }
@@ -640,7 +781,7 @@ function scopePrice(price, scope, side) {
   return price * (1 + scope);
 }
 function orderFee(inputs) {
-  return new import_utils3.Decimal(inputs.qty).mul(inputs.price).mul(inputs.futuresTakeFeeRate).toNumber();
+  return new import_utils5.Decimal(inputs.qty).mul(inputs.price).mul(inputs.futuresTakeFeeRate).toNumber();
 }
 function estLiqPrice(inputs) {
   var _a;
@@ -655,13 +796,13 @@ function estLiqPrice(inputs) {
     IMR_Factor
   } = inputs;
   let currentPosition = void 0;
-  let newTotalMM = import_utils3.zero;
+  let newTotalMM = import_utils5.zero;
   const hasPosition = positions.filter((item) => item.position_qty > 0).length > 0;
   const basePrice = hasPosition ? markPrice : newOrder.price;
-  const newOrderNotional = new import_utils3.Decimal(newOrder.qty).mul(newOrder.price);
+  const newOrderNotional = new import_utils5.Decimal(newOrder.qty).mul(newOrder.price);
   for (let index = 0; index < positions.length; index++) {
     const position = positions[index];
-    let notional2 = new import_utils3.Decimal(position.position_qty).mul(position.mark_price);
+    let notional2 = new import_utils5.Decimal(position.position_qty).mul(position.mark_price);
     if (newOrder.symbol === position.symbol) {
       currentPosition = position;
       notional2 = notional2.add(newOrderNotional);
@@ -673,26 +814,26 @@ function estLiqPrice(inputs) {
   }
   const newMMR = Math.max(
     baseMMR,
-    new import_utils3.Decimal(baseMMR).div(baseIMR).mul(IMR_Factor).mul(
+    new import_utils5.Decimal(baseMMR).div(baseIMR).mul(IMR_Factor).mul(
       newOrderNotional.add(
-        !!currentPosition ? new import_utils3.Decimal(currentPosition.position_qty).mul(
+        !!currentPosition ? new import_utils5.Decimal(currentPosition.position_qty).mul(
           currentPosition.mark_price
-        ) : import_utils3.zero
+        ) : import_utils5.zero
       ).abs()
     ).toPower(4 / 5).toNumber()
   );
-  const newQty = new import_utils3.Decimal(newOrder.qty).add(
+  const newQty = new import_utils5.Decimal(newOrder.qty).add(
     (_a = currentPosition == null ? void 0 : currentPosition.position_qty) != null ? _a : 0
   );
   if (newQty.eq(0)) {
     return 0;
   }
   const denominator = newQty.abs().mul(newMMR).sub(newQty);
-  if (denominator.eq(import_utils3.zero)) {
+  if (denominator.eq(import_utils5.zero)) {
     return 0;
   }
-  const price = new import_utils3.Decimal(basePrice).add(
-    new import_utils3.Decimal(totalCollateral2).sub(newTotalMM).sub(orderFee2).div(denominator)
+  const price = new import_utils5.Decimal(basePrice).add(
+    new import_utils5.Decimal(totalCollateral2).sub(newTotalMM).sub(orderFee2).div(denominator)
   ).toNumber();
   return Math.max(0, price);
 }
@@ -703,35 +844,35 @@ function estLeverage(inputs) {
   }
   let hasPosition = false;
   let sumPositionNotional = positions.reduce((acc, cur) => {
-    let count = new import_utils3.Decimal(cur.position_qty).mul(cur.mark_price);
+    let count = new import_utils5.Decimal(cur.position_qty).mul(cur.mark_price);
     if (cur.symbol === newOrder.symbol) {
       hasPosition = true;
-      count = count.add(new import_utils3.Decimal(newOrder.qty).mul(newOrder.price));
+      count = count.add(new import_utils5.Decimal(newOrder.qty).mul(newOrder.price));
     }
     return acc.add(count.abs());
-  }, import_utils3.zero);
+  }, import_utils5.zero);
   if (!hasPosition) {
     sumPositionNotional = sumPositionNotional.add(
-      new import_utils3.Decimal(newOrder.qty).mul(newOrder.price).abs()
+      new import_utils5.Decimal(newOrder.qty).mul(newOrder.price).abs()
     );
   }
-  if (sumPositionNotional.eq(import_utils3.zero)) {
+  if (sumPositionNotional.eq(import_utils5.zero)) {
     return null;
   }
-  const totalMarginRatio2 = new import_utils3.Decimal(totalCollateral2).div(
+  const totalMarginRatio2 = new import_utils5.Decimal(totalCollateral2).div(
     sumPositionNotional
   );
-  return new import_utils3.Decimal(1).div(totalMarginRatio2).toDecimalPlaces(2, import_utils3.Decimal.ROUND_HALF_EVEN).toNumber();
+  return new import_utils5.Decimal(1).div(totalMarginRatio2).toDecimalPlaces(2, import_utils5.Decimal.ROUND_HALF_EVEN).toNumber();
 }
 function tpslROI(inputs) {
-  const direction = (0, import_utils3.getTPSLDirection)({
+  const direction = (0, import_utils5.getTPSLDirection)({
     side: inputs.side,
     type: inputs.type,
     closePrice: inputs.closePrice,
     orderPrice: inputs.orderPrice
   });
   const { closePrice, orderPrice, leverage } = inputs;
-  return new import_utils3.Decimal(closePrice).minus(orderPrice).div(orderPrice).mul(leverage).abs().mul(direction).toNumber();
+  return new import_utils5.Decimal(closePrice).minus(orderPrice).div(orderPrice).mul(leverage).abs().mul(direction).toNumber();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {