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

package/dist/index.mjs

@@ -3,7 +3,7 @@ import useSWR5__default, { mutate } from 'swr';
 import * as useSWR5 from 'swr';
 export { useSWR5 as swr };
 export { unstable_serialize, default as useSWR, useSWRConfig } from 'swr';
-import { TesnetTokenFallback, ArbitrumSepoliaTokenInfo, SolanaDevnetTokenInfo, OrderType, OrderSide, SDKError, TrackerEventName, AccountStatusEnum, AlgoOrderType, AlgoOrderRootType, OrderStatus, ArbitrumSepoliaChainInfo, SolanaDevnetChainInfo, EMPTY_LIST, EMPTY_OBJECT, isNativeTokenChecker, nativeTokenAddress, ChainKey, chainsInfoMap, ARBITRUM_TESTNET_CHAINID, ARBITRUM_MAINNET_CHAINID, ChainNamespace, MaxUint256, DEPOSIT_FEE_RATE, ETHEREUM_MAINNET_CHAINID, LedgerWalletKey, SOLANA_TESTNET_CHAINID, MONAD_TESTNET_CHAINID, ABSTRACT_TESTNET_CHAINID, BSC_TESTNET_CHAINID, SolanaChains, PositionType, DistributionType, TriggerPriceType } from '@orderly.network/types';
+import { TesnetTokenFallback, ArbitrumSepoliaTokenInfo, SolanaDevnetTokenInfo, OrderType, OrderSide, MarginMode, SDKError, TrackerEventName, AccountStatusEnum, AlgoOrderType, AlgoOrderRootType, OrderStatus, ArbitrumSepoliaChainInfo, SolanaDevnetChainInfo, EMPTY_LIST, EMPTY_OBJECT, isNativeTokenChecker, nativeTokenAddress, ChainKey, chainsInfoMap, ARBITRUM_TESTNET_CHAINID, ARBITRUM_MAINNET_CHAINID, ChainNamespace, MaxUint256, DEPOSIT_FEE_RATE, ETHEREUM_MAINNET_CHAINID, LedgerWalletKey, SOLANA_TESTNET_CHAINID, MONAD_TESTNET_CHAINID, ABSTRACT_TESTNET_CHAINID, BSC_TESTNET_CHAINID, SolanaChains, PositionType, DistributionType, TriggerPriceType } from '@orderly.network/types';
 import React, { createContext, useContext, useCallback, useState, useEffect, useMemo, useRef, useId, useLayoutEffect } from 'react';
 import { zero, windowGuard, getTimestamp, getGlobalObject, Decimal, timeConvertString, isTestnet, getPrecisionByNumber, getBBOType, camelCaseToUnderscoreCase, commify, todpIfNeed, getTPSLDirection } from '@orderly.network/utils';
 import useSWRMutation from 'swr/mutation';
@@ -38,9 +38,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";
+  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.11.0-alpha.0";
 }
-var version_default = "2.10.2";
+var version_default = "2.11.0-alpha.0";
 var fetcher = (url, init2 = {}, queryOptions) => get(url, init2, queryOptions?.formatter);
 var noCacheConfig = {
   dedupingInterval: 0,
@@ -1084,12 +1084,12 @@ var findTPSLOrderPriceFromOrder = (order) => {
     sl_order_price
   };
 };
-var findPositionTPSLFromOrders = (orders, symbol) => {
+var findPositionTPSLFromOrders = (orders, symbol, marginMode = MarginMode.CROSS) => {
   const fullPositionOrder = orders?.find((order) => {
-    return order.symbol === symbol && order.algo_type === AlgoOrderRootType.POSITIONAL_TP_SL && (order.root_algo_status === OrderStatus.NEW || order.root_algo_status === OrderStatus.REPLACED || order.root_algo_status === OrderStatus.PARTIAL_FILLED);
+    return order.symbol === symbol && order.algo_type === AlgoOrderRootType.POSITIONAL_TP_SL && order.margin_mode === marginMode && (order.root_algo_status === OrderStatus.NEW || order.root_algo_status === OrderStatus.REPLACED || order.root_algo_status === OrderStatus.PARTIAL_FILLED);
   });
   const partialPositionOrders = orders?.filter((order) => {
-    return order.symbol === symbol && order.algo_type === AlgoOrderRootType.TP_SL && (order.root_algo_status === OrderStatus.NEW || order.root_algo_status === OrderStatus.REPLACED || order.root_algo_status === OrderStatus.PARTIAL_FILLED);
+    return order.symbol === symbol && order.margin_mode === marginMode && order.algo_type === AlgoOrderRootType.TP_SL && (order.root_algo_status === OrderStatus.NEW || order.root_algo_status === OrderStatus.REPLACED || order.root_algo_status === OrderStatus.PARTIAL_FILLED);
   }).sort((a, b) => {
     return b.created_time - a.created_time;
   });
@@ -2114,9 +2114,11 @@ var useAppStore = create()(
       totalCollateral: zero,
       totalValue: null,
       freeCollateral: zero,
+      freeCollateralUSDCOnly: zero,
       availableBalance: 0,
       unsettledPnL: 0,
-      totalUnrealizedROI: 0
+      totalUnrealizedROI: 0,
+      usdcHolding: 0
     },
     appState: {
       positionsLoading: false,
@@ -2137,9 +2139,11 @@ var useAppStore = create()(
             totalCollateral: zero,
             totalValue: null,
             freeCollateral: zero,
+            freeCollateralUSDCOnly: zero,
             availableBalance: 0,
             unsettledPnL: 0,
-            totalUnrealizedROI: 0
+            totalUnrealizedROI: 0,
+            usdcHolding: 0
           };
         }, false);
       },
