@orderly.network/hooks 2.8.1 → 2.8.2

package/dist/index.js

@@ -4,22 +4,24 @@ var net = require('@orderly.network/net');
 var useSWR = require('swr');
 var types = require('@orderly.network/types');
 var React2 = require('react');
-var useSWRMutation = require('swr/mutation');
 var utils = require('@orderly.network/utils');
+var useSWRMutation = require('swr/mutation');
 var useConstant = require('use-constant');
 var core = require('@orderly.network/core');
 var lodash = require('lodash');
 var useSWRInfinite = require('swr/infinite');
 var ramda = require('ramda');
 var perp = require('@orderly.network/perp');
+var zustand = require('zustand');
+var immer = require('zustand/middleware/immer');
+var pathOr = require('ramda/es/pathOr');
+var middleware = require('zustand/middleware');
 var useSWRSubscription = require('swr/subscription');
 var amplitude = require('@amplitude/analytics-browser');
 var jsxRuntime = require('react/jsx-runtime');
 var defaultEvmAdapter = require('@orderly.network/default-evm-adapter');
 var defaultSolanaAdapter = require('@orderly.network/default-solana-adapter');
 var web3ProviderEthers = require('@orderly.network/web3-provider-ethers');
-var zustand = require('zustand');
-var immer = require('zustand/middleware/immer');
 var useDebounce = require('use-debounce');
 var immer$1 = require('immer');
 var qr = require('@akamfoad/qr');
@@ -49,6 +51,7 @@ var React2__default = /*#__PURE__*/_interopDefault(React2);
 var useSWRMutation__default = /*#__PURE__*/_interopDefault(useSWRMutation);
 var useConstant__default = /*#__PURE__*/_interopDefault(useConstant);
 var useSWRInfinite__default = /*#__PURE__*/_interopDefault(useSWRInfinite);
+var pathOr__default = /*#__PURE__*/_interopDefault(pathOr);
 var useSWRSubscription__default = /*#__PURE__*/_interopDefault(useSWRSubscription);
 var amplitude__namespace = /*#__PURE__*/_interopNamespace(amplitude);
 
@@ -61,9 +64,9 @@ var __export = (target, all) => {
 // src/version.ts
 if (typeof window !== "undefined") {
   window.__ORDERLY_VERSION__ = window.__ORDERLY_VERSION__ || {};
-  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.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) => net.get(url, init2, queryOptions?.formatter);
 var noCacheConfig = {
   dedupingInterval: 0,
@@ -110,6 +113,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 = utils.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 || {};
@@ -2061,90 +2127,710 @@ var useReferralInfo = () => {
     getFirstRefCode
   };
 };
-var usePreLoadData = () => {
-  const [timestampOffsetInitialized, setTimestampOffsetInitialized] = React2.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__namespace.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 = zustand.create()(
+  immer.immer((set) => ({
+    // accountInfo: null,
+    portfolio: {
+      totalCollateral: utils.zero,
+      totalValue: null,
+      freeCollateral: utils.zero,
+      availableBalance: 0,
+      unsettledPnL: 0,
+      totalUnrealizedROI: 0
     },
-    {
-      errorRetryCount: 3,
-      errorRetryInterval: 500
-    }
-  );
-  React2.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: utils.zero,
+            totalValue: null,
+            freeCollateral: utils.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"
+        );
       }
-      utils.getGlobalObject().__ORDERLY_timestamp_offset = diff;
-      setTimestampOffsetInitialized(true);
     }
-  }, [systemInfo, timestampOffsetInitialized]);
-  const isDone = React2.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 = React2.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] = React2.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);
+      }
     }
