@pear-protocol/hyperliquid-sdk 0.1.12 → 0.1.13-beta.2

package/dist/clients/auth.d.ts

@@ -1,4 +1,4 @@
-import type { ApiResponse, GetEIP712MessageResponse, AuthenticateRequest, AuthenticateResponse, RefreshTokenResponse, LogoutResponse } from '../types';
+import type { ApiResponse, GetEIP712MessageResponse, AuthenticateRequest, AuthenticateResponse, RefreshTokenResponse, LogoutResponse } from "../types";
 export declare function getEIP712Message(baseUrl: string, address: string, clientId: string): Promise<ApiResponse<GetEIP712MessageResponse>>;
 export declare function authenticate(baseUrl: string, body: AuthenticateRequest): Promise<ApiResponse<AuthenticateResponse>>;
 /**

package/dist/hooks/useAuth.d.ts

@@ -1,4 +1,4 @@
-import type { GetEIP712MessageResponse } from "../types";
+import type { GetEIP712MessageResponse } from '../types';
 export declare function useAuth(): {
     readonly isReady: boolean;
     readonly isAuthenticated: boolean;
@@ -10,4 +10,6 @@ export declare function useAuth(): {
     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 clearSession: () => void;
 };

package/dist/index.d.ts

@@ -1429,6 +1429,8 @@ declare function useAuth(): {
     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 clearSession: () => void;
 };
 
 interface MarginRequiredPerCollateral {

package/dist/index.js

@@ -65,18 +65,29 @@ const useUserData = create((set) => ({
     userExtraAgents: null,
     spotState: null,
     userAbstractionMode: null,
+    isReady: false,
     setUserAbstractionMode: (value) => set({ userAbstractionMode: value }),
     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');
-            }
+    setIsReady: (value) => set({ isReady: value }),
+    setAddress: (address) => set((state) => {
+        // If address changed, clear user-specific data to prevent stale balances
+        const addressChanged = state.address !== null && state.address !== address;
+        if (addressChanged) {
+            return {
+                address,
+                // Clear user-specific data when address changes
+                spotState: null,
+                tradeHistories: null,
+                rawOpenPositions: null,
+                openOrders: null,
+                accountSummary: null,
+                twapDetails: null,
+                notifications: null,
+                userExtraAgents: null,
+                userAbstractionMode: null,
+            };
         }
         return { address };
     }),
@@ -88,10 +99,6 @@ const useUserData = create((set) => ({
     setNotifications: (value) => set({ notifications: value }),
     setSpotState: (value) => set({ spotState: value }),
     clean: () => set({
-        accessToken: null,
-        refreshToken: null,
-        isAuthenticated: false,
-        address: null,
         tradeHistories: null,
         rawOpenPositions: null,
         openOrders: null,
@@ -384,19 +391,19 @@ class TokenMetadataExtractor {
         if (!assetCtx) {
             return null;
         }
-        // Get current price - prefer assetCtx.midPx as it's already index-matched,
-        // fall back to allMids lookup if midPx is null
+        // Get current price - prefer allMids (real-time WebSocket data),
+        // fall back to assetCtx.midPx if not available
         const actualSymbol = foundAsset.name;
         let currentPrice = 0;
-        // Fallback: assetCtx.midPx (already properly indexed)
-        if (!currentPrice || isNaN(currentPrice)) {
-            const currentPriceStr = allMids.mids[actualSymbol] || allMids.mids[symbol];
-            currentPrice = currentPriceStr ? parseFloat(currentPriceStr) : 0;
-        }
-        // Primary source: allMids lookup
+        // Fallback: assetCtx.midPx (from REST API, less frequent)
         if (assetCtx.midPx) {
             currentPrice = parseFloat(assetCtx.midPx);
         }
+        // Primary source: allMids (real-time WebSocket data)
+        const currentPriceStr = allMids.mids[actualSymbol] || allMids.mids[symbol];
+        if (currentPriceStr) {
+            currentPrice = parseFloat(currentPriceStr);
+        }
         // Get previous day price
         const prevDayPrice = parseFloat(assetCtx.prevDayPx);
         // Calculate 24h price change
@@ -551,7 +558,7 @@ const useHyperliquidData = create((set) => ({
         tokenMetadata: refreshTokenMetadata(state, { allMids: value }),
     })),
     setActiveAssetData: (value) => set((state) => {
-        const activeAssetData = typeof value === 'function' ? value(state.activeAssetData) : value;
+        const activeAssetData = typeof value === "function" ? value(state.activeAssetData) : value;
         return {
             activeAssetData,
             tokenMetadata: refreshTokenMetadata(state, { activeAssetData }),
@@ -591,7 +598,10 @@ const useHyperliquidData = create((set) => ({
     setCandleData: (value) => set({ candleData: value }),
     upsertActiveAssetData: (key, value) => set((state) => {
         var _a;
-        const activeAssetData = { ...((_a = state.activeAssetData) !== null && _a !== void 0 ? _a : {}), [key]: value };
+        const activeAssetData = {
+            ...((_a = state.activeAssetData) !== null && _a !== void 0 ? _a : {}),
+            [key]: value,
+        };
         return {
             activeAssetData,
             tokenMetadata: refreshTokenMetadata(state, { activeAssetData }, { symbols: [key] }),
@@ -626,6 +636,11 @@ const useHyperliquidData = create((set) => ({
             perpMetasByDex: state.perpMetasByDex,
         }),
     })),
+    // Clear user-specific data (called when wallet address changes)
+    clearUserData: () => set({
+        aggregatedClearingHouseState: null,
+        rawClearinghouseStates: null,
+    }),
 }));
 
 /**
@@ -906,6 +921,7 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
     const reconnectAttemptsRef = useRef(0);
     const manualCloseRef = useRef(false);
     const onUserFillsRef = useRef(onUserFills);
+    const reconnectTimeoutRef = useRef(null);
     const [readyState, setReadyState] = useState(ReadyState.CONNECTING);
     // Keep the ref updated with the latest callback
     useEffect(() => {
@@ -916,9 +932,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         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 {
@@ -927,44 +943,44 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
                 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 'userFills':
+                    case "userFills":
                         {
                             const maybePromise = (_a = onUserFillsRef.current) === null || _a === void 0 ? void 0 : _a.call(onUserFillsRef);
                             if (maybePromise instanceof Promise) {
-                                maybePromise.catch((err) => console.error('[HyperLiquid WS] userFills callback error', err));
+                                maybePromise.catch((err) => console.error("[HyperLiquid WS] userFills callback error", err));
                             }
                         }
                         break;
-                    case 'webData3':
+                    case "webData3":
                         const webData3 = response.data;
                         // finalAssetContexts now sourced from allDexsAssetCtxs channel
                         const finalAtOICaps = webData3.perpDexStates.flatMap((dex) => dex.perpsAtOpenInterestCap);
                         setFinalAtOICaps(finalAtOICaps);
                         setUserAbstractionMode(webData3.userState.abstraction || null);
                         break;
-                    case 'allDexsAssetCtxs':
+                    case "allDexsAssetCtxs":
                         {
                             const data = response.data;
                             // Store by DEX name, mapping '' to 'HYPERLIQUID'
                             const assetContextsByDex = new Map();
                             data.ctxs.forEach(([dexKey, ctxs]) => {
-                                const dexName = dexKey === '' ? 'HYPERLIQUID' : dexKey;
+                                const dexName = dexKey === "" ? "HYPERLIQUID" : dexKey;
                                 assetContextsByDex.set(dexName, ctxs || []);
                             });
                             setAssetContextsByDex(assetContextsByDex);
                         }
                         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 = {
@@ -994,26 +1010,26 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
                             setClearinghouseStateReceived(true);
                         }
                         break;
-                    case 'allMids':
+                    case "allMids":
                         {
                             const data = response.data;
                             setAllMids(data);
                         }
                         break;
-                    case 'activeAssetData':
+                    case "activeAssetData":
                         {
                             const assetData = response.data;
                             upsertActiveAssetData(assetData.coin, assetData);
                         }
                         break;
-                    case 'candle':
+                    case "candle":
                         {
                             const candleDataItem = response.data;
-                            const symbol = candleDataItem.s || '';
+                            const symbol = candleDataItem.s || "";
                             addCandleData(symbol, candleDataItem);
                         }
                         break;
-                    case 'spotState':
+                    case "spotState":
                         {
                             const spotStateData = response.data;
                             if (spotStateData === null || spotStateData === void 0 ? void 0 : spotStateData.spotState) {
@@ -1028,7 +1044,7 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         }
         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);
         }
     }, [
@@ -1042,9 +1058,14 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         setSpotState,
     ]);
     const connect = useCallback(() => {
-        console.log('[HyperLiquid WS] connect() called, enabled:', enabled);
+        console.log("[HyperLiquid WS] connect() called, enabled:", enabled);
         if (!enabled)
             return;
+        // Clear any pending reconnect timeout
+        if (reconnectTimeoutRef.current) {
+            clearTimeout(reconnectTimeoutRef.current);
+            reconnectTimeoutRef.current = null;
+        }
         try {
             // Avoid opening multiple sockets if one is already active or connecting
             if (wsRef.current &&
@@ -1053,10 +1074,10 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
                 console.log('[HyperLiquid WS] connect() returning early - socket already exists, readyState:', wsRef.current.readyState);
                 return;
             }
-            console.log('[HyperLiquid WS] Creating new WebSocket connection');
+            console.log("[HyperLiquid WS] Creating new WebSocket connection");
             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;
@@ -1065,17 +1086,22 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
             };
             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) {
+                // Reset subscription state so effects will resubscribe on reconnect
+                setSubscribedAddress(null);
+                setSubscribedTokens([]);
+                setSubscribedCandleTokens([]);
+                setClearinghouseStateReceived(false);
+                if (!manualCloseRef.current) {
                     reconnectAttemptsRef.current += 1;
-                    if (reconnectAttemptsRef.current === 5) {
-                        console.error('[HyperLiquid WS] Reconnection stopped after 5 attempts');
-                    }
-                    setTimeout(() => connect(), 3000);
+                    // Exponential backoff: 1s, 2s, 4s, 8s, 16s, 30s (max), then stay at 30s
+                    const delay = Math.min(1000 * Math.pow(2, reconnectAttemptsRef.current - 1), 30000);
+                    console.log(`[HyperLiquid WS] Reconnecting in ${delay}ms (attempt ${reconnectAttemptsRef.current})`);
+                    reconnectTimeoutRef.current = setTimeout(() => connect(), delay);
                 }
             };
         }
@@ -1086,9 +1112,53 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
     useEffect(() => {
         console.log('[HyperLiquid WS] Connection effect running - calling connect()');
         connect();
+        // Handle online/offline events to reconnect when internet is restored
+        const handleOnline = () => {
+            console.log('[HyperLiquid WS] Browser went online, attempting reconnect');
+            // Reset reconnect attempts when internet comes back
+            reconnectAttemptsRef.current = 0;
+            // Clear any pending reconnect timeout
+            if (reconnectTimeoutRef.current) {
+                clearTimeout(reconnectTimeoutRef.current);
+                reconnectTimeoutRef.current = null;
+            }
+            // Reset subscription state so effects will resubscribe on reconnect
+            setSubscribedAddress(null);
+            setSubscribedTokens([]);
+            setSubscribedCandleTokens([]);
+            setClearinghouseStateReceived(false);
+            // Close existing socket if in a bad state
+            if (wsRef.current &&
+                wsRef.current.readyState !== WebSocket.OPEN &&
+                wsRef.current.readyState !== WebSocket.CONNECTING) {
+                try {
+                    wsRef.current.close();
+                }
+                catch (_a) { }
+                wsRef.current = null;
+            }
+            // Attempt to reconnect
+            connect();
+        };
+        const handleOffline = () => {
+            console.log('[HyperLiquid WS] Browser went offline');
+            // Clear pending reconnect timeout since we're offline
+            if (reconnectTimeoutRef.current) {
+                clearTimeout(reconnectTimeoutRef.current);
+                reconnectTimeoutRef.current = null;
+            }
+        };
+        window.addEventListener('online', handleOnline);
+        window.addEventListener('offline', handleOffline);
         return () => {
             console.log('[HyperLiquid WS] Connection effect cleanup - closing existing connection');
+            window.removeEventListener('online', handleOnline);
+            window.removeEventListener('offline', handleOffline);
             manualCloseRef.current = true;
+            if (reconnectTimeoutRef.current) {
+                clearTimeout(reconnectTimeoutRef.current);
+                reconnectTimeoutRef.current = null;
+            }
             if (wsRef.current) {
                 try {
                     wsRef.current.close();
@@ -1109,7 +1179,7 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         if (isConnected) {
             // Send ping every 30 seconds
             pingIntervalRef.current = setInterval(() => {
-                sendJsonMessage({ method: 'ping' });
+                sendJsonMessage({ method: "ping" });
             }, 30000);
         }
         else {
@@ -1127,27 +1197,27 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
     }, [isConnected, sendJsonMessage]);
     // Handle address subscription changes
     useEffect(() => {
-        const DEFAULT_ADDRESS = '0x0000000000000000000000000000000000000000';
+        const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
         const userAddress = (address || DEFAULT_ADDRESS).toLowerCase();
         const normalizedSubscribedAddress = (subscribedAddress === null || subscribedAddress === void 0 ? void 0 : subscribedAddress.toLowerCase()) || null;
-        console.log('[HyperLiquid WS] Address subscription effect running');
-        console.log('[HyperLiquid WS] address:', address, 'userAddress:', userAddress, 'subscribedAddress:', subscribedAddress, 'normalizedSubscribedAddress:', normalizedSubscribedAddress);
-        console.log('[HyperLiquid WS] isConnected:', isConnected);
+        console.log("[HyperLiquid WS] Address subscription effect running");
+        console.log("[HyperLiquid WS] address:", address, "userAddress:", userAddress, "subscribedAddress:", subscribedAddress, "normalizedSubscribedAddress:", normalizedSubscribedAddress);
+        console.log("[HyperLiquid WS] isConnected:", isConnected);
         if (normalizedSubscribedAddress === userAddress) {
-            console.log('[HyperLiquid WS] Address unchanged, skipping subscription update');
+            console.log("[HyperLiquid WS] Address unchanged, skipping subscription update");
             return;
         }
         if (!isConnected) {
-            console.log('[HyperLiquid WS] Not connected, skipping subscription update');
+            console.log("[HyperLiquid WS] Not connected, skipping subscription update");
             return;
         }
         // Unsubscribe from previous address if exists
         if (subscribedAddress) {
-            console.log('[HyperLiquid WS] Unsubscribing from previous address:', subscribedAddress);
+            console.log("[HyperLiquid WS] Unsubscribing from previous address:", subscribedAddress);
             const unsubscribeMessage = {
-                method: 'unsubscribe',
+                method: "unsubscribe",
                 subscription: {
-                    type: 'webData3',
+                    type: "webData3",
                     user: subscribedAddress,
                 },
             };
@@ -1155,54 +1225,54 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
             // Unsubscribe from spotState for previous address
             if (subscribedAddress !== DEFAULT_ADDRESS) {
                 const unsubscribeSpotState = {
-                    method: 'unsubscribe',
+                    method: "unsubscribe",
                     subscription: {
-                        type: 'spotState',
+                        type: "spotState",
                         user: subscribedAddress,
                     },
                 };
                 sendJsonMessage(unsubscribeSpotState);
             }
             const unsubscribeAllDexsClearinghouseState = {
-                method: 'unsubscribe',
+                method: "unsubscribe",
                 subscription: {
-                    type: 'allDexsClearinghouseState',
+                    type: "allDexsClearinghouseState",
                     user: subscribedAddress,
                 },
             };
             sendJsonMessage(unsubscribeAllDexsClearinghouseState);
             const unsubscribeUserFills = {
-                method: 'unsubscribe',
+                method: "unsubscribe",
                 subscription: {
-                    type: 'userFills',
+                    type: "userFills",
                     user: subscribedAddress,
                 },
             };
             sendJsonMessage(unsubscribeUserFills);
         }
         const subscribeWebData3 = {
-            method: 'subscribe',
+            method: "subscribe",
             subscription: {
-                type: 'webData3',
+                type: "webData3",
                 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",
             },
         };
-        console.log('[HyperLiquid WS] Subscribing to new address:', userAddress);
+        console.log("[HyperLiquid WS] Subscribing to new address:", userAddress);
         sendJsonMessage(subscribeWebData3);
         sendJsonMessage(subscribeAllMids);
         sendJsonMessage(subscribeAllDexsAssetCtxs);
@@ -1210,9 +1280,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         // Only subscribe if we have a real user address (not the default)
         if (userAddress !== DEFAULT_ADDRESS.toLowerCase()) {
             const subscribeSpotState = {
-                method: 'subscribe',
+                method: "subscribe",
                 subscription: {
-                    type: 'spotState',
+                    type: "spotState",
                     user: userAddress,
                 },
             };
@@ -1222,9 +1292,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         // Only subscribe if we have a real user address (not the default)
         if (userAddress !== DEFAULT_ADDRESS.toLowerCase()) {
             const subscribeAllDexsClearinghouseState = {
-                method: 'subscribe',
+                method: "subscribe",
                 subscription: {
-                    type: 'allDexsClearinghouseState',
+                    type: "allDexsClearinghouseState",
                     user: userAddress,
                 },
             };
@@ -1258,9 +1328,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
             !userSummary)
             return;
         const subscribeUserFills = {
-            method: 'subscribe',
+            method: "subscribe",
             subscription: {
-                type: 'userFills',
+                type: "userFills",
                 user: subscribedAddress,
             },
         };
@@ -1282,9 +1352,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         // Unsubscribe from tokens no longer in the list
         tokensToUnsubscribe.forEach((token) => {
             const unsubscribeMessage = {
-                method: 'unsubscribe',
+                method: "unsubscribe",
                 subscription: {
-                    type: 'activeAssetData',
+                    type: "activeAssetData",
                     user: address,
                     coin: token,
                 },
@@ -1294,9 +1364,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         // Subscribe to new tokens
         tokensToSubscribe.forEach((token) => {
             const subscribeMessage = {
-                method: 'subscribe',
+                method: "subscribe",
                 subscription: {
-                    type: 'activeAssetData',
+                    type: "activeAssetData",
                     user: address,
                     coin: token,
                 },
@@ -1325,9 +1395,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         if (prevInterval && prevInterval !== candleInterval) {
             subscribedCandleTokens.forEach((token) => {
                 const unsubscribeMessage = {
-                    method: 'unsubscribe',
+                    method: "unsubscribe",
                     subscription: {
-                        type: 'candle',
+                        type: "candle",
                         coin: token,
                         interval: prevInterval,
                     },
@@ -1342,9 +1412,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         // 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,
                 },
@@ -1354,9 +1424,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         // Subscribe to new tokens
         tokensToSubscribe.forEach((token) => {
             const subscribeMessage = {
-                method: 'subscribe',
+                method: "subscribe",
                 subscription: {
-                    type: 'candle',
+                    type: "candle",
                     coin: token,
                     interval: candleInterval,
                 },
@@ -5871,10 +5941,10 @@ function toApiError(error) {
     var _a;
     const axiosError = error;
     const payload = (axiosError && axiosError.response ? axiosError.response.data : undefined);
-    const message = typeof payload === 'object' && payload && 'message' in payload
+    const message = typeof payload === "object" && payload && "message" in payload
         ? String(payload.message)
-        : (axiosError === null || axiosError === void 0 ? void 0 : axiosError.message) || 'Request failed';
-    const errField = typeof payload === 'object' && payload && 'error' in payload
+        : (axiosError === null || axiosError === void 0 ? void 0 : axiosError.message) || "Request failed";
+    const errField = typeof payload === "object" && payload && "error" in payload
         ? String(payload.error)
         : undefined;
     return {
@@ -5884,8 +5954,8 @@ function toApiError(error) {
     };
 }
 function joinUrl(baseUrl, path) {
-    const cleanBase = baseUrl.replace(/\/$/, '');
-    const cleanPath = path.startsWith('/') ? path : `/${path}`;
+    const cleanBase = baseUrl.replace(/\/$/, "");
+    const cleanPath = path.startsWith("/") ? path : `/${path}`;
     return `${cleanBase}${cleanPath}`;
 }
 /**
@@ -5914,7 +5984,7 @@ function addAuthInterceptors(params) {
         pendingRequests = [];
     }
     const isOurApiUrl = (url) => Boolean(url && url.startsWith(apiBaseUrl));
-    const isRefreshUrl = (url) => Boolean(url && url.startsWith(joinUrl(apiBaseUrl, '/auth/refresh')));
+    const isRefreshUrl = (url) => Boolean(url && url.startsWith(joinUrl(apiBaseUrl, "/auth/refresh")));
     const reqId = apiClient.interceptors.request.use((config) => {
         var _a;
         try {
@@ -5922,11 +5992,12 @@ function addAuthInterceptors(params) {
                 const token = getAccessToken();
                 if (token) {
                     config.headers = (_a = config.headers) !== null && _a !== void 0 ? _a : {};
-                    (config.headers)['Authorization'] = `Bearer ${token}`;
+                    config.headers["Authorization"] = `Bearer ${token}`;
                 }
             }
         }
-        catch (_b) {
+        catch (err) {
+            console.error("[Auth Interceptor] Request interceptor error:", err);
         }
         return config;
     });
@@ -5937,22 +6008,36 @@ function addAuthInterceptors(params) {
         const url = originalRequest === null || originalRequest === void 0 ? void 0 : originalRequest.url;
         // If not our API or not 401, just reject
         if (!status || status !== 401 || !isOurApiUrl(url)) {
+            if (status === 401) {
+                console.warn("[Auth Interceptor] 401 received but URL check failed:", {
+                    url,
+                    apiBaseUrl,
+                    isOurApiUrl: isOurApiUrl(url),
+                });
+            }
             return Promise.reject(error);
         }
+        console.log("[Auth Interceptor] 401 detected, attempting token refresh for URL:", url);
         // If the 401 is from refresh endpoint itself -> force logout
         if (isRefreshUrl(url)) {
+            console.warn("[Auth Interceptor] Refresh endpoint returned 401, logging out");
             try {
                 await logout();
             }
-            catch (_d) { }
+            catch (err) {
+                console.error("[Auth Interceptor] Logout failed:", err);
+            }
             return Promise.reject(error);
         }
         // Prevent infinite loop
         if (originalRequest && originalRequest._retry) {
+            console.warn("[Auth Interceptor] Request already retried, logging out");
             try {
                 await logout();
             }
-            catch (_e) { }
+            catch (err) {
+                console.error("[Auth Interceptor] Logout failed:", err);
+            }
             return Promise.reject(error);
         }
         // Mark so we don't retry twice
@@ -5966,31 +6051,45 @@ function addAuthInterceptors(params) {
                     if (!newToken || !originalRequest)
                         return reject(error);
                     originalRequest.headers = (_a = originalRequest.headers) !== null && _a !== void 0 ? _a : {};
-                    originalRequest.headers['Authorization'] = `Bearer ${newToken}`;
+                    originalRequest.headers["Authorization"] =
+                        `Bearer ${newToken}`;
                     resolve(apiClient.request(originalRequest));
                 });
             });
         }
         isRefreshing = true;
         try {
+            console.log("[Auth Interceptor] Refreshing tokens...");
             const refreshed = await refreshTokens();
-            const newAccessToken = (_b = (refreshed && (refreshed.accessToken || ((_a = refreshed.data) === null || _a === void 0 ? void 0 : _a.accessToken)))) !== null && _b !== void 0 ? _b : null;
+            const newAccessToken = (_b = (refreshed &&
+                (refreshed.accessToken || ((_a = refreshed.data) === null || _a === void 0 ? void 0 : _a.accessToken)))) !== null && _b !== void 0 ? _b : null;
+            if (!newAccessToken) {
+                console.error("[Auth Interceptor] Token refresh succeeded but no access token in response:", refreshed);
+            }
+            else {
+                console.log("[Auth Interceptor] Token refresh successful");
+            }
             resolvePendingRequests(newAccessToken);
             if (originalRequest) {
                 originalRequest.headers = (_c = originalRequest.headers) !== null && _c !== void 0 ? _c : {};
                 if (newAccessToken)
-                    (originalRequest.headers)['Authorization'] = `Bearer ${newAccessToken}`;
+                    originalRequest.headers["Authorization"] =
+                        `Bearer ${newAccessToken}`;
+                console.log("[Auth Interceptor] Retrying original request with new token");
                 const resp = await apiClient.request(originalRequest);
                 return resp;
             }
             return Promise.reject(error);
         }
         catch (refreshErr) {
+            console.error("[Auth Interceptor] Token refresh failed:", refreshErr);
             resolvePendingRequests(null);
             try {
                 await logout();
             }
-            catch (_f) { }
+            catch (err) {
+                console.error("[Auth Interceptor] Logout failed:", err);
+            }
             return Promise.reject(refreshErr);
         }
         finally {
@@ -6001,11 +6100,15 @@ function addAuthInterceptors(params) {
         try {
             apiClient.interceptors.request.eject(reqId);
         }
-        catch (_a) { }
+        catch (err) {
+            console.error("[Auth Interceptor] Failed to eject request interceptor:", err);
+        }
         try {
             apiClient.interceptors.response.eject(resId);
         }
-        catch (_b) { }
+        catch (err) {
+            console.error("[Auth Interceptor] Failed to eject response interceptor:", err);
+        }
     };
 }
 
@@ -7511,20 +7614,34 @@ function usePortfolio() {
 }
 
 async function getEIP712Message(baseUrl, address, clientId) {
-    const url = joinUrl(baseUrl, '/auth/eip712-message');
+    const url = joinUrl(baseUrl, "/auth/eip712-message");
     try {
-        const resp = await axios$1.get(url, { params: { address, clientId }, timeout: 30000 });
-        return { data: resp.data, status: resp.status, headers: resp.headers };
+        const resp = await apiClient.get(url, {
+            params: { address, clientId },
+            timeout: 30000,
+        });
+        return {
+            data: resp.data,
+            status: resp.status,
+            headers: resp.headers,
+        };
     }
     catch (error) {
         throw toApiError(error);
     }
 }
 async function authenticate(baseUrl, body) {
-    const url = joinUrl(baseUrl, '/auth/login');
+    const url = joinUrl(baseUrl, "/auth/login");
     try {
-        const resp = await axios$1.post(url, body, { headers: { 'Content-Type': 'application/json' }, timeout: 30000 });
-        return { data: resp.data, status: resp.status, headers: resp.headers };
+        const resp = await apiClient.post(url, body, {
+            headers: { "Content-Type": "application/json" },
+            timeout: 30000,
+        });
+        return {
+            data: resp.data,
+            status: resp.status,
+            headers: resp.headers,
+        };
     }
     catch (error) {
         throw toApiError(error);
@@ -7535,7 +7652,7 @@ async function authenticate(baseUrl, body) {
  */
 async function authenticateWithPrivy(baseUrl, params) {
     const body = {
-        method: 'privy_access_token',
+        method: "privy_access_token",
         address: params.address,
         clientId: params.clientId,
         details: { appId: params.appId, accessToken: params.accessToken },
@@ -7543,62 +7660,124 @@ async function authenticateWithPrivy(baseUrl, params) {
     return authenticate(baseUrl, body);
 }
 async function refreshToken(baseUrl, refreshTokenVal) {
-    const url = joinUrl(baseUrl, '/auth/refresh');
+    const url = joinUrl(baseUrl, "/auth/refresh");
     try {
-        const resp = await axios$1.post(url, { refreshToken: refreshTokenVal }, { headers: { 'Content-Type': 'application/json' }, timeout: 30000 });
-        return { data: resp.data, status: resp.status, headers: resp.headers };
+        const resp = await apiClient.post(url, { refreshToken: refreshTokenVal }, { headers: { "Content-Type": "application/json" }, timeout: 30000 });
+        return {
+            data: resp.data,
+            status: resp.status,
+            headers: resp.headers,
+        };
     }
     catch (error) {
         throw toApiError(error);
     }
 }
 async function logout(baseUrl, refreshTokenVal) {
-    const url = joinUrl(baseUrl, '/auth/logout');
+    const url = joinUrl(baseUrl, "/auth/logout");
     try {
-        const resp = await axios$1.post(url, { refreshToken: refreshTokenVal }, { headers: { 'Content-Type': 'application/json' }, timeout: 30000 });
-        return { data: resp.data, status: resp.status, headers: resp.headers };
+        const resp = await apiClient.post(url, { refreshToken: refreshTokenVal }, { headers: { "Content-Type": "application/json" }, timeout: 30000 });
+        return {
+            data: resp.data,
+            status: resp.status,
+            headers: resp.headers,
+        };
     }
     catch (error) {
         throw toApiError(error);
     }
 }
 
+// Token expiration constants
+const ACCESS_TOKEN_BUFFER_MS = 5 * 60 * 1000; // Refresh 5 min before expiry
+const REFRESH_TOKEN_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days fallback
+function nowMs() {
+    return Date.now();
+}
+function calcExpiresAt(expiresInSeconds) {
+    return nowMs() + expiresInSeconds * 1000;
+}
 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 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 address = useUserData((s) => s.address);
     const setAddress = useUserData((s) => s.setAddress);
+    // Ref to prevent concurrent refresh attempts
+    const isRefreshingRef = useRef(false);
     useEffect(() => {
-        if (typeof window == "undefined") {
+        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);
-        setIsReady(true);
-    }, [setAccessToken, setRefreshToken, setIsAuthenticated, setAddress]);
+        if (address) {
+            const accessTokenKey = `${address}_accessToken`;
+            const refreshTokenKey = `${address}_refreshToken`;
+            const accessTokenExpiresAtKey = `${address}_accessTokenExpiresAt`;
+            const refreshTokenExpiresAtKey = `${address}_refreshTokenExpiresAt`;
+            const storedAccessToken = localStorage.getItem(accessTokenKey);
+            const storedRefreshToken = localStorage.getItem(refreshTokenKey);
+            const accessExpRaw = localStorage.getItem(accessTokenExpiresAtKey);
+            const refreshExpRaw = localStorage.getItem(refreshTokenExpiresAtKey);
+            const accessExp = accessExpRaw ? Number(accessExpRaw) : 0;
+            const refreshExp = refreshExpRaw ? Number(refreshExpRaw) : 0;
+            const now = nowMs();
+            const accessValid = !!storedAccessToken && accessExp > now;
+            const refreshValid = !!storedRefreshToken && refreshExp > now;
+            if (accessValid && refreshValid) {
+                // Both tokens are valid
+                setAccessToken(storedAccessToken);
+                setRefreshToken(storedRefreshToken);
+                setIsAuthenticated(true);
+                setIsReady(true);
+            }
+            else if (refreshValid) {
+                // Access token expired but refresh still valid → refresh immediately
+                setAccessToken(storedAccessToken);
+                setRefreshToken(storedRefreshToken);
+                (async () => {
+                    try {
+                        await refreshTokens();
+                    }
+                    catch (_a) {
+                        // Refresh failed → clear tokens
+                        setAccessToken(null);
+                        setRefreshToken(null);
+                        setIsAuthenticated(false);
+                    }
+                    setIsReady(true);
+                })();
+                return; // setIsReady will be called in the async block
+            }
+            else {
+                // Refresh expired or no tokens → clear
+                setAccessToken(null);
+                setRefreshToken(null);
+                setIsAuthenticated(false);
+                setIsReady(true);
+            }
+        }
+        else {
+            setIsReady(true);
+        }
+    }, [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();
@@ -7612,6 +7791,55 @@ function useAuth() {
             cleanup();
         };
     }, [apiBaseUrl]);