@@ -3935,25 +3939,27 @@ var OrderbookService = class _OrderbookService {
 };
 var orderBookService = OrderbookService.getInstance();
 var orderbook_service_default = orderBookService;
+var useMarkPriceStore = 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] = useState(0);
-  const symbolRef = useRef(symbol);
-  symbolRef.current = symbol;
-  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) => {
@@ -3976,6 +3982,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 = useRef(symbol);
@@ -3995,29 +4007,6 @@ var useOpenInterest = (symbol) => {
     };
   });
 };
-var useMarkPriceStore = 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) => {
@@ -4710,6 +4699,94 @@ var useLeverage = () => {
     maxLeverage: memoizedMaxLeverage
   };
 };
+var buildKey = (symbol, marginMode) => `${symbol}_${marginMode ?? MarginMode.CROSS}`;
+var useSymbolLeverageMap = () => {
+  const { data, error, isLoading, mutate: mutate6 } = usePrivateQuery("/v1/client/leverages", {
+    revalidateOnFocus: false,
+    revalidateOnReconnect: false,
+    errorRetryCount: 1
+  });
+  const leverages = 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 = 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 = 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 = MarginMode.CROSS) => {
+  const { marginModes, isLoading, error, refresh, updateMarginMode } = useMarginModes();
+  const marginMode = fallback === null ? marginModes[symbol] : marginModes[symbol] ?? fallback;
+  const update = 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 = () => {
@@ -5067,10 +5144,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 {
@@ -5078,13 +5158,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 = [];
@@ -5115,6 +5228,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) => {
@@ -5155,28 +5280,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
     });
@@ -5389,21 +5513,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 = 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 === MarginMode.ISOLATED ? new Decimal(item.margin ?? 0).add(item.unsettlement_pnl ?? 0).toNumber() : crossMarginCollateral.toNumber();
+        let est_liq_price;
+        if (item.margin_mode === MarginMode.ISOLATED) {
+          est_liq_price = 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 = 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
@@ -5554,7 +5695,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;
@@ -5590,7 +5733,14 @@ var PortfolioCalculator = class extends BaseCalculator {
     if (!holding || !positions3 || !Array.isArray(positions3.rows) || !markPrices || !indexPrices || !accountInfo) {
       return null;
     }
-    const unsettledPnL = pathOr(0, ["total_unsettled_pnl"])(positions3);
+    const totallCrossUnsettledPnL = positions3.rows.reduce(
+      (sum, pos) => pos.margin_mode === MarginMode.ISOLATED ? sum : sum + (pos.unsettled_pnl ?? 0),
+      0
+    );
+    const totalUnsettlementPnL = positions3.rows.reduce(
+      (sum, pos) => sum + (pos.unsettled_pnl ?? 0),
+      0
+    );
     const unrealizedPnL = pathOr(0, ["total_unreal_pnl"])(positions3);
     const [USDC_holding, nonUSDC] = parseHolding(
       holding,
@@ -5601,28 +5751,51 @@ var PortfolioCalculator = class extends BaseCalculator {
     const totalCollateral = 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 !== MarginMode.ISOLATED) {
+        return acc;
+      }
+      return acc.add(curr.margin ?? 0);
+    }, zero);
     const totalValue = account.totalValue({
-      totalUnsettlementPnL: unsettledPnL,
+      totalUnsettlementPnL,
       USDCHolding: USDC_holding,
-      nonUSDCHolding: nonUSDC
+      nonUSDCHolding: nonUSDC,
+      totalIsolatedPositionMargin: sumIsolatedMargin.toNumber()
     });
     const totalUnrealizedROI = account.totalUnrealizedROI({
       totalUnrealizedPnL: unrealizedPnL,
       totalValue: totalValue.toNumber()
     });
+    const maxLeverageBySymbol = positions3.rows.reduce(
+      (acc, position) => {
+        if (position.margin_mode !== MarginMode.ISOLATED && position.leverage && !acc[position.symbol]) {
+          acc[position.symbol] = position.leverage;
+        }
+        return acc;
+      },
+      {}
+    );
     const totalInitialMarginWithOrders = account.totalInitialMarginWithQty({
       positions: positions3.rows,
+      orders: [],
       markPrices,
       IMR_Factors: accountInfo.imr_factor,
-      maxLeverage: accountInfo.max_leverage,
+      maxLeverageBySymbol,
       symbolInfo: createGetter({ ...symbolsInfo })
     });
     const freeCollateral = account.freeCollateral({
       totalCollateral,
       totalInitialMarginWithOrders
     });
+    const freeCollateralUSDCOnly = account.freeCollateralUSDCOnly({
+      freeCollateral,
+      nonUSDCHolding: nonUSDC
+    });
     const availableBalance = account.availableBalance({
       USDCHolding: usdc?.holding ?? 0,
       unsettlementPnL: positions3.total_unsettled_pnl ?? 0
@@ -5633,8 +5806,10 @@ var PortfolioCalculator = class extends BaseCalculator {
       totalUnrealizedROI,
       freeCollateral,
       availableBalance,
-      unsettledPnL,
-      holding
+      unsettledPnL: totalUnsettlementPnL,
+      holding,
+      usdcHolding: USDC_holding,
+      freeCollateralUSDCOnly
     };
   }
   update(data, scope) {
@@ -5643,10 +5818,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()
       });
     }
   }