-  };
-  React2.useEffect(() => {
-    setStoredValue(readValue());
-  }, []);
-  React2.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 = React2.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__default.default([], ["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 = middleware.createJSONStorage(
+    () => adaptToStateStorage(indexedDBStorage)
+  );
+  return middleware.persist(initializer, {
+    ...rest,
+    storage: jsonStorage
+  });
+};
+
+// src/provider/store/createDataStore.ts
+var createDataStore = (config) => {
+  const {
+    name,
+    dbName,
+    storeName,
+    keyPath,
+    endpoint,
+    baseUrl,
+    formatter = (data) => pathOr__default.default([], ["rows"], data),
+    initData
+    // brokerId,
+  } = config;
+  return zustand.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 = [types.ArbitrumSepoliaChainInfo, types.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 = zustand.create()(
+  middleware.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 = types.TesnetTokenFallback([
+  types.ArbitrumSepoliaTokenInfo,
+  types.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] = React2.useState(false);
+  const { configStore, enableSwapDeposit } = React2.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);
+  React2.useEffect(() => {
+    fetchMainTokens();
+    fetchSymbols(apiBaseUrl).then((symbols) => {
+    });
+    fetchMainChains(void 0, {
+      brokerId: configStore.get("brokerId")
+    });
+  }, []);
+  React2.useEffect(() => {
+    if (!urlPrefix)
+      return;
+    fetchTestTokens(urlPrefix);
+    fetchTestChains(urlPrefix, {
+      brokerId: configStore.get("brokerId")
+    });
+  }, [urlPrefix]);
+  React2.useEffect(() => {
+    if (!mainTokenInfo || !testTokenInfo)
+      return;
+    setTokensInfo(env === "prod" ? mainTokenInfo : testTokenInfo);
+  }, [mainTokenInfo, testTokenInfo]);
+  React2.useEffect(() => {
+    if (swapSupportInfo || !enableSwapDeposit)
+      return;
+    fetchSwapSupport();
+  }, [swapSupportInfo, enableSwapDeposit]);
+  const { data: systemInfo } = useSWR__namespace.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
+    }
+  );
+  React2.useEffect(() => {
+    if (timestampOffsetInitialized)
+      return;
+    if (typeof systemInfo !== "undefined") {
+      const serverTimestamp = systemInfo.timestamp;
+      const localTimestamp = Date.now();
+      const timestampOffset = serverTimestamp - localTimestamp;
+      if (isNaN(timestampOffset)) {
+        return;
+      }
+      utils.getGlobalObject().__ORDERLY_timestamp_offset = timestampOffset;
+      setTimestampOffsetInitialized(true);
+    }
+  }, [systemInfo, timestampOffsetInitialized]);
+  const isDone = React2.useMemo(() => {
+    return timestampOffsetInitialized;
+  }, [timestampOffsetInitialized]);
+  return {
+    error: null,
+    done: isDone
+  };
+};
+function useSessionStorage(key, initialValue) {
+  const readValue = React2.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] = React2.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) {
+    }
+  };
+  React2.useEffect(() => {
+    setStoredValue(readValue());
+  }, []);
+  React2.useEffect(() => {
+    if (typeof window == "undefined") {
+      return;
+    }
+    window.addEventListener?.("storage", handleStorageChange);
+    return () => {
+      window.removeEventListener?.("storage", handleStorageChange);
+    };
+  });
+  const handleStorageChange = React2.useCallback(
+    (event) => {
+      if (event?.key && event.key !== key) {
+        return;
+      }
+      setStoredValue(readValue());
     },
     [key, readValue]
   );
@@ -2167,7 +2853,7 @@ var useNetworkInfo = (networkId) => {
 };
 
 // src/orderly/useAccountInfo.ts
