@orderly.network/hooks 2.8.0 → 2.8.1

package/dist/index.js

@@ -61,9 +61,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.8.0";
+  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.8.1";
 }
-var version_default = "2.8.0";
+var version_default = "2.8.1";
 var fetcher = (url, init2 = {}, queryOptions) => net.get(url, init2, queryOptions?.formatter);
 var noCacheConfig = {
   dedupingInterval: 0,
@@ -1249,7 +1249,7 @@ function checkTPSLOrderTypeIsMarket(key, values) {
 }
 function tpslCalculateHelper(key, inputs, options = {}) {
   const { symbol } = options;
-  if (key !== "quantity" && key !== "tp_trigger_price" && key !== "sl_trigger_price" && key !== "tp_pnl" && key !== "sl_pnl" && key !== "tp_offset" && key !== "sl_offset" && key !== "tp_offset_percentage" && key !== "sl_offset_percentage" && key !== "tp_order_price" && key !== "sl_order_price" && key !== "tp_order_type" && key !== "sl_order_type" && key !== "tp_enable" && key !== "sl_enable") {
+  if (key !== "quantity" && key !== "tp_trigger_price" && key !== "sl_trigger_price" && key !== "tp_pnl" && key !== "sl_pnl" && key !== "tp_offset" && key !== "sl_offset" && key !== "tp_offset_percentage" && key !== "sl_offset_percentage" && key !== "tp_order_price" && key !== "sl_order_price" && key !== "tp_order_type" && key !== "sl_order_type") {
     return {
       [key]: inputs.value
     };
@@ -1288,19 +1288,6 @@ function tpslCalculateHelper(key, inputs, options = {}) {
       }
       break;
     }
-    case "tp_enable":
-    case "sl_enable": {
-      return {
-        [`${keyPrefix}enable`]: inputs.value,
-        [`${keyPrefix}order_type`]: types.OrderType.MARKET,
-        [`${keyPrefix}trigger_price`]: "",
-        [`${keyPrefix}order_price`]: "",
-        [`${keyPrefix}offset`]: "",
-        [`${keyPrefix}offset_percentage`]: "",
-        [`${keyPrefix}pnl`]: "",
-        [`${keyPrefix}ROI`]: ""
-      };
-    }
     case "tp_pnl":
     case "sl_pnl": {
       pnl = inputs.value;
@@ -1649,7 +1636,6 @@ var getCalculateHandler = (fieldName) => {
     case "total": {
       return totalInputHandle;
     }
-    case "tp_enable":
     case "tp_pnl":
     case "sl_pnl":
     case "tp_trigger_price":
@@ -1660,7 +1646,6 @@ var getCalculateHandler = (fieldName) => {
     case "sl_offset_percentage":
     case "tp_order_price":
     case "tp_order_type":
-    case "sl_enable":
     case "sl_order_type":
     case "sl_order_price":
       return tpslInputHandle;
@@ -2760,6 +2745,7 @@ var useAppStore = zustand.create()(
 );
 var useAccountInfo2 = () => useAppStore((state) => state.accountInfo);
 var usePortfolio = () => useAppStore((state) => state.portfolio);
+var useFundingRateBySymbol = (symbol) => useAppStore((state) => state.fundingRates?.[symbol]);
 
 // src/orderly/useRwaSymbolsInfo.ts
 var isCurrentlyTrading = (nextClose, status, currentTime = Date.now()) => {
@@ -2781,10 +2767,16 @@ var computeSymbolState = (rwaSymbol, currentTime) => {
   let closeTimeInterval;
   let openTimeInterval;
   if (next_close && typeof next_close === "number" && next_close > currentTime) {
-    closeTimeInterval = Math.max(0, Math.floor((next_close - currentTime) / 1e3));
+    closeTimeInterval = Math.max(
+      0,
+      Math.floor((next_close - currentTime) / 1e3)
+    );
   }
   if (next_open && typeof next_open === "number" && next_open > currentTime) {
-    openTimeInterval = Math.max(0, Math.floor((next_open - currentTime) / 1e3));
+    openTimeInterval = Math.max(
+      0,
+      Math.floor((next_open - currentTime) / 1e3)
+    );
   }
   return {
     isRwa: true,
@@ -2795,46 +2787,48 @@ var computeSymbolState = (rwaSymbol, currentTime) => {
     openTimeInterval
   };
 };
-var useRwaSymbolsRuntimeStore = zustand.create((set, get3) => ({
-  computedStates: {},
-  currentTime: Date.now(),
-  timerId: void 0,
-  startTimer: () => {
-    const state = get3();
-    if (state.timerId) {
-      clearInterval(state.timerId);
-    }
-    const timerId = setInterval(() => {
-      const currentTime = Date.now();
-      const rwaSymbolsInfo = useAppStore.getState().rwaSymbolsInfo;
-      if (!rwaSymbolsInfo) {
-        set({ currentTime });
-        return;
+var useRwaSymbolsRuntimeStore = zustand.create(
+  (set, get3) => ({
+    computedStates: {},
+    currentTime: Date.now(),
+    timerId: void 0,
+    startTimer: () => {
+      const state = get3();
+      if (state.timerId) {
+        clearInterval(state.timerId);
+      }
+      const timerId = setInterval(() => {
+        const currentTime = Date.now();
+        const rwaSymbolsInfo = useAppStore.getState().rwaSymbolsInfo;
+        if (!rwaSymbolsInfo) {
+          set({ currentTime });
+          return;
+        }
+        const computedStates = {};
+        Object.entries(rwaSymbolsInfo).forEach(([symbol, rwaSymbol]) => {
+          computedStates[symbol] = computeSymbolState(rwaSymbol, currentTime);
+        });
+        set({ computedStates, currentTime });
+      }, 1e3);
+      set({ timerId });
+    },
+    stopTimer: () => {
+      const state = get3();
+      if (state.timerId) {
+        clearInterval(state.timerId);
+        set({ timerId: void 0 });
       }
+    },
+    updateComputedStates: (rwaSymbolsInfo) => {
+      const currentTime = get3().currentTime;
       const computedStates = {};
       Object.entries(rwaSymbolsInfo).forEach(([symbol, rwaSymbol]) => {
         computedStates[symbol] = computeSymbolState(rwaSymbol, currentTime);
       });
-      set({ computedStates, currentTime });
-    }, 1e3);
-    set({ timerId });
-  },
-  stopTimer: () => {
-    const state = get3();
-    if (state.timerId) {
-      clearInterval(state.timerId);
-      set({ timerId: void 0 });
+      set({ computedStates });
     }
-  },
-  updateComputedStates: (rwaSymbolsInfo) => {
-    const currentTime = get3().currentTime;
-    const computedStates = {};
-    Object.entries(rwaSymbolsInfo).forEach(([symbol, rwaSymbol]) => {
-      computedStates[symbol] = computeSymbolState(rwaSymbol, currentTime);
-    });
-    set({ computedStates });
-  }
-}));
+  })
+);
 var useInitRwaSymbolsRuntime = () => {
   const rwaSymbolsInfo = useRwaSymbolsInfoStore();
   const { startTimer, stopTimer, updateComputedStates } = useRwaSymbolsRuntimeStore();
@@ -3310,1914 +3304,1918 @@ var useWSObserver = (calculatorService) => {
     };
   }, []);
 };
-var useApiStatusStore = zustand.create()(
-  immer.immer((set) => ({
-    apis: {
-      positions: {
-        loading: false
-      }
-    },
-    actions: {
-      updateStatus: (key, status) => {
-        set((state) => {
-          state.apis[key] = status;
-        });
-      },
-      updateApiLoading: (key, loading) => {
-        set((state) => {
-          state.apis[key].loading = loading;
-        });
-      },
-      updateApiError: (key, error) => {
-        set((state) => {
-          state.apis[key] = {
-            loading: false,
-            error
-          };
-        });
-      }
-    }
-  }))
-);
-var useApiStatusActions = () => useApiStatusStore((state) => state.actions);
-var useTokensInfoStore = zustand.create(
-  (set) => ({
-    tokensInfo: [],
-    setTokensInfo(data) {
-      set({ tokensInfo: data });
-    }
-  })
-);
-var useTokensInfo = () => {
-  const tokensInfo = useTokensInfoStore((state) => state.tokensInfo);
-  return tokensInfo;
-};
-var useTokenInfo = (token) => {
-  const tokensInfo = useTokensInfo();
-  return React2.useMemo(() => {
-    return tokensInfo?.find((item) => item.token === token);
-  }, [tokensInfo, token]);
-};
 
-// src/orderly/calculator/baseCalculator.ts
-var BaseCalculator = class {
-  cache(data) {
-    this._cache = data;
-  }
+// src/orderly/orderbook.service.ts
+var defaultRawOrderBook = {
+  asks: [],
+  bids: [],
+  ts: 0
 };
-var useMarkPriceStore = zustand.create((set, get3) => ({
-  markPrices: {},
-  // orderBook: {},
-  // ask_bid: [],
-  actions: {
-    updateMarkPrice: (markPrice) => {
-      set({
-        markPrices: markPrice
-      });
-    },
-    getMarkPriceBySymbol: (symbol) => {
-      return get3().markPrices[symbol];
-    }
-  }
-}));
-var useMarkPriceBySymbol = (symbol) => useMarkPriceStore((state) => state.actions.getMarkPriceBySymbol(symbol));
-var useMarkPriceActions = () => useMarkPriceStore((state) => state.actions);
-
-// src/orderly/calculator/markPrice.ts
-var MarketCalculatorName = "markPriceCalculator";
-var MarkPriceCalculator = class extends BaseCalculator {
+var OrderbookService = class _OrderbookService {
   constructor() {
-    super(...arguments);
-    this.name = MarketCalculatorName;
-  }
-  calc(scope, data, ctx) {
-    return data;
+    this.bufferedOrderBookUpdates = {};
+    this.rawOrderBook = {};
   }
-  update(data, scope) {
-    useMarkPriceStore.getState().actions.updateMarkPrice(data);
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new _OrderbookService();
+    }
+    return this.instance;
   }
-};
-
-// src/orderly/calculator/calculatorContext.ts
-var CalculatorContext = class _CalculatorContext {
-  static get instance() {
-    return this._instance;
+  sortBufferedOrderBookUpdates(symbol) {
+    this.bufferedOrderBookUpdates[symbol]?.sort((a, b) => a.ts - b.ts);
   }
-  static create(scope, data) {
-    if (!this._instance) {
-      this._instance = new _CalculatorContext(scope, data);
+  applyUpdateToRawOrderBook(symbol, update) {
+    const rawOrderBook = this.rawOrderBook[symbol];
+    if (!rawOrderBook || rawOrderBook.ts > update.prevTs) {
+      return;
     }
-    return this._instance.update(scope, data);
-  }
-  constructor(scope, data) {
-    this.setCtxData();
-    this.output = {
-      // rows: positions,
-    };
+    const askMap = /* @__PURE__ */ new Map();
+    const bidMap = /* @__PURE__ */ new Map();
+    rawOrderBook.asks.forEach((ask) => {
+      askMap.set(ask[0], ask[1]);
+    });
+    rawOrderBook.bids.forEach((bid) => {
+      bidMap.set(bid[0], bid[1]);
+    });
+    update.asks.forEach(
+      (ask) => ask[1] === 0 ? askMap.delete(ask[0]) : askMap.set(ask[0], ask[1])
+    );
+    update.bids.forEach(
+      (bid) => bid[1] === 0 ? bidMap.delete(bid[0]) : bidMap.set(bid[0], bid[1])
+    );
+    rawOrderBook.asks = Array.from(askMap.entries()).sort(
+      (a, b) => a[0] - b[0]
+    );
+    rawOrderBook.bids = Array.from(bidMap.entries()).sort(
+      (a, b) => b[0] - a[0]
+    );
+    rawOrderBook.ts = update.ts;
   }
-  update(scope, data) {
-    this.setCtxData();
-    this.markPrices = scope === "markPrice" /* MARK_PRICE */ ? data : this.output[MarketCalculatorName];
-    this.portfolio = this.output["portfolio"] || useAppStore.getState().portfolio;
-    return this;
+  applyBufferedUpdatesToRawOrderBooks(symbol) {
+    this.bufferedOrderBookUpdates[symbol]?.forEach((update) => {
+      this.applyUpdateToRawOrderBook(symbol, update);
+    });
   }
-  setCtxData() {
-    this.accountInfo = useAppStore.getState().accountInfo;
-    this.symbolsInfo = useAppStore.getState().symbolsInfo;
-    this.fundingRates = useAppStore.getState().fundingRates;
-    this.tokensInfo = useTokensInfoStore.getState().tokensInfo;
+  deleteBufferedOrderBookUpdates(symbol) {
+    delete this.bufferedOrderBookUpdates[symbol];
   }
-  get(fn) {
-    return fn(this.output);
+  commitOrderBook(symbol) {
+    const rawOrderBook = this.rawOrderBook[symbol];
+    if (!rawOrderBook) {
+      return;
+    }
   }
-  getCacheValue(name, fallback) {
-    return this.output[name] || fallback();
+  pushUpdateToBuffer(symbol, update) {
+    if (this.bufferedOrderBookUpdates[symbol] === void 0) {
+      this.bufferedOrderBookUpdates[symbol] = [];
+    }
+    const buffer = this.bufferedOrderBookUpdates[symbol];
+    if (buffer.length > 0) {
+      const lastUpdate = buffer[buffer.length - 1];
+      if (lastUpdate.ts !== update.prevTs) {
+        this.bufferedOrderBookUpdates[symbol] = [];
+      }
+    }
+    this.bufferedOrderBookUpdates[symbol].push(update);
   }
-  clearCache() {
-    this.output = {};
-    this.accountInfo = void 0;
-    this.portfolio = void 0;
+  isValidFullOrderBook(symbol, currentTs) {
+    if ((this.bufferedOrderBookUpdates[symbol]?.length ?? 0) !== 0) {
+      const earliestUpdates = this.bufferedOrderBookUpdates[symbol][0];
+      return earliestUpdates.prevTs <= currentTs;
+    }
+    return true;
   }
-  deleteByName(name) {
-    delete this.output[name];
+  setFullOrderbook(symbol, rawOrderbook) {
+    const { ts } = rawOrderbook;
+    this.rawOrderBook[symbol] = rawOrderbook;
+    this.sortBufferedOrderBookUpdates(symbol);
+    if (this.isValidFullOrderBook(symbol, ts)) {
+      this.applyBufferedUpdatesToRawOrderBooks(symbol);
+    }
   }
-  // get positions(): API.PositionTPSLExt[] {
-  //   if (this.output.positionCalculator) return this.output.positionCalculator;
-  //   return usePositionStore.getState().positions;
-  // }
-  get isReady() {
-    return !!this.accountInfo;
+  updateOrderbook(symbol, update, callback) {
+    const { asks, bids, prevTs, ts } = update;
+    const rawOrderBook = this.rawOrderBook[symbol];
+    if (!rawOrderBook) {
+      return;
+    }
+    const currentTs = rawOrderBook.ts;
+    if (currentTs === 0) {
+      this.pushUpdateToBuffer(symbol, { asks, bids, prevTs, ts });
+      return;
+    }
+    if (prevTs !== currentTs) {
+      this.pushUpdateToBuffer(symbol, { asks, bids, prevTs, ts });
+      if (callback) {
+        callback();
+      }
+      return;
+    }
+    this.applyUpdateToRawOrderBook(symbol, update);
+    this.deleteBufferedOrderBookUpdates(symbol);
   }
-  saveOutput(name, data) {
-    this.output[name] = data;
+  getRawOrderbook(symbol) {
+    return this.rawOrderBook[symbol];
   }
-  outputToValue() {
-    return this.output;
+  resetOrderBook(symbol) {
+    this.rawOrderBook[symbol] = defaultRawOrderBook;
   }
 };
-
-// src/orderly/calculator/calculatorService.ts
-var CalculatorService = class {
-  constructor(scheduler, calculators) {
-    this.scheduler = scheduler;
-    this.pendingCalc = [];
-    this.calcQueue = [];
-    /**
-     * Reference count for each calculator, used to determine if a calculator is still in use.
-     */
-    this.referenceCount = /* @__PURE__ */ new Map();
-    this.isPaused = false;
-    this.calculators = new Map(calculators);
-  }
-  register(scope, calculator) {
-    const ref_count_name = `${scope}_${calculator.name}`;
-    const count = this.referenceCount.get(ref_count_name);
-    if (typeof count !== "undefined" && count > 0) {
-      this.referenceCount.set(ref_count_name, count + 1);
-      return;
+var orderBookService = OrderbookService.getInstance();
+var orderbook_service_default = orderBookService;
+var useMarkPrice = (symbol) => {
+  const ws = useWS();
+  const [price, setPrice] = React2.useState(0);
+  React2.useEffect(() => {
+    const unsubscribe = ws.subscribe(`${symbol}@markprice`, {
+      onMessage: (message) => {
+        setPrice(message.price);
+      }
+    });
+    return () => {
+      unsubscribe?.();
+    };
+  }, [symbol]);
+  return { data: price };
+};
+var useIndexPrice = (symbol) => {
+  symbol = symbol.replace("PERP", "SPOT");
+  const ws = useWS();
+  return useSWRSubscription__default.default(`${symbol}@indexprice`, (key, { next }) => {
+    const unsubscribe = ws.subscribe(`${symbol}@indexprice`, {
+      onMessage: (message) => {
+        next(null, message.price);
+      }
+    });
+    return () => {
+      unsubscribe?.();
+    };
+  });
+};
+var useOpenInterest = (symbol) => {
+  const ws = useWS();
+  return useSWRSubscription__default.default(`${symbol}@openinterest`, (key, { next }) => {
+    const unsubscribe = ws.subscribe(`${symbol}@openinterest`, {
+      onMessage: (message) => {
+        next(null, message.openInterest);
+      }
+    });
+    return () => {
+      unsubscribe?.();
+    };
+  });
+};
+var useFutures = () => {
+  const { data, isLoading, error } = useQuery(
+    `/v1/public/futures`,
+    {
+      revalidateOnFocus: false
     }
-    const calculators = this.calculators.get(scope);
-    if (Array.isArray(calculators)) {
-      calculators.push(calculator);
-    } else {
-      this.calculators.set(scope, [calculator]);
+  );
+  const [sortedData, setSortedData] = React2.useState(data);
+  useWS();
+  React2.useEffect(() => {
+  }, []);
+  React2.useEffect(() => {
+    if (data) {
+      const sortedData2 = data.sort((a, b) => {
+        return 0;
+      });
+      setSortedData(sortedData2);
     }
-    this.referenceCount.set(ref_count_name, 1);
+  }, [data]);
+  const sortBy = React2.useCallback((key) => {
+  }, [data]);
+  const filterBy = React2.useCallback((key) => {
+  }, [data]);
+  return {
+    data: sortedData,
+    sortBy,
+    filterBy,
+    isLoading,
+    error
+  };
+};
+
+// src/orderly/useTickerStream.ts
+var useTickerStream = (symbol) => {
+  if (!symbol) {
+    throw new types.SDKError("Symbol is required");
   }
-  unregister(scope, calculator) {
-    const ref_count_name = `${scope}_${calculator.name}`;
-    const count = this.referenceCount.get(ref_count_name);
-    if (typeof count !== "undefined" && count > 1) {
-      this.referenceCount.set(ref_count_name, count - 1);
-      return;
+  const { data: info } = useQuery(
+    `/v1/public/futures/${symbol}`,
+    {
+      revalidateOnFocus: false
     }
-    const calculators = this.calculators.get(scope);
-    if (Array.isArray(calculators)) {
-      const index = calculators.findIndex((c) => c.name === calculator.name);
-      if (index > -1) {
-        calculators[index].destroy?.();
-        calculators.splice(index, 1);
+  );
+  const [ticker, setTicker] = React2.useState();
+  const ws = useWS();
+  React2.useEffect(() => {
+    const unsubscribe = ws.subscribe(
+      // { event: "subscribe", topic: "markprices" },
+      `${symbol}@ticker`,
+      {
+        onMessage: (message) => {
+          if (message.symbol !== symbol)
+            return;
+          setTicker(message);
+        }
+        // onUnsubscribe: () => {
+        //   return "markprices";
+        // },
+        // onError: (error: any) => {
+        //
+        // },
       }
+    );
+    return () => {
+      setTicker(void 0);
+      unsubscribe?.();
+    };
+  }, [symbol]);
+  const { data: markPrice } = useMarkPrice(symbol);
+  const { data: indexPrice } = useIndexPrice(symbol);
+  const { data: openInterest } = useOpenInterest(symbol);
+  const { data: futures } = useFutures();
+  const value = React2.useMemo(() => {
+    if (!info)
+      return null;
+    if (!ticker || ticker.symbol !== symbol)
+      return info;
+    const futureIndex = futures?.findIndex(
+      (item) => item.symbol === symbol
+    );
+    let _oi = openInterest;
+    if (!_oi && futureIndex !== -1 && futures) {
+      _oi = futures[futureIndex].open_interest;
     }
-    this.referenceCount.delete(ref_count_name);
-  }
-  async calc(scope, data, options) {
-    if (scope !== "position" /* POSITION */) {
-      if (!options?.skipWhenOnPause) ;
+    const config = {
+      ...info,
+      mark_price: markPrice,
+      index_price: indexPrice,
+      open_interest: _oi
+    };
+    if (ticker.open !== void 0) {
+      config["24h_open"] = ticker.open;
     }
-    const ctx = CalculatorContext.create(scope, data);
-    if (!ctx.isReady && options?.skipPending) {
-      return;
+    if (ticker.close !== void 0) {
+      config["24h_close"] = ticker.close;
     }
-    if (options?.skipWhenOnPause && !this.windowIsVisible)
-      return;
-    this.calcQueue.push({ scope, data, options });
-    await this.handleCalcQueue(ctx);
-    this.ctx = ctx;
-  }
-  // private async handlePendingCalc() {
-  //   // console.log("[handlePendingCalc]:", this.pendingCalc);
-  //   if (this.pendingCalc.length === 0) return;
-  //   this.calcQueue = [...this.pendingCalc, ...this.calcQueue];
-  //   this.pendingCalc = [];
-  // }
-  async handleCalcQueue(context) {
-    const first = this.calcQueue.shift();
-    if (first) {
-      const { scope, data, options } = first;
-      const ctx = context || CalculatorContext.create(scope, data);
-      const calculators = this.calculators.get(scope);
-      if (Array.isArray(calculators) && calculators.length) {
-        try {
-          await this.scheduler.calc(scope, calculators, data, ctx);
-        } catch (e) {
-        }
-        if (!options?.skipUpdate) {
-          this.scheduler.update(scope, calculators, ctx.outputToValue());
-        }
-      }
-      if (this.calcQueue.length) {
-        this.handleCalcQueue(ctx);
-      }
+    if (ticker.high !== void 0) {
+      config["24h_high"] = ticker.high;
     }
-  }
-  stop() {
-    this.calcQueue = [];
-    this.ctx?.clearCache();
-  }
-  get windowIsVisible() {
-    if (typeof document === "undefined") {
-      return true;
+    if (ticker.low !== void 0) {
+      config["24h_low"] = ticker.low;
     }
-    return document.visibilityState === "visible";
-  }
+    if (ticker.volume !== void 0) {
+      config["24h_volumn"] = ticker.volume;
+      config["24h_volume"] = ticker.volume;
+    }
+    if (ticker.close !== void 0 && ticker.open !== void 0) {
+      config["change"] = new utils.Decimal(ticker.close).minus(ticker.open).div(ticker.open).toNumber();
+      config["24h_change"] = new utils.Decimal(ticker.close).minus(ticker.open).toNumber();
+    }
+    return config;
+  }, [info, symbol, ticker, futures, openInterest]);
+  return value;
 };
-var CalculatorServiceID = "CalculatorService";
 
-// src/orderly/calculator/shardedScheduler.ts
-var requestIdleCallbackPolyfill = (callback, options) => {
-  const startTime = Date.now();
-  return setTimeout(() => {
-    callback({
-      didTimeout: false,
-      timeRemaining: () => Math.max(0, 50 - (Date.now() - startTime))
-    });
-  }, 1);
+// src/orderly/useOrderbookStream.ts
+var paddingFn = (len) => Array(len).fill([Number.NaN, Number.NaN, Number.NaN, Number.NaN]);
+var isNumber = (val) => {
+  return typeof val === "number" && !Number.isNaN(val);
 };
-var cancelIdleCallbackPolyfill = (id) => {
-  clearTimeout(id);
+var getPriceKey = (rawPrice, depth, isAsks) => {
+  return new utils.Decimal(rawPrice).div(depth).toDecimalPlaces(0, isAsks ? utils.Decimal.ROUND_CEIL : utils.Decimal.ROUND_FLOOR).mul(depth).toNumber();
 };
-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 {
-  // run(calculators: Calculator[]) {}
-  calc(scope, calculators, data, ctx) {
-    return new Promise((resolve, reject) => {
-      try {
-        this.computation(
-          calculators,
-          (shard) => {
-            const results = [];
-            for (let index = 0; index < shard.length; index++) {
-              const calculator = shard[index];
-              const result = calculator.calc(scope, data, ctx);
-              if (result) {
-                ctx.saveOutput(calculator.name, result);
-                results.push(result);
-              }
-            }
-            return results;
-          },
-          (results) => {
-            resolve(results);
-          }
-        );
-      } catch (error) {
-        reject(error);
-      }
-    });
+var reduceItems = (depth, data, isAsks) => {
+  if (!Array.isArray(data) || data.length === 0) {
+    return [];
   }
-  update(scope, calculators, data) {
-    for (let index = 0; index < calculators.length; index++) {
-      const calculator = calculators[index];
-      const item = data[calculator.name];
-      if (!!item) {
-        calculator.update(item, scope);
+  let newData = [...data];
+  const result = [];
+  if (typeof depth !== "undefined") {
+    const pricesMap = /* @__PURE__ */ new Map();
+    const len = data.length;
+    for (let i = 0; i < len; i++) {
+      const [rawPrice, quantity] = data[i];
+      if (!isNumber(rawPrice) || !isNumber(quantity)) {
+        continue;
+      }
+      const priceKey = getPriceKey(rawPrice, depth, isAsks);
+      const amtByRaw = new utils.Decimal(rawPrice).mul(quantity).toNumber();
+      if (pricesMap.has(priceKey)) {
+        const item = pricesMap.get(priceKey);
+        const sumQty = new utils.Decimal(item[1]).add(quantity).toNumber();
+        const sumAmtByRaw = new utils.Decimal(item[2] ?? 0).add(amtByRaw).toNumber();
+        pricesMap.set(priceKey, [priceKey, sumQty, sumAmtByRaw]);
+      } else {
+        pricesMap.set(priceKey, [priceKey, quantity, amtByRaw]);
       }
     }
-    return Promise.resolve();
+    newData = Array.from(pricesMap.values());
   }
-  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));
+  for (let i = 0; i < newData.length; i++) {
+    const [price, quantity, sumAmtByRaw] = newData[i];
+    if (!isNumber(price) || !isNumber(quantity)) {
+      continue;
+    }
+    const resLen = result.length;
+    const newQuantity = new utils.Decimal(quantity).add(resLen ? result[resLen - 1][2] : 0).toNumber();
+    const pieceAmount = isNumber(sumAmtByRaw) ? sumAmtByRaw : new utils.Decimal(quantity).mul(price).toNumber();
+    const newAmount = new utils.Decimal(pieceAmount).add(resLen ? result[resLen - 1][3] : 0).toNumber();
+    result.push([price, quantity, newQuantity, newAmount]);
+  }
+  return result;
+};
+var reduceOrderbook = (depth, level, padding, data) => {
+  let asks = reduceItems(depth, data.asks, true);
+  let bids = reduceItems(depth, data.bids, false);
+  if (asks.length !== 0 && bids.length !== 0 && asks[0][0] <= bids[0][0]) {
+    if (asks.length === 1) {
+      const [price, qty, newQuantity, newAmount] = asks[0];
+      asks.shift();
+      asks.push([
+        price + (depth === void 0 ? 0 : Number(depth)),
+        qty,
+        newQuantity,
+        newAmount
+      ]);
+    } else {
+      const [bidPrice] = bids[0];
+      while (asks.length > 0) {
+        const [askPrice, askQty, newQuantity, newAmount] = asks[0];
+        if (askPrice <= bidPrice) {
+          asks.shift();
+          for (let i = 0; i < asks.length; i++) {
+            if (i === 0) {
+              const quantity = new utils.Decimal(asks[i][1]).add(askQty);
+              asks[i][1] = quantity.toNumber();
+              asks[i][2] = quantity.toNumber();
+              asks[i][3] = quantity.toDecimalPlaces(0, utils.Decimal.ROUND_CEIL).mul(asks[i][0]).toNumber();
+            } else {
+              asks[i][3] = new utils.Decimal(asks[i][0]).mul(asks[i][1]).add(asks[i - 1][3]).toNumber();
+            }
+          }
         } else {
-          shardSize = Math.min(data.length - index, shardSize * 2);
+          break;
         }
       }
-      if (index < data.length) {
-        safeRequestIdleCallback(processNextShard, {
-          timeout: 1e3
-        });
-      } else {
-        onComplete(results.flat());
-      }
     }
-    safeRequestIdleCallback(processNextShard, {
-      timeout: 1e3
-    });
   }
+  asks = asks.reverse();
+  if (padding) {
+    asks = asks.length < level ? paddingFn(level - asks.length).concat(asks) : asks;
+    bids = bids.length < level ? bids.concat(paddingFn(level - bids.length)) : bids;
+  }
+  return {
+    asks,
+    bids
+  };
 };
-var POSITION_EMPTY = {
-  rows: null,
-  margin_ratio: 0,
-  initial_margin_ratio: 0,
-  maintenance_margin_ratio: 0,
-  open_margin_ratio: 0,
-  current_margin_ratio_with_orders: 0,
-  initial_margin_ratio_with_orders: 0,
-  maintenance_margin_ratio_with_orders: 0,
-  total_collateral_value: 0,
-  free_collateral: 0,
-  total_pnl_24_h: 0,
-  unrealPnL: 0,
-  total_unreal_pnl: 0,
-  unsettledPnL: 0,
-  total_unsettled_pnl: 0,
-  notional: 0,
-  unrealPnlROI: 0
+var ORDERLY_ORDERBOOK_DEPTH_KEY = "orderly_orderbook_depth_key";
+var INIT_DATA = {
+  asks: [],
+  bids: []
 };
-var usePositionStore = zustand.create()(
-  immer.immer((set) => ({
-    positions: {
-      all: POSITION_EMPTY
-    },
-    actions: {
-      setPositions: (key, positions3) => {
-        set((state) => {
-          state.positions[key] = positions3;
-        });
-      },
-      closePosition: (symbol) => {
-        set((state) => {
-          delete state.positions[symbol];
-        });
-      },
-      clearAll: () => {
-        set((state) => {
-          state.positions = {
-            all: POSITION_EMPTY
-          };
-        });
-      }
-    }
-  }))
-);
-var usePositions = (symbol = "all") => usePositionStore((state) => (state.positions[symbol] ?? POSITION_EMPTY).rows);
-var usePositionActions = () => usePositionStore((state) => state.actions);
-
-// src/orderly/calculator/positions.ts
-var NAME_PREFIX = "positionCalculator";
-var AllPositions = "all";
-var PositionCalculator = class extends BaseCalculator {
-  // private id: string;
-  constructor(symbol = AllPositions) {
-    super();
-    this.name = `${NAME_PREFIX}_${symbol}`;
-    this.symbol = symbol;
+var useOrderbookStream = (symbol, initial = INIT_DATA, options) => {
+  if (!symbol) {
+    throw new types.SDKError("Symbol is required");
   }
-  calc(scope, data, ctx) {
-    if (scope === "markPrice" /* MARK_PRICE */) {
-      return this.calcByMarkPrice(data, ctx);
+  const level = options?.level ?? 10;
+  const padding = options?.padding ?? true;
+  const symbolRef = React2.useRef(symbol);
+  symbolRef.current = symbol;
+  const {
+    defaultOrderbookTickSizes: DEFAULT_TICK_SIZES2 = {},
+    defaultOrderbookSymbolDepths: DEFAULT_SYMBOL_DEPTHS2 = {}
+  } = React2.useContext(OrderlyContext);
+  const [data, setData] = React2.useState(initial);
+  const [isLoading, setIsLoading] = React2.useState(true);
+  const config = useSymbolsInfo()[symbol];
+  const [depthObject, setDepthObject] = useLocalStorage(
+    ORDERLY_ORDERBOOK_DEPTH_KEY,
+    {}
+  );
+  const prevMiddlePrice = React2.useRef(0);
+  const tick = config("quote_tick");
+  const depths = React2.useMemo(() => {
+    if (DEFAULT_SYMBOL_DEPTHS2[symbol]) {
+      return DEFAULT_SYMBOL_DEPTHS2[symbol];
     }
-    if (scope === "indexPrice" /* INDEX_PRICE */) {
-      return this.calcByIndexPrice(data, ctx);
+    if (typeof tick === "undefined") {
+      return [];
     }
-    if (scope === "position" /* POSITION */) {
-      return this.calcByPosition(
-        this.preprocess(data),
-        ctx
-      );
+    try {
+      const base = new utils.Decimal(tick);
+      return [
+        base.toNumber(),
+        base.mul(10).toNumber(),
+        base.mul(100).toNumber(),
+        base.mul(1e3).toNumber()
+      ];
+    } catch {
     }
-    return data;
-  }
-  update(data, scope) {
-    if (!data || !Array.isArray(data.rows))
+    return [tick];
+  }, [symbol, tick]);
+  React2.useEffect(() => {
+    if (depthObject[symbol]) {
       return;
-    usePositionStore.getState().actions.setPositions(this.symbol, data);
-    if (Array.isArray(data.rows) && useApiStatusStore.getState().apis.positions.loading) {
-      useApiStatusStore.getState().actions.updateApiLoading("positions", false);
     }
-  }
-  calcByMarkPrice(markPrice, ctx) {
-    let positions3 = this.getPosition(markPrice, ctx);
-    useAppStore.getState().fundingRates;
-    if (!positions3 || !Array.isArray(positions3.rows) || !positions3.rows.length)
-      return positions3;
-    positions3 = {
-      ...positions3,
-      rows: positions3.rows.map((item) => {
-        return {
-          ...item,
-          mark_price: markPrice[item.symbol] || item.mark_price
-        };
-      })
-    };
-    return this.format(positions3, ctx);
-  }
-  calcByIndexPrice(indexPrice, ctx) {
-    let positions3 = this.getPosition(indexPrice, ctx);
-    if (!positions3) {
-      return positions3;
-    }
-    if (!Array.isArray(positions3.rows) || !positions3.rows.length)
-      return positions3;
-    positions3 = {
-      ...positions3,
-      rows: positions3.rows.map((item) => ({
-        ...item,
-        index_price: indexPrice[item.symbol] || item.index_price || item.mark_price
-      }))
-    };
-    return this.format(positions3, ctx);
-  }
-  calcByPosition(positions3, ctx) {
-    if (positions3.rows.length === 0)
-      return positions3;
-    return this.format(positions3, ctx);
-  }
-  format(data, ctx) {
-    const { accountInfo, symbolsInfo, fundingRates, portfolio } = ctx;
-    if (!accountInfo || !fundingRates || !symbolsInfo) {
-      return data;
-    }
-    let unrealPnL_total = utils.zero, unrealPnL_total_index = utils.zero, notional_total = utils.zero, unsettlementPnL_total = utils.zero;
-    let rows = data.rows.map((item) => {
-      const info = symbolsInfo[item.symbol];
-      const sum_unitary_funding = fundingRates?.[item.symbol]?.["sum_unitary_funding"] ?? 0;
-      const notional = perp.positions.notional(item.position_qty, item.mark_price);
-      const unrealPnl = perp.positions.unrealizedPnL({
-        qty: item.position_qty,
-        openPrice: item?.average_open_price,
-        // markPrice: unRealizedPrice,
-        markPrice: item.mark_price
-      });
-      let unrealPnl_index = 0, unrealPnlROI_index = 0;
-      const maxLeverage = item.leverage || 1;
-      const imr = perp.account.IMR({
-        maxLeverage,
-        baseIMR: info?.["base_imr"],
-        IMR_Factor: accountInfo.imr_factor[item.symbol],
-        positionNotional: notional,
-        ordersNotional: 0,
-        IMR_factor_power: 4 / 5
-      });
-      const unrealPnlROI = perp.positions.unrealizedPnLROI({
-        positionQty: item.position_qty,
-        openPrice: item.average_open_price,
-        IMR: imr,
-        unrealizedPnL: unrealPnl
-      });
-      if (item.index_price) {
-        unrealPnl_index = perp.positions.unrealizedPnL({
-          qty: item.position_qty,
-          openPrice: item?.average_open_price,
-          // markPrice: unRealizedPrice,
-          markPrice: item.index_price
-        });
-        unrealPnlROI_index = perp.positions.unrealizedPnLROI({
-          positionQty: item.position_qty,
-          openPrice: item.average_open_price,
-          IMR: imr,
-          unrealizedPnL: unrealPnl_index
-        });
-      }
-      const unsettlementPnL2 = perp.positions.unsettlementPnL({
-        positionQty: item.position_qty,
-        markPrice: item.mark_price,
-        costPosition: item.cost_position,
-        sumUnitaryFunding: ramda.propOr(
-          0,
-          "sum_unitary_funding",
-          fundingRates[item.symbol]
-        ),
-        lastSumUnitaryFunding: item.last_sum_unitary_funding
-      });
-      const MMR = perp.positions.MMR({
-        baseMMR: info?.["base_mmr"],
-        baseIMR: info?.["base_imr"],
-        IMRFactor: accountInfo.imr_factor[item.symbol],
-        positionNotional: notional,
-        IMR_factor_power: 4 / 5
-      });
-      unrealPnL_total = unrealPnL_total.add(unrealPnl);
-      unrealPnL_total_index = unrealPnL_total_index.add(unrealPnl_index);
-      notional_total = notional_total.add(notional);
-      unsettlementPnL_total = unsettlementPnL_total.add(unsettlementPnL2);
-      const fundingFee = new utils.Decimal(sum_unitary_funding).sub(item.last_sum_unitary_funding).mul(item.position_qty).negated().toNumber();
-      return {
-        ...item,
-        fundingFee,
-        mm: perp.positions.maintenanceMargin({
-          positionQty: item.position_qty,
-          markPrice: item.mark_price,
-          MMR
-        }),
-        mmr: MMR,
-        notional,
-        unsettlement_pnl: unsettlementPnL2,
-        unrealized_pnl: unrealPnl,
-        unrealized_pnl_index: unrealPnl_index,
-        unrealized_pnl_ROI: unrealPnlROI,
-        unrealized_pnl_ROI_index: unrealPnlROI_index
-      };
-    });
-    const totalUnrealPnl = unrealPnL_total.toNumber();
-    const totalUnrealPnl_index = unrealPnL_total_index.toNumber();
-    const unsettlementPnL = unsettlementPnL_total.toNumber();
-    let totalUnrealizedROI = 0, totalUnrealizedROI_index = 0;
-    if (portfolio) {
-      const { totalValue, totalCollateral } = portfolio;
-      rows = rows.map((item) => {
-        const est_liq_price = perp.positions.liqPrice({
-          markPrice: item.mark_price,
-          totalCollateral: totalCollateral.toNumber(),
-          positionQty: item.position_qty,
-          positions: rows,
-          MMR: item.mmr
-        });
-        return {
-          ...item,
-          est_liq_price
-        };
-      });
-      if (totalValue !== null && !totalValue.eq(utils.zero)) {
-        totalUnrealizedROI = perp.account.totalUnrealizedROI({
-          totalUnrealizedPnL: totalUnrealPnl,
-          totalValue: totalValue.toNumber()
-        });
-        totalUnrealizedROI_index = perp.account.totalUnrealizedROI({
-          totalUnrealizedPnL: totalUnrealPnl_index,
-          totalValue: totalValue.toNumber()
-        });
-      }
-    }
-    return {
-      ...data,
-      unrealPnL: totalUnrealPnl,
-      total_unreal_pnl: totalUnrealPnl,
-      total_unreal_pnl_index: totalUnrealPnl_index,
-      notional: notional_total.toNumber(),
-      unsettledPnL: unsettlementPnL,
-      total_unsettled_pnl: unsettlementPnL,
-      unrealPnlROI: totalUnrealizedROI,
-      unrealPnlROI_index: totalUnrealizedROI_index,
-      rows
-    };
-  }
-  preprocess(data) {
-    let rows = data.rows;
-    if (this.symbol !== AllPositions && Array.isArray(rows)) {
-      rows = rows.filter((item) => item.symbol === this.symbol);
-    }
-    return {
-      ...data,
-      rows
-    };
-  }
-  getPosition(_, ctx) {
-    const positions3 = ctx.get((output) => output[this.name]) || usePositionStore.getState().positions[this.symbol];
-    if (this.symbol === AllPositions) {
-      return positions3;
-    }
-    if (positions3 && Array.isArray(positions3.rows)) {
-      return positions3;
-    }
-    return this.preprocess(this.getAllPositions(ctx));
-  }
-  destroy() {
-    usePositionStore.getState().actions.closePosition(this.symbol);
-    CalculatorContext.instance?.deleteByName(this.name);
-  }
-  getAllPositions(ctx) {
-    return ctx.get((output) => output[AllPositions]) || usePositionStore.getState().positions[AllPositions];
-  }
-};
-PositionCalculator.logPosition = (symbol = "all") => {
-  return usePositionStore.getState().positions[symbol];
-};
-var parseHolding = (holding, indexPrices, tokensInfo) => {
-  const nonUSDC = [];
-  let USDC_holding = 0;
-  holding.forEach((item) => {
-    if (item.token === "USDC") {
-      USDC_holding = item.holding;
-    } else {
-      const tokenInfo = tokensInfo.find(({ token }) => token === item.token);
-      const {
-        base_weight = 0,
-        discount_factor = 0,
-        user_max_qty = 0
-      } = tokenInfo || {};
-      const holdingQty = item?.holding ?? 0;
-      const indexPrice = indexPrices[`PERP_${item.token}_USDC`] ?? 0;
-      const collateralRatio4 = perp.account.collateralRatio({
-        baseWeight: base_weight,
-        discountFactor: discount_factor,
-        collateralQty: holdingQty,
-        collateralCap: user_max_qty,
-        indexPrice
-      });
-      nonUSDC.push({
-        holding: holdingQty,
-        indexPrice,
-        collateralCap: user_max_qty,
-        collateralRatio: collateralRatio4
-      });
-    }
-  });
-  return [USDC_holding, nonUSDC];
-};
-var useIndexPriceStore = zustand.create((set) => ({
-  indexPrices: {},
-  actions: {
-    updateIndexPrice: (indexPrice) => {
-      set({
-        indexPrices: indexPrice
-      });
-    }
-  }
-}));
-
-// src/orderly/calculator/indexPrice.ts
-var IndexPriceCalculatorName = "indexPriceCalculator";
-var IndexPriceCalculator = class extends BaseCalculator {
-  constructor() {
-    super(...arguments);
-    this.name = IndexPriceCalculatorName;
-  }
-  calc(scope, data, ctx) {
-    return data;
-  }
-  update(data) {
-    if (!data)
-      return;
-    useIndexPriceStore.getState().actions.updateIndexPrice(data);
-  }
-  static getValue() {
-    return useIndexPriceStore.getState().indexPrices;
-  }
-};
-
-// src/orderly/calculator/portfolio.ts
-var PortfolioCalculatorName = "portfolio";
-var PortfolioCalculator = class extends BaseCalculator {
-  constructor() {
-    super(...arguments);
-    this.name = PortfolioCalculatorName;
-  }
-  calc(scope, data, ctx) {
-    let markPrices;
-    let indexPrices;
-    const portfolio = this.getPortfolio(ctx);
-    if (scope === "markPrice" /* MARK_PRICE */) {
-      markPrices = data;
-    } else {
-      markPrices = ctx.get(
-        (cache) => cache[MarketCalculatorName]
-      );
-    }
-    if (scope === "indexPrice" /* INDEX_PRICE */) {
-      indexPrices = data;
+    if (DEFAULT_TICK_SIZES2[symbol]) {
+      setDepthObject((prev) => ({
+        ...prev,
+        [symbol]: Number(DEFAULT_TICK_SIZES2[symbol])
+      }));
     } else {
-      indexPrices = ctx.get(
-        (cache) => cache[IndexPriceCalculatorName]
-      );
+      setDepthObject((prev) => ({
+        ...prev,
+        [symbol]: tick
+      }));
     }
-    const positions3 = ctx.get(
-      (output) => output.positionCalculator_all
-    );
-    let holding = portfolio.holding;
-    if (scope === "portfolio" /* PORTFOLIO */ && data.holding && Array.isArray(holding)) {
-      if (Array.isArray(data.holding)) {
-        holding = data.holding;
-      } else {
-        holding = holding.map((item) => {
-          if (data.holding[item.token]) {
-            return {
-              ...item,
-              holding: data.holding[item.token].holding,
-              frozen: data.holding[item.token].frozen
-            };
+  }, [depthObject, tick, symbol, DEFAULT_TICK_SIZES2]);
+  const onDepthChange = React2.useCallback(
+    (val) => {
+      setDepthObject((prev) => ({ ...prev, [symbol]: val }));
+    },
+    [symbol]
+  );
+  const ws = useWS();
+  const ticker = useTickerStream(symbol);
+  const eventEmitter = useEventEmitter();
+  React2.useEffect(() => {
+    let needRequestFullOrderbook = true;
+    setIsLoading(true);
+    let fullOrderBookUpdateSub;
+    const orderBookUpdateSub = ws.subscribe(
+      {
+        event: "subscribe",
+        topic: `${symbol}@orderbookupdate`
+      },
+      {
+        formatter: (message) => message,
+        onMessage: (message) => {
+          const { data: wsData, ts } = message;
+          const { symbol: symbol2, asks, bids, prevTs } = wsData;
+          if (symbolRef.current !== symbol2) {
+            orderBookUpdateSub?.();
+            return;
           }
-          return item;
-        });
+          orderbook_service_default.updateOrderbook(
+            symbol2,
+            { asks, bids, ts, prevTs },
+            () => {
+              needRequestFullOrderbook = true;
+            }
+          );
+          const data2 = orderbook_service_default.getRawOrderbook(symbol2);
+          setData({ bids: data2.bids, asks: data2.asks });
+        }
       }
-    }
-    const accountInfo = ctx.accountInfo;
-    const symbolsInfo = ctx.symbolsInfo;
-    const tokensInfo = ctx.tokensInfo;
-    return this.format({
-      holding,
-      positions: positions3,
-      markPrices,
-      accountInfo,
-      symbolsInfo,
-      indexPrices,
-      tokensInfo: tokensInfo ?? types.EMPTY_LIST
-    });
-  }
-  getPortfolio(ctx) {
-    return ctx.get((output) => output[this.name]) || useAppStore.getState().portfolio;
-  }
-  format(inputs) {
-    const {
-      holding,
-      positions: positions3,
-      markPrices,
-      indexPrices,
-      accountInfo,
-      symbolsInfo,
-      tokensInfo
-    } = inputs;
-    if (!holding || !positions3 || !Array.isArray(positions3.rows) || !markPrices || !indexPrices || !accountInfo) {
-      return null;
-    }
-    const unsettledPnL = ramda.pathOr(0, ["total_unsettled_pnl"])(positions3);
-    const unrealizedPnL = ramda.pathOr(0, ["total_unreal_pnl"])(positions3);
-    const [USDC_holding, nonUSDC] = parseHolding(
-      holding,
-      indexPrices,
-      tokensInfo
     );
-    const usdc = holding.find((item) => item.token === "USDC");
-    const totalCollateral = perp.account.totalCollateral({
-      USDCHolding: USDC_holding,
-      nonUSDCHolding: nonUSDC,
-      unsettlementPnL: unsettledPnL
-    });
-    const totalValue = perp.account.totalValue({
-      totalUnsettlementPnL: unsettledPnL,
-      USDCHolding: USDC_holding,
-      nonUSDCHolding: nonUSDC
-    });
-    const totalUnrealizedROI = perp.account.totalUnrealizedROI({
-      totalUnrealizedPnL: unrealizedPnL,
-      totalValue: totalValue.toNumber()
-    });
-    const totalInitialMarginWithOrders = perp.account.totalInitialMarginWithQty({
-      positions: positions3.rows,
-      markPrices,
-      IMR_Factors: accountInfo.imr_factor,
-      maxLeverage: accountInfo.max_leverage,
-      symbolInfo: createGetter({ ...symbolsInfo })
-    });
-    const freeCollateral = perp.account.freeCollateral({
-      totalCollateral,
-      totalInitialMarginWithOrders
-    });
-    const availableBalance = perp.account.availableBalance({
-      USDCHolding: usdc?.holding ?? 0,
-      unsettlementPnL: positions3.total_unsettled_pnl ?? 0
-    });
-    return {
-      totalCollateral,
-      totalValue,
-      totalUnrealizedROI,
-      freeCollateral,
-      availableBalance,
-      unsettledPnL,
-      holding
+    if (needRequestFullOrderbook) {
+      setIsLoading(true);
+      fullOrderBookUpdateSub = ws.onceSubscribe(
+        {
+          event: "request",
+          id: `${symbol}@orderbook`,
+          params: {
+            type: "orderbook",
+            symbol
+          }
+        },
+        {
+          formatter: (message) => message,
+          onMessage: (message) => {
+            const { symbol: symbol2, asks, bids, ts } = message.data;
+            if (symbolRef.current !== symbol2) {
+              return;
+            }
+            orderbook_service_default.setFullOrderbook(symbol2, { asks, bids, ts });
+            const data2 = orderbook_service_default.getRawOrderbook(symbol2);
+            setData({ bids: data2.bids, asks: data2.asks });
+            setIsLoading(false);
+          }
+        }
+      );
+      needRequestFullOrderbook = false;
+    }
+    return () => {
+      orderBookUpdateSub?.();
+      fullOrderBookUpdateSub?.();
+      orderbook_service_default.resetOrderBook(symbol);
+      setData(INIT_DATA);
     };
-  }
-  update(data, scope) {
-    if (data) {
-      useAppStore.getState().actions.batchUpdateForPortfolio({
-        totalCollateral: data.totalCollateral,
-        totalValue: data.totalValue,
-        freeCollateral: data.freeCollateral,
-        availableBalance: data.availableBalance,
-        totalUnrealizedROI: data.totalUnrealizedROI,
-        unsettledPnL: data.unsettledPnL,
-        holding: Array.isArray(data.holding) ? data.holding : []
-      });
+  }, [symbol]);
+  const { data: markPrice } = useMarkPrice(symbol);
+  const onItemClick = React2.useCallback((item) => {
+    eventEmitter.emit("orderbook:item:click", item);
+  }, []);
+  const reducedData = reduceOrderbook(depthObject[symbol], level, padding, {
+    asks: data.asks,
+    bids: data.bids
+  });
+  React2.useEffect(() => {
+    eventEmitter.emit("orderbook:update", reducedData);
+  }, [reducedData]);
+  const middlePrice = React2.useMemo(() => {
+    let asksFrist = 0;
+    let bidsFirst = 0;
+    if (data.asks.length > 0) {
+      asksFrist = reducedData.asks?.[reducedData.asks.length - 1]?.[0];
     }
-  }
-};
-
-// src/useCalculatorService.ts
-var useCalculatorService = () => {
-  const { get: get3 } = useSimpleDI();
-  const calculatorService = useConstant__default.default(() => {
-    let calculatorService2 = get3(CalculatorServiceID);
-    if (!calculatorService2) {
-      const positionCalculator = new PositionCalculator();
-      const portfolioCalculator = new PortfolioCalculator();
-      const markPriceCalculator = new MarkPriceCalculator();
-      const indexPriceCalculator = new IndexPriceCalculator();
-      calculatorService2 = new CalculatorService(new ShardingScheduler(), [
-        [
-          "markPrice" /* MARK_PRICE */,
-          [
-            markPriceCalculator,
-            positionCalculator,
-            portfolioCalculator,
-            positionCalculator
-          ]
-        ],
-        ["position" /* POSITION */, [positionCalculator, portfolioCalculator]],
-        ["portfolio" /* PORTFOLIO */, [portfolioCalculator]],
-        // indexPrice
-        [
-          "indexPrice" /* INDEX_PRICE */,
-          [indexPriceCalculator, positionCalculator]
-        ]
-      ]);
-      core.SimpleDI.registerByName(CalculatorServiceID, calculatorService2);
+    if (data.bids.length > 0) {
+      bidsFirst = data.bids[0][0];
     }
-    return calculatorService2;
-  });
-  return calculatorService;
-};
-
-// src/orderly/orderbook.service.ts
-var defaultRawOrderBook = {
-  asks: [],
-  bids: [],
-  ts: 0
-};
-var OrderbookService = class _OrderbookService {
-  constructor() {
-    this.bufferedOrderBookUpdates = {};
-    this.rawOrderBook = {};
-  }
-  static getInstance() {
-    if (!this.instance) {
-      this.instance = new _OrderbookService();
+    if (!isNumber(asksFrist) || !isNumber(bidsFirst) || !ticker) {
+      return 0;
     }
-    return this.instance;
-  }
-  sortBufferedOrderBookUpdates(symbol) {
-    this.bufferedOrderBookUpdates[symbol]?.sort((a, b) => a.ts - b.ts);
-  }
-  applyUpdateToRawOrderBook(symbol, update) {
-    const rawOrderBook = this.rawOrderBook[symbol];
-    if (!rawOrderBook || rawOrderBook.ts > update.prevTs) {
-      return;
+    return [asksFrist, bidsFirst, ticker["24h_close"]].sort()[1];
+  }, [ticker?.["24h_close"], data]);
+  React2.useEffect(() => {
+    prevMiddlePrice.current = middlePrice;
+  }, [middlePrice]);
+  return [
+    {
+      asks: reducedData.asks.slice(-level),
+      bids: reducedData.bids.slice(0, level),
+      markPrice,
+      middlePrice: [prevMiddlePrice.current, middlePrice]
+    },
+    {
+      onDepthChange,
+      depth: depthObject[symbol],
+      allDepths: depths,
+      isLoading,
+      onItemClick
     }
-    const askMap = /* @__PURE__ */ new Map();
-    const bidMap = /* @__PURE__ */ new Map();
-    rawOrderBook.asks.forEach((ask) => {
-      askMap.set(ask[0], ask[1]);
-    });
-    rawOrderBook.bids.forEach((bid) => {
-      bidMap.set(bid[0], bid[1]);
-    });
-    update.asks.forEach(
-      (ask) => ask[1] === 0 ? askMap.delete(ask[0]) : askMap.set(ask[0], ask[1])
-    );
-    update.bids.forEach(
-      (bid) => bid[1] === 0 ? bidMap.delete(bid[0]) : bidMap.set(bid[0], bid[1])
-    );
-    rawOrderBook.asks = Array.from(askMap.entries()).sort(
-      (a, b) => a[0] - b[0]
-    );
-    rawOrderBook.bids = Array.from(bidMap.entries()).sort(
-      (a, b) => b[0] - a[0]
-    );
-    rawOrderBook.ts = update.ts;
-  }
-  applyBufferedUpdatesToRawOrderBooks(symbol) {
-    this.bufferedOrderBookUpdates[symbol]?.forEach((update) => {
-      this.applyUpdateToRawOrderBook(symbol, update);
+  ];
+};
+var useSymbolInfo = (symbol) => {
+  const infos = useSymbolsInfo();
+  return React2.useMemo(() => {
+    return !symbol || infos.isNil ? null : infos[symbol];
+  }, [infos, symbol]);
+};
+var useFundingRates = () => {
+  const data = useAppStore((state) => state.fundingRates);
+  return createGetter({ ...data });
+};
+var useFundingRatesStore = () => {
+  const data = useAppStore((state) => state.fundingRates);
+  return data;
+};
+
+// src/orderly/useMarket.ts
+var DefaultTab = { name: "Popular", id: 1 };
+var marketsKey = "markets";
+var useMarket = (type) => {
+  const { configStore } = React2.useContext(OrderlyContext);
+  const symbolsInfo = useSymbolsInfo();
+  const fundingRates = useFundingRates();
+  const { data: futures } = useMarketsStream();
+  const updateStore = (key, data) => {
+    configStore.set(marketsKey, {
+      ...configStore.getOr(marketsKey, {}),
+      [key]: data
     });
-  }
-  deleteBufferedOrderBookUpdates(symbol) {
-    delete this.bufferedOrderBookUpdates[symbol];
-  }
-  commitOrderBook(symbol) {
-    const rawOrderBook = this.rawOrderBook[symbol];
-    if (!rawOrderBook) {
-      return;
+  };
+  const getStore = (key, defaultValue) => {
+    return configStore.get(marketsKey)[key] || defaultValue;
+  };
+  if (!configStore.get(marketsKey)) {
+    const jsonStr = localStorage.getItem(marketsKey);
+    if (jsonStr) {
+      configStore.set(marketsKey, JSON.parse(jsonStr));
+    } else {
+      configStore.set(marketsKey, {
+        recent: [],
+        favorites: [
+          { name: "PERP_ETH_USDC", tabs: [{ ...DefaultTab }] },
+          { name: "PERP_BTC_USDC", tabs: [{ ...DefaultTab }] }
+        ],
+        favoriteTabs: [{ ...DefaultTab }],
+        lastSelectedFavoriteTab: { ...DefaultTab }
+      });
     }
   }
-  pushUpdateToBuffer(symbol, update) {
-    if (this.bufferedOrderBookUpdates[symbol] === void 0) {
-      this.bufferedOrderBookUpdates[symbol] = [];
-    }
-    const buffer = this.bufferedOrderBookUpdates[symbol];
-    if (buffer.length > 0) {
-      const lastUpdate = buffer[buffer.length - 1];
-      if (lastUpdate.ts !== update.prevTs) {
-        this.bufferedOrderBookUpdates[symbol] = [];
+  const getFavoriteTabs = React2.useMemo(() => {
+    return getStore("favoriteTabs", [{ ...DefaultTab }]);
+  }, []);
+  const getFavorites = React2.useMemo(() => {
+    const curData = getStore("favorites", []);
+    const tabs = getFavoriteTabs;
+    const result = [];
+    const len = curData.length;
+    for (let index = 0; index < len; index++) {
+      const favData = curData[index];
+      const favTabs = favData.tabs.filter(
+        (tab) => tabs.findIndex((item) => tab.id === item.id) !== -1
+      );
+      if (favTabs.length) {
+        result.push({ ...favData, tabs: favTabs });
       }
     }
-    this.bufferedOrderBookUpdates[symbol].push(update);
-  }
-  isValidFullOrderBook(symbol, currentTs) {
-    if ((this.bufferedOrderBookUpdates[symbol]?.length ?? 0) !== 0) {
-      const earliestUpdates = this.bufferedOrderBookUpdates[symbol][0];
-      return earliestUpdates.prevTs <= currentTs;
-    }
-    return true;
-  }
-  setFullOrderbook(symbol, rawOrderbook) {
-    const { ts } = rawOrderbook;
-    this.rawOrderBook[symbol] = rawOrderbook;
-    this.sortBufferedOrderBookUpdates(symbol);
-    if (this.isValidFullOrderBook(symbol, ts)) {
-      this.applyBufferedUpdatesToRawOrderBooks(symbol);
-    }
-  }
-  updateOrderbook(symbol, update, callback) {
-    const { asks, bids, prevTs, ts } = update;
-    const rawOrderBook = this.rawOrderBook[symbol];
-    if (!rawOrderBook) {
-      return;
-    }
-    const currentTs = rawOrderBook.ts;
-    if (currentTs === 0) {
-      this.pushUpdateToBuffer(symbol, { asks, bids, prevTs, ts });
+    updateStore("favorites", result);
+    return result;
+  }, [configStore]);
+  const [favoriteTabs, setFavoriteTabs] = React2.useState(getFavoriteTabs);
+  const [favorites, setFavorites] = React2.useState(getFavorites);
+  const [recent, setRecent] = React2.useState(
+    getStore("recent", []).filter((e) => e)
+  );
+  const [tabSort, setTabSort] = React2.useState(
+    getStore("tabSort", {})
+  );
+  const updateFavoriteTabs = (tab, operator) => {
+    const saveTabs = (tabs2) => {
+      setFavoriteTabs(tabs2);
+      updateStore("favoriteTabs", tabs2);
+    };
+    if (Array.isArray(tab)) {
+      saveTabs(tab);
       return;
     }
-    if (prevTs !== currentTs) {
-      this.pushUpdateToBuffer(symbol, { asks, bids, prevTs, ts });
-      if (callback) {
-        callback();
+    const tabs = [...favoriteTabs];
+    const index = tabs.findIndex((item) => item.id === tab.id);
+    if (operator?.add) {
+      tabs.push(tab);
+    } else if (operator?.update) {
+      if (index !== -1) {
+        tabs[index] = tab;
+      }
+    } else if (operator?.delete) {
+      if (index !== -1) {
+        tabs.splice(index, 1);
       }
-      return;
     }
-    this.applyUpdateToRawOrderBook(symbol, update);
-    this.deleteBufferedOrderBookUpdates(symbol);
-  }
-  getRawOrderbook(symbol) {
-    return this.rawOrderBook[symbol];
-  }
-  resetOrderBook(symbol) {
-    this.rawOrderBook[symbol] = defaultRawOrderBook;
-  }
-};
-var orderBookService = OrderbookService.getInstance();
-var orderbook_service_default = orderBookService;
-var useMarkPrice = (symbol) => {
-  const ws = useWS();
-  const [price, setPrice] = React2.useState(0);
-  React2.useEffect(() => {
-    const unsubscribe = ws.subscribe(`${symbol}@markprice`, {
-      onMessage: (message) => {
-        setPrice(message.price);
+    saveTabs(tabs);
+  };
+  const updateFavorites = (favorites2) => {
+    updateStore("favorites", favorites2);
+    setFavorites(favorites2);
+  };
+  const addToHistory = (symbol) => {
+    const curData = [...recent];
+    const index = curData.findIndex((item) => item.name == symbol.symbol);
+    if (index !== -1) {
+      curData.splice(index, 1);
+    }
+    curData.unshift({ name: symbol.symbol });
+    updateStore("recent", curData);
+    setRecent(curData);
+  };
+  const updateSymbolFavoriteState = (symbol, tab, remove = false) => {
+    const curData = [...favorites];
+    const index = curData.findIndex((item) => item.name == symbol.symbol);
+    if (index === -1) {
+      if (Array.isArray(tab)) {
+        if (tab.length > 0) {
+          curData.unshift({ name: symbol.symbol, tabs: tab });
+        }
+      } else {
+        if (!remove) {
+          curData.unshift({ name: symbol.symbol, tabs: [tab] });
+        }
       }
-    });
-    return () => {
-      unsubscribe?.();
-    };
-  }, [symbol]);
-  return { data: price };
-};
-var useIndexPrice = (symbol) => {
-  symbol = symbol.replace("PERP", "SPOT");
-  const ws = useWS();
-  return useSWRSubscription__default.default(`${symbol}@indexprice`, (key, { next }) => {
-    const unsubscribe = ws.subscribe(`${symbol}@indexprice`, {
-      onMessage: (message) => {
-        next(null, message.price);
+    } else {
+      const favorite = curData[index];
+      if (Array.isArray(tab)) {
+        if (tab.length === 0) {
+          curData.splice(index, 1);
+        } else {
+          curData[index] = { ...favorite, tabs: tab };
+        }
+      } else {
+        if (remove) {
+          const tabs = favorite.tabs.filter((item) => item.id != tab.id);
+          if (tabs.length === 0) {
+            curData.splice(index, 1);
+          } else {
+            curData[index] = { ...favorite, tabs };
+          }
+        } else {
+          const tabs = favorite.tabs;
+          tabs.push(tab);
+          curData[index] = { ...favorite, tabs };
+        }
       }
+    }
+    updateStore("favorites", curData);
+    setFavorites(() => curData);
+  };
+  const marketsList = React2.useMemo(() => {
+    const list = futures?.map((item) => {
+      const { open_interest = 0, index_price = 0 } = item;
+      const info = symbolsInfo[item.symbol];
+      const rate = fundingRates[item.symbol];
+      const est_funding_rate = rate("est_funding_rate");
+      const funding_period = info("funding_period");
+      const change = item.change === void 0 ? get24hChange2(item["24h_close"], item["24h_open"]) : item.change;
+      return {
+        ...item,
+        change,
+        "8h_funding": get8hFunding2(est_funding_rate, funding_period),
+        quote_dp: info("quote_dp"),
+        created_time: info("created_time"),
+        openInterest: new utils.Decimal(open_interest || 0).mul(index_price || 0).toNumber()
+      };
     });
-    return () => {
-      unsubscribe?.();
-    };
-  });
-};
-var useOpenInterest = (symbol) => {
-  const ws = useWS();
-  return useSWRSubscription__default.default(`${symbol}@openinterest`, (key, { next }) => {
-    const unsubscribe = ws.subscribe(`${symbol}@openinterest`, {
-      onMessage: (message) => {
-        next(null, message.openInterest);
+    return list || [];
+  }, [symbolsInfo, futures, fundingRates]);
+  const getData = (type2) => {
+    const localData = type2 === 0 /* FAVORITES */ ? [...favorites] : [...recent];
+    const keys = localData.map((item) => item.name);
+    const filter = type2 == 2 /* ALL */ ? marketsList : marketsList?.filter((item) => keys.includes(item.symbol));
+    const favoritesData = [...favorites];
+    const favoriteKeys = favoritesData.map((item) => item.name);
+    if (filter) {
+      for (let index = 0; index < filter.length; index++) {
+        const element = filter[index];
+        const isFavorite = type2 == 0 /* FAVORITES */ ? true : favoriteKeys.includes(element.symbol);
+        const fIndex = favoritesData.findIndex(
+          (item) => item.name === element.symbol
+        );
+        const tabs = fIndex === -1 ? [] : favoritesData[fIndex].tabs;
+        let imr = void 0;
+        if (symbolsInfo) {
+          imr = symbolsInfo?.[element.symbol]("base_imr");
+        }
+        filter[index] = {
+          ...filter[index],
+          isFavorite,
+          tabs,
+          leverage: imr ? 1 / imr : void 0
+        };
       }
-    });
-    return () => {
-      unsubscribe?.();
+    }
+    return filter;
+  };
+  const pinToTop = (symbol) => {
+    const index = favorites.findIndex((item) => item.name === symbol.symbol);
+    if (index !== -1) {
+      const element = favorites[index];
+      const list = [...favorites];
+      list.splice(index, 1);
+      list.unshift(element);
+      updateStore("favorites", list);
+      setFavorites(list);
+    }
+  };
+  const getLastSelFavTab = () => {
+    return getStore("lastSelectedFavoriteTab", { ...DefaultTab });
+  };
+  const updateSelectedFavoriteTab = (tab) => {
+    updateStore("lastSelectedFavoriteTab", tab);
+  };
+  const updateTabsSortState = (tabId, sortKey, sortOrder) => {
+    const map = getStore("tabSort", {});
+    map[tabId] = {
+      sortKey,
+      sortOrder
     };
-  });
-};
-var useFutures = () => {
-  const { data, isLoading, error } = useQuery(
-    `/v1/public/futures`,
+    updateStore("tabSort", map);
+    setTabSort(map);
+  };
+  const markets = getData(type);
+  return [
+    markets || types.EMPTY_LIST,
     {
-      revalidateOnFocus: false
+      favoriteTabs,
+      favorites,
+      recent,
+      tabSort,
+      addToHistory,
+      updateFavorites,
+      updateFavoriteTabs,
+      updateSymbolFavoriteState,
+      pinToTop,
+      getLastSelFavTab,
+      updateSelectedFavoriteTab,
+      updateTabsSortState
     }
-  );
-  const [sortedData, setSortedData] = React2.useState(data);
-  useWS();
-  React2.useEffect(() => {
-  }, []);
-  React2.useEffect(() => {
-    if (data) {
-      const sortedData2 = data.sort((a, b) => {
-        return 0;
+  ];
+};
+function get8hFunding2(est_funding_rate, funding_period) {
+  let funding8h = 0;
+  if (est_funding_rate === void 0 || est_funding_rate === null) {
+    return null;
+  }
+  if (funding_period) {
+    funding8h = new utils.Decimal(est_funding_rate || 0).mul(funding_period).div(8).toNumber();
+  }
+  return funding8h;
+}
+function get24hChange2(close, open) {
+  if (close !== void 0 && open !== void 0) {
+    if (open === 0) {
+      return 0;
+    }
+    return new utils.Decimal(close).minus(open).div(open).toNumber();
+  }
+}
+var useMarkPriceStore = zustand.create((set, get3) => ({
+  markPrices: {},
+  // orderBook: {},
+  // ask_bid: [],
+  actions: {
+    updateMarkPrice: (markPrice) => {
+      set({
+        markPrices: markPrice
+      });
+    },
+    getMarkPriceBySymbol: (symbol) => {
+      return get3().markPrices[symbol];
+    }
+  }
+}));
+var useMarkPriceBySymbol = (symbol) => useMarkPriceStore((state) => state.actions.getMarkPriceBySymbol(symbol));
+var useMarkPriceActions = () => useMarkPriceStore((state) => state.actions);
+
+// src/orderly/useMarkPricesStream.ts
+var useMarkPricesStream = () => {
+  const data = useMarkPriceStore((state) => state.markPrices);
+  return { data };
+};
+var useIndexPriceStore = zustand.create((set) => ({
+  indexPrices: {},
+  actions: {
+    updateIndexPrice: (indexPrice) => {
+      set({
+        indexPrices: indexPrice
       });
-      setSortedData(sortedData2);
     }
-  }, [data]);
-  const sortBy = React2.useCallback((key) => {
-  }, [data]);
-  const filterBy = React2.useCallback((key) => {
-  }, [data]);
+  }
+}));
+
+// src/orderly/useIndexPricesStream.ts
+var useIndexPricesStream = () => {
+  const indexPrices = useIndexPriceStore((state) => state.indexPrices);
+  const getIndexPrice = (token) => {
+    if (token === "USDC") {
+      return 1;
+    }
+    return indexPrices[`PERP_${token}_USDC`] ?? 0;
+  };
   return {
-    data: sortedData,
-    sortBy,
-    filterBy,
-    isLoading,
-    error
+    data: indexPrices,
+    getIndexPrice: useMemoizedFn(getIndexPrice)
   };
 };
-
-// src/orderly/useTickerStream.ts
-var useTickerStream = (symbol) => {
-  if (!symbol) {
-    throw new types.SDKError("Symbol is required");
+var generateLeverageLevers = (max2) => {
+  const min2 = 1;
+  const parts = 5;
+  const step = (max2 - min2) / (parts - 1);
+  const result = [];
+  for (let i = 0; i < parts; i++) {
+    result.push(Math.floor(min2 + step * i));
   }
-  const { data: info } = useQuery(
-    `/v1/public/futures/${symbol}`,
+  return result;
+};
+var useLeverage = () => {
+  const { data, mutate: mutate6 } = usePrivateQuery(
+    "/v1/client/info",
     {
       revalidateOnFocus: false
     }
   );
-  const [ticker, setTicker] = React2.useState();
-  const ws = useWS();
-  React2.useEffect(() => {
-    const unsubscribe = ws.subscribe(
-      // { event: "subscribe", topic: "markprices" },
-      `${symbol}@ticker`,
-      {
-        onMessage: (message) => {
-          if (message.symbol !== symbol)
-            return;
-          setTicker(message);
-        }
-        // onUnsubscribe: () => {
-        //   return "markprices";
-        // },
-        // onError: (error: any) => {
-        //
-        // },
+  const [update, { isMutating }] = useMutation("/v1/client/leverage");
+  const { data: leverageConfig, isLoading } = useQuery("/v1/public/leverage", {
+    revalidateOnFocus: false,
+    errorRetryCount: 3
+    // formatter: (data) => data,
+  });
+  const updateLeverage = React2.useCallback(
+    async (data2) => {
+      const res = await update(data2);
+      if (res.success) {
+        return mutate6();
+      } else {
+        throw new Error(res.message);
       }
-    );
-    return () => {
-      setTicker(void 0);
-      unsubscribe?.();
-    };
-  }, [symbol]);
-  const { data: markPrice } = useMarkPrice(symbol);
-  const { data: indexPrice } = useIndexPrice(symbol);
-  const { data: openInterest } = useOpenInterest(symbol);
-  const { data: futures } = useFutures();
-  const value = React2.useMemo(() => {
-    if (!info)
-      return null;
-    if (!ticker || ticker.symbol !== symbol)
-      return info;
-    const futureIndex = futures?.findIndex(
-      (item) => item.symbol === symbol
-    );
-    let _oi = openInterest;
-    if (!_oi && futureIndex !== -1 && futures) {
-      _oi = futures[futureIndex].open_interest;
-    }
-    const config = {
-      ...info,
-      mark_price: markPrice,
-      index_price: indexPrice,
-      open_interest: _oi
-    };
-    if (ticker.open !== void 0) {
-      config["24h_open"] = ticker.open;
-    }
-    if (ticker.close !== void 0) {
-      config["24h_close"] = ticker.close;
-    }
-    if (ticker.high !== void 0) {
-      config["24h_high"] = ticker.high;
-    }
-    if (ticker.low !== void 0) {
-      config["24h_low"] = ticker.low;
-    }
-    if (ticker.volume !== void 0) {
-      config["24h_volumn"] = ticker.volume;
-      config["24h_volume"] = ticker.volume;
+    },
+    [update, mutate6]
+  );
+  const memoizedCurLeverage = React2.useMemo(() => {
+    if (data?.max_leverage !== void 0) {
+      return Number(data.max_leverage);
     }
-    if (ticker.close !== void 0 && ticker.open !== void 0) {
-      config["change"] = new utils.Decimal(ticker.close).minus(ticker.open).div(ticker.open).toNumber();
-      config["24h_change"] = new utils.Decimal(ticker.close).minus(ticker.open).toNumber();
+    return 1;
+  }, [data?.max_leverage]);
+  const memoizedMaxLeverage = React2.useMemo(() => {
+    if (leverageConfig?.max_futures_leverage !== void 0) {
+      return Number(leverageConfig.max_futures_leverage);
     }
-    return config;
-  }, [info, symbol, ticker, futures, openInterest]);
-  return value;
+    return 1;
+  }, [leverageConfig?.max_futures_leverage]);
+  const memoizedLeverageLevers = React2.useMemo(() => {
+    return generateLeverageLevers(memoizedMaxLeverage);
+  }, [memoizedMaxLeverage]);
+  return {
+    update: updateLeverage,
+    isLoading: isLoading || isMutating,
+    leverageLevers: memoizedLeverageLevers,
+    curLeverage: memoizedCurLeverage,
+    maxLeverage: memoizedMaxLeverage
+  };
 };
 
-// src/orderly/useOrderbookStream.ts
-var paddingFn = (len) => Array(len).fill([Number.NaN, Number.NaN, Number.NaN, Number.NaN]);
-var isNumber = (val) => {
-  return typeof val === "number" && !Number.isNaN(val);
-};
-var getPriceKey = (rawPrice, depth, isAsks) => {
-  return new utils.Decimal(rawPrice).div(depth).toDecimalPlaces(0, isAsks ? utils.Decimal.ROUND_CEIL : utils.Decimal.ROUND_FLOOR).mul(depth).toNumber();
+// src/orderly/useOdosQuote.ts
+var useOdosQuote = () => {
+  return useMutation(`https://api.odos.xyz/sor/quote/v2`);
 };
-var reduceItems = (depth, data, isAsks) => {
-  if (!Array.isArray(data) || data.length === 0) {
-    return [];
-  }
-  let newData = [...data];
-  const result = [];
-  if (typeof depth !== "undefined") {
-    const pricesMap = /* @__PURE__ */ new Map();
-    const len = data.length;
-    for (let i = 0; i < len; i++) {
-      const [rawPrice, quantity] = data[i];
-      if (!isNumber(rawPrice) || !isNumber(quantity)) {
-        continue;
-      }
-      const priceKey = getPriceKey(rawPrice, depth, isAsks);
-      const amtByRaw = new utils.Decimal(rawPrice).mul(quantity).toNumber();
-      if (pricesMap.has(priceKey)) {
-        const item = pricesMap.get(priceKey);
-        const sumQty = new utils.Decimal(item[1]).add(quantity).toNumber();
-        const sumAmtByRaw = new utils.Decimal(item[2] ?? 0).add(amtByRaw).toNumber();
-        pricesMap.set(priceKey, [priceKey, sumQty, sumAmtByRaw]);
-      } else {
-        pricesMap.set(priceKey, [priceKey, quantity, amtByRaw]);
-      }
-    }
-    newData = Array.from(pricesMap.values());
-  }
-  for (let i = 0; i < newData.length; i++) {
-    const [price, quantity, sumAmtByRaw] = newData[i];
-    if (!isNumber(price) || !isNumber(quantity)) {
-      continue;
+var useTokensInfoStore = zustand.create(
+  (set) => ({
+    tokensInfo: [],
+    setTokensInfo(data) {
+      set({ tokensInfo: data });
     }
-    const resLen = result.length;
-    const newQuantity = new utils.Decimal(quantity).add(resLen ? result[resLen - 1][2] : 0).toNumber();
-    const pieceAmount = isNumber(sumAmtByRaw) ? sumAmtByRaw : new utils.Decimal(quantity).mul(price).toNumber();
-    const newAmount = new utils.Decimal(pieceAmount).add(resLen ? result[resLen - 1][3] : 0).toNumber();
-    result.push([price, quantity, newQuantity, newAmount]);
-  }
-  return result;
+  })
+);
+var useTokensInfo = () => {
+  const tokensInfo = useTokensInfoStore((state) => state.tokensInfo);
+  return tokensInfo;
 };
-var reduceOrderbook = (depth, level, padding, data) => {
-  let asks = reduceItems(depth, data.asks, true);
-  let bids = reduceItems(depth, data.bids, false);
-  if (asks.length !== 0 && bids.length !== 0 && asks[0][0] <= bids[0][0]) {
-    if (asks.length === 1) {
-      const [price, qty, newQuantity, newAmount] = asks[0];
-      asks.shift();
-      asks.push([
-        price + (depth === void 0 ? 0 : Number(depth)),
-        qty,
-        newQuantity,
-        newAmount
-      ]);
-    } else {
-      const [bidPrice] = bids[0];
-      while (asks.length > 0) {
-        const [askPrice, askQty, newQuantity, newAmount] = asks[0];
-        if (askPrice <= bidPrice) {
-          asks.shift();
-          for (let i = 0; i < asks.length; i++) {
-            if (i === 0) {
-              const quantity = new utils.Decimal(asks[i][1]).add(askQty);
-              asks[i][1] = quantity.toNumber();
-              asks[i][2] = quantity.toNumber();
-              asks[i][3] = quantity.toDecimalPlaces(0, utils.Decimal.ROUND_CEIL).mul(asks[i][0]).toNumber();
-            } else {
-              asks[i][3] = new utils.Decimal(asks[i][0]).mul(asks[i][1]).add(asks[i - 1][3]).toNumber();
-            }
-          }
-        } else {
-          break;
-        }
-      }
+var useTokenInfo = (token) => {
+  const tokensInfo = useTokensInfo();
+  return React2.useMemo(() => {
+    return tokensInfo?.find((item) => item.token === token);
+  }, [tokensInfo, token]);
+};
+
+// src/orderly/useComputedLTV.ts
+var { LTV, collateralRatio } = perp.account;
+var useComputedLTV = (options = {}) => {
+  const { input, token } = options;
+  const isUSDC = token?.toUpperCase() === "USDC";
+  const tokensInfo = useTokensInfo();
+  const { usdc, data: holdingList = [] } = useHoldingStream();
+  const { getIndexPrice } = useIndexPricesStream();
+  const { unsettledPnL } = useCollateral();
+  const usdcBalance = React2.useMemo(() => {
+    if (isUSDC && input) {
+      return new utils.Decimal(usdc?.holding ?? 0).add(input).toNumber();
     }
+    return usdc?.holding ?? 0;
+  }, [usdc?.holding, input, isUSDC]);
+  const getAdjustedQty = React2.useCallback(
+    (item) => {
+      if (input && item.token === token) {
+        return new utils.Decimal(item?.holding ?? 0).add(input).toNumber();
+      }
+      return item?.holding ?? 0;
+    },
+    [input, token]
+  );
+  const memoizedLTV = React2.useMemo(() => {
+    return LTV({
+      usdcBalance,
+      upnl: unsettledPnL,
+      assets: holdingList.filter((h) => h.token.toUpperCase() !== "USDC").map((item) => {
+        const indexPrice = getIndexPrice(item.token);
+        const findToken = tokensInfo?.find((i) => i.token === item.token);
+        const qty = getAdjustedQty(item);
+        const weight = collateralRatio({
+          baseWeight: findToken?.base_weight ?? 0,
+          discountFactor: findToken?.discount_factor ?? 0,
+          collateralCap: findToken?.user_max_qty ?? qty,
+          collateralQty: qty,
+          indexPrice
+        });
+        return {
+          qty,
+          indexPrice,
+          weight: weight.toNumber()
+        };
+      })
+    });
+  }, [
+    usdcBalance,
+    unsettledPnL,
+    holdingList,
+    tokensInfo,
+    getIndexPrice,
+    getAdjustedQty
+  ]);
+  if (new utils.Decimal(usdcBalance).add(new utils.Decimal(unsettledPnL)).gte(utils.zero)) {
+    return 0;
   }
-  asks = asks.reverse();
-  if (padding) {
-    asks = asks.length < level ? paddingFn(level - asks.length).concat(asks) : asks;
-    bids = bids.length < level ? bids.concat(paddingFn(level - bids.length)) : bids;
-  }
-  return {
-    asks,
-    bids
-  };
-};
-var ORDERLY_ORDERBOOK_DEPTH_KEY = "orderly_orderbook_depth_key";
-var INIT_DATA = {
-  asks: [],
-  bids: []
+  return new utils.Decimal(memoizedLTV).mul(100).toDecimalPlaces(2, utils.Decimal.ROUND_DOWN).toNumber();
 };
-var useOrderbookStream = (symbol, initial = INIT_DATA, options) => {
+var useFundingRate = (symbol) => {
   if (!symbol) {
     throw new types.SDKError("Symbol is required");
   }
-  const level = options?.level ?? 10;
-  const padding = options?.padding ?? true;
-  const symbolRef = React2.useRef(symbol);
-  symbolRef.current = symbol;
-  const {
-    defaultOrderbookTickSizes: DEFAULT_TICK_SIZES2 = {},
-    defaultOrderbookSymbolDepths: DEFAULT_SYMBOL_DEPTHS2 = {}
-  } = React2.useContext(OrderlyContext);
-  const [data, setData] = React2.useState(initial);
-  const [isLoading, setIsLoading] = React2.useState(true);
-  const config = useSymbolsInfo()[symbol];
-  const [depthObject, setDepthObject] = useLocalStorage(
-    ORDERLY_ORDERBOOK_DEPTH_KEY,
-    {}
-  );
-  const prevMiddlePrice = React2.useRef(0);
-  const tick = config("quote_tick");
-  const depths = React2.useMemo(() => {
-    if (DEFAULT_SYMBOL_DEPTHS2[symbol]) {
-      return DEFAULT_SYMBOL_DEPTHS2[symbol];
-    }
-    if (typeof tick === "undefined") {
-      return [];
-    }
-    try {
-      const base = new utils.Decimal(tick);
-      return [
-        base.toNumber(),
-        base.mul(10).toNumber(),
-        base.mul(100).toNumber(),
-        base.mul(1e3).toNumber()
-      ];
-    } catch {
+  const [countDown, setCountDown] = React2.useState("00:00:00");
+  const timerRef = React2.useRef(null);
+  const { data, isLoading } = useQuery(
+    `/v1/public/funding_rate/${symbol}`,
+    {
+      fallbackData: {
+        est_funding_rate: 0,
+        next_funing_time: 0
+      }
     }
-    return [tick];
-  }, [symbol, tick]);
+  );
   React2.useEffect(() => {
-    if (depthObject[symbol]) {
+    if (!data || isLoading) {
       return;
     }
-    if (DEFAULT_TICK_SIZES2[symbol]) {
-      setDepthObject((prev) => ({
-        ...prev,
-        [symbol]: Number(DEFAULT_TICK_SIZES2[symbol])
-      }));
-    } else {
-      setDepthObject((prev) => ({
-        ...prev,
-        [symbol]: tick
-      }));
+    const { next_funding_time } = data;
+    if (!next_funding_time || next_funding_time <= 0) {
+      return;
     }
-  }, [depthObject, tick, symbol, DEFAULT_TICK_SIZES2]);
-  const onDepthChange = React2.useCallback(
-    (val) => {
-      setDepthObject((prev) => ({ ...prev, [symbol]: val }));
-    },
-    [symbol]
-  );
-  const ws = useWS();
-  const ticker = useTickerStream(symbol);
-  const eventEmitter = useEventEmitter();
-  React2.useEffect(() => {
-    let needRequestFullOrderbook = true;
-    setIsLoading(true);
-    let fullOrderBookUpdateSub;
-    const orderBookUpdateSub = ws.subscribe(
-      {
-        event: "subscribe",
-        topic: `${symbol}@orderbookupdate`
-      },
-      {
-        formatter: (message) => message,
-        onMessage: (message) => {
-          const { data: wsData, ts } = message;
-          const { symbol: symbol2, asks, bids, prevTs } = wsData;
-          if (symbolRef.current !== symbol2) {
-            orderBookUpdateSub?.();
-            return;
-          }
-          orderbook_service_default.updateOrderbook(
-            symbol2,
-            { asks, bids, ts, prevTs },
-            () => {
-              needRequestFullOrderbook = true;
-            }
-          );
-          const data2 = orderbook_service_default.getRawOrderbook(symbol2);
-          setData({ bids: data2.bids, asks: data2.asks });
+    timerRef.current = setInterval(() => {
+      const diff = new Date(next_funding_time).getTime() - utils.getTimestamp();
+      if (diff <= 0) {
+        setCountDown("00:00:00");
+        if (timerRef.current) {
+          clearInterval(timerRef.current);
         }
+        return;
+      }
+      const result = utils.timeConvertString(diff);
+      if (result.length === 3) {
+        setCountDown(
+          `${result[0].toString().padStart(2, "0")}:${result[1].toString().padStart(2, "0")}:${result[2].toString().padStart(2, "0")}`
+        );
+      }
+    }, 1e3);
+    return () => {
+      if (timerRef.current) {
+        clearInterval(timerRef.current);
       }
+    };
+  }, [data, isLoading]);
+  const est_funding_rate = React2.useMemo(() => {
+    if (!data) {
+      return;
+    }
+    const { next_funding_time, est_funding_rate: est_funding_rate2 = 0 } = data;
+    if (utils.getTimestamp() > next_funding_time) {
+      return null;
+    }
+    return new utils.Decimal(Number(est_funding_rate2) * 100).toFixed(
+      4,
+      utils.Decimal.ROUND_DOWN
     );
-    if (needRequestFullOrderbook) {
-      setIsLoading(true);
-      fullOrderBookUpdateSub = ws.onceSubscribe(
-        {
-          event: "request",
-          id: `${symbol}@orderbook`,
-          params: {
-            type: "orderbook",
-            symbol
-          }
+  }, [data]);
+  return {
+    ...data,
+    est_funding_rate,
+    countDown
+  };
+};
+var useFundingDetails = (symbol) => {
+  if (!symbol) {
+    throw new types.SDKError("symbol is required");
+  }
+  return useQuery(`/v1/public/info/${symbol}`, {
+    errorRetryCount: 3,
+    revalidateOnFocus: false
+  });
+};
+var calculatePositiveRate = (periodData, period) => {
+  if (!periodData || !period) {
+    return 0;
+  }
+  const daysMap = {
+    "1d": 1,
+    "3d": 3,
+    "7d": 7,
+    "14d": 14,
+    "30d": 30,
+    "90d": 90
+  };
+  const totalTimes = daysMap[period] * 3;
+  return periodData.positive / totalTimes;
+};
+var useFundingRateHistory = () => {
+  const { data: historyData, isLoading } = useQuery(
+    "/v1/public/market_info/funding_history"
+  );
+  const getPositiveRates = React2.useCallback(
+    (data, period) => {
+      if (!data?.length) {
+        return {};
+      }
+      return data.reduce(
+        (acc, item) => {
+          acc[item.symbol] = calculatePositiveRate(
+            item.funding[period],
+            period
+          );
+          return acc;
         },
-        {
-          formatter: (message) => message,
-          onMessage: (message) => {
-            const { symbol: symbol2, asks, bids, ts } = message.data;
-            if (symbolRef.current !== symbol2) {
-              return;
-            }
-            orderbook_service_default.setFullOrderbook(symbol2, { asks, bids, ts });
-            const data2 = orderbook_service_default.getRawOrderbook(symbol2);
-            setData({ bids: data2.bids, asks: data2.asks });
-            setIsLoading(false);
-          }
-        }
+        {}
       );
-      needRequestFullOrderbook = false;
-    }
-    return () => {
-      orderBookUpdateSub?.();
-      fullOrderBookUpdateSub?.();
-      orderbook_service_default.resetOrderBook(symbol);
-      setData(INIT_DATA);
-    };
-  }, [symbol]);
-  const { data: markPrice } = useMarkPrice(symbol);
-  const onItemClick = React2.useCallback((item) => {
-    eventEmitter.emit("orderbook:item:click", item);
-  }, []);
-  const reducedData = reduceOrderbook(depthObject[symbol], level, padding, {
-    asks: data.asks,
-    bids: data.bids
-  });
-  React2.useEffect(() => {
-    eventEmitter.emit("orderbook:update", reducedData);
-  }, [reducedData]);
-  const middlePrice = React2.useMemo(() => {
-    let asksFrist = 0;
-    let bidsFirst = 0;
-    if (data.asks.length > 0) {
-      asksFrist = reducedData.asks?.[reducedData.asks.length - 1]?.[0];
-    }
-    if (data.bids.length > 0) {
-      bidsFirst = data.bids[0][0];
-    }
-    if (!isNumber(asksFrist) || !isNumber(bidsFirst) || !ticker) {
-      return 0;
-    }
-    return [asksFrist, bidsFirst, ticker["24h_close"]].sort()[1];
-  }, [ticker?.["24h_close"], data]);
-  React2.useEffect(() => {
-    prevMiddlePrice.current = middlePrice;
-  }, [middlePrice]);
-  return [
-    {
-      asks: reducedData.asks.slice(-level),
-      bids: reducedData.bids.slice(0, level),
-      markPrice,
-      middlePrice: [prevMiddlePrice.current, middlePrice]
     },
-    {
-      onDepthChange,
-      depth: depthObject[symbol],
-      allDepths: depths,
+    []
+  );
+  return React2.useMemo(() => {
+    return {
+      data: historyData ?? types.EMPTY_LIST,
       isLoading,
-      onItemClick
-    }
-  ];
+      getPositiveRates
+    };
+  }, [historyData, isLoading, getPositiveRates]);
 };
-var useSymbolInfo = (symbol) => {
-  const infos = useSymbolsInfo();
-  return React2.useMemo(() => {
-    return !symbol || infos.isNil ? null : infos[symbol];
-  }, [infos, symbol]);
+var useApiStatusStore = zustand.create()(
+  immer.immer((set) => ({
+    apis: {
+      positions: {
+        loading: false
+      }
+    },
+    actions: {
+      updateStatus: (key, status) => {
+        set((state) => {
+          state.apis[key] = status;
+        });
+      },
+      updateApiLoading: (key, loading) => {
+        set((state) => {
+          state.apis[key].loading = loading;
+        });
+      },
+      updateApiError: (key, error) => {
+        set((state) => {
+          state.apis[key] = {
+            loading: false,
+            error
+          };
+        });
+      }
+    }
+  }))
+);
+var useApiStatusActions = () => useApiStatusStore((state) => state.actions);
+
+// src/orderly/calculator/baseCalculator.ts
+var BaseCalculator = class {
+  cache(data) {
+    this._cache = data;
+  }
 };
-var useFundingRates = () => {
-  const data = useAppStore((state) => state.fundingRates);
-  return createGetter({ ...data });
+
+// src/orderly/calculator/markPrice.ts
+var MarketCalculatorName = "markPriceCalculator";
+var MarkPriceCalculator = class extends BaseCalculator {
+  constructor() {
+    super(...arguments);
+    this.name = MarketCalculatorName;
+  }
+  calc(scope, data, ctx) {
+    return data;
+  }
+  update(data, scope) {
+    useMarkPriceStore.getState().actions.updateMarkPrice(data);
+  }
 };
-var useFundingRatesStore = () => {
-  const data = useAppStore((state) => state.fundingRates);
-  return data;
+
+// src/orderly/calculator/calculatorContext.ts
+var CalculatorContext = class _CalculatorContext {
+  static get instance() {
+    return this._instance;
+  }
+  static create(scope, data) {
+    if (!this._instance) {
+      this._instance = new _CalculatorContext(scope, data);
+    }
+    return this._instance.update(scope, data);
+  }
+  constructor(scope, data) {
+    this.setCtxData();
+    this.output = {
+      // rows: positions,
+    };
+  }
+  update(scope, data) {
+    this.setCtxData();
+    this.markPrices = scope === "markPrice" /* MARK_PRICE */ ? data : this.output[MarketCalculatorName];
+    this.portfolio = this.output["portfolio"] || useAppStore.getState().portfolio;
+    return this;
+  }
+  setCtxData() {
+    this.accountInfo = useAppStore.getState().accountInfo;
+    this.symbolsInfo = useAppStore.getState().symbolsInfo;
+    this.fundingRates = useAppStore.getState().fundingRates;
+    this.tokensInfo = useTokensInfoStore.getState().tokensInfo;
+  }
+  get(fn) {
+    return fn(this.output);
+  }
+  getCacheValue(name, fallback) {
+    return this.output[name] || fallback();
+  }
+  clearCache() {
+    this.output = {};
+    this.accountInfo = void 0;
+    this.portfolio = void 0;
+  }
+  deleteByName(name) {
+    delete this.output[name];
+  }
+  // get positions(): API.PositionTPSLExt[] {
+  //   if (this.output.positionCalculator) return this.output.positionCalculator;
+  //   return usePositionStore.getState().positions;
+  // }
+  get isReady() {
+    return !!this.accountInfo;
+  }
+  saveOutput(name, data) {
+    this.output[name] = data;
+  }
+  outputToValue() {
+    return this.output;
+  }
 };
 
-// src/orderly/useMarket.ts
-var DefaultTab = { name: "Popular", id: 1 };
-var marketsKey = "markets";
-var useMarket = (type) => {
-  const { configStore } = React2.useContext(OrderlyContext);
-  const symbolsInfo = useSymbolsInfo();
-  const fundingRates = useFundingRates();
-  const { data: futures } = useMarketsStream();
-  const updateStore = (key, data) => {
-    configStore.set(marketsKey, {
-      ...configStore.getOr(marketsKey, {}),
-      [key]: data
-    });
-  };
-  const getStore = (key, defaultValue) => {
-    return configStore.get(marketsKey)[key] || defaultValue;
-  };
-  if (!configStore.get(marketsKey)) {
-    const jsonStr = localStorage.getItem(marketsKey);
-    if (jsonStr) {
-      configStore.set(marketsKey, JSON.parse(jsonStr));
+// src/orderly/calculator/calculatorService.ts
+var CalculatorService = class {
+  constructor(scheduler, calculators) {
+    this.scheduler = scheduler;
+    this.pendingCalc = [];
+    this.calcQueue = [];
+    /**
+     * Reference count for each calculator, used to determine if a calculator is still in use.
+     */
+    this.referenceCount = /* @__PURE__ */ new Map();
+    this.isPaused = false;
+    this.calculators = new Map(calculators);
+  }
+  register(scope, calculator) {
+    const ref_count_name = `${scope}_${calculator.name}`;
+    const count = this.referenceCount.get(ref_count_name);
+    if (typeof count !== "undefined" && count > 0) {
+      this.referenceCount.set(ref_count_name, count + 1);
+      return;
+    }
+    const calculators = this.calculators.get(scope);
+    if (Array.isArray(calculators)) {
+      calculators.push(calculator);
     } else {
-      configStore.set(marketsKey, {
-        recent: [],
-        favorites: [
-          { name: "PERP_ETH_USDC", tabs: [{ ...DefaultTab }] },
-          { name: "PERP_BTC_USDC", tabs: [{ ...DefaultTab }] }
-        ],
-        favoriteTabs: [{ ...DefaultTab }],
-        lastSelectedFavoriteTab: { ...DefaultTab }
-      });
+      this.calculators.set(scope, [calculator]);
+    }
+    this.referenceCount.set(ref_count_name, 1);
+  }
+  unregister(scope, calculator) {
+    const ref_count_name = `${scope}_${calculator.name}`;
+    const count = this.referenceCount.get(ref_count_name);
+    if (typeof count !== "undefined" && count > 1) {
+      this.referenceCount.set(ref_count_name, count - 1);
+      return;
+    }
+    const calculators = this.calculators.get(scope);
+    if (Array.isArray(calculators)) {
+      const index = calculators.findIndex((c) => c.name === calculator.name);
+      if (index > -1) {
+        calculators[index].destroy?.();
+        calculators.splice(index, 1);
+      }
     }
+    this.referenceCount.delete(ref_count_name);
   }
-  const getFavoriteTabs = React2.useMemo(() => {
-    return getStore("favoriteTabs", [{ ...DefaultTab }]);
-  }, []);
-  const getFavorites = React2.useMemo(() => {
-    const curData = getStore("favorites", []);
-    const tabs = getFavoriteTabs;
-    const result = [];
-    const len = curData.length;
-    for (let index = 0; index < len; index++) {
-      const favData = curData[index];
-      const favTabs = favData.tabs.filter(
-        (tab) => tabs.findIndex((item) => tab.id === item.id) !== -1
-      );
-      if (favTabs.length) {
-        result.push({ ...favData, tabs: favTabs });
-      }
+  async calc(scope, data, options) {
+    if (scope !== "position" /* POSITION */) {
+      if (!options?.skipWhenOnPause) ;
     }
-    updateStore("favorites", result);
-    return result;
-  }, [configStore]);
-  const [favoriteTabs, setFavoriteTabs] = React2.useState(getFavoriteTabs);
-  const [favorites, setFavorites] = React2.useState(getFavorites);
-  const [recent, setRecent] = React2.useState(
-    getStore("recent", []).filter((e) => e)
-  );
-  const [tabSort, setTabSort] = React2.useState(
-    getStore("tabSort", {})
-  );
-  const updateFavoriteTabs = (tab, operator) => {
-    const saveTabs = (tabs2) => {
-      setFavoriteTabs(tabs2);
-      updateStore("favoriteTabs", tabs2);
-    };
-    if (Array.isArray(tab)) {
-      saveTabs(tab);
+    const ctx = CalculatorContext.create(scope, data);
+    if (!ctx.isReady && options?.skipPending) {
       return;
     }
-    const tabs = [...favoriteTabs];
-    const index = tabs.findIndex((item) => item.id === tab.id);
-    if (operator?.add) {
-      tabs.push(tab);
-    } else if (operator?.update) {
-      if (index !== -1) {
-        tabs[index] = tab;
+    if (options?.skipWhenOnPause && !this.windowIsVisible)
+      return;
+    this.calcQueue.push({ scope, data, options });
+    await this.handleCalcQueue(ctx);
+    this.ctx = ctx;
+  }
+  // private async handlePendingCalc() {
+  //   // console.log("[handlePendingCalc]:", this.pendingCalc);
+  //   if (this.pendingCalc.length === 0) return;
+  //   this.calcQueue = [...this.pendingCalc, ...this.calcQueue];
+  //   this.pendingCalc = [];
+  // }
+  async handleCalcQueue(context) {
+    const first = this.calcQueue.shift();
+    if (first) {
+      const { scope, data, options } = first;
+      const ctx = context || CalculatorContext.create(scope, data);
+      const calculators = this.calculators.get(scope);
+      if (Array.isArray(calculators) && calculators.length) {
+        try {
+          await this.scheduler.calc(scope, calculators, data, ctx);
+        } catch (e) {
+        }
+        if (!options?.skipUpdate) {
+          this.scheduler.update(scope, calculators, ctx.outputToValue());
+        }
       }
-    } else if (operator?.delete) {
-      if (index !== -1) {
-        tabs.splice(index, 1);
+      if (this.calcQueue.length) {
+        this.handleCalcQueue(ctx);
       }
     }
-    saveTabs(tabs);
-  };
-  const updateFavorites = (favorites2) => {
-    updateStore("favorites", favorites2);
-    setFavorites(favorites2);
-  };
-  const addToHistory = (symbol) => {
-    const curData = [...recent];
-    const index = curData.findIndex((item) => item.name == symbol.symbol);
-    if (index !== -1) {
-      curData.splice(index, 1);
+  }
+  stop() {
+    this.calcQueue = [];
+    this.ctx?.clearCache();
+  }
+  get windowIsVisible() {
+    if (typeof document === "undefined") {
+      return true;
     }
-    curData.unshift({ name: symbol.symbol });
-    updateStore("recent", curData);
-    setRecent(curData);
-  };
-  const updateSymbolFavoriteState = (symbol, tab, remove = false) => {
-    const curData = [...favorites];
-    const index = curData.findIndex((item) => item.name == symbol.symbol);
-    if (index === -1) {
-      if (Array.isArray(tab)) {
-        if (tab.length > 0) {
-          curData.unshift({ name: symbol.symbol, tabs: tab });
-        }
-      } else {
-        if (!remove) {
-          curData.unshift({ name: symbol.symbol, tabs: [tab] });
-        }
+    return document.visibilityState === "visible";
+  }
+};
+var CalculatorServiceID = "CalculatorService";
+
+// src/orderly/calculator/shardedScheduler.ts
+var requestIdleCallbackPolyfill = (callback, options) => {
+  const startTime = Date.now();
+  return setTimeout(() => {
+    callback({
+      didTimeout: false,
+      timeRemaining: () => Math.max(0, 50 - (Date.now() - startTime))
+    });
+  }, 1);
+};
+var cancelIdleCallbackPolyfill = (id) => {
+  clearTimeout(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 {
+  // run(calculators: Calculator[]) {}
+  calc(scope, calculators, data, ctx) {
+    return new Promise((resolve, reject) => {
+      try {
+        this.computation(
+          calculators,
+          (shard) => {
+            const results = [];
+            for (let index = 0; index < shard.length; index++) {
+              const calculator = shard[index];
+              const result = calculator.calc(scope, data, ctx);
+              if (result) {
+                ctx.saveOutput(calculator.name, result);
+                results.push(result);
+              }
+            }
+            return results;
+          },
+          (results) => {
+            resolve(results);
+          }
+        );
+      } catch (error) {
+        reject(error);
       }
-    } else {
-      const favorite = curData[index];
-      if (Array.isArray(tab)) {
-        if (tab.length === 0) {
-          curData.splice(index, 1);
+    });
+  }
+  update(scope, calculators, data) {
+    for (let index = 0; index < calculators.length; index++) {
+      const calculator = calculators[index];
+      const item = data[calculator.name];
+      if (!!item) {
+        calculator.update(item, scope);
+      }
+    }
+    return Promise.resolve();
+  }
+  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 {
-          curData[index] = { ...favorite, tabs: tab };
+          shardSize = Math.min(data.length - index, shardSize * 2);
         }
+      }
+      if (index < data.length) {
+        safeRequestIdleCallback(processNextShard, {
+          timeout: 1e3
+        });
       } else {
-        if (remove) {
-          const tabs = favorite.tabs.filter((item) => item.id != tab.id);
-          if (tabs.length === 0) {
-            curData.splice(index, 1);
-          } else {
-            curData[index] = { ...favorite, tabs };
-          }
-        } else {
-          const tabs = favorite.tabs;
-          tabs.push(tab);
-          curData[index] = { ...favorite, tabs };
-        }
+        onComplete(results.flat());
+      }
+    }
+    safeRequestIdleCallback(processNextShard, {
+      timeout: 1e3
+    });
+  }
+};
+var POSITION_EMPTY = {
+  rows: null,
+  margin_ratio: 0,
+  initial_margin_ratio: 0,
+  maintenance_margin_ratio: 0,
+  open_margin_ratio: 0,
+  current_margin_ratio_with_orders: 0,
+  initial_margin_ratio_with_orders: 0,
+  maintenance_margin_ratio_with_orders: 0,
+  total_collateral_value: 0,
+  free_collateral: 0,
+  total_pnl_24_h: 0,
+  unrealPnL: 0,
+  total_unreal_pnl: 0,
+  unsettledPnL: 0,
+  total_unsettled_pnl: 0,
+  notional: 0,
+  unrealPnlROI: 0
+};
+var usePositionStore = zustand.create()(
+  immer.immer((set) => ({
+    positions: {
+      all: POSITION_EMPTY
+    },
+    actions: {
+      setPositions: (key, positions3) => {
+        set((state) => {
+          state.positions[key] = positions3;
+        });
+      },
+      closePosition: (symbol) => {
+        set((state) => {
+          delete state.positions[symbol];
+        });
+      },
+      clearAll: () => {
+        set((state) => {
+          state.positions = {
+            all: POSITION_EMPTY
+          };
+        });
       }
     }
-    updateStore("favorites", curData);
-    setFavorites(() => curData);
-  };
-  const marketsList = React2.useMemo(() => {
-    const list = futures?.map((item) => {
-      const { open_interest = 0, index_price = 0 } = item;
+  }))
+);
+var usePositions = (symbol = "all") => usePositionStore((state) => (state.positions[symbol] ?? POSITION_EMPTY).rows);
+var usePositionActions = () => usePositionStore((state) => state.actions);
+
+// src/orderly/calculator/positions.ts
+var NAME_PREFIX = "positionCalculator";
+var AllPositions = "all";
+var PositionCalculator = class extends BaseCalculator {
+  // private id: string;
+  constructor(symbol = AllPositions) {
+    super();
+    this.name = `${NAME_PREFIX}_${symbol}`;
+    this.symbol = symbol;
+  }
+  calc(scope, data, ctx) {
+    if (scope === "markPrice" /* MARK_PRICE */) {
+      return this.calcByMarkPrice(data, ctx);
+    }
+    if (scope === "indexPrice" /* INDEX_PRICE */) {
+      return this.calcByIndexPrice(data, ctx);
+    }
+    if (scope === "position" /* POSITION */) {
+      return this.calcByPosition(
+        this.preprocess(data),
+        ctx
+      );
+    }
+    return data;
+  }
+  update(data, scope) {
+    if (!data || !Array.isArray(data.rows))
+      return;
+    usePositionStore.getState().actions.setPositions(this.symbol, data);
+    if (Array.isArray(data.rows) && useApiStatusStore.getState().apis.positions.loading) {
+      useApiStatusStore.getState().actions.updateApiLoading("positions", false);
+    }
+  }
+  calcByMarkPrice(markPrice, ctx) {
+    let positions3 = this.getPosition(markPrice, ctx);
+    useAppStore.getState().fundingRates;
+    if (!positions3 || !Array.isArray(positions3.rows) || !positions3.rows.length)
+      return positions3;
+    positions3 = {
+      ...positions3,
+      rows: positions3.rows.map((item) => {
+        return {
+          ...item,
+          mark_price: markPrice[item.symbol] || item.mark_price
+        };
+      })
+    };
+    return this.format(positions3, ctx);
+  }
+  calcByIndexPrice(indexPrice, ctx) {
+    let positions3 = this.getPosition(indexPrice, ctx);
+    if (!positions3) {
+      return positions3;
+    }
+    if (!Array.isArray(positions3.rows) || !positions3.rows.length)
+      return positions3;
+    positions3 = {
+      ...positions3,
+      rows: positions3.rows.map((item) => ({
+        ...item,
+        index_price: indexPrice[item.symbol] || item.index_price || item.mark_price
+      }))
+    };
+    return this.format(positions3, ctx);
+  }
+  calcByPosition(positions3, ctx) {
+    if (positions3.rows.length === 0)
+      return positions3;
+    return this.format(positions3, ctx);
+  }
+  format(data, ctx) {
+    const { accountInfo, symbolsInfo, fundingRates, portfolio } = ctx;
+    if (!accountInfo || !fundingRates || !symbolsInfo) {
+      return data;
+    }
+    let unrealPnL_total = utils.zero, unrealPnL_total_index = utils.zero, notional_total = utils.zero, unsettlementPnL_total = utils.zero;
+    let rows = data.rows.map((item) => {
       const info = symbolsInfo[item.symbol];
-      const rate = fundingRates[item.symbol];
-      const est_funding_rate = rate("est_funding_rate");
-      const funding_period = info("funding_period");
-      const change = item.change === void 0 ? get24hChange2(item["24h_close"], item["24h_open"]) : item.change;
+      const sum_unitary_funding = fundingRates?.[item.symbol]?.["sum_unitary_funding"] ?? 0;
+      const notional = perp.positions.notional(item.position_qty, item.mark_price);
+      const unrealPnl = perp.positions.unrealizedPnL({
+        qty: item.position_qty,
+        openPrice: item?.average_open_price,
+        // markPrice: unRealizedPrice,
+        markPrice: item.mark_price
+      });
+      let unrealPnl_index = 0, unrealPnlROI_index = 0;
+      const maxLeverage = item.leverage || 1;
+      const imr = perp.account.IMR({
+        maxLeverage,
+        baseIMR: info?.["base_imr"],
+        IMR_Factor: accountInfo.imr_factor[item.symbol],
+        positionNotional: notional,
+        ordersNotional: 0,
+        IMR_factor_power: 4 / 5
+      });
+      const unrealPnlROI = perp.positions.unrealizedPnLROI({
+        positionQty: item.position_qty,
+        openPrice: item.average_open_price,
+        IMR: imr,
+        unrealizedPnL: unrealPnl
+      });
+      if (item.index_price) {
+        unrealPnl_index = perp.positions.unrealizedPnL({
+          qty: item.position_qty,
+          openPrice: item?.average_open_price,
+          // markPrice: unRealizedPrice,
+          markPrice: item.index_price
+        });
+        unrealPnlROI_index = perp.positions.unrealizedPnLROI({
+          positionQty: item.position_qty,
+          openPrice: item.average_open_price,
+          IMR: imr,
+          unrealizedPnL: unrealPnl_index
+        });
+      }
+      const unsettlementPnL2 = perp.positions.unsettlementPnL({
+        positionQty: item.position_qty,
+        markPrice: item.mark_price,
+        costPosition: item.cost_position,
+        sumUnitaryFunding: ramda.propOr(
+          0,
+          "sum_unitary_funding",
+          fundingRates[item.symbol]
+        ),
+        lastSumUnitaryFunding: item.last_sum_unitary_funding
+      });
+      const MMR = perp.positions.MMR({
+        baseMMR: info?.["base_mmr"],
+        baseIMR: info?.["base_imr"],
+        IMRFactor: accountInfo.imr_factor[item.symbol],
+        positionNotional: notional,
+        IMR_factor_power: 4 / 5
+      });
+      unrealPnL_total = unrealPnL_total.add(unrealPnl);
+      unrealPnL_total_index = unrealPnL_total_index.add(unrealPnl_index);
+      notional_total = notional_total.add(notional);
+      unsettlementPnL_total = unsettlementPnL_total.add(unsettlementPnL2);
+      const fundingFee = new utils.Decimal(sum_unitary_funding).sub(item.last_sum_unitary_funding).mul(item.position_qty).negated().toNumber();
       return {
         ...item,
-        change,
-        "8h_funding": get8hFunding2(est_funding_rate, funding_period),
-        quote_dp: info("quote_dp"),
-        created_time: info("created_time"),
-        openInterest: new utils.Decimal(open_interest || 0).mul(index_price || 0).toNumber()
+        fundingFee,
+        mm: perp.positions.maintenanceMargin({
+          positionQty: item.position_qty,
+          markPrice: item.mark_price,
+          MMR
+        }),
+        mmr: MMR,
+        notional,
+        unsettlement_pnl: unsettlementPnL2,
+        unrealized_pnl: unrealPnl,
+        unrealized_pnl_index: unrealPnl_index,
+        unrealized_pnl_ROI: unrealPnlROI,
+        unrealized_pnl_ROI_index: unrealPnlROI_index
       };
     });
-    return list || [];
-  }, [symbolsInfo, futures, fundingRates]);
-  const getData = (type2) => {
-    const localData = type2 === 0 /* FAVORITES */ ? [...favorites] : [...recent];
-    const keys = localData.map((item) => item.name);
-    const filter = type2 == 2 /* ALL */ ? marketsList : marketsList?.filter((item) => keys.includes(item.symbol));
-    const favoritesData = [...favorites];
-    const favoriteKeys = favoritesData.map((item) => item.name);
-    if (filter) {
-      for (let index = 0; index < filter.length; index++) {
-        const element = filter[index];
-        const isFavorite = type2 == 0 /* FAVORITES */ ? true : favoriteKeys.includes(element.symbol);
-        const fIndex = favoritesData.findIndex(
-          (item) => item.name === element.symbol
-        );
-        const tabs = fIndex === -1 ? [] : favoritesData[fIndex].tabs;
-        let imr = void 0;
-        if (symbolsInfo) {
-          imr = symbolsInfo?.[element.symbol]("base_imr");
-        }
-        filter[index] = {
-          ...filter[index],
-          isFavorite,
-          tabs,
-          leverage: imr ? 1 / imr : void 0
+    const totalUnrealPnl = unrealPnL_total.toNumber();
+    const totalUnrealPnl_index = unrealPnL_total_index.toNumber();
+    const unsettlementPnL = unsettlementPnL_total.toNumber();
+    let totalUnrealizedROI = 0, totalUnrealizedROI_index = 0;
+    if (portfolio) {
+      const { totalValue, totalCollateral } = portfolio;
+      rows = rows.map((item) => {
+        const est_liq_price = perp.positions.liqPrice({
+          markPrice: item.mark_price,
+          totalCollateral: totalCollateral.toNumber(),
+          positionQty: item.position_qty,
+          positions: rows,
+          MMR: item.mmr
+        });
+        return {
+          ...item,
+          est_liq_price
         };
+      });
+      if (totalValue !== null && !totalValue.eq(utils.zero)) {
+        totalUnrealizedROI = perp.account.totalUnrealizedROI({
+          totalUnrealizedPnL: totalUnrealPnl,
+          totalValue: totalValue.toNumber()
+        });
+        totalUnrealizedROI_index = perp.account.totalUnrealizedROI({
+          totalUnrealizedPnL: totalUnrealPnl_index,
+          totalValue: totalValue.toNumber()
+        });
       }
     }
-    return filter;
-  };
-  const pinToTop = (symbol) => {
-    const index = favorites.findIndex((item) => item.name === symbol.symbol);
-    if (index !== -1) {
-      const element = favorites[index];
-      const list = [...favorites];
-      list.splice(index, 1);
-      list.unshift(element);
-      updateStore("favorites", list);
-      setFavorites(list);
+    return {
+      ...data,
+      unrealPnL: totalUnrealPnl,
+      total_unreal_pnl: totalUnrealPnl,
+      total_unreal_pnl_index: totalUnrealPnl_index,
+      notional: notional_total.toNumber(),
+      unsettledPnL: unsettlementPnL,
+      total_unsettled_pnl: unsettlementPnL,
+      unrealPnlROI: totalUnrealizedROI,
+      unrealPnlROI_index: totalUnrealizedROI_index,
+      rows
+    };
+  }
+  preprocess(data) {
+    let rows = data.rows;
+    if (this.symbol !== AllPositions && Array.isArray(rows)) {
+      rows = rows.filter((item) => item.symbol === this.symbol);
     }
-  };
-  const getLastSelFavTab = () => {
-    return getStore("lastSelectedFavoriteTab", { ...DefaultTab });
-  };
-  const updateSelectedFavoriteTab = (tab) => {
-    updateStore("lastSelectedFavoriteTab", tab);
-  };
-  const updateTabsSortState = (tabId, sortKey, sortOrder) => {
-    const map = getStore("tabSort", {});
-    map[tabId] = {
-      sortKey,
-      sortOrder
+    return {
+      ...data,
+      rows
     };
-    updateStore("tabSort", map);
-    setTabSort(map);
-  };
-  const markets = getData(type);
-  return [
-    markets || types.EMPTY_LIST,
-    {
-      favoriteTabs,
-      favorites,
-      recent,
-      tabSort,
-      addToHistory,
-      updateFavorites,
-      updateFavoriteTabs,
-      updateSymbolFavoriteState,
-      pinToTop,
-      getLastSelFavTab,
-      updateSelectedFavoriteTab,
-      updateTabsSortState
+  }
+  getPosition(_, ctx) {
+    const positions3 = ctx.get((output) => output[this.name]) || usePositionStore.getState().positions[this.symbol];
+    if (this.symbol === AllPositions) {
+      return positions3;
     }
-  ];
-};
-function get8hFunding2(est_funding_rate, funding_period) {
-  let funding8h = 0;
-  if (est_funding_rate === void 0 || est_funding_rate === null) {
-    return null;
+    if (positions3 && Array.isArray(positions3.rows)) {
+      return positions3;
+    }
+    return this.preprocess(this.getAllPositions(ctx));
   }
-  if (funding_period) {
-    funding8h = new utils.Decimal(est_funding_rate || 0).mul(funding_period).div(8).toNumber();
+  destroy() {
+    usePositionStore.getState().actions.closePosition(this.symbol);
+    CalculatorContext.instance?.deleteByName(this.name);
   }
-  return funding8h;
-}
-function get24hChange2(close, open) {
-  if (close !== void 0 && open !== void 0) {
-    if (open === 0) {
-      return 0;
-    }
-    return new utils.Decimal(close).minus(open).div(open).toNumber();
+  getAllPositions(ctx) {
+    return ctx.get((output) => output[AllPositions]) || usePositionStore.getState().positions[AllPositions];
   }
-}
-
-// src/orderly/useMarkPricesStream.ts
-var useMarkPricesStream = () => {
-  const data = useMarkPriceStore((state) => state.markPrices);
-  return { data };
-};
-
-// src/orderly/useIndexPricesStream.ts
-var useIndexPricesStream = () => {
-  const indexPrices = useIndexPriceStore((state) => state.indexPrices);
-  const getIndexPrice = (token) => {
-    if (token === "USDC") {
-      return 1;
-    }
-    return indexPrices[`PERP_${token}_USDC`] ?? 0;
-  };
-  return {
-    data: indexPrices,
-    getIndexPrice: useMemoizedFn(getIndexPrice)
-  };
 };
-var generateLeverageLevers = (max2) => {
-  const min2 = 1;
-  const parts = 5;
-  const step = (max2 - min2) / (parts - 1);
-  const result = [];
-  for (let i = 0; i < parts; i++) {
-    result.push(Math.floor(min2 + step * i));
-  }
-  return result;
+PositionCalculator.logPosition = (symbol = "all") => {
+  return usePositionStore.getState().positions[symbol];
 };
-var useLeverage = () => {
-  const { data, mutate: mutate6 } = usePrivateQuery(
-    "/v1/client/info",
-    {
-      revalidateOnFocus: false
+var parseHolding = (holding, indexPrices, tokensInfo) => {
+  const nonUSDC = [];
+  let USDC_holding = 0;
+  holding.forEach((item) => {
+    if (item.token === "USDC") {
+      USDC_holding = item.holding;
+    } else {
+      const tokenInfo = tokensInfo.find(({ token }) => token === item.token);
+      const {
+        base_weight = 0,
+        discount_factor = 0,
+        user_max_qty = 0
+      } = tokenInfo || {};
+      const holdingQty = item?.holding ?? 0;
+      const indexPrice = indexPrices[`PERP_${item.token}_USDC`] ?? 0;
+      const collateralRatio4 = perp.account.collateralRatio({
+        baseWeight: base_weight,
+        discountFactor: discount_factor,
+        collateralQty: holdingQty,
+        collateralCap: user_max_qty,
+        indexPrice
+      });
+      nonUSDC.push({
+        holding: holdingQty,
+        indexPrice,
+        collateralCap: user_max_qty,
+        collateralRatio: collateralRatio4
+      });
     }
-  );
-  const [update, { isMutating }] = useMutation("/v1/client/leverage");
-  const { data: leverageConfig, isLoading } = useQuery("/v1/public/leverage", {
-    revalidateOnFocus: false,
-    errorRetryCount: 3
-    // formatter: (data) => data,
   });
-  const updateLeverage = React2.useCallback(
-    async (data2) => {
-      const res = await update(data2);
-      if (res.success) {
-        return mutate6();
-      } else {
-        throw new Error(res.message);
-      }
-    },
-    [update, mutate6]
-  );
-  const memoizedCurLeverage = React2.useMemo(() => {
-    if (data?.max_leverage !== void 0) {
-      return Number(data.max_leverage);
-    }
-    return 1;
-  }, [data?.max_leverage]);
-  const memoizedMaxLeverage = React2.useMemo(() => {
-    if (leverageConfig?.max_futures_leverage !== void 0) {
-      return Number(leverageConfig.max_futures_leverage);
-    }
-    return 1;
-  }, [leverageConfig?.max_futures_leverage]);
-  const memoizedLeverageLevers = React2.useMemo(() => {
-    return generateLeverageLevers(memoizedMaxLeverage);
-  }, [memoizedMaxLeverage]);
-  return {
-    update: updateLeverage,
-    isLoading: isLoading || isMutating,
-    leverageLevers: memoizedLeverageLevers,
-    curLeverage: memoizedCurLeverage,
-    maxLeverage: memoizedMaxLeverage
-  };
+  return [USDC_holding, nonUSDC];
 };
 
-// src/orderly/useOdosQuote.ts
-var useOdosQuote = () => {
-  return useMutation(`https://api.odos.xyz/sor/quote/v2`);
-};
-var { LTV, collateralRatio } = perp.account;
-var useComputedLTV = (options = {}) => {
-  const { input, token } = options;
-  const isUSDC = token?.toUpperCase() === "USDC";
-  const tokensInfo = useTokensInfo();
-  const { usdc, data: holdingList = [] } = useHoldingStream();
-  const { getIndexPrice } = useIndexPricesStream();
-  const { unsettledPnL } = useCollateral();
-  const usdcBalance = React2.useMemo(() => {
-    if (isUSDC && input) {
-      return new utils.Decimal(usdc?.holding ?? 0).add(input).toNumber();
-    }
-    return usdc?.holding ?? 0;
-  }, [usdc?.holding, input, isUSDC]);
-  const getAdjustedQty = React2.useCallback(
-    (item) => {
-      if (input && item.token === token) {
-        return new utils.Decimal(item?.holding ?? 0).add(input).toNumber();
-      }
-      return item?.holding ?? 0;
-    },
-    [input, token]
-  );
-  const memoizedLTV = React2.useMemo(() => {
-    return LTV({
-      usdcBalance,
-      upnl: unsettledPnL,
-      assets: holdingList.filter((h) => h.token.toUpperCase() !== "USDC").map((item) => {
-        const indexPrice = getIndexPrice(item.token);
-        const findToken = tokensInfo?.find((i) => i.token === item.token);
-        const qty = getAdjustedQty(item);
-        const weight = collateralRatio({
-          baseWeight: findToken?.base_weight ?? 0,
-          discountFactor: findToken?.discount_factor ?? 0,
-          collateralCap: findToken?.user_max_qty ?? qty,
-          collateralQty: qty,
-          indexPrice
-        });
-        return {
-          qty,
-          indexPrice,
-          weight: weight.toNumber()
-        };
-      })
-    });
-  }, [
-    usdcBalance,
-    unsettledPnL,
-    holdingList,
-    tokensInfo,
-    getIndexPrice,
-    getAdjustedQty
-  ]);
-  if (new utils.Decimal(usdcBalance).add(new utils.Decimal(unsettledPnL)).gte(utils.zero)) {
-    return 0;
-  }
-  return new utils.Decimal(memoizedLTV).mul(100).toDecimalPlaces(2, utils.Decimal.ROUND_DOWN).toNumber();
-};
-var useFundingRate = (symbol) => {
-  if (!symbol) {
-    throw new types.SDKError("Symbol is required");
+// src/orderly/calculator/indexPrice.ts
+var IndexPriceCalculatorName = "indexPriceCalculator";
+var IndexPriceCalculator = class extends BaseCalculator {
+  constructor() {
+    super(...arguments);
+    this.name = IndexPriceCalculatorName;
   }
-  const [countDown, setCountDown] = React2.useState("00:00:00");
-  const timerRef = React2.useRef(null);
-  const { data, isLoading } = useQuery(
-    `/v1/public/funding_rate/${symbol}`,
-    {
-      fallbackData: {
-        est_funding_rate: 0,
-        next_funing_time: 0
-      }
-    }
-  );
-  React2.useEffect(() => {
-    if (!data || isLoading) {
+  calc(scope, data, ctx) {
+    return data;
+  }
+  update(data) {
+    if (!data)
       return;
+    useIndexPriceStore.getState().actions.updateIndexPrice(data);
+  }
+  static getValue() {
+    return useIndexPriceStore.getState().indexPrices;
+  }
+};
+
+// src/orderly/calculator/portfolio.ts
+var PortfolioCalculatorName = "portfolio";
+var PortfolioCalculator = class extends BaseCalculator {
+  constructor() {
+    super(...arguments);
+    this.name = PortfolioCalculatorName;
+  }
+  calc(scope, data, ctx) {
+    let markPrices;
+    let indexPrices;
+    const portfolio = this.getPortfolio(ctx);
+    if (scope === "markPrice" /* MARK_PRICE */) {
+      markPrices = data;
+    } else {
+      markPrices = ctx.get(
+        (cache) => cache[MarketCalculatorName]
+      );
     }
-    const { next_funding_time } = data;
-    if (!next_funding_time || next_funding_time <= 0) {
-      return;
+    if (scope === "indexPrice" /* INDEX_PRICE */) {
+      indexPrices = data;
+    } else {
+      indexPrices = ctx.get(
+        (cache) => cache[IndexPriceCalculatorName]
+      );
     }
-    timerRef.current = setInterval(() => {
-      const diff = new Date(next_funding_time).getTime() - utils.getTimestamp();
-      if (diff <= 0) {
-        setCountDown("00:00:00");
-        if (timerRef.current) {
-          clearInterval(timerRef.current);
-        }
-        return;
-      }
-      const result = utils.timeConvertString(diff);
-      if (result.length === 3) {
-        setCountDown(
-          `${result[0].toString().padStart(2, "0")}:${result[1].toString().padStart(2, "0")}:${result[2].toString().padStart(2, "0")}`
-        );
-      }
-    }, 1e3);
-    return () => {
-      if (timerRef.current) {
-        clearInterval(timerRef.current);
+    const positions3 = ctx.get(
+      (output) => output.positionCalculator_all
+    );
+    let holding = portfolio.holding;
+    if (scope === "portfolio" /* PORTFOLIO */ && data.holding && Array.isArray(holding)) {
+      if (Array.isArray(data.holding)) {
+        holding = data.holding;
+      } else {
+        holding = holding.map((item) => {
+          if (data.holding[item.token]) {
+            return {
+              ...item,
+              holding: data.holding[item.token].holding,
+              frozen: data.holding[item.token].frozen
+            };
+          }
+          return item;
+        });
       }
-    };
-  }, [data, isLoading]);
-  const est_funding_rate = React2.useMemo(() => {
-    if (!data) {
-      return;
     }
-    const { next_funding_time, est_funding_rate: est_funding_rate2 = 0 } = data;
-    if (utils.getTimestamp() > next_funding_time) {
+    const accountInfo = ctx.accountInfo;
+    const symbolsInfo = ctx.symbolsInfo;
+    const tokensInfo = ctx.tokensInfo;
+    return this.format({
+      holding,
+      positions: positions3,
+      markPrices,
+      accountInfo,
+      symbolsInfo,
+      indexPrices,
+      tokensInfo: tokensInfo ?? types.EMPTY_LIST
+    });
+  }
+  getPortfolio(ctx) {
+    return ctx.get((output) => output[this.name]) || useAppStore.getState().portfolio;
+  }
+  format(inputs) {
+    const {
+      holding,
+      positions: positions3,
+      markPrices,
+      indexPrices,
+      accountInfo,
+      symbolsInfo,
+      tokensInfo
+    } = inputs;
+    if (!holding || !positions3 || !Array.isArray(positions3.rows) || !markPrices || !indexPrices || !accountInfo) {
       return null;
     }
-    return new utils.Decimal(Number(est_funding_rate2) * 100).toFixed(
-      4,
-      utils.Decimal.ROUND_DOWN
+    const unsettledPnL = ramda.pathOr(0, ["total_unsettled_pnl"])(positions3);
+    const unrealizedPnL = ramda.pathOr(0, ["total_unreal_pnl"])(positions3);
+    const [USDC_holding, nonUSDC] = parseHolding(
+      holding,
+      indexPrices,
+      tokensInfo
     );
-  }, [data]);
-  return {
-    ...data,
-    est_funding_rate,
-    countDown
-  };
-};
-var useFundingDetails = (symbol) => {
-  if (!symbol) {
-    throw new types.SDKError("symbol is required");
+    const usdc = holding.find((item) => item.token === "USDC");
+    const totalCollateral = perp.account.totalCollateral({
+      USDCHolding: USDC_holding,
+      nonUSDCHolding: nonUSDC,
+      unsettlementPnL: unsettledPnL
+    });
+    const totalValue = perp.account.totalValue({
+      totalUnsettlementPnL: unsettledPnL,
+      USDCHolding: USDC_holding,
+      nonUSDCHolding: nonUSDC
+    });
+    const totalUnrealizedROI = perp.account.totalUnrealizedROI({
+      totalUnrealizedPnL: unrealizedPnL,
+      totalValue: totalValue.toNumber()
+    });
+    const totalInitialMarginWithOrders = perp.account.totalInitialMarginWithQty({
+      positions: positions3.rows,
+      markPrices,
+      IMR_Factors: accountInfo.imr_factor,
+      maxLeverage: accountInfo.max_leverage,
+      symbolInfo: createGetter({ ...symbolsInfo })
+    });
+    const freeCollateral = perp.account.freeCollateral({
+      totalCollateral,
+      totalInitialMarginWithOrders
+    });
+    const availableBalance = perp.account.availableBalance({
+      USDCHolding: usdc?.holding ?? 0,
+      unsettlementPnL: positions3.total_unsettled_pnl ?? 0
+    });
+    return {
+      totalCollateral,
+      totalValue,
+      totalUnrealizedROI,
+      freeCollateral,
+      availableBalance,
+      unsettledPnL,
+      holding
+    };
   }
-  return useQuery(`/v1/public/info/${symbol}`, {
-    errorRetryCount: 3,
-    revalidateOnFocus: false
-  });
-};
-var calculatePositiveRate = (periodData, period) => {
-  if (!periodData || !period) {
-    return 0;
+  update(data, scope) {
+    if (data) {
+      useAppStore.getState().actions.batchUpdateForPortfolio({
+        totalCollateral: data.totalCollateral,
+        totalValue: data.totalValue,
+        freeCollateral: data.freeCollateral,
+        availableBalance: data.availableBalance,
+        totalUnrealizedROI: data.totalUnrealizedROI,
+        unsettledPnL: data.unsettledPnL,
+        holding: Array.isArray(data.holding) ? data.holding : []
+      });
+    }
   }
-  const daysMap = {
-    "1d": 1,
-    "3d": 3,
-    "7d": 7,
-    "14d": 14,
-    "30d": 30,
-    "90d": 90
-  };
-  const totalTimes = daysMap[period] * 3;
-  return periodData.positive / totalTimes;
 };
-var useFundingRateHistory = () => {
-  const { data: historyData, isLoading } = useQuery(
-    "/v1/public/market_info/funding_history"
-  );
-  const getPositiveRates = React2.useCallback(
-    (data, period) => {
-      if (!data?.length) {
-        return {};
-      }
-      return data.reduce(
-        (acc, item) => {
-          acc[item.symbol] = calculatePositiveRate(
-            item.funding[period],
-            period
-          );
-          return acc;
-        },
-        {}
-      );
-    },
-    []
-  );
-  return React2.useMemo(() => {
-    return {
-      data: historyData ?? types.EMPTY_LIST,
-      isLoading,
-      getPositiveRates
-    };
-  }, [historyData, isLoading, getPositiveRates]);
+
+// src/useCalculatorService.ts
+var useCalculatorService = () => {
+  const { get: get3 } = useSimpleDI();
+  const calculatorService = useConstant__default.default(() => {
+    let calculatorService2 = get3(CalculatorServiceID);
+    if (!calculatorService2) {
+      const positionCalculator = new PositionCalculator();
+      const portfolioCalculator = new PortfolioCalculator();
+      const markPriceCalculator = new MarkPriceCalculator();
+      const indexPriceCalculator = new IndexPriceCalculator();
+      calculatorService2 = new CalculatorService(new ShardingScheduler(), [
+        [
+          "markPrice" /* MARK_PRICE */,
+          [
+            markPriceCalculator,
+            positionCalculator,
+            portfolioCalculator,
+            positionCalculator
+          ]
+        ],
+        ["position" /* POSITION */, [positionCalculator, portfolioCalculator]],
+        ["portfolio" /* PORTFOLIO */, [portfolioCalculator]],
+        // indexPrice
+        [
+          "indexPrice" /* INDEX_PRICE */,
+          [indexPriceCalculator, positionCalculator]
+        ]
+      ]);
+      core.SimpleDI.registerByName(CalculatorServiceID, calculatorService2);
+    }
+    return calculatorService2;
+  });
+  return calculatorService;
 };
+
+// src/orderly/usePositionStream/usePositionStream.ts
 var scopes = [
   "position" /* POSITION */,
   "markPrice" /* MARK_PRICE */,
@@ -7143,6 +7141,252 @@ var useSettleSubscription = (options) => {
     }
   );
 };
+var usePrivateDataObserver = (options) => {
+  const ws = useWS();
+  const ee = useEventEmitter();
+  const { state, account: account9 } = useAccount();
+  const { setAccountInfo, restoreHolding, cleanAll } = useAppStore(
+    (state2) => state2.actions
+  );
+  const statusActions = useApiStatusActions();
+  const calculatorService = useCalculatorService();
+  const positionsActions = usePositionActions();
+  const { data: clientInfo } = usePrivateQuery(
+    "/v1/client/info",
+    {
+      revalidateOnFocus: false
+    }
+  );
+  React2.useEffect(() => {
+    if (clientInfo) {
+      setAccountInfo(clientInfo);
+    }
+  }, [clientInfo, setAccountInfo]);
+  const { data: positions3, isLoading: isPositionLoading } = usePrivateQuery("/v1/positions", {
+    formatter: (data) => data,
+    onError: (error) => {
+      statusActions.updateApiError("positions", error.message);
+    }
+    // revalidateOnFocus: false,
+  });
+  React2.useEffect(() => {
+    const handler = (state2) => {
+      if (!state2.accountId) {
+        calculatorService.stop();
+        cleanAll();
+        positionsActions.clearAll();
+      }
+    };
+    account9.on(core.EVENT_NAMES.statusChanged, handler);
+    return () => {
+      account9.off(core.EVENT_NAMES.statusChanged, handler);
+    };
+  }, []);
+  React2.useEffect(() => {
+    if (isPositionLoading) {
+      statusActions.updateApiLoading("positions", isPositionLoading);
+    }
+  }, [isPositionLoading, statusActions]);
+  React2.useEffect(() => {
+    if (positions3 && Array.isArray(positions3.rows)) {
+      calculatorService.calc("position" /* POSITION */, positions3);
+    }
+  }, [calculatorService, positions3]);
+  const { data: holding } = usePrivateQuery(
+    "/v1/client/holding",
+    {
+      formatter: (data) => data.holding
+      // revalidateOnFocus: false,
+    }
+  );
+  React2.useEffect(() => {
+    if (!account9.accountId)
+      return;
+    const unsubscribe = ws.privateSubscribe(
+      {
+        id: "balance",
+        event: "subscribe",
+        topic: "balance",
+        ts: Date.now()
+      },
+      {
+        onMessage: (data) => {
+          const holding2 = data?.balances ?? {};
+          if (holding2) {
+            calculatorService.calc("portfolio" /* PORTFOLIO */, { holding: holding2 });
+          }
+        }
+      }
+    );
+    return () => unsubscribe?.();
+  }, [account9.accountId]);
+  const isHoldingInit = React2.useRef(false);
+  React2.useEffect(() => {
+    isHoldingInit.current = false;
+  }, [state.address]);
+  React2.useEffect(() => {
+    if (!holding) {
+      return;
+    }
+    if (isHoldingInit.current) {
+      calculatorService.calc("portfolio" /* PORTFOLIO */, { holding });
+    } else {
+      restoreHolding(holding);
+    }
+    isHoldingInit.current = true;
+  }, [holding]);
+  const [subOrder] = useLocalStorage("orderly_subscribe_order", true);
+  const updateOrders = (data, isAlgoOrder) => {
+    const keysMap = options.getKeysMap("orders");
+    const filteredKeys = /* @__PURE__ */ new Map();
+    const keyStartWith = isAlgoOrder ? "algoOrders" : "orders";
+    const keys = keysMap.keys();
+    for (const key of keys) {
+      if (key.startsWith(keyStartWith)) {
+        filteredKeys.set(key, keysMap.get(key));
+      }
+    }
+    let fieldChanges = {};
+    filteredKeys.forEach((getKey, key) => {
+      useSWR.mutate(
+        useSWRInfinite.unstable_serialize((index, prevData) => [
+          getKey(index, prevData),
+          state.accountId
+        ]),
+        (prevData) => {
+          try {
+            if (isAlgoOrder) {
+              const res = updateAlgoOrdersHandler(
+                key,
+                data,
+                prevData
+              );
+              fieldChanges = res?.fieldChanges || {};
+              return res?.mergedOrders;
+            }
+            return updateOrdersHandler(key, data, prevData);
+          } catch (error) {
+            return prevData;
+          }
+        },
+        {
+          revalidate: false
+        }
+      );
+    });
+    const formattedData = isAlgoOrder ? AlgoOrderMergeHandler.groupOrders(data) : object2underscore(data);
+    ee.emit("orders:changed", {
+      ...formattedData,
+      status: isAlgoOrder ? formattedData.algo_status : data.status,
+      // custom field name
+      fieldChanges
+    });
+  };
+  React2.useEffect(() => {
+    if (!state.accountId) {
+      return;
+    }
+    if (subOrder !== true) {
+      return;
+    }
+    const unsubscribe = ws.privateSubscribe("executionreport", {
+      onMessage: (data) => {
+        updateOrders(data, false);
+      }
+    });
+    return () => unsubscribe?.();
+  }, [state.accountId, subOrder]);
+  React2.useEffect(() => {
+    if (!state.accountId)
+      return;
+    if (subOrder !== true)
+      return;
+    const unsubscribe = ws.privateSubscribe("algoexecutionreport", {
+      onMessage: (data) => {
+        updateOrders(data, true);
+      }
+    });
+    return () => unsubscribe?.();
+  }, [state.accountId, subOrder]);
+  React2.useEffect(() => {
+    if (!state.accountId)
+      return;
+    const key = ["/v1/positions", state.accountId];
+    const unsubscribe = ws.privateSubscribe("account", {
+      onMessage: (data) => {
+        const { symbol, leverage } = data?.accountDetail?.symbolLeverage || {};
+        if (symbol && leverage) {
+          useSWR.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
+            }
+          );
+        }
+      }
+    });
+    return () => unsubscribe?.();
+  }, [state.accountId]);
+  React2.useEffect(() => {
+    if (!state.accountId) {
+      return;
+    }
+    const key = ["/v1/positions", state.accountId];
+    const unsubscribe = ws.privateSubscribe("position", {
+      onMessage: (data) => {
+        const { positions: nextPositions } = data;
+        useSWR.mutate(
+          key,
+          (prevPositions) => {
+            if (!!prevPositions) {
+              const newPositions = {
+                ...prevPositions,
+                rows: prevPositions.rows.map((row) => {
+                  const itemIndex = nextPositions.findIndex(
+                    (item) => item.symbol === row.symbol
+                  );
+                  if (itemIndex >= 0) {
+                    const itemArr = nextPositions.splice(itemIndex, 1);
+                    const item = itemArr[0];
+                    if (item.averageOpenPrice === 0 && item.positionQty !== 0) {
+                      return row;
+                    }
+                    return object2underscore(item);
+                  }
+                  return row;
+                })
+              };
+              if (nextPositions.length > 0) {
+                newPositions.rows = [
+                  ...newPositions.rows,
+                  ...nextPositions.map(object2underscore)
+                ];
+              }
+              return newPositions;
+            }
+          },
+          {
+            revalidate: false
+          }
+        );
+      }
+    });
+    return () => {
+      unsubscribe?.();
+    };
+  }, [state.accountId]);
+};
 var useSymbolPriceRange = (symbol, side, price) => {
   const config = useSymbolsInfo();
   const priceRange = config?.[symbol]("price_range");
@@ -7595,12 +7839,12 @@ async function bracketOrderValidator(values, config) {
   const result = /* @__PURE__ */ Object.create(null);
   await Promise.resolve();
   const {
-    tp_enable,
+    // tp_enable,
+    // sl_enable,
     tp_trigger_price,
     tp_order_price,
     tp_order_type,
     sl_trigger_price,
-    sl_enable,
     sl_order_price,
     sl_order_type,
     side
@@ -7620,12 +7864,6 @@ async function bracketOrderValidator(values, config) {
   if (Number(sl_trigger_price) < 0) {
     result.sl_trigger_price = OrderValidation.min("sl_trigger_price", 0);
   }
-  if (tp_enable && !tp_trigger_price) {
-    result.tp_trigger_price = OrderValidation.required("tp_trigger_price");
-  }
-  if (sl_enable && !sl_trigger_price) {
-    result.sl_trigger_price = OrderValidation.required("sl_trigger_price");
-  }
   if (tp_order_type === types.OrderType.LIMIT && !tp_order_price) {
     result.tp_order_price = OrderValidation.required("tp_order_price");
   }
@@ -8445,8 +8683,8 @@ var BaseAlgoOrderCreator = class {
         tp_trigger_price,
         sl_trigger_price,
         side,
-        tp_enable,
-        sl_enable,
+        // tp_enable,
+        // sl_enable,
         tp_order_type,
         sl_order_type,
         tp_order_price,
@@ -8475,12 +8713,6 @@ var BaseAlgoOrderCreator = class {
       if (Number(sl_trigger_price) < 0) {
         result.sl_trigger_price = OrderValidation.min("sl_trigger_price", 0);
       }
-      if (tp_enable && !tp_trigger_price) {
-        result.tp_trigger_price = OrderValidation.required("tp_trigger_price");
-      }
-      if (sl_enable && !sl_trigger_price) {
-        result.sl_trigger_price = OrderValidation.required("sl_trigger_price");
-      }
       if (tp_order_type === types.OrderType.LIMIT && !tp_order_price) {
         result.tp_order_price = OrderValidation.required("tp_order_price");
       }
@@ -8991,9 +9223,6 @@ var tpslFields = [
   "sl_offset_percentage"
 ];
 var isBracketOrder = (order) => {
-  if (order.sl_enable || order.tp_enable) {
-    return true;
-  }
   return !!order.tp_trigger_price || !!order.sl_trigger_price;
 };
 var hasTPSL = (order) => {
@@ -9523,28 +9752,6 @@ function useSubAccountMaxWithdrawal(options) {
 }
 
 // src/orderly/useTakeProfitAndStopLoss/useTPSL.ts
-var checkIsEnableTpSL = (order) => {
-  const result = {
-    tp_enable: true,
-    sl_enable: true
-  };
-  if (!order) {
-    return result;
-  }
-  const tp = order.child_orders.find(
-    (o) => o.algo_type === types.AlgoOrderType.TAKE_PROFIT && o.is_activated
-  );
-  const sl = order.child_orders.find(
-    (o) => o.algo_type === types.AlgoOrderType.STOP_LOSS && o.is_activated
-  );
-  if (!tp) {
-    result.tp_enable = false;
-  }
-  if (!sl) {
-    result.sl_enable = false;
-  }
-  return result;
-};
 var useTaskProfitAndStopLossInternal = (position, options) => {
   const isEditing = typeof options?.isEditing !== "undefined" ? options.isEditing : !!options?.defaultOrder;
   const [order, setOrder] = React2.useState({
@@ -9559,8 +9766,12 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
     // quantity:
     //   options?.defaultOrder?.quantity || Math.abs(position.position_qty),
     algo_type: options?.defaultOrder?.algo_type,
-    tp_enable: isEditing ? checkIsEnableTpSL(options?.defaultOrder).tp_enable : options?.tpslEnable?.tp_enable,
-    sl_enable: isEditing ? checkIsEnableTpSL(options?.defaultOrder).sl_enable : options?.tpslEnable?.sl_enable,
+    // tp_enable: isEditing
+    //   ? checkIsEnableTpSL(options?.defaultOrder).tp_enable
+    //   : options?.tpslEnable?.tp_enable,
+    // sl_enable: isEditing
+    //   ? checkIsEnableTpSL(options?.defaultOrder).sl_enable
+    //   : options?.tpslEnable?.sl_enable,
     position_type: options?.positionType
   });
   const symbolInfo = useSymbolsInfo()[position.symbol]();
@@ -10212,254 +10423,6 @@ var useStorageLedgerAddress = () => {
     ledgerWallet
   };
 };
-
-// src/orderly/usePrivateDataObserver.ts
-var usePrivateDataObserver = (options) => {
-  const ws = useWS();
-  const ee = useEventEmitter();
-  const { state, account: account9 } = useAccount();
-  const { setAccountInfo, restoreHolding, cleanAll } = useAppStore(
-    (state2) => state2.actions
-  );
-  const statusActions = useApiStatusActions();
-  const calculatorService = useCalculatorService();
-  const positionsActions = usePositionActions();
-  const { data: clientInfo } = usePrivateQuery(
-    "/v1/client/info",
-    {
-      revalidateOnFocus: false
-    }
-  );
-  React2.useEffect(() => {
-    if (clientInfo) {
-      setAccountInfo(clientInfo);
-    }
-  }, [clientInfo, setAccountInfo]);
-  const { data: positions3, isLoading: isPositionLoading } = usePrivateQuery("/v1/positions", {
-    formatter: (data) => data,
-    onError: (error) => {
-      statusActions.updateApiError("positions", error.message);
-    }
-    // revalidateOnFocus: false,
-  });
-  React2.useEffect(() => {
-    const handler = (state2) => {
-      if (!state2.accountId) {
-        calculatorService.stop();
-        cleanAll();
-        positionsActions.clearAll();
-      }
-    };
-    account9.on(core.EVENT_NAMES.statusChanged, handler);
-    return () => {
-      account9.off(core.EVENT_NAMES.statusChanged, handler);
-    };
-  }, []);
-  React2.useEffect(() => {
-    if (isPositionLoading) {
-      statusActions.updateApiLoading("positions", isPositionLoading);
-    }
-  }, [isPositionLoading, statusActions]);
-  React2.useEffect(() => {
-    if (positions3 && Array.isArray(positions3.rows)) {
-      calculatorService.calc("position" /* POSITION */, positions3);
-    }
-  }, [calculatorService, positions3]);
-  const { data: holding } = usePrivateQuery(
-    "/v1/client/holding",
-    {
-      formatter: (data) => data.holding
-      // revalidateOnFocus: false,
-    }
-  );
-  React2.useEffect(() => {
-    if (!account9.accountId)
-      return;
-    const unsubscribe = ws.privateSubscribe(
-      {
-        id: "balance",
-        event: "subscribe",
-        topic: "balance",
-        ts: Date.now()
-      },
-      {
-        onMessage: (data) => {
-          const holding2 = data?.balances ?? {};
-          if (holding2) {
-            calculatorService.calc("portfolio" /* PORTFOLIO */, { holding: holding2 });
-          }
-        }
-      }
-    );
-    return () => unsubscribe?.();
-  }, [account9.accountId]);
-  const isHoldingInit = React2.useRef(false);
-  React2.useEffect(() => {
-    isHoldingInit.current = false;
-  }, [state.address]);
-  React2.useEffect(() => {
-    if (!holding) {
-      return;
-    }
-    if (isHoldingInit.current) {
-      calculatorService.calc("portfolio" /* PORTFOLIO */, { holding });
-    } else {
-      restoreHolding(holding);
-    }
-    isHoldingInit.current = true;
-  }, [holding]);
-  const [subOrder] = useLocalStorage("orderly_subscribe_order", true);
-  const updateOrders = (data, isAlgoOrder) => {
-    const keysMap = options.getKeysMap("orders");
-    const filteredKeys = /* @__PURE__ */ new Map();
-    const keyStartWith = isAlgoOrder ? "algoOrders" : "orders";
-    const keys = keysMap.keys();
-    for (const key of keys) {
-      if (key.startsWith(keyStartWith)) {
-        filteredKeys.set(key, keysMap.get(key));
-      }
-    }
-    let fieldChanges = {};
-    filteredKeys.forEach((getKey, key) => {
-      useSWR.mutate(
-        useSWRInfinite.unstable_serialize((index, prevData) => [
-          getKey(index, prevData),
-          state.accountId
-        ]),
-        (prevData) => {
-          try {
-            if (isAlgoOrder) {
-              const res = updateAlgoOrdersHandler(
-                key,
-                data,
-                prevData
-              );
-              fieldChanges = res?.fieldChanges || {};
-              return res?.mergedOrders;
-            }
-            return updateOrdersHandler(key, data, prevData);
-          } catch (error) {
-            return prevData;
-          }
-        },
-        {
-          revalidate: false
-        }
-      );
-    });
-    const formattedData = isAlgoOrder ? AlgoOrderMergeHandler.groupOrders(data) : object2underscore(data);
-    ee.emit("orders:changed", {
-      ...formattedData,
-      status: isAlgoOrder ? formattedData.algo_status : data.status,
-      // custom field name
-      fieldChanges
-    });
-  };
-  React2.useEffect(() => {
-    if (!state.accountId) {
-      return;
-    }
-    if (subOrder !== true) {
-      return;
-    }
-    const unsubscribe = ws.privateSubscribe("executionreport", {
-      onMessage: (data) => {
-        updateOrders(data, false);
-      }
-    });
-    return () => unsubscribe?.();
-  }, [state.accountId, subOrder]);
-  React2.useEffect(() => {
-    if (!state.accountId)
-      return;
-    if (subOrder !== true)
-      return;
-    const unsubscribe = ws.privateSubscribe("algoexecutionreport", {
-      onMessage: (data) => {
-        updateOrders(data, true);
-      }
-    });
-    return () => unsubscribe?.();
-  }, [state.accountId, subOrder]);
-  React2.useEffect(() => {
-    if (!state.accountId)
-      return;
-    const key = ["/v1/positions", state.accountId];
-    const unsubscribe = ws.privateSubscribe("account", {
-      onMessage: (data) => {
-        const { symbol, leverage } = data?.accountDetail?.symbolLeverage || {};
-        if (symbol && leverage) {
-          useSWR.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
-            }
-          );
-        }
-      }
-    });
-    return () => unsubscribe?.();
-  }, [state.accountId]);
-  React2.useEffect(() => {
-    if (!state.accountId) {
-      return;
-    }
-    const key = ["/v1/positions", state.accountId];
-    const unsubscribe = ws.privateSubscribe("position", {
-      onMessage: (data) => {
-        const { positions: nextPositions } = data;
-        useSWR.mutate(
-          key,
-          (prevPositions) => {
-            if (!!prevPositions) {
-              const newPositions = {
-                ...prevPositions,
-                rows: prevPositions.rows.map((row) => {
-                  const itemIndex = nextPositions.findIndex(
-                    (item) => item.symbol === row.symbol
-                  );
-                  if (itemIndex >= 0) {
-                    const itemArr = nextPositions.splice(itemIndex, 1);
-                    const item = itemArr[0];
-                    if (item.averageOpenPrice === 0 && item.positionQty !== 0) {
-                      return row;
-                    }
-                    return object2underscore(item);
-                  }
-                  return row;
-                })
-              };
-              if (nextPositions.length > 0) {
-                newPositions.rows = [
-                  ...newPositions.rows,
-                  ...nextPositions.map(object2underscore)
-                ];
-              }
-              return newPositions;
-            }
-          },
-          {
-            revalidate: false
-          }
-        );
-      }
-    });
-    return () => {
-      unsubscribe?.();
-    };
-  }, [state.accountId]);
-};
 var useMarketStore = zustand.create(
   (set, get3) => ({
     market: [],
@@ -18149,6 +18112,7 @@ exports.useFeeState = useFeeState;
 exports.useFundingDetails = useFundingDetails;
 exports.useFundingFeeHistory = useFundingFeeHistory;
 exports.useFundingRate = useFundingRate;
+exports.useFundingRateBySymbol = useFundingRateBySymbol;
 exports.useFundingRateHistory = useFundingRateHistory;
 exports.useFundingRates = useFundingRates;
 exports.useFundingRatesStore = useFundingRatesStore;