@orderly.network/hooks 2.8.1 → 2.8.2

package/dist/index.mjs

@@ -3,10 +3,10 @@ import useSWR__default, { mutate } from 'swr';
 import * as useSWR from 'swr';
 export { useSWR as swr };
 export { unstable_serialize, default as useSWR, useSWRConfig } from 'swr';
-import { TesntTokenFallback, ArbitrumSepoliaTokenInfo, SolanaDevnetTokenInfo, OrderType, OrderSide, SDKError, TrackerEventName, AccountStatusEnum, AlgoOrderType, AlgoOrderRootType, OrderStatus, EMPTY_LIST, EMPTY_OBJECT, ArbitrumSepoliaChainInfo, SolanaDevnetChainInfo, ARBITRUM_TESTNET_CHAINID, SOLANA_TESTNET_CHAINID, MONAD_TESTNET_CHAINID, ABSTRACT_TESTNET_CHAINID, BSC_TESTNET_CHAINID, nativeTokenAddress, ChainKey, chainsInfoMap, ARBITRUM_MAINNET_CHAINID, isNativeTokenChecker, ChainNamespace, MaxUint256, ETHEREUM_MAINNET_CHAINID, DEPOSIT_FEE_RATE, LedgerWalletKey, SolanaChains, PositionType, DistributionType, TriggerPriceType } from '@orderly.network/types';
+import { TesnetTokenFallback, ArbitrumSepoliaTokenInfo, SolanaDevnetTokenInfo, OrderType, OrderSide, SDKError, TrackerEventName, AccountStatusEnum, AlgoOrderType, AlgoOrderRootType, OrderStatus, ArbitrumSepoliaChainInfo, SolanaDevnetChainInfo, EMPTY_LIST, EMPTY_OBJECT, ARBITRUM_TESTNET_CHAINID, SOLANA_TESTNET_CHAINID, MONAD_TESTNET_CHAINID, ABSTRACT_TESTNET_CHAINID, BSC_TESTNET_CHAINID, nativeTokenAddress, ChainKey, chainsInfoMap, ARBITRUM_MAINNET_CHAINID, isNativeTokenChecker, ChainNamespace, MaxUint256, ETHEREUM_MAINNET_CHAINID, DEPOSIT_FEE_RATE, LedgerWalletKey, SolanaChains, PositionType, DistributionType, TriggerPriceType } from '@orderly.network/types';
 import React2, { createContext, useContext, useCallback, useState, useEffect, useMemo, useRef, useId, useLayoutEffect } from 'react';
-import useSWRMutation from 'swr/mutation';
 import { zero, windowGuard, getTimestamp, getGlobalObject, Decimal, timeConvertString, isTestnet, getPrecisionByNumber, getBBOType, camelCaseToUnderscoreCase, commify, todpIfNeed, getTPSLDirection } from '@orderly.network/utils';
+import useSWRMutation from 'swr/mutation';
 import useConstant from 'use-constant';
 export { default as useConstant } from 'use-constant';
 import { SimpleDI, Account, EventEmitter, DefaultConfigStore, EVENT_NAMES, LocalStorageStore } from '@orderly.network/core';
@@ -14,14 +14,16 @@ import { debounce } from 'lodash';
 import useSWRInfinite, { unstable_serialize } from 'swr/infinite';
 import { pathOr, min, max, omit, prop, pick, compose, head, mergeDeepRight, isNil, propOr, path, lensIndex, over } from 'ramda';
 import { account, order, positions } from '@orderly.network/perp';
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+import pathOr$1 from 'ramda/es/pathOr';
+import { persist, createJSONStorage } from 'zustand/middleware';
 import useSWRSubscription from 'swr/subscription';
 import * as amplitude from '@amplitude/analytics-browser';
 import { jsx } from 'react/jsx-runtime';
 import { DefaultEVMWalletAdapter } from '@orderly.network/default-evm-adapter';
 import { DefaultSolanaWalletAdapter } from '@orderly.network/default-solana-adapter';
 import { EthersProvider } from '@orderly.network/web3-provider-ethers';
-import { create } from 'zustand';
-import { immer } from 'zustand/middleware/immer';
 import { useDebouncedCallback } from 'use-debounce';
 export * from 'use-debounce';
 import { produce } from 'immer';
