@orderly.network/perp 4.10.2 → 4.11.0

package/dist/index.js

@@ -1,41 +1,22 @@
-"use strict";
+'use strict';
+
+var utils = require('@orderly.network/utils');
+var types = require('@orderly.network/types');
+
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  account: () => account_exports,
-  order: () => order_exports,
-  orderUtils: () => order_exports,
-  positions: () => positions_exports,
-  version: () => version_default
-});
-module.exports = __toCommonJS(index_exports);
 
 // src/version.ts
 if (typeof window !== "undefined") {
   window.__ORDERLY_VERSION__ = window.__ORDERLY_VERSION__ || {};
-  window.__ORDERLY_VERSION__["@orderly.network/perp"] = "4.10.2";
+  window.__ORDERLY_VERSION__["@orderly.network/perp"] = "4.11.0";
 }
-var version_default = "4.10.2";
+var version_default = "4.11.0";
 
-// src/positions.ts
+// src/positions/index.ts
 var positions_exports = {};
 __export(positions_exports, {
   MMR: () => MMR,
@@ -45,6 +26,7 @@ __export(positions_exports, {
   estPriceForTP: () => estPriceForTP,
   estPriceFromOffsetForTP: () => estPriceFromOffsetForTP,
   liqPrice: () => liqPrice,
+  liquidationPriceIsolated: () => liquidationPriceIsolated,
   maintenanceMargin: () => maintenanceMargin,
   maxPositionLeverage: () => maxPositionLeverage,
   maxPositionNotional: () => maxPositionNotional,
@@ -56,34 +38,8 @@ __export(positions_exports, {
   unrealizedPnLROI: () => unrealizedPnLROI,
   unsettlementPnL: () => unsettlementPnL
 });
-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_utils2.Decimal(qty).mul(mark_price).abs().toNumber();
+  return new utils.Decimal(qty).mul(mark_price).abs().toNumber();
 }
 function totalNotional(positions) {
   return positions.reduce((acc, cur) => {
@@ -91,13 +47,13 @@ function totalNotional(positions) {
   }, 0);
 }
 function unrealizedPnL(inputs) {
-  return new import_utils2.Decimal(inputs.qty).mul(inputs.markPrice - inputs.openPrice).toNumber();
+  return new utils.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)
+  const { openPrice, IMR: IMR4 } = inputs;
+  if (inputs.unrealizedPnL === 0 || inputs.positionQty === 0 || openPrice === 0 || IMR4 === 0)
     return 0;
-  return new import_utils2.Decimal(inputs.unrealizedPnL).div(new import_utils2.Decimal(Math.abs(inputs.positionQty)).mul(openPrice).mul(IMR2)).toNumber();
+  return new utils.Decimal(inputs.unrealizedPnL).div(new utils.Decimal(Math.abs(inputs.positionQty)).mul(openPrice).mul(IMR4)).toNumber();
 }
 function totalUnrealizedPnL(positions) {
   return positions.reduce((acc, cur) => {
@@ -108,19 +64,41 @@ function totalUnrealizedPnL(positions) {
     });
   }, 0);
 }
+
+// src/constants.ts
+var IMRFactorPower = 4 / 5;
+var DMax = (...values) => {
+  if (values.length === 0) {
+    throw new Error("DMax requires at least one argument");
+  }
+  const decimals = values.map(
+    (val) => val instanceof utils.Decimal ? val : new 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/liqPrice.ts
+var MaxIterates = 30;
+var CONVERGENCE_THRESHOLD = 1e-4;
 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)
+      new utils.Decimal(cur.position_qty).abs().mul(cur.mark_price).mul(cur.mmr)
     );
-  }, import_utils2.zero);
+  }, utils.zero);
 };
 var calculateLiqPrice = (markPrice, positionQty, MMR3, totalCollateral2, positions) => {
-  const decimalMarkPrice = new import_utils2.Decimal(markPrice);
-  const absQty = new import_utils2.Decimal(positionQty).abs();
+  const decimalMarkPrice = new utils.Decimal(markPrice);
+  const absQty = new utils.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);
+  const liqPrice2 = new utils.Decimal(totalCollateral2).sub(absQty.mul(decimalMarkPrice).mul(MMR3)).sub(mmForOtherSymbols(positions)).div(denominator).add(decimalMarkPrice);
+  return DMax(liqPrice2, utils.zero);
 };
 var compareCollateralWithMM = (inputs) => {
   return (price) => {
@@ -133,18 +111,18 @@ var compareCollateralWithMM = (inputs) => {
       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 decimalPositionQty = new utils.Decimal(positionQty);
+    const collateral = new utils.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()
+        new utils.Decimal(baseMMR).div(baseIMR).mul(IMRFactor).mul(decimalPositionQty.mul(price).abs().toPower(IMRFactorPower)).toNumber()
       )
     ).add(mmForOtherSymbols(positions));
     return collateral.gte(mm);
   };
 };
