@kodiak-finance/orderly-hooks 2.8.18 → 2.8.19-rc.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as swr from 'swr';
-import { SWRConfiguration, SWRHook, SWRResponse } from 'swr';
+import { SWRConfiguration, SWRHook, SWRResponse, Middleware } from 'swr';
 export { swr };
 export { KeyedMutator, Middleware, SWRConfiguration, SWRHook, SWRResponse, unstable_serialize, default as useSWR, useSWRConfig } from 'swr';
 import * as swr_mutation from 'swr/mutation';
@@ -9,7 +9,7 @@ import { SWRInfiniteKeyLoader, SWRInfiniteConfiguration } from 'swr/infinite';
 import * as react from 'react';
 import react__default, { PropsWithChildren, FC, ReactNode } from 'react';
 import * as _kodiak_finance_orderly_types from '@kodiak-finance/orderly-types';
-import { NetworkId, TrackerEventName, API, Chain as Chain$1, OrderlyOrder, ChainNamespace, WSMessage, OrderType, OrderStatus, OrderSide, AlgoOrderRootType, OrderEntity, PositionType, AlgoOrderEntity, AssetHistoryStatusEnum, AlgoOrderType, RequireKeys } from '@kodiak-finance/orderly-types';
+import { NetworkId, TrackerEventName, API, OrderlyOrder, ChainNamespace, WSMessage, OrderType, OrderStatus, OrderSide, AlgoOrderRootType, OrderEntity, PositionType, AlgoOrderEntity, AssetHistoryStatusEnum, AlgoOrderType, RequireKeys } from '@kodiak-finance/orderly-types';
 import * as _kodiak_finance_orderly_core from '@kodiak-finance/orderly-core';
 import { AccountState, Account, EventEmitter, ConfigStore, ConfigKey, SimpleDI, OrderlyKeyStore, WalletAdapter, IContract, DefaultConfigStore } from '@kodiak-finance/orderly-core';
 export { SubAccount, WalletAdapter } from '@kodiak-finance/orderly-core';
@@ -22,9 +22,12 @@ import { SolanaWalletProvider } from '@kodiak-finance/orderly-default-solana-ada
 import * as swr_subscription from 'swr/subscription';
 import * as _kodiak_finance_orderly_utils from '@kodiak-finance/orderly-utils';
 import { Decimal } from '@kodiak-finance/orderly-utils';
-export * from 'use-debounce';
 import * as immer from 'immer';
 import * as zustand from 'zustand';