@@ -36,9 +38,9 @@ var __export = (target, all) => {
 // src/version.ts
 if (typeof window !== "undefined") {
   window.__ORDERLY_VERSION__ = window.__ORDERLY_VERSION__ || {};
-  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.8.1";
+  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.8.2";
 }
-var version_default = "2.8.1";
+var version_default = "2.8.2";
 var fetcher = (url, init2 = {}, queryOptions) => get(url, init2, queryOptions?.formatter);
 var noCacheConfig = {
   dedupingInterval: 0,
@@ -85,6 +87,69 @@ var useQuery = (query, options) => {
     swrOptions
   );
 };
+var timestampOffsetPromise = null;
+var timestampOffsetReady = false;
+var timestampWaitingMiddleware = (useSWRNext) => {
+  return (key, fetcher4, config) => {
+    if (!fetcher4) {
+      return useSWRNext(key, fetcher4, config);
+    }
+    const wrappedFetcher = async (...args) => {
+      await getTimestampOffsetPromise();
+      return fetcher4(...args);
+    };
+    return useSWRNext(key, wrappedFetcher, config);
+  };
+};
+function getTimestampOffsetPromise() {
+  if (timestampOffsetReady) {
+    return Promise.resolve();
+  }
+  if (timestampOffsetPromise) {
+    return timestampOffsetPromise;
+  }
+  timestampOffsetPromise = waitForTimestampOffset();
+  timestampOffsetPromise.then(() => {
+    timestampOffsetReady = true;
+  }).catch(() => {
+    timestampOffsetPromise = null;
+  });
+  return timestampOffsetPromise;
+}
+async function waitForTimestampOffset(maxWaitTime = 3e4) {
+  let globalObj;
+  try {
+    globalObj = getGlobalObject();
+  } catch {
+    throw new Error("Failed to access global object");
+  }
+  const checkTimestampOffset = () => {
+    return typeof globalObj.__ORDERLY_timestamp_offset === "number";
+  };
+  if (checkTimestampOffset()) {
+    return;
+  }
+  return new Promise((resolve, reject) => {
+    let attempts = 0;
+    const maxAttempts = maxWaitTime / 100;
+    const pollInterval = setInterval(() => {
+      attempts++;
+      if (checkTimestampOffset()) {
+        clearInterval(pollInterval);
+        resolve();
+      } else if (attempts >= maxAttempts) {
+        clearInterval(pollInterval);
+        reject(
+          new Error("Timeout waiting for timestamp offset initialization")
+        );
+      }
+    }, 100);
+  });
+}
+function resetTimestampOffsetState() {
+  timestampOffsetPromise = null;
+  timestampOffsetReady = false;
+}
 var useLazyQuery = (query, options) => {
   const apiBaseUrl = useConfig("apiBaseUrl");
   const { formatter, init: init2, ...swrOptions } = options || {};
@@ -2036,90 +2101,710 @@ var useReferralInfo = () => {
     getFirstRefCode
   };
 };
-var usePreLoadData = () => {
-  const [timestampOffsetInitialized, setTimestampOffsetInitialized] = useState(false);
-  const { error: tokenError, data: tokenData } = useQuery(
-    "https://api.orderly.org/v1/public/token",
-    {
-      revalidateOnFocus: false
-    }
-  );
-  const apiBaseUrl = useConfig("apiBaseUrl");
-  const { data: systemInfo } = useSWR__default(
-    "/v1/public/system_info",
-    async (url, init2) => {
-      const data = await fetch(
-        url.startsWith("http") ? url : `${apiBaseUrl}${url}`,
-        init2
-      );
-      return await data.json();
+var useAppStore = create()(
+  immer((set) => ({
+    // accountInfo: null,
+    portfolio: {
+      totalCollateral: zero,
+      totalValue: null,
+      freeCollateral: zero,
+      availableBalance: 0,
+      unsettledPnL: 0,
+      totalUnrealizedROI: 0
     },
-    {
-      errorRetryCount: 3,
-      errorRetryInterval: 500
-    }
-  );
-  useEffect(() => {
-    if (timestampOffsetInitialized)
-      return;
-    if (typeof systemInfo !== "undefined") {
-      const sd = systemInfo.timestamp;
-      const ld = Date.now();
-      const diff = sd - ld;
-      if (isNaN(diff)) {
-        return;
+    appState: {
+      positionsLoading: false,
+      ordersLoading: false,
+      fundingRatesLoading: false,
+      ready: false
+    },
+    actions: {
+      setTokensInfo: (tokensInfo) => {
+        set((state) => {
+          state.tokensInfo = tokensInfo;
+        }, false);
+      },
+      cleanAll: () => {
+        set((state) => {
+          state.accountInfo = void 0;
+          state.portfolio = {
+            totalCollateral: zero,
+            totalValue: null,
+            freeCollateral: zero,
+            availableBalance: 0,
+            unsettledPnL: 0,
+            totalUnrealizedROI: 0
+          };
+        }, false);
+      },
+      setAccountInfo: (accountInfo) => {
+        set(
+          (state) => {
+            state.accountInfo = accountInfo;
+          },
+          false
+          // "setAccountInfo"
+        );
+      },
+      setSymbolsInfo: (symbolsInfo) => {
+        set(
+          (state) => {
+            state.symbolsInfo = symbolsInfo;
+          },
+          false
+          // "setSymbolsInfo"
+        );
+      },
+      setRwaSymbolsInfo: (rwaSymbolsInfo) => {
+        set(
+          (state) => {
+            state.rwaSymbolsInfo = rwaSymbolsInfo;
+          },
+          false
+          // "setRwaSymbolsInfo"
+        );
+      },
+      setFundingRates: (fundingRates) => {
+        set(
+          (state) => {
+            state.fundingRates = fundingRates;
+          },
+          false
+          // "setFundingRates"
+        );
+      },
+      updateAppStatus: (key, value) => {
+        set(
+          (state) => {
+            state.appState[key] = value;
+          },
+          false
+          // "updateAppStatus"
+        );
+      },
+      updatePortfolio: (key, value) => {
+        set(
+          (state) => {
+            state.portfolio[key] = value;
+          },
+          false
+          // "updatePortfolio"
+        );
+      },
+      batchUpdateForPortfolio: (data) => {
+        set(
+          (state) => {
+            state.portfolio = { ...state.portfolio, ...data };
+          },
+          false
+          // "batchUpdateForPortfolio"
+        );
+      },
+      restoreHolding: (holding) => {
+        set(
+          (state) => {
+            state.portfolio.holding = holding;
+          },
+          false
+          // "updateHolding"
+        );
+      },
+      updateHolding(msg) {
+        set(
+          (state) => {
+            if (state.portfolio.holding && state.portfolio.holding.length) {
+              for (const key in msg) {
+                const holding = state.portfolio.holding.find(
+                  (item) => item.token === key
+                );
+                if (holding) {
+                  holding.holding = msg[key].holding;
+                  holding.frozen = msg[key].frozen;
+                }
+              }
+            }
+          },
+          false
+          // "updateHolding"
+        );
       }
-      getGlobalObject().__ORDERLY_timestamp_offset = diff;
-      setTimestampOffsetInitialized(true);
     }
-  }, [systemInfo, timestampOffsetInitialized]);
-  const isDone = useMemo(() => {
-    return !!tokenData && timestampOffsetInitialized;
-  }, [timestampOffsetInitialized, tokenData]);
-  return {
-    error: tokenError,
-    done: isDone
-  };
+  }))
+);
+var useAccountInfo = () => useAppStore((state) => state.accountInfo);
+var usePortfolio = () => useAppStore((state) => state.portfolio);
+var useFundingRateBySymbol = (symbol) => useAppStore((state) => state.fundingRates?.[symbol]);
+
+// src/middleware/indexedDBManager.ts
+var ORDERLY_SYMBOLS = {
+  name: "ORDERLY_SYMBOLS",
+  keyPath: "symbol",
+  autoIncrement: false
 };
-function useSessionStorage(key, initialValue) {
-  const readValue = useCallback(() => {
-    if (typeof window === "undefined") {
-      return initialValue;
+var ORDERLY_MAIN_CHAIN_INFO = {
+  name: "ORDERLY_MAIN_CHAIN_INFO",
+  keyPath: "chain_id",
+  autoIncrement: false
+};
+var ORDERLY_TEST_CHAIN_INFO = {
+  name: "ORDERLY_TEST_CHAIN_INFO",
+  keyPath: "chain_id",
+  autoIncrement: false
+};
+var ORDERLY_MAIN_TOKEN = {
+  name: "ORDERLY_MAIN_TOKEN",
+  keyPath: "token",
+  autoIncrement: false
+};
+var ORDERLY_TEST_TOKEN = {
+  name: "ORDERLY_TEST_TOKEN",
+  keyPath: "token",
+  autoIncrement: false
+};
+var DEFAULT_DATABASE_CONFIG = {
+  name: "ORDERLY_STORE",
+  version: 4,
+  stores: [
+    ORDERLY_MAIN_CHAIN_INFO,
+    ORDERLY_TEST_CHAIN_INFO,
+    ORDERLY_MAIN_TOKEN,
+    ORDERLY_SYMBOLS,
+    ORDERLY_TEST_TOKEN
+  ]
+};
+var IndexedDBManager = class _IndexedDBManager {
+  constructor() {
+    this.connections = /* @__PURE__ */ new Map();
+    this.databaseConfig = null;
+    /** Promise that resolves when database initialization is complete */
+    this.initializationPromise = null;
+  }
+  static getInstance() {
+    if (!_IndexedDBManager.instance) {
+      _IndexedDBManager.instance = new _IndexedDBManager();
     }
-    try {
-      const item = window.sessionStorage.getItem(key);
-      return item ? parseJSON(item) : initialValue;
-    } catch (error) {
-      return initialValue;
+    return _IndexedDBManager.instance;
+  }
+  async initializeDatabase(config) {
+    if (this.initializationPromise) {
+      return this.initializationPromise;
     }
-  }, [initialValue, key]);
-  const [storedValue, setStoredValue] = useState(readValue);
-  const setValue = (value) => {
-    try {
-      const newValue = value instanceof Function ? value(storedValue) : value;
-      window.sessionStorage.setItem(key, JSON.stringify(newValue));
-      setStoredValue(newValue);
-    } catch (error) {
+    this.initializationPromise = this._performInitialization(config);
+    return this.initializationPromise;
+  }
+  /**
+   * Performs the actual database initialization
+   * Now keeps the connection open for better performance
+   */
+  async _performInitialization(config) {
+    this.databaseConfig = config;
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(config.name, config.version);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        config.stores.forEach((storeConfig) => {
+          if (!db.objectStoreNames.contains(storeConfig.name)) {
+            db.createObjectStore(storeConfig.name, {
+              keyPath: storeConfig.keyPath,
+              autoIncrement: storeConfig.autoIncrement ?? true
+            });
+          }
+        });
+      };
+      request.onsuccess = () => {
+        const db = request.result;
+        this.connections.set(config.name, db);
+        db.addEventListener("close", () => {
+          this.connections.delete(config.name);
+        });
+        resolve();
+      };
+      request.onerror = () => {
+        this._handleInitializationError(config.name, request.error);
+        reject(request.error);
+      };
+      request.onblocked = () => {
+        const error = new Error(
+          `Database '${config.name}' is blocked by another connection`
+        );
+        this._handleInitializationError(config.name, error);
+        reject(error);
+      };
+    });
+  }
+  /**
+   * Handles initialization errors consistently
+   */
+  _handleInitializationError(dbName, error) {
+    this.initializationPromise = null;
+  }
+  async getConnection(dbName, storeName) {
+    await this.ensureInitialized();
+    if (this.connections.has(dbName)) {
+      const existingConnection = this.connections.get(dbName);
+      try {
+        if (existingConnection.objectStoreNames.contains(storeName)) {
+          return existingConnection;
+        }
+      } catch {
+        this.connections.delete(dbName);
+      }
     }
-  };
-  useEffect(() => {
-    setStoredValue(readValue());
-  }, []);
-  useEffect(() => {
-    if (typeof window == "undefined") {
-      return;
+    const db = await this.createConnection(dbName);
+    this.connections.set(dbName, db);
+    db.addEventListener("close", () => {
+      this.connections.delete(dbName);
+    });
+    return db;
+  }
+  /**
+   * Ensures database is initialized, initializes if not already done
+   */
+  async ensureInitialized() {
+    if (this.initializationPromise) {
+      return this.initializationPromise;
     }
-    window.addEventListener?.("storage", handleStorageChange);
-    return () => {
-      window.removeEventListener?.("storage", handleStorageChange);
-    };
-  });
-  const handleStorageChange = useCallback(
-    (event) => {
-      if (event?.key && event.key !== key) {
-        return;
-      }
-      setStoredValue(readValue());
+    if (!this.databaseConfig) {
+      return this.initializeDatabase(DEFAULT_DATABASE_CONFIG);
+    }
+    const isActuallyInitialized = await this._checkDatabaseExists();
+    if (!isActuallyInitialized) {
+      this.initializationPromise = null;
+      return this.initializeDatabase(this.databaseConfig);
+    }
+    this.initializationPromise = Promise.resolve();
+    return this.initializationPromise;
+  }
+  /**
+   * Creates a new database connection
+   */
+  async createConnection(dbName) {
+    const config = this.databaseConfig;
+    if (!config) {
+      throw new Error(
+        "Database not initialized. Call initializeDatabase() first."
+      );
+    }
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(dbName, config.version);
+      request.onsuccess = () => {
+        resolve(request.result);
+      };
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  }
+  /**
+   * Checks if database and all required stores exist
+   */
+  async _checkDatabaseExists() {
+    if (!this.databaseConfig) {
+      return false;
+    }
+    try {
+      return new Promise((resolve) => {
+        const config = this.databaseConfig;
+        const request = indexedDB.open(config.name, config.version);
+        request.onsuccess = () => {
+          const db = request.result;
+          const config2 = this.databaseConfig;
+          const allStoresExist = config2.stores.every(
+            (store) => db.objectStoreNames.contains(store.name)
+          );
+          db.close();
+          resolve(allStoresExist);
+        };
+        request.onerror = () => resolve(false);
+      });
+    } catch {
+      return false;
+    }
+  }
+};
+var indexedDBManager = IndexedDBManager.getInstance();
+var initializeAppDatabase = async (config) => {
+  try {
+    await indexedDBManager.initializeDatabase(config);
+  } catch (error) {
+    throw error;
+  }
+};
+var createIndexedDBStorage = (config) => {
+  const { dbName, storeName } = config;
+  const getDB = async () => {
+    return indexedDBManager.getConnection(dbName, storeName);
+  };
+  const executeTransaction = async (operation, mode = "readwrite") => {
+    const dbInstance = await getDB();
+    const transaction = dbInstance.transaction(storeName, mode);
+    const store = transaction.objectStore(storeName);
+    return new Promise((resolve, reject) => {
+      const result = operation(store);
+      transaction.oncomplete = () => resolve(result);
+      transaction.onerror = () => {
+        reject(transaction.error);
+      };
+      transaction.onabort = () => {
+        reject(new Error("Transaction was aborted"));
+      };
+    });
+  };
+  const getItem = async () => {
+    try {
+      const allValues = await executeTransaction((store) => {
+        return new Promise((resolve, reject) => {
+          const request = store.getAll();
+          request.onsuccess = () => {
+            const result = request.result;
+            resolve(result.length > 0 ? result : []);
+          };
+          request.onerror = () => reject(request.error);
+        });
+      }, "readonly");
+      return allValues.length > 0 ? allValues : null;
+    } catch (error) {
+      return null;
+    }
+  };
+  const setItem = async (value) => {
+    try {
+      await executeTransaction((store) => {
+        store.clear();
+        value.forEach((item) => store.put(item));
+        return void 0;
+      }, "readwrite");
+    } catch (error) {
+      throw error;
+    }
+  };
+  const removeItem = async () => {
+    try {
+      await executeTransaction((store) => {
+        store.clear();
+        return void 0;
+      }, "readwrite");
+    } catch (error) {
+      throw error;
+    }
+  };
+  return {
+    getItem,
+    setItem,
+    removeItem
+  };
+};
+var adaptToStateStorage = (indexedDBStorage) => ({
+  getItem: async () => {
+    try {
+      const result = await indexedDBStorage.getItem();
+      return result && Array.isArray(result) && result.length > 0 ? JSON.stringify({
+        state: result,
+        version: 0
+      }) : null;
+    } catch (error) {
+      return null;
+    }
+  },
+  setItem: async (_name, value) => {
+    try {
+      const parsed = JSON.parse(value);
+      const stateData = pathOr$1([], ["state"], parsed);
+      if (Array.isArray(stateData) && stateData.length > 0) {
+        await indexedDBStorage.setItem(stateData);
+      }
+    } catch (error) {
+    }
+  },
+  removeItem: async () => {
+    try {
+      await indexedDBStorage.removeItem();
+    } catch (error) {
+    }
+  }
+});
+var persistIndexedDB = (initializer, options) => {
+  const { indexedDBConfig, ...rest } = options;
+  const indexedDBStorage = createIndexedDBStorage(indexedDBConfig);
+  const jsonStorage = createJSONStorage(
+    () => adaptToStateStorage(indexedDBStorage)
+  );
+  return persist(initializer, {
+    ...rest,
+    storage: jsonStorage
+  });
+};
+
+// src/provider/store/createDataStore.ts
+var createDataStore = (config) => {
+  const {
+    name,
+    dbName,
+    storeName,
+    keyPath,
+    endpoint,
+    baseUrl,
+    formatter = (data) => pathOr$1([], ["rows"], data),
+    initData
+    // brokerId,
+  } = config;
+  return create(
+    persistIndexedDB(
+      (set) => ({
+        name: storeName,
+        data: typeof initData === "undefined" ? [] : initData,
+        loading: false,
+        error: null,
+        fetchData: async (dynamicBaseUrl, options) => {
+          try {
+            set({ loading: true });
+            const brokerIdQuery = typeof options?.brokerId === "string" && options?.brokerId !== "orderly" ? `?broker_id=${options?.brokerId}` : "";
+            const url = `${dynamicBaseUrl || baseUrl || ""}${endpoint}${brokerIdQuery}`;
+            const data = await fetcher(url, {}, { formatter });
+            const dataWithBrokerId = data.map((item) => ({
+              ...item,
+              broker_id: options?.brokerId
+            }));
+            set({
+              data: dataWithBrokerId,
+              loading: false,
+              error: null
+            });
+            return dataWithBrokerId;
+          } catch (error) {
+            set({ error, loading: false });
+            return null;
+          }
+        }
+      }),
+      {
+        name,
+        indexedDBConfig: {
+          dbName,
+          storeName
+        },
+        //@ts-ignore
+        partialize: (state) => state.data,
+        merge: (persisted, current) => {
+          return {
+            ...current,
+            data: persisted
+          };
+        }
+      }
+    )
+  );
+};
+
+// src/provider/store/chainInfoMainStore.ts
+var useMainnetChainsStore = createDataStore({
+  name: "orderly-main-chain-info",
+  dbName: "ORDERLY_STORE",
+  storeName: ORDERLY_MAIN_CHAIN_INFO.name,
+  keyPath: ORDERLY_MAIN_CHAIN_INFO.keyPath,
+  endpoint: "/v1/public/chain_info",
+  baseUrl: "https://api.orderly.org",
+  initData: null
+});
+var testnetChainFallback = [ArbitrumSepoliaChainInfo, SolanaDevnetChainInfo];
+var useTestnetChainsStore = createDataStore({
+  name: "orderly-test-chain-info",
+  dbName: "ORDERLY_STORE",
+  storeName: ORDERLY_TEST_CHAIN_INFO.name,
+  keyPath: ORDERLY_TEST_CHAIN_INFO.keyPath,
+  endpoint: "/v1/public/chain_info",
+  baseUrl: "https://testnet-api.orderly.org",
+  initData: testnetChainFallback
+});
+
+// src/provider/store/mainTokenStore.ts
+var useMainTokenStore = createDataStore({
+  name: "orderly-main-token",
+  dbName: "ORDERLY_STORE",
+  storeName: ORDERLY_MAIN_TOKEN.name,
+  keyPath: ORDERLY_MAIN_TOKEN.keyPath,
+  endpoint: "/v1/public/token",
+  baseUrl: "https://api.orderly.org"
+});
+var useSwapSupportStore = create()(
+  persist(
+    (set) => ({
+      data: null,
+      loading: false,
+      error: null,
+      fetchData: async () => {
+        try {
+          set({ loading: true, error: null });
+          const res = await fetch("https://fi-api.woo.org/swap_support");
+          const data = await res.json();
+          if (data.status === "ok") {
+            set({ data: data.data, loading: false, error: null });
+            return data.data;
+          }
+          set((state) => ({
+            data: state.data ?? {},
+            error: new Error(data.message),
+            loading: false
+          }));
+          return null;
+        } catch (error) {
+          set((state) => ({
+            data: state.data ?? {},
+            error,
+            loading: false
+          }));
+          return null;
+        }
+      }
+    }),
+    {
+      name: "orderly-swap-support",
+      // Key for localStorage persistence
+      partialize: (state) => ({ data: state.data })
+      // Only persist data field
+    }
+  )
+);
+
+// src/provider/store/symbolStore.ts
+var useSymbolStore = createDataStore({
+  name: "orderly-main-symbols",
+  dbName: "ORDERLY_STORE",
+  storeName: ORDERLY_SYMBOLS.name,
+  keyPath: ORDERLY_SYMBOLS.keyPath,
+  endpoint: "/v1/public/info"
+});
+var testnetTokenFallback = TesnetTokenFallback([
+  ArbitrumSepoliaTokenInfo,
+  SolanaDevnetTokenInfo
+]);
+var useTestTokenStore = createDataStore({
+  name: "orderly-main-token",
+  dbName: "ORDERLY_STORE",
+  storeName: ORDERLY_TEST_TOKEN.name,
+  keyPath: ORDERLY_TEST_TOKEN.keyPath,
+  endpoint: "/v1/public/token",
+  initData: testnetTokenFallback
+});
+
+// src/usePreloadData.ts
+var usePreLoadData = () => {
+  const [timestampOffsetInitialized, setTimestampOffsetInitialized] = useState(false);
+  const { configStore, enableSwapDeposit } = useContext(OrderlyContext);
+  const env = configStore.get("env");
+  const apiBaseUrl = configStore.get("apiBaseUrl");
+  const urlPrefix = env === "prod" ? "https://testnet-api.orderly.org" : configStore.get("apiBaseUrl");
+  const fetchMainTokens = useMainTokenStore((state) => state.fetchData);
+  const fetchTestTokens = useTestTokenStore((state) => state.fetchData);
+  const fetchMainChains = useMainnetChainsStore((state) => state.fetchData);
+  const fetchTestChains = useTestnetChainsStore((state) => state.fetchData);
+  const fetchSymbols = useSymbolStore((state) => state.fetchData);
+  const fetchSwapSupport = useSwapSupportStore((state) => state.fetchData);
+  const setTokensInfo = useAppStore((state) => state.actions.setTokensInfo);
+  const mainTokenInfo = useMainTokenStore((state) => state.data);
+  const testTokenInfo = useTestTokenStore((state) => state.data);
+  const swapSupportInfo = useSwapSupportStore((state) => state.data);
+  useEffect(() => {
+    fetchMainTokens();
+    fetchSymbols(apiBaseUrl).then((symbols) => {
+    });
+    fetchMainChains(void 0, {
+      brokerId: configStore.get("brokerId")
+    });
+  }, []);
+  useEffect(() => {
+    if (!urlPrefix)
+      return;
+    fetchTestTokens(urlPrefix);
+    fetchTestChains(urlPrefix, {
+      brokerId: configStore.get("brokerId")
+    });
+  }, [urlPrefix]);
+  useEffect(() => {
+    if (!mainTokenInfo || !testTokenInfo)
+      return;
+    setTokensInfo(env === "prod" ? mainTokenInfo : testTokenInfo);
+  }, [mainTokenInfo, testTokenInfo]);
+  useEffect(() => {
+    if (swapSupportInfo || !enableSwapDeposit)
+      return;
+    fetchSwapSupport();
+  }, [swapSupportInfo, enableSwapDeposit]);
+  const { data: systemInfo } = useSWR__default(
+    "/v1/public/system_info",
+    async (url, init2) => {
+      const data = await fetch(
+        url.startsWith("http") ? url : `${apiBaseUrl}${url}`,
+        init2
+      );
+      return await data.json();
+    },
+    {
+      errorRetryCount: 3,
+      errorRetryInterval: 500
+    }
+  );
+  useEffect(() => {
+    if (timestampOffsetInitialized)
+      return;
+    if (typeof systemInfo !== "undefined") {
+      const serverTimestamp = systemInfo.timestamp;
+      const localTimestamp = Date.now();
+      const timestampOffset = serverTimestamp - localTimestamp;
+      if (isNaN(timestampOffset)) {
+        return;
+      }
+      getGlobalObject().__ORDERLY_timestamp_offset = timestampOffset;
+      setTimestampOffsetInitialized(true);
+    }
+  }, [systemInfo, timestampOffsetInitialized]);
+  const isDone = useMemo(() => {
+    return timestampOffsetInitialized;
+  }, [timestampOffsetInitialized]);
+  return {
+    error: null,
+    done: isDone
+  };
+};
+function useSessionStorage(key, initialValue) {
+  const readValue = useCallback(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.sessionStorage.getItem(key);
+      return item ? parseJSON(item) : initialValue;
+    } catch (error) {
+      return initialValue;
+    }
+  }, [initialValue, key]);
+  const [storedValue, setStoredValue] = useState(readValue);
+  const setValue = (value) => {
+    try {
+      const newValue = value instanceof Function ? value(storedValue) : value;
+      window.sessionStorage.setItem(key, JSON.stringify(newValue));
+      setStoredValue(newValue);
+    } catch (error) {
+    }
+  };
+  useEffect(() => {
+    setStoredValue(readValue());
+  }, []);
+  useEffect(() => {
+    if (typeof window == "undefined") {
+      return;
+    }
+    window.addEventListener?.("storage", handleStorageChange);
+    return () => {
+      window.removeEventListener?.("storage", handleStorageChange);
+    };
+  });
+  const handleStorageChange = useCallback(
+    (event) => {
+      if (event?.key && event.key !== key) {
+        return;
+      }
+      setStoredValue(readValue());
     },
     [key, readValue]
   );
@@ -2142,7 +2827,7 @@ var useNetworkInfo = (networkId) => {
 };
 
 // src/orderly/useAccountInfo.ts
-var useAccountInfo = () => {
+var useAccountInfo2 = () => {
   return usePrivateQuery("/v1/client/info", {
     revalidateOnFocus: false
   });
@@ -2160,7 +2845,7 @@ var computeEffectiveFromBps = (userBps, orderlyBps, rebate) => {
   return effective;
 };
 var useFeeState = () => {
-  const { data: accountInfo, isLoading: isAccountLoading } = useAccountInfo();
+  const { data: accountInfo, isLoading: isAccountLoading } = useAccountInfo2();
   const { data: referralData, isLoading: isReferralLoading } = usePrivateQuery("/v1/referral/info", {
     revalidateOnFocus: true,
     errorRetryCount: 3,
@@ -2512,215 +3197,87 @@ var useMarketsStream = () => {
   });
   const topic = "tickers";
   const { data: tickers } = useSWRSubscription("tickers", (_, { next }) => {
-    const unsubscribe = ws.subscribe(
-      // { event: "subscribe", topic: "markprices" },
-      topic,
-      {
-        onMessage: (message) => {
-          next(null, message);
-        }
-        // onUnsubscribe: () => {
-        //   return "markprices";
-        // },
-        // onError: (error: any) => {
-        //
-        // },
-      }
-    );
-    return () => {
-      unsubscribe?.();
-    };
-  });
-  const value = useMemo(() => {
-    if (!futures)
-      return null;
-    if (!tickers)
-      return futures;
-    return futures.map((item) => {
-      const ticker = tickers.find(
-        (t) => t.symbol === item.symbol
-      );
-      if (ticker) {
-        const data = {
-          ...item,
-          ["24h_close"]: ticker.close,
-          ["24h_open"]: ticker.open,
-          /**
-           * @deprecated
-           * spelling mistake, use 24h_volume to instead, will be remove next version
-           */
-          ["24h_volumn"]: ticker.volume,
-          ["24h_volume"]: ticker.volume,
-          ["24h_amount"]: ticker.amount,
-          change: 0
-        };
-        if (ticker.close !== void 0 && ticker.open !== void 0) {
-          data["change"] = new Decimal(ticker.close).minus(ticker.open).div(ticker.open).toNumber();
-        }
-        return data;
-      }
-      return item;
-    });
-  }, [futures, tickers]);
-  return { data: value };
-};
-function createGetter(data, depth = 2) {
-  const getValue = (value, defaultValue) => {
-    if (defaultValue === void 0) {
-      return value;
-    }
-    return value ?? defaultValue;
-  };
-  return new Proxy(data || {}, {
-    get(target, property, receiver) {
-      if (property === "isNil") {
-        return isNil(data);
-      }
-      if (depth === 1) {
-        return (defaultValue) => {
-          if (!target)
-            return defaultValue;
-          return getValue(target[property], defaultValue);
-        };
-      }
-      return (key, defaultValue) => {
-        if (key) {
-          return getValue(target[property]?.[key], defaultValue);
-        } else {
-          return getValue(target[property], defaultValue);
-        }
-      };
-    }
-  });
-}
-var useAppStore = create()(
-  immer((set) => ({
-    // accountInfo: null,
-    portfolio: {
-      totalCollateral: zero,
-      totalValue: null,
-      freeCollateral: zero,
-      availableBalance: 0,
-      unsettledPnL: 0,
-      totalUnrealizedROI: 0
-    },
-    appState: {
-      positionsLoading: false,
-      ordersLoading: false,
-      fundingRatesLoading: false,
-      ready: false
-    },
-    actions: {
-      cleanAll: () => {
-        set((state) => {
-          state.accountInfo = void 0;
-          state.portfolio = {
-            totalCollateral: zero,
-            totalValue: null,
-            freeCollateral: zero,
-            availableBalance: 0,
-            unsettledPnL: 0,
-            totalUnrealizedROI: 0
-          };
-        }, false);
-      },
-      setAccountInfo: (accountInfo) => {
-        set(
-          (state) => {
-            state.accountInfo = accountInfo;
-          },
-          false
-          // "setAccountInfo"
-        );
-      },
-      setSymbolsInfo: (symbolsInfo) => {
-        set(
-          (state) => {
-            state.symbolsInfo = symbolsInfo;
-          },
-          false
-          // "setSymbolsInfo"
-        );
-      },
-      setRwaSymbolsInfo: (rwaSymbolsInfo) => {
-        set(
-          (state) => {
-            state.rwaSymbolsInfo = rwaSymbolsInfo;
-          },
-          false
-          // "setRwaSymbolsInfo"
-        );
-      },
-      setFundingRates: (fundingRates) => {
-        set(
-          (state) => {
-            state.fundingRates = fundingRates;
-          },
-          false
-          // "setFundingRates"
-        );
-      },
-      updateAppStatus: (key, value) => {
-        set(
-          (state) => {
-            state.appState[key] = value;
-          },
-          false
-          // "updateAppStatus"
-        );
-      },
-      updatePortfolio: (key, value) => {
-        set(
-          (state) => {
-            state.portfolio[key] = value;
-          },
-          false
-          // "updatePortfolio"
-        );
-      },
-      batchUpdateForPortfolio: (data) => {
-        set(
-          (state) => {
-            state.portfolio = { ...state.portfolio, ...data };
-          },
-          false
-          // "batchUpdateForPortfolio"
-        );
-      },
-      restoreHolding: (holding) => {
-        set(
-          (state) => {
-            state.portfolio.holding = holding;
-          },
-          false
-          // "updateHolding"
-        );
-      },
-      updateHolding(msg) {
-        set(
-          (state) => {
-            if (state.portfolio.holding && state.portfolio.holding.length) {
-              for (const key in msg) {
-                const holding = state.portfolio.holding.find(
-                  (item) => item.token === key
-                );
-                if (holding) {
-                  holding.holding = msg[key].holding;
-                  holding.frozen = msg[key].frozen;
-                }
-              }
-            }
-          },
-          false
-          // "updateHolding"
-        );
+    const unsubscribe = ws.subscribe(
+      // { event: "subscribe", topic: "markprices" },
+      topic,
+      {
+        onMessage: (message) => {
+          next(null, message);
+        }
+        // onUnsubscribe: () => {
+        //   return "markprices";
+        // },
+        // onError: (error: any) => {
+        //
+        // },
+      }
+    );
+    return () => {
+      unsubscribe?.();
+    };
+  });
+  const value = useMemo(() => {
+    if (!futures)
+      return null;
+    if (!tickers)
+      return futures;
+    return futures.map((item) => {
+      const ticker = tickers.find(
+        (t) => t.symbol === item.symbol
+      );
+      if (ticker) {
+        const data = {
+          ...item,
+          ["24h_close"]: ticker.close,
+          ["24h_open"]: ticker.open,
+          /**
+           * @deprecated
+           * spelling mistake, use 24h_volume to instead, will be remove next version
+           */
+          ["24h_volumn"]: ticker.volume,
+          ["24h_volume"]: ticker.volume,
+          ["24h_amount"]: ticker.amount,
+          change: 0
+        };
+        if (ticker.close !== void 0 && ticker.open !== void 0) {
+          data["change"] = new Decimal(ticker.close).minus(ticker.open).div(ticker.open).toNumber();
+        }
+        return data;
       }
+      return item;
+    });
+  }, [futures, tickers]);
+  return { data: value };
+};
+function createGetter(data, depth = 2) {
+  const getValue = (value, defaultValue) => {
+    if (defaultValue === void 0) {
+      return value;
     }
-  }))
-);
-var useAccountInfo2 = () => useAppStore((state) => state.accountInfo);
-var usePortfolio = () => useAppStore((state) => state.portfolio);
-var useFundingRateBySymbol = (symbol) => useAppStore((state) => state.fundingRates?.[symbol]);
+    return value ?? defaultValue;
+  };
+  return new Proxy(data || {}, {
+    get(target, property, receiver) {
+      if (property === "isNil") {
+        return isNil(data);
+      }
+      if (depth === 1) {
+        return (defaultValue) => {
+          if (!target)
+            return defaultValue;
+          return getValue(target[property], defaultValue);
+        };
+      }
+      return (key, defaultValue) => {
+        if (key) {
+          return getValue(target[property]?.[key], defaultValue);
+        } else {
+          return getValue(target[property], defaultValue);
+        }
+      };
+    }
+  });
+}
 
 // src/orderly/useRwaSymbolsInfo.ts
 var isCurrentlyTrading = (nextClose, status, currentTime = Date.now()) => {
@@ -3402,9 +3959,15 @@ var orderbook_service_default = orderBookService;
 var useMarkPrice = (symbol) => {
   const ws = useWS();
   const [price, setPrice] = useState(0);
+  const symbolRef = useRef(symbol);
+  symbolRef.current = symbol;
   useEffect(() => {
     const unsubscribe = ws.subscribe(`${symbol}@markprice`, {
       onMessage: (message) => {
+        if (message.symbol !== symbolRef.current) {
+          unsubscribe?.();
+          return;
+        }
         setPrice(message.price);
       }
     });
@@ -3414,33 +3977,6 @@ var useMarkPrice = (symbol) => {
   }, [symbol]);
   return { data: price };
 };
-var useIndexPrice = (symbol) => {
-  symbol = symbol.replace("PERP", "SPOT");
-  const ws = useWS();
-  return useSWRSubscription(`${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(`${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`,
@@ -3472,6 +4008,45 @@ var useFutures = () => {
     error
   };
 };
+var useIndexPrice = (symbol) => {
+  symbol = symbol.replace("PERP", "SPOT");
+  const symbolRef = useRef(symbol);
+  symbolRef.current = symbol;
+  const ws = useWS();
+  return useSWRSubscription(`${symbol}@indexprice`, (key, { next }) => {
+    const unsubscribe = ws.subscribe(`${symbol}@indexprice`, {
+      onMessage: (message) => {
+        if (message.symbol !== symbolRef.current) {
+          unsubscribe?.();
+          return;
+        }
+        next(null, message.price);
+      }
+    });
+    return () => {
+      unsubscribe?.();
+    };
+  });
+};
+var useOpenInterest = (symbol) => {
+  const ws = useWS();
+  const symbolRef = useRef(symbol);
+  symbolRef.current = symbol;
+  return useSWRSubscription(`${symbol}@openinterest`, (key, { next }) => {
+    const unsubscribe = ws.subscribe(`${symbol}@openinterest`, {
+      onMessage: (message) => {
+        if (message.symbol !== symbolRef.current) {
+          unsubscribe?.();
+          return;
+        }
+        next(null, message.openInterest);
+      }
+    });
+    return () => {
+      unsubscribe?.();
+    };
+  });
+};
 
 // src/orderly/useTickerStream.ts
 var useTickerStream = (symbol) => {
@@ -3485,6 +4060,8 @@ var useTickerStream = (symbol) => {
     }
   );
   const [ticker, setTicker] = useState();
+  const symbolRef = useRef(symbol);
+  symbolRef.current = symbol;
   const ws = useWS();
   useEffect(() => {
     const unsubscribe = ws.subscribe(
@@ -3492,16 +4069,12 @@ var useTickerStream = (symbol) => {
       `${symbol}@ticker`,
       {
         onMessage: (message) => {
-          if (message.symbol !== symbol)
+          if (message.symbol !== symbolRef.current) {
+            unsubscribe?.();
             return;
+          }
           setTicker(message);
         }
-        // onUnsubscribe: () => {
-        //   return "markprices";
-        // },
-        // onError: (error: any) => {
-        //
-        // },
       }
     );
     return () => {
@@ -4200,31 +4773,11 @@ var useLeverage = () => {
 var useOdosQuote = () => {
   return useMutation(`https://api.odos.xyz/sor/quote/v2`);
 };
-var useTokensInfoStore = 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 useMemo(() => {
-    return tokensInfo?.find((item) => item.token === token);
-  }, [tokensInfo, token]);
-};
-
-// src/orderly/useComputedLTV.ts
 var { LTV, collateralRatio } = account;
 var useComputedLTV = (options = {}) => {
   const { input, token } = options;
   const isUSDC = token?.toUpperCase() === "USDC";
-  const tokensInfo = useTokensInfo();
+  const tokensInfo = useAppStore((state) => state.tokensInfo);
   const { usdc, data: holdingList = [] } = useHoldingStream();
   const { getIndexPrice } = useIndexPricesStream();
   const { unsettledPnL } = useCollateral();
@@ -4476,7 +5029,7 @@ var CalculatorContext = class _CalculatorContext {
     this.accountInfo = useAppStore.getState().accountInfo;
     this.symbolsInfo = useAppStore.getState().symbolsInfo;
     this.fundingRates = useAppStore.getState().fundingRates;
-    this.tokensInfo = useTokensInfoStore.getState().tokensInfo;
+    this.tokensInfo = useAppStore.getState().tokensInfo || [];
   }
   get(fn) {
     return fn(this.output);
@@ -5275,7 +5828,6 @@ var usePositionStream = (symbol = "all", options) => {
           ...rust,
           unrealized_pnl: unrealized_pnl_index ?? 0,
           unsettled_pnl_ROI: unrealized_pnl_ROI_index ?? 0
-          // mark_price: item.last_price,
         };
       });
     }
@@ -5287,9 +5839,6 @@ var usePositionStream = (symbol = "all", options) => {
         const partial_tp_sl = partialPossitionOrder ? findTPSLFromOrder(partialPossitionOrder) : void 0;
         return {
           ...item,
-          // tp_trigger_price: tp_sl_pricer?.tp_trigger_price,
-          // sl_trigger_price: tp_sl_pricer?.sl_trigger_price,
-          // algo_order: related_order,
           full_tp_sl: {
             tp_trigger_price: full_tp_sl?.tp_trigger_price,
             sl_trigger_price: full_tp_sl?.sl_trigger_price,
@@ -5300,7 +5849,6 @@ var usePositionStream = (symbol = "all", options) => {
             tp_trigger_price: partial_tp_sl?.tp_trigger_price,
             sl_trigger_price: partial_tp_sl?.sl_trigger_price,
             algo_order: partialPossitionOrder
-            // algo_order: partialPositionOrders,
           }
         };
       });
@@ -5313,11 +5861,14 @@ var usePositionStream = (symbol = "all", options) => {
   return [
     {
       rows,
-      // rows: formattedPositions[0],
+      // Processed position rows with TP/SL data
       aggregated: formattedPositions?.[1] ?? EMPTY_OBJECT,
       totalCollateral,
+      // Portfolio-wide collateral
       totalValue,
+      // Total portfolio value
       totalUnrealizedROI
+      // Total unrealized ROI across all positions
     },
     positionInfoGetter,
     {
@@ -5647,6 +6198,8 @@ var useMarketTradeStream = (symbol, options = {}) => {
   }
   const [trades, setTrades] = useState([]);
   const [isLoading, setIsLoading] = useState(false);
+  const symbolRef = useRef(symbol);
+  symbolRef.current = symbol;
   const { limit = 50 } = options;
   const ws = useWS();
   useEffect(() => {
@@ -5671,7 +6224,7 @@ var useMarketTradeStream = (symbol, options = {}) => {
     );
   }, [symbol]);
   useEffect(() => {
-    const unsubscript = ws.subscribe(
+    const unsubscribe = ws.subscribe(
       {
         id: `${symbol}@trade`,
         event: "subscribe",
@@ -5680,6 +6233,10 @@ var useMarketTradeStream = (symbol, options = {}) => {
       },
       {
         onMessage: (data) => {
+          if (data.symbol !== symbolRef.current) {
+            unsubscribe?.();
+            return;
+          }
           setTrades((prev) => {
             const arr = [{ ...data, ts: getTimestamp() }, ...prev];
             if (arr.length > limit) {
@@ -5691,7 +6248,7 @@ var useMarketTradeStream = (symbol, options = {}) => {
       }
     );
     return () => {
-      unsubscript?.();
+      unsubscribe?.();
     };
   }, [symbol]);
   return { data: trades, isLoading };
@@ -5755,7 +6312,7 @@ var useLeverageBySymbol = (symbol) => {
 // src/orderly/useMaxQty.ts
 var useMaxQty = (symbol, side, reduceOnly = false) => {
   const positions3 = usePositions();
-  const accountInfo = useAccountInfo2();
+  const accountInfo = useAccountInfo();
   const symbolInfo = useSymbolsInfo();
   const { totalCollateral } = useCollateral();
   const { data: markPrices } = useMarkPricesStream();
@@ -5874,11 +6431,6 @@ var TestNetWhiteList = [
   ABSTRACT_TESTNET_CHAINID,
   BSC_TESTNET_CHAINID
 ];
-var testnetTokenFallback = TesntTokenFallback([
-  ArbitrumSepoliaTokenInfo,
-  SolanaDevnetTokenInfo
-]);
-var testnetChainFallback = [ArbitrumSepoliaChainInfo, SolanaDevnetChainInfo];
 function useChains(networkId, options = {}) {
   const { pick: pickField, ...swrOptions } = options;
   const {
@@ -5890,47 +6442,16 @@ function useChains(networkId, options = {}) {
   const filterFun = useRef(options?.filter);
   filterFun.current = options?.filter;
   const chainsMap = useRef(/* @__PURE__ */ new Map());
-  const brokerId = configStore.get("brokerId");
-  const env = configStore.get("env");
-  const brokerIdQuery = brokerId !== "orderly" ? `?broker_id=${brokerId}` : "";
-  const urlPrefix = env === "prod" ? "https://testnet-api.orderly.org" : "";
   const needFetchFromAPI = options.forceAPI || !customChains;
-  const commonSwrOpts = {
-    revalidateIfStale: false,
-    revalidateOnFocus: false,
-    revalidateOnReconnect: false,
-    // If false, undefined data gets cached against the key.
-    revalidateOnMount: true,
-    // don't duplicate a request with the same key for 1hr
-    dedupingInterval: 36e5,
-    ...swrOptions
-  };
-  const { data: tokenChainsRes, error: tokenError } = useQuery(
-    "https://api.orderly.org/v1/public/token",
-    { ...commonSwrOpts }
-  );
-  const { data: testTokenChainsRes } = useQuery(
-    `${urlPrefix}/v1/public/token`,
-    {
-      ...commonSwrOpts,
-      fallbackData: testnetTokenFallback
-    }
-  );
-  const { data: chainInfos, error: chainInfoErr } = useQuery(
-    needFetchFromAPI ? `https://api.orderly.org/v1/public/chain_info${brokerIdQuery}` : null,
-    { ...commonSwrOpts }
-  );
-  const { data: testChainInfos, error: testChainInfoError } = useQuery(
-    needFetchFromAPI ? `${urlPrefix}/v1/public/chain_info${brokerIdQuery}` : null,
-    {
-      ...commonSwrOpts,
-      fallbackData: testnetChainFallback,
-      onError: (error) => {
-      }
-    }
-  );
+  const { data: tokenChainsRes, error: tokenError } = useMainTokenStore();
+  const testTokenChainsRes = useTestTokenStore((state) => state.data);
+  const chainInfos = useMainnetChainsStore((state) => state.data);
+  const testChainInfos = useTestnetChainsStore((state) => state.data);
   const { swapChains, swapChainsError } = useSwapChains();
   const chains = useMemo(() => {
+    if (!tokenChainsRes || !testTokenChainsRes || !chainInfos || !testChainInfos) {
+      return [];
+    }
     const mainnetChains = formatChains({
       tokenChains: tokenChainsRes,
       chainInfos,
@@ -6038,19 +6559,7 @@ function filterByAllowedChains(chains, allowedChains) {
 }
 function useSwapChains() {
   const { enableSwapDeposit } = useContext(OrderlyContext);
-  const { data: swapChainsRes, error: swapChainsError } = useSWR__default(
-    () => enableSwapDeposit ? "https://fi-api.woo.org/swap_support" : null,
-    (url) => fetch(url).then((res) => res.json()),
-    {
-      revalidateIfStale: false,
-      revalidateOnFocus: false,
-      revalidateOnReconnect: false,
-      // If false, undefined data gets cached against the key.
-      revalidateOnMount: true,
-      // dont duplicate a request w/ same key for 1hr
-      dedupingInterval: 36e5
-    }
-  );
+  const { data: swapChainsRes, error: swapChainsError } = useSwapSupportStore();
   const swapChains = useMemo(() => {
     if (!enableSwapDeposit || !swapChainsRes || !swapChainsRes.data) {
       return [];
@@ -6478,7 +6987,7 @@ var useDeposit = (options) => {
     [options.address]
   );
   const fetchBalanceHandler = useCallback(
-    async (address, decimals) => {
+    async (address, decimals, token) => {
       let balance2;
       try {
         if (address && isNativeTokenChecker(address)) {
@@ -6492,7 +7001,8 @@ var useDeposit = (options) => {
         }
       } catch (err) {
         if (ignoreBalanceError({
-          token: options.srcToken,
+          // TODO: use token params instead of options.srcToken
+          token: token || options.srcToken,
           chainNamespace: account9.walletAdapter?.chainNamespace,
           err
         })) {
@@ -6507,16 +7017,17 @@ var useDeposit = (options) => {
   const fetchBalances = useCallback(async (tokens) => {
     const tasks = [];
     for (const token of tokens) {
-      if (isNativeTokenChecker(token.address)) {
-        continue;
-      }
       tasks.push(
-        account9.assetsManager.getBalance(token.address, {
-          decimals: token?.decimals
-        })
+        fetchBalanceHandler(token.address, token?.decimals, token.symbol)
       );
     }
-    const balances = await Promise.all(tasks);
+    const results = await Promise.allSettled(tasks);
+    const balances = {};
+    for (const [index, balance2] of results.entries()) {
+      if (balance2.status === "fulfilled") {
+        balances[tokens[index].symbol] = balance2.value;
+      }
+    }
     return balances;
   }, []);
   const getAllowance = async (inputs) => {
@@ -9516,7 +10027,7 @@ var useSubAccountDataObserver = (accountId) => {
   const { data: indexPrices } = useIndexPricesStream();
   const symbolsInfo = useSymbolsInfo();
   const fundingRates = useFundingRatesStore();
-  const tokensInfo = useTokensInfo();
+  const tokensInfo = useAppStore((state) => state.tokensInfo);
   const [holding, setHolding] = useState([]);
   const [positions3, setPositions] = useState(
     POSITION_EMPTY
@@ -9671,7 +10182,9 @@ var useSubAccountDataObserver = (accountId) => {
 var { maxWithdrawalUSDC: maxWithdrawalUSDC2, maxWithdrawalOtherCollateral: maxWithdrawalOtherCollateral2, collateralRatio: collateralRatio3 } = account;
 function useSubAccountMaxWithdrawal(options) {
   const { token, unsettledPnL, freeCollateral, holdings } = options;
-  const tokenInfo = useTokenInfo(token);
+  const tokenInfo = useAppStore(
+    (state) => state.tokensInfo?.find((item) => item.token === token)
+  );
   const { data: indexPrices } = useIndexPricesStream();
   const usdc = useMemo(() => {
     const usdc2 = holdings?.find((item) => item.token === "USDC");
@@ -10029,7 +10542,7 @@ var useTPSLOrder = (position, options) => {
 };
 var useMaxLeverage = (symbol) => {
   const symbolsInfo = useSymbolsInfo();
-  const accountInfo = useAccountInfo2();
+  const accountInfo = useAccountInfo();
   const maxAccountLeverage = accountInfo?.max_leverage;
   const maxSymbolLeverage = useMemo(() => {
     const symbolInfo = symbolsInfo[symbol];
@@ -10398,6 +10911,16 @@ var useStorageLedgerAddress = () => {
     ledgerWallet
   };
 };
+var useTokensInfo = () => {
+  const tokensInfo = useAppStore((state) => state.tokensInfo);
+  return tokensInfo;
+};
+var useTokenInfo = (token) => {
+  const tokensInfo = useAppStore((state) => state.tokensInfo);
+  return useMemo(() => {
+    return tokensInfo?.find((item) => item.token === token);
+  }, [tokensInfo, token]);
+};
 var useMarketStore = create(
   (set, get3) => ({
     market: [],
@@ -10443,34 +10966,31 @@ var usePublicDataObserver = () => {
     (state) => state.actions
   );
   const { updateMarket } = useMarketStore((state) => state.actions);
-  const setTokensInfo = useTokensInfoStore((state) => state.setTokensInfo);
+  const symbols = useSymbolStore((state) => state.data);
   const { dataAdapter } = useOrderlyContext();
   const resolveList = typeof dataAdapter?.symbolList === "function" ? dataAdapter.symbolList : (oriVal) => oriVal;
-  useQuery(`/v1/public/info`, {
-    ...publicQueryOptions,
-    onSuccess(data) {
-      if (!data || !data?.length) {
-        return {};
-      }
-      const obj = {};
-      for (let index = 0; index < data.length; index++) {
-        const item = data[index];
-        const arr = item.symbol.split("_");
-        const base_dp = getPrecisionByNumber(item.base_tick);
-        const quote_dp = getPrecisionByNumber(item.quote_tick);
-        obj[item.symbol] = {
-          ...item,
-          base_dp,
-          quote_dp,
-          base: arr[1],
-          quote: arr[2],
-          type: arr[0],
-          name: `${arr[1]}-${arr[0]}`
-        };
-      }
-      setSymbolsInfo(obj);
+  useEffect(() => {
+    if (!symbols || !symbols?.length) {
+      return;
     }
-  });
+    const obj = {};
+    for (let index = 0; index < symbols.length; index++) {
+      const item = symbols[index];
+      const arr = item.symbol.split("_");
+      const base_dp = getPrecisionByNumber(item.base_tick);
+      const quote_dp = getPrecisionByNumber(item.quote_tick);
+      obj[item.symbol] = {
+        ...item,
+        base_dp,
+        quote_dp,
+        base: arr[1],
+        quote: arr[2],
+        type: arr[0],
+        name: `${arr[1]}-${arr[0]}`
+      };
+    }
+    setSymbolsInfo(obj);
+  }, [symbols]);
   useQuery(`/v1/public/rwa/info`, {
     ...publicQueryOptions,
     onSuccess(data) {
@@ -10526,16 +11046,6 @@ var usePublicDataObserver = () => {
       return resolveList(data);
     }
   });
-  useQuery(`/v1/public/token`, {
-    // revalidateOnFocus: false,
-    ...publicQueryOptions,
-    onSuccess(data) {
-      if (!data || !data.length) {
-        return [];
-      }
-      setTokensInfo(data);
-    }
-  });
 };
 function getEstFundingRate(data) {
   if (!data) {
@@ -10547,9 +11057,26 @@ function getEstFundingRate(data) {
   }
   return est_funding_rate;
 }
+var useDatabaseInitialization = () => {
+  const [isInitialized, setIsInitialized] = useState(false);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    const initialize = async () => {
+      try {
+        await initializeAppDatabase(DEFAULT_DATABASE_CONFIG);
+        setIsInitialized(true);
+      } catch (err) {
+        setError(err);
+      }
+    };
+    initialize();
+  }, []);
+  return { isInitialized, error };
+};
 var DataCenterProvider = ({
   children
 }) => {
+  useDatabaseInitialization();
   const { error, done } = usePreLoadData();
   useInitRwaSymbolsRuntime();
   const calculatorService = useCalculatorService();
@@ -10574,9 +11101,6 @@ var DataCenterProvider = ({
   if (error) {
     return /* @__PURE__ */ jsx("div", { children: "Data load failed" });
   }
-  if (!done) {
-    return null;
-  }
   return /* @__PURE__ */ jsx(DataCenterContext.Provider, { value: memoizedValue, children });
 };
 var OrderlyConfigProvider = (props) => {
@@ -17304,7 +17828,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
   });
   const actions = useMarkPriceActions();
   const symbolConfig = useSymbolsInfo();
-  const accountInfo = useAccountInfo2();
+  const accountInfo = useAccountInfo();
   const positions3 = usePositions();
   const symbolLeverage = useLeverageBySymbol(symbol);
   const symbolInfo = symbolConfig[symbol]();
@@ -18011,6 +18535,6 @@ var usePositionClose = (options) => {
   };
 };
 
-export { DefaultLayoutConfig, DistributionId, ENVType2 as ENVType, EpochStatus, ExtendedConfigStore, MaintenanceStatus, MarketsStorageKey, MarketsType, ORDERLY_ORDERBOOK_DEPTH_KEY, OrderlyConfigProvider, OrderlyContext, OrderlyProvider, StatusProvider, TWType, WalletConnectorContext, WsNetworkStatus, checkNotional, cleanStringStyle, fetcher, findPositionTPSLFromOrders, findTPSLFromOrder, findTPSLOrderPriceFromOrder, getMinNotional, getPriceKey, isCurrentlyClosed, isCurrentlyTrading, noCacheConfig, parseJSON, useAccount, useAccountInfo, useAccountInstance, useAccountRewardsHistory, useAllBrokers, useApiKeyManager, useAssetsHistory, useAudioPlayer, useBalanceSubscription, useBalanceTopic, useBoolean, useChain, useChainInfo, useChains, useCheckReferralCode, useCollateral, useCommission, useComputedLTV, useConfig, useConvert, useCurEpochEstimate, useDaily, useDeposit, useDistribution, useDistributionHistory, useEpochInfo, useEventEmitter, useFeeState, useFundingDetails, useFundingFeeHistory, useFundingRate, useFundingRateBySymbol, useFundingRateHistory, useFundingRates, useFundingRatesStore, useGetClaimed, useGetEnv, useGetReferralCode, useGetRwaSymbolCloseTimeInterval, useGetRwaSymbolInfo, useGetRwaSymbolOpenStatus, useGetRwaSymbolOpenTimeInterval, useHoldingStream, useIndexPrice, useIndexPricesStream, useInfiniteQuery, useInitRwaSymbolsRuntime, useInternalTransfer, useKeyStore, useLazyQuery, useLeverage, useLeverageBySymbol, useLocalStorage, useMaintenanceStatus, useMarginRatio, useMarkPrice, useMarkPriceBySymbol, useMarkPricesStream, useMarket, useMarketList, useMarketMap, useMarketTradeStream, useMarkets, useMarketsStore, useMarketsStream, useMaxLeverage, useMaxQty, useMaxWithdrawal, useMediaQuery, useMemoizedFn, useMutation, useNetworkInfo, useOdosQuote, useOrderEntity, useOrderEntry2 as useOrderEntry, useOrderEntry as useOrderEntry_deprecated, useOrderStore2 as useOrderStore, useOrderStream, useOrderbookStream, useOrderlyContext, usePortfolio, usePositionActions, usePositionClose, usePositionStream, usePoster, usePreLoadData, usePrivateDataObserver, usePrivateInfiniteQuery, usePrivateQuery, useQuery, useRefereeHistory, useRefereeInfo, useRefereeRebateSummary, useReferralInfo, useReferralRebateSummary, useRestrictedInfo, useRwaSymbolsInfo, useRwaSymbolsInfoStore, useSessionStorage, useSettleSubscription, useSimpleDI, useStatisticsDaily, useStorageChain, useStorageLedgerAddress, useSubAccountDataObserver, useSubAccountMaxWithdrawal, useSubAccountMutation, useSubAccountQuery, useSubAccountWS, useSymbolInfo, useSymbolLeverage, useSymbolPriceRange, useSymbolsInfo, useSymbolsInfoStore, useTPSLOrder, useTickerStream, useTokenInfo, useTokensInfo, useTrack, useTrackingInstance, useTradingRewardsStatus, useTransfer, useTransferHistory, useUpdatedRef, useVaultsHistory, useWS, useWalletConnector, useWalletRewardsHistory, useWalletSubscription, useWalletTopic, useWithdraw, useWsStatus, utils_exports as utils, version_default as version };
+export { DefaultLayoutConfig, DistributionId, ENVType2 as ENVType, EpochStatus, ExtendedConfigStore, MaintenanceStatus, MarketsStorageKey, MarketsType, ORDERLY_ORDERBOOK_DEPTH_KEY, OrderlyConfigProvider, OrderlyContext, OrderlyProvider, StatusProvider, TWType, WalletConnectorContext, WsNetworkStatus, checkNotional, cleanStringStyle, fetcher, findPositionTPSLFromOrders, findTPSLFromOrder, findTPSLOrderPriceFromOrder, getMinNotional, getPriceKey, indexedDBManager, initializeAppDatabase, isCurrentlyClosed, isCurrentlyTrading, noCacheConfig, parseJSON, persistIndexedDB, resetTimestampOffsetState, timestampWaitingMiddleware, useAccount, useAccountInfo2 as useAccountInfo, useAccountInstance, useAccountRewardsHistory, useAllBrokers, useApiKeyManager, useAppStore, useAssetsHistory, useAudioPlayer, useBalanceSubscription, useBalanceTopic, useBoolean, useChain, useChainInfo, useChains, useCheckReferralCode, useCollateral, useCommission, useComputedLTV, useConfig, useConvert, useCurEpochEstimate, useDaily, useDeposit, useDistribution, useDistributionHistory, useEpochInfo, useEventEmitter, useFeeState, useFundingDetails, useFundingFeeHistory, useFundingRate, useFundingRateBySymbol, useFundingRateHistory, useFundingRates, useFundingRatesStore, useGetClaimed, useGetEnv, useGetReferralCode, useGetRwaSymbolCloseTimeInterval, useGetRwaSymbolInfo, useGetRwaSymbolOpenStatus, useGetRwaSymbolOpenTimeInterval, useHoldingStream, useIndexPrice, useIndexPricesStream, useInfiniteQuery, useInitRwaSymbolsRuntime, useInternalTransfer, useKeyStore, useLazyQuery, useLeverage, useLeverageBySymbol, useLocalStorage, useMainTokenStore, useMainnetChainsStore, useMaintenanceStatus, useMarginRatio, useMarkPrice, useMarkPriceBySymbol, useMarkPricesStream, useMarket, useMarketList, useMarketMap, useMarketTradeStream, useMarkets, useMarketsStore, useMarketsStream, useMaxLeverage, useMaxQty, useMaxWithdrawal, useMediaQuery, useMemoizedFn, useMutation, useNetworkInfo, useOdosQuote, useOrderEntity, useOrderEntry2 as useOrderEntry, useOrderEntry as useOrderEntry_deprecated, useOrderStore2 as useOrderStore, useOrderStream, useOrderbookStream, useOrderlyContext, usePortfolio, usePositionActions, usePositionClose, usePositionStream, usePoster, usePreLoadData, usePrivateDataObserver, usePrivateInfiniteQuery, usePrivateQuery, useQuery, useRefereeHistory, useRefereeInfo, useRefereeRebateSummary, useReferralInfo, useReferralRebateSummary, useRestrictedInfo, useRwaSymbolsInfo, useRwaSymbolsInfoStore, useSessionStorage, useSettleSubscription, useSimpleDI, useStatisticsDaily, useStorageChain, useStorageLedgerAddress, useSubAccountDataObserver, useSubAccountMaxWithdrawal, useSubAccountMutation, useSubAccountQuery, useSubAccountWS, useSwapSupportStore, useSymbolInfo, useSymbolLeverage, useSymbolPriceRange, useSymbolsInfo, useSymbolsInfoStore, useTPSLOrder, useTestTokenStore, useTestnetChainsStore, useTickerStream, useTokenInfo, useTokensInfo, useTrack, useTrackingInstance, useTradingRewardsStatus, useTransfer, useTransferHistory, useUpdatedRef, useVaultsHistory, useWS, useWalletConnector, useWalletRewardsHistory, useWalletSubscription, useWalletTopic, useWithdraw, useWsStatus, utils_exports as utils, version_default as version };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map