-var liqPrice = (inputs) => {
+function liqPrice(inputs) {
   const {
     positionQty,
     markPrice,
@@ -189,7 +167,7 @@ var liqPrice = (inputs) => {
       if (liqPriceLeft.gte(liqPriceRight)) {
         return liqPriceRight.toNumber();
       }
-      const mid = new import_utils2.Decimal(liqPriceLeft).add(liqPriceRight).div(2);
+      const mid = new utils.Decimal(liqPriceLeft).add(liqPriceRight).div(2);
       if (compareCollateralWithMMFunc(mid)) {
         liqPriceRight = mid;
       } else {
@@ -213,8 +191,8 @@ var liqPrice = (inputs) => {
       positionQty,
       Math.max(
         baseIMR,
-        new import_utils2.Decimal(baseMMR).div(baseIMR).mul(IMRFactor).mul(
-          new import_utils2.Decimal(positionQty).mul(liqPriceRight).abs().toPower(IMRFactorPower)
+        new utils.Decimal(baseMMR).div(baseIMR).mul(IMRFactor).mul(
+          new utils.Decimal(positionQty).mul(liqPriceRight).abs().toPower(IMRFactorPower)
         ).toNumber()
       ),
       totalCollateral2,
@@ -245,10 +223,10 @@ var liqPrice = (inputs) => {
     }
     return liqPriceLeft.toNumber();
   }
-};
+}
 function maintenanceMargin(inputs) {
   const { positionQty, markPrice, MMR: MMR3 } = inputs;
-  return new import_utils2.Decimal(positionQty).mul(markPrice).mul(MMR3).abs().toNumber();
+  return new utils.Decimal(positionQty).mul(markPrice).mul(MMR3).abs().toNumber();
 }
 function unsettlementPnL(inputs) {
   const {
@@ -258,8 +236,8 @@ function unsettlementPnL(inputs) {
     sumUnitaryFunding,
     lastSumUnitaryFunding
   } = inputs;
-  const qty = new import_utils2.Decimal(positionQty);
-  return qty.mul(markPrice).sub(costPosition).sub(qty.mul(new import_utils2.Decimal(sumUnitaryFunding).sub(lastSumUnitaryFunding))).toNumber();
+  const qty = new utils.Decimal(positionQty);
+  return qty.mul(markPrice).sub(costPosition).sub(qty.mul(new utils.Decimal(sumUnitaryFunding).sub(lastSumUnitaryFunding))).toNumber();
 }
 function totalUnsettlementPnL(positions) {
   if (!Array.isArray(positions) || positions.length === 0) {
@@ -285,56 +263,127 @@ function MMR(inputs) {
   } = inputs;
   return Math.max(
     baseMMR,
-    new import_utils2.Decimal(baseMMR).div(baseIMR).mul(IMRFactor).mul(Math.pow(Math.abs(positionNotional), IMR_factor_power)).toNumber()
+    new utils.Decimal(baseMMR).div(baseIMR).mul(IMRFactor).mul(Math.pow(Math.abs(positionNotional), IMR_factor_power)).toNumber()
   );
 }
 function estPnLForTP(inputs) {
-  return new import_utils2.Decimal(inputs.positionQty).mul(new import_utils2.Decimal(inputs.price).sub(inputs.entryPrice)).toNumber();
+  return new utils.Decimal(inputs.positionQty).mul(new utils.Decimal(inputs.price).sub(inputs.entryPrice)).toNumber();
 }
 function estPriceForTP(inputs) {
-  return new import_utils2.Decimal(inputs.pnl).div(inputs.positionQty).add(inputs.entryPrice).toNumber();
+  return new utils.Decimal(inputs.pnl).div(inputs.positionQty).add(inputs.entryPrice).toNumber();
 }
 function estOffsetForTP(inputs) {
-  return new import_utils2.Decimal(inputs.price).div(inputs.entryPrice).toNumber();
+  return new utils.Decimal(inputs.price).div(inputs.entryPrice).toNumber();
 }
 function estPriceFromOffsetForTP(inputs) {
-  return new import_utils2.Decimal(inputs.offset).add(inputs.entryPrice).toNumber();
+  return new utils.Decimal(inputs.offset).add(inputs.entryPrice).toNumber();
 }
 function estPnLForSL(inputs) {
   return 0;
 }
 function maxPositionNotional(inputs) {
   const { leverage, IMRFactor } = inputs;
-  return new import_utils2.Decimal(1).div(new import_utils2.Decimal(leverage).mul(IMRFactor)).pow(1 / 0.8).toNumber();
+  return new utils.Decimal(1).div(new utils.Decimal(leverage).mul(IMRFactor)).pow(1 / 0.8).toNumber();
 }
 function maxPositionLeverage(inputs) {
   const { IMRFactor, notional: notional2 } = inputs;
-  return new import_utils2.Decimal(1).div(new import_utils2.Decimal(IMRFactor).mul(new import_utils2.Decimal(notional2).pow(0.8))).toNumber();
+  return new utils.Decimal(1).div(new utils.Decimal(IMRFactor).mul(new utils.Decimal(notional2).pow(0.8))).toNumber();
+}
+function liquidationPriceIsolated(inputs) {
+  const {
+    isolatedPositionMargin,
+    costPosition,
+    positionQty,
+    sumUnitaryFunding,
+    lastSumUnitaryFunding,
+    baseMMR,
+    baseIMR,
+    IMRFactor,
+    referencePrice,
+    orderSide,
+    orderQty = 0,
+    leverage
+  } = inputs;
+  const refPrice = referencePrice != null ? referencePrice : 0;
+  if (refPrice <= 0 && orderQty !== 0) {
+    return null;
+  }
+  const orderSideMultiplier = orderSide === "BUY" ? 1 : orderSide === "SELL" ? -1 : 0;
+  const newPositionQty = positionQty + orderSideMultiplier * orderQty;
+  if (newPositionQty === 0) {
+    return null;
+  }
+  let newIsolatedPositionMargin;
+  let newCostPosition;
+  if (orderQty === 0) {
+    newIsolatedPositionMargin = new utils.Decimal(isolatedPositionMargin);
+    newCostPosition = new utils.Decimal(costPosition);
+  } else if (positionQty === 0 || orderSideMultiplier > 0 && positionQty > 0 || orderSideMultiplier < 0 && positionQty < 0) {
+    newIsolatedPositionMargin = new utils.Decimal(isolatedPositionMargin).add(
+      new utils.Decimal(orderQty).mul(refPrice).div(leverage)
+    );
+    newCostPosition = new utils.Decimal(costPosition).add(
+      new utils.Decimal(orderSideMultiplier).mul(orderQty).mul(refPrice)
+    );
+  } else {
+    const signPositionQty = positionQty > 0 ? 1 : -1;
+    const signNewPositionQty = newPositionQty > 0 ? 1 : -1;
+    if (signNewPositionQty === signPositionQty) {
+      newIsolatedPositionMargin = new utils.Decimal(isolatedPositionMargin).mul(newPositionQty).div(positionQty);
+      newCostPosition = new utils.Decimal(costPosition).add(
+        new utils.Decimal(orderSideMultiplier).mul(orderQty).mul(refPrice)
+      );
+    } else {
+      newIsolatedPositionMargin = new utils.Decimal(Math.abs(newPositionQty)).mul(refPrice).div(leverage);
+      newCostPosition = new utils.Decimal(newPositionQty).mul(refPrice);
+    }
+  }
+  const fundingAdjustment = new utils.Decimal(newPositionQty).mul(
+    new utils.Decimal(sumUnitaryFunding).sub(lastSumUnitaryFunding)
+  );
+  const newPositionNotional = new utils.Decimal(Math.abs(newPositionQty)).mul(
+    refPrice
+  );
+  const dynamicMMR = new utils.Decimal(baseMMR).div(baseIMR).mul(IMRFactor).mul(newPositionNotional.toPower(IMRFactorPower)).toNumber();
+  const newMMR = Math.max(baseMMR, dynamicMMR);
+  const denominator = new utils.Decimal(Math.abs(newPositionQty)).mul(newMMR).sub(newPositionQty);
+  if (denominator.isZero()) {
+    return null;
+  }
+  const numerator = newIsolatedPositionMargin.sub(newCostPosition).sub(fundingAdjustment);
+  const liquidationPrice = numerator.div(denominator).toNumber();
+  if (liquidationPrice <= 0) {
+    return null;
+  }
+  return liquidationPrice;
 }
 
-// src/account.ts
+// src/account/index.ts
 var account_exports = {};
 __export(account_exports, {
   IMR: () => IMR,
   LTV: () => LTV,
   MMR: () => MMR2,
   availableBalance: () => availableBalance,
+  availableBalanceForIsolatedMargin: () => availableBalanceForIsolatedMargin,
   buyOrdersFilter_by_symbol: () => buyOrdersFilter_by_symbol,
   calcMinimumReceived: () => calcMinimumReceived,
   collateralContribution: () => collateralContribution,
   collateralRatio: () => collateralRatio,
   currentLeverage: () => currentLeverage,
-  extractSymbols: () => extractSymbols,
+  extractSymbols: () => extractSymbols2,
   freeCollateral: () => freeCollateral,
+  freeCollateralUSDCOnly: () => freeCollateralUSDCOnly,
   getPositonsAndOrdersNotionalBySymbol: () => getPositonsAndOrdersNotionalBySymbol,
   getQtyFromOrdersBySide: () => getQtyFromOrdersBySide,
   getQtyFromPositions: () => getQtyFromPositions,
   groupOrdersBySymbol: () => groupOrdersBySymbol,
-  initialMarginWithOrder: () => initialMarginWithOrder,
-  maxLeverage: () => maxLeverage,
+  maxAdd: () => maxAdd,
   maxQty: () => maxQty,
   maxQtyByLong: () => maxQtyByLong,
   maxQtyByShort: () => maxQtyByShort,
+  maxQtyForIsolatedMargin: () => maxQtyForIsolatedMargin,
+  maxReduce: () => maxReduce,
   maxWithdrawalOtherCollateral: () => maxWithdrawalOtherCollateral,
   maxWithdrawalUSDC: () => maxWithdrawalUSDC,
   otherIMs: () => otherIMs,
@@ -342,42 +391,61 @@ __export(account_exports, {
   positionQtyWithOrders_by_symbol: () => positionQtyWithOrders_by_symbol,
   sellOrdersFilter_by_symbol: () => sellOrdersFilter_by_symbol,
   totalCollateral: () => totalCollateral,
-  totalInitialMarginWithOrders: () => totalInitialMarginWithOrders,
   totalInitialMarginWithQty: () => totalInitialMarginWithQty,
   totalMarginRatio: () => totalMarginRatio,
   totalUnrealizedROI: () => totalUnrealizedROI,
   totalValue: () => totalValue
 });
-var import_types = require("@orderly.network/types");
-var import_utils4 = require("@orderly.network/utils");
 function totalValue(inputs) {
-  const { totalUnsettlementPnL: totalUnsettlementPnL2, USDCHolding, nonUSDCHolding } = inputs;
+  const {
+    totalUnsettlementPnL: totalUnsettlementPnL2,
+    USDCHolding,
+    nonUSDCHolding,
+    totalIsolatedPositionMargin = 0
+  } = inputs;
   const nonUSDCHoldingValue = nonUSDCHolding.reduce((acc, cur) => {
-    return new import_utils4.Decimal(cur.holding).mul(cur.indexPrice).add(acc);
-  }, import_utils4.zero);
-  return nonUSDCHoldingValue.add(USDCHolding).add(totalUnsettlementPnL2);
+    return new utils.Decimal(cur.holding).mul(cur.indexPrice).add(acc);
+  }, utils.zero);
+  return nonUSDCHoldingValue.add(USDCHolding).add(totalIsolatedPositionMargin).add(totalUnsettlementPnL2);
 }
 function freeCollateral(inputs) {
   const value = inputs.totalCollateral.sub(inputs.totalInitialMarginWithOrders);
-  return value.isNegative() ? import_utils4.zero : value;
+  return value.isNegative() ? utils.zero : value;
+}
+function freeCollateralUSDCOnly(inputs) {
+  const { freeCollateral: freeCollateral2, nonUSDCHolding } = inputs;
+  const nonUSDCHoldingValue = nonUSDCHolding.reduce((acc, cur) => {
+    const finalHolding = Math.min(cur.holding, cur.collateralCap);
+    const value2 = new utils.Decimal(finalHolding).mul(cur.collateralRatio).mul(cur.indexPrice);
+    return acc.add(value2);
+  }, utils.zero);
+  const value = freeCollateral2.sub(nonUSDCHoldingValue);
+  return value.isNegative() ? utils.zero : value;
 }
 function totalCollateral(inputs) {
-  const { USDCHolding, nonUSDCHolding, unsettlementPnL: unsettlementPnL2 } = inputs;
+  const {
+    USDCHolding,
+    nonUSDCHolding,
+    unsettlementPnL: unsettlementPnL2,
+    usdcBalancePendingShortQty = 0,
+    usdcBalanceIsolatedOrderFrozen = 0,
+    totalCrossUnsettledPnL
+  } = inputs;
+  const usdcPart = new utils.Decimal(USDCHolding).add(usdcBalancePendingShortQty).sub(Math.abs(usdcBalanceIsolatedOrderFrozen));
   const nonUSDCHoldingValue = nonUSDCHolding.reduce((acc, cur) => {
     const finalHolding = Math.min(cur.holding, cur.collateralCap);
-    const value = new import_utils4.Decimal(finalHolding).mul(cur.collateralRatio).mul(cur.indexPrice);
+    const value = new utils.Decimal(finalHolding).mul(cur.collateralRatio).mul(cur.indexPrice);
     return acc.add(value);
-  }, import_utils4.zero);
-  return new import_utils4.Decimal(USDCHolding).add(nonUSDCHoldingValue).add(unsettlementPnL2);
-}
-function initialMarginWithOrder() {
+  }, utils.zero);
+  const pnl = totalCrossUnsettledPnL !== void 0 ? totalCrossUnsettledPnL : unsettlementPnL2;
+  return usdcPart.add(nonUSDCHoldingValue).add(pnl);
 }
 function positionNotionalWithOrder_by_symbol(inputs) {
-  return new import_utils4.Decimal(inputs.markPrice).mul(inputs.positionQtyWithOrders);
+  return new utils.Decimal(inputs.markPrice).mul(inputs.positionQtyWithOrders);
 }
 function positionQtyWithOrders_by_symbol(inputs) {
   const { positionQty, buyOrdersQty, sellOrdersQty } = inputs;
-  const positionQtyDecimal = new import_utils4.Decimal(positionQty);
+  const positionQtyDecimal = new utils.Decimal(positionQty);
   const qty = Math.max(
     positionQtyDecimal.add(buyOrdersQty).abs().toNumber(),
     positionQtyDecimal.sub(sellOrdersQty).abs().toNumber()
@@ -386,7 +454,7 @@ function positionQtyWithOrders_by_symbol(inputs) {
 }
 function IMR(inputs) {
   const {
-    maxLeverage: maxLeverage2,
+    maxLeverage,
     baseIMR,
     IMR_Factor,
     positionNotional,
@@ -394,21 +462,21 @@ function IMR(inputs) {
     IMR_factor_power = IMRFactorPower
   } = inputs;
   return Math.max(
-    1 / maxLeverage2,
+    1 / maxLeverage,
     baseIMR,
-    new import_utils4.Decimal(IMR_Factor).mul(
-      new import_utils4.Decimal(positionNotional).add(orderNotional).abs().toPower(IMR_factor_power)
+    new utils.Decimal(IMR_Factor).mul(
+      new utils.Decimal(positionNotional).add(orderNotional).abs().toPower(IMR_factor_power)
     ).toNumber()
   );
 }
 function buyOrdersFilter_by_symbol(orders, symbol) {
   return orders.filter(
-    (item) => item.symbol === symbol && item.side === import_types.OrderSide.BUY
+    (item) => item.symbol === symbol && item.side === types.OrderSide.BUY
   );
 }
 function sellOrdersFilter_by_symbol(orders, symbol) {
   return orders.filter(
-    (item) => item.symbol === symbol && item.side === import_types.OrderSide.SELL
+    (item) => item.symbol === symbol && item.side === types.OrderSide.SELL
   );
 }
 function getQtyFromPositions(positions, symbol) {
@@ -419,7 +487,7 @@ function getQtyFromPositions(positions, symbol) {
   return (position == null ? void 0 : position.position_qty) || 0;
 }
 function getQtyFromOrdersBySide(orders, symbol, side) {
-  const ordersBySide = side === import_types.OrderSide.SELL ? sellOrdersFilter_by_symbol(orders, symbol) : buyOrdersFilter_by_symbol(orders, symbol);
+  const ordersBySide = side === types.OrderSide.SELL ? sellOrdersFilter_by_symbol(orders, symbol) : buyOrdersFilter_by_symbol(orders, symbol);
   return ordersBySide.reduce((acc, cur) => {
     return acc + cur.quantity;
   }, 0);
@@ -427,87 +495,119 @@ function getQtyFromOrdersBySide(orders, symbol, side) {
 function getPositonsAndOrdersNotionalBySymbol(inputs) {
   const { positions, orders, symbol, markPrice } = 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_utils4.Decimal(markPrice);
-  return markPriceDecimal.mul(positionQty).add(markPriceDecimal.mul(new import_utils4.Decimal(buyOrdersQty).add(sellOrdersQty))).abs().toNumber();
+  const buyOrdersQty = getQtyFromOrdersBySide(orders, symbol, types.OrderSide.BUY);
+  const sellOrdersQty = getQtyFromOrdersBySide(orders, symbol, types.OrderSide.SELL);
+  const markPriceDecimal = new utils.Decimal(markPrice);
+  return markPriceDecimal.mul(positionQty).add(markPriceDecimal.mul(new utils.Decimal(buyOrdersQty).add(sellOrdersQty))).abs().toNumber();
+}
+function calculateSymbolInitialMargin(params) {
+  const {
+    symbol,
+    positionQty,
+    buyOrdersQty,
+    sellOrdersQty,
+    markPrice,
+    IMR_Factors,
+    symbolInfo,
+    symbolMaxLeverage
+  } = params;
+  const positionQtyWithOrders = positionQtyWithOrders_by_symbol({
+    positionQty,
+    buyOrdersQty,
+    sellOrdersQty
+  });
+  const positionNotionalWithOrders = positionNotionalWithOrder_by_symbol({
+    markPrice,
+    positionQtyWithOrders
+  });
+  const markPriceDecimal = new utils.Decimal(markPrice);
+  const imr = IMR2({
+    positionNotional: markPriceDecimal.mul(positionQty).toNumber(),
+    ordersNotional: markPriceDecimal.mul(new utils.Decimal(buyOrdersQty).sub(sellOrdersQty)).toNumber(),
+    maxLeverage: symbolMaxLeverage,
+    IMR_Factor: IMR_Factors[symbol],
+    baseIMR: symbolInfo[symbol]("base_imr", 0)
+  });
+  return positionNotionalWithOrders.mul(imr).toNumber();
 }
-function totalInitialMarginWithOrders(inputs) {
+function IMR2(inputs) {
+  const {
+    maxLeverage,
+    baseIMR,
+    IMR_Factor,
+    positionNotional,
+    ordersNotional: orderNotional,
+    IMR_factor_power = IMRFactorPower
+  } = inputs;
+  const imr = IMR_Factor === 0 ? 0 : new utils.Decimal(IMR_Factor).mul(
+    new utils.Decimal(positionNotional).add(orderNotional).abs().toPower(IMR_factor_power)
+  ).toNumber();
+  return Math.max(1 / maxLeverage, baseIMR, imr);
+}
+function totalInitialMarginWithQty(inputs) {
   const {
     positions,
     orders,
     markPrices,
     IMR_Factors,
-    maxLeverage: maxLeverage2,
-    symbolInfo
+    symbolInfo,
+    maxLeverageBySymbol
   } = inputs;
-  const symbols = extractSymbols(positions, orders);
-  const total_initial_margin_with_orders = symbols.reduce((acc, cur) => {
-    const symbol = cur;
-    const positionQty = getQtyFromPositions(positions, symbol);
-    const buyOrdersQty = getQtyFromOrdersBySide(orders, symbol, import_types.OrderSide.BUY);
+  const crossPositions = positions.filter(
+    (p) => p.margin_mode !== types.MarginMode.ISOLATED
+  );
+  const crossOrders = orders.filter(
+    (o) => o.margin_mode !== types.MarginMode.ISOLATED
+  );
+  const crossLeverageBySymbol = crossPositions.reduce(
+    (acc, position) => {
+      if (!acc[position.symbol] && position.leverage) {
+        acc[position.symbol] = position.leverage;
+      }
+      return acc;
+    },
+    {}
+  );
+  const symbols = extractSymbols(crossPositions, crossOrders);
+  return symbols.map((symbol) => {
+    var _a, _b;
+    const positionQty = getQtyFromPositions(crossPositions, symbol);
+    const markPrice = markPrices[symbol] || 0;
+    const buyOrdersQty = getQtyFromOrdersBySide(
+      crossOrders,
+      symbol,
+      types.OrderSide.BUY
+    );
     const sellOrdersQty = getQtyFromOrdersBySide(
-      orders,
+      crossOrders,
       symbol,
-      import_types.OrderSide.SELL
+      types.OrderSide.SELL
     );
-    const markPrice = markPrices[symbol] || 0;
-    const positionQtyWithOrders = positionQtyWithOrders_by_symbol({
+    const symbolMaxLeverage = (_b = (_a = crossLeverageBySymbol[symbol]) != null ? _a : maxLeverageBySymbol == null ? void 0 : maxLeverageBySymbol[symbol]) != null ? _b : 1;
+    return calculateSymbolInitialMargin({
+      symbol,
       positionQty,
       buyOrdersQty,
-      sellOrdersQty
-    });
-    const position_notional_with_orders = positionNotionalWithOrder_by_symbol({
+      sellOrdersQty,
       markPrice,
-      positionQtyWithOrders
+      IMR_Factors,
+      symbolInfo,
+      symbolMaxLeverage
     });
-    const markPriceDecimal = new import_utils4.Decimal(markPrice);
-    const imr = IMR({
-      positionNotional: markPriceDecimal.mul(positionQty).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)
-    });
-    return position_notional_with_orders.mul(imr).add(acc).toNumber();
-  }, 0);
-  return total_initial_margin_with_orders;
+  }).reduce((acc, margin) => acc.add(margin), utils.zero).toNumber();
 }
-function totalInitialMarginWithQty(inputs) {
-  const { positions, markPrices, IMR_Factors, symbolInfo } = inputs;
-  const symbols = positions.map((item) => item.symbol);
-  const total_initial_margin_with_orders = symbols.reduce((acc, cur) => {
-    var _a;
-    const symbol = cur;
-    const position = positions.find((item) => item.symbol === symbol);
-    const positionQty = (position == null ? void 0 : position.position_qty) || 0;
-    const buyOrdersQty = (position == null ? void 0 : position.pending_long_qty) || 0;
-    const sellOrdersQty = (position == null ? void 0 : position.pending_short_qty) || 0;
-    const markPrice = markPrices[symbol] || 0;
-    const positionQtyWithOrders = positionQtyWithOrders_by_symbol({
-      positionQty,
-      buyOrdersQty,
-      sellOrdersQty
-    });
-    const position_notional_with_orders = positionNotionalWithOrder_by_symbol({
-      markPrice,
-      positionQtyWithOrders
-    });
-    const markPriceDecimal = new import_utils4.Decimal(markPrice);
-    const imr = IMR({
-      positionNotional: markPriceDecimal.mul(positionQty).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
-      }),
-      IMR_Factor: IMR_Factors[symbol],
-      baseIMR: symbolInfo[symbol]("base_imr", 0)
-    });
-    return position_notional_with_orders.mul(imr).add(acc).toNumber();
-  }, 0);
-  return total_initial_margin_with_orders;
+function extractSymbols(positions, orders) {
+  const symbols = /* @__PURE__ */ new Set();
+  positions.forEach((item) => {
+    symbols.add(item.symbol);
+  });
+  orders.forEach((item) => {
+    symbols.add(item.symbol);
+  });
+  return Array.from(symbols);
 }
+
+// src/account/groupOrders.ts
 function groupOrdersBySymbol(orders) {
   const symbols = {};
   orders.forEach((item) => {
@@ -518,7 +618,7 @@ function groupOrdersBySymbol(orders) {
   });
   return symbols;
 }
-function extractSymbols(positions, orders) {
+function extractSymbols2(positions, orders) {
   const symbols = /* @__PURE__ */ new Set();
   positions.forEach((item) => {
     symbols.add(item.symbol);
@@ -528,6 +628,23 @@ function extractSymbols(positions, orders) {
   });
   return Array.from(symbols);
 }
+function IMR3(inputs) {
+  const {
+    maxLeverage,
+    baseIMR,
+    IMR_Factor,
+    positionNotional,
+    ordersNotional: orderNotional,
+    IMR_factor_power = 4 / 5
+  } = inputs;
+  return Math.max(
+    1 / maxLeverage,
+    baseIMR,
+    new utils.Decimal(IMR_Factor).mul(
+      new utils.Decimal(positionNotional).add(orderNotional).abs().toPower(IMR_factor_power)
+    ).toNumber()
+  );
+}
 function otherIMs(inputs) {
   const {
     // orders,
@@ -543,23 +660,21 @@ function otherIMs(inputs) {
       console.warn("markPrices[%s] is undefined", symbol);
       return acc;
     }
-    const markPriceDecimal = new import_utils4.Decimal(markPrices[symbol] || 0);
+    const markPriceDecimal = new utils.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_utils4.Decimal(buyOrdersQty).add(sellOrdersQty)).toNumber();
+    const ordersNotional = markPriceDecimal.mul(new utils.Decimal(buyOrdersQty).add(sellOrdersQty)).toNumber();
     const IMR_Factor = IMR_Factors[symbol];
     if (typeof IMR_Factor === "undefined") {
       console.warn("IMR_Factor is not found:", symbol);
       return acc;
     }
-    const imr = IMR({
-      maxLeverage: maxLeverage({
-        symbolLeverage: position.leverage,
-        accountLeverage: inputs.maxLeverage
-      }),
+    const imr = IMR3({
+      // Use symbol + mode leverage from position directly.
+      maxLeverage: (position == null ? void 0 : position.leverage) || 1,
       IMR_Factor,
       baseIMR: symbolInfo[symbol]("base_imr", 0),
       positionNotional,
@@ -575,10 +690,10 @@ function otherIMs(inputs) {
       positionQtyWithOrders
     });
     return acc.add(positionNotionalWithOrders.mul(imr));
-  }, import_utils4.zero).toNumber();
+  }, utils.zero).toNumber();
 }
 function maxQty(side, inputs, options) {
-  if (side === import_types.OrderSide.BUY) {
+  if (side === types.OrderSide.BUY) {
     return maxQtyByLong(inputs);
   }
   return maxQtyByShort(inputs);
@@ -589,7 +704,7 @@ function maxQtyByLong(inputs, options) {
       baseMaxQty,
       totalCollateral: totalCollateral2,
       otherIMs: otherIMs2,
-      maxLeverage: maxLeverage2,
+      maxLeverage,
       baseIMR,
       markPrice,
       IMR_Factor,
@@ -600,10 +715,10 @@ function maxQtyByLong(inputs, options) {
     if (totalCollateral2 === 0) {
       return 0;
     }
-    const totalCollateralDecimal = new import_utils4.Decimal(totalCollateral2);
+    const totalCollateralDecimal = new utils.Decimal(totalCollateral2);
     const factor_1 = totalCollateralDecimal.sub(otherIMs2).div(
-      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();
+      new utils.Decimal(takerFeeRate).mul(2).mul(1e-4).add(Math.max(1 / maxLeverage, baseIMR))
+    ).div(markPrice).mul(0.995).sub(new utils.Decimal(positionQty).add(buyOrdersQty)).toNumber();
     if (positionQty === 0 && buyOrdersQty === 0) {
       return Math.min(baseMaxQty, factor_1);
     }
@@ -611,10 +726,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_utils4.Decimal(positionQty).add(buyOrdersQty)
+      new utils.Decimal(positionQty).add(buyOrdersQty)
       // .abs()
       // .div(new Decimal(takerFeeRate).mul(2).mul(0.0001).add(1))
-    ).div(new import_utils4.Decimal(takerFeeRate).mul(2).mul(1e-4).add(1)).mul(0.995).toNumber();
+    ).div(new utils.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;
@@ -626,7 +741,7 @@ function maxQtyByShort(inputs, options) {
       baseMaxQty,
       totalCollateral: totalCollateral2,
       otherIMs: otherIMs2,
-      maxLeverage: maxLeverage2,
+      maxLeverage,
       baseIMR,
       markPrice,
       IMR_Factor,
@@ -635,9 +750,9 @@ function maxQtyByShort(inputs, options) {
       sellOrdersQty,
       takerFeeRate
     } = inputs;
-    const totalCollateralDecimal = new import_utils4.Decimal(totalCollateral2);
+    const totalCollateralDecimal = new utils.Decimal(totalCollateral2);
     const factor_1 = totalCollateralDecimal.sub(otherIMs2).div(
-      new import_utils4.Decimal(takerFeeRate).mul(2).mul(1e-4).add(Math.max(1 / maxLeverage2, baseIMR))
+      new utils.Decimal(takerFeeRate).mul(2).mul(1e-4).add(Math.max(1 / maxLeverage, baseIMR))
     ).div(markPrice).mul(0.995).add(positionQty).sub(Math.abs(sellOrdersQty)).toNumber();
     if (positionQty === 0 && sellOrdersQty === 0) {
       return Math.min(baseMaxQty, factor_1);
@@ -645,31 +760,147 @@ 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_utils4.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 utils.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;
   }
 }
+function maxQtyForIsolatedMargin(inputs) {
+  const {
+    orderSide,
+    currentOrderReferencePrice,
+    availableBalance: availableBalance2,
+    leverage,
+    IMR_Factor,
+    markPrice,
+    positionQty,
+    pendingLongOrders,
+    pendingSellOrders,
+    symbolMaxNotional,
+    epsilon = 1
+  } = inputs;
+  const maxNotional = Math.min(
+    new utils.Decimal(1).div(new utils.Decimal(leverage).mul(IMR_Factor)).pow(5 / 4).toNumber(),
+    symbolMaxNotional
+  );
+  if (orderSide === types.OrderSide.BUY) {
+    if (positionQty >= 0) {
+      const pendingLongNotional = pendingLongOrders.reduce(
+        (acc, order) => acc + new utils.Decimal(order.referencePrice).mul(order.quantity).toNumber(),
+        0
+      );
+      const maxQtyByBalance = new utils.Decimal(availableBalance2).div(currentOrderReferencePrice).mul(leverage).toNumber();
+      const maxQtyByNotional = new utils.Decimal(maxNotional).sub(new utils.Decimal(markPrice).mul(positionQty)).sub(pendingLongNotional).div(currentOrderReferencePrice).toNumber();
+      return Math.max(0, Math.min(maxQtyByBalance, maxQtyByNotional));
+    } else {
+      return maxQtyIsolatedBinarySearch(
+        {
+          currentOrderReferencePrice,
+          availableBalance: availableBalance2,
+          leverage,
+          baseIMR: inputs.baseIMR,
+          IMR_Factor,
+          positionQty,
+          pendingLongOrders,
+          pendingSellOrders,
+          isoOrderFrozenLong: inputs.isoOrderFrozenLong,
+          isoOrderFrozenShort: inputs.isoOrderFrozenShort
+        },
+        maxNotional,
+        epsilon,
+        types.OrderSide.BUY
+      );
+    }
+  } else {
+    if (positionQty <= 0) {
+      const pendingSellNotional = pendingSellOrders.reduce(
+        (acc, order) => acc + new utils.Decimal(order.referencePrice).mul(order.quantity).toNumber(),
+        0
+      );
+      const maxQtyByBalance = new utils.Decimal(availableBalance2).div(currentOrderReferencePrice).mul(leverage).toNumber();
+      const maxQtyByNotional = new utils.Decimal(maxNotional).sub(new utils.Decimal(markPrice).mul(Math.abs(positionQty))).sub(pendingSellNotional).div(currentOrderReferencePrice).toNumber();
+      return Math.max(0, Math.min(maxQtyByBalance, maxQtyByNotional));
+    } else {
+      return maxQtyIsolatedBinarySearch(
+        {
+          currentOrderReferencePrice,
+          availableBalance: availableBalance2,
+          leverage,
+          baseIMR: inputs.baseIMR,
+          IMR_Factor,
+          positionQty,
+          pendingLongOrders,
+          pendingSellOrders,
+          isoOrderFrozenLong: inputs.isoOrderFrozenLong,
+          isoOrderFrozenShort: inputs.isoOrderFrozenShort
+        },
+        maxNotional,
+        epsilon,
+        types.OrderSide.SELL
+      );
+    }
+  }
+}
+function maxQtyIsolatedBinarySearch(inputs, maxNotional, epsilon, orderSide) {
+  const {
+    currentOrderReferencePrice,
+    availableBalance: availableBalance2,
+    leverage,
+    positionQty,
+    pendingLongOrders,
+    pendingSellOrders,
+    isoOrderFrozenLong,
+    isoOrderFrozenShort
+  } = inputs;
+  inputs.baseIMR;
+  inputs.IMR_Factor;
+  const pendingOrdersQty = orderSide === types.OrderSide.BUY ? pendingLongOrders.reduce((acc, order) => acc + order.quantity, 0) : pendingSellOrders.reduce((acc, order) => acc + order.quantity, 0);
+  let left = Math.max(0, Math.max(0, Math.abs(positionQty)) - pendingOrdersQty);
+  let right = new utils.Decimal(maxNotional).div(currentOrderReferencePrice).add(Math.abs(positionQty)).toNumber();
+  for (let i = 0; i < 30; i++) {
+    const mid = (left + right) / 2;
+    const orderNotional = new utils.Decimal(mid).mul(currentOrderReferencePrice);
+    const orderMargin = orderNotional.div(leverage);
+    const totalFrozenMargin = orderSide === types.OrderSide.BUY ? isoOrderFrozenLong + orderMargin.toNumber() : isoOrderFrozenShort + orderMargin.toNumber();
+    const newPositionQty = orderSide === types.OrderSide.BUY ? positionQty + mid : positionQty - mid;
+    const openNotional = new utils.Decimal(Math.abs(newPositionQty)).mul(
+      currentOrderReferencePrice
+    );
+    const frozenOk = totalFrozenMargin <= availableBalance2;
+    const notionalOk = openNotional.lte(maxNotional);
+    if (frozenOk && notionalOk) {
+      left = mid;
+      if (new utils.Decimal(availableBalance2).sub(totalFrozenMargin).lte(epsilon)) {
+        break;
+      }
+    } else {
+      right = mid;
+    }
+  }
+  return Math.max(0, left);
+}
 function totalMarginRatio(inputs, dp) {
   const { totalCollateral: totalCollateral2, markPrices, positions } = inputs;
   if (totalCollateral2 === 0) {
     return 0;
   }
-  const totalCollateralDecimal = new import_utils4.Decimal(totalCollateral2);
+  const totalCollateralDecimal = new utils.Decimal(totalCollateral2);
   const totalPositionNotional = positions.reduce((acc, cur) => {
     const markPrice = markPrices[cur.symbol] || 0;
-    return acc.add(new import_utils4.Decimal(cur.position_qty).mul(markPrice).abs());
-  }, import_utils4.zero);
-  if (totalPositionNotional.eq(import_utils4.zero)) {
+    return acc.add(new utils.Decimal(cur.position_qty).mul(markPrice).abs());
+  }, utils.zero);
+  if (totalPositionNotional.eq(utils.zero)) {
     return 0;
   }
   return totalCollateralDecimal.div(totalPositionNotional).toNumber();
 }
 function totalUnrealizedROI(inputs) {
   const { totalUnrealizedPnL: totalUnrealizedPnL2, totalValue: totalValue2 } = inputs;
-  return new import_utils4.Decimal(totalUnrealizedPnL2).div(totalValue2 - totalUnrealizedPnL2).toNumber();
+  return new utils.Decimal(totalUnrealizedPnL2).div(totalValue2 - totalUnrealizedPnL2).toNumber();
 }
+
+// src/account/leverage.ts
 function currentLeverage(totalMarginRatio2) {
   if (totalMarginRatio2 === 0) {
     return 0;
@@ -678,7 +909,16 @@ function currentLeverage(totalMarginRatio2) {
 }
 function availableBalance(inputs) {
   const { USDCHolding, unsettlementPnL: unsettlementPnL2 } = inputs;
-  return new import_utils4.Decimal(USDCHolding).add(unsettlementPnL2).toNumber();
+  return new utils.Decimal(USDCHolding).add(unsettlementPnL2).toNumber();
+}
+function availableBalanceForIsolatedMargin(inputs) {
+  return Math.max(
+    0,
+    Math.min(
+      inputs.USDCHolding,
+      new utils.Decimal(inputs.freeCollateral).sub(Math.max(inputs.totalCrossUnsettledPnL, 0)).toNumber()
+    )
+  );
 }
 function MMR2(inputs) {
   if (inputs.positionsNotional === 0) {
@@ -687,7 +927,7 @@ function MMR2(inputs) {
   if (inputs.positionsMMR === 0) {
     return null;
   }
-  return new import_utils4.Decimal(inputs.positionsMMR).div(inputs.positionsNotional).toNumber();
+  return new utils.Decimal(inputs.positionsMMR).div(inputs.positionsNotional).toNumber();
 }
 var collateralRatio = (params) => {
   const {
@@ -698,30 +938,30 @@ var collateralRatio = (params) => {
     indexPrice
   } = params;
   const cap = collateralCap === -1 ? collateralQty : collateralCap;
-  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 K = new utils.Decimal(1.2);
+  const DCF = new utils.Decimal(discountFactor || 0);
+  const qty = new utils.Decimal(Math.min(collateralQty, cap));
   const notionalAbs = qty.mul(indexPrice).abs();
   const dynamicWeight = DCF.mul(notionalAbs.toPower(IMRFactorPower));
-  const result = K.div(new import_utils4.Decimal(1).add(dynamicWeight));
-  return result.lt(baseWeight) ? result : new import_utils4.Decimal(baseWeight);
+  const result = K.div(new utils.Decimal(1).add(dynamicWeight));
+  return result.lt(baseWeight) ? result : new utils.Decimal(baseWeight);
 };
 var collateralContribution = (params) => {
   const { collateralQty, collateralCap, collateralRatio: collateralRatio2, indexPrice } = params;
   const cap = collateralCap === -1 ? collateralQty : collateralCap;
-  return new import_utils4.Decimal(Math.min(collateralQty, cap)).mul(collateralRatio2).mul(indexPrice).toNumber();
+  return new utils.Decimal(Math.min(collateralQty, cap)).mul(collateralRatio2).mul(indexPrice).toNumber();
 };
 var LTV = (params) => {
   const { usdcBalance, upnl, assets } = params;
-  const usdcLoss = new import_utils4.Decimal(Math.min(usdcBalance, 0)).abs();
-  const upnlLoss = new import_utils4.Decimal(Math.min(upnl, 0)).abs();
+  const usdcLoss = new utils.Decimal(Math.min(usdcBalance, 0)).abs();
+  const upnlLoss = new utils.Decimal(Math.min(upnl, 0)).abs();
   const numerator = usdcLoss.add(upnlLoss);
   const collateralSum = assets.reduce((acc, asset) => {
     return acc.add(
-      new import_utils4.Decimal(Math.max(asset.qty, 0)).mul(new import_utils4.Decimal(asset.indexPrice)).mul(new import_utils4.Decimal(asset.weight))
+      new utils.Decimal(Math.max(asset.qty, 0)).mul(new utils.Decimal(asset.indexPrice)).mul(new utils.Decimal(asset.weight))
     );
-  }, import_utils4.zero);
-  const denominator = collateralSum.add(new import_utils4.Decimal(Math.max(upnl, 0)));
+  }, utils.zero);
+  const denominator = collateralSum.add(new utils.Decimal(Math.max(upnl, 0)));
   if (numerator.isZero() || denominator.isZero()) {
     return 0;
   }
@@ -730,44 +970,60 @@ var LTV = (params) => {
 var maxWithdrawalUSDC = (inputs) => {
   const { USDCBalance, freeCollateral: freeCollateral2, upnl } = inputs;
   const value = Math.min(
-    new import_utils4.Decimal(USDCBalance).toNumber(),
-    new import_utils4.Decimal(freeCollateral2).sub(Math.max(upnl, 0)).toNumber()
+    new utils.Decimal(USDCBalance).toNumber(),
+    new utils.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_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);
+  const usdcBalance = new utils.Decimal(USDCBalance);
+  const denominator = usdcBalance.isNegative() ? new utils.Decimal(indexPrice).mul(weight).mul(new utils.Decimal(1).add(2e-3)) : new utils.Decimal(indexPrice).mul(weight);
   if (denominator.isZero()) {
-    return import_utils4.zero;
+    return utils.zero;
   }
-  const qty = new import_utils4.Decimal(collateralQty);
-  const maxQtyByValue = new import_utils4.Decimal(freeCollateral2).div(denominator);
+  const qty = new utils.Decimal(collateralQty);
+  const maxQtyByValue = new utils.Decimal(freeCollateral2).div(denominator);
   return maxQtyByValue.lt(qty) ? maxQtyByValue : qty;
 };
 var calcMinimumReceived = (inputs) => {
   const { amount, slippage } = inputs;
-  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;
-  return symbolLeverage != null ? symbolLeverage : 1;
+  const slippageRatio = new utils.Decimal(slippage).div(100);
+  return new utils.Decimal(amount).mul(new utils.Decimal(1).minus(slippageRatio)).toNumber();
 };
 
+// src/account/maxAddReduce.ts
+function maxAdd(inputs) {
+  return availableBalanceForIsolatedMargin(inputs);
+}
+function maxReduce(inputs) {
+  const {
+    isolatedPositionMargin,
+    positionNotional,
+    imr,
+    positionUnsettledPnL
+  } = inputs;
+  const minRequiredMargin = positionNotional * imr;
+  const pnlAdjustment = Math.min(0, positionUnsettledPnL);
+  return Math.max(
+    0,
+    isolatedPositionMargin - minRequiredMargin + pnlAdjustment
+  );
+}
+
 // src/order.ts
 var order_exports = {};
 __export(order_exports, {
   estLeverage: () => estLeverage,
   estLiqPrice: () => estLiqPrice,
+  estLiqPriceIsolated: () => estLiqPriceIsolated,
+  getOrderReferencePrice: () => getOrderReferencePrice,
   maxPrice: () => maxPrice,
   minPrice: () => minPrice,
   orderFee: () => orderFee,
   scopePrice: () => scopePrice,
   tpslROI: () => tpslROI
 });
-var import_utils5 = require("@orderly.network/utils");
 function maxPrice(markprice, range) {
   return markprice * (1 + range);
 }
@@ -781,7 +1037,135 @@ function scopePrice(price, scope, side) {
   return price * (1 + scope);
 }
 function orderFee(inputs) {
-  return new import_utils5.Decimal(inputs.qty).mul(inputs.price).mul(inputs.futuresTakeFeeRate).toNumber();
+  return new utils.Decimal(inputs.qty).mul(inputs.price).mul(inputs.futuresTakeFeeRate).toNumber();
+}
+function getOrderReferencePrice(order, askPrice, bidPrice) {
+  const getMarketRefPrice = () => {
+    if (order.side === types.OrderSide.BUY) {
+      return askPrice > 0 ? askPrice : null;
+    }
+    return bidPrice > 0 ? bidPrice : null;
+  };
+  const isValidPrice = (price) => typeof price === "number" && Number.isFinite(price) && price > 0;
+  const { orderType, orderTypeExt, side } = order;
+  const limitPrice = isValidPrice(order.limitPrice) ? order.limitPrice : void 0;
+  const triggerPrice = isValidPrice(order.triggerPrice) ? order.triggerPrice : void 0;
+  if (orderType === types.OrderType.LIMIT && (orderTypeExt === types.OrderType.ASK || orderTypeExt === types.OrderType.BID)) {
+    if (side === types.OrderSide.BUY) {
+      return orderTypeExt === types.OrderType.ASK ? isValidPrice(askPrice) ? askPrice : null : isValidPrice(bidPrice) ? bidPrice : null;
+    }
+    return orderTypeExt === types.OrderType.ASK ? isValidPrice(askPrice) ? askPrice : null : isValidPrice(bidPrice) ? bidPrice : null;
+  }
+  switch (orderType) {
+    case types.OrderType.LIMIT:
+    case types.OrderType.IOC:
+    case types.OrderType.FOK:
+    case types.OrderType.POST_ONLY: {
+      if (!limitPrice) {
+        return getMarketRefPrice();
+      }
+      if (side === types.OrderSide.BUY) {
+        return limitPrice;
+      }
+      const effectiveBid = isValidPrice(bidPrice) ? bidPrice : 0;
+      return Math.max(limitPrice, effectiveBid);
+    }
+    case types.OrderType.MARKET: {
+      return getMarketRefPrice();
+    }
+    case types.OrderType.STOP_MARKET: {
+      if (triggerPrice) {
+        return triggerPrice;
+      }
+      return getMarketRefPrice();
+    }
+    case types.OrderType.STOP_LIMIT: {
+      if (limitPrice) {
+        return limitPrice;
+      }
+      return getMarketRefPrice();
+    }
+    case types.OrderType.TRAILING_STOP: {
+      if (triggerPrice) {
+        return triggerPrice;
+      }
+      return getMarketRefPrice();
+    }
+    default:
+      return null;
+  }
+}
+function estLiqPriceIsolated(inputs) {
+  var _a, _b;
+  const {
+    isolatedPositionMargin,
+    costPosition,
+    positionQty,
+    sumUnitaryFunding,
+    lastSumUnitaryFunding,
+    markPrice,
+    baseMMR,
+    baseIMR,
+    IMR_Factor: IMRFactor,
+    leverage,
+    newOrder
+  } = inputs;
+  const signedOrderQty = (_a = newOrder == null ? void 0 : newOrder.qty) != null ? _a : 0;
+  const newPositionQty = positionQty + signedOrderQty;
+  if (newPositionQty === 0) {
+    return 0;
+  }
+  const orderRefPrice = (_b = newOrder == null ? void 0 : newOrder.price) != null ? _b : markPrice;
+  if (markPrice <= 0 || signedOrderQty !== 0 && orderRefPrice <= 0) {
+    return 0;
+  }
+  const isSameSign = (a, b) => a > 0 && b > 0 || a < 0 && b < 0;
+  const getScenario = () => {
+    if (signedOrderQty === 0) return "NO_ORDER";
+    if (positionQty === 0 || isSameSign(signedOrderQty, positionQty))
+      return "OPEN_ADD";
+    if (isSameSign(positionQty, newPositionQty)) return "REDUCE";
+    return "FLIP";
+  };
+  const decNewPositionQty = new utils.Decimal(newPositionQty);
+  const decAbsNewPositionQty = decNewPositionQty.abs();
+  const decCostPosition = new utils.Decimal(costPosition);
+  const decIsolatedMargin = new utils.Decimal(isolatedPositionMargin);
+  const decOrderCost = new utils.Decimal(signedOrderQty).mul(orderRefPrice);
+  let newIsolatedPositionMargin;
+  let newCostPosition;
+  switch (getScenario()) {
+    case "NO_ORDER":
+      newIsolatedPositionMargin = decIsolatedMargin;
+      newCostPosition = decCostPosition;
+      break;
+    case "OPEN_ADD":
+      newIsolatedPositionMargin = decIsolatedMargin.add(
+        new utils.Decimal(Math.abs(signedOrderQty)).mul(orderRefPrice).div(leverage)
+      );
+      newCostPosition = decCostPosition.add(decOrderCost);
+      break;
+    case "REDUCE":
+      newIsolatedPositionMargin = decIsolatedMargin.mul(newPositionQty).div(positionQty);
+      newCostPosition = decCostPosition.add(decOrderCost);
+      break;
+    case "FLIP":
+      newIsolatedPositionMargin = decAbsNewPositionQty.mul(orderRefPrice).div(leverage);
+      newCostPosition = decNewPositionQty.mul(orderRefPrice);
+      break;
+  }
+  const fundingAdjustment = decNewPositionQty.mul(
+    new utils.Decimal(sumUnitaryFunding).sub(lastSumUnitaryFunding)
+  );
+  const newPositionNotional = decAbsNewPositionQty.mul(markPrice);
+  const dynamicMMR = new utils.Decimal(baseMMR).div(baseIMR).mul(IMRFactor).mul(newPositionNotional.toPower(IMRFactorPower)).toNumber();
+  const newMMR = Math.max(baseMMR, dynamicMMR);
+  const denominator = decAbsNewPositionQty.mul(newMMR).sub(decNewPositionQty);
+  if (denominator.isZero()) {
+    return 0;
+  }
+  const liquidationPrice = newIsolatedPositionMargin.sub(newCostPosition).sub(fundingAdjustment).div(denominator).toNumber();
+  return Math.max(0, liquidationPrice);
 }
 function estLiqPrice(inputs) {
   var _a;
@@ -796,13 +1180,13 @@ function estLiqPrice(inputs) {
     IMR_Factor
   } = inputs;
   let currentPosition = void 0;
-  let newTotalMM = import_utils5.zero;
+  let newTotalMM = utils.zero;
   const hasPosition = positions.filter((item) => item.position_qty > 0).length > 0;
   const basePrice = hasPosition ? markPrice : newOrder.price;
-  const newOrderNotional = new import_utils5.Decimal(newOrder.qty).mul(newOrder.price);
+  const newOrderNotional = new utils.Decimal(newOrder.qty).mul(newOrder.price);
   for (let index = 0; index < positions.length; index++) {
     const position = positions[index];
-    let notional2 = new import_utils5.Decimal(position.position_qty).mul(position.mark_price);
+    let notional2 = new utils.Decimal(position.position_qty).mul(position.mark_price);
     if (newOrder.symbol === position.symbol) {
       currentPosition = position;
       notional2 = notional2.add(newOrderNotional);
@@ -814,26 +1198,26 @@ function estLiqPrice(inputs) {
   }
   const newMMR = Math.max(
     baseMMR,
-    new import_utils5.Decimal(baseMMR).div(baseIMR).mul(IMR_Factor).mul(
+    new utils.Decimal(baseMMR).div(baseIMR).mul(IMR_Factor).mul(
       newOrderNotional.add(
-        !!currentPosition ? new import_utils5.Decimal(currentPosition.position_qty).mul(
+        !!currentPosition ? new utils.Decimal(currentPosition.position_qty).mul(
           currentPosition.mark_price
-        ) : import_utils5.zero
+        ) : utils.zero
       ).abs()
     ).toPower(4 / 5).toNumber()
   );
-  const newQty = new import_utils5.Decimal(newOrder.qty).add(
+  const newQty = new utils.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_utils5.zero)) {
+  if (denominator.eq(utils.zero)) {
     return 0;
   }
-  const price = new import_utils5.Decimal(basePrice).add(
-    new import_utils5.Decimal(totalCollateral2).sub(newTotalMM).sub(orderFee2).div(denominator)
+  const price = new utils.Decimal(basePrice).add(
+    new utils.Decimal(totalCollateral2).sub(newTotalMM).sub(orderFee2).div(denominator)
   ).toNumber();
   return Math.max(0, price);
 }
@@ -844,42 +1228,41 @@ function estLeverage(inputs) {
   }
   let hasPosition = false;
   let sumPositionNotional = positions.reduce((acc, cur) => {
-    let count = new import_utils5.Decimal(cur.position_qty).mul(cur.mark_price);
+    let count = new utils.Decimal(cur.position_qty).mul(cur.mark_price);
     if (cur.symbol === newOrder.symbol) {
       hasPosition = true;
-      count = count.add(new import_utils5.Decimal(newOrder.qty).mul(newOrder.price));
+      count = count.add(new utils.Decimal(newOrder.qty).mul(newOrder.price));
     }
     return acc.add(count.abs());
-  }, import_utils5.zero);
+  }, utils.zero);
   if (!hasPosition) {
     sumPositionNotional = sumPositionNotional.add(
-      new import_utils5.Decimal(newOrder.qty).mul(newOrder.price).abs()
+      new utils.Decimal(newOrder.qty).mul(newOrder.price).abs()
     );
   }
-  if (sumPositionNotional.eq(import_utils5.zero)) {
+  if (sumPositionNotional.eq(utils.zero)) {
     return null;
   }
-  const totalMarginRatio2 = new import_utils5.Decimal(totalCollateral2).div(
+  const totalMarginRatio2 = new utils.Decimal(totalCollateral2).div(
     sumPositionNotional
   );
-  return new import_utils5.Decimal(1).div(totalMarginRatio2).toDecimalPlaces(2, import_utils5.Decimal.ROUND_HALF_EVEN).toNumber();
+  return new utils.Decimal(1).div(totalMarginRatio2).toDecimalPlaces(2, utils.Decimal.ROUND_HALF_EVEN).toNumber();
 }
 function tpslROI(inputs) {
-  const direction = (0, import_utils5.getTPSLDirection)({
+  const direction = utils.getTPSLDirection({
     side: inputs.side,
     type: inputs.type,
     closePrice: inputs.closePrice,
     orderPrice: inputs.orderPrice
   });
   const { closePrice, orderPrice, leverage } = inputs;
-  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 = {
-  account,
-  order,
-  orderUtils,
-  positions,
-  version
-});
+  return new utils.Decimal(closePrice).minus(orderPrice).div(orderPrice).mul(leverage).abs().mul(direction).toNumber();
+}
+
+exports.account = account_exports;
+exports.order = order_exports;
+exports.orderUtils = order_exports;
+exports.positions = positions_exports;
+exports.version = version_default;
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map