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

package/dist/index.mjs

@@ -7,9 +7,9 @@ var __export = (target, all) => {
 // src/version.ts
 if (typeof window !== "undefined") {
   window.__ORDERLY_VERSION__ = window.__ORDERLY_VERSION__ || {};
-  window.__ORDERLY_VERSION__["@orderly.network/perp"] = "4.8.9";
+  window.__ORDERLY_VERSION__["@orderly.network/perp"] = "4.8.10-alpha.0";
 }
-var version_default = "4.8.9";
+var version_default = "4.8.10-alpha.0";
 
 // src/positions.ts
 var positions_exports = {};
@@ -32,14 +32,34 @@ __export(positions_exports, {
   unrealizedPnLROI: () => unrealizedPnLROI,
   unsettlementPnL: () => unsettlementPnL
 });
-import { Decimal, zero } from "@orderly.network/utils";
+import { Decimal as Decimal2, zero } from "@orderly.network/utils";
 
 // src/constants.ts
 var IMRFactorPower = 4 / 5;
 
+// src/utils.ts
+import { Decimal } from "@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 Decimal ? val : new 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 Decimal(qty).mul(mark_price).abs().toNumber();
+  return new Decimal2(qty).mul(mark_price).abs().toNumber();
 }
 function totalNotional(positions) {
   return positions.reduce((acc, cur) => {
@@ -47,13 +67,13 @@ function totalNotional(positions) {
   }, 0);
 }
 function unrealizedPnL(inputs) {
-  return new Decimal(inputs.qty).mul(inputs.markPrice - inputs.openPrice).toNumber();
+  return new Decimal2(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 Decimal(inputs.unrealizedPnL).div(new Decimal(Math.abs(inputs.positionQty)).mul(openPrice).mul(IMR2)).toNumber();
+  return new Decimal2(inputs.unrealizedPnL).div(new Decimal2(Math.abs(inputs.positionQty)).mul(openPrice).mul(IMR2)).toNumber();
 }
 function totalUnrealizedPnL(positions) {
   return positions.reduce((acc, cur) => {
@@ -64,26 +84,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 Decimal2(cur.position_qty).abs().mul(cur.mark_price).mul(cur.mmr)
+    );
+  }, zero);
+};
+var calculateLiqPrice = (markPrice, positionQty, MMR3, totalCollateral2, positions) => {
+  const decimalMarkPrice = new Decimal2(markPrice);
+  const absQty = new Decimal2(positionQty).abs();
+  const denominator = absQty.mul(MMR3).sub(positionQty);
+  const liqPrice2 = new Decimal2(totalCollateral2).sub(absQty.mul(decimalMarkPrice).mul(MMR3)).sub(mmForOtherSymbols(positions)).div(denominator).add(decimalMarkPrice);
+  return DMax(liqPrice2, zero);
+};
+var compareCollateralWithMM = (inputs) => {
+  return (price) => {
+    const {
+      totalCollateral: totalCollateral2,
+      positionQty,
+      markPrice,
+      baseMMR,
+      baseIMR,
+      IMRFactor,
+      positions
+    } = inputs;
+    const decimalPositionQty = new Decimal2(positionQty);
+    const collateral = new Decimal2(totalCollateral2).sub(decimalPositionQty.mul(markPrice)).add(decimalPositionQty.mul(price));
+    const mm = decimalPositionQty.abs().mul(price).mul(
+      Math.max(
+        baseMMR,
+        new Decimal2(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 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
     );
-  }, zero);
-  return Math.max(
-    new Decimal(markPrice).add(
-      new Decimal(totalCollateral2).sub(totalNotional2).div(new 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 Decimal2(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 Decimal2(baseMMR).div(baseIMR).mul(IMRFactor).mul(
+          new Decimal2(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 Decimal(positionQty).mul(markPrice).mul(MMR3).abs().toNumber();
+  return new Decimal2(positionQty).mul(markPrice).mul(MMR3).abs().toNumber();
 }
 function unsettlementPnL(inputs) {
   const {
@@ -93,8 +234,8 @@ function unsettlementPnL(inputs) {
     sumUnitaryFunding,
     lastSumUnitaryFunding
   } = inputs;
-  const qty = new Decimal(positionQty);
-  return qty.mul(markPrice).sub(costPosition).sub(qty.mul(new Decimal(sumUnitaryFunding).sub(lastSumUnitaryFunding))).toNumber();
+  const qty = new Decimal2(positionQty);
+  return qty.mul(markPrice).sub(costPosition).sub(qty.mul(new Decimal2(sumUnitaryFunding).sub(lastSumUnitaryFunding))).toNumber();
 }
 function totalUnsettlementPnL(positions) {
   if (!Array.isArray(positions) || positions.length === 0) {
@@ -120,31 +261,31 @@ function MMR(inputs) {
   } = inputs;
   return Math.max(
     baseMMR,
-    new Decimal(baseMMR).div(baseIMR).mul(IMRFactor).mul(Math.pow(Math.abs(positionNotional), IMR_factor_power)).toNumber()
+    new Decimal2(baseMMR).div(baseIMR).mul(IMRFactor).mul(Math.pow(Math.abs(positionNotional), IMR_factor_power)).toNumber()
   );
 }
 function estPnLForTP(inputs) {
-  return new Decimal(inputs.positionQty).mul(new Decimal(inputs.price).sub(inputs.entryPrice)).toNumber();
+  return new Decimal2(inputs.positionQty).mul(new Decimal2(inputs.price).sub(inputs.entryPrice)).toNumber();
 }
 function estPriceForTP(inputs) {
-  return new Decimal(inputs.pnl).add(inputs.entryPrice).div(inputs.positionQty).toNumber();
+  return new Decimal2(inputs.pnl).div(inputs.positionQty).add(inputs.entryPrice).toNumber();
 }
 function estOffsetForTP(inputs) {
-  return new Decimal(inputs.price).div(inputs.entryPrice).toNumber();
+  return new Decimal2(inputs.price).div(inputs.entryPrice).toNumber();
 }
 function estPriceFromOffsetForTP(inputs) {
-  return new Decimal(inputs.offset).add(inputs.entryPrice).toNumber();
+  return new Decimal2(inputs.offset).add(inputs.entryPrice).toNumber();
 }
 function estPnLForSL(inputs) {
   return 0;
 }
 function maxPositionNotional(inputs) {
   const { leverage, IMRFactor } = inputs;
-  return new Decimal(1).div(new Decimal(leverage).mul(IMRFactor)).pow(1 / 0.8).toNumber();
+  return new Decimal2(1).div(new Decimal2(leverage).mul(IMRFactor)).pow(1 / 0.8).toNumber();
 }
 function maxPositionLeverage(inputs) {
   const { IMRFactor, notional: notional2 } = inputs;
-  return new Decimal(1).div(new Decimal(IMRFactor).mul(new Decimal(notional2).pow(0.8))).toNumber();
+  return new Decimal2(1).div(new Decimal2(IMRFactor).mul(new Decimal2(notional2).pow(0.8))).toNumber();
 }
 
 // src/account.ts
@@ -184,11 +325,11 @@ __export(account_exports, {
   totalValue: () => totalValue
 });
 import { OrderSide } from "@orderly.network/types";
-import { Decimal as Decimal2, zero as zero2 } from "@orderly.network/utils";
+import { Decimal as Decimal3, zero as zero2 } from "@orderly.network/utils";
 function totalValue(inputs) {
   const { totalUnsettlementPnL: totalUnsettlementPnL2, USDCHolding, nonUSDCHolding } = inputs;
   const nonUSDCHoldingValue = nonUSDCHolding.reduce((acc, cur) => {
-    return new Decimal2(cur.holding).mul(cur.indexPrice).add(acc);
+    return new Decimal3(cur.holding).mul(cur.indexPrice).add(acc);
   }, zero2);
   return nonUSDCHoldingValue.add(USDCHolding).add(totalUnsettlementPnL2);
 }
@@ -200,19 +341,19 @@ 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 Decimal2(finalHolding).mul(cur.collateralRatio).mul(cur.indexPrice);
+    const value = new Decimal3(finalHolding).mul(cur.collateralRatio).mul(cur.indexPrice);
     return acc.add(value);
   }, zero2);
-  return new Decimal2(USDCHolding).add(nonUSDCHoldingValue).add(unsettlementPnL2);
+  return new Decimal3(USDCHolding).add(nonUSDCHoldingValue).add(unsettlementPnL2);
 }
 function initialMarginWithOrder() {
 }
 function positionNotionalWithOrder_by_symbol(inputs) {
-  return new Decimal2(inputs.markPrice).mul(inputs.positionQtyWithOrders);
+  return new Decimal3(inputs.markPrice).mul(inputs.positionQtyWithOrders);
 }
 function positionQtyWithOrders_by_symbol(inputs) {
   const { positionQty, buyOrdersQty, sellOrdersQty } = inputs;
-  const positionQtyDecimal = new Decimal2(positionQty);
+  const positionQtyDecimal = new Decimal3(positionQty);
   const qty = Math.max(
     positionQtyDecimal.add(buyOrdersQty).abs().toNumber(),
     positionQtyDecimal.sub(sellOrdersQty).abs().toNumber()
@@ -231,8 +372,8 @@ function IMR(inputs) {
   return Math.max(
     1 / maxLeverage2,
     baseIMR,
-    new Decimal2(IMR_Factor).mul(
-      new Decimal2(positionNotional).add(orderNotional).abs().toPower(IMR_factor_power)
+    new Decimal3(IMR_Factor).mul(
+      new Decimal3(positionNotional).add(orderNotional).abs().toPower(IMR_factor_power)
     ).toNumber()
   );
 }
@@ -264,8 +405,8 @@ function getPositonsAndOrdersNotionalBySymbol(inputs) {
   const positionQty = getQtyFromPositions(positions, symbol);
   const buyOrdersQty = getQtyFromOrdersBySide(orders, symbol, OrderSide.BUY);
   const sellOrdersQty = getQtyFromOrdersBySide(orders, symbol, OrderSide.SELL);
-  const markPriceDecimal = new Decimal2(markPrice);
-  return markPriceDecimal.mul(positionQty).add(markPriceDecimal.mul(new Decimal2(buyOrdersQty).add(sellOrdersQty))).abs().toNumber();
+  const markPriceDecimal = new Decimal3(markPrice);
+  return markPriceDecimal.mul(positionQty).add(markPriceDecimal.mul(new Decimal3(buyOrdersQty).add(sellOrdersQty))).abs().toNumber();
 }
 function totalInitialMarginWithOrders(inputs) {
   const {
@@ -296,10 +437,10 @@ function totalInitialMarginWithOrders(inputs) {
       markPrice,
       positionQtyWithOrders
     });
-    const markPriceDecimal = new Decimal2(markPrice);
+    const markPriceDecimal = new Decimal3(markPrice);
     const imr = IMR({
       positionNotional: markPriceDecimal.mul(positionQty).toNumber(),
-      ordersNotional: markPriceDecimal.mul(new Decimal2(buyOrdersQty).add(sellOrdersQty)).toNumber(),
+      ordersNotional: markPriceDecimal.mul(new Decimal3(buyOrdersQty).add(sellOrdersQty)).toNumber(),
       maxLeverage: maxLeverage2,
       IMR_Factor: IMR_Factors[symbol],
       baseIMR: symbolInfo[symbol]("base_imr", 0)
@@ -328,10 +469,10 @@ function totalInitialMarginWithQty(inputs) {
       markPrice,
       positionQtyWithOrders
     });
-    const markPriceDecimal = new Decimal2(markPrice);
+    const markPriceDecimal = new Decimal3(markPrice);
     const imr = IMR({
       positionNotional: markPriceDecimal.mul(positionQty).toNumber(),
-      ordersNotional: markPriceDecimal.mul(new Decimal2(buyOrdersQty).add(sellOrdersQty)).toNumber(),
+      ordersNotional: markPriceDecimal.mul(new Decimal3(buyOrdersQty).add(sellOrdersQty)).toNumber(),
       maxLeverage: maxLeverage({
         symbolLeverage: (_a = position == null ? void 0 : position.leverage) != null ? _a : inputs.maxLeverage,
         accountLeverage: inputs.maxLeverage
@@ -378,13 +519,13 @@ function otherIMs(inputs) {
       console.warn("markPrices[%s] is undefined", symbol);
       return acc;
     }
-    const markPriceDecimal = new Decimal2(markPrices[symbol] || 0);
+    const markPriceDecimal = new Decimal3(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 Decimal2(buyOrdersQty).add(sellOrdersQty)).toNumber();
+    const ordersNotional = markPriceDecimal.mul(new Decimal3(buyOrdersQty).add(sellOrdersQty)).toNumber();
     const IMR_Factor = IMR_Factors[symbol];
     if (typeof IMR_Factor === "undefined") {
       console.warn("IMR_Factor is not found:", symbol);
@@ -435,10 +576,10 @@ function maxQtyByLong(inputs, options) {
     if (totalCollateral2 === 0) {
       return 0;
     }
-    const totalCollateralDecimal = new Decimal2(totalCollateral2);
+    const totalCollateralDecimal = new Decimal3(totalCollateral2);
     const factor_1 = totalCollateralDecimal.sub(otherIMs2).div(
-      new Decimal2(takerFeeRate).mul(2).mul(1e-4).add(Math.max(1 / maxLeverage2, baseIMR))
-    ).div(markPrice).mul(0.995).sub(new Decimal2(positionQty).add(buyOrdersQty)).toNumber();
+      new Decimal3(takerFeeRate).mul(2).mul(1e-4).add(Math.max(1 / maxLeverage2, baseIMR))
+    ).div(markPrice).mul(0.995).sub(new Decimal3(positionQty).add(buyOrdersQty)).toNumber();
     if (positionQty === 0 && buyOrdersQty === 0) {
       return Math.min(baseMaxQty, factor_1);
     }
@@ -446,10 +587,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 Decimal2(positionQty).add(buyOrdersQty)
+      new Decimal3(positionQty).add(buyOrdersQty)
       // .abs()
       // .div(new Decimal(takerFeeRate).mul(2).mul(0.0001).add(1))
-    ).div(new Decimal2(takerFeeRate).mul(2).mul(1e-4).add(1)).mul(0.995).toNumber();
+    ).div(new Decimal3(takerFeeRate).mul(2).mul(1e-4).add(1)).mul(0.995).toNumber();
     return Math.min(baseMaxQty, factor_1, factor_2);
   } catch (error) {
     return 0;
@@ -470,9 +611,9 @@ function maxQtyByShort(inputs, options) {
       sellOrdersQty,
       takerFeeRate
     } = inputs;
-    const totalCollateralDecimal = new Decimal2(totalCollateral2);
+    const totalCollateralDecimal = new Decimal3(totalCollateral2);
     const factor_1 = totalCollateralDecimal.sub(otherIMs2).div(
-      new Decimal2(takerFeeRate).mul(2).mul(1e-4).add(Math.max(1 / maxLeverage2, baseIMR))
+      new Decimal3(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);
@@ -480,7 +621,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 Decimal2(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 Decimal3(takerFeeRate).mul(2).mul(1e-4).add(1)).mul(0.995).toNumber();
     return Math.min(baseMaxQty, factor_1, factor_2);
   } catch (error) {
     return 0;
@@ -491,10 +632,10 @@ function totalMarginRatio(inputs, dp) {
   if (totalCollateral2 === 0) {
     return 0;
   }
-  const totalCollateralDecimal = new Decimal2(totalCollateral2);
+  const totalCollateralDecimal = new Decimal3(totalCollateral2);
   const totalPositionNotional = positions.reduce((acc, cur) => {
     const markPrice = markPrices[cur.symbol] || 0;
-    return acc.add(new Decimal2(cur.position_qty).mul(markPrice).abs());
+    return acc.add(new Decimal3(cur.position_qty).mul(markPrice).abs());
   }, zero2);
   if (totalPositionNotional.eq(zero2)) {
     return 0;
@@ -503,7 +644,7 @@ function totalMarginRatio(inputs, dp) {
 }
 function totalUnrealizedROI(inputs) {
   const { totalUnrealizedPnL: totalUnrealizedPnL2, totalValue: totalValue2 } = inputs;
-  return new Decimal2(totalUnrealizedPnL2).div(totalValue2 - totalUnrealizedPnL2).toNumber();
+  return new Decimal3(totalUnrealizedPnL2).div(totalValue2 - totalUnrealizedPnL2).toNumber();
 }
 function currentLeverage(totalMarginRatio2) {
   if (totalMarginRatio2 === 0) {
@@ -513,7 +654,7 @@ function currentLeverage(totalMarginRatio2) {
 }
 function availableBalance(inputs) {
   const { USDCHolding, unsettlementPnL: unsettlementPnL2 } = inputs;
-  return new Decimal2(USDCHolding).add(unsettlementPnL2).toNumber();
+  return new Decimal3(USDCHolding).add(unsettlementPnL2).toNumber();
 }
 function MMR2(inputs) {
   if (inputs.positionsNotional === 0) {
@@ -522,7 +663,7 @@ function MMR2(inputs) {
   if (inputs.positionsMMR === 0) {
     return null;
   }
-  return new Decimal2(inputs.positionsMMR).div(inputs.positionsNotional).toNumber();
+  return new Decimal3(inputs.positionsMMR).div(inputs.positionsNotional).toNumber();
 }
 var collateralRatio = (params) => {
   const {
@@ -533,30 +674,30 @@ var collateralRatio = (params) => {
     indexPrice
   } = params;
   const cap = collateralCap === -1 ? collateralQty : collateralCap;
-  const K = new Decimal2(1.2);
-  const DCF = new Decimal2(discountFactor || 0);
-  const qty = new Decimal2(Math.min(collateralQty, cap));
+  const K = new Decimal3(1.2);
+  const DCF = new Decimal3(discountFactor || 0);
+  const qty = new Decimal3(Math.min(collateralQty, cap));
   const notionalAbs = qty.mul(indexPrice).abs();
   const dynamicWeight = DCF.mul(notionalAbs.toPower(IMRFactorPower));
-  const result = K.div(new Decimal2(1).add(dynamicWeight));
-  return result.lt(baseWeight) ? result : new Decimal2(baseWeight);
+  const result = K.div(new Decimal3(1).add(dynamicWeight));
+  return result.lt(baseWeight) ? result : new Decimal3(baseWeight);
 };
 var collateralContribution = (params) => {
   const { collateralQty, collateralCap, collateralRatio: collateralRatio2, indexPrice } = params;
   const cap = collateralCap === -1 ? collateralQty : collateralCap;
-  return new Decimal2(Math.min(collateralQty, cap)).mul(collateralRatio2).mul(indexPrice).toNumber();
+  return new Decimal3(Math.min(collateralQty, cap)).mul(collateralRatio2).mul(indexPrice).toNumber();
 };
 var LTV = (params) => {
   const { usdcBalance, upnl, assets } = params;
-  const usdcLoss = new Decimal2(Math.min(usdcBalance, 0)).abs();
-  const upnlLoss = new Decimal2(Math.min(upnl, 0)).abs();
+  const usdcLoss = new Decimal3(Math.min(usdcBalance, 0)).abs();
+  const upnlLoss = new Decimal3(Math.min(upnl, 0)).abs();
   const numerator = usdcLoss.add(upnlLoss);
   const collateralSum = assets.reduce((acc, asset) => {
     return acc.add(
-      new Decimal2(Math.max(asset.qty, 0)).mul(new Decimal2(asset.indexPrice)).mul(new Decimal2(asset.weight))
+      new Decimal3(Math.max(asset.qty, 0)).mul(new Decimal3(asset.indexPrice)).mul(new Decimal3(asset.weight))
     );
   }, zero2);
-  const denominator = collateralSum.add(new Decimal2(Math.max(upnl, 0)));
+  const denominator = collateralSum.add(new Decimal3(Math.max(upnl, 0)));
   if (numerator.isZero() || denominator.isZero()) {
     return 0;
   }
@@ -565,26 +706,26 @@ var LTV = (params) => {
 var maxWithdrawalUSDC = (inputs) => {
   const { USDCBalance, freeCollateral: freeCollateral2, upnl } = inputs;
   const value = Math.min(
-    new Decimal2(USDCBalance).toNumber(),
-    new Decimal2(freeCollateral2).sub(Math.max(upnl, 0)).toNumber()
+    new Decimal3(USDCBalance).toNumber(),
+    new Decimal3(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 Decimal2(USDCBalance);
-  const denominator = usdcBalance.isNegative() ? new Decimal2(indexPrice).mul(weight).mul(new Decimal2(1).add(2e-3)) : new Decimal2(indexPrice).mul(weight);
+  const usdcBalance = new Decimal3(USDCBalance);
+  const denominator = usdcBalance.isNegative() ? new Decimal3(indexPrice).mul(weight).mul(new Decimal3(1).add(2e-3)) : new Decimal3(indexPrice).mul(weight);
   if (denominator.isZero()) {
     return zero2;
   }
-  const qty = new Decimal2(collateralQty);
-  const maxQtyByValue = new Decimal2(freeCollateral2).div(denominator);
+  const qty = new Decimal3(collateralQty);
+  const maxQtyByValue = new Decimal3(freeCollateral2).div(denominator);
   return maxQtyByValue.lt(qty) ? maxQtyByValue : qty;
 };
 var calcMinimumReceived = (inputs) => {
   const { amount, slippage } = inputs;
-  const slippageRatio = new Decimal2(slippage).div(100);
-  return new Decimal2(amount).mul(new Decimal2(1).minus(slippageRatio)).toNumber();
+  const slippageRatio = new Decimal3(slippage).div(100);
+  return new Decimal3(amount).mul(new Decimal3(1).minus(slippageRatio)).toNumber();
 };
 var maxLeverage = (inputs) => {
   const { symbolLeverage, accountLeverage } = inputs;
@@ -602,7 +743,7 @@ __export(order_exports, {
   scopePrice: () => scopePrice,
   tpslROI: () => tpslROI
 });
-import { Decimal as Decimal3, getTPSLDirection, zero as zero3 } from "@orderly.network/utils";
+import { Decimal as Decimal4, getTPSLDirection, zero as zero3 } from "@orderly.network/utils";
 function maxPrice(markprice, range) {
   return markprice * (1 + range);
 }
@@ -616,7 +757,7 @@ function scopePrice(price, scope, side) {
   return price * (1 + scope);
 }
 function orderFee(inputs) {
-  return new Decimal3(inputs.qty).mul(inputs.price).mul(inputs.futuresTakeFeeRate).toNumber();
+  return new Decimal4(inputs.qty).mul(inputs.price).mul(inputs.futuresTakeFeeRate).toNumber();
 }
 function estLiqPrice(inputs) {
   var _a;
@@ -634,10 +775,10 @@ function estLiqPrice(inputs) {
   let newTotalMM = zero3;
   const hasPosition = positions.filter((item) => item.position_qty > 0).length > 0;
   const basePrice = hasPosition ? markPrice : newOrder.price;
-  const newOrderNotional = new Decimal3(newOrder.qty).mul(newOrder.price);
+  const newOrderNotional = new Decimal4(newOrder.qty).mul(newOrder.price);
   for (let index = 0; index < positions.length; index++) {
     const position = positions[index];
-    let notional2 = new Decimal3(position.position_qty).mul(position.mark_price);
+    let notional2 = new Decimal4(position.position_qty).mul(position.mark_price);
     if (newOrder.symbol === position.symbol) {
       currentPosition = position;
       notional2 = notional2.add(newOrderNotional);
@@ -649,15 +790,15 @@ function estLiqPrice(inputs) {
   }
   const newMMR = Math.max(
     baseMMR,
-    new Decimal3(baseMMR).div(baseIMR).mul(IMR_Factor).mul(
+    new Decimal4(baseMMR).div(baseIMR).mul(IMR_Factor).mul(
       newOrderNotional.add(
-        !!currentPosition ? new Decimal3(currentPosition.position_qty).mul(
+        !!currentPosition ? new Decimal4(currentPosition.position_qty).mul(
           currentPosition.mark_price
         ) : zero3
       ).abs()
     ).toPower(4 / 5).toNumber()
   );
-  const newQty = new Decimal3(newOrder.qty).add(
+  const newQty = new Decimal4(newOrder.qty).add(
     (_a = currentPosition == null ? void 0 : currentPosition.position_qty) != null ? _a : 0
   );
   if (newQty.eq(0)) {
@@ -667,8 +808,8 @@ function estLiqPrice(inputs) {
   if (denominator.eq(zero3)) {
     return 0;
   }
-  const price = new Decimal3(basePrice).add(
-    new Decimal3(totalCollateral2).sub(newTotalMM).sub(orderFee2).div(denominator)
+  const price = new Decimal4(basePrice).add(
+    new Decimal4(totalCollateral2).sub(newTotalMM).sub(orderFee2).div(denominator)
   ).toNumber();
   return Math.max(0, price);
 }
@@ -679,25 +820,25 @@ function estLeverage(inputs) {
   }
   let hasPosition = false;
   let sumPositionNotional = positions.reduce((acc, cur) => {
-    let count = new Decimal3(cur.position_qty).mul(cur.mark_price);
+    let count = new Decimal4(cur.position_qty).mul(cur.mark_price);
     if (cur.symbol === newOrder.symbol) {
       hasPosition = true;
-      count = count.add(new Decimal3(newOrder.qty).mul(newOrder.price));
+      count = count.add(new Decimal4(newOrder.qty).mul(newOrder.price));
     }
     return acc.add(count.abs());
   }, zero3);
   if (!hasPosition) {
     sumPositionNotional = sumPositionNotional.add(
-      new Decimal3(newOrder.qty).mul(newOrder.price).abs()
+      new Decimal4(newOrder.qty).mul(newOrder.price).abs()
     );
   }
   if (sumPositionNotional.eq(zero3)) {
     return null;
   }
-  const totalMarginRatio2 = new Decimal3(totalCollateral2).div(
+  const totalMarginRatio2 = new Decimal4(totalCollateral2).div(
     sumPositionNotional
   );
-  return new Decimal3(1).div(totalMarginRatio2).toDecimalPlaces(2, Decimal3.ROUND_HALF_EVEN).toNumber();
+  return new Decimal4(1).div(totalMarginRatio2).toDecimalPlaces(2, Decimal4.ROUND_HALF_EVEN).toNumber();
 }
 function tpslROI(inputs) {
   const direction = getTPSLDirection({
@@ -707,7 +848,7 @@ function tpslROI(inputs) {
     orderPrice: inputs.orderPrice
   });
   const { closePrice, orderPrice, leverage } = inputs;
-  return new Decimal3(closePrice).minus(orderPrice).div(orderPrice).mul(leverage).abs().mul(direction).toNumber();
+  return new Decimal4(closePrice).minus(orderPrice).div(orderPrice).mul(leverage).abs().mul(direction).toNumber();
 }
 export {
   account_exports as account,