@@ -5777,7 +5954,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;
@@ -5909,15 +6086,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 = useMemo(() => {
     if (!normalOrdersResponse.data || !algoOrdersResponse.data && !sourceTypeAll) {
       return null;
@@ -6035,7 +6218,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 });
@@ -6230,7 +6415,14 @@ function formatPortfolio(inputs) {
   if (!holding || !positions3 || !Array.isArray(positions3.rows) || !markPrices || !indexPrices || !accountInfo || symbolsInfo?.isNil) {
     return null;
   }
-  const unsettledPnL = pathOr(0, ["total_unsettled_pnl"])(positions3);
+  const totallCrossUnsettledPnL = positions3.rows.reduce(
+    (sum, pos) => pos.margin_mode === MarginMode.ISOLATED ? sum : sum + (pos.unsettled_pnl ?? 0),
+    0
+  );
+  const totalUnsettlementPnL = positions3.rows.reduce(
+    (sum, pos) => sum + (pos.unsettled_pnl ?? 0),
+    0
+  );
   const unrealizedPnL = pathOr(0, ["total_unreal_pnl"])(positions3);
   const [USDC_holding, nonUSDC] = parseHolding(
     holding,
@@ -6241,29 +6433,51 @@ function formatPortfolio(inputs) {
   const totalCollateral = 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 !== MarginMode.ISOLATED) {
+      return acc;
+    }
+    return acc.add(curr.margin ?? 0);
+  }, zero);
   const totalValue = account.totalValue({
-    totalUnsettlementPnL: unsettledPnL,
+    totalUnsettlementPnL,
     USDCHolding: USDC_holding,
-    nonUSDCHolding: nonUSDC
+    nonUSDCHolding: nonUSDC,
+    totalIsolatedPositionMargin: sumIsolatedMargin.toNumber()
   });
   const totalUnrealizedROI = account.totalUnrealizedROI({
     totalUnrealizedPnL: unrealizedPnL,
     totalValue: totalValue.toNumber()
   });
+  const maxLeverageBySymbol = positions3.rows.reduce(
+    (acc, position) => {
+      if (position.margin_mode !== MarginMode.ISOLATED && position.leverage && !acc[position.symbol]) {
+        acc[position.symbol] = position.leverage;
+      }
+      return acc;
+    },
+    {}
+  );
   const totalInitialMarginWithOrders = 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 = account.freeCollateral({
     totalCollateral,
     totalInitialMarginWithOrders
   });
+  const freeCollateralUSDCOnly = account.freeCollateralUSDCOnly({
+    freeCollateral,
+    nonUSDCHolding: nonUSDC
+  });
   const availableBalance = account.availableBalance({
     USDCHolding: usdc?.holding ?? 0,
     unsettlementPnL: positions3.total_unsettled_pnl ?? 0
@@ -6274,8 +6488,9 @@ function formatPortfolio(inputs) {
     totalUnrealizedROI,
     freeCollateral,
     availableBalance,
-    unsettledPnL,
-    holding
+    unsettledPnL: totalUnsettlementPnL,
+    holding,
+    freeCollateralUSDCOnly
   };
 }
 function formatPositions(data, accountInfo, symbolsInfo, fundingRates) {
@@ -6795,7 +7010,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 });
@@ -6982,120 +7199,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
-    }
-  );
-  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];
-          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 ?? MarginMode.CROSS : marginMode ?? 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 = useMemo(() => {
     if (!symbol) return 0;
-    const positionQty = 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 = account.getQtyFromPositions(positionsArray, symbol);
     if (reduceOnly) {
-      if (positionQty > 0) {
-        if (side === OrderSide.BUY) {
-          return 0;
-        } else {
-          return Math.abs(positionQty);
-        }
-      }
-      if (positionQty < 0) {
-        if (side === OrderSide.BUY) {
-          return Math.abs(positionQty);
-        } else {
-          return 0;
-        }
-      }
-      return 0;
+      if (positionQty === 0) return 0;
+      return side === 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 === MarginMode.ISOLATED) {
+      const availableBalance = freeCollateralUSDCOnly;
+      const pendingLongOrders = buyOrdersQty > 0 ? [{ referencePrice: markPrice, quantity: buyOrdersQty }] : [];
+      const pendingSellOrders = sellOrdersQty > 0 ? [{ referencePrice: markPrice, quantity: sellOrdersQty }] : [];
+      const markPriceDecimal = new Decimal(markPrice);
+      const leverageDecimal = new 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] ?? positions.maxPositionNotional({
+        leverage,
+        IMRFactor: IMR_Factor
+      });
+      const currentOrderReferencePrice = typeof reduceOnlyOrOptions === "object" && reduceOnlyOrOptions !== null && typeof reduceOnlyOrOptions.currentOrderReferencePrice === "number" && reduceOnlyOrOptions.currentOrderReferencePrice > 0 ? reduceOnlyOrOptions.currentOrderReferencePrice : markPrice;
+      return account.maxQtyForIsolatedMargin({
+        symbol,
+        orderSide: side,
+        currentOrderReferencePrice,
+        availableBalance,
+        leverage,
+        baseIMR,
+        IMR_Factor,
+        markPrice,
+        positionQty,
+        pendingLongOrders,
+        pendingSellOrders,
+        isoOrderFrozenLong,
+        isoOrderFrozenShort,
+        symbolMaxNotional
+      });
+    }
     const otherIMs = account.otherIMs({
       positions: otherPositions,
       symbolInfo,
       markPrices,
-      IMR_Factors: accountInfo.imr_factor,
-      // Not used
-      maxLeverage: accountInfo.max_leverage
+      IMR_Factors: accountInfo.imr_factor
     });
     return 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,
@@ -7105,10 +7324,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;
@@ -8414,29 +8635,67 @@ var usePrivateDataObserver = (options) => {
   }, [state.accountId, subOrder]);
   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) {
-          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;
         }
