@pear-protocol/hyperliquid-sdk 0.0.67 → 0.0.68-beta

package/dist/hooks/useAuth.d.ts

@@ -1,12 +1,14 @@
 import type { GetEIP712MessageResponse } from "../types";
 export declare function useAuth(): {
     readonly isReady: boolean;
-    readonly isAuthenticated: any;
-    readonly accessToken: any;
-    readonly refreshToken: any;
+    readonly isAuthenticated: boolean;
+    readonly accessToken: string | null;
+    readonly refreshToken: string | null;
     readonly getEip712: (address: string) => Promise<GetEIP712MessageResponse>;
     readonly loginWithSignedMessage: (address: string, signature: string, timestamp: number) => Promise<void>;
     readonly loginWithPrivyToken: (address: string, appId: string, privyAccessToken: string) => Promise<void>;
     readonly refreshTokens: () => Promise<import("../types").RefreshTokenResponse>;
     readonly logout: () => Promise<void>;
+    readonly setAddress: (address: string | null) => void;
+    readonly address: string | null;
 };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import React, { ReactNode } from 'react';
+import * as zustand from 'zustand';
 
 interface PearHyperliquidContextType {
     clientId: string;
@@ -781,7 +782,18 @@ interface TokenHistoricalPriceData {
     oldestTime: number | null;
     latestTime: number | null;
 }
-declare const useHistoricalPriceDataStore: any;
+interface HistoricalPriceDataState {
+    historicalPriceData: Record<string, TokenHistoricalPriceData>;
+    loadingTokens: Set<string>;
+    addHistoricalPriceData: (symbol: string, interval: CandleInterval, candles: CandleData[], range: HistoricalRange) => void;
+    hasHistoricalPriceData: (symbol: string, interval: CandleInterval, startTime: number, endTime: number) => boolean;
+    getHistoricalPriceData: (symbol: string, interval: CandleInterval, startTime: number, endTime: number) => CandleData[];
+    setTokenLoading: (symbol: string, loading: boolean) => void;
+    isTokenLoading: (symbol: string) => boolean;
+    removeTokenPriceData: (symbol: string, interval: CandleInterval) => void;
+    clearData: () => void;
+}
+declare const useHistoricalPriceDataStore: zustand.UseBoundStore<zustand.StoreApi<HistoricalPriceDataState>>;
 
 interface UseHistoricalPriceDataReturn {
     fetchHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval, callback?: (data: Record<string, CandleData[]>) => void) => Promise<Record<string, CandleData[]>>;
@@ -1119,14 +1131,16 @@ declare function usePortfolio(): UsePortfolioResult;
 
 declare function useAuth(): {
     readonly isReady: boolean;
-    readonly isAuthenticated: any;
-    readonly accessToken: any;
-    readonly refreshToken: any;
+    readonly isAuthenticated: boolean;
+    readonly accessToken: string | null;
+    readonly refreshToken: string | null;
     readonly getEip712: (address: string) => Promise<GetEIP712MessageResponse>;
     readonly loginWithSignedMessage: (address: string, signature: string, timestamp: number) => Promise<void>;
     readonly loginWithPrivyToken: (address: string, appId: string, privyAccessToken: string) => Promise<void>;
     readonly refreshTokens: () => Promise<RefreshTokenResponse>;
     readonly logout: () => Promise<void>;
+    readonly setAddress: (address: string | null) => void;
+    readonly address: string | null;
 };
 
 interface UseHyperliquidWebSocketProps {
@@ -1323,7 +1337,14 @@ declare function validatePositionSize(usdValue: number, longAssets?: PairAssetIn
     minimumRequired?: number;
 };
 
-declare const useMarketData: any;
+interface MarketDataState {
+    marketData: ActiveAssetsResponse | null;
+    marketDataAll: ActiveAssetsAllResponse | null;
+    setMarketData: (value: ActiveAssetsResponse | null) => void;
+    setMarketDataAll: (value: ActiveAssetsAllResponse | null) => void;
+    clean: () => void;
+}
+declare const useMarketData: zustand.UseBoundStore<zustand.StoreApi<MarketDataState>>;
 
 export { AccountSummaryCalculator, ConflictDetector, MAX_ASSETS_PER_LEG, MINIMUM_ASSET_USD_VALUE, MaxAssetsPerLegError, MinimumPositionSizeError, PearHyperliquidProvider, TokenMetadataExtractor, adjustAdvancePosition, adjustOrder, adjustPosition, calculateMinimumPositionValue, calculateWeightedRatio, cancelOrder, cancelTwap, cancelTwapOrder, closeAllPositions, closePosition, computeBasketCandles, createCandleLookups, createPosition, getCompleteTimestamps, getPortfolio, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, toggleWatchlist, updateRiskParameters, useAccountSummary, useActiveBaskets, useAgentWallet, useAllBaskets, useAuth, useAutoSyncFills, useBasketCandles, useFindBasket, useHighlightedBaskets, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMarketData, useMarketDataAllPayload, useMarketDataPayload, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePortfolio, usePosition, useTokenSelectionMetadata, useTopGainers, useTopLosers, useTradeHistories, useTwap, useUserSelection, useWatchlist, useWatchlistBaskets, useWebData, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };
 export type { AccountSummaryResponseDto, ActiveAssetGroupItem, ActiveAssetsResponse, AdjustAdvanceAssetInput, AdjustAdvanceItemInput, AdjustAdvanceResponseDto, AdjustExecutionType, AdjustOrderRequestInput, AdjustOrderResponseDto, AdjustPositionRequestInput, AdjustPositionResponseDto, AgentWalletDto, AgentWalletState, ApiErrorResponse, ApiResponse, AssetCtx, AssetInformationDetail, AssetMarketData, AssetPosition, AutoSyncFillsOptions, AutoSyncFillsState, BalanceSummaryDto, CancelOrderResponseDto, CancelTwapResponseDto, CandleChartData, CandleData, CandleInterval, CandleSnapshotRequest, ClearinghouseState, CloseAllPositionsResponseDto, CloseAllPositionsResultDto, CloseExecutionType, ClosePositionRequestInput, ClosePositionResponseDto, CreatePositionRequestInput, CreatePositionResponseDto, CrossMarginSummaryDto, CumFundingDto, ExecutionType, ExtraAgent, HLWebSocketResponse, HistoricalRange, LadderConfigInput, MarginSummaryDto, NotificationCategory, NotificationDto, OpenLimitOrderDto, OpenPositionDto, OrderAssetDto, OrderStatus, PairAssetDto, PairAssetInput, PerformanceOverlay, PlatformAccountSummaryResponseDto, PortfolioBucketDto, PortfolioInterval, PortfolioIntervalsDto, PortfolioOverallDto, PortfolioResponseDto, PositionAdjustmentType, PositionAssetDetailDto, PositionAssetSummaryDto, PositionResponseStatus, RealtimeBar, RealtimeBarsCallback, ToggleWatchlistResponseDto, TokenConflict, TokenHistoricalPriceData, TokenMetadata, TokenSelection, TpSlThresholdInput, TpSlThresholdType, TradeHistoryAssetDataDto, TradeHistoryDataDto, TwapChunkStatusDto, TwapMonitoringDto, TwapSliceFillResponseItem, UniverseAsset, UpdateRiskParametersRequestInput, UpdateRiskParametersResponseDto, UseAuthOptions, UseBasketCandlesReturn, UseHistoricalPriceDataReturn, UseNotificationsResult, UsePerformanceOverlaysReturn, UsePortfolioResult, UseTokenSelectionMetadataReturn, UserProfile, UserSelectionState, WatchlistItemDto, WebSocketAckResponse, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketSubscribeMessage, WsAllMidsData };

package/dist/index.js

@@ -1,6 +1,5 @@
 import { jsx } from 'react/jsx-runtime';
-import { useState, useRef, useCallback, useEffect, useMemo, useContext, createContext } from 'react';
-import { create } from 'zustand';
+import React, { useState, useRef, useCallback, useEffect, useMemo, useContext, createContext } from 'react';
 
 // Browser-compatible WebSocket ready state enum (mirrors native values)
 var ReadyState;
@@ -11,10 +10,52 @@ var ReadyState;
     ReadyState[ReadyState["CLOSED"] = 3] = "CLOSED";
 })(ReadyState || (ReadyState = {}));
 