+import { StoreMutatorIdentifier, StateCreator } from 'zustand';
+import * as zustand_middleware from 'zustand/middleware';
+import { PersistOptions } from 'zustand/middleware';
+export * from 'use-debounce';
 
 declare global {
     interface Window {
@@ -49,6 +52,16 @@ declare const noCacheConfig: SWRConfiguration;
  */
 declare const useQuery: <T>(query: Parameters<SWRHook>[0], options?: useQueryOptions<T>) => SWRResponse<T>;
 
+/**
+ * SWR middleware that waits for __ORDERLY_timestamp_offset to be initialized
+ * before allowing requests to proceed.
+ */
+declare const timestampWaitingMiddleware: Middleware;
+/**
+ * Reset timestamp state (for testing or re-initialization)
+ */
+declare function resetTimestampOffsetState(): void;
+
 /**
  * useQuery
  * @description for public api
@@ -356,7 +369,7 @@ declare const useAccount: () => {
 declare const useAccountInstance: () => Account;
 
 declare const usePreLoadData: () => {
-    error: any;
+    error: null;
     done: boolean;
 };
 
@@ -382,6 +395,10 @@ declare const useFeeState: () => {
     readonly refereeRebate: number | undefined;
     readonly effectiveTakerFee: string;
     readonly effectiveMakerFee: string;
+    readonly rwaTakerFee: string;
+    readonly rwaMakerFee: string;
+    readonly rwaEffectiveTakerFee: string;
+    readonly rwaEffectiveMakerFee: string;
 };
 
 declare const useTrack: () => {
@@ -454,12 +471,14 @@ declare function useChains<T extends NetworkId | undefined, K extends UseChainsO
     UseChainsReturnObject
 ];
 
-type filteredChains$1 = {
-    mainnet?: Chain$1[];
-    testnet?: Chain$1[];
+type FilteredChains = {
+    mainnet?: {
+        id: number;
+    }[];
+    testnet?: {
+        id: number;
+    }[];
 };
-type chainFilterFunc = (config: ConfigStore) => filteredChains$1;
-type chainFilter = filteredChains$1 | chainFilterFunc;
 interface OrderlyConfigContextState {
     fetcher?: (url: string, init: RequestInit) => Promise<any>;
     configStore: ConfigStore;
@@ -470,11 +489,11 @@ interface OrderlyConfigContextState {
      * @hidden
      */
     onlyTestnet?: boolean;
-    filteredChains?: filteredChains$1 | null;
+    filteredChains?: FilteredChains;
     customChains?: Chains<undefined, undefined>;
     chainTransformer?: (params: {
         chains: API.Chain[];
-        tokenChains: API.Chain[];
+        tokenChains: API.Token[];
         chainInfos: any[];
         swapChains: any[];
         mainnet: boolean;
@@ -511,6 +530,11 @@ interface OrderlyConfigContextState {
              * @default false
              */
             defaultOpen?: boolean;
+            /**
+             * Whether to display the notification in the order entry.
+             * @default true
+             */
+            displayInOrderEntry?: boolean;
         };
     };
     amplitudeConfig?: {
@@ -537,16 +561,13 @@ declare enum WsNetworkStatus {
 }
 declare function useWsStatus(): WsNetworkStatus;
 
-type filteredChains = {
-    mainnet?: Chain$1[];
-    testnet?: Chain$1[];
-};
-type filterChainsFunc = (config: ConfigStore) => filteredChains;
+type ChainFilterFunc = (config: ConfigStore) => FilteredChains;
+type ChainFilter = FilteredChains | ChainFilterFunc;
 type BaseConfigProviderProps = {
     keyStore?: OrderlyKeyStore;
     contracts?: IContract;
     walletAdapters?: WalletAdapter[];
-    chainFilter?: filteredChains | filterChainsFunc;
+    chainFilter?: ChainFilter;
     /**
      * Custom orderbook default tick sizes.
      */
@@ -684,7 +705,7 @@ declare const useSymbolInfo: (symbol?: string) => ((<Key extends keyof _kodiak_f
 declare const useAccountInfo: () => swr.SWRResponse<API.AccountInfo, any, any>;
 
 declare const useMarketsStream: () => {
-    data: WSMessage.Ticker[] | null;
+    data: WSMessage.Ticker[];
 };
 
 declare enum MarketsType$1 {
@@ -735,7 +756,8 @@ declare enum MarketsType {
     FAVORITES = 0,
     RECENT = 1,
     ALL = 2,
-    NEW_LISTING = 3
+    RWA = 3,
+    NEW_LISTING = 4
 }
 interface FavoriteTab {
     name: string;
@@ -778,6 +800,10 @@ type MarketsItem = {
     openInterest: number;
     isFavorite: boolean;
     leverage?: number;
+    isRwa: boolean;
+    rwaNextOpen?: number;
+    rwaNextClose?: number;
+    rwaStatus?: "open" | "close";
 };
 type MarketsStore = ReturnType<typeof useMarketsStore>;
 declare const MarketsStorageKey = "orderly_markets";
@@ -913,16 +939,89 @@ declare const useFundingRateHistory: () => {
     getPositiveRates: (data: ReadonlyArray<API.FundingHistory> | API.FundingHistory[], period: PeriodKey) => Record<string, number>;
 };
 
+/**
+ * Price mode for PnL calculations in position streams
+ * @typedef {("markPrice" | "lastPrice")} PriceMode
+ * - markPrice: Uses mark price for unrealized PnL calculations (default)
+ * - lastPrice: Uses last traded price (index price) for unrealized PnL calculations
+ */
 type PriceMode = "markPrice" | "lastPrice";
-declare const usePositionStream: (
 /**
- * If symbol is passed, only the position of that symbol will be returned.
+ * Real-time position stream hook with WebSocket integration
+ *
+ * Subscribes to position updates via WebSocket and provides real-time position data with automatic
+ * calculations for unrealized PnL, ROI, and aggregated portfolio metrics. Integrates TP/SL orders
+ * and supports both full portfolio view and single symbol tracking.
+ *
+ * **Key Features:**
+ * - Real-time WebSocket updates for positions
+ * - Automatic integration of TP/SL (take-profit/stop-loss) orders
+ * - Dual price mode support (mark price vs last price)
+ * - Optional pending order inclusion
+ * - Calculator service integration for real-time PnL updates
+ * - Aggregated portfolio metrics (total collateral, value, ROI)
+ *
+ * **Price Calculation Modes:**
+ * - markPrice (default): Uses mark price for unrealized PnL - recommended for margin calculations
+ * - lastPrice: Uses last traded price (index price) - useful for more conservative PnL views
+ *
+ * **Data Flow:**
+ * 1. Subscribes to position store (WebSocket-driven)
+ * 2. Fetches related TP/SL orders via useOrderStream
+ * 3. Registers calculator for real-time price updates (single symbol only)
+ * 4. Merges position data with TP/SL information
+ * 5. Applies price mode transformations
+ * 6. Filters positions based on includedPendingOrder flag
+ *
+ * @param {string} [symbol="all"] - Trading symbol to filter positions, or "all" for entire portfolio
+ *   - "all": Returns all positions across all symbols (calculator not registered)
+ *   - "BTC-PERP": Returns only BTC-PERP position (calculator registered for real-time updates)
+ *
+ * @param {Object} [options] - Configuration options extending SWR configuration
+ * @param {PriceMode} [options.calcMode] - Price calculation mode: "markPrice" or "lastPrice"
+ *   - markPrice: Uses mark_price field for unrealized_pnl (default, matches exchange calculations)
+ *   - lastPrice: Uses unrealized_pnl_index field based on last traded price
+ * @param {boolean} [options.includedPendingOrder=false] - Include positions with only pending orders
+ *   - false: Only returns positions with non-zero position_qty
+ *   - true: Returns positions with position_qty !== 0 OR pending_long_qty/pending_short_qty !== 0
+ *
+ * @returns {readonly [PositionData, PositionInfoGetter, LoadingState]} Tuple containing:
+ *   - [0] PositionData object:
+ *     - rows: Array of position objects with TP/SL information
+ *     - aggregated: Aggregated metrics (total unrealized PnL, ROI, etc.)
+ *     - totalCollateral: Total collateral across all positions
+ *     - totalValue: Total portfolio value
+ *     - totalUnrealizedROI: Total unrealized ROI percentage
+ *   - [1] PositionInfoGetter: Memoized getter function for aggregated data access
+ *   - [2] LoadingState object:
+ *     - loading: Loading status (deprecated, use isLoading)
+ *     - isLoading: Current loading state of position data
+ *
+ * @example
+ * // Get all positions with mark price calculation
+ * const [{ rows, aggregated, totalCollateral }] = usePositionStream();
+ *
+ * @example
+ * // Get single symbol position with last price calculation
+ * const [{ rows }] = usePositionStream("BTC-PERP", {
+ *   calcMode: "lastPrice"
+ * });
+ *
+ * @example
+ * // Include pending orders in results
+ * const [{ rows }, getter, { isLoading }] = usePositionStream("all", {
+ *   includedPendingOrder: true
+ * });
+ *
+ * @example
+ * // Access specific position with TP/SL data
+ * const [{ rows }] = usePositionStream("ETH-PERP");
+ * const position = rows[0];
+ * console.log(position.full_tp_sl.tp_trigger_price); // Full position TP price
+ * console.log(position.partial_tp_sl.order_num); // Number of partial TP/SL orders
  */
-symbol?: string, options?: SWRConfiguration & {
+declare const usePositionStream: (symbol?: string, options?: SWRConfiguration & {
     calcMode?: PriceMode;
-    /**
-     * If true, the pending order will be included in the result.
-     */
     includedPendingOrder?: boolean;
 }) => readonly [{
     readonly rows: API.PositionTPSLExt[];
@@ -994,8 +1093,9 @@ params: {
     readonly refresh: () => void;
     readonly loadMore: () => void;
     readonly cancelAllOrders: (symbol?: string) => Promise<[any, any, any]>;
+    readonly cancelAllPendingOrders: (symbol?: string) => void;
     readonly cancelAllTPSLOrders: (symbol?: string) => Promise<any[]>;
-    readonly cancelAlgoOrdersByTypes: (types: AlgoOrderRootType[]) => Promise<any[]>;
+    readonly cancelAlgoOrdersByTypes: (types: AlgoOrderRootType[], symbol?: string) => Promise<any[]>;
     readonly updateOrder: (orderId: string, order: OrderEntity) => Promise<any>;
     readonly cancelOrder: (orderId: number, symbol?: string) => Promise<any>;
     readonly updateAlgoOrder: (orderId: string, order: OrderEntity) => Promise<any>;
@@ -1226,10 +1326,11 @@ declare const useDeposit: (options: DepositOptions) => {
     depositFeeRevalidating: boolean;
     approve: (amount?: string) => Promise<void | undefined>;
     deposit: () => Promise<any>;
-    fetchBalance: (address: string, decimals?: number) => Promise<string>;
-    fetchBalances: (tokens: API.TokenInfo[]) => Promise<string[]>;
+    fetchBalance: (address: string, decimals?: number, token?: string) => Promise<string>;
+    fetchBalances: (tokens: API.TokenInfo[]) => Promise<Record<string, string>>;
     /** set input quantity */
     setQuantity: react.Dispatch<react.SetStateAction<string>>;
+    targetChain: API.Chain;
 };
 
 interface ConvertOptions {
@@ -1341,6 +1442,10 @@ type OrderValidationItem = {
     type: "priceErrorMin" | "priceErrorMax";
     message: string;
     value?: never;
+} | {
+    type: number;
+    message: string;
+    value?: never;
 };
 type OrderValidationResult = {
     [P in keyof OrderlyOrder]?: OrderValidationItem;
@@ -1390,10 +1495,6 @@ declare const useTaskProfitAndStopLossInternal: (position: Partial<API.PositionT
      * Conversely, even if defaultOrder is provided and isEditing is false, a new TPSL order is still created
      */
     isEditing?: boolean;
-    tpslEnable?: {
-        tp_enable?: boolean;
-        sl_enable?: boolean;
-    };
     positionType?: PositionType;
 }) => [
 /**
@@ -1416,7 +1517,7 @@ ComputedAlgoOrder, {
     /**
      *
      */
-    validate: () => Promise<AlgoOrderEntity<AlgoOrderRootType.POSITIONAL_TP_SL | AlgoOrderRootType.TP_SL>>;
+    validate: (otherErrors?: ValidateError) => Promise<AlgoOrderEntity<AlgoOrderRootType.POSITIONAL_TP_SL | AlgoOrderRootType.TP_SL>>;
     metaState: {
         dirty: { [K in keyof OrderlyOrder]?: boolean; };
         submitted: boolean;
@@ -1437,10 +1538,6 @@ position: Partial<API.PositionTPSLExt> & Pick<API.PositionTPSLExt, "symbol" | "a
      * it is usually used when editing order
      */
     defaultOrder?: API.AlgoOrder;
-    tpslEnable?: {
-        tp_enable?: boolean;
-        sl_enable?: boolean;
-    };
     isEditing?: boolean;
     positionType?: PositionType;
 }) => ReturnType<typeof useTaskProfitAndStopLossInternal>;
@@ -1648,12 +1745,114 @@ declare const useStorageLedgerAddress: () => {
 /**
  * return all tokens info
  */
-declare const useTokensInfo: () => API.Chain[];
+declare const useTokensInfo: () => _kodiak_finance_orderly_types.API.Token[] | undefined;
 /**
  * return token info by specify token
  */
-declare const useTokenInfo: (token: string) => API.Chain | undefined;
+declare const useTokenInfo: (token: string) => _kodiak_finance_orderly_types.API.Token | undefined;
+
+/**
+ * Check if currently trading based on next_open/next_close timestamps
+ * @param nextOpen - Next open time timestamp
+ * @param nextClose - Next close time timestamp
+ * @param currentTime - Current time timestamp
+ * @returns boolean - true if currently trading
+ */
+declare const isCurrentlyTrading: (nextClose: number, status: "open" | "close", currentTime?: number) => boolean;
+declare const isCurrentlyClosed: (nextOpen: number, status: "open" | "close", currentTime?: number) => boolean;
+/**
+ * Type alias for the return type of useSymbolsInfo hook
+ */
+type RwaSymbolsInfo = ReturnType<typeof useRwaSymbolsInfo>;
+/**
+ * A hook that provides access to symbol information.
+ *
+ * @returns A getter object that provides access to symbol information.
+ * The getter allows accessing symbol data either by symbol name directly,
+ * or through a two-level access pattern (symbol and property).
+ *
+ * @example
+ * ```typescript
+ * const rwaSymbolsInfo = useRwaSymbolsInfo();
+ *
+ * // Get all info for a symbol
+ * const ethInfo = rwaSymbolsInfo["PERP_ETH_USDC"]();
+ * ```
+ */
+declare const useRwaSymbolsInfo: () => Record<string, <Key extends keyof API.RwaSymbol>(key: Key, defaultValue?: API.RwaSymbol[Key] | undefined) => API.RwaSymbol[Key]> & Record<string, () => API.RwaSymbol> & {
+    isNil: boolean;
+};
+declare const useRwaSymbolsInfoStore: () => Record<string, API.RwaSymbol> | undefined;
+/**
+ * Return type definition for the hook
+ *
+ * - isRwa: true if the symbol is an RWA symbol
+ * - open: true if the symbol is open for trading
+ * - nextOpen: the next open time in milliseconds
+ * - nextClose: the next close time in milliseconds
+ * - closeTimeInterval: the time interval in seconds until the symbol closes (countdown format)
+ * - openTimeInterval: the time interval in seconds until the symbol opens (countdown format)
+ */
+interface RwaSymbolResult {
+    isRwa: boolean;
+    open?: boolean;
+    nextOpen?: number;
+    nextClose?: number;
+    closeTimeInterval?: number;
+    openTimeInterval?: number;
+}
+/**
+ * Hook to initialize and manage the global timer
+ * This hook should be called once at the top level of the application to start and manage the global timer
+ */
+declare const useInitRwaSymbolsRuntime: () => void;
+/**
+ * Hook to get current RWA symbol information with real-time updates
+ * Retrieves the state of a specific symbol from the centralized store
+ * @param symbol - The symbol to query
+ * @returns RwaSymbolResult containing RWA status and countdown information
+ */
+declare const useGetRwaSymbolInfo: (symbol: string) => RwaSymbolResult;
+/**
+ * Simplified hook to get RWA symbol open status with real-time updates
+ * @param symbol - The symbol to query
+ * @returns Object containing isRwa and open status
+ */
+declare const useGetRwaSymbolOpenStatus: (symbol: string) => {
+    isRwa: boolean;
+    open?: boolean;
+};
+/**
+ * Hook to get RWA symbol close time interval with filtering
+ * @param symbol - The symbol to query
+ * @param thresholdMinutes - Time threshold in minutes, defaults to 30
+ * @returns Close time interval in seconds, or undefined if not within threshold
+ */
+declare const useGetRwaSymbolCloseTimeInterval: (symbol: string, thresholdMinutes?: number) => {
+    isRwa: boolean;
+    open?: boolean;
+    closeTimeInterval?: number;
+    nextClose?: number;
+};
+/**
+ * Hook to get RWA symbol open time interval with filtering
+ * @param symbol - The symbol to query
+ * @param thresholdMinutes - Time threshold in minutes, defaults to 30
+ * @returns Open time interval in seconds, or undefined if not within threshold
+ */
+declare const useGetRwaSymbolOpenTimeInterval: (symbol: string, thresholdMinutes?: number) => {
+    isRwa: boolean;
+    open?: boolean;
+    openTimeInterval?: number;
+    nextOpen?: number;
+};
 
+type AppStatus = {
+    positionsLoading: boolean;
+    ordersLoading: boolean;
+    fundingRatesLoading: boolean;
+    ready: boolean;
+};
 type Portfolio$1 = {
     holding?: API.Holding[];
     totalCollateral: Decimal;
@@ -1663,7 +1862,144 @@ type Portfolio$1 = {
     unsettledPnL: number;
     totalUnrealizedROI: number;
 };
+type AppState = {
+    accountInfo?: API.AccountInfo;
+    symbolsInfo?: Record<string, API.SymbolExt>;
+    tokensInfo?: API.Token[];
+    rwaSymbolsInfo?: Record<string, API.RwaSymbol>;
+    fundingRates?: Record<string, API.FundingRate>;
+    portfolio: Portfolio$1;
+    appState: AppStatus;
+};
+type AppActions = {
+    cleanAll: () => void;
+    setAccountInfo: (accountInfo: API.AccountInfo) => void;
+    setTokensInfo: (tokensInfo: API.Token[]) => void;
+    setSymbolsInfo: (symbolsInfo: Record<string, API.SymbolExt>) => void;
+    setRwaSymbolsInfo: (rwaSymbolsInfo: Record<string, API.RwaSymbol>) => void;
+    setFundingRates: (fundingRates: Record<string, API.FundingRate>) => void;
+    updateAppStatus: (key: keyof AppStatus, value: boolean) => void;
+    updatePortfolio: (key: keyof Omit<Portfolio$1, "usdc" | "holding">, value: number | Decimal) => void;
+    batchUpdateForPortfolio: (data: Partial<Portfolio$1>) => void;
+    restoreHolding: (holding: API.Holding[]) => void;
+    updateHolding: (msg: Record<string, WSMessage.Holding>) => void;
+};
+/**
+ * @warning This store should be used with caution. It contains sensitive account and portfolio data.
+ * Please ensure you have proper authorization and follow security best practices when using this store.
+ *
+ * @example
+ * // Correct usage:
+ * const accountInfo = useAppStore(state => state.accountInfo);
+ *
+ * // Avoid direct store manipulation:
+ * const store = useAppStore.getState(); // Not recommended
+ */
+declare const useAppStore: zustand.UseBoundStore<Omit<zustand.StoreApi<AppState & {
+    actions: AppActions;
+}>, "setState"> & {
+    setState(nextStateOrUpdater: (AppState & {
+        actions: AppActions;
+    }) | Partial<AppState & {
+        actions: AppActions;
+    }> | ((state: immer.WritableDraft<AppState & {
+        actions: AppActions;
+    }>) => void), shouldReplace?: boolean | undefined): void;
+}>;
 declare const usePortfolio: () => Portfolio$1;
+declare const useFundingRateBySymbol: (symbol: string) => API.FundingRate | undefined;
+
+/**
+ * Generic store state for data fetching
+ */
+interface DataStoreState<T> {
+    data: T[] | null;
+    loading: boolean;
+    error: Error | null;
+    name: string;
+    /** Whether the store has been hydrated from IndexedDB */
+    hydrated: boolean;
+}
+/**
+ * Generic store actions for data fetching
+ */
+interface DataStoreActions<T> {
+    fetchData: (baseUrl?: string, options?: {
+        brokerId?: string;
+    }) => Promise<T[]>;
+}
+
+declare const useMainnetChainsStore: zustand.UseBoundStore<Omit<zustand.StoreApi<DataStoreState<API.Chain> & DataStoreActions<API.Chain>>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<DataStoreState<API.Chain> & DataStoreActions<API.Chain>, T>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: DataStoreState<API.Chain> & DataStoreActions<API.Chain>) => void) => () => void;
+        onFinishHydration: (fn: (state: DataStoreState<API.Chain> & DataStoreActions<API.Chain>) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<DataStoreState<API.Chain> & DataStoreActions<API.Chain>, T>>;
+    };
+}>;
+
+declare const useTestnetChainsStore: zustand.UseBoundStore<Omit<zustand.StoreApi<DataStoreState<API.Chain> & DataStoreActions<API.Chain>>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<DataStoreState<API.Chain> & DataStoreActions<API.Chain>, T>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: DataStoreState<API.Chain> & DataStoreActions<API.Chain>) => void) => () => void;
+        onFinishHydration: (fn: (state: DataStoreState<API.Chain> & DataStoreActions<API.Chain>) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<DataStoreState<API.Chain> & DataStoreActions<API.Chain>, T>>;
+    };
+}>;
+
+declare const useMainTokenStore: zustand.UseBoundStore<Omit<zustand.StoreApi<DataStoreState<API.Token> & DataStoreActions<API.Token>>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<DataStoreState<API.Token> & DataStoreActions<API.Token>, T>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: DataStoreState<API.Token> & DataStoreActions<API.Token>) => void) => () => void;
+        onFinishHydration: (fn: (state: DataStoreState<API.Token> & DataStoreActions<API.Token>) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<DataStoreState<API.Token> & DataStoreActions<API.Token>, T>>;
+    };
+}>;
+
+declare const useTestTokenStore: zustand.UseBoundStore<Omit<zustand.StoreApi<DataStoreState<API.Token> & DataStoreActions<API.Token>>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<DataStoreState<API.Token> & DataStoreActions<API.Token>, T>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: DataStoreState<API.Token> & DataStoreActions<API.Token>) => void) => () => void;
+        onFinishHydration: (fn: (state: DataStoreState<API.Token> & DataStoreActions<API.Token>) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<DataStoreState<API.Token> & DataStoreActions<API.Token>, T>>;
+    };
+}>;
+
+type SwapSupport = {
+    data: Record<string, any> | null;
+    loading: boolean;
+    error: Error | null;
+};
+type SwapSupportActions = {
+    fetchData: () => Promise<Record<string, any> | null>;
+};
+declare const useSwapSupportStore: zustand.UseBoundStore<Omit<zustand.StoreApi<SwapSupport & SwapSupportActions>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<SwapSupport & SwapSupportActions, {
+            data: Record<string, any> | null;
+        }>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: SwapSupport & SwapSupportActions) => void) => () => void;
+        onFinishHydration: (fn: (state: SwapSupport & SwapSupportActions) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<SwapSupport & SwapSupportActions, {
+            data: Record<string, any> | null;
+        }>>;
+    };
+}>;
 
 type UseOrderEntryOptions = {
     commify?: boolean;
@@ -1926,6 +2262,7 @@ declare function priceToPnl(inputs: {
 }, options?: {
     symbol?: Pick<API.SymbolExt, "quote_dp">;
 }): number;
+/** @deprecated use priceToROI instead */
 declare function calcTPSL_ROI(inputs: {
     pnl: number | string;
     qty: number | string;
@@ -2117,6 +2454,94 @@ declare const useApiKeyManager: (queryParams?: {
     readonly resetOrderlyKeyIPRestriction: (orderlyKey: string, mode: "ALLOW_ALL_IPS" | "DISALLOW_ALL_IPS") => Promise<any>;
 }];
 
+interface StoreConfig {
+    name: string;
+    keyPath?: string;
+    autoIncrement?: boolean;
+}
+interface DatabaseConfig {
+    name: string;
+    version: number;
+    stores: StoreConfig[];
+}
+declare class IndexedDBManager {
+    private static instance;
+    private connections;
+    private databaseConfig;
+    /** Promise that resolves when database initialization is complete */
+    private initializationPromise;
+    static getInstance(): IndexedDBManager;
+    initializeDatabase(config: DatabaseConfig): Promise<void>;
+    /**
+     * Performs the actual database initialization
+     * Now keeps the connection open for better performance
+     */
+    private _performInitialization;
+    /**
+     * Handles initialization errors consistently
+     */
+    private _handleInitializationError;
+    getConnection(dbName: string, storeName: string): Promise<IDBDatabase>;
+    /**
+     * Ensures database is initialized, initializes if not already done
+     */
+    private ensureInitialized;
+    /**
+     * Creates a new database connection
+     */
+    private createConnection;
+    /**
+     * Checks if database and all required stores exist
+     */
+    private _checkDatabaseExists;
+}
+declare const indexedDBManager: IndexedDBManager;
+declare const initializeAppDatabase: (config: DatabaseConfig) => Promise<void>;
+
+/**
+ * Configuration for IndexedDB storage
+ */
+interface IndexedDBStorageConfig {
+    /** Database name */
+    dbName: string;
+    /** Object store name */
+    storeName: string;
+}
+/**
+ * Configuration options for IndexedDB persistence middleware
+ */
+type IndexedDBPersistOptions<T, U = T> = Omit<PersistOptions<T, U>, "storage"> & {
+    /** IndexedDB configuration */
+    indexedDBConfig: IndexedDBStorageConfig;
+};
+/**
+ * Creates a Zustand store with IndexedDB persistence
+ *
+ * @param initializer - The state creator function
+ * @param options - Persistence options including IndexedDB configuration
+ * @returns A state creator with IndexedDB persistence middleware applied
+ *
+ * @example
+ * ```typescript
+ * const useStore = create(
+ *   persistIndexedDB(
+ *     (set) => ({
+ *       items: [],
+ *       addItem: (item) => set((state) => ({ items: [...state.items, item] })),
+ *     }),
+ *     {
+ *       name: 'my-store',
+ *       indexedDBConfig: {
+ *         dbName: 'ORDERLY_STORE',
+ *         storeName: 'ITEMS_STORE',
+ *       },
+ *     }
+ *   )
+ * );
+ * ```
+ */
+declare const persistIndexedDB: <T, Mps extends [StoreMutatorIdentifier, unknown][] = [], Mcs extends [StoreMutatorIdentifier, unknown][] = [], U = T>(initializer: StateCreator<T, [...Mps, ["zustand/persist", unknown]], Mcs>, options: IndexedDBPersistOptions<T, U>) => StateCreator<T, Mps, [["zustand/persist", U], ...Mcs]>;
+
 type FullOrderState = OrderlyOrder;
 type OrderEntryStateEntity = RequireKeys<FullOrderState, "side" | "order_type" | "symbol">;
 type OrderEntryState = {
@@ -2155,6 +2580,7 @@ declare const useOrderEntryNextInternal: (symbol: string, options?: {
      */
     initialOrder?: Omit<Partial<FullOrderState>, "symbol">;
     symbolInfo?: API.SymbolExt;
+    symbolLeverage?: number;
 }) => {
     readonly formattedOrder: Required<Pick<OrderlyOrder, "symbol" | "side" | "order_type">> & Partial<Omit<OrderlyOrder, "symbol" | "side" | "order_type">>;
     readonly setValue: (key: keyof FullOrderState, value: any, additional?: {
@@ -2215,7 +2641,7 @@ type OrderEntryReturn = {
          * Function to validate the order.
          * @returns {Promise<OrderValidationResult | null>} The validation result.
          */
-        validate: () => Promise<OrderValidationResult | null>;
+        validate: (otherErrors?: OrderValidationResult) => Promise<OrderValidationResult | null>;
     };
     freeCollateral: number;
     /**
@@ -2244,7 +2670,8 @@ type OrderEntryReturn = {
      * Indicates if a mutation (order creation) is in progress.
      */
     isMutating: boolean;
-    markPrice: number | undefined;
+    markPrice?: number;
+    symbolLeverage?: number;
 };
 /**
  * Custom hook for managing order entry in the Orderly application.
@@ -2424,4 +2851,19 @@ declare const usePositionClose: (options: PositionCloseOptions) => {
 declare const useMarketList: () => API.MarketInfoExt[];
 declare const useMarketMap: () => Record<string, API.MarketInfoExt> | null;
 
-export { type APIKeyItem, type AccountRewardsHistory, type AccountRewardsHistoryRow, type Brokers, type Chain, type Chains, type CheckReferralCodeReturns, type CollateralOutputs, type ComputedAlgoOrder, type ConfigProviderProps, type ConnectedChain, type CurrentEpochEstimate, DefaultLayoutConfig, DistributionId, type DrawOptions, ENVType, type EpochInfoItem, type EpochInfoType, EpochStatus, type ExclusiveConfigProviderProps, ExtendedConfigStore, type Favorite, type FavoriteTab, type FundingRates, MaintenanceStatus, type MarginRatioReturn, type MarketsItem, MarketsStorageKey, type MarketsStore, MarketsType, type NewListing, ORDERLY_ORDERBOOK_DEPTH_KEY, type OrderBookItem, type OrderEntryReturn, type OrderMetadata, type OrderMetadataConfig, type OrderParams, type OrderValidationItem, type OrderValidationResult, type OrderbookData, type OrderbookOptions, type OrderlyConfigContextState, OrderlyConfigProvider, OrderlyContext, OrderlyProvider, type PosterLayoutConfig, type PriceMode, type Recent, RefferalAPI, type RestrictedInfoOptions, type RestrictedInfoReturns, ScopeType, type StatusInfo, StatusProvider, type SymbolsInfo, TWType, type UseChainsOptions, type UseChainsReturnObject, type UseOrderEntryMetaState, WalletConnectorContext, type WalletConnectorContextState, type WalletRewards, type WalletRewardsHistoryReturns, type WalletRewardsItem, type WalletState, WsNetworkStatus, type chainFilter, type chainFilterFunc, checkNotional, cleanStringStyle, fetcher, type filteredChains$1 as filteredChains, findPositionTPSLFromOrders, findTPSLFromOrder, findTPSLOrderPriceFromOrder, getMinNotional, getPriceKey, 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, useFundingRateHistory, useFundingRates, useFundingRatesStore, useGetClaimed, useGetEnv, useGetReferralCode, useHoldingStream, useIndexPrice, useIndexPricesStream, useInfiniteQuery, 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, useOrderEntry, useOrderEntry$1 as useOrderEntry_deprecated, useOrderStore, useOrderStream, useOrderbookStream, useOrderlyContext, usePortfolio, usePositionActions, usePositionClose, usePositionStream, usePoster, usePreLoadData, usePrivateDataObserver, usePrivateInfiniteQuery, usePrivateQuery, useQuery, type useQueryOptions, useRefereeHistory, useRefereeInfo, useRefereeRebateSummary, useReferralInfo, useReferralRebateSummary, useRestrictedInfo, 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, index as utils, _default as version };
+type TpslPriceParams = {
+    warning_threshold?: number;
+    slPrice?: string;
+    liqPrice: number | null;
+    side?: OrderSide;
+};
+declare const useTpslPriceChecker: (params: TpslPriceParams) => OrderValidationResult | null;
+
+declare const ERROR_MSG_CODES: {
+    SL_PRICE_WARNING: number;
+    SL_PRICE_ERROR: number;
+};
+
+declare const useEstLiqPriceBySymbol: (symbol: string) => number | undefined;
+
+export { type APIKeyItem, type AccountRewardsHistory, type AccountRewardsHistoryRow, type Brokers, type Chain, type ChainFilter, type Chains, type CheckReferralCodeReturns, type CollateralOutputs, type ComputedAlgoOrder, type ConfigProviderProps, type ConnectedChain, type CurrentEpochEstimate, DefaultLayoutConfig, DistributionId, type DrawOptions, ENVType, ERROR_MSG_CODES, type EpochInfoItem, type EpochInfoType, EpochStatus, type ExclusiveConfigProviderProps, ExtendedConfigStore, type Favorite, type FavoriteTab, type FilteredChains, type FundingRates, MaintenanceStatus, type MarginRatioReturn, type MarketsItem, MarketsStorageKey, type MarketsStore, MarketsType, type NewListing, ORDERLY_ORDERBOOK_DEPTH_KEY, type OrderBookItem, type OrderEntryReturn, type OrderMetadata, type OrderMetadataConfig, type OrderParams, type OrderValidationItem, type OrderValidationResult, type OrderbookData, type OrderbookOptions, type OrderlyConfigContextState, OrderlyConfigProvider, OrderlyContext, OrderlyProvider, type PosterLayoutConfig, type PriceMode, type Recent, RefferalAPI, type RestrictedInfoOptions, type RestrictedInfoReturns, type RwaSymbolResult, type RwaSymbolsInfo, ScopeType, type StatusInfo, StatusProvider, type SymbolsInfo, TWType, type UseChainsOptions, type UseChainsReturnObject, type UseOrderEntryMetaState, WalletConnectorContext, type WalletConnectorContextState, type WalletRewards, type WalletRewardsHistoryReturns, type WalletRewardsItem, type WalletState, WsNetworkStatus, checkNotional, cleanStringStyle, fetcher, findPositionTPSLFromOrders, findTPSLFromOrder, findTPSLOrderPriceFromOrder, getMinNotional, getPriceKey, indexedDBManager, initializeAppDatabase, isCurrentlyClosed, isCurrentlyTrading, noCacheConfig, parseJSON, persistIndexedDB, resetTimestampOffsetState, timestampWaitingMiddleware, useAccount, useAccountInfo, useAccountInstance, useAccountRewardsHistory, useAllBrokers, useApiKeyManager, useAppStore, useAssetsHistory, useAudioPlayer, useBalanceSubscription, useBalanceTopic, useBoolean, useChain, useChainInfo, useChains, useCheckReferralCode, useCollateral, useCommission, useComputedLTV, useConfig, useConvert, useCurEpochEstimate, useDaily, useDeposit, useDistribution, useDistributionHistory, useEpochInfo, useEstLiqPriceBySymbol, useEventEmitter, useFeeState, useFundingDetails, useFundingFeeHistory, useFundingRate, useFundingRateBySymbol, useFundingRateHistory, useFundingRates, useFundingRatesStore, useGetClaimed, useGetEnv, 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, useOrderEntry, useOrderEntry$1 as useOrderEntry_deprecated, useOrderStore, useOrderStream, useOrderbookStream, useOrderlyContext, usePortfolio, usePositionActions, usePositionClose, usePositionStream, usePoster, usePreLoadData, usePrivateDataObserver, usePrivateInfiniteQuery, usePrivateQuery, useQuery, type useQueryOptions, 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, useTpslPriceChecker, useTrack, useTrackingInstance, useTradingRewardsStatus, useTransfer, useTransferHistory, useUpdatedRef, useVaultsHistory, useWS, useWalletConnector, useWalletRewardsHistory, useWalletSubscription, useWalletTopic, useWithdraw, useWsStatus, index as utils, _default as version };