+        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
+          }
+        );
+        mutate(
+          leveragesKey,
+          (prev) => {
+            if (!prev) {
+              return [
+                {
+                  symbol,
+                  leverage,
+                  margin_mode: marginMode
+                }
+              ];
+            }
+            const index = prev.findIndex(
+              (item) => item.symbol === symbol && (item.margin_mode ?? MarginMode.CROSS) === (marginMode ?? 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?.();
@@ -8457,7 +8716,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);
@@ -8640,14 +8899,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 === 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 || MarginMode.CROSS
       // slippage: data.slippage,
     };
     if (data.order_type === OrderType.MARKET && !!data.slippage) {
@@ -8666,10 +8981,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) {
@@ -8714,7 +9040,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) {
@@ -8863,7 +9189,11 @@ var BBOOrderCreator = class extends BaseOrderCreator {
     super(...arguments);
     this.orderType = OrderType.LIMIT;
   }
-  create(values) {
+  /**
+   * Builds the BBO order
+   * Implements template method hook
+   */
+  buildOrder(values) {
     const order = {
       ...this.baseOrder(values),
       level: values.level
@@ -8876,15 +9206,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) {
@@ -8911,6 +9244,24 @@ function getOrderPrice(order, askAndBid) {
     }
   }
 }
+order.getOrderReferencePrice;
+function getOrderReferencePriceFromOrder(order$1, askAndBid) {
+  if (!askAndBid || askAndBid.length < 2) return null;
+  if (!order$1.order_type || !order$1.side) {
+    return null;
+  }
+  return order.getOrderReferencePrice(
+    {
+      orderType: order$1.order_type,
+      orderTypeExt: order$1.order_type_ext,
+      side: order$1.side,
+      limitPrice: order$1.order_price ? Number(order$1.order_price) : void 0,
+      triggerPrice: order$1.trigger_price ? Number(order$1.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;
@@ -8924,97 +9275,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 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 === OrderType.MARKET ? config.markPrice : values.order_price ? Number(values.order_price) : void 0;
-  const tpslSide = side === OrderSide.BUY ? OrderSide.SELL : 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 === OrderType.LIMIT && !tp_order_price) {
-    result.tp_order_price = OrderValidation.required("tp_order_price");
-  }
-  if (sl_order_type === OrderType.LIMIT && !sl_order_price) {
-    result.sl_order_price = OrderValidation.required("sl_order_price");
-  }
-  if (side === 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 === OrderType.MARKET || order_type == null ? config.markPrice : order_price ? Number(order_price) : void 0;
+    const tpslSide = side === OrderSide.BUY ? OrderSide.SELL : 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 === OrderType.LIMIT && !tp_order_price) {
+      result.tp_order_price = OrderValidation.required("tp_order_price");
+    }
+    if (sl_order_type === OrderType.LIMIT && !sl_order_price) {
+      result.sl_order_price = OrderValidation.required("sl_order_price");
+    }
+    if (side === 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 === 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");
       }
     }
@@ -9022,69 +9446,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 === 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");
       }
     }
@@ -9092,37 +9543,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 } = 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 Decimal(order_price);
+    const { symbol } = config;
+    const { quote_max, quote_min, quote_dp, price_range, price_scope } = symbol;
+    const maxPriceNumber = order.maxPrice(config.markPrice, price_range);
+    const minPriceNumber = order.minPrice(config.markPrice, price_range);
+    const scopePriceNumber = order.scopePrice(
+      config.markPrice,
+      price_scope,
+      side
+    );
+    const priceRange = side === 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 Decimal(priceRange.max).todp(quote_dp).toString()
+      );
+    }
+    if (price.lt(priceRange.min)) {
+      return OrderValidation.min(
+        "order_price",
+        new 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 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 Decimal(order_quantity);
+    if (qty.lt(base_min)) {
+      return OrderValidation.min(
+        "order_quantity",
+        new Decimal(base_min).todp(base_dp).toString()
+      );
+    }
+    if (qty.gt(maxQty)) {
+      return OrderValidation.max(
+        "order_quantity",
+        new 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 = 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 pick(
@@ -9134,58 +9842,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 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 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 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;
   }
 };
 
@@ -9208,34 +9881,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 = 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;
   }
 };
 
@@ -9267,14 +9987,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);
   }
 };