+    // Proactive refresh effect: refresh when app regains focus or timer fires
+    useEffect(() => {
+        if (typeof window === 'undefined' || !address || !refreshToken$1)
+            return;
+        const refreshIfNeeded = async () => {
+            // Prevent concurrent refresh attempts
+            if (isRefreshingRef.current)
+                return;
+            // Read fresh expiration values from localStorage (not stale closure)
+            const accessExpRaw = localStorage.getItem(`${address}_accessTokenExpiresAt`);
+            const refreshExpRaw = localStorage.getItem(`${address}_refreshTokenExpiresAt`);
+            const accessExp = accessExpRaw ? Number(accessExpRaw) : 0;
+            const refreshExp = refreshExpRaw ? Number(refreshExpRaw) : 0;
+            const now = nowMs();
+            // If refresh token is already expired, do nothing
+            if (refreshExp <= now)
+                return;
+            // If access token is within buffer window, refresh
+            if (accessExp - now <= ACCESS_TOKEN_BUFFER_MS) {
+                isRefreshingRef.current = true;
+                try {
+                    await refreshTokens();
+                }
+                catch (_a) {
+                    // Refresh failed, interceptor will handle logout on next API call
+                }
+                finally {
+                    isRefreshingRef.current = false;
+                }
+            }
+        };
+        const onVisibilityChange = () => {
+            if (document.visibilityState === 'visible') {
+                refreshIfNeeded();
+            }
+        };
+        document.addEventListener('visibilitychange', onVisibilityChange);
+        // Schedule timer for (accessExp - buffer)
+        const accessExpRaw = localStorage.getItem(`${address}_accessTokenExpiresAt`);
+        const accessExp = accessExpRaw ? Number(accessExpRaw) : 0;
+        const delay = Math.max(0, accessExp - nowMs() - ACCESS_TOKEN_BUFFER_MS);
+        const timer = window.setTimeout(() => {
+            refreshIfNeeded();
+        }, delay);
+        return () => {
+            document.removeEventListener('visibilitychange', onVisibilityChange);
+            clearTimeout(timer);
+        };
+    }, [address, refreshToken$1]);
     async function getEip712(address) {
         const { data } = await getEIP712Message(apiBaseUrl, address, clientId);
         return data;
@@ -7619,17 +7847,21 @@ function useAuth() {
     async function loginWithSignedMessage(address, signature, timestamp) {
         try {
             const { data } = await authenticate(apiBaseUrl, {
-                method: "eip712",
+                method: 'eip712',
                 address,
                 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`;
+            const accessTokenExpiresAtKey = `${address}_accessTokenExpiresAt`;
+            const refreshTokenExpiresAtKey = `${address}_refreshTokenExpiresAt`;
+            window.localStorage.setItem(accessTokenKey, data.accessToken);
+            window.localStorage.setItem(refreshTokenKey, data.refreshToken);
+            window.localStorage.setItem(accessTokenExpiresAtKey, String(calcExpiresAt(data.expiresIn)));
+            window.localStorage.setItem(refreshTokenExpiresAtKey, String(nowMs() + REFRESH_TOKEN_TTL_MS));
             setAccessToken(data.accessToken);
             setRefreshToken(data.refreshToken);
-            setAddress(address);
             setIsAuthenticated(true);
         }
         catch (e) {
@@ -7644,12 +7876,16 @@ 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`;
+            const accessTokenExpiresAtKey = `${address}_accessTokenExpiresAt`;
+            const refreshTokenExpiresAtKey = `${address}_refreshTokenExpiresAt`;
+            window.localStorage.setItem(accessTokenKey, data.accessToken);
+            window.localStorage.setItem(refreshTokenKey, data.refreshToken);
+            window.localStorage.setItem(accessTokenExpiresAtKey, String(calcExpiresAt(data.expiresIn)));
+            window.localStorage.setItem(refreshTokenExpiresAtKey, String(nowMs() + REFRESH_TOKEN_TTL_MS));
             setAccessToken(data.accessToken);
             setRefreshToken(data.refreshToken);
-            setAddress(address);
             setIsAuthenticated(true);
         }
         catch (e) {
@@ -7657,35 +7893,61 @@ function useAuth() {
         }
     }
     async function refreshTokens() {
-        const refresh = window.localStorage.getItem("refreshToken");
-        if (!refresh)
-            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 currentAddress = address;
+        const currentRefresh = refreshToken$1;
+        if (!currentRefresh || !currentAddress)
+            throw new Error('No refresh token');
+        const { data } = await refreshToken(apiBaseUrl, currentRefresh);
+        // Update tokens in localStorage
+        const accessTokenKey = `${currentAddress}_accessToken`;
+        const refreshTokenKey = `${currentAddress}_refreshToken`;
+        const accessTokenExpiresAtKey = `${currentAddress}_accessTokenExpiresAt`;
+        const refreshTokenExpiresAtKey = `${currentAddress}_refreshTokenExpiresAt`;
+        window.localStorage.setItem(accessTokenKey, data.accessToken);
+        window.localStorage.setItem(refreshTokenKey, data.refreshToken);
+        window.localStorage.setItem(accessTokenExpiresAtKey, String(calcExpiresAt(data.expiresIn)));
+        window.localStorage.setItem(refreshTokenExpiresAtKey, String(nowMs() + REFRESH_TOKEN_TTL_MS));
         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`;
+            const accessTokenExpiresAtKey = `${currentAddress}_accessTokenExpiresAt`;
+            const refreshTokenExpiresAtKey = `${currentAddress}_refreshTokenExpiresAt`;
+            window.localStorage.removeItem(accessTokenKey);
+            window.localStorage.removeItem(refreshTokenKey);
+            window.localStorage.removeItem(accessTokenExpiresAtKey);
+            window.localStorage.removeItem(refreshTokenExpiresAtKey);
+        }
         setAccessToken(null);
         setRefreshToken(null);
         setAddress(null);
         setIsAuthenticated(false);
     }
+    /**
+     * Clear the current session without logging out from the API.
+     * Useful when switching wallets to clear stale in-memory auth state.
+     * Note: setAddress will clear user-specific data (spotState, etc.) when called
+     */
+    function clearSession() {
+        setAccessToken(null);
+        setRefreshToken(null);
+        setIsAuthenticated(false);
+    }
     return {
         isReady,
         isAuthenticated,
@@ -7697,6 +7959,8 @@ function useAuth() {
         loginWithPrivyToken,
         refreshTokens,
         logout: logout$1,
+        setAddress,
+        clearSession,
     };
 }
 
@@ -8009,9 +8273,17 @@ const PearHyperliquidContext = createContext(undefined);
 /**
  * React Provider for PearHyperliquidClient
  */
-const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearprotocol.io', clientId = 'PEARPROTOCOLUI', wsUrl = 'wss://hl-ui.pearprotocol.io/ws', }) => {
+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 clearHyperliquidUserData = useHyperliquidData((state) => state.clearUserData);
+    const prevAddressRef = useRef(null);
+    // Clear user-specific data when address changes
+    useEffect(() => {
+        if (prevAddressRef.current !== null && prevAddressRef.current !== address) {
+            clearHyperliquidUserData();
+        }
+        prevAddressRef.current = address;
+    }, [address, clearHyperliquidUserData]);
     const perpMetasByDex = useHyperliquidData((state) => state.perpMetasByDex);
     const setPerpDexs = useHyperliquidData((state) => state.setPerpDexs);
     const setPerpMetasByDex = useHyperliquidData((state) => state.setPerpMetasByDex);
@@ -8042,20 +8314,20 @@ const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearpro
                 perpMetas.forEach((item, perpIndex) => {
                     var _a, _b;
                     const dexName = perpIndex === 0
-                        ? 'HYPERLIQUID'
+                        ? "HYPERLIQUID"
                         : ((_b = (_a = perpDexs[perpIndex]) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : `DEX_${perpIndex}`);
                     var collateralToken;
                     if (item.collateralToken === 360) {
-                        collateralToken = 'USDH';
+                        collateralToken = "USDH";
                     }
                     if (item.collateralToken === 0) {
-                        collateralToken = 'USDC';
+                        collateralToken = "USDC";
                     }
                     if (item.collateralToken === 235) {
-                        collateralToken = 'USDE';
+                        collateralToken = "USDE";
                     }
                     if (item.collateralToken === 268) {
-                        collateralToken = 'USDT0';
+                        collateralToken = "USDT0";
                     }
                     const universeAssets = item.universe.map((asset) => ({
                         ...asset,
@@ -8083,8 +8355,6 @@ const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearpro
     }), [
         apiBaseUrl,
         wsUrl,
-        address,
-        setAddress,
         isConnected,
         lastError,
         nativeIsConnected,
@@ -8099,7 +8369,7 @@ const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearpro
 function usePearHyperliquid() {
     const ctx = useContext(PearHyperliquidContext);
     if (!ctx)
-        throw new Error('usePearHyperliquid must be used within a PearHyperliquidProvider');
+        throw new Error("usePearHyperliquid must be used within a PearHyperliquidProvider");
     return ctx;
 }
 

package/dist/provider.d.ts

@@ -1,4 +1,4 @@
-import React, { ReactNode } from 'react';
+import React, { ReactNode } from "react";
 export interface PearHyperliquidContextType {
     clientId: string;
     apiBaseUrl: string;

package/dist/store/hyperliquidDataStore.d.ts

@@ -1,5 +1,5 @@
-import { ActiveAssetData, CandleChartData, CandleData, ClearinghouseState, UniverseAsset, WebData3AssetCtx, WsAllMidsData, PerpDexsResponse } from '../types';
-import { TokenMetadataBySymbol } from '../utils/token-metadata-extractor';
+import { ActiveAssetData, CandleChartData, CandleData, ClearinghouseState, UniverseAsset, WebData3AssetCtx, WsAllMidsData, PerpDexsResponse } from "../types";
+import { TokenMetadataBySymbol } from "../utils/token-metadata-extractor";
 interface HyperliquidDataState {
     allMids: WsAllMidsData | null;
     activeAssetData: Record<string, ActiveAssetData> | null;
@@ -28,6 +28,7 @@ interface HyperliquidDataState {
     setPerpDexs: (value: PerpDexsResponse | null) => void;
     setPerpMetasByDex: (value: Map<string, UniverseAsset[]> | null) => void;
     setAssetContextsByDex: (value: Map<string, WebData3AssetCtx[]> | null) => void;
+    clearUserData: () => void;
 }
 export declare const useHyperliquidData: import("zustand").UseBoundStore<import("zustand").StoreApi<HyperliquidDataState>>;
 export {};

package/dist/store/userDataStore.d.ts

@@ -3,6 +3,7 @@ interface UserDataState {
     accessToken: string | null;
     refreshToken: string | null;
     isAuthenticated: boolean;
+    isReady: boolean;
     address: string | null;
     tradeHistories: TradeHistoryDataDto[] | null;
     rawOpenPositions: RawPositionDto[] | null;
@@ -26,6 +27,7 @@ interface UserDataState {
     setNotifications: (value: NotificationDto[] | null) => void;
     setSpotState: (value: SpotState | null) => void;
     setUserAbstractionMode: (value: UserAbstraction | null) => void;
+    setIsReady: (value: boolean) => void;
     clean: () => void;
 }
 export declare const useUserData: import("zustand").UseBoundStore<import("zustand").StoreApi<UserDataState>>;

package/dist/utils/http.d.ts

@@ -1,5 +1,5 @@
-import type { AxiosInstance } from 'axios';
-import { ApiErrorResponse } from '../types';
+import type { AxiosInstance } from "axios";
+import { ApiErrorResponse } from "../types";
 export declare function toApiError(error: unknown): ApiErrorResponse;
 export declare function joinUrl(baseUrl: string, path: string): string;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/hyperliquid-sdk",
-  "version": "0.1.12",
+  "version": "0.1.13-beta.2",
   "description": "React SDK for Pear Protocol Hyperliquid API integration",
   "type": "module",
   "main": "dist/index.js",