+const createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const api = { setState, getState, getInitialState, subscribe };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+const createStore = ((createState) => createState ? createStoreImpl(createState) : createStoreImpl);
+
+const identity = (arg) => arg;
+function useStore(api, selector = identity) {
+  const slice = React.useSyncExternalStore(
+    api.subscribe,
+    React.useCallback(() => selector(api.getState()), [api, selector]),
+    React.useCallback(() => selector(api.getInitialState()), [api, selector])
+  );
+  React.useDebugValue(slice);
+  return slice;
+}
+const createImpl = (createState) => {
+  const api = createStore(createState);
+  const useBoundStore = (selector) => useStore(api, selector);
+  Object.assign(useBoundStore, api);
+  return useBoundStore;
+};
+const create = ((createState) => createState ? createImpl(createState) : createImpl);
+
 const useUserData = create((set) => ({
     accessToken: null,
     refreshToken: null,
     isAuthenticated: false,
+    isReady: false,
     address: null,
     tradeHistories: null,
     rawOpenPositions: null,
@@ -26,17 +67,17 @@ const useUserData = create((set) => ({
     setAccessToken: (token) => set({ accessToken: token }),
     setRefreshToken: (token) => set({ refreshToken: token }),
     setIsAuthenticated: (value) => set({ isAuthenticated: value }),
-    setAddress: (address) => set(() => {
-        if (typeof window !== 'undefined') {
-            if (address) {
-                window.localStorage.setItem('address', address);
-            }
-            else {
-                window.localStorage.removeItem('address');
-            }
-        }
-        return { address };
-    }),
+    setIsReady: (value) => set({ isReady: value }),
+    setAddress: (address) => {
+        // if (typeof window !== "undefined") {
+        //   if (address) {
+        //     window.localStorage.setItem("address", address);
+        //   } else {
+        //     window.localStorage.removeItem("address");
+        //   }
+        // }
+        set({ address });
+    },
     setTradeHistories: (value) => set({ tradeHistories: value }),
     setRawOpenPositions: (value) => set({ rawOpenPositions: value }),
     setOpenOrders: (value) => set({ openOrders: value }),
@@ -44,10 +85,11 @@ const useUserData = create((set) => ({
     setTwapDetails: (value) => set({ twapDetails: value }),
     setNotifications: (value) => set({ notifications: value }),
     clean: () => set({
-        accessToken: null,
-        refreshToken: null,
-        isAuthenticated: false,
-        address: null,
+        //   accessToken: null,
+        //   refreshToken: null,
+        //   isAuthenticated: false,
+        //   isReady: false,
+        //   address: null,
         tradeHistories: null,
         rawOpenPositions: null,
         openOrders: null,
@@ -625,11 +667,11 @@ const useUserSelection$1 = create((set, get) => ({
 }));
 
 const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
-    const { setAllMids, setActiveAssetData, upsertActiveAssetData, setCandleData, deleteCandleSymbol, deleteActiveAssetData, addCandleData, setFinalAssetContexts, setFinalAtOICaps, setAggregatedClearingHouseState } = useHyperliquidData();
+    const { setAllMids, setActiveAssetData, upsertActiveAssetData, setCandleData, deleteCandleSymbol, deleteActiveAssetData, addCandleData, setFinalAssetContexts, setFinalAtOICaps, setAggregatedClearingHouseState, } = useHyperliquidData();
     const { candleInterval } = useUserSelection$1();
     const longTokens = useUserSelection$1((s) => s.longTokens);
     const shortTokens = useUserSelection$1((s) => s.shortTokens);
-    const selectedTokenSymbols = useMemo(() => ([...longTokens, ...shortTokens].map((t) => t.symbol)), [longTokens, shortTokens]);
+    const selectedTokenSymbols = useMemo(() => [...longTokens, ...shortTokens].map((t) => t.symbol), [longTokens, shortTokens]);
     const [lastError, setLastError] = useState(null);
     const [subscribedAddress, setSubscribedAddress] = useState(null);
     const [subscribedTokens, setSubscribedTokens] = useState([]);
@@ -644,9 +686,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
         try {
             const message = JSON.parse(event.data);
             // Handle subscription responses
-            if ('success' in message || 'error' in message) {
+            if ("success" in message || "error" in message) {
                 if (message.error) {
-                    console.error('[HyperLiquid WS] Subscription error:', message.error);
+                    console.error("[HyperLiquid WS] Subscription error:", message.error);
                     setLastError(message.error);
                 }
                 else {
@@ -655,30 +697,30 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
                 return;
             }
             // Handle channel data messages
-            if ('channel' in message && 'data' in message) {
+            if ("channel" in message && "data" in message) {
                 const response = message;
                 switch (response.channel) {
-                    case 'webData3':
+                    case "webData3":
                         const webData3 = response.data;
                         // finalAssetContexts now sourced from allDexsAssetCtxs channel
                         const finalAtOICaps = webData3.perpDexStates.flatMap((dex) => dex.perpsAtOpenInterestCap);
                         setFinalAtOICaps(finalAtOICaps);
                         break;
-                    case 'allDexsAssetCtxs':
+                    case "allDexsAssetCtxs":
                         {
                             const data = response.data;
                             const finalAssetContexts = (data.ctxs || []).flatMap(([, ctxs]) => ctxs || []);
                             setFinalAssetContexts(finalAssetContexts);
                         }
                         break;
-                    case 'allDexsClearinghouseState':
+                    case "allDexsClearinghouseState":
                         {
                             const data = response.data;
                             const states = (data.clearinghouseStates || [])
                                 .map(([, s]) => s)
                                 .filter(Boolean);
-                            const sum = (values) => values.reduce((acc, v) => acc + (parseFloat(v || '0') || 0), 0);
-                            const toStr = (n) => (Number.isFinite(n) ? n.toString() : '0');
+                            const sum = (values) => values.reduce((acc, v) => acc + (parseFloat(v || "0") || 0), 0);
+                            const toStr = (n) => Number.isFinite(n) ? n.toString() : "0";
                             const assetPositions = states.flatMap((s) => s.assetPositions || []);
                             const crossMaintenanceMarginUsed = toStr(sum(states.map((s) => s.crossMaintenanceMarginUsed)));
                             const crossMarginSummary = {
@@ -706,29 +748,34 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
                             setAggregatedClearingHouseState(aggregatedClearingHouseState);
                         }
                         break;
-                    case 'allMids':
+                    case "allMids":
                         {
                             const data = response.data;
                             const remapped = {
                                 mids: Object.fromEntries(
                                 // only support non hip-3 and xyz market
-                                Object.entries(data.mids || {}).filter(([k, v]) => !k.includes(':') || k.includes('xyz:')).map(([k, v]) => [toDisplaySymbol(k), v]))
+                                Object.entries(data.mids || {})
+                                    .filter(([k, v]) => !k.includes(":") || k.includes("xyz:"))
+                                    .map(([k, v]) => [toDisplaySymbol(k), v])),
                             };
                             setAllMids(remapped);
                         }
                         break;
-                    case 'activeAssetData':
+                    case "activeAssetData":
                         {
                             const assetData = response.data;
                             const symbol = toDisplaySymbol(assetData.coin);
-                            const normalized = { ...assetData, coin: symbol };
+                            const normalized = {
+                                ...assetData,
+                                coin: symbol,
+                            };
                             upsertActiveAssetData(symbol, normalized);
                         }
                         break;
-                    case 'candle':
+                    case "candle":
                         {
                             const candleDataItem = response.data;
-                            const symbol = toDisplaySymbol(candleDataItem.s || '');
+                            const symbol = toDisplaySymbol(candleDataItem.s || "");
                             const normalized = { ...candleDataItem, s: symbol };
                             addCandleData(symbol, normalized);
                         }
@@ -740,10 +787,17 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
         }
         catch (error) {
             const errorMessage = `Failed to parse message: ${error instanceof Error ? error.message : String(error)}`;
-            console.error('[HyperLiquid WS] Parse error:', errorMessage, 'Raw message:', event.data);
+            console.error("[HyperLiquid WS] Parse error:", errorMessage, "Raw message:", event.data);
             setLastError(errorMessage);
         }
-    }, [setAllMids, upsertActiveAssetData, addCandleData, setFinalAssetContexts, setFinalAtOICaps, setAggregatedClearingHouseState]);
+    }, [
+        setAllMids,
+        upsertActiveAssetData,
+        addCandleData,
+        setFinalAssetContexts,
+        setFinalAtOICaps,
+        setAggregatedClearingHouseState,
+    ]);
     const connect = useCallback(() => {
         if (!enabled)
             return;
@@ -756,7 +810,7 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
             }
             manualCloseRef.current = false;
             setReadyState(ReadyState.CONNECTING);
-            const ws = new WebSocket('wss://api.hyperliquid.xyz/ws');
+            const ws = new WebSocket("wss://api.hyperliquid.xyz/ws");
             wsRef.current = ws;
             ws.onopen = () => {
                 reconnectAttemptsRef.current = 0;
@@ -765,15 +819,15 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
             };
             ws.onmessage = handleMessage;
             ws.onerror = (event) => {
-                console.error('[HyperLiquid WS] Connection error:', event);
-                setLastError('WebSocket error');
+                console.error("[HyperLiquid WS] Connection error:", event);
+                setLastError("WebSocket error");
             };
             ws.onclose = () => {
                 setReadyState(ReadyState.CLOSED);
                 if (!manualCloseRef.current && reconnectAttemptsRef.current < 5) {
                     reconnectAttemptsRef.current += 1;
                     if (reconnectAttemptsRef.current === 5) {
-                        console.error('[HyperLiquid WS] Reconnection stopped after 5 attempts');
+                        console.error("[HyperLiquid WS] Reconnection stopped after 5 attempts");
                     }
                     setTimeout(() => connect(), 3000);
                 }
@@ -807,7 +861,7 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
         if (isConnected) {
             // Send ping every 30 seconds
             pingIntervalRef.current = setInterval(() => {
-                sendJsonMessage({ method: 'ping' });
+                sendJsonMessage({ method: "ping" });
             }, 30000);
         }
         else {
@@ -827,57 +881,57 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
     useEffect(() => {
         if (!isConnected)
             return;
-        const DEFAULT_ADDRESS = '0x0000000000000000000000000000000000000000';
+        const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
         const userAddress = address || DEFAULT_ADDRESS;
         if (subscribedAddress === userAddress)
             return;
         // Unsubscribe from previous address if exists
         if (subscribedAddress) {
             const unsubscribeMessage = {
-                method: 'unsubscribe',
+                method: "unsubscribe",
                 subscription: {
-                    type: 'webData3',
+                    type: "webData3",
                     user: subscribedAddress,
                 },
             };
             sendJsonMessage(unsubscribeMessage);
             const unsubscribeAllDexsClearinghouseState = {
-                method: 'unsubscribe',
+                method: "unsubscribe",
                 subscription: {
-                    type: 'allDexsClearinghouseState',
+                    type: "allDexsClearinghouseState",
                     user: subscribedAddress,
                 },
             };
             sendJsonMessage(unsubscribeAllDexsClearinghouseState);
         }
         const subscribeWebData3 = {
-            method: 'subscribe',
+            method: "subscribe",
             subscription: {
-                type: 'webData3',
+                type: "webData3",
                 user: userAddress,
             },
         };
         // Subscribe to allDexsClearinghouseState with the same payload as webData3
         const subscribeAllDexsClearinghouseState = {
-            method: 'subscribe',
+            method: "subscribe",
             subscription: {
-                type: 'allDexsClearinghouseState',
+                type: "allDexsClearinghouseState",
                 user: userAddress,
             },
         };
         // Subscribe to allMids
         const subscribeAllMids = {
-            method: 'subscribe',
+            method: "subscribe",
             subscription: {
-                type: 'allMids',
-                dex: 'ALL_DEXS',
+                type: "allMids",
+                dex: "ALL_DEXS",
             },
         };
         // Subscribe to allDexsAssetCtxs (no payload params, global feed)
         const subscribeAllDexsAssetCtxs = {
-            method: 'subscribe',
+            method: "subscribe",
             subscription: {
-                type: 'allDexsAssetCtxs',
+                type: "allDexsAssetCtxs",
             },
         };
         sendJsonMessage(subscribeWebData3);
@@ -890,7 +944,13 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
             // clear aggregatedClearingHouseState
             setAggregatedClearingHouseState(null);
         }
-    }, [isConnected, address, subscribedAddress, sendJsonMessage, setAggregatedClearingHouseState]);
+    }, [
+        isConnected,
+        address,
+        subscribedAddress,
+        sendJsonMessage,
+        setAggregatedClearingHouseState,
+    ]);
     // Handle token subscriptions for activeAssetData
     useEffect(() => {
         if (!isConnected || !address)
@@ -899,11 +959,11 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
         const tokensToSubscribe = effectiveTokens.filter((token) => token && !subscribedTokens.includes(token));
         const tokensToUnsubscribe = subscribedTokens.filter((token) => !effectiveTokens.includes(token));
         // Unsubscribe from tokens no longer in the list
-        tokensToUnsubscribe.forEach(token => {
+        tokensToUnsubscribe.forEach((token) => {
             const unsubscribeMessage = {
-                method: 'unsubscribe',
+                method: "unsubscribe",
                 subscription: {
-                    type: 'activeAssetData',
+                    type: "activeAssetData",
                     user: address,
                     coin: token,
                 },
@@ -911,11 +971,11 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
             sendJsonMessage(unsubscribeMessage);
         });
         // Subscribe to new tokens
-        tokensToSubscribe.forEach(token => {
+        tokensToSubscribe.forEach((token) => {
             const subscribeMessage = {
-                method: 'subscribe',
+                method: "subscribe",
                 subscription: {
-                    type: 'activeAssetData',
+                    type: "activeAssetData",
                     user: address,
                     coin: token,
                 },
@@ -926,7 +986,14 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
             setSubscribedTokens(effectiveTokens.filter((token) => token));
             tokensToSubscribe.forEach((token) => deleteActiveAssetData(token));
         }
-    }, [isConnected, address, selectedTokenSymbols, subscribedTokens, sendJsonMessage, setActiveAssetData]);
+    }, [
+        isConnected,
+        address,
+        selectedTokenSymbols,
+        subscribedTokens,
+        sendJsonMessage,
+        setActiveAssetData,
+    ]);
     // Handle candle subscriptions for tokens and interval changes
     useEffect(() => {
         if (!isConnected)
@@ -935,11 +1002,11 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
         // Unsubscribe from previous candle subscriptions if interval changed
         const prevInterval = prevCandleIntervalRef.current;
         if (prevInterval && prevInterval !== candleInterval) {
-            subscribedCandleTokens.forEach(token => {
+            subscribedCandleTokens.forEach((token) => {
                 const unsubscribeMessage = {
-                    method: 'unsubscribe',
+                    method: "unsubscribe",
                     subscription: {
-                        type: 'candle',
+                        type: "candle",
                         coin: token,
                         interval: prevInterval,
                     },
@@ -954,9 +1021,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
         // Unsubscribe from tokens no longer in the list
         tokensToUnsubscribe.forEach((token) => {
             const unsubscribeMessage = {
-                method: 'unsubscribe',
+                method: "unsubscribe",
                 subscription: {
-                    type: 'candle',
+                    type: "candle",
                     coin: token,
                     interval: candleInterval,
                 },
@@ -966,9 +1033,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
         // Subscribe to new tokens
         tokensToSubscribe.forEach((token) => {
             const subscribeMessage = {
-                method: 'subscribe',
+                method: "subscribe",
                 subscription: {
-                    type: 'candle',
+                    type: "candle",
                     coin: token,
                     interval: candleInterval,
                 },
@@ -976,12 +1043,21 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, }) => {
             sendJsonMessage(subscribeMessage);
         });
         // Update subscribed state
-        if (tokensToSubscribe.length > 0 || tokensToUnsubscribe.length > 0 || prevInterval !== candleInterval) {
+        if (tokensToSubscribe.length > 0 ||
+            tokensToUnsubscribe.length > 0 ||
+            prevInterval !== candleInterval) {
             setSubscribedCandleTokens(effectiveTokens.filter((token) => token));
             prevCandleIntervalRef.current = candleInterval;
             tokensToUnsubscribe.forEach((token) => deleteCandleSymbol(token));
         }
-    }, [isConnected, selectedTokenSymbols, candleInterval, subscribedCandleTokens, sendJsonMessage, setCandleData]);
+    }, [
+        isConnected,
+        selectedTokenSymbols,
+        candleInterval,
+        subscribedCandleTokens,
+        sendJsonMessage,
+        setCandleData,
+    ]);
     return {
         isConnected,
         lastError,
@@ -7077,38 +7153,47 @@ async function logout(baseUrl, refreshTokenVal) {
 function useAuth() {
     const context = useContext(PearHyperliquidContext);
     if (!context) {
-        throw new Error("usePortfolio must be used within a PearHyperliquidProvider");
+        throw new Error("useAuth must be used within a PearHyperliquidProvider");
     }
     const { apiBaseUrl, clientId } = context;
-    const [isReady, setIsReady] = useState(false);
     const accessToken = useUserData((s) => s.accessToken);
     const refreshToken$1 = useUserData((s) => s.refreshToken);
+    const isReady = useUserData((s) => s.isReady);
+    const isAuthenticated = useUserData((s) => s.isAuthenticated);
+    const address = useUserData((s) => s.address);
     const setAccessToken = useUserData((s) => s.setAccessToken);
     const setRefreshToken = useUserData((s) => s.setRefreshToken);
-    const isAuthenticated = useUserData((s) => s.isAuthenticated);
+    const setIsReady = useUserData((s) => s.setIsReady);
     const setIsAuthenticated = useUserData((s) => s.setIsAuthenticated);
     const setAddress = useUserData((s) => s.setAddress);
+    console.log("sdk", { sdkAddress: address });
     useEffect(() => {
         if (typeof window == "undefined") {
             return;
         }
-        const access = localStorage.getItem("accessToken");
-        const refresh = localStorage.getItem("refreshToken");
-        const addr = localStorage.getItem("address");
-        setAccessToken(access);
-        setRefreshToken(refresh);
-        setAddress(addr);
-        const authed = Boolean(access && addr);
-        setIsAuthenticated(authed);
+        if (address) {
+            // If we already have an address in state, use it to load the session
+            const accessTokenKey = `${address}_accessToken`;
+            const refreshTokenKey = `${address}_refreshToken`;
+            const storedAccessToken = localStorage.getItem(accessTokenKey);
+            const storedRefreshToken = localStorage.getItem(refreshTokenKey);
+            console.log({ storedAccessToken, storedRefreshToken });
+            if (storedAccessToken && storedRefreshToken) {
+                setAccessToken(storedAccessToken);
+                setRefreshToken(storedRefreshToken);
+                setIsAuthenticated(true);
+            }
+        }
         setIsReady(true);
-    }, [setAccessToken, setRefreshToken, setIsAuthenticated, setAddress]);
+    }, [address]);
     useEffect(() => {
         const cleanup = addAuthInterceptors({
             apiBaseUrl,
             getAccessToken: () => {
-                return typeof window !== "undefined"
-                    ? window.localStorage.getItem("accessToken")
-                    : null;
+                if (typeof window === "undefined")
+                    return null;
+                // Read from Zustand state as single source of truth
+                return useUserData.getState().accessToken;
             },
             refreshTokens: async () => {
                 const data = await refreshTokens();
@@ -7134,12 +7219,13 @@ function useAuth() {
                 clientId,
                 details: { signature, timestamp },
             });
-            window.localStorage.setItem("accessToken", data.accessToken);
-            window.localStorage.setItem("refreshToken", data.refreshToken);
-            window.localStorage.setItem("address", address);
+            const accessTokenKey = `${address}_accessToken`;
+            const refreshTokenKey = `${address}_refreshToken`;
+            window.localStorage.setItem(accessTokenKey, data.accessToken);
+            window.localStorage.setItem(refreshTokenKey, data.refreshToken);
             setAccessToken(data.accessToken);
             setRefreshToken(data.refreshToken);
-            setAddress(address);
+            // setAddress(address);
             setIsAuthenticated(true);
         }
         catch (e) {
@@ -7154,12 +7240,13 @@ function useAuth() {
                 appId,
                 accessToken: privyAccessToken,
             });
-            window.localStorage.setItem("accessToken", data.accessToken);
-            window.localStorage.setItem("refreshToken", data.refreshToken);
-            window.localStorage.setItem("address", address);
+            const accessTokenKey = `${address}_accessToken`;
+            const refreshTokenKey = `${address}_refreshToken`;
+            window.localStorage.setItem(accessTokenKey, data.accessToken);
+            window.localStorage.setItem(refreshTokenKey, data.refreshToken);
             setAccessToken(data.accessToken);
             setRefreshToken(data.refreshToken);
-            setAddress(address);
+            // setAddress(address);
             setIsAuthenticated(true);
         }
         catch (e) {
@@ -7167,33 +7254,41 @@ function useAuth() {
         }
     }
     async function refreshTokens() {
-        const refresh = window.localStorage.getItem("refreshToken");
-        if (!refresh)
+        const currentAddress = address;
+        const currentRefresh = refreshToken$1;
+        if (!currentRefresh || !currentAddress)
             throw new Error("No refresh token");
-        const { data } = await refreshToken(apiBaseUrl, refresh);
-        window.localStorage.setItem("accessToken", data.accessToken);
-        window.localStorage.setItem("refreshToken", data.refreshToken);
+        const { data } = await refreshToken(apiBaseUrl, currentRefresh);
+        // Update tokens in localStorage
+        const accessTokenKey = `${currentAddress}_accessToken`;
+        const refreshTokenKey = `${currentAddress}_refreshToken`;
+        window.localStorage.setItem(accessTokenKey, data.accessToken);
+        window.localStorage.setItem(refreshTokenKey, data.refreshToken);
         setAccessToken(data.accessToken);
         setRefreshToken(data.refreshToken);
         setIsAuthenticated(true);
         return data;
     }
     async function logout$1() {
-        const refresh = window.localStorage.getItem("refreshToken");
-        if (refresh) {
+        const currentAddress = address;
+        const currentRefresh = refreshToken$1;
+        if (currentRefresh) {
             try {
-                await logout(apiBaseUrl, refresh);
+                await logout(apiBaseUrl, currentRefresh);
             }
             catch (_a) {
                 /* ignore */
             }
         }
-        window.localStorage.removeItem("accessToken");
-        window.localStorage.removeItem("refreshToken");
-        window.localStorage.removeItem("address");
+        if (currentAddress) {
+            const accessTokenKey = `${currentAddress}_accessToken`;
+            const refreshTokenKey = `${currentAddress}_refreshToken`;
+            window.localStorage.removeItem(accessTokenKey);
+            window.localStorage.removeItem(refreshTokenKey);
+        }
         setAccessToken(null);
         setRefreshToken(null);
-        setAddress(null);
+        // setAddress(null);
         setIsAuthenticated(false);
     }
     return {
@@ -7206,6 +7301,8 @@ function useAuth() {
         loginWithPrivyToken,
         refreshTokens,
         logout: logout$1,
+        setAddress,
+        address,
     };
 }
 
@@ -7215,7 +7312,6 @@ const PearHyperliquidContext = createContext(undefined);
  */
 const PearHyperliquidProvider = ({ children, apiBaseUrl = "https://hl-ui.pearprotocol.io", clientId = "PEARPROTOCOLUI", wsUrl = "wss://hl-ui.pearprotocol.io/ws", }) => {
     const address = useUserData((s) => s.address);
-    const setAddress = useUserData((s) => s.setAddress);
     const perpsMetaAssets = useHyperliquidData((state) => state.perpMetaAssets);
     const setPerpMetaAssets = useHyperliquidData((state) => state.setPerpMetaAssets);
     const setHip3DisplayToFull = useHyperliquidData((state) => state.setHip3DisplayToFull);
@@ -7280,8 +7376,6 @@ const PearHyperliquidProvider = ({ children, apiBaseUrl = "https://hl-ui.pearpro
     }), [
         apiBaseUrl,
         wsUrl,
-        address,
-        setAddress,
         isConnected,
         lastError,
         nativeIsConnected,

package/dist/store/historicalPriceDataStore.d.ts

@@ -10,5 +10,16 @@ interface TokenHistoricalPriceData {
     oldestTime: number | null;
     latestTime: number | null;
 }
-export declare const useHistoricalPriceDataStore: any;
+interface HistoricalPriceDataState {
+    historicalPriceData: Record<string, TokenHistoricalPriceData>;
+    loadingTokens: Set<string>;
+    addHistoricalPriceData: (symbol: string, interval: CandleInterval, candles: CandleData[], range: HistoricalRange) => void;
+    hasHistoricalPriceData: (symbol: string, interval: CandleInterval, startTime: number, endTime: number) => boolean;
+    getHistoricalPriceData: (symbol: string, interval: CandleInterval, startTime: number, endTime: number) => CandleData[];
+    setTokenLoading: (symbol: string, loading: boolean) => void;
+    isTokenLoading: (symbol: string) => boolean;
+    removeTokenPriceData: (symbol: string, interval: CandleInterval) => void;
+    clearData: () => void;
+}
+export declare const useHistoricalPriceDataStore: import("zustand").UseBoundStore<import("zustand").StoreApi<HistoricalPriceDataState>>;
 export type { HistoricalRange, TokenHistoricalPriceData };

package/dist/store/hyperliquidDataStore.d.ts

@@ -1 +1,25 @@
-export declare const useHyperliquidData: any;
+import { ActiveAssetData, CandleChartData, CandleData, ClearinghouseState, UniverseAsset, WebData3AssetCtx, WsAllMidsData } from "../types";
+interface HyperliquidDataState {
+    allMids: WsAllMidsData | null;
+    activeAssetData: Record<string, ActiveAssetData> | null;
+    candleData: CandleChartData | null;
+    finalAssetContexts: WebData3AssetCtx[] | null;
+    finalAtOICaps: string[] | null;
+    aggregatedClearingHouseState: ClearinghouseState | null;
+    perpMetaAssets: UniverseAsset[] | null;
+    hip3DisplayToFull: Map<string, string>;
+    setAllMids: (value: WsAllMidsData | null) => void;
+    setActiveAssetData: (value: Record<string, ActiveAssetData> | null | ((prev: Record<string, ActiveAssetData> | null) => Record<string, ActiveAssetData> | null)) => void;
+    deleteActiveAssetData: (key: string) => void;
+    addCandleData: (symbol: string, candle: CandleData) => void;
+    deleteCandleSymbol: (symbol: string) => void;
+    setCandleData: (value: CandleChartData | null) => void;
+    upsertActiveAssetData: (key: string, value: ActiveAssetData) => void;
+    setFinalAssetContexts: (value: WebData3AssetCtx[] | null) => void;
+    setFinalAtOICaps: (value: string[] | null) => void;
+    setAggregatedClearingHouseState: (value: ClearinghouseState | null) => void;
+    setPerpMetaAssets: (value: UniverseAsset[] | null) => void;
+    setHip3DisplayToFull: (value: Map<string, string>) => void;
+}
+export declare const useHyperliquidData: import("zustand").UseBoundStore<import("zustand").StoreApi<HyperliquidDataState>>;
+export {};

package/dist/store/marketDataStore.d.ts

@@ -1 +1,10 @@
-export declare const useMarketData: any;
+import type { ActiveAssetsAllResponse, ActiveAssetsResponse } from '../types';
+interface MarketDataState {
+    marketData: ActiveAssetsResponse | null;
+    marketDataAll: ActiveAssetsAllResponse | null;
+    setMarketData: (value: ActiveAssetsResponse | null) => void;
+    setMarketDataAll: (value: ActiveAssetsAllResponse | null) => void;
+    clean: () => void;
+}
+export declare const useMarketData: import("zustand").UseBoundStore<import("zustand").StoreApi<MarketDataState>>;
+export {};

package/dist/store/tokenSelectionMetadataStore.d.ts

@@ -24,4 +24,4 @@ export interface TokenSelectionMetadataState {
         shortTokens: TokenSelection[];
     }) => void;
 }
-export declare const useTokenSelectionMetadataStore: any;
+export declare const useTokenSelectionMetadataStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TokenSelectionMetadataState>>;

package/dist/store/userDataStore.d.ts

@@ -1 +1,30 @@
-export declare const useUserData: any;
+import { PlatformAccountSummaryResponseDto, OpenLimitOrderDto, RawPositionDto, TradeHistoryDataDto, TwapMonitoringDto, NotificationDto, ExtraAgent } from "../types";
+interface UserDataState {
+    accessToken: string | null;
+    refreshToken: string | null;
+    isAuthenticated: boolean;
+    isReady: boolean;
+    address: string | null;
+    tradeHistories: TradeHistoryDataDto[] | null;
+    rawOpenPositions: RawPositionDto[] | null;
+    openOrders: OpenLimitOrderDto[] | null;
+    accountSummary: PlatformAccountSummaryResponseDto | null;
+    twapDetails: TwapMonitoringDto[] | null;
+    notifications: NotificationDto[] | null;
+    userExtraAgents: ExtraAgent[] | null;
+    setAccessToken: (token: string | null) => void;
+    setRefreshToken: (token: string | null) => void;
+    setIsAuthenticated: (value: boolean) => void;
+    setIsReady: (value: boolean) => void;
+    setAddress: (address: string | null) => void;
+    setTradeHistories: (value: TradeHistoryDataDto[] | null) => void;
+    setRawOpenPositions: (value: RawPositionDto[] | null) => void;
+    setOpenOrders: (value: OpenLimitOrderDto[] | null) => void;
+    setAccountSummary: (value: PlatformAccountSummaryResponseDto | null) => void;
+    setUserExtraAgents: (value: ExtraAgent[] | null) => void;
+    setTwapDetails: (value: TwapMonitoringDto[] | null) => void;
+    setNotifications: (value: NotificationDto[] | null) => void;
+    clean: () => void;
+}
+export declare const useUserData: import("zustand").UseBoundStore<import("zustand").StoreApi<UserDataState>>;
+export {};

package/dist/store/userSelection.d.ts

@@ -23,5 +23,5 @@ interface UserSelectionState {
     setTokenSelections: (longTokens: TokenSelection[], shortTokens: TokenSelection[]) => void;
     resetToDefaults: () => void;
 }
-export declare const useUserSelection: any;
+export declare const useUserSelection: import("zustand").UseBoundStore<import("zustand").StoreApi<UserSelectionState>>;
 export type { UserSelectionState };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/hyperliquid-sdk",
-  "version": "0.0.67",
+  "version": "0.0.68-beta",
   "description": "React SDK for Pear Protocol Hyperliquid API integration",
   "type": "module",
   "main": "dist/index.js",
@@ -24,7 +24,8 @@
     "clean": "rimraf dist"
   },
   "dependencies": {
-    "axios": "^1.6.0"
+    "axios": "^1.6.0",
+    "zustand": "^5.0.8"
   },
   "peerDependencies": {
     "react": "^18.0.0",