@@ -9383,7 +10115,8 @@ function calcScaledOrderBatchBody(order, symbolInfo) {
       distribution_type,
       skew,
       reduce_only,
-      visible_quantity
+      visible_quantity,
+      margin_mode
     } = order;
     const prices = calcScaledOrderPrices({
       start_price,
@@ -9409,6 +10142,8 @@ function calcScaledOrderBatchBody(order, symbolInfo) {
         order_quantity: qtys[index],
         order_price: price,
         reduce_only,
+        margin_mode: margin_mode || 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}`
       };
@@ -9512,7 +10247,11 @@ var ScaledOrderCreator = class extends BaseOrderCreator {
     super(...arguments);
     this.orderType = 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 = {
@@ -9530,6 +10269,7 @@ var ScaledOrderCreator = class extends BaseOrderCreator {
         "reduce_only",
         "side",
         "order_type",
+        "margin_mode",
         "orders",
         "total_orders",
         "distribution_type",
@@ -9538,7 +10278,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;
@@ -9607,22 +10351,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 Decimal(value || 0);
-    if (price.lt(minPrice3)) {
+    if (price.lt(minPrice)) {
       errors[key] = OrderValidation.min(
         key,
-        new Decimal(minPrice3).todp(quote_dp).toString()
+        new Decimal(minPrice).todp(quote_dp).toString()
       );
-    } else if (price.gt(maxPrice3)) {
+    } else if (price.gt(maxPrice)) {
       errors[key] = OrderValidation.max(
         key,
-        new Decimal(maxPrice3).todp(quote_dp).toString()
+        new Decimal(maxPrice).todp(quote_dp).toString()
       );
     }
   };
@@ -9630,13 +10374,40 @@ function validatePrice(values, config) {
   comparePrice("end_price", end_price);
   return errors;
 }
-var { maxPrice: maxPrice2, minPrice: minPrice2, scopePrice: scopePrice2 } = 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 = 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),
@@ -9658,84 +10429,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 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 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 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: 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: AlgoOrderRootType.STOP,
       type: OrderType.MARKET,
       quantity: values["order_quantity"],
-      // price: values["order_price"],
       trigger_price_type: TriggerPriceType.MARK_PRICE
     };
     return pick(
@@ -9745,225 +10514,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 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 === OrderType.LIMIT && !tp_order_price) {
-        result.tp_order_price = OrderValidation.required("tp_order_price");
-      }
-      if (sl_order_type === OrderType.LIMIT && !sl_order_price) {
-        result.sl_order_price = OrderValidation.required("sl_order_price");
-      }
-      const mark_price = orderType === OrderType.MARKET || orderType == null ? config.markPrice : values.order_price ? Number(values.order_price) : void 0;
-      const tpslSide = side === OrderSide.BUY ? OrderSide.SELL : OrderSide.BUY;
-      if (side === 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 === 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)
+    );
   }
 };
 
@@ -10016,7 +10600,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 || MarginMode.CROSS
     };
   }
   crateUpdateOrder(values, oldValue, config) {
@@ -10118,7 +10704,9 @@ var TPSLPositionOrderCreator = class extends BaseAlgoOrderCreator {
       trigger_price_type: 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 || MarginMode.CROSS
     };
   }
   crateUpdateOrder(values, oldValue, config) {
@@ -10155,7 +10743,11 @@ var TrailingStopOrderCreator = class extends BaseOrderCreator {
     super(...arguments);
     this.orderType = 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),
@@ -10176,6 +10768,7 @@ var TrailingStopOrderCreator = class extends BaseOrderCreator {
         "quantity",
         "side",
         "reduce_only",
+        "margin_mode",
         "visible_quantity",
         "activated_price",
         "callback_value",
@@ -10184,28 +10777,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 Decimal(activated_price);
-      if (activatedPrice.lt(minPrice3) || activatedPrice.equals(0)) {
-        errors.activated_price = OrderValidation.min(
-          "activated_price",
-          new Decimal(minPrice3).todp(quote_dp).toString()
-        );
-      } else if (activatedPrice.gt(maxPrice3)) {
-        errors.activated_price = OrderValidation.max(
-          "activated_price",
-          new Decimal(maxPrice3).todp(quote_dp).toString()
-        );
+      if (!isNaN(minPrice) && !isNaN(maxPrice)) {
+        const activatedPrice = new Decimal(activated_price);
+        if (activatedPrice.lt(minPrice) || activatedPrice.equals(0)) {
+          errors.activated_price = OrderValidation.min(
+            "activated_price",
+            new Decimal(minPrice).todp(quote_dp).toString()
+          );
+        } else if (activatedPrice.gt(maxPrice)) {
+          errors.activated_price = OrderValidation.max(
+            "activated_price",
+            new Decimal(maxPrice).todp(quote_dp).toString()
+          );
+        }
       }
     }
     if (!callback_value && !callback_rate) {
@@ -10237,23 +10836,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 === 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 {
@@ -10376,27 +10958,63 @@ var calcEstLiqPrice = (order$1, askAndBid, inputs) => {
     markPrice,
     totalCollateral,
     futures_taker_fee_rate,
-    positions: positions3
+    positions: positions3,
+    symbolLeverage,
+    sumUnitaryFunding
   } = inputs;
   const orderFee = order.orderFee({
     qty: quantity,
     price,
     futuresTakeFeeRate: Number(futures_taker_fee_rate) / 1e4
   });
-  const liqPrice = 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$1.margin_mode === MarginMode.CROSS) {
+    liqPrice = 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 === 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 = 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;
 };
@@ -10454,7 +11072,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 ?? MarginMode.CROSS
   });
   const symbolInfo = useSymbolsInfo()[position.symbol]();
   const { data: markPrice } = useMarkPrice(order.symbol);
@@ -10757,11 +11377,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 = 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];
+      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 ?? MarginMode.CROSS) === (data.margin_mode ?? 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,
@@ -11498,8 +12160,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) {
@@ -11512,7 +12174,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 ?? MarginMode.CROSS
+  });
   const parseString2Number = (order, key, dp) => {
     if (typeof order[key] !== "string") return;
     if (order[key] && order[key].startsWith(".")) {
@@ -12063,7 +12730,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, {
@@ -12094,6 +12761,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) {
@@ -12174,8 +12863,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),
@@ -17717,95 +18406,111 @@ var initialOrderState = {
   trigger_price: "",
   tp_trigger_price: "",
   sl_trigger_price: "",
-  tp_order_type: OrderType.MARKET,
-  tp_pnl: "",
-  sl_pnl: "",
-  tp_offset_percentage: "",
-  sl_offset_percentage: "",
-  tp_offset: "",
-  sl_offset: "",
-  sl_order_type: 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] = useState(initialOrder);
-  const [estLeverage, setEstLeverage] = useState(null);
-  const [estLiquidationPrice, setEstLiquidationPrice] = useState(
-    null
-  );
-  const [errors, setErrors] = useState({});
-  const updateOrder = (order) => {
-    setEntry(
-      // if use {...draft, ...order} will cause extra updated when object it not changed
-      produce((draft) => {
-        Object.assign(draft, order);
-      })
-      // (prev) => ({ ...prev, ...order })
-    );
-  };
-  const updateOrderByKey = (key, value) => {
-    setEntry(
-      produce((draft) => {
-        draft[key] = value;
-      })
-    );
-  };
-  const restoreOrder = (order) => {
-    setEntry(produce((draft) => order));
-  };
-  const updateOrderComputed = (data) => {
-    setEstLeverage(data.estLeverage);
-    setEstLiquidationPrice(data.estLiquidationPrice);
-  };
-  const resetOrder = (order) => {
-    setEntry(
-      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 = create()(
+  immer((set, get3) => ({
+    entry: {
+      side: OrderSide.BUY,
+      order_type: 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 ?? OrderSide.BUY,
+            order_type: options?.order_type ?? OrderType.LIMIT,
+            margin_mode: options?.margin_mode ?? 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: OrderSide.BUY,
-    order_type: 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);
+  useEffect(() => {
+    orderEntryActions.initOrder(symbol, options.initialOrder);
+    if (options.initialOrder) {
+      orderEntryActions.updateOrder(options.initialOrder);
+    }
+  }, [symbol]);
   const calculate2 = useCallback(
     (values, fieldName, value, markPrice, config) => {
       const fieldHandler = getCalculateHandler(fieldName);
@@ -17819,17 +18524,15 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
     },
     []
   );
-  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,
@@ -17910,7 +18613,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,
@@ -17926,10 +18630,11 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
   const onMarkPriceUpdated = 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,
@@ -17940,7 +18645,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
           newValues = calculate2(
             { ...newValues },
             key,
-            orderEntity[key],
+            currentEntry[key],
             markPrice,
             options.symbolInfo
           );
@@ -17961,7 +18666,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, {
@@ -18010,6 +18715,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
   const lastChangedField = useRef();
   const lastOrderTypeExt = useRef();
   const lastLevel = useRef();
+  const fundingRates = useFundingRatesStore();
   const calculateTPSL_baseOn = useRef({
     tp: "",
     sl: ""
@@ -18018,7 +18724,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 ?? MarginMode.CROSS;
+  const symbolLeverage = useLeverageBySymbol(symbol, effectiveMarginMode);
   const symbolInfo = symbolConfig[symbol]();
   const markPrice = actions.getMarkPriceBySymbol(symbol);
   const { orderMetadata } = useOrderlyContext();
@@ -18040,11 +18748,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;
@@ -18134,6 +18844,9 @@ var useOrderEntry2 = (symbol, options = {}) => {
     };
   }, []);
   useEffect(() => {
+    if (formattedOrder.symbol !== symbol) {
+      return;
+    }
     if ((formattedOrder.order_type === OrderType.MARKET || formattedOrder.order_type === OrderType.STOP_MARKET) && markPrice) {
       const baseOn = /* @__PURE__ */ new Set();
       if (lastChangedField.current) {
@@ -18147,7 +18860,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
       }
       orderEntryActions.onMarkPriceChange(markPrice, Array.from(baseOn));
     }
-  }, [markPrice, formattedOrder.order_type]);
+  }, [markPrice, formattedOrder.order_type, formattedOrder.symbol, symbol]);
   const prepareData = useCallback(() => {
     return {
       markPrice: actions.getMarkPriceBySymbol(symbol),
@@ -18256,7 +18969,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
       }
     );
   };
-  const { freeCollateral, totalCollateral } = useCollateral();
+  const { freeCollateral, freeCollateralUSDCOnly, totalCollateral } = useCollateral();
   const currentPosition = useMemo(() => {
     const rows = positions3 ?? [];
     const p = Array.isArray(rows) ? rows.find(
@@ -18269,6 +18982,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,
@@ -18276,7 +18990,9 @@ var useOrderEntry2 = (symbol, options = {}) => {
       imr_factor: accountInfo.imr_factor[symbol],
       symbol,
       positions: positions3,
-      symbolInfo
+      symbolInfo,
+      sumUnitaryFunding,
+      symbolLeverage
     });
     return estLiqPrice2;
   }, [
@@ -18286,7 +19002,9 @@ var useOrderEntry2 = (symbol, options = {}) => {
     totalCollateral,
     symbol,
     maxQty,
-    symbolInfo
+    symbolInfo,
+    fundingRates,
+    symbolLeverage
   ]);
   const estLiqPriceDistance = useMemo(() => {
     if (!estLiqPrice) {
@@ -18421,7 +19139,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
       validator: validateOrder,
       validate: validateOrder
     },
-    freeCollateral,
+    freeCollateral: effectiveMarginMode === MarginMode.ISOLATED ? freeCollateralUSDCOnly : freeCollateral,
     setValue: useMemoizedFn(setValue),
     setValues: useMemoizedFn(setValues),
     symbolInfo: symbolInfo || EMPTY_OBJECT,
@@ -18431,93 +19149,6 @@ var useOrderEntry2 = (symbol, options = {}) => {
     symbolLeverage
   };
 };
-var initialOrderState2 = {
-  order_price: "",
-  order_quantity: "",
-  trigger_price: "",
-  tp_trigger_price: "",
-  sl_trigger_price: "",
-  total: "",
-  symbol: ""
-};
-var useOrderStore2 = create()(
-  immer((set, get3) => ({
-    entry: {
-      side: OrderSide.BUY,
-      order_type: 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 || {};
@@ -18675,13 +19306,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 || MarginMode.CROSS
     };
     if (type === OrderType.LIMIT) {
       data.order_price = price;
     }
     return data;
-  }, [symbol, price, type, quantity]);
+  }, [symbol, price, type, quantity, position.margin_mode]);
   const maxQty = useMemo(() => {
     if (!position) {
       return 0;
@@ -18883,9 +19516,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 useMemo(() => {
     return position?.est_liq_price ?? void 0;
   }, [position]);
@@ -18906,7 +19541,63 @@ var useGetEstLiqPrice = (props) => {
     return estLiqPrice;
   }, [estLiqPrice, markPrice, side]);
 };
+var useFeatureFlag = (key) => {
+  const { data: publicFlags, isLoading: publicLoading } = useQuery("/v1/public/feature_flags", {});
+  const publicFlag = useMemo(() => {
+    if (!publicFlags || publicLoading) {
+      return void 0;
+    }
+    return publicFlags.find((flag) => flag.key === key);
+  }, [publicFlags, publicLoading, key]);
+  const shouldQueryPrivate = useMemo(() => {
+    return publicFlag !== void 0;
+  }, [publicFlag]);
+  const { data: privateFlags, isLoading: privateLoading } = usePrivateQuery(shouldQueryPrivate ? "/v1/feature_flags" : null, {});
+  const privateFlag = useMemo(() => {
+    if (!shouldQueryPrivate || !privateFlags || privateLoading) {
+      return void 0;
+    }
+    return privateFlags.find((flag) => flag.key === key);
+  }, [shouldQueryPrivate, privateFlags, privateLoading, key]);
+  return 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 || {});
 
-export { DefaultLayoutConfig, DistributionId, ENVType2 as ENVType, ERROR_MSG_CODES, EpochStatus, ExtendedConfigStore, MaintenanceStatus, MarketsStorageKey, MarketsType, ORDERLY_ORDERBOOK_DEPTH_KEY, OrderlyConfigProvider, OrderlyContext, OrderlyProvider, StatusProvider, TWType, WalletConnectorContext, WsNetworkStatus, checkNotional, cleanStringStyle, fetcher, findPositionTPSLFromOrders, findTPSLFromOrder, findTPSLOrderPriceFromOrder, getMinNotional, getPriceKey, indexedDBManager, initializeAppDatabase, isCurrentlyClosed, isCurrentlyTrading, noCacheConfig, parseJSON, persistIndexedDB, resetTimestampOffsetState, timestampWaitingMiddleware, useAccount, useAccountInfo2 as useAccountInfo, useAccountInstance, useAccountRewardsHistory, useAllBrokers, useApiKeyManager, useAppStore, useAssetsHistory, useAudioPlayer, useBalanceSubscription, useBalanceTopic, useBoolean, useChain, useChainInfo, useChains, useCheckReferralCode, useCollateral, useCommission, useComputedLTV, useConfig, useConvert, useCurEpochEstimate, useDaily, useDeposit, useDistribution, useDistributionHistory, useEpochInfo, useEstLiqPriceBySymbol, useEventEmitter, useFeeState, useFundingDetails, useFundingFeeHistory, useFundingRate, useFundingRateBySymbol, useFundingRateHistory, useFundingRates, useFundingRatesStore, useGetClaimed, useGetEnv, useGetEstLiqPrice, useGetReferralCode, useGetRwaSymbolCloseTimeInterval, useGetRwaSymbolInfo, useGetRwaSymbolOpenStatus, useGetRwaSymbolOpenTimeInterval, useHoldingStream, useIndexPrice, useIndexPricesStream, useInfiniteQuery, useInitRwaSymbolsRuntime, useInternalTransfer, useKeyStore, useLazyQuery, useLeverage, useLeverageBySymbol, useLocalStorage, useMainTokenStore, useMainnetChainsStore, useMaintenanceStatus, useMarginRatio, useMarkPrice, useMarkPriceBySymbol, useMarkPricesStream, useMarket, useMarketList, useMarketMap, useMarketTradeStream, useMarkets, useMarketsStore, useMarketsStream, useMaxLeverage, useMaxQty, useMaxWithdrawal, useMediaQuery, useMemoizedFn, useMutation, useNetworkInfo, useOdosQuote, useOrderEntity, useOrderEntry2 as useOrderEntry, useOrderEntry as useOrderEntry_deprecated, useOrderStore2 as useOrderStore, useOrderStream, useOrderbookStream, useOrderlyContext, usePortfolio, usePositionActions, usePositionClose, usePositionStream, usePoster, usePreLoadData, usePrivateDataObserver, usePrivateInfiniteQuery, usePrivateQuery, useQuery, useRefereeHistory, useRefereeInfo, useRefereeRebateSummary, useReferralInfo, useReferralRebateSummary, useRestrictedInfo, useRwaSymbolsInfo, useRwaSymbolsInfoStore, useSessionStorage, useSettleSubscription, useSimpleDI, useStatisticsDaily, useStorageChain, useStorageLedgerAddress, useSubAccountAlgoOrderStream, useSubAccountDataObserver, useSubAccountMaxWithdrawal, useSubAccountMutation, useSubAccountQuery, useSubAccountWS, useSwapSupportStore, useSymbolInfo, useSymbolLeverage, useSymbolPriceRange, useSymbolsInfo, useSymbolsInfoStore, useTPSLOrder, useTestTokenStore, useTestnetChainsStore, useTickerStream, useTokenInfo, useTokensInfo, useTpslPriceChecker, useTrack, useTrackingInstance, useTradingRewardsStatus, useTransfer, useTransferHistory, useUpdatedRef, useUserStatistics, useVaultsHistory, useWS, useWalletConnector, useWalletRewardsHistory, useWalletSubscription, useWalletTopic, useWithdraw, useWsStatus, utils_exports as utils, version_default as version };
+export { DefaultLayoutConfig, DistributionId, ENVType2 as ENVType, ERROR_MSG_CODES, EpochStatus, ExtendedConfigStore, FlagKeys, MaintenanceStatus, MarketsStorageKey, MarketsType, ORDERLY_ORDERBOOK_DEPTH_KEY, OrderlyConfigProvider, OrderlyContext, OrderlyProvider, StatusProvider, TWType, WalletConnectorContext, WsNetworkStatus, checkNotional, cleanStringStyle, fetcher, findPositionTPSLFromOrders, findTPSLFromOrder, findTPSLOrderPriceFromOrder, getMinNotional, getPriceKey, indexedDBManager, initializeAppDatabase, isCurrentlyClosed, isCurrentlyTrading, noCacheConfig, parseJSON, persistIndexedDB, resetTimestampOffsetState, timestampWaitingMiddleware, useAccount, useAccountInfo2 as useAccountInfo, useAccountInstance, useAccountRewardsHistory, useAllBrokers, useApiKeyManager, useAppStore, useAssetsHistory, useAudioPlayer, useBalanceSubscription, useBalanceTopic, useBoolean, useChain, useChainInfo, useChains, useCheckReferralCode, useCollateral, useCommission, useComputedLTV, useConfig, useConvert, useCurEpochEstimate, useDaily, useDeposit, useDistribution, useDistributionHistory, useEpochInfo, useEstLiqPriceBySymbol, useEventEmitter, useFeatureFlag, useFeeState, useFundingDetails, useFundingFeeHistory, useFundingRate, useFundingRateBySymbol, useFundingRateHistory, useFundingRates, useFundingRatesStore, useGetClaimed, useGetEnv, useGetEstLiqPrice, useGetReferralCode, useGetRwaSymbolCloseTimeInterval, useGetRwaSymbolInfo, useGetRwaSymbolOpenStatus, useGetRwaSymbolOpenTimeInterval, useHoldingStream, useIndexPrice, useIndexPricesStream, useInfiniteQuery, useInitRwaSymbolsRuntime, useInternalTransfer, useKeyStore, useLazyQuery, useLeverage, useLeverageBySymbol, useLocalStorage, useMainTokenStore, useMainnetChainsStore, useMaintenanceStatus, useMarginModeBySymbol, useMarginModes, useMarginRatio, useMarkPrice, useMarkPriceBySymbol, useMarkPricesStream, useMarket, useMarketList, useMarketMap, useMarketTradeStream, useMarkets, useMarketsStore, useMarketsStream, useMaxLeverage, useMaxQty, useMaxWithdrawal, useMediaQuery, useMemoizedFn, useMutation, useNetworkInfo, useOdosQuote, useOrderEntity, useOrderEntry2 as useOrderEntry, useOrderEntry as useOrderEntry_deprecated, useOrderStore, useOrderStream, useOrderbookStream, useOrderlyContext, usePortfolio, usePositionActions, usePositionClose, usePositionStream, usePositions, usePoster, usePreLoadData, usePrivateDataObserver, usePrivateInfiniteQuery, usePrivateQuery, useQuery, useRefereeHistory, useRefereeInfo, useRefereeRebateSummary, useReferralInfo, useReferralRebateSummary, useRestrictedInfo, useRwaSymbolsInfo, useRwaSymbolsInfoStore, useSessionStorage, useSettleSubscription, useSimpleDI, useStatisticsDaily, useStorageChain, useStorageLedgerAddress, useSubAccountAlgoOrderStream, useSubAccountDataObserver, useSubAccountMaxWithdrawal, useSubAccountMutation, useSubAccountQuery, useSubAccountWS, useSwapSupportStore, useSymbolInfo, useSymbolLeverage, useSymbolLeverageMap, useSymbolPriceRange, useSymbolsInfo, useSymbolsInfoStore, useTPSLOrder, useTestTokenStore, useTestnetChainsStore, useTickerStream, useTokenInfo, useTokensInfo, useTpslPriceChecker, useTrack, useTrackingInstance, useTradingRewardsStatus, useTransfer, useTransferHistory, useUpdatedRef, useUserStatistics, useVaultsHistory, useWS, useWalletConnector, useWalletRewardsHistory, useWalletSubscription, useWalletTopic, useWithdraw, useWsStatus, utils_exports as utils, version_default as version };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map