-var useAccountInfo = () => {
+var useAccountInfo2 = () => {
   return usePrivateQuery("/v1/client/info", {
     revalidateOnFocus: false
   });
@@ -2185,7 +2871,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,
@@ -2537,215 +3223,87 @@ var useMarketsStream = () => {
   });
   const topic = "tickers";
   const { data: tickers } = useSWRSubscription__default.default("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 = React2.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 utils.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 ramda.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 = zustand.create()(
-  immer.immer((set) => ({
-    // accountInfo: null,
-    portfolio: {
-      totalCollateral: utils.zero,
-      totalValue: null,
-      freeCollateral: utils.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: utils.zero,
-            totalValue: null,
-            freeCollateral: utils.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 = React2.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 utils.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 ramda.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()) => {
@@ -3427,9 +3985,15 @@ var orderbook_service_default = orderBookService;
 var useMarkPrice = (symbol) => {
   const ws = useWS();
   const [price, setPrice] = React2.useState(0);
+  const symbolRef = React2.useRef(symbol);
+  symbolRef.current = symbol;
   React2.useEffect(() => {
     const unsubscribe = ws.subscribe(`${symbol}@markprice`, {
       onMessage: (message) => {
+        if (message.symbol !== symbolRef.current) {
+          unsubscribe?.();
+          return;
+        }
         setPrice(message.price);
       }
     });
@@ -3439,33 +4003,6 @@ var useMarkPrice = (symbol) => {
   }, [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`,
@@ -3497,6 +4034,45 @@ var useFutures = () => {
     error
   };
 };
+var useIndexPrice = (symbol) => {
+  symbol = symbol.replace("PERP", "SPOT");
+  const symbolRef = React2.useRef(symbol);
+  symbolRef.current = symbol;
+  const ws = useWS();
+  return useSWRSubscription__default.default(`${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 = React2.useRef(symbol);
+  symbolRef.current = symbol;
+  return useSWRSubscription__default.default(`${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) => {
@@ -3510,6 +4086,8 @@ var useTickerStream = (symbol) => {
     }
   );
   const [ticker, setTicker] = React2.useState();
+  const symbolRef = React2.useRef(symbol);
+  symbolRef.current = symbol;
   const ws = useWS();
   React2.useEffect(() => {
     const unsubscribe = ws.subscribe(
@@ -3517,16 +4095,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 () => {
@@ -4225,31 +4799,11 @@ var useLeverage = () => {
 var useOdosQuote = () => {
   return useMutation(`https://api.odos.xyz/sor/quote/v2`);
 };
-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/useComputedLTV.ts
 var { LTV, collateralRatio } = perp.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();
@@ -4501,7 +5055,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);
@@ -5300,7 +5854,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,
         };
       });
     }
@@ -5312,9 +5865,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,
@@ -5325,7 +5875,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,
           }
         };
       });
@@ -5338,11 +5887,14 @@ var usePositionStream = (symbol = "all", options) => {
   return [
     {
       rows,
-      // rows: formattedPositions[0],
+      // Processed position rows with TP/SL data
       aggregated: formattedPositions?.[1] ?? types.EMPTY_OBJECT,
       totalCollateral,
+      // Portfolio-wide collateral
       totalValue,
+      // Total portfolio value
       totalUnrealizedROI
+      // Total unrealized ROI across all positions
     },
     positionInfoGetter,
     {
@@ -5672,6 +6224,8 @@ var useMarketTradeStream = (symbol, options = {}) => {
   }
   const [trades, setTrades] = React2.useState([]);
   const [isLoading, setIsLoading] = React2.useState(false);
+  const symbolRef = React2.useRef(symbol);
+  symbolRef.current = symbol;
   const { limit = 50 } = options;
   const ws = useWS();
   React2.useEffect(() => {
@@ -5696,7 +6250,7 @@ var useMarketTradeStream = (symbol, options = {}) => {
     );
   }, [symbol]);
   React2.useEffect(() => {
-    const unsubscript = ws.subscribe(
+    const unsubscribe = ws.subscribe(
       {
         id: `${symbol}@trade`,
         event: "subscribe",
@@ -5705,6 +6259,10 @@ var useMarketTradeStream = (symbol, options = {}) => {
       },
       {
         onMessage: (data) => {
+          if (data.symbol !== symbolRef.current) {
+            unsubscribe?.();
+            return;
+          }
           setTrades((prev) => {
             const arr = [{ ...data, ts: utils.getTimestamp() }, ...prev];
             if (arr.length > limit) {
@@ -5716,7 +6274,7 @@ var useMarketTradeStream = (symbol, options = {}) => {
       }
     );
     return () => {
-      unsubscript?.();
+      unsubscribe?.();
     };
   }, [symbol]);
   return { data: trades, isLoading };
@@ -5780,7 +6338,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();
@@ -5899,11 +6457,6 @@ var TestNetWhiteList = [
   types.ABSTRACT_TESTNET_CHAINID,
   types.BSC_TESTNET_CHAINID
 ];
-var testnetTokenFallback = types.TesntTokenFallback([
-  types.ArbitrumSepoliaTokenInfo,
-  types.SolanaDevnetTokenInfo
-]);
-var testnetChainFallback = [types.ArbitrumSepoliaChainInfo, types.SolanaDevnetChainInfo];
 function useChains(networkId, options = {}) {
   const { pick: pickField, ...swrOptions } = options;
   const {
@@ -5915,47 +6468,16 @@ function useChains(networkId, options = {}) {
   const filterFun = React2.useRef(options?.filter);
   filterFun.current = options?.filter;
   const chainsMap = React2.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 = React2.useMemo(() => {
+    if (!tokenChainsRes || !testTokenChainsRes || !chainInfos || !testChainInfos) {
+      return [];
+    }
     const mainnetChains = formatChains({
       tokenChains: tokenChainsRes,
       chainInfos,
@@ -6063,19 +6585,7 @@ function filterByAllowedChains(chains, allowedChains) {
 }
 function useSwapChains() {
   const { enableSwapDeposit } = React2.useContext(OrderlyContext);
-  const { data: swapChainsRes, error: swapChainsError } = useSWR__namespace.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 = React2.useMemo(() => {
     if (!enableSwapDeposit || !swapChainsRes || !swapChainsRes.data) {
       return [];
@@ -6503,7 +7013,7 @@ var useDeposit = (options) => {
     [options.address]
   );
   const fetchBalanceHandler = React2.useCallback(
-    async (address, decimals) => {
+    async (address, decimals, token) => {
       let balance2;
       try {
         if (address && types.isNativeTokenChecker(address)) {
@@ -6517,7 +7027,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
         })) {
@@ -6532,16 +7043,17 @@ var useDeposit = (options) => {
   const fetchBalances = React2.useCallback(async (tokens) => {
     const tasks = [];
     for (const token of tokens) {
-      if (types.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) => {
@@ -9541,7 +10053,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] = React2.useState([]);
   const [positions3, setPositions] = React2.useState(
     POSITION_EMPTY
@@ -9696,7 +10208,9 @@ var useSubAccountDataObserver = (accountId) => {
 var { maxWithdrawalUSDC: maxWithdrawalUSDC2, maxWithdrawalOtherCollateral: maxWithdrawalOtherCollateral2, collateralRatio: collateralRatio3 } = perp.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 = React2.useMemo(() => {
     const usdc2 = holdings?.find((item) => item.token === "USDC");
@@ -10054,7 +10568,7 @@ var useTPSLOrder = (position, options) => {
 };
 var useMaxLeverage = (symbol) => {
   const symbolsInfo = useSymbolsInfo();
-  const accountInfo = useAccountInfo2();
+  const accountInfo = useAccountInfo();
   const maxAccountLeverage = accountInfo?.max_leverage;
   const maxSymbolLeverage = React2.useMemo(() => {
     const symbolInfo = symbolsInfo[symbol];
@@ -10423,6 +10937,16 @@ var useStorageLedgerAddress = () => {
     ledgerWallet
   };
 };
+var useTokensInfo = () => {
+  const tokensInfo = useAppStore((state) => state.tokensInfo);
+  return tokensInfo;
+};
+var useTokenInfo = (token) => {
+  const tokensInfo = useAppStore((state) => state.tokensInfo);
+  return React2.useMemo(() => {
+    return tokensInfo?.find((item) => item.token === token);
+  }, [tokensInfo, token]);
+};
 var useMarketStore = zustand.create(
   (set, get3) => ({
     market: [],
@@ -10468,34 +10992,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 = utils.getPrecisionByNumber(item.base_tick);
-        const quote_dp = utils.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);
+  React2.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 = utils.getPrecisionByNumber(item.base_tick);
+      const quote_dp = utils.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) {
@@ -10551,16 +11072,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) {
@@ -10572,9 +11083,26 @@ function getEstFundingRate(data) {
   }
   return est_funding_rate;
 }
+var useDatabaseInitialization = () => {
+  const [isInitialized, setIsInitialized] = React2.useState(false);
+  const [error, setError] = React2.useState(null);
+  React2.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();
@@ -10599,9 +11127,6 @@ var DataCenterProvider = ({
   if (error) {
     return /* @__PURE__ */ jsxRuntime.jsx("div", { children: "Data load failed" });
   }
-  if (!done) {
-    return null;
-  }
   return /* @__PURE__ */ jsxRuntime.jsx(DataCenterContext.Provider, { value: memoizedValue, children });
 };
 var OrderlyConfigProvider = (props) => {
@@ -17329,7 +17854,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]();
@@ -18077,16 +18602,22 @@ exports.findTPSLFromOrder = findTPSLFromOrder;
 exports.findTPSLOrderPriceFromOrder = findTPSLOrderPriceFromOrder;
 exports.getMinNotional = getMinNotional;
 exports.getPriceKey = getPriceKey;
+exports.indexedDBManager = indexedDBManager;
+exports.initializeAppDatabase = initializeAppDatabase;
 exports.isCurrentlyClosed = isCurrentlyClosed;
 exports.isCurrentlyTrading = isCurrentlyTrading;
 exports.noCacheConfig = noCacheConfig;
 exports.parseJSON = parseJSON;
+exports.persistIndexedDB = persistIndexedDB;
+exports.resetTimestampOffsetState = resetTimestampOffsetState;
+exports.timestampWaitingMiddleware = timestampWaitingMiddleware;
 exports.useAccount = useAccount;
-exports.useAccountInfo = useAccountInfo;
+exports.useAccountInfo = useAccountInfo2;
 exports.useAccountInstance = useAccountInstance;
 exports.useAccountRewardsHistory = useAccountRewardsHistory;
 exports.useAllBrokers = useAllBrokers;
 exports.useApiKeyManager = useApiKeyManager;
+exports.useAppStore = useAppStore;
 exports.useAssetsHistory = useAssetsHistory;
 exports.useAudioPlayer = useAudioPlayer;
 exports.useBalanceSubscription = useBalanceSubscription;
@@ -18134,6 +18665,8 @@ exports.useLazyQuery = useLazyQuery;
 exports.useLeverage = useLeverage;
 exports.useLeverageBySymbol = useLeverageBySymbol;
 exports.useLocalStorage = useLocalStorage;
+exports.useMainTokenStore = useMainTokenStore;
+exports.useMainnetChainsStore = useMainnetChainsStore;
 exports.useMaintenanceStatus = useMaintenanceStatus;
 exports.useMarginRatio = useMarginRatio;
 exports.useMarkPrice = useMarkPrice;
@@ -18190,12 +18723,15 @@ exports.useSubAccountMaxWithdrawal = useSubAccountMaxWithdrawal;
 exports.useSubAccountMutation = useSubAccountMutation;
 exports.useSubAccountQuery = useSubAccountQuery;
 exports.useSubAccountWS = useSubAccountWS;
+exports.useSwapSupportStore = useSwapSupportStore;
 exports.useSymbolInfo = useSymbolInfo;
 exports.useSymbolLeverage = useSymbolLeverage;
 exports.useSymbolPriceRange = useSymbolPriceRange;
 exports.useSymbolsInfo = useSymbolsInfo;
 exports.useSymbolsInfoStore = useSymbolsInfoStore;
 exports.useTPSLOrder = useTPSLOrder;
+exports.useTestTokenStore = useTestTokenStore;
+exports.useTestnetChainsStore = useTestnetChainsStore;
 exports.useTickerStream = useTickerStream;
 exports.useTokenInfo = useTokenInfo;
 exports.useTokensInfo = useTokensInfo;