@orderly.network/hooks 2.10.2-alpha.0 → 2.11.0-alpha.0

package/dist/index.js

@@ -64,9 +64,9 @@ var __export = (target, all) => {
 // src/version.ts
 if (typeof window !== "undefined") {
   window.__ORDERLY_VERSION__ = window.__ORDERLY_VERSION__ || {};
-  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.10.2-alpha.0";
+  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.11.0-alpha.0";
 }
-var version_default = "2.10.2-alpha.0";
+var version_default = "2.11.0-alpha.0";
 var fetcher = (url, init2 = {}, queryOptions) => net.get(url, init2, queryOptions?.formatter);
 var noCacheConfig = {
   dedupingInterval: 0,
@@ -1110,12 +1110,12 @@ var findTPSLOrderPriceFromOrder = (order) => {
     sl_order_price
   };
 };
-var findPositionTPSLFromOrders = (orders, symbol) => {
+var findPositionTPSLFromOrders = (orders, symbol, marginMode = types.MarginMode.CROSS) => {
   const fullPositionOrder = orders?.find((order) => {
-    return order.symbol === symbol && order.algo_type === types.AlgoOrderRootType.POSITIONAL_TP_SL && (order.root_algo_status === types.OrderStatus.NEW || order.root_algo_status === types.OrderStatus.REPLACED || order.root_algo_status === types.OrderStatus.PARTIAL_FILLED);
+    return order.symbol === symbol && order.algo_type === types.AlgoOrderRootType.POSITIONAL_TP_SL && order.margin_mode === marginMode && (order.root_algo_status === types.OrderStatus.NEW || order.root_algo_status === types.OrderStatus.REPLACED || order.root_algo_status === types.OrderStatus.PARTIAL_FILLED);
   });
   const partialPositionOrders = orders?.filter((order) => {
-    return order.symbol === symbol && order.algo_type === types.AlgoOrderRootType.TP_SL && (order.root_algo_status === types.OrderStatus.NEW || order.root_algo_status === types.OrderStatus.REPLACED || order.root_algo_status === types.OrderStatus.PARTIAL_FILLED);
+    return order.symbol === symbol && order.margin_mode === marginMode && order.algo_type === types.AlgoOrderRootType.TP_SL && (order.root_algo_status === types.OrderStatus.NEW || order.root_algo_status === types.OrderStatus.REPLACED || order.root_algo_status === types.OrderStatus.PARTIAL_FILLED);
   }).sort((a, b) => {
     return b.created_time - a.created_time;
   });
@@ -2140,9 +2140,11 @@ var useAppStore = zustand.create()(
       totalCollateral: utils.zero,
       totalValue: null,
       freeCollateral: utils.zero,
+      freeCollateralUSDCOnly: utils.zero,
       availableBalance: 0,
       unsettledPnL: 0,
-      totalUnrealizedROI: 0
+      totalUnrealizedROI: 0,
+      usdcHolding: 0
     },
     appState: {
       positionsLoading: false,
@@ -2163,9 +2165,11 @@ var useAppStore = zustand.create()(
             totalCollateral: utils.zero,
             totalValue: null,
             freeCollateral: utils.zero,
+            freeCollateralUSDCOnly: utils.zero,
             availableBalance: 0,
             unsettledPnL: 0,
-            totalUnrealizedROI: 0
+            totalUnrealizedROI: 0,
+            usdcHolding: 0
           };
         }, false);
       },
@@ -3961,25 +3965,27 @@ var OrderbookService = class _OrderbookService {
 };
 var orderBookService = OrderbookService.getInstance();
 var orderbook_service_default = orderBookService;
+var useMarkPriceStore = zustand.create((set, get3) => ({
+  markPrices: {},
+  // orderBook: {},
+  // ask_bid: [],
+  actions: {
+    updateMarkPrice: (markPrice) => {
+      set({
+        markPrices: markPrice
+      });
+    },
+    getMarkPriceBySymbol: (symbol) => {
+      return get3().markPrices[symbol];
+    }
+  }
+}));
+var useMarkPriceBySymbol = (symbol) => useMarkPriceStore((state) => state.actions.getMarkPriceBySymbol(symbol));
+var useMarkPriceActions = () => useMarkPriceStore((state) => state.actions);
+
+// src/orderly/useMarkPrice.ts
 var useMarkPrice = (symbol) => {
-  const ws = useWS();
-  const [price, setPrice] = React.useState(0);
-  const symbolRef = React.useRef(symbol);
-  symbolRef.current = symbol;
-  React.useEffect(() => {
-    const unsubscribe = ws.subscribe(`${symbol}@markprice`, {
-      onMessage: (message) => {
-        if (message.symbol !== symbolRef.current) {
-          unsubscribe?.();
-          return;
-        }
-        setPrice(message.price);
-      }
-    });
-    return () => {
-      unsubscribe?.();
-    };
-  }, [symbol]);
+  const price = useMarkPriceBySymbol(symbol);
   return { data: price };
 };
 var useIndexPrice = (symbol) => {
@@ -4002,6 +4008,12 @@ var useIndexPrice = (symbol) => {
     };
   });
 };
+
+// src/orderly/useMarkPricesStream.ts
+var useMarkPricesStream = () => {
+  const data = useMarkPriceStore((state) => state.markPrices);
+  return { data };
+};
 var useOpenInterest = (symbol) => {
   const ws = useWS();
   const symbolRef = React.useRef(symbol);
@@ -4021,29 +4033,6 @@ var useOpenInterest = (symbol) => {
     };
   });
 };
-var useMarkPriceStore = zustand.create((set, get3) => ({
-  markPrices: {},
-  // orderBook: {},
-  // ask_bid: [],
-  actions: {
-    updateMarkPrice: (markPrice) => {
-      set({
-        markPrices: markPrice
-      });
-    },
-    getMarkPriceBySymbol: (symbol) => {
-      return get3().markPrices[symbol];
-    }
-  }
-}));
-var useMarkPriceBySymbol = (symbol) => useMarkPriceStore((state) => state.actions.getMarkPriceBySymbol(symbol));
-var useMarkPriceActions = () => useMarkPriceStore((state) => state.actions);
-
-// src/orderly/useMarkPricesStream.ts
-var useMarkPricesStream = () => {
-  const data = useMarkPriceStore((state) => state.markPrices);
-  return { data };
-};
 
 // src/orderly/useTickerStream.ts
 var useTickerStream = (symbol) => {
@@ -4736,6 +4725,94 @@ var useLeverage = () => {
     maxLeverage: memoizedMaxLeverage
   };
 };
+var buildKey = (symbol, marginMode) => `${symbol}_${marginMode ?? types.MarginMode.CROSS}`;
+var useSymbolLeverageMap = () => {
+  const { data, error, isLoading, mutate: mutate6 } = usePrivateQuery("/v1/client/leverages", {
+    revalidateOnFocus: false,
+    revalidateOnReconnect: false,
+    errorRetryCount: 1
+  });
+  const leverages = React.useMemo(() => {
+    if (!data || !Array.isArray(data)) return {};
+    const map = {};
+    for (const item of data) {
+      const key = buildKey(item.symbol, item.margin_mode);
+      map[key] = item.leverage;
+    }
+    return map;
+  }, [data]);
+  const getSymbolLeverage = (symbol, marginMode) => {
+    if (!symbol) return void 0;
+    const key = buildKey(symbol, marginMode);
+    return leverages[key];
+  };
+  return {
+    leverages,
+    getSymbolLeverage,
+    isLoading,
+    error,
+    refresh: mutate6
+  };
+};
+var useMarginModes = () => {
+  const { data, error, isLoading, mutate: mutate6 } = usePrivateQuery("/v1/client/margin_modes", {
+    revalidateOnFocus: false,
+    revalidateOnMount: true
+  });
+  const [setMarginModeInternal, { isMutating }] = useMutation(
+    "/v1/client/margin_mode",
+    "POST"
+  );
+  const marginModes = React.useMemo(() => {
+    if (!data || !Array.isArray(data)) return {};
+    const map = {};
+    for (const item of data) {
+      map[item.symbol] = item.default_margin_mode;
+    }
+    return map;
+  }, [data]);
+  const setMarginMode = (payload) => setMarginModeInternal(payload);
+  const updateMarginMode = React.useCallback(
+    async (payload) => {
+      const result = await setMarginMode(payload);
+      if (result.success) {
+        await mutate6();
+        return result;
+      }
+      throw new Error(result.message ?? "Failed to update margin mode");
+    },
+    [setMarginMode, mutate6]
+  );
+  return {
+    marginModes,
+    isLoading,
+    error,
+    refresh: mutate6,
+    setMarginMode,
+    updateMarginMode,
+    isMutating
+  };
+};
+var useMarginModeBySymbol = (symbol, fallback = types.MarginMode.CROSS) => {
+  const { marginModes, isLoading, error, refresh, updateMarginMode } = useMarginModes();
+  const marginMode = fallback === null ? marginModes[symbol] : marginModes[symbol] ?? fallback;
+  const update = React.useCallback(
+    async (mode) => {
+      return updateMarginMode({
+        symbol_list: [symbol],
+        default_margin_mode: mode
+      });
+    },
+    [symbol, updateMarginMode]
+  );
+  return {
+    marginMode,
+    isLoading,
+    error,
+    refresh,
+    update
+  };
+};
 
 // src/orderly/useOdosQuote.ts
 var useOdosQuote = () => {
@@ -5093,10 +5170,13 @@ var CalculatorService = class {
   //   this.pendingCalc = [];
   // }
   async handleCalcQueue(context) {
-    const first = this.calcQueue.shift();
-    if (first) {
+    const batchCollector = /* @__PURE__ */ new Map();
+    let currentContext = context;
+    while (this.calcQueue.length > 0) {
+      const first = this.calcQueue.shift();
+      if (!first) break;
       const { scope, data, options } = first;
-      const ctx = context || CalculatorContext.create(scope, data);
+      const ctx = currentContext || CalculatorContext.create(scope, data);
       const calculators = this.calculators.get(scope);
       if (Array.isArray(calculators) && calculators.length) {
         try {
@@ -5104,13 +5184,46 @@ var CalculatorService = class {
         } catch (e) {
         }
         if (!options?.skipUpdate) {
-          this.scheduler.update(scope, calculators, ctx.outputToValue());
+          this.collectUpdates(
+            batchCollector,
+            scope,
+            calculators,
+            ctx.outputToValue()
+          );
         }
       }
-      if (this.calcQueue.length) {
-        this.handleCalcQueue(ctx);
+      currentContext = ctx;
+    }
+    await this.commitBatchUpdates(batchCollector);
+    this.ctx = currentContext;
+  }
+  collectUpdates(collector, scope, calculators, data) {
+    if (!collector.has(scope)) {
+      collector.set(scope, /* @__PURE__ */ new Map());
+    }
+    const scopeCollector = collector.get(scope);
+    for (const calculator of calculators) {
+      const item = data[calculator.name];
+      if (item !== void 0 && item !== null) {
+        scopeCollector.set(calculator.name, item);
+      }
+    }
+  }
+  async commitBatchUpdates(collector) {
+    if (collector.size === 0) return;
+    for (const [scope, updateMap] of collector.entries()) {
+      const calculators = this.calculators.get(scope);
+      if (!Array.isArray(calculators)) continue;
+      const batchData = {};
+      for (const [calculatorName, data] of updateMap.entries()) {
+        batchData[calculatorName] = data;
+      }
+      try {
+        this.scheduler.update(scope, calculators, batchData);
+      } catch (e) {
       }
     }
+    collector.clear();
   }
   stop() {
     this.calcQueue = [];
@@ -5141,6 +5254,18 @@ var cancelIdleCallbackPolyfill = (id) => {
 var safeRequestIdleCallback = typeof window !== "undefined" && window.requestIdleCallback ? window.requestIdleCallback.bind(window) : requestIdleCallbackPolyfill;
 typeof window !== "undefined" && window.cancelIdleCallback ? window.cancelIdleCallback.bind(window) : cancelIdleCallbackPolyfill;
 var ShardingScheduler = class {
+  constructor() {
+    /**
+     * Maximum continuous execution time per frame (in milliseconds)
+     * Prevents blocking the main thread for too long
+     */
+    this.MAX_CONTINUOUS_MS = 5;
+    /**
+     * Minimum remaining idle time threshold (in milliseconds)
+     * Ensures the browser has enough idle time for other tasks
+     */
+    this.MIN_IDLE_REMAINING = 2;
+  }
   // run(calculators: Calculator[]) {}
   calc(scope, calculators, data, ctx) {
     return new Promise((resolve, reject) => {
@@ -5181,28 +5306,27 @@ var ShardingScheduler = class {
   computation(data, processor, onComplete) {
     let index = 0;
     const results = [];
-    const estimatedShardSize = Math.min(data.length, 2);
-    function processNextShard(deadline) {
-      let shardSize = estimatedShardSize;
-      while (index + shardSize <= data.length && deadline.timeRemaining() > 0) {
-        const shard = data.slice(index, index + shardSize);
-        const result = processor(shard);
-        results.push(result);
-        index += shardSize;
-        if (deadline.timeRemaining() < 1) {
-          shardSize = Math.max(1, Math.floor(shardSize / 2));
-        } else {
-          shardSize = Math.min(data.length - index, shardSize * 2);
+    const MAX_CONTINUOUS_MS = this.MAX_CONTINUOUS_MS;
+    const MIN_IDLE_REMAINING = this.MIN_IDLE_REMAINING;
+    const processNextShard = (deadline) => {
+      const frameStart = performance.now();
+      while (index < data.length) {
+        const elapsed = performance.now() - frameStart;
+        const remaining = deadline.timeRemaining();
+        if (elapsed > MAX_CONTINUOUS_MS || remaining < MIN_IDLE_REMAINING) {
+          safeRequestIdleCallback(processNextShard, {
+            timeout: 1e3
+          });
+          return;
         }
+        const result = processor([data[index]]);
+        if (result && result.length > 0) {
+          results.push(...result);
+        }
+        index++;
       }
-      if (index < data.length) {
-        safeRequestIdleCallback(processNextShard, {
-          timeout: 1e3
-        });
-      } else {
-        onComplete(results.flat());
-      }
-    }
+      onComplete(results);
+    };
     safeRequestIdleCallback(processNextShard, {
       timeout: 1e3
     });
@@ -5415,21 +5539,38 @@ var PositionCalculator = class extends BaseCalculator {
     const unsettlementPnL = unsettlementPnL_total.toNumber();
     let totalUnrealizedROI = 0, totalUnrealizedROI_index = 0;
     if (portfolio) {
-      const { totalValue, totalCollateral } = portfolio;
+      const { totalValue, totalCollateral: crossMarginCollateral } = portfolio;
       rows = rows.map((item) => {
         const info = symbolsInfo[item.symbol];
-        const est_liq_price = perp.positions.liqPrice({
-          symbol: item.symbol,
-          markPrice: item.mark_price,
-          totalCollateral: totalCollateral.toNumber(),
-          positionQty: item.position_qty,
-          positions: rows,
-          MMR: item.mmr,
-          baseMMR: info?.["base_mmr"],
-          baseIMR: info?.["base_imr"],
-          IMRFactor: accountInfo.imr_factor[item.symbol],
-          costPosition: item.cost_position
-        });
+        const totalCollateral = item.margin_mode === types.MarginMode.ISOLATED ? new utils.Decimal(item.margin ?? 0).add(item.unsettlement_pnl ?? 0).toNumber() : crossMarginCollateral.toNumber();
+        let est_liq_price;
+        if (item.margin_mode === types.MarginMode.ISOLATED) {
+          est_liq_price = perp.positions.liquidationPriceIsolated({
+            isolatedPositionMargin: item.margin ?? 0,
+            costPosition: item.cost_position ?? 0,
+            positionQty: item.position_qty ?? 0,
+            sumUnitaryFunding: fundingRates?.[item.symbol]?.["sum_unitary_funding"] ?? 0,
+            lastSumUnitaryFunding: item.last_sum_unitary_funding ?? 0,
+            baseMMR: info?.["base_mmr"] ?? 0,
+            baseIMR: info?.["base_imr"] ?? 0,
+            IMRFactor: accountInfo.imr_factor[item.symbol],
+            referencePrice: item.mark_price,
+            leverage: item.leverage ?? 0
+          });
+        } else {
+          est_liq_price = perp.positions.liqPrice({
+            symbol: item.symbol,
+            markPrice: item.mark_price,
+            totalCollateral,
+            positionQty: item.position_qty,
+            positions: rows,
+            MMR: item.mmr,
+            baseMMR: info?.["base_mmr"],
+            baseIMR: info?.["base_imr"],
+            IMRFactor: accountInfo.imr_factor[item.symbol],
+            costPosition: item.cost_position
+          });
+        }
         return {
           ...item,
           est_liq_price
@@ -5580,7 +5721,9 @@ var PortfolioCalculator = class extends BaseCalculator {
             return {
               ...item,
               holding: data.holding[item.token].holding,
-              frozen: data.holding[item.token].frozen
+              frozen: data.holding[item.token].frozen,
+              isolatedMargin: data.holding[item.token].isolatedMargin,
+              isolatedOrderFrozen: data.holding[item.token].isolatedOrderFrozen
             };
           }
           return item;
@@ -5616,7 +5759,14 @@ var PortfolioCalculator = class extends BaseCalculator {
     if (!holding || !positions3 || !Array.isArray(positions3.rows) || !markPrices || !indexPrices || !accountInfo) {
       return null;
     }
-    const unsettledPnL = ramda.pathOr(0, ["total_unsettled_pnl"])(positions3);
+    const totallCrossUnsettledPnL = positions3.rows.reduce(
+      (sum, pos) => pos.margin_mode === types.MarginMode.ISOLATED ? sum : sum + (pos.unsettled_pnl ?? 0),
+      0
+    );
+    const totalUnsettlementPnL = positions3.rows.reduce(
+      (sum, pos) => sum + (pos.unsettled_pnl ?? 0),
+      0
+    );
     const unrealizedPnL = ramda.pathOr(0, ["total_unreal_pnl"])(positions3);
     const [USDC_holding, nonUSDC] = parseHolding(
       holding,
@@ -5627,28 +5777,51 @@ var PortfolioCalculator = class extends BaseCalculator {
     const totalCollateral = perp.account.totalCollateral({
       USDCHolding: USDC_holding,
       nonUSDCHolding: nonUSDC,
-      unsettlementPnL: unsettledPnL
+      unsettlementPnL: totallCrossUnsettledPnL,
+      usdcBalancePendingShortQty: usdc?.pending_short ?? 0,
+      usdcBalanceIsolatedOrderFrozen: usdc?.isolated_order_frozen ?? 0
     });
+    const sumIsolatedMargin = positions3.rows.reduce((acc, curr) => {
+      if (curr.margin_mode !== types.MarginMode.ISOLATED) {
+        return acc;
+      }
+      return acc.add(curr.margin ?? 0);
+    }, utils.zero);
     const totalValue = perp.account.totalValue({
-      totalUnsettlementPnL: unsettledPnL,
+      totalUnsettlementPnL,
       USDCHolding: USDC_holding,
-      nonUSDCHolding: nonUSDC
+      nonUSDCHolding: nonUSDC,
+      totalIsolatedPositionMargin: sumIsolatedMargin.toNumber()
     });
     const totalUnrealizedROI = perp.account.totalUnrealizedROI({
       totalUnrealizedPnL: unrealizedPnL,
       totalValue: totalValue.toNumber()
     });
+    const maxLeverageBySymbol = positions3.rows.reduce(
+      (acc, position) => {
+        if (position.margin_mode !== types.MarginMode.ISOLATED && position.leverage && !acc[position.symbol]) {
+          acc[position.symbol] = position.leverage;
+        }
+        return acc;
+      },
+      {}
+    );
     const totalInitialMarginWithOrders = perp.account.totalInitialMarginWithQty({
       positions: positions3.rows,
+      orders: [],
       markPrices,
       IMR_Factors: accountInfo.imr_factor,
-      maxLeverage: accountInfo.max_leverage,
+      maxLeverageBySymbol,
       symbolInfo: createGetter({ ...symbolsInfo })
     });
     const freeCollateral = perp.account.freeCollateral({
       totalCollateral,
       totalInitialMarginWithOrders
     });
+    const freeCollateralUSDCOnly = perp.account.freeCollateralUSDCOnly({
+      freeCollateral,
+      nonUSDCHolding: nonUSDC
+    });
     const availableBalance = perp.account.availableBalance({
       USDCHolding: usdc?.holding ?? 0,
       unsettlementPnL: positions3.total_unsettled_pnl ?? 0
@@ -5659,8 +5832,10 @@ var PortfolioCalculator = class extends BaseCalculator {
       totalUnrealizedROI,
       freeCollateral,
       availableBalance,
-      unsettledPnL,
-      holding
+      unsettledPnL: totalUnsettlementPnL,
+      holding,
+      usdcHolding: USDC_holding,
+      freeCollateralUSDCOnly
     };
   }
   update(data, scope) {
@@ -5669,10 +5844,12 @@ var PortfolioCalculator = class extends BaseCalculator {
         totalCollateral: data.totalCollateral,
         totalValue: data.totalValue,
         freeCollateral: data.freeCollateral,
+        freeCollateralUSDCOnly: data.freeCollateralUSDCOnly,
         availableBalance: data.availableBalance,
         totalUnrealizedROI: data.totalUnrealizedROI,
         unsettledPnL: data.unsettledPnL,
-        holding: Array.isArray(data.holding) ? data.holding : []
+        holding: Array.isArray(data.holding) ? data.holding : [],
+        usdcHolding: typeof data.usdcHolding === "number" ? data.usdcHolding : data.usdcHolding.toNumber()
       });
     }
   }
@@ -5803,7 +5980,7 @@ var usePositionStream = (symbol = "all", options) => {
     }
     if (Array.isArray(tpslOrders) && tpslOrders.length) {
       rows = rows.map((item) => {
-        const { fullPositionOrder, partialPositionOrders } = findPositionTPSLFromOrders(tpslOrders, item.symbol);
+        const { fullPositionOrder, partialPositionOrders } = findPositionTPSLFromOrders(tpslOrders, item.symbol, item.margin_mode);
         const full_tp_sl = fullPositionOrder ? findTPSLFromOrder(fullPositionOrder) : void 0;
         const partialPossitionOrder = partialPositionOrders && partialPositionOrders.length ? partialPositionOrders[0] : void 0;
         const partial_tp_sl = partialPossitionOrder ? findTPSLFromOrder(partialPossitionOrder) : void 0;
@@ -5935,15 +6112,21 @@ var useOrderStream = (params, options) => {
       }
     };
   }, [normalOrderKeyFn, options?.keeplive]);
-  const normalOrdersResponse = usePrivateInfiniteQuery(normalOrderKeyFn, {
-    initialSize: 1,
-    formatter: (data) => data,
-    revalidateOnFocus: false
-  });
-  const algoOrdersResponse = usePrivateInfiniteQuery(algoOrderKeyFn, {
-    formatter: (data) => data,
-    revalidateOnFocus: false
-  });
+  const normalOrdersResponse = usePrivateInfiniteQuery(
+    normalOrderKeyFn,
+    {
+      initialSize: 1,
+      formatter: (data) => data,
+      revalidateOnFocus: false
+    }
+  );
+  const algoOrdersResponse = usePrivateInfiniteQuery(
+    algoOrderKeyFn,
+    {
+      formatter: (data) => data,
+      revalidateOnFocus: false
+    }
+  );
   const flattenOrders = React.useMemo(() => {
     if (!normalOrdersResponse.data || !algoOrdersResponse.data && !sourceTypeAll) {
       return null;
@@ -6061,7 +6244,9 @@ var useOrderStream = (params, options) => {
             // trailing stop order fields
             activated_price: order.activated_price,
             callback_value: order.callback_value,
-            callback_rate: order.callback_rate
+            callback_rate: order.callback_rate,
+            // Include margin_mode if present
+            ...order.margin_mode && { margin_mode: order.margin_mode }
           });
         default:
           return doUpdateOrder({ ...order, order_id: orderId });
@@ -6256,7 +6441,14 @@ function formatPortfolio(inputs) {
   if (!holding || !positions3 || !Array.isArray(positions3.rows) || !markPrices || !indexPrices || !accountInfo || symbolsInfo?.isNil) {
     return null;
   }
-  const unsettledPnL = ramda.pathOr(0, ["total_unsettled_pnl"])(positions3);
+  const totallCrossUnsettledPnL = positions3.rows.reduce(
+    (sum, pos) => pos.margin_mode === types.MarginMode.ISOLATED ? sum : sum + (pos.unsettled_pnl ?? 0),
+    0
+  );
+  const totalUnsettlementPnL = positions3.rows.reduce(
+    (sum, pos) => sum + (pos.unsettled_pnl ?? 0),
+    0
+  );
   const unrealizedPnL = ramda.pathOr(0, ["total_unreal_pnl"])(positions3);
   const [USDC_holding, nonUSDC] = parseHolding(
     holding,
@@ -6267,29 +6459,51 @@ function formatPortfolio(inputs) {
   const totalCollateral = perp.account.totalCollateral({
     USDCHolding: USDC_holding,
     nonUSDCHolding: nonUSDC,
-    unsettlementPnL: unsettledPnL
+    unsettlementPnL: totallCrossUnsettledPnL,
+    usdcBalancePendingShortQty: usdc?.pending_short ?? 0,
+    usdcBalanceIsolatedOrderFrozen: usdc?.isolated_order_frozen ?? 0
   });
+  const sumIsolatedMargin = positions3.rows.reduce((acc, curr) => {
+    if (curr.margin_mode !== types.MarginMode.ISOLATED) {
+      return acc;
+    }
+    return acc.add(curr.margin ?? 0);
+  }, utils.zero);
   const totalValue = perp.account.totalValue({
-    totalUnsettlementPnL: unsettledPnL,
+    totalUnsettlementPnL,
     USDCHolding: USDC_holding,
-    nonUSDCHolding: nonUSDC
+    nonUSDCHolding: nonUSDC,
+    totalIsolatedPositionMargin: sumIsolatedMargin.toNumber()
   });
   const totalUnrealizedROI = perp.account.totalUnrealizedROI({
     totalUnrealizedPnL: unrealizedPnL,
     totalValue: totalValue.toNumber()
   });
+  const maxLeverageBySymbol = positions3.rows.reduce(
+    (acc, position) => {
+      if (position.margin_mode !== types.MarginMode.ISOLATED && position.leverage && !acc[position.symbol]) {
+        acc[position.symbol] = position.leverage;
+      }
+      return acc;
+    },
+    {}
+  );
   const totalInitialMarginWithOrders = perp.account.totalInitialMarginWithQty({
     positions: positions3.rows,
+    orders: [],
     markPrices,
     IMR_Factors: accountInfo.imr_factor,
-    // Not used
-    maxLeverage: accountInfo.max_leverage,
-    symbolInfo: symbolsInfo
+    maxLeverageBySymbol,
+    symbolInfo: createGetter({ ...symbolsInfo })
   });
   const freeCollateral = perp.account.freeCollateral({
     totalCollateral,
     totalInitialMarginWithOrders
   });
+  const freeCollateralUSDCOnly = perp.account.freeCollateralUSDCOnly({
+    freeCollateral,
+    nonUSDCHolding: nonUSDC
+  });
   const availableBalance = perp.account.availableBalance({
     USDCHolding: usdc?.holding ?? 0,
     unsettlementPnL: positions3.total_unsettled_pnl ?? 0
@@ -6300,8 +6514,9 @@ function formatPortfolio(inputs) {
     totalUnrealizedROI,
     freeCollateral,
     availableBalance,
-    unsettledPnL,
-    holding
+    unsettledPnL: totalUnsettlementPnL,
+    holding,
+    freeCollateralUSDCOnly
   };
 }
 function formatPositions(data, accountInfo, symbolsInfo, fundingRates) {
@@ -6821,7 +7036,9 @@ var useSubAccountAlgoOrderStream = (params, options) => {
             // trailing stop order fields
             activated_price: order.activated_price,
             callback_value: order.callback_value,
-            callback_rate: order.callback_rate
+            callback_rate: order.callback_rate,
+            // include margin_mode if present (align with useOrderStream)
+            ...order.margin_mode && { margin_mode: order.margin_mode }
           });
         default:
           return doUpdateOrder({ ...order, order_id: orderId });
@@ -7008,120 +7225,122 @@ var useCollateral = (options = { dp: 6 }) => {
     totalCollateral,
     totalValue,
     freeCollateral,
+    freeCollateralUSDCOnly,
     availableBalance,
     unsettledPnL,
-    holding
+    holding,
+    usdcHolding
   } = useAppStore((state) => state.portfolio);
   const accountInfo = useAppStore((state) => state.accountInfo);
   return {
     totalCollateral: totalCollateral.toDecimalPlaces(dp).toNumber(),
     freeCollateral: freeCollateral.toDecimalPlaces(dp).toNumber(),
+    freeCollateralUSDCOnly: freeCollateralUSDCOnly.toDecimalPlaces(dp).toNumber(),
     totalValue: totalValue?.toDecimalPlaces(dp).toNumber() ?? null,
     availableBalance,
     unsettledPnL,
     accountInfo,
-    holding
+    holding,
+    usdcHolding
     // @hidden
     // positions: positionsPath(positions),
   };
 };
-var useLeverageBySymbol = (symbol) => {
-  const { state } = useAccount();
-  const ws = useWS();
-  const { data } = usePrivateQuery(
-    symbol ? `/v1/client/leverage?symbol=${symbol}` : null,
-    {
-      revalidateOnFocus: false
-    }
-  );
-  React.useEffect(() => {
-    if (!state.accountId || !symbol) return;
-    const unsubscribe = ws.privateSubscribe("account", {
-      onMessage: (data2) => {
-        const res = data2?.accountDetail?.symbolLeverage || {};
-        if (res.symbol === symbol) {
-          const key = [`/v1/client/leverage?symbol=${symbol}`, state.accountId];
-          useSWR5.mutate(
-            key,
-            (prevData) => {
-              return {
-                ...prevData,
-                leverage: res.leverage
-              };
-            },
-            {
-              revalidate: false
-            }
-          );
-        }
-      }
-    });
-    return () => unsubscribe?.();
-  }, [symbol, state.accountId]);
-  return data?.leverage;
+
+// src/orderly/useLeverageBySymbol.ts
+var useLeverageBySymbol = (symbol, marginMode) => {
+  const { getSymbolLeverage } = useSymbolLeverageMap();
+  return getSymbolLeverage(symbol, marginMode);
 };
 
 // src/orderly/useMaxQty.ts
-var useMaxQty = (symbol, side, reduceOnly = false) => {
+function useMaxQty(symbol, side, reduceOnlyOrOptions, marginMode) {
+  const reduceOnly = typeof reduceOnlyOrOptions === "object" && reduceOnlyOrOptions !== null ? reduceOnlyOrOptions.reduceOnly ?? false : reduceOnlyOrOptions ?? false;
+  const finalMarginMode = typeof reduceOnlyOrOptions === "object" && reduceOnlyOrOptions !== null ? reduceOnlyOrOptions.marginMode ?? types.MarginMode.CROSS : marginMode ?? types.MarginMode.CROSS;
   const positions3 = usePositions();
   const accountInfo = useAccountInfo();
   const symbolInfo = useSymbolsInfo();
-  const { totalCollateral } = useCollateral();
+  const { totalCollateral, freeCollateralUSDCOnly } = useCollateral();
   const { data: markPrices } = useMarkPricesStream();
-  const symbolLeverage = useLeverageBySymbol(symbol);
+  const symbolLeverage = useLeverageBySymbol(symbol, finalMarginMode);
   const maxQty = React.useMemo(() => {
     if (!symbol) return 0;
-    const positionQty = perp.account.getQtyFromPositions(
-      positions3 === null ? [] : positions3,
-      symbol
+    if (!markPrices || !markPrices[symbol] || !accountInfo || !positions3) {
+      return 0;
+    }
+    const positionsArray = (positions3 === null ? [] : positions3).filter(
+      (position) => position.margin_mode === finalMarginMode
     );
+    const positionQty = perp.account.getQtyFromPositions(positionsArray, symbol);
     if (reduceOnly) {
-      if (positionQty > 0) {
-        if (side === types.OrderSide.BUY) {
-          return 0;
-        } else {
-          return Math.abs(positionQty);
-        }
-      }
-      if (positionQty < 0) {
-        if (side === types.OrderSide.BUY) {
-          return Math.abs(positionQty);
-        } else {
-          return 0;
-        }
-      }
-      return 0;
+      if (positionQty === 0) return 0;
+      return side === types.OrderSide.BUY ? positionQty < 0 ? Math.abs(positionQty) : 0 : positionQty > 0 ? positionQty : 0;
     }
-    if (!markPrices || !markPrices[symbol] || !accountInfo || !positions3)
-      return 0;
     const getSymbolInfo = symbolInfo[symbol];
-    const currentSymbolPosition = positions3.find(
-      (item) => item.symbol === symbol
-    );
+    let currentSymbolPosition;
+    const otherPositions = [];
+    for (const position of positionsArray) {
+      if (position.symbol === symbol) {
+        currentSymbolPosition = position;
+      } else {
+        otherPositions.push(position);
+      }
+    }
+    const markPrice = markPrices[symbol];
+    const baseIMR = getSymbolInfo("base_imr") ?? 0;
+    const IMR_Factor = accountInfo.imr_factor[symbol] ?? 0;
+    const leverage = symbolLeverage || currentSymbolPosition?.leverage || 1;
     const buyOrdersQty = currentSymbolPosition?.pending_long_qty ?? 0;
     const sellOrdersQty = currentSymbolPosition?.pending_short_qty ?? 0;
-    const otherPositions = !Array.isArray(positions3) ? [] : positions3.filter((item) => item.symbol !== symbol);
+    if (finalMarginMode === types.MarginMode.ISOLATED) {
+      const availableBalance = freeCollateralUSDCOnly;
+      const pendingLongOrders = buyOrdersQty > 0 ? [{ referencePrice: markPrice, quantity: buyOrdersQty }] : [];
+      const pendingSellOrders = sellOrdersQty > 0 ? [{ referencePrice: markPrice, quantity: sellOrdersQty }] : [];
+      const markPriceDecimal = new utils.Decimal(markPrice);
+      const leverageDecimal = new utils.Decimal(leverage);
+      const isoOrderFrozenLong = buyOrdersQty > 0 ? markPriceDecimal.mul(buyOrdersQty).div(leverageDecimal).toNumber() : 0;
+      const isoOrderFrozenShort = sellOrdersQty > 0 ? markPriceDecimal.mul(sellOrdersQty).div(leverageDecimal).toNumber() : 0;
+      const symbolMaxNotional = accountInfo.max_notional?.[symbol] ?? perp.positions.maxPositionNotional({
+        leverage,
+        IMRFactor: IMR_Factor
+      });
+      const currentOrderReferencePrice = typeof reduceOnlyOrOptions === "object" && reduceOnlyOrOptions !== null && typeof reduceOnlyOrOptions.currentOrderReferencePrice === "number" && reduceOnlyOrOptions.currentOrderReferencePrice > 0 ? reduceOnlyOrOptions.currentOrderReferencePrice : markPrice;
+      return perp.account.maxQtyForIsolatedMargin({
+        symbol,
+        orderSide: side,
+        currentOrderReferencePrice,
+        availableBalance,
+        leverage,
+        baseIMR,
+        IMR_Factor,
+        markPrice,
+        positionQty,
+        pendingLongOrders,
+        pendingSellOrders,
+        isoOrderFrozenLong,
+        isoOrderFrozenShort,
+        symbolMaxNotional
+      });
+    }
     const otherIMs = perp.account.otherIMs({
       positions: otherPositions,
       symbolInfo,
       markPrices,
-      IMR_Factors: accountInfo.imr_factor,
-      // Not used
-      maxLeverage: accountInfo.max_leverage
+      IMR_Factors: accountInfo.imr_factor
     });
     return perp.account.maxQty(side, {
-      markPrice: markPrices[symbol],
+      markPrice,
       symbol,
       baseMaxQty: getSymbolInfo("base_max"),
       totalCollateral,
-      maxLeverage: symbolLeverage || currentSymbolPosition?.leverage || 1,
+      maxLeverage: leverage,
       takerFeeRate: accountInfo.futures_taker_fee_rate,
-      baseIMR: getSymbolInfo("base_imr"),
+      baseIMR,
       otherIMs,
       positionQty,
       buyOrdersQty,
       sellOrdersQty,
-      IMR_Factor: accountInfo.imr_factor[symbol]
+      IMR_Factor
     });
   }, [
     symbol,
@@ -7131,10 +7350,12 @@ var useMaxQty = (symbol, side, reduceOnly = false) => {
     accountInfo,
     symbolInfo,
     side,
-    totalCollateral
+    totalCollateral,
+    finalMarginMode,
+    symbolLeverage
   ]);
   return Math.max(maxQty, 0);
-};
+}
 var useMarginRatio = () => {
   const positions3 = usePositionStore((state2) => state2.positions.all);
   const { rows, notional } = positions3;
@@ -8440,29 +8661,67 @@ var usePrivateDataObserver = (options) => {
   }, [state.accountId, subOrder]);
   React.useEffect(() => {
     if (!state.accountId) return;
-    const key = ["/v1/positions", state.accountId];
+    const positionsKey = ["/v1/positions", state.accountId];
+    const leveragesKey = ["/v1/client/leverages", state.accountId];
     const unsubscribe = ws.privateSubscribe("account", {
       onMessage: (data) => {
-        const { symbol, leverage } = data?.accountDetail?.symbolLeverage || {};
-        if (symbol && leverage) {
-          useSWR5.mutate(
-            key,
-            (prevPositions) => {
-              if (prevPositions?.rows?.length) {
-                return {
-                  ...prevPositions,
-                  rows: prevPositions.rows.map((row) => {
-                    return row.symbol === symbol ? { ...row, leverage } : row;
-                  })
-                };
-              }
-              return prevPositions;
-            },
-            {
-              revalidate: false
-            }
-          );
+        const { symbol, leverage, marginMode } = data?.accountDetail?.symbolLeverage || {};
+        if (!symbol || leverage === void 0) {
+          return;
         }
+        useSWR5.mutate(
+          positionsKey,
+          (prevPositions) => {
+            if (prevPositions?.rows?.length) {
+              return {
+                ...prevPositions,
+                rows: prevPositions.rows.map((row) => {
+                  return row.symbol === symbol && row.margin_mode === marginMode ? { ...row, leverage } : row;
+                })
+              };
+            }
+            return prevPositions;
+          },
+          {
+            revalidate: false
+          }
+        );
+        useSWR5.mutate(
+          leveragesKey,
+          (prev) => {
+            if (!prev) {
+              return [
+                {
+                  symbol,
+                  leverage,
+                  margin_mode: marginMode
+                }
+              ];
+            }
+            const index = prev.findIndex(
+              (item) => item.symbol === symbol && (item.margin_mode ?? types.MarginMode.CROSS) === (marginMode ?? types.MarginMode.CROSS)
+            );
+            if (index === -1) {
+              return [
+                ...prev,
+                {
+                  symbol,
+                  leverage,
+                  margin_mode: marginMode
+                }
+              ];
+            }
+            const next = [...prev];
+            next[index] = {
+              ...next[index],
+              leverage
+            };
+            return next;
+          },
+          {
+            revalidate: false
+          }
+        );
       }
     });
     return () => unsubscribe?.();
@@ -8483,7 +8742,7 @@ var usePrivateDataObserver = (options) => {
                 ...prevPositions,
                 rows: prevPositions.rows.map((row) => {
                   const itemIndex = nextPositions.findIndex(
-                    (item) => item.symbol === row.symbol
+                    (item) => item.symbol === row.symbol && item.marginMode === row.margin_mode
                   );
                   if (itemIndex >= 0) {
                     const itemArr = nextPositions.splice(itemIndex, 1);
@@ -8666,14 +8925,70 @@ var OrderValidation = class {
 
 // src/services/orderCreator/baseCreator.ts
 var BaseOrderCreator = class {
-  baseOrder(data) {
+  /**
+   * Template method for order creation
+   * Defines the algorithm structure with hooks for subclasses
+   */
+  create(values, config) {
+    this.beforeCreate(values, config);
+    const order = this.buildOrder(values, config);
+    return this.afterCreate(order, config);
+  }
+  /**
+   * Template method for order validation
+   * Defines the algorithm structure with hooks for subclasses
+   */
+  validate(values, config) {
+    this.beforeValidate(values, config);
+    const errors = this.runValidations(values, config);
+    return Promise.resolve(this.afterValidate(errors, values, config));
+  }
+  /**
+   * Hook method called before order creation
+   * Subclasses can override to perform pre-creation setup
+   * @param values - Order values
+   * @param config - Configuration
+   */
+  beforeCreate(values, config) {
+  }
+  /**
+   * Hook method called after order creation
+   * Subclasses can override to perform post-creation processing
+   * @param order - The created order
+   * @param config - Configuration
+   * @returns The final order (possibly modified)
+   */
+  afterCreate(order, config) {
+    return order;
+  }
+  /**
+   * Hook method called before validation
+   * Subclasses can override to perform pre-validation setup
+   * @param values - Order values to validate
+   * @param config - Configuration
+   */
+  beforeValidate(values, config) {
+  }
+  /**
+   * Hook method called after validation
+   * Subclasses can override to perform post-validation processing
+   * @param errors - Validation errors found
+   * @param values - Original order values
+   * @param config - Configuration
+   * @returns Final validation result (possibly modified)
+   */
+  afterValidate(errors, values, config) {
+    return errors;
+  }
+  baseOrder(data) {
     const order = {
       symbol: data.symbol,
       order_type: data.order_type === types.OrderType.LIMIT ? !!data.order_type_ext ? data.order_type_ext : data.order_type : data.order_type,
       side: data.side,
       reduce_only: data.reduce_only,
       order_quantity: data.order_quantity,
-      total: data.total
+      total: data.total,
+      margin_mode: data.margin_mode || types.MarginMode.CROSS
       // slippage: data.slippage,
     };
     if (data.order_type === types.OrderType.MARKET && !!data.slippage) {
@@ -8692,10 +9007,21 @@ var BaseOrderCreator = class {
       child_orders: [bracketOrder]
     };
   }
+  /**
+   * Base validation method that can be called by subclasses
+   * Validates common order properties like quantity and min notional
+   * @param values - Order values to validate
+   * @param configs - Configuration
+   * @returns Validation result (synchronous, not a Promise)
+   */
   baseValidate(values, configs) {
     const errors = {};
     const { maxQty, symbol, markPrice } = configs;
-    let { order_quantity, total, order_price, reduce_only, order_type } = values;
+    let order_quantity = values.order_quantity;
+    const total = values.total;
+    const order_price = values.order_price;
+    const reduce_only = values.reduce_only;
+    const order_type = values.order_type;
     const { min_notional, base_tick, quote_dp, quote_tick, base_dp } = symbol || {};
     if (!order_quantity) {
       if (total && order_price) {
@@ -8740,7 +9066,7 @@ var BaseOrderCreator = class {
       };
     }
     this.validateBracketOrder(values, configs, errors);
-    return Promise.resolve(errors);
+    return errors;
   }
   totalToQuantity(order, config) {
     if (!order.order_quantity && order.total && order.order_price) {
@@ -8889,7 +9215,11 @@ var BBOOrderCreator = class extends BaseOrderCreator {
     super(...arguments);
     this.orderType = types.OrderType.LIMIT;
   }
-  create(values) {
+  /**
+   * Builds the BBO order
+   * Implements template method hook
+   */
+  buildOrder(values) {
     const order = {
       ...this.baseOrder(values),
       level: values.level
@@ -8902,15 +9232,18 @@ var BBOOrderCreator = class extends BaseOrderCreator {
         "reduce_only",
         "side",
         "order_type",
+        "margin_mode",
         "level"
       ],
       order
     );
   }
-  async validate(values, configs) {
-    return this.baseValidate(values, configs).then((errors) => {
-      return errors;
-    });
+  /**
+   * Runs base validations
+   * Implements template method hook
+   */
+  runValidations(values, configs) {
+    return this.baseValidate(values, configs);
   }
 };
 function getOrderPrice(order, askAndBid) {
@@ -8937,6 +9270,24 @@ function getOrderPrice(order, askAndBid) {
     }
   }
 }
+perp.order.getOrderReferencePrice;
+function getOrderReferencePriceFromOrder(order, askAndBid) {
+  if (!askAndBid || askAndBid.length < 2) return null;
+  if (!order.order_type || !order.side) {
+    return null;
+  }
+  return perp.order.getOrderReferencePrice(
+    {
+      orderType: order.order_type,
+      orderTypeExt: order.order_type_ext,
+      side: order.side,
+      limitPrice: order.order_price ? Number(order.order_price) : void 0,
+      triggerPrice: order.trigger_price ? Number(order.trigger_price) : void 0
+    },
+    askAndBid[0],
+    askAndBid[1]
+  );
+}
 function getPriceRange(inputs) {
   const { basePrice, side, symbolInfo } = inputs;
   const { price_range, price_scope, quote_min, quote_max } = symbolInfo;
@@ -8950,97 +9301,170 @@ function getPriceRange(inputs) {
     min: minPriceNumber,
     max: scopePriceNumber
   };
-  const minPrice3 = Math.max(quote_min, priceRange?.min);
-  const maxPrice3 = Math.min(quote_max, priceRange?.max);
+  const minPrice = Math.max(quote_min, priceRange?.min);
+  const maxPrice = Math.min(quote_max, priceRange?.max);
   return {
-    minPrice: minPrice3,
-    maxPrice: maxPrice3
+    minPrice,
+    maxPrice
   };
 }
 
-// src/services/orderCreator/baseBracketOrderCreator.ts
+// src/services/orderCreator/validators/TPSLValidationStrategy.ts
 var formatPrice = (price, quote_dp) => {
   return new utils.Decimal(price).toDecimalPlaces(quote_dp).toNumber();
 };
-async function bracketOrderValidator(values, config) {
-  const result = /* @__PURE__ */ Object.create(null);
-  await Promise.resolve();
-  const {
-    // tp_enable,
-    // sl_enable,
-    tp_trigger_price,
-    tp_order_price,
-    tp_order_type,
-    sl_trigger_price,
-    sl_order_price,
-    sl_order_type,
-    side
-  } = values;
-  const qty = Number(values.quantity);
-  const maxQty = config.maxQty;
-  const type = values.order_type;
-  const { quote_max, quote_min, quote_dp } = config.symbol ?? {};
-  const mark_price = type === types.OrderType.MARKET ? config.markPrice : values.order_price ? Number(values.order_price) : void 0;
-  const tpslSide = side === types.OrderSide.BUY ? types.OrderSide.SELL : types.OrderSide.BUY;
-  if (!isNaN(qty) && qty > maxQty) {
-    result.quantity = OrderValidation.max("quantity", config.maxQty);
-  }
-  if (Number(tp_trigger_price) < 0) {
-    result.tp_trigger_price = OrderValidation.min("tp_trigger_price", 0);
-  }
-  if (Number(sl_trigger_price) < 0) {
-    result.sl_trigger_price = OrderValidation.min("sl_trigger_price", 0);
-  }
-  if (tp_order_type === types.OrderType.LIMIT && !tp_order_price) {
-    result.tp_order_price = OrderValidation.required("tp_order_price");
-  }
-  if (sl_order_type === types.OrderType.LIMIT && !sl_order_price) {
-    result.sl_order_price = OrderValidation.required("sl_order_price");
-  }
-  if (side === types.OrderSide.BUY && mark_price) {
-    if (!!sl_trigger_price && Number(sl_trigger_price) < quote_min) {
-      result.sl_trigger_price = OrderValidation.min(
-        "sl_trigger_price",
-        formatPrice(quote_min, quote_dp)
+var TPSLValidationStrategy = class {
+  /**
+   * Validates TP/SL order values
+   * @param values - TP/SL order values including trigger prices, order prices, etc.
+   * @param config - Configuration with symbol info and mark price
+   * @returns Validation result object with any errors found
+   */
+  validate(values, config) {
+    const result = /* @__PURE__ */ Object.create(null);
+    const {
+      tp_trigger_price,
+      tp_order_price,
+      tp_order_type,
+      sl_trigger_price,
+      sl_order_price,
+      sl_order_type,
+      side,
+      quantity,
+      order_type,
+      order_price
+    } = values;
+    const qty = Number(quantity);
+    const maxQty = config.maxQty;
+    const { quote_max, quote_min, quote_dp, base_min } = config.symbol ?? {};
+    const mark_price = order_type === types.OrderType.MARKET || order_type == null ? config.markPrice : order_price ? Number(order_price) : void 0;
+    const tpslSide = side === types.OrderSide.BUY ? types.OrderSide.SELL : types.OrderSide.BUY;
+    if (!isNaN(qty) && qty > maxQty) {
+      result.quantity = OrderValidation.max("quantity", config.maxQty);
+    }
+    if (!isNaN(qty) && qty < (base_min ?? 0)) {
+      result.quantity = OrderValidation.min("quantity", base_min ?? 0);
+    }
+    if (tp_trigger_price !== void 0 && tp_trigger_price !== "" && tp_trigger_price !== null && Number(tp_trigger_price) < 0) {
+      result.tp_trigger_price = OrderValidation.min("tp_trigger_price", 0);
+    }
+    if (sl_trigger_price !== void 0 && sl_trigger_price !== "" && sl_trigger_price !== null && Number(sl_trigger_price) < 0) {
+      result.sl_trigger_price = OrderValidation.min("sl_trigger_price", 0);
+    }
+    if (tp_order_type === types.OrderType.LIMIT && !tp_order_price) {
+      result.tp_order_price = OrderValidation.required("tp_order_price");
+    }
+    if (sl_order_type === types.OrderType.LIMIT && !sl_order_price) {
+      result.sl_order_price = OrderValidation.required("sl_order_price");
+    }
+    if (side === types.OrderSide.BUY && mark_price) {
+      this.validateBuySide(
+        {
+          tp_trigger_price,
+          tp_order_price,
+          sl_trigger_price,
+          sl_order_price
+        },
+        {
+          mark_price,
+          quote_min: quote_min ?? 0,
+          quote_max: quote_max ?? 0,
+          quote_dp: quote_dp ?? 0,
+          tpslSide,
+          symbol: config.symbol
+        },
+        result
       );
-    }
-    if (!!sl_trigger_price && Number(sl_trigger_price) > mark_price) {
-      result.sl_trigger_price = OrderValidation.max(
-        "sl_trigger_price",
-        formatPrice(mark_price, quote_dp)
+    } else if (side === types.OrderSide.SELL && mark_price) {
+      this.validateSellSide(
+        {
+          tp_trigger_price,
+          tp_order_price,
+          sl_trigger_price,
+          sl_order_price
+        },
+        {
+          mark_price,
+          quote_min: quote_min ?? 0,
+          quote_max: quote_max ?? 0,
+          quote_dp: quote_dp ?? 0,
+          tpslSide,
+          symbol: config.symbol
+        },
+        result
       );
     }
-    if (!!tp_trigger_price && Number(tp_trigger_price) <= mark_price) {
-      result.tp_trigger_price = OrderValidation.min(
-        "tp_trigger_price",
-        formatPrice(mark_price, quote_dp)
-      );
+    return Object.keys(result).length > 0 ? result : null;
+  }
+  /**
+   * Validates TP/SL for BUY orders
+   * For BUY orders:
+   * - SL trigger price must be < mark price
+   * - TP trigger price must be > mark price
+   */
+  validateBuySide(prices, config, result) {
+    const {
+      tp_trigger_price,
+      tp_order_price,
+      sl_trigger_price,
+      sl_order_price
+    } = prices;
+    const { mark_price, quote_min, quote_max, quote_dp, tpslSide, symbol } = config;
+    if (sl_trigger_price !== void 0 && sl_trigger_price !== "" && sl_trigger_price !== null) {
+      const slTrigger = Number(sl_trigger_price);
+      if (!isNaN(slTrigger)) {
+        if (quote_min > 0 && slTrigger < quote_min) {
+          result.sl_trigger_price = OrderValidation.min(
+            "sl_trigger_price",
+            formatPrice(quote_min, quote_dp)
+          );
+        }
+        if (slTrigger >= mark_price) {
+          result.sl_trigger_price = OrderValidation.max(
+            "sl_trigger_price",
+            formatPrice(mark_price, quote_dp)
+          );
+        }
+      }
     }
-    if (!!tp_trigger_price && Number(tp_trigger_price) > quote_max) {
-      result.tp_trigger_price = OrderValidation.max(
-        "tp_trigger_price",
-        formatPrice(quote_max, quote_dp)
-      );
+    if (tp_trigger_price !== void 0 && tp_trigger_price !== "" && tp_trigger_price !== null) {
+      const tpTrigger = Number(tp_trigger_price);
+      if (!isNaN(tpTrigger)) {
+        if (tpTrigger <= mark_price) {
+          result.tp_trigger_price = OrderValidation.min(
+            "tp_trigger_price",
+            formatPrice(mark_price, quote_dp)
+          );
+        }
+        if (quote_max > 0 && tpTrigger > quote_max) {
+          result.tp_trigger_price = OrderValidation.max(
+            "tp_trigger_price",
+            formatPrice(quote_max, quote_dp)
+          );
+        }
+      }
     }
     if (sl_trigger_price && sl_order_price) {
       const priceRange = getPriceRange({
         side: tpslSide,
         basePrice: Number(sl_trigger_price),
-        symbolInfo: config.symbol
+        symbolInfo: symbol
       });
-      if (Number(sl_order_price) < priceRange.minPrice) {
+      const slOrderPrice = Number(sl_order_price);
+      const slTrigger = Number(sl_trigger_price);
+      if (slOrderPrice < priceRange.minPrice) {
         result.sl_order_price = OrderValidation.min(
           "sl_order_price",
           formatPrice(priceRange.minPrice, quote_dp)
         );
       }
-      if (Number(sl_order_price) > priceRange.maxPrice) {
+      if (slOrderPrice > priceRange.maxPrice) {
         result.sl_order_price = OrderValidation.max(
           "sl_order_price",
           formatPrice(priceRange.maxPrice, quote_dp)
         );
       }
-      if (Number(sl_trigger_price) < Number(sl_order_price)) {
+      if (slTrigger < slOrderPrice) {
         result.sl_trigger_price = OrderValidation.priceErrorMax("sl_trigger_price");
       }
     }
@@ -9048,69 +9472,96 @@ async function bracketOrderValidator(values, config) {
       const priceRange = getPriceRange({
         side: tpslSide,
         basePrice: Number(tp_trigger_price),
-        symbolInfo: config.symbol
+        symbolInfo: symbol
       });
-      if (Number(tp_order_price) > priceRange.maxPrice) {
+      const tpOrderPrice = Number(tp_order_price);
+      const tpTrigger = Number(tp_trigger_price);
+      if (tpOrderPrice > priceRange.maxPrice) {
         result.tp_order_price = OrderValidation.max(
           "tp_order_price",
           formatPrice(priceRange.maxPrice, quote_dp)
         );
       }
-      if (Number(tp_order_price) < priceRange.minPrice) {
+      if (tpOrderPrice < priceRange.minPrice) {
         result.tp_order_price = OrderValidation.min(
           "tp_order_price",
           formatPrice(priceRange.minPrice, quote_dp)
         );
       }
-      if (Number(tp_trigger_price) > Number(tp_order_price)) {
+      if (tpTrigger > tpOrderPrice) {
         result.tp_trigger_price = OrderValidation.priceErrorMax("tp_trigger_price");
       }
     }
   }
-  if (side === types.OrderSide.SELL && mark_price) {
-    if (!!sl_trigger_price && Number(sl_trigger_price) > quote_max) {
-      result.sl_trigger_price = OrderValidation.max(
-        "sl_trigger_price",
-        formatPrice(quote_max, quote_dp)
-      );
-    }
-    if (!!sl_trigger_price && Number(sl_trigger_price) < mark_price) {
-      result.sl_trigger_price = OrderValidation.min(
-        "sl_trigger_price",
-        formatPrice(mark_price, quote_dp)
-      );
-    }
-    if (!!tp_trigger_price && Number(tp_trigger_price) >= mark_price) {
-      result.tp_trigger_price = OrderValidation.max(
-        "tp_trigger_price",
-        formatPrice(mark_price, quote_dp)
-      );
+  /**
+   * Validates TP/SL for SELL orders
+   * For SELL orders:
+   * - SL trigger price must be > mark price
+   * - TP trigger price must be < mark price
+   */
+  validateSellSide(prices, config, result) {
+    const {
+      tp_trigger_price,
+      tp_order_price,
+      sl_trigger_price,
+      sl_order_price
+    } = prices;
+    const { mark_price, quote_min, quote_max, quote_dp, tpslSide, symbol } = config;
+    if (sl_trigger_price !== void 0 && sl_trigger_price !== "" && sl_trigger_price !== null) {
+      const slTrigger = Number(sl_trigger_price);
+      if (!isNaN(slTrigger)) {
+        if (quote_max > 0 && slTrigger > quote_max) {
+          result.sl_trigger_price = OrderValidation.max(
+            "sl_trigger_price",
+            formatPrice(quote_max, quote_dp)
+          );
+        }
+        if (slTrigger <= mark_price) {
+          result.sl_trigger_price = OrderValidation.min(
+            "sl_trigger_price",
+            formatPrice(mark_price, quote_dp)
+          );
+        }
+      }
     }
-    if (!!tp_trigger_price && Number(tp_trigger_price) < quote_min) {
-      result.tp_trigger_price = OrderValidation.min(
-        "tp_trigger_price",
-        formatPrice(quote_min, quote_dp)
-      );
+    if (tp_trigger_price !== void 0 && tp_trigger_price !== "" && tp_trigger_price !== null) {
+      const tpTrigger = Number(tp_trigger_price);
+      if (!isNaN(tpTrigger)) {
+        if (tpTrigger >= mark_price) {
+          result.tp_trigger_price = OrderValidation.max(
+            "tp_trigger_price",
+            formatPrice(mark_price, quote_dp)
+          );
+        }
+        if (quote_min > 0 && tpTrigger < quote_min) {
+          result.tp_trigger_price = OrderValidation.min(
+            "tp_trigger_price",
+            formatPrice(quote_min, quote_dp)
+          );
+        }
+      }
     }
     if (sl_trigger_price && sl_order_price) {
       const priceRange = getPriceRange({
         side: tpslSide,
         basePrice: Number(sl_trigger_price),
-        symbolInfo: config.symbol
+        symbolInfo: symbol
       });
-      if (Number(sl_order_price) < priceRange.minPrice) {
+      const slOrderPrice = Number(sl_order_price);
+      const slTrigger = Number(sl_trigger_price);
+      if (slOrderPrice < priceRange.minPrice) {
         result.sl_order_price = OrderValidation.min(
           "sl_order_price",
           formatPrice(priceRange.minPrice, quote_dp)
         );
       }
-      if (Number(sl_order_price) > priceRange.maxPrice) {
+      if (slOrderPrice > priceRange.maxPrice) {
         result.sl_order_price = OrderValidation.max(
           "sl_order_price",
           formatPrice(priceRange.maxPrice, quote_dp)
         );
       }
-      if (Number(sl_trigger_price) > Number(sl_order_price)) {
+      if (slTrigger > slOrderPrice) {
         result.sl_trigger_price = OrderValidation.priceErrorMin("sl_trigger_price");
       }
     }
@@ -9118,37 +9569,294 @@ async function bracketOrderValidator(values, config) {
       const priceRange = getPriceRange({
         side: tpslSide,
         basePrice: Number(tp_trigger_price),
-        symbolInfo: config.symbol
+        symbolInfo: symbol
       });
-      if (Number(tp_order_price) < priceRange.minPrice) {
+      const tpOrderPrice = Number(tp_order_price);
+      const tpTrigger = Number(tp_trigger_price);
+      if (tpOrderPrice < priceRange.minPrice) {
         result.tp_order_price = OrderValidation.min(
           "tp_order_price",
           formatPrice(priceRange.minPrice, quote_dp)
         );
       }
-      if (Number(tp_order_price) > priceRange.maxPrice) {
+      if (tpOrderPrice > priceRange.maxPrice) {
         result.tp_order_price = OrderValidation.max(
           "tp_order_price",
           formatPrice(priceRange.maxPrice, quote_dp)
         );
       }
-      if (Number(tp_trigger_price) < Number(tp_order_price)) {
+      if (tpTrigger < tpOrderPrice) {
         result.tp_trigger_price = OrderValidation.priceErrorMax("tp_trigger_price");
       }
     }
   }
-  return Object.keys(result).length > 0 ? result : null;
+};
+
+// src/services/orderCreator/baseBracketOrderCreator.ts
+async function bracketOrderValidator(values, config) {
+  const strategy = new TPSLValidationStrategy();
+  return strategy.validate(values, config);
 }
-var { maxPrice, minPrice, scopePrice } = perp.order;
+
+// src/services/orderCreator/validators/BaseValidator.ts
+var BaseValidator = class {
+  /**
+   * Sets the next validator in the chain
+   * @param validator - The next validator to call
+   * @returns The next validator for method chaining
+   */
+  setNext(validator) {
+    this.next = validator;
+    return validator;
+  }
+  /**
+   * Validates values and passes to next validator in chain
+   * @param values - The values to validate
+   * @param config - Configuration for validation
+   * @param errors - Accumulated validation errors
+   * @returns Updated validation result
+   */
+  validate(values, config, errors) {
+    const result = this.doValidate(values, config);
+    if (result) {
+      errors[this.getFieldName()] = result;
+    }
+    return this.next?.validate(values, config, errors) ?? errors;
+  }
+};
+var PriceValidationStrategy = class {
+  /**
+   * Validates order price against symbol constraints and price range
+   * @param values - Object containing order_price, side, and order_type
+   * @param config - Configuration with symbol info and mark price
+   * @returns Validation error if price is invalid, undefined otherwise
+   */
+  validate(values, config) {
+    const { order_price, side } = values;
+    if (!order_price) {
+      return OrderValidation.required("order_price");
+    }
+    const price = new utils.Decimal(order_price);
+    const { symbol } = config;
+    const { quote_max, quote_min, quote_dp, price_range, price_scope } = symbol;
+    const maxPriceNumber = perp.order.maxPrice(config.markPrice, price_range);
+    const minPriceNumber = perp.order.minPrice(config.markPrice, price_range);
+    const scopePriceNumber = perp.order.scopePrice(
+      config.markPrice,
+      price_scope,
+      side
+    );
+    const priceRange = side === types.OrderSide.BUY ? {
+      min: scopePriceNumber,
+      max: maxPriceNumber
+    } : {
+      min: minPriceNumber,
+      max: scopePriceNumber
+    };
+    if (price.gt(quote_max)) {
+      return OrderValidation.max("order_price", quote_max);
+    }
+    if (price.lt(quote_min)) {
+      return OrderValidation.min("order_price", quote_min);
+    }
+    if (price.gt(priceRange.max)) {
+      return OrderValidation.max(
+        "order_price",
+        new utils.Decimal(priceRange.max).todp(quote_dp).toString()
+      );
+    }
+    if (price.lt(priceRange.min)) {
+      return OrderValidation.min(
+        "order_price",
+        new utils.Decimal(priceRange.min).todp(quote_dp).toString()
+      );
+    }
+    return void 0;
+  }
+};
+var TriggerPriceValidationStrategy = class {
+  /**
+   * Validates trigger price against symbol constraints
+   * @param values - Object containing trigger_price
+   * @param config - Configuration with symbol info
+   * @returns Validation error if trigger price is invalid, undefined otherwise
+   */
+  validate(values, config) {
+    const { trigger_price } = values;
+    const { symbol } = config;
+    const { quote_max, quote_min } = symbol;
+    if (!trigger_price) {
+      return OrderValidation.required("trigger_price");
+    }
+    const triggerPrice = Number(trigger_price);
+    if (triggerPrice > quote_max) {
+      return OrderValidation.max("trigger_price", quote_max);
+    }
+    if (triggerPrice < quote_min || triggerPrice === 0) {
+      return OrderValidation.min("trigger_price", quote_min);
+    }
+    return void 0;
+  }
+};
+
+// src/services/orderCreator/validators/PriceValidator.ts
+var PriceValidator = class extends BaseValidator {
+  constructor() {
+    super();
+    this.strategy = new PriceValidationStrategy();
+  }
+  doValidate(values, config) {
+    return this.strategy.validate(
+      {
+        order_price: values.order_price,
+        side: values.side,
+        order_type: values.order_type
+      },
+      config
+    );
+  }
+  getFieldName() {
+    return "order_price";
+  }
+};
+var QuantityValidationStrategy = class {
+  /**
+   * Validates order quantity against symbol constraints
+   * Also handles conversion from total to quantity if needed
+   * @param values - Object containing order_quantity, total, and order_price
+   * @param config - Configuration with symbol info and max quantity
+   * @returns Validation error if quantity is invalid, undefined otherwise
+   */
+  validate(values, config) {
+    let { order_quantity, total, order_price } = values;
+    const { maxQty, symbol } = config;
+    const { base_min, base_dp, quote_dp } = symbol;
+    if (!order_quantity && total && order_price) {
+      const totalNumber = new utils.Decimal(total);
+      const qty2 = totalNumber.dividedBy(order_price).toFixed(quote_dp);
+      order_quantity = qty2;
+    }
+    if (!order_quantity) {
+      return OrderValidation.required("order_quantity");
+    }
+    const qty = new utils.Decimal(order_quantity);
+    if (qty.lt(base_min)) {
+      return OrderValidation.min(
+        "order_quantity",
+        new utils.Decimal(base_min).todp(base_dp).toString()
+      );
+    }
+    if (qty.gt(maxQty)) {
+      return OrderValidation.max(
+        "order_quantity",
+        new utils.Decimal(maxQty).todp(base_dp).toString()
+      );
+    }
+    return void 0;
+  }
+};
+
+// src/services/orderCreator/validators/QuantityValidator.ts
+var QuantityValidator = class extends BaseValidator {
+  constructor() {
+    super();
+    this.strategy = new QuantityValidationStrategy();
+  }
+  doValidate(values, config) {
+    return this.strategy.validate(
+      {
+        order_quantity: values.order_quantity,
+        total: values.total,
+        order_price: values.order_price
+      },
+      config
+    );
+  }
+  getFieldName() {
+    return "order_quantity";
+  }
+};
+
+// src/services/orderCreator/validators/ValidationChain.ts
+var ValidationChain = class {
+  constructor() {
+    this.validators = [];
+  }
+  /**
+   * Adds a validator to the chain
+   * @param validator - The validator to add
+   * @returns This chain instance for method chaining
+   */
+  addValidator(validator) {
+    this.validators.push(validator);
+    if (!this.head) {
+      this.head = validator;
+    } else {
+      let current = this.head;
+      while (current && current.next) {
+        current = current.next;
+      }
+      if (current) {
+        current.setNext(validator);
+      }
+    }
+    return this;
+  }
+  /**
+   * Adds multiple validators to the chain
+   * @param validators - Array of validators to add
+   * @returns This chain instance for method chaining
+   */
+  addValidators(validators) {
+    validators.forEach((validator) => this.addValidator(validator));
+    return this;
+  }
+  /**
+   * Validates values using all validators in the chain
+   * @param values - The values to validate
+   * @param config - Configuration for validation
+   * @returns Validation result with all errors found
+   */
+  validate(values, config) {
+    const errors = {};
+    if (this.head) {
+      return this.head.validate(values, config, errors);
+    }
+    return errors;
+  }
+  /**
+   * Clears all validators from the chain
+   */
+  clear() {
+    this.validators = [];
+    this.head = void 0;
+  }
+  /**
+   * Gets the number of validators in the chain
+   * @returns The number of validators
+   */
+  get length() {
+    return this.validators.length;
+  }
+};
+
+// src/services/orderCreator/limitOrderCreator.ts
 var LimitOrderCreator = class extends BaseOrderCreator {
   constructor() {
     super(...arguments);
+    // private priceValidationStrategy = new PriceValidationStrategy();
+    this.validationChain = new ValidationChain().addValidator(new QuantityValidator()).addValidator(new PriceValidator());
     this.orderType = types.OrderType.LIMIT;
   }
-  create(values, config) {
+  /**
+   * Builds the limit order
+   * Implements template method hook
+   */
+  buildOrder(values, config) {
+    const orderlyValues = values;
     const order = {
-      ...this.baseOrder(values),
-      order_price: values.order_price
+      ...this.baseOrder(orderlyValues),
+      order_price: orderlyValues.order_price
     };
     this.totalToQuantity(order, config);
     return ramda.pick(
@@ -9160,58 +9868,23 @@ var LimitOrderCreator = class extends BaseOrderCreator {
         "reduce_only",
         "side",
         "order_type",
+        "margin_mode",
         "algo_type",
         "child_orders"
       ],
       order
     );
   }
-  validate(values, config) {
-    return this.baseValidate(values, config).then((errors) => {
-      const { order_price, side } = values;
-      if (!order_price) {
-        errors.order_price = OrderValidation.required("order_price");
-      } else {
-        const price = new utils.Decimal(order_price);
-        const { symbol } = config;
-        const { price_range, price_scope, quote_max, quote_min } = symbol;
-        const maxPriceNumber = maxPrice(config.markPrice, price_range);
-        const minPriceNumber = minPrice(config.markPrice, price_range);
-        const scopePriceNumber = scopePrice(
-          config.markPrice,
-          price_scope,
-          side
-        );
-        const priceRange = side === "BUY" ? {
-          min: scopePriceNumber,
-          max: maxPriceNumber
-        } : {
-          min: minPriceNumber,
-          max: scopePriceNumber
-        };
-        if (price.gt(quote_max)) {
-          errors.order_price = OrderValidation.max("order_price", quote_max);
-        } else {
-          if (price.gt(priceRange?.max)) {
-            errors.order_price = OrderValidation.max(
-              "order_price",
-              new utils.Decimal(priceRange.max).todp(symbol.quote_dp).toString()
-            );
-          }
-        }
-        if (price.lt(quote_min)) {
-          errors.order_price = OrderValidation.min("order_price", quote_min);
-        } else {
-          if (price.lt(priceRange?.min)) {
-            errors.order_price = OrderValidation.min(
-              "order_price",
-              new utils.Decimal(priceRange.min).todp(symbol.quote_dp).toString()
-            );
-          }
-        }
-      }
-      return errors;
-    });
+  /**
+   * Runs validations using validation chain
+   * Implements template method hook
+   */
+  runValidations(values, config) {
+    const orderlyValues = values;
+    const errors = this.baseValidate(orderlyValues, config);
+    const chainErrors = this.validationChain.validate(orderlyValues, config);
+    Object.assign(errors, chainErrors);
+    return errors;
   }
 };
 
@@ -9234,34 +9907,81 @@ var BracketLimitOrderCreator = class extends LimitOrderCreator {
   }
 };
 
+// src/services/orderCreator/validators/SlippageValidationStrategy.ts
+var SlippageValidationStrategy = class {
+  /**
+   * Validates slippage against estimated slippage
+   * @param values - Object containing slippage value
+   * @param config - Configuration with estimated slippage
+   * @returns Validation error if slippage exceeds estimated, undefined otherwise
+   */
+  validate(values, config) {
+    const slippage = Number(values.slippage);
+    const estSlippage = Number.isNaN(config.estSlippage) ? 0 : Number(config.estSlippage) * 100;
+    if (!isNaN(slippage) && estSlippage > slippage) {
+      return {
+        type: "max",
+        message: "Estimated slippage exceeds your maximum allowed slippage.",
+        value: estSlippage
+      };
+    }
+    return void 0;
+  }
+};
+
+// src/services/orderCreator/validators/SlippageValidator.ts
+var SlippageValidator = class extends BaseValidator {
+  constructor() {
+    super();
+    this.strategy = new SlippageValidationStrategy();
+  }
+  doValidate(values, config) {
+    return this.strategy.validate(
+      {
+        slippage: values.slippage
+      },
+      config
+    );
+  }
+  getFieldName() {
+    return "slippage";
+  }
+};
+
 // src/services/orderCreator/marketOrderCreator.ts
 var MarketOrderCreator = class extends BaseOrderCreator {
-  create(values) {
-    const data = this.baseOrder(values);
-    delete data["order_price"];
-    delete data["total"];
-    delete data["trigger_price"];
-    delete data["isStopOrder"];
-    return {
-      ...data
-    };
+  constructor() {
+    super(...arguments);
+    this.slippageValidationStrategy = new SlippageValidationStrategy();
+    this.validationChain = new ValidationChain().addValidator(new QuantityValidator()).addValidator(new SlippageValidator());
+    this.orderType = types.OrderType.MARKET;
   }
-  validate(values, configs) {
-    return this.baseValidate(values, configs).then((result) => {
-      const slippage = Number(values.slippage);
-      const estSlippage = Number.isNaN(configs.estSlippage) ? 0 : Number(configs.estSlippage) * 100;
-      if (!isNaN(slippage) && estSlippage > slippage) {
-        return {
-          ...result,
-          slippage: {
-            type: "max",
-            message: "Estimated slippage exceeds your maximum allowed slippage.",
-            value: estSlippage
-          }
-        };
-      }
-      return result;
-    });
+  /**
+   * Builds the market order
+   * Implements template method hook
+   */
+  buildOrder(values, config) {
+    const orderlyValues = values;
+    const data = this.baseOrder(orderlyValues);
+    const result = { ...data };
+    delete result.order_price;
+    delete result.total;
+    delete result.trigger_price;
+    if ("isStopOrder" in result) {
+      delete result.isStopOrder;
+    }
+    return result;
+  }
+  /**
+   * Runs validations using validation chain
+   * Implements template method hook
+   */
+  runValidations(values, configs) {
+    const orderlyValues = values;
+    const result = this.baseValidate(orderlyValues, configs);
+    const chainErrors = this.validationChain.validate(orderlyValues, configs);
+    Object.assign(result, chainErrors);
+    return result;
   }
 };
 
@@ -9293,14 +10013,26 @@ var FOKOrderCreator = class extends LimitOrderCreator {
 
 // src/services/orderCreator/generalCreator.ts
 var GeneralOrderCreator = class extends BaseOrderCreator {
-  create(data) {
+  constructor() {
+    super(...arguments);
+    this.orderType = void 0;
+  }
+  /**
+   * Builds the general order
+   * Implements template method hook
+   */
+  buildOrder(data) {
     return {
       ...this.baseOrder(data),
       order_price: data.order_price,
       order_quantity: data.order_quantity
     };
   }
-  validate(values, configs) {
+  /**
+   * Runs base validations
+   * Implements template method hook
+   */
+  runValidations(values, configs) {
     return super.baseValidate(values, configs);
   }
 };
@@ -9409,7 +10141,8 @@ function calcScaledOrderBatchBody(order, symbolInfo) {
       distribution_type,
       skew,
       reduce_only,
-      visible_quantity
+      visible_quantity,
+      margin_mode
     } = order;
     const prices = calcScaledOrderPrices({
       start_price,
@@ -9435,6 +10168,8 @@ function calcScaledOrderBatchBody(order, symbolInfo) {
         order_quantity: qtys[index],
         order_price: price,
         reduce_only,
+        margin_mode: margin_mode || types.MarginMode.CROSS,
+        // Default to CROSS if not provided for backward compatibility
         // it will be used for identify the scaled order from ws
         client_order_id: `scaled_${index}_${now}`
       };
@@ -9538,7 +10273,11 @@ var ScaledOrderCreator = class extends BaseOrderCreator {
     super(...arguments);
     this.orderType = types.OrderType.SCALED;
   }
-  create(values, config) {
+  /**
+   * Builds the scaled order
+   * Implements template method hook
+   */
+  buildOrder(values, config) {
     const orders = calcScaledOrderBatchBody(values, config.symbol);
     const { total_orders, distribution_type, skew } = values;
     const order = {
@@ -9556,6 +10295,7 @@ var ScaledOrderCreator = class extends BaseOrderCreator {
         "reduce_only",
         "side",
         "order_type",
+        "margin_mode",
         "orders",
         "total_orders",
         "distribution_type",
@@ -9564,7 +10304,11 @@ var ScaledOrderCreator = class extends BaseOrderCreator {
       order
     );
   }
-  async validate(values, config) {
+  /**
+   * Runs validations for scaled order
+   * Implements template method hook
+   */
+  runValidations(values, config) {
     const { maxQty, askAndBid, markPrice, symbol } = config;
     const { base_dp, quote_dp } = config.symbol;
     const { order_quantity, total, total_orders, distribution_type, skew } = values;
@@ -9633,22 +10377,22 @@ function validatePrice(values, config) {
   if (!config.markPrice) {
     return errors;
   }
-  const { minPrice: minPrice3, maxPrice: maxPrice3 } = getPriceRange({
+  const { minPrice, maxPrice } = getPriceRange({
     side: values.side,
     basePrice: config.markPrice,
     symbolInfo: config.symbol
   });
   const comparePrice = (key, value) => {
     const price = new utils.Decimal(value || 0);
-    if (price.lt(minPrice3)) {
+    if (price.lt(minPrice)) {
       errors[key] = OrderValidation.min(
         key,
-        new utils.Decimal(minPrice3).todp(quote_dp).toString()
+        new utils.Decimal(minPrice).todp(quote_dp).toString()
       );
-    } else if (price.gt(maxPrice3)) {
+    } else if (price.gt(maxPrice)) {
       errors[key] = OrderValidation.max(
         key,
-        new utils.Decimal(maxPrice3).todp(quote_dp).toString()
+        new utils.Decimal(maxPrice).todp(quote_dp).toString()
       );
     }
   };
@@ -9656,13 +10400,40 @@ function validatePrice(values, config) {
   comparePrice("end_price", end_price);
   return errors;
 }
-var { maxPrice: maxPrice2, minPrice: minPrice2, scopePrice: scopePrice2 } = perp.order;
+
+// src/services/orderCreator/validators/TriggerPriceValidator.ts
+var TriggerPriceValidator = class extends BaseValidator {
+  constructor() {
+    super();
+    this.strategy = new TriggerPriceValidationStrategy();
+  }
+  doValidate(values, config) {
+    return this.strategy.validate(
+      {
+        trigger_price: values.trigger_price
+      },
+      config
+    );
+  }
+  getFieldName() {
+    return "trigger_price";
+  }
+};
+
+// src/services/orderCreator/stopLimitOrderCreator.ts
 var StopLimitOrderCreator = class extends BaseOrderCreator {
   constructor() {
     super(...arguments);
+    this.priceValidationStrategy = new PriceValidationStrategy();
+    this.triggerPriceValidationStrategy = new TriggerPriceValidationStrategy();
+    this.validationChain = new ValidationChain().addValidator(new QuantityValidator()).addValidator(new TriggerPriceValidator()).addValidator(new PriceValidator());
     this.orderType = types.OrderType.STOP_LIMIT;
   }
-  create(values, config) {
+  /**
+   * Builds the stop-limit order
+   * Implements template method hook
+   */
+  buildOrder(values, config) {
     this.totalToQuantity(values, config);
     const order = {
       ...this.baseOrder(values),
@@ -9684,84 +10455,82 @@ var StopLimitOrderCreator = class extends BaseOrderCreator {
         "trigger_price_type",
         "side",
         "reduce_only",
+        "margin_mode",
         "visible_quantity"
       ],
       order
     );
   }
-  validate(values, config) {
-    return this.baseValidate(values, config).then((errors) => {
-      const { order_price, trigger_price, side } = values;
-      const { symbol } = config;
-      const { price_range, price_scope, quote_max, quote_min } = symbol;
-      if (!order_price) {
-        errors.order_price = OrderValidation.required("order_price");
-      }
-      if (!trigger_price) {
-        errors.trigger_price = OrderValidation.required("trigger_price");
-      } else {
-        if (trigger_price > quote_max) {
-          errors.trigger_price = OrderValidation.max(
-            "trigger_price",
-            quote_max
-          );
-        } else if (trigger_price < quote_min || trigger_price == 0) {
-          errors.trigger_price = OrderValidation.min(
-            "trigger_price",
-            quote_min
-          );
-        } else if (order_price) {
-          const price = new utils.Decimal(order_price);
-          const maxPriceNumber = maxPrice2(trigger_price, price_range);
-          const minPriceNumber = minPrice2(trigger_price, price_range);
-          const scropePriceNumbere = scopePrice2(
-            trigger_price,
-            price_scope,
-            side
-          );
-          const priceRange = side === "BUY" ? {
-            min: scropePriceNumbere,
-            max: maxPriceNumber
-          } : {
-            min: minPriceNumber,
-            max: scropePriceNumbere
-          };
-          if (price.gt(quote_max)) {
-            errors.order_price = OrderValidation.max("order_price", quote_max);
-          } else {
-            if (price.gt(priceRange?.max)) {
-              errors.order_price = OrderValidation.max(
-                "order_price",
-                new utils.Decimal(priceRange.max).todp(symbol.quote_dp).toString()
-              );
-            }
-          }
-          if (price.lt(quote_min)) {
-            errors.order_price = OrderValidation.min("order_price", quote_min);
-          } else {
-            if (price.lt(priceRange?.min)) {
-              errors.order_price = OrderValidation.min(
-                "order_price",
-                new utils.Decimal(priceRange.min).todp(symbol.quote_dp).toString()
-              );
-            }
-          }
-        }
+  /**
+   * Runs validations using validation chain
+   * Implements template method hook
+   */
+  runValidations(values, config) {
+    const orderlyValues = values;
+    const errors = this.baseValidate(orderlyValues, config);
+    const triggerPrice = values.trigger_price;
+    if (!triggerPrice || triggerPrice === 0) {
+      errors.trigger_price = OrderValidation.required("trigger_price");
+    } else {
+      const triggerError = this.triggerPriceValidationStrategy.validate(
+        { trigger_price: triggerPrice },
+        config
+      );
+      if (triggerError) {
+        errors.trigger_price = triggerError;
+      }
+    }
+    const valuesWithFields = values;
+    const orderPrice = valuesWithFields.order_price ?? valuesWithFields.price;
+    const triggerPriceForPriceValidation = triggerPrice;
+    const side = valuesWithFields.side ?? orderlyValues.side;
+    if (!orderPrice) {
+      errors.order_price = OrderValidation.required("order_price");
+    } else if (orderPrice && triggerPriceForPriceValidation && side) {
+      const modifiedConfig = {
+        ...config,
+        markPrice: Number(triggerPriceForPriceValidation)
+      };
+      const priceError = this.priceValidationStrategy.validate(
+        {
+          order_price: orderPrice,
+          side,
+          order_type: types.OrderType.LIMIT
+        },
+        modifiedConfig
+      );
+      if (priceError) {
+        errors.order_price = priceError;
       }
-      return errors;
-    });
+    } else if (orderPrice && triggerPriceForPriceValidation) {
+      const { quote_max, quote_min } = config.symbol;
+      const price = Number(orderPrice);
+      if (quote_max && price > quote_max) {
+        errors.order_price = OrderValidation.max("order_price", quote_max);
+      } else if (quote_min && price < quote_min) {
+        errors.order_price = OrderValidation.min("order_price", quote_min);
+      }
+    }
+    return errors;
   }
 };
 var StopMarketOrderCreator = class extends BaseOrderCreator {
-  create(values) {
+  constructor() {
+    super(...arguments);
+    this.triggerPriceValidationStrategy = new TriggerPriceValidationStrategy();
+    this.validationChain = new ValidationChain().addValidator(new QuantityValidator()).addValidator(new TriggerPriceValidator());
+  }
+  /**
+   * Builds the stop-market order
+   * Implements template method hook
+   */
+  buildOrder(values) {
     const order = {
       ...this.baseOrder(values),
-      // order_price: values.order_price,
       trigger_price: values.trigger_price,
       algo_type: types.AlgoOrderRootType.STOP,
       type: types.OrderType.MARKET,
       quantity: values["order_quantity"],
-      // price: values["order_price"],
       trigger_price_type: types.TriggerPriceType.MARK_PRICE
     };
     return ramda.pick(
@@ -9771,225 +10540,40 @@ var StopMarketOrderCreator = class extends BaseOrderCreator {
         "algo_type",
         "type",
         "quantity",
-        // "price",
         "trigger_price_type",
         "side",
         "reduce_only",
+        "margin_mode",
         "visible_quantity"
       ],
       order
     );
   }
-  validate(values, config) {
-    return this.baseValidate(values, config).then((errors) => {
-      const { trigger_price } = values;
-      const { symbol } = config;
-      const { quote_max, quote_min } = symbol;
-      if (!trigger_price) {
-        errors.trigger_price = OrderValidation.required("trigger_price");
-      } else if (trigger_price > quote_max) {
-        errors.trigger_price = OrderValidation.max("trigger_price", quote_max);
-      } else if (trigger_price < quote_min || trigger_price == 0) {
-        errors.trigger_price = OrderValidation.min("trigger_price", quote_min);
-      }
-      return errors;
-    });
+  /**
+   * Runs validations using validation chain
+   * Implements template method hook
+   */
+  runValidations(values, config) {
+    const errors = this.baseValidate(values, config);
+    const chainErrors = this.validationChain.validate(values, config);
+    Object.assign(errors, chainErrors);
+    return errors;
   }
 };
-var formatPrice2 = (price, quote_dp) => {
-  return new utils.Decimal(price).toDecimalPlaces(quote_dp).toNumber();
-};
+
+// src/services/orderCreator/baseAlgoCreator.ts
 var BaseAlgoOrderCreator = class {
+  constructor() {
+    this.tpslValidationStrategy = new TPSLValidationStrategy();
+  }
   /**
-   * base validate
+   * Validates TP/SL order using TPSLValidationStrategy
+   * Consolidates validation logic from baseBracketOrderCreator
    */
   validate(values, config) {
-    const result = /* @__PURE__ */ Object.create(null);
-    return Promise.resolve().then(() => {
-      const {
-        tp_trigger_price,
-        sl_trigger_price,
-        side,
-        // tp_enable,
-        // sl_enable,
-        tp_order_type,
-        sl_order_type,
-        tp_order_price,
-        sl_order_price
-      } = values;
-      const qty = Number(values.quantity);
-      const maxQty = config.maxQty;
-      const orderType = values.order_type;
-      const {
-        quote_max,
-        quote_min,
-        price_scope,
-        quote_dp,
-        base_min,
-        min_notional
-      } = config.symbol ?? {};
-      if (!isNaN(qty) && qty > maxQty) {
-        result.quantity = OrderValidation.max("quantity", config.maxQty);
-      }
-      if (!isNaN(qty) && qty < base_min) {
-        result.quantity = OrderValidation.min("quantity", base_min);
-      }
-      if (Number(tp_trigger_price) < 0) {
-        result.tp_trigger_price = OrderValidation.min("tp_trigger_price", 0);
-      }
-      if (Number(sl_trigger_price) < 0) {
-        result.sl_trigger_price = OrderValidation.min("sl_trigger_price", 0);
-      }
-      if (tp_order_type === types.OrderType.LIMIT && !tp_order_price) {
-        result.tp_order_price = OrderValidation.required("tp_order_price");
-      }
-      if (sl_order_type === types.OrderType.LIMIT && !sl_order_price) {
-        result.sl_order_price = OrderValidation.required("sl_order_price");
-      }
-      const mark_price = orderType === types.OrderType.MARKET || orderType == null ? config.markPrice : values.order_price ? Number(values.order_price) : void 0;
-      const tpslSide = side === types.OrderSide.BUY ? types.OrderSide.SELL : types.OrderSide.BUY;
-      if (side === types.OrderSide.BUY && mark_price) {
-        if (!!sl_trigger_price && Number(sl_trigger_price) < quote_min) {
-          result.sl_trigger_price = OrderValidation.min(
-            "sl_trigger_price",
-            formatPrice2(quote_min, quote_dp)
-          );
-        }
-        if (!!sl_trigger_price && Number(sl_trigger_price) >= mark_price) {
-          result.sl_trigger_price = OrderValidation.max(
-            "sl_trigger_price",
-            formatPrice2(mark_price, quote_dp)
-          );
-        }
-        if (!!tp_trigger_price && Number(tp_trigger_price) <= mark_price) {
-          result.tp_trigger_price = OrderValidation.min(
-            "tp_trigger_price",
-            formatPrice2(mark_price, quote_dp)
-          );
-        }
-        if (!!tp_trigger_price && Number(tp_trigger_price) > quote_max) {
-          result.tp_trigger_price = OrderValidation.max(
-            "tp_trigger_price",
-            formatPrice2(quote_max, quote_dp)
-          );
-        }
-        if (sl_trigger_price && sl_order_price) {
-          const slOrderPriceRange = getPriceRange({
-            side: tpslSide,
-            basePrice: Number(sl_trigger_price),
-            symbolInfo: config.symbol
-          });
-          if (Number(sl_order_price) < slOrderPriceRange.minPrice) {
-            result.sl_order_price = OrderValidation.min(
-              "sl_order_price",
-              formatPrice2(slOrderPriceRange.minPrice, quote_dp)
-            );
-          }
-          if (Number(sl_order_price) > slOrderPriceRange.maxPrice) {
-            result.sl_order_price = OrderValidation.max(
-              "sl_order_price",
-              formatPrice2(slOrderPriceRange.maxPrice, quote_dp)
-            );
-          }
-          if (Number(sl_trigger_price) < Number(sl_order_price)) {
-            result.sl_trigger_price = OrderValidation.priceErrorMax("sl_trigger_price");
-          }
-        }
-        if (tp_trigger_price && tp_order_price) {
-          const tpOrderPriceRange = getPriceRange({
-            side: tpslSide,
-            basePrice: Number(tp_trigger_price),
-            symbolInfo: config.symbol
-          });
-          if (Number(tp_order_price) > tpOrderPriceRange.maxPrice) {
-            result.tp_order_price = OrderValidation.max(
-              "tp_order_price",
-              formatPrice2(tpOrderPriceRange.maxPrice, quote_dp)
-            );
-          }
-          if (Number(tp_order_price) < tpOrderPriceRange.minPrice) {
-            result.tp_order_price = OrderValidation.min(
-              "tp_order_price",
-              formatPrice2(tpOrderPriceRange.minPrice, quote_dp)
-            );
-          }
-          if (Number(tp_trigger_price) > Number(tp_order_price)) {
-            result.tp_trigger_price = OrderValidation.priceErrorMin("tp_trigger_price");
-          }
-        }
-      }
-      if (side === types.OrderSide.SELL && mark_price) {
-        if (!!sl_trigger_price && Number(sl_trigger_price) > quote_max) {
-          result.sl_trigger_price = OrderValidation.max(
-            "sl_trigger_price",
-            formatPrice2(quote_max, quote_dp)
-          );
-        }
-        if (!!sl_trigger_price && Number(sl_trigger_price) <= mark_price) {
-          result.sl_trigger_price = OrderValidation.min(
-            "sl_trigger_price",
-            formatPrice2(mark_price, quote_dp)
-          );
-        }
-        if (!!tp_trigger_price && Number(tp_trigger_price) >= mark_price) {
-          result.tp_trigger_price = OrderValidation.max(
-            "tp_trigger_price",
-            formatPrice2(mark_price, quote_dp)
-          );
-        }
-        if (!!tp_trigger_price && Number(tp_trigger_price) < quote_min) {
-          result.tp_trigger_price = OrderValidation.min(
-            "tp_trigger_price",
-            formatPrice2(quote_min, quote_dp)
-          );
-        }
-        if (sl_trigger_price && sl_order_price) {
-          const slOrderPriceRange = getPriceRange({
-            side: tpslSide,
-            basePrice: Number(sl_trigger_price),
-            symbolInfo: config.symbol
-          });
-          if (Number(sl_order_price) < slOrderPriceRange.minPrice) {
-            result.sl_order_price = OrderValidation.min(
-              "sl_order_price",
-              formatPrice2(slOrderPriceRange.minPrice, quote_dp)
-            );
-          }
-          if (Number(sl_order_price) > slOrderPriceRange.maxPrice) {
-            result.sl_order_price = OrderValidation.max(
-              "sl_order_price",
-              formatPrice2(slOrderPriceRange.maxPrice, quote_dp)
-            );
-          }
-          if (Number(sl_trigger_price) > Number(sl_order_price)) {
-            result.sl_trigger_price = OrderValidation.priceErrorMin("sl_trigger_price");
-          }
-        }
-        if (tp_trigger_price && tp_order_price) {
-          const tpOrderPriceRange = getPriceRange({
-            side: tpslSide,
-            basePrice: Number(tp_trigger_price),
-            symbolInfo: config.symbol
-          });
-          if (Number(tp_order_price) < tpOrderPriceRange.minPrice) {
-            result.tp_order_price = OrderValidation.min(
-              "tp_order_price",
-              formatPrice2(tpOrderPriceRange.minPrice, quote_dp)
-            );
-          }
-          if (Number(tp_order_price) > tpOrderPriceRange.maxPrice) {
-            result.tp_order_price = OrderValidation.max(
-              "tp_order_price",
-              formatPrice2(tpOrderPriceRange.maxPrice, quote_dp)
-            );
-          }
-          if (Number(tp_trigger_price) < Number(tp_order_price)) {
-            result.tp_trigger_price = OrderValidation.priceErrorMax("tp_trigger_price");
-          }
-        }
-      }
-      return Object.keys(result).length > 0 ? result : null;
-    });
+    return Promise.resolve(
+      this.tpslValidationStrategy.validate(values, config)
+    );
   }
 };
 
@@ -10042,7 +10626,9 @@ var TPSLOrderCreator = class extends BaseAlgoOrderCreator {
       reduce_only: true,
       quantity: values.quantity,
       symbol: values.symbol,
-      child_orders
+      child_orders,
+      // Include margin_mode for isolated/cross margin support; default CROSS per order entry pattern
+      margin_mode: values.margin_mode || types.MarginMode.CROSS
     };
   }
   crateUpdateOrder(values, oldValue, config) {
@@ -10144,7 +10730,9 @@ var TPSLPositionOrderCreator = class extends BaseAlgoOrderCreator {
       trigger_price_type: types.TriggerPriceType.MARK_PRICE,
       // reduce_only: true,
       symbol: values.symbol,
-      child_orders
+      child_orders,
+      // Include margin_mode for isolated/cross margin support; default CROSS per order entry pattern
+      margin_mode: values.margin_mode || types.MarginMode.CROSS
     };
   }
   crateUpdateOrder(values, oldValue, config) {
@@ -10181,7 +10769,11 @@ var TrailingStopOrderCreator = class extends BaseOrderCreator {
     super(...arguments);
     this.orderType = types.OrderType.TRAILING_STOP;
   }
-  create(values, config) {
+  /**
+   * Builds the trailing stop order
+   * Implements template method hook
+   */
+  buildOrder(values, config) {
     const { order_quantity, activated_price, callback_value, callback_rate } = values;
     const order = {
       ...this.baseOrder(values),
@@ -10202,6 +10794,7 @@ var TrailingStopOrderCreator = class extends BaseOrderCreator {
         "quantity",
         "side",
         "reduce_only",
+        "margin_mode",
         "visible_quantity",
         "activated_price",
         "callback_value",
@@ -10210,28 +10803,34 @@ var TrailingStopOrderCreator = class extends BaseOrderCreator {
       order
     );
   }
-  async validate(values, config) {
+  /**
+   * Runs validations for trailing stop order
+   * Implements template method hook
+   */
+  runValidations(values, config) {
     const { markPrice, symbol } = config;
     const { quote_dp } = config.symbol;
     const { side, activated_price, callback_value, callback_rate } = values;
-    const errors = await this.baseValidate(values, config);
+    const errors = this.baseValidate(values, config);
     if (activated_price) {
-      const { minPrice: minPrice3, maxPrice: maxPrice3 } = getPriceRange2({
+      const { minPrice, maxPrice } = getPriceRange({
         side,
-        markPrice,
+        basePrice: markPrice,
         symbolInfo: symbol
       });
-      const activatedPrice = new utils.Decimal(activated_price);
-      if (activatedPrice.lt(minPrice3) || activatedPrice.equals(0)) {
-        errors.activated_price = OrderValidation.min(
-          "activated_price",
-          new utils.Decimal(minPrice3).todp(quote_dp).toString()
-        );
-      } else if (activatedPrice.gt(maxPrice3)) {
-        errors.activated_price = OrderValidation.max(
-          "activated_price",
-          new utils.Decimal(maxPrice3).todp(quote_dp).toString()
-        );
+      if (!isNaN(minPrice) && !isNaN(maxPrice)) {
+        const activatedPrice = new utils.Decimal(activated_price);
+        if (activatedPrice.lt(minPrice) || activatedPrice.equals(0)) {
+          errors.activated_price = OrderValidation.min(
+            "activated_price",
+            new utils.Decimal(minPrice).todp(quote_dp).toString()
+          );
+        } else if (activatedPrice.gt(maxPrice)) {
+          errors.activated_price = OrderValidation.max(
+            "activated_price",
+            new utils.Decimal(maxPrice).todp(quote_dp).toString()
+          );
+        }
       }
     }
     if (!callback_value && !callback_rate) {
@@ -10263,23 +10862,6 @@ var TrailingStopOrderCreator = class extends BaseOrderCreator {
     return errors;
   }
 };
-function getPriceRange2(inputs) {
-  const { markPrice, side, symbolInfo } = inputs;
-  const { quote_min, quote_max } = symbolInfo;
-  const priceRange = side === types.OrderSide.BUY ? {
-    min: quote_min,
-    max: markPrice
-  } : {
-    min: markPrice,
-    max: quote_max
-  };
-  const minPrice3 = Math.max(quote_min, priceRange?.min);
-  const maxPrice3 = Math.min(quote_max, priceRange?.max);
-  return {
-    minPrice: minPrice3,
-    maxPrice: maxPrice3
-  };
-}
 
 // src/services/orderCreator/factory.ts
 var OrderFactory = class {
@@ -10402,27 +10984,63 @@ var calcEstLiqPrice = (order, askAndBid, inputs) => {
     markPrice,
     totalCollateral,
     futures_taker_fee_rate,
-    positions: positions3
+    positions: positions3,
+    symbolLeverage,
+    sumUnitaryFunding
   } = inputs;
   const orderFee = perp.order.orderFee({
     qty: quantity,
     price,
     futuresTakeFeeRate: Number(futures_taker_fee_rate) / 1e4
   });
-  const liqPrice = perp.order.estLiqPrice({
-    markPrice,
-    baseIMR: symbolInfo.base_imr,
-    baseMMR: symbolInfo.base_mmr,
-    totalCollateral,
-    positions: positions3 == null ? [] : positions3,
-    IMR_Factor: imr_factor,
-    orderFee,
-    newOrder: {
-      qty: quantity,
-      price,
-      symbol
+  let liqPrice = 0;
+  if (order.margin_mode === types.MarginMode.CROSS) {
+    liqPrice = perp.order.estLiqPrice({
+      markPrice,
+      baseIMR: symbolInfo.base_imr,
+      baseMMR: symbolInfo.base_mmr,
+      totalCollateral,
+      positions: positions3 == null ? [] : positions3,
+      IMR_Factor: imr_factor,
+      orderFee,
+      newOrder: {
+        qty: quantity,
+        price,
+        symbol
+      }
+    });
+  } else {
+    let isolatedPositionMargin = 0, costPosition = 0, positionQty = 0, lastSumUnitaryFunding = 0, leverage = symbolLeverage ?? 1;
+    if (positions3) {
+      const position = positions3.find(
+        (p) => p.symbol === symbol && p.margin_mode === types.MarginMode.ISOLATED
+      );
+      if (position) {
+        isolatedPositionMargin = position.margin ?? 0;
+        costPosition = position.cost_position ?? 0;
+        positionQty = position.position_qty ?? 0;
+        lastSumUnitaryFunding = position.last_sum_unitary_funding ?? 0;
+        leverage = position.leverage ? Number(position.leverage) : 1;
+      }
     }
-  });
+    liqPrice = perp.order.estLiqPriceIsolated({
+      isolatedPositionMargin,
+      costPosition,
+      positionQty,
+      sumUnitaryFunding,
+      lastSumUnitaryFunding,
+      markPrice,
+      baseIMR: symbolInfo.base_imr,
+      baseMMR: symbolInfo.base_mmr,
+      IMR_Factor: imr_factor,
+      leverage,
+      newOrder: {
+        symbol,
+        qty: quantity,
+        price
+      }
+    });
+  }
   if (liqPrice <= 0) return null;
   return liqPrice;
 };
@@ -10480,7 +11098,9 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
     // sl_enable: isEditing
     //   ? checkIsEnableTpSL(options?.defaultOrder).sl_enable
     //   : options?.tpslEnable?.sl_enable,
-    position_type: options?.positionType
+    position_type: options?.positionType,
+    // Use defaultOrder.margin_mode when editing; otherwise position.margin_mode; default CROSS for backward compatibility
+    margin_mode: options?.defaultOrder?.margin_mode ?? position?.margin_mode ?? types.MarginMode.CROSS
   });
   const symbolInfo = useSymbolsInfo()[position.symbol]();
   const { data: markPrice } = useMarkPrice(order.symbol);
@@ -10783,11 +11403,53 @@ var useMaxLeverage = (symbol) => {
 };
 var useSymbolLeverage = (symbol) => {
   const symbolInfo = useSymbolInfo(symbol);
-  const [update, { isMutating }] = useMutation("/v1/client/leverage");
+  const { state } = useAccount();
+  const [updateMutation, { isMutating }] = useMutation("/v1/client/leverage");
   const maxLeverage = React.useMemo(() => {
     const baseIMR = symbolInfo?.("base_imr");
     return baseIMR ? 1 / baseIMR : 1;
   }, [symbolInfo]);
+  const update = async (data) => {
+    const result = await updateMutation(data);
+    if (result?.success && data.symbol && state.accountId) {
+      const key = ["/v1/client/leverages", state.accountId];
+      useSWR5.mutate(
+        key,
+        (prev) => {
+          if (!prev) {
+            return [
+              {
+                symbol: data.symbol,
+                leverage: data.leverage,
+                margin_mode: data.margin_mode
+              }
+            ];
+          }
+          const index = prev.findIndex(
+            (item) => item.symbol === data.symbol && (item.margin_mode ?? types.MarginMode.CROSS) === (data.margin_mode ?? types.MarginMode.CROSS)
+          );
+          if (index === -1) {
+            return [
+              ...prev,
+              {
+                symbol: data.symbol,
+                leverage: data.leverage,
+                margin_mode: data.margin_mode
+              }
+            ];
+          }
+          const next = [...prev];
+          next[index] = {
+            ...next[index],
+            leverage: data.leverage
+          };
+          return next;
+        },
+        { revalidate: false }
+      );
+    }
+    return result;
+  };
   return {
     maxLeverage,
     update,
@@ -11524,8 +12186,8 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
     const keys = Object.keys(current);
     for (let i = 0; i < keys.length; i++) {
       const k = keys[i];
-      let preveValue = prev[k];
-      let currentValue = current[k];
+      const preveValue = prev[k];
+      const currentValue = current[k];
       if (typeof preveValue === "undefined" && typeof currentValue === "undefined")
         continue;
       if (preveValue !== currentValue) {
@@ -11538,7 +12200,12 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
     if (!key) return null;
     return { key, value, preValue };
   };
-  const maxQty = useMaxQty(symbol, sideValue, isReduceOnly);
+  const { marginMode: symbolMarginMode } = useMarginModeBySymbol(symbol);
+  const marginMode = typeof symbolOrOrder === "object" && symbolOrOrder.margin_mode ? symbolOrOrder.margin_mode : symbolMarginMode;
+  const maxQty = useMaxQty(symbol, sideValue, {
+    reduceOnly: isReduceOnly,
+    marginMode: marginMode ?? types.MarginMode.CROSS
+  });
   const parseString2Number = (order, key, dp) => {
     if (typeof order[key] !== "string") return;
     if (order[key] && order[key].startsWith(".")) {
@@ -12089,7 +12756,7 @@ var DataPaint = class extends BasePaint {
     );
     const { position, fontSize = 14 } = layout;
     let left = this._ratio(position.left);
-    let top = layout.position.top + offsetTop + this.transformTop;
+    const top = layout.position.top + offsetTop + this.transformTop;
     let prevElementBoundingBox = {};
     if (typeof options.data?.position.side !== "undefined") {
       prevElementBoundingBox = this._drawText(options.data.position.side, {
@@ -12120,6 +12787,28 @@ var DataPaint = class extends BasePaint {
         fontFamily: options.fontFamily
       });
     }
+    const marginMode = options.data?.position.marginMode;
+    if (marginMode) {
+      left += (prevElementBoundingBox.width ?? 0) + this._ratio(7);
+      if (prevElementBoundingBox.width) {
+        prevElementBoundingBox = this._drawText("|", {
+          color: "rgba(255,255,255,0.2)",
+          left,
+          top: this._ratio(top),
+          fontSize: this._ratio(fontSize),
+          fontFamily: options.fontFamily
+        });
+      }
+      left += (prevElementBoundingBox.width ?? 0) + this._ratio(7);
+      const marginModeText = marginMode.charAt(0).toUpperCase() + marginMode.slice(1);
+      prevElementBoundingBox = this._drawText(marginModeText, {
+        color: layout.color,
+        left,
+        top: this._ratio(top),
+        fontSize: this._ratio(fontSize),
+        fontFamily: options.fontFamily
+      });
+    }
     if (typeof options.data?.position.leverage !== "undefined") {
       left += (prevElementBoundingBox.width ?? 0) + this._ratio(7);
       if (prevElementBoundingBox.width) {
@@ -12200,8 +12889,8 @@ var DataPaint = class extends BasePaint {
     (options.data?.position.informations.length ?? 0) === 2;
     const col = informations.length > 4 ? 3 : 2;
     informations.forEach((info, index) => {
-      let left = position.left + index % col * this.positionInfoCellWidth;
-      let top = position.top + Math.floor(index / col) * 38 + this.transformTop;
+      const left = position.left + index % col * this.positionInfoCellWidth;
+      const top = position.top + Math.floor(index / col) * 38 + this.transformTop;
       this._drawText(info.title, {
         left: this._ratio(left),
         top: this._ratio(top),
@@ -17743,95 +18432,111 @@ var initialOrderState = {
   trigger_price: "",
   tp_trigger_price: "",
   sl_trigger_price: "",
-  tp_order_type: types.OrderType.MARKET,
-  tp_pnl: "",
-  sl_pnl: "",
-  tp_offset_percentage: "",
-  sl_offset_percentage: "",
-  tp_offset: "",
-  sl_offset: "",
-  sl_order_type: types.OrderType.MARKET,
   total: "",
-  // scaled order
-  start_price: "",
-  end_price: "",
-  totalOrders: "",
-  distribution_type: "",
-  skew: "",
-  // symbol: "",
-  // trailing stop order
-  activated_price: "",
-  callback_value: "",
-  callback_rate: ""
+  symbol: ""
 };
-var useOrderStore = (initialOrder) => {
-  const [entry, setEntry] = React.useState(initialOrder);
-  const [estLeverage, setEstLeverage] = React.useState(null);
-  const [estLiquidationPrice, setEstLiquidationPrice] = React.useState(
-    null
-  );
-  const [errors, setErrors] = React.useState({});
-  const updateOrder = (order) => {
-    setEntry(
-      // if use {...draft, ...order} will cause extra updated when object it not changed
-      immer$1.produce((draft) => {
-        Object.assign(draft, order);
-      })
-      // (prev) => ({ ...prev, ...order })
-    );
-  };
-  const updateOrderByKey = (key, value) => {
-    setEntry(
-      immer$1.produce((draft) => {
-        draft[key] = value;
-      })
-    );
-  };
-  const restoreOrder = (order) => {
-    setEntry(immer$1.produce((draft) => order));
-  };
-  const updateOrderComputed = (data) => {
-    setEstLeverage(data.estLeverage);
-    setEstLiquidationPrice(data.estLiquidationPrice);
-  };
-  const resetOrder = (order) => {
-    setEntry(
-      immer$1.produce((draft) => ({
-        ...draft,
-        ...order ?? initialOrderState
-      }))
-    );
-  };
-  const hasTP_SL = () => {
-    return typeof entry.tp_trigger_price !== "undefined" || typeof entry.sl_trigger_price !== "undefined";
-  };
-  return {
-    entry,
-    estLeverage,
-    estLiquidationPrice,
-    errors,
+var useOrderStore = zustand.create()(
+  immer.immer((set, get3) => ({
+    entry: {
+      side: types.OrderSide.BUY,
+      order_type: types.OrderType.LIMIT,
+      ...initialOrderState
+    },
+    estLeverage: null,
+    estLiquidationPrice: null,
+    errors: {},
     actions: {
-      updateOrder,
-      updateOrderByKey,
-      restoreOrder,
-      updateOrderComputed,
-      resetOrder,
-      hasTP_SL
+      initOrder: (symbol, options) => {
+        set((state) => {
+          state.entry = {
+            ...initialOrderState,
+            symbol,
+            side: options?.side ?? types.OrderSide.BUY,
+            order_type: options?.order_type ?? types.OrderType.LIMIT,
+            margin_mode: options?.margin_mode ?? types.MarginMode.CROSS
+          };
+          state.estLeverage = null;
+          state.estLiquidationPrice = null;
+          state.errors = {};
+        });
+      },
+      hasTP_SL: () => {
+        const order = get3().entry;
+        return typeof order.tp_trigger_price !== "undefined" || typeof order.sl_trigger_price !== "undefined";
+      },
+      updateOrderComputed: (data) => {
+        set(
+          (state) => {
+            state.estLeverage = data.estLeverage;
+            state.estLiquidationPrice = data.estLiquidationPrice;
+          },
+          false
+          // "updateOrderComputed"
+        );
+      },
+      updateOrder: (order) => {
+        set(
+          (state) => {
+            state.entry = {
+              ...state.entry,
+              ...order
+            };
+          },
+          false
+          // "updateOrder"
+        );
+      },
+      updateOrderByKey: (key, value) => {
+        set(
+          (state) => {
+            state.entry[key] = value;
+          },
+          false
+          // "updateOrderByKey"
+        );
+      },
+      restoreOrder: (order) => {
+        set(
+          (state) => {
+            state.entry = order;
+          },
+          false
+          // "restoreOrder"
+        );
+      },
+      resetOrder: (_order) => {
+        set(
+          (state) => {
+            state.entry.order_price = "";
+            state.entry.order_quantity = "";
+            state.entry.trigger_price = "";
+            state.entry.total = "";
+            state.entry.tp_trigger_price = "";
+            state.entry.tp_pnl = "";
+            state.entry.tp_offset = "";
+            state.entry.tp_offset_percentage = "";
+            state.entry.sl_trigger_price = "";
+            state.entry.sl_pnl = "";
+            state.entry.sl_offset = "";
+            state.entry.sl_offset_percentage = "";
+          },
+          true
+          // "resetOrder"
+        );
+      }
     }
-  };
-};
-
-// src/next/useOrderEntry/useOrderEntry.internal.ts
+  }))
+);
 var useOrderEntryNextInternal = (symbol, options = {}) => {
   const { symbolInfo, symbolLeverage } = options;
-  const initialOrder = {
-    side: types.OrderSide.BUY,
-    order_type: types.OrderType.LIMIT,
-    order_price: "",
-    symbol,
-    ...options.initialOrder
-  };
-  const { actions: orderEntryActions, entry: orderEntity } = useOrderStore(initialOrder);
+  const orderEntity = useOrderStore((state) => state.entry);
+  const orderEntryActions = useOrderStore((state) => state.actions);
+  React.useEffect(() => {
+    orderEntryActions.initOrder(symbol, options.initialOrder);
+    if (options.initialOrder) {
+      orderEntryActions.updateOrder(options.initialOrder);
+    }
+  }, [symbol]);
   const calculate2 = React.useCallback(
     (values, fieldName, value, markPrice, config) => {
       const fieldHandler = getCalculateHandler(fieldName);
@@ -17845,17 +18550,15 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
     },
     []
   );
-  React.useEffect(() => {
-    orderEntryActions.updateOrderByKey("symbol", symbol);
-  }, [orderEntryActions, symbol]);
   const setValue = (key, value, additional) => {
     if (!symbolInfo) {
       orderEntryActions.updateOrderByKey(key, value);
       return;
     }
+    const currentEntry = useOrderStore.getState().entry;
     const { markPrice } = additional ?? { markPrice: 0 };
     let newValues = calculate2(
-      { ...orderEntity },
+      { ...currentEntry },
       key,
       value,
       markPrice,
@@ -17936,7 +18639,8 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
       orderEntryActions.updateOrder(values);
       return;
     }
-    let newValues = { ...orderEntity };
+    const currentEntry = useOrderStore.getState().entry;
+    let newValues = { ...currentEntry };
     Object.keys(values).forEach((key) => {
       newValues = calculate2(
         newValues,
@@ -17952,10 +18656,11 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
   const onMarkPriceUpdated = React.useCallback(
     (markPrice, baseOn = []) => {
       if (!options.symbolInfo) return;
-      let newValues = { ...orderEntity };
+      const currentEntry = useOrderStore.getState().entry;
+      let newValues = { ...currentEntry };
       if (baseOn.length === 0) {
         newValues = calculate2(
-          { ...orderEntity },
+          { ...currentEntry },
           "order_price",
           markPrice,
           markPrice,
@@ -17966,7 +18671,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
           newValues = calculate2(
             { ...newValues },
             key,
-            orderEntity[key],
+            currentEntry[key],
             markPrice,
             options.symbolInfo
           );
@@ -17987,7 +18692,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
       }
       orderEntryActions.updateOrder(newValues);
     },
-    [calculate2, options.symbolInfo, orderEntity, orderEntryActions]
+    [calculate2, options.symbolInfo, orderEntryActions]
   );
   const validate = (order, creator, options2) => {
     return creator?.validate(order, {
@@ -18036,6 +18741,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
   const lastChangedField = React.useRef();
   const lastOrderTypeExt = React.useRef();
   const lastLevel = React.useRef();
+  const fundingRates = useFundingRatesStore();
   const calculateTPSL_baseOn = React.useRef({
     tp: "",
     sl: ""
@@ -18044,7 +18750,9 @@ var useOrderEntry2 = (symbol, options = {}) => {
   const symbolConfig = useSymbolsInfo();
   const accountInfo = useAccountInfo();
   const positions3 = usePositions();
-  const symbolLeverage = useLeverageBySymbol(symbol);
+  const entry = useOrderStore((s) => s.entry);
+  const effectiveMarginMode = options?.initialOrder?.margin_mode ?? entry?.margin_mode ?? types.MarginMode.CROSS;
+  const symbolLeverage = useLeverageBySymbol(symbol, effectiveMarginMode);
   const symbolInfo = symbolConfig[symbol]();
   const markPrice = actions.getMarkPriceBySymbol(symbol);
   const { orderMetadata } = useOrderlyContext();
@@ -18066,11 +18774,13 @@ var useOrderEntry2 = (symbol, options = {}) => {
   const [doCreateOrder, { isMutating }] = useMutation(
     getCreateOrderUrl(formattedOrder)
   );
-  const maxQtyValue = useMaxQty(
-    symbol,
-    formattedOrder.side,
-    formattedOrder.reduce_only
-  );
+  const bestAskBid = askAndBid.current?.[0] || [];
+  const referencePriceFromOrder = bestAskBid.length >= 2 && formattedOrder.order_type && formattedOrder.side ? getOrderReferencePriceFromOrder(formattedOrder, bestAskBid) : null;
+  const maxQtyValue = useMaxQty(symbol, formattedOrder.side, {
+    reduceOnly: formattedOrder.reduce_only,
+    marginMode: effectiveMarginMode,
+    currentOrderReferencePrice: referencePriceFromOrder && referencePriceFromOrder > 0 ? referencePriceFromOrder : void 0
+  });
   const maxQty = options.maxQty ?? maxQtyValue;
   const updateOrderPrice = () => {
     const order_type = formattedOrder.order_type;
@@ -18160,6 +18870,9 @@ var useOrderEntry2 = (symbol, options = {}) => {
     };
   }, []);
   React.useEffect(() => {
+    if (formattedOrder.symbol !== symbol) {
+      return;
+    }
     if ((formattedOrder.order_type === types.OrderType.MARKET || formattedOrder.order_type === types.OrderType.STOP_MARKET) && markPrice) {
       const baseOn = /* @__PURE__ */ new Set();
       if (lastChangedField.current) {
@@ -18173,7 +18886,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
       }
       orderEntryActions.onMarkPriceChange(markPrice, Array.from(baseOn));
     }
-  }, [markPrice, formattedOrder.order_type]);
+  }, [markPrice, formattedOrder.order_type, formattedOrder.symbol, symbol]);
   const prepareData = React.useCallback(() => {
     return {
       markPrice: actions.getMarkPriceBySymbol(symbol),
@@ -18282,7 +18995,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
       }
     );
   };
-  const { freeCollateral, totalCollateral } = useCollateral();
+  const { freeCollateral, freeCollateralUSDCOnly, totalCollateral } = useCollateral();
   const currentPosition = React.useMemo(() => {
     const rows = positions3 ?? [];
     const p = Array.isArray(rows) ? rows.find(
@@ -18295,6 +19008,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
     if (!markPrice2 || !accountInfo || !symbolInfo) {
       return null;
     }
+    const sumUnitaryFunding = fundingRates[symbol]?.sum_unitary_funding ?? 0;
     const estLiqPrice2 = calcEstLiqPrice(formattedOrder, askAndBid.current[0], {
       markPrice: markPrice2,
       totalCollateral,
@@ -18302,7 +19016,9 @@ var useOrderEntry2 = (symbol, options = {}) => {
       imr_factor: accountInfo.imr_factor[symbol],
       symbol,
       positions: positions3,
-      symbolInfo
+      symbolInfo,
+      sumUnitaryFunding,
+      symbolLeverage
     });
     return estLiqPrice2;
   }, [
@@ -18312,7 +19028,9 @@ var useOrderEntry2 = (symbol, options = {}) => {
     totalCollateral,
     symbol,
     maxQty,
-    symbolInfo
+    symbolInfo,
+    fundingRates,
+    symbolLeverage
   ]);
   const estLiqPriceDistance = React.useMemo(() => {
     if (!estLiqPrice) {
@@ -18447,7 +19165,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
       validator: validateOrder,
       validate: validateOrder
     },
-    freeCollateral,
+    freeCollateral: effectiveMarginMode === types.MarginMode.ISOLATED ? freeCollateralUSDCOnly : freeCollateral,
     setValue: useMemoizedFn(setValue),
     setValues: useMemoizedFn(setValues),
     symbolInfo: symbolInfo || types.EMPTY_OBJECT,
@@ -18457,93 +19175,6 @@ var useOrderEntry2 = (symbol, options = {}) => {
     symbolLeverage
   };
 };
-var initialOrderState2 = {
-  order_price: "",
-  order_quantity: "",
-  trigger_price: "",
-  tp_trigger_price: "",
-  sl_trigger_price: "",
-  total: "",
-  symbol: ""
-};
-var useOrderStore2 = zustand.create()(
-  immer.immer((set, get3) => ({
-    entry: {
-      side: types.OrderSide.BUY,
-      order_type: types.OrderType.LIMIT,
-      ...initialOrderState2
-    },
-    estLeverage: null,
-    estLiquidationPrice: null,
-    errors: {},
-    actions: {
-      hasTP_SL: () => {
-        const order = get3().entry;
-        return typeof order.tp_trigger_price !== "undefined" || typeof order.sl_trigger_price !== "undefined";
-      },
-      updateOrderComputed: (data) => {
-        set(
-          (state) => {
-            state.estLeverage = data.estLeverage;
-            state.estLiquidationPrice = data.estLiquidationPrice;
-          },
-          false
-          // "updateOrderComputed"
-        );
-      },
-      updateOrder: (order) => {
-        set(
-          (state) => {
-            state.entry = {
-              ...state.entry,
-              ...order
-            };
-          },
-          false
-          // "updateOrder"
-        );
-      },
-      updateOrderByKey: (key, value) => {
-        set(
-          (state) => {
-            state.entry[key] = value;
-          },
-          false
-          // "updateOrderByKey"
-        );
-      },
-      restoreOrder: (order) => {
-        set(
-          (state) => {
-            state.entry = order;
-          },
-          false
-          // "restoreOrder"
-        );
-      },
-      resetOrder: (order) => {
-        set(
-          (state) => {
-            state.entry.order_price = "";
-            state.entry.order_quantity = "";
-            state.entry.trigger_price = "";
-            state.entry.total = "";
-            state.entry.tp_trigger_price = "";
-            state.entry.tp_pnl = "";
-            state.entry.tp_offset = "";
-            state.entry.tp_offset_percentage = "";
-            state.entry.sl_trigger_price = "";
-            state.entry.sl_pnl = "";
-            state.entry.sl_offset = "";
-            state.entry.sl_offset_percentage = "";
-          },
-          true
-          // "resetOrder"
-        );
-      }
-    }
-  }))
-);
 var useOrderEntity = (order, options) => {
   const { symbol } = order;
   const { maxQty } = options || {};
@@ -18701,13 +19332,15 @@ var usePositionClose = (options) => {
       symbol,
       order_type: type,
       side,
-      reduce_only: true
+      reduce_only: true,
+      // Use position's margin_mode or default to CROSS for backward compatibility
+      margin_mode: position.margin_mode || types.MarginMode.CROSS
     };
     if (type === types.OrderType.LIMIT) {
       data.order_price = price;
     }
     return data;
-  }, [symbol, price, type, quantity]);
+  }, [symbol, price, type, quantity, position.margin_mode]);
   const maxQty = React.useMemo(() => {
     if (!position) {
       return 0;
@@ -18909,9 +19542,11 @@ var useTpslPriceChecker = (params) => {
   prevResultRef.current = currentResult;
   return currentResult;
 };
-var useEstLiqPriceBySymbol = (symbol) => {
+var useEstLiqPriceBySymbol = (symbol, marginMode) => {
   const [data] = usePositionStream(symbol);
-  const position = data?.rows?.find((row) => row.symbol === symbol);
+  const position = data?.rows?.find(
+    (row) => row.symbol === symbol && row.margin_mode === marginMode
+  );
   return React.useMemo(() => {
     return position?.est_liq_price ?? void 0;
   }, [position]);
@@ -18932,6 +19567,62 @@ var useGetEstLiqPrice = (props) => {
     return estLiqPrice;
   }, [estLiqPrice, markPrice, side]);
 };
+var useFeatureFlag = (key) => {
+  const { data: publicFlags, isLoading: publicLoading } = useQuery("/v1/public/feature_flags", {});
+  const publicFlag = React.useMemo(() => {
+    if (!publicFlags || publicLoading) {
+      return void 0;
+    }
+    return publicFlags.find((flag) => flag.key === key);
+  }, [publicFlags, publicLoading, key]);
+  const shouldQueryPrivate = React.useMemo(() => {
+    return publicFlag !== void 0;
+  }, [publicFlag]);
+  const { data: privateFlags, isLoading: privateLoading } = usePrivateQuery(shouldQueryPrivate ? "/v1/feature_flags" : null, {});
+  const privateFlag = React.useMemo(() => {
+    if (!shouldQueryPrivate || !privateFlags || privateLoading) {
+      return void 0;
+    }
+    return privateFlags.find((flag) => flag.key === key);
+  }, [shouldQueryPrivate, privateFlags, privateLoading, key]);
+  return React.useMemo(() => {
+    if (publicLoading || shouldQueryPrivate && privateLoading) {
+      return {
+        enabled: false,
+        data: void 0
+      };
+    }
+    if (publicFlag === void 0) {
+      return {
+        enabled: true,
+        data: void 0
+      };
+    }
+    if (privateFlag === void 0) {
+      return {
+        enabled: false,
+        data: void 0
+      };
+    }
+    return {
+      enabled: true,
+      data: privateFlag
+    };
+  }, [
+    publicFlag,
+    privateFlag,
+    publicLoading,
+    shouldQueryPrivate,
+    privateLoading,
+    key
+  ]);
+};
+
+// src/feature-flag/flagKeys.ts
+var FlagKeys = /* @__PURE__ */ ((FlagKeys2) => {
+  FlagKeys2["IsolatedMargin"] = "isolated-margin";
+  return FlagKeys2;
+})(FlagKeys || {});
 
 exports.swr = useSWR5__namespace;
 Object.defineProperty(exports, "unstable_serialize", {
@@ -18956,6 +19647,7 @@ exports.ENVType = ENVType2;
 exports.ERROR_MSG_CODES = ERROR_MSG_CODES;
 exports.EpochStatus = EpochStatus;
 exports.ExtendedConfigStore = ExtendedConfigStore;
+exports.FlagKeys = FlagKeys;
 exports.MaintenanceStatus = MaintenanceStatus;
 exports.MarketsStorageKey = MarketsStorageKey;
 exports.MarketsType = MarketsType;
@@ -19013,6 +19705,7 @@ exports.useDistributionHistory = useDistributionHistory;
 exports.useEpochInfo = useEpochInfo;
 exports.useEstLiqPriceBySymbol = useEstLiqPriceBySymbol;
 exports.useEventEmitter = useEventEmitter;
+exports.useFeatureFlag = useFeatureFlag;
 exports.useFeeState = useFeeState;
 exports.useFundingDetails = useFundingDetails;
 exports.useFundingFeeHistory = useFundingFeeHistory;
@@ -19043,6 +19736,8 @@ exports.useLocalStorage = useLocalStorage;
 exports.useMainTokenStore = useMainTokenStore;
 exports.useMainnetChainsStore = useMainnetChainsStore;
 exports.useMaintenanceStatus = useMaintenanceStatus;
+exports.useMarginModeBySymbol = useMarginModeBySymbol;
+exports.useMarginModes = useMarginModes;
 exports.useMarginRatio = useMarginRatio;
 exports.useMarkPrice = useMarkPrice;
 exports.useMarkPriceBySymbol = useMarkPriceBySymbol;
@@ -19065,7 +19760,7 @@ exports.useOdosQuote = useOdosQuote;
 exports.useOrderEntity = useOrderEntity;
 exports.useOrderEntry = useOrderEntry2;
 exports.useOrderEntry_deprecated = useOrderEntry;
-exports.useOrderStore = useOrderStore2;
+exports.useOrderStore = useOrderStore;
 exports.useOrderStream = useOrderStream;
 exports.useOrderbookStream = useOrderbookStream;
 exports.useOrderlyContext = useOrderlyContext;
@@ -19073,6 +19768,7 @@ exports.usePortfolio = usePortfolio;
 exports.usePositionActions = usePositionActions;
 exports.usePositionClose = usePositionClose;
 exports.usePositionStream = usePositionStream;
+exports.usePositions = usePositions;
 exports.usePoster = usePoster;
 exports.usePreLoadData = usePreLoadData;
 exports.usePrivateDataObserver = usePrivateDataObserver;
@@ -19102,6 +19798,7 @@ exports.useSubAccountWS = useSubAccountWS;
 exports.useSwapSupportStore = useSwapSupportStore;
 exports.useSymbolInfo = useSymbolInfo;
 exports.useSymbolLeverage = useSymbolLeverage;
+exports.useSymbolLeverageMap = useSymbolLeverageMap;
 exports.useSymbolPriceRange = useSymbolPriceRange;
 exports.useSymbolsInfo = useSymbolsInfo;
 exports.useSymbolsInfoStore = useSymbolsInfoStore;