@pear-protocol/hyperliquid-sdk 0.1.2 → 0.1.4-pnl

package/dist/index.js

@@ -64,17 +64,28 @@ const useUserData = create((set) => ({
     notifications: null,
     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) => {
+        const addressChanged = state.address !== null && state.address !== address;
+        if (addressChanged) {
+            return {
+                address,
+                spotState: null,
+                tradeHistories: null,
+                rawOpenPositions: null,
+                openOrders: null,
+                accountSummary: null,
+                twapDetails: null,
+                notifications: null,
+                userExtraAgents: null,
+                userAbstractionMode: null,
+            };
         }
         return { address };
     }),
@@ -86,10 +97,11 @@ const useUserData = create((set) => ({
     setNotifications: (value) => set({ notifications: value }),
     setSpotState: (value) => set({ spotState: 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,
@@ -382,19 +394,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
@@ -549,7 +561,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 }),
@@ -589,7 +601,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] }),
@@ -624,6 +639,29 @@ const useHyperliquidData = create((set) => ({
             perpMetasByDex: state.perpMetasByDex,
         }),
     })),
+    clearUserData: () => set((state) => {
+        const refreshedMetadata = refreshTokenMetadata(state, {
+            activeAssetData: null,
+        });
+        // Remove user-scoped fields even when upstream metadata inputs are not ready.
+        const tokenMetadata = Object.fromEntries(Object.entries(refreshedMetadata).map(([symbol, metadata]) => [
+            symbol,
+            metadata
+                ? {
+                    ...metadata,
+                    leverage: undefined,
+                    maxTradeSzs: undefined,
+                    availableToTrade: undefined,
+                }
+                : null,
+        ]));
+        return {
+            aggregatedClearingHouseState: null,
+            rawClearinghouseStates: null,
+            activeAssetData: null,
+            tokenMetadata,
+        };
+    }),
 }));
 
 /**
@@ -887,7 +925,7 @@ const useUserSelection$1 = create((set, get) => ({
 
 const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }) => {
     const { setAllMids, setActiveAssetData, upsertActiveAssetData, setCandleData, deleteCandleSymbol, deleteActiveAssetData, addCandleData, setFinalAtOICaps, setAggregatedClearingHouseState, setRawClearinghouseStates, setAssetContextsByDex, } = useHyperliquidData();
-    const { setSpotState } = useUserData();
+    const { setSpotState, setUserAbstractionMode } = useUserData();
     const { candleInterval } = useUserSelection$1();
     const userSummary = useUserData((state) => state.accountSummary);
     const longTokens = useUserSelection$1((s) => s.longTokens);
@@ -899,18 +937,26 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
     const [subscribedCandleTokens, setSubscribedCandleTokens] = useState([]);
     const [clearinghouseStateReceived, setClearinghouseStateReceived] = useState(false);
     const prevCandleIntervalRef = useRef(null);
+    const prevActiveAssetAddressRef = useRef(null);
     const pingIntervalRef = useRef(null);
     const wsRef = useRef(null);
     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(() => {
+        onUserFillsRef.current = onUserFills;
+    }, [onUserFills]);
     const handleMessage = useCallback((event) => {
+        var _a;
         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 {
@@ -919,43 +965,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 = onUserFills === null || onUserFills === void 0 ? void 0 : onUserFills();
+                            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 = {
@@ -985,26 +1032,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) {
@@ -1019,7 +1066,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);
         }
     }, [
@@ -1031,18 +1078,25 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         setRawClearinghouseStates,
         setAssetContextsByDex,
         setSpotState,
-        onUserFills,
     ]);
     const connect = useCallback(() => {
+        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 &&
                 (wsRef.current.readyState === WebSocket.OPEN ||
                     wsRef.current.readyState === WebSocket.CONNECTING)) {
+                console.log('[HyperLiquid WS] connect() returning early - socket already exists, readyState:', wsRef.current.readyState);
                 return;
             }
+            console.log("[HyperLiquid WS] Creating new WebSocket connection");
             manualCloseRef.current = false;
             setReadyState(ReadyState.CONNECTING);
             const ws = new WebSocket("wss://api.hyperliquid.xyz/ws");
@@ -1059,12 +1113,17 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
             };
             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);
                 }
             };
         }
@@ -1073,9 +1132,55 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         }
     }, [handleMessage, enabled]);
     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();
@@ -1114,14 +1219,23 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
     }, [isConnected, sendJsonMessage]);
     // Handle address subscription changes
     useEffect(() => {
-        if (!isConnected)
-            return;
         const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
-        const userAddress = address || DEFAULT_ADDRESS;
-        if (subscribedAddress === userAddress)
+        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);
+        if (normalizedSubscribedAddress === userAddress) {
+            console.log("[HyperLiquid WS] Address unchanged, skipping subscription update");
+            return;
+        }
+        if (!isConnected) {
+            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);
             const unsubscribeMessage = {
                 method: "unsubscribe",
                 subscription: {
@@ -1133,9 +1247,9 @@ 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,
                     },
                 };
@@ -1150,9 +1264,9 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
             };
             sendJsonMessage(unsubscribeAllDexsClearinghouseState);
             const unsubscribeUserFills = {
-                method: 'unsubscribe',
+                method: "unsubscribe",
                 subscription: {
-                    type: 'userFills',
+                    type: "userFills",
                     user: subscribedAddress,
                 },
             };
@@ -1165,14 +1279,6 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
                 user: userAddress,
             },
         };
-        // Subscribe to allDexsClearinghouseState with the same payload as webData3
-        const subscribeAllDexsClearinghouseState = {
-            method: "subscribe",
-            subscription: {
-                type: "allDexsClearinghouseState",
-                user: userAddress,
-            },
-        };
         // Subscribe to allMids
         const subscribeAllMids = {
             method: "subscribe",
@@ -1188,25 +1294,38 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
                 type: "allDexsAssetCtxs",
             },
         };
+        console.log("[HyperLiquid WS] Subscribing to new address:", userAddress);
         sendJsonMessage(subscribeWebData3);
-        sendJsonMessage(subscribeAllDexsClearinghouseState);
         sendJsonMessage(subscribeAllMids);
         sendJsonMessage(subscribeAllDexsAssetCtxs);
         // Subscribe to spotState for real-time spot balances (USDH, USDC, etc.)
         // Only subscribe if we have a real user address (not the default)
-        if (userAddress !== DEFAULT_ADDRESS) {
+        if (userAddress !== DEFAULT_ADDRESS.toLowerCase()) {
             const subscribeSpotState = {
-                method: 'subscribe',
+                method: "subscribe",
                 subscription: {
-                    type: 'spotState',
+                    type: "spotState",
                     user: userAddress,
                 },
             };
             sendJsonMessage(subscribeSpotState);
         }
+        // Subscribe to allDexsClearinghouseState with the same payload as webData3
+        // Only subscribe if we have a real user address (not the default)
+        if (userAddress !== DEFAULT_ADDRESS.toLowerCase()) {
+            const subscribeAllDexsClearinghouseState = {
+                method: "subscribe",
+                subscription: {
+                    type: "allDexsClearinghouseState",
+                    user: userAddress,
+                },
+            };
+            sendJsonMessage(subscribeAllDexsClearinghouseState);
+        }
         setSubscribedAddress(userAddress);
         // Clear previous data when address changes
-        if (subscribedAddress && subscribedAddress !== userAddress) {
+        if (normalizedSubscribedAddress &&
+            normalizedSubscribedAddress !== userAddress) {
             // clear aggregatedClearingHouseState
             setAggregatedClearingHouseState(null);
             setRawClearinghouseStates(null);
@@ -1225,23 +1344,57 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         setSpotState,
     ]);
     useEffect(() => {
-        if (!isConnected || !subscribedAddress || !clearinghouseStateReceived || !userSummary)
+        if (!isConnected ||
+            !subscribedAddress ||
+            !clearinghouseStateReceived ||
+            !userSummary)
             return;
         const subscribeUserFills = {
-            method: 'subscribe',
+            method: "subscribe",
             subscription: {
-                type: 'userFills',
+                type: "userFills",
                 user: subscribedAddress,
             },
         };
         sendJsonMessage(subscribeUserFills);
-    }, [isConnected, subscribedAddress, clearinghouseStateReceived, userSummary, sendJsonMessage]);
+    }, [
+        isConnected,
+        subscribedAddress,
+        clearinghouseStateReceived,
+        userSummary,
+        sendJsonMessage,
+    ]);
+    // activeAssetData is user-scoped; reset subscriptions/data whenever address changes.
+    useEffect(() => {
+        if (!isConnected)
+            return;
+        const previousAddress = prevActiveAssetAddressRef.current;
+        if (previousAddress === address)
+            return;
+        if (previousAddress) {
+            subscribedTokens.forEach((token) => {
+                const unsubscribeMessage = {
+                    method: "unsubscribe",
+                    subscription: {
+                        type: "activeAssetData",
+                        user: previousAddress,
+                        coin: token,
+                    },
+                };
+                sendJsonMessage(unsubscribeMessage);
+            });
+        }
+        // Clear user-derived leverage/available-to-trade data before re-subscribing.
+        setActiveAssetData(null);
+        setSubscribedTokens([]);
+        prevActiveAssetAddressRef.current = address;
+    }, [isConnected, address, subscribedTokens, sendJsonMessage, setActiveAssetData]);
     // Handle token subscriptions for activeAssetData
     useEffect(() => {
         if (!isConnected || !address)
             return;
-        const effectiveTokens = selectedTokenSymbols;
-        const tokensToSubscribe = effectiveTokens.filter((token) => token && !subscribedTokens.includes(token));
+        const effectiveTokens = selectedTokenSymbols.filter((token) => token);
+        const tokensToSubscribe = effectiveTokens.filter((token) => !subscribedTokens.includes(token));
         const tokensToUnsubscribe = subscribedTokens.filter((token) => !effectiveTokens.includes(token));
         // Unsubscribe from tokens no longer in the list
         tokensToUnsubscribe.forEach((token) => {
@@ -1268,7 +1421,7 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
             sendJsonMessage(subscribeMessage);
         });
         if (tokensToSubscribe.length > 0 || tokensToUnsubscribe.length > 0) {
-            setSubscribedTokens(effectiveTokens.filter((token) => token));
+            setSubscribedTokens(effectiveTokens);
             tokensToSubscribe.forEach((token) => deleteActiveAssetData(token));
         }
     }, [
@@ -1277,7 +1430,7 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         selectedTokenSymbols,
         subscribedTokens,
         sendJsonMessage,
-        setActiveAssetData,
+        deleteActiveAssetData,
     ]);
     // Handle candle subscriptions for tokens and interval changes
     useEffect(() => {
@@ -1453,8 +1606,9 @@ const getAssetByName = (tokenMetadata, symbol) => {
  * Hook to access webData
  */
 const useMarket = () => {
+    const supportedMarkets = ['USDT', 'USDT0', 'USDC', 'USDH'];
     const tokenMetadata = useHyperliquidData((state) => state.tokenMetadata);
-    const allTokenMetadata = useMemo(() => Object.values(tokenMetadata).filter((metadata) => Boolean(metadata)), [tokenMetadata]);
+    const allTokenMetadata = useMemo(() => Object.values(tokenMetadata).filter((metadata) => Boolean(metadata)).filter((token) => { var _a; return supportedMarkets.includes((_a = token.collateralToken) !== null && _a !== void 0 ? _a : ''); }), [tokenMetadata]);
     const getAssetByName$1 = useCallback((symbol) => getAssetByName(tokenMetadata, symbol), [tokenMetadata]);
     return { allTokenMetadata, getAssetByName: getAssetByName$1 };
 };
@@ -1469,17 +1623,33 @@ const useTradeHistories = () => {
     const enrichedTradeHistories = useMemo(() => {
         if (!tradeHistories)
             return null;
-        return tradeHistories.map((history) => ({
-            ...history,
-            closedLongAssets: history.closedLongAssets.map((asset) => ({
-                ...asset,
-                metadata: getAssetByName(asset.coin),
-            })),
-            closedShortAssets: history.closedShortAssets.map((asset) => ({
-                ...asset,
-                metadata: getAssetByName(asset.coin),
-            })),
-        }));
+        return tradeHistories.map((history) => {
+            const totalClosePositionSize = history.closedLongAssets.reduce((acc, asset) => acc + asset.limitPrice * asset.size, 0) +
+                history.closedShortAssets.reduce((acc, asset) => acc + asset.limitPrice * asset.size, 0);
+            return {
+                ...history,
+                closedLongAssets: history.closedLongAssets.map((asset) => {
+                    const closeNotional = asset.limitPrice * asset.size;
+                    return {
+                        ...asset,
+                        closeWeight: totalClosePositionSize > 0
+                            ? closeNotional / totalClosePositionSize
+                            : 0,
+                        metadata: getAssetByName(asset.coin),
+                    };
+                }),
+                closedShortAssets: history.closedShortAssets.map((asset) => {
+                    const closeNotional = asset.limitPrice * asset.size;
+                    return {
+                        ...asset,
+                        closeWeight: totalClosePositionSize > 0
+                            ? closeNotional / totalClosePositionSize
+                            : 0,
+                        metadata: getAssetByName(asset.coin),
+                    };
+                }),
+            };
+        });
     }, [tradeHistories, getAssetByName]);
     const isLoading = useMemo(() => {
         return tradeHistories === null && context.isConnected;
@@ -1513,7 +1683,36 @@ const useOpenOrders = () => {
 };
 
 const useUserSelection = () => {
-    return useUserSelection$1();
+    const longTokens = useUserSelection$1((s) => s.longTokens);
+    const shortTokens = useUserSelection$1((s) => s.shortTokens);
+    const candleInterval = useUserSelection$1((s) => s.candleInterval);
+    const openTokenSelector = useUserSelection$1((s) => s.openTokenSelector);
+    const selectorConfig = useUserSelection$1((s) => s.selectorConfig);
+    const openConflictModal = useUserSelection$1((s) => s.openConflictModal);
+    const setLongTokens = useUserSelection$1((s) => s.setLongTokens);
+    const setShortTokens = useUserSelection$1((s) => s.setShortTokens);
+    const setCandleInterval = useUserSelection$1((s) => s.setCandleInterval);
+    const setTokenSelections = useUserSelection$1((s) => s.setTokenSelections);
+    const setOpenTokenSelector = useUserSelection$1((s) => s.setOpenTokenSelector);
+    const setSelectorConfig = useUserSelection$1((s) => s.setSelectorConfig);
+    const setOpenConflictModal = useUserSelection$1((s) => s.setOpenConflictModal);
+    const addToken = useUserSelection$1((s) => s.addToken);
+    return {
+        longTokens,
+        shortTokens,
+        candleInterval,
+        openTokenSelector,
+        selectorConfig,
+        openConflictModal,
+        setLongTokens,
+        setShortTokens,
+        setCandleInterval,
+        setTokenSelections,
+        setOpenTokenSelector,
+        setSelectorConfig,
+        setOpenConflictModal,
+        addToken,
+    };
 };
 
 const useTokenSelectionMetadataStore = create((set) => ({
@@ -1529,11 +1728,10 @@ const useTokenSelectionMetadataStore = create((set) => ({
     volume: "0",
     sumNetFunding: 0,
     maxLeverage: 0,
-    minMargin: 0,
+    minSize: {},
     leverageMatched: true,
-    recompute: ({ perpMetaAssets, tokenMetadata, marketData, longTokens, shortTokens, }) => {
+    recompute: ({ tokenMetadata, marketData, longTokens, shortTokens }) => {
         const isPriceDataReady = Object.keys(tokenMetadata).length > 0;
-        // Get token symbols for lookups
         const longSymbols = longTokens.map((t) => t.symbol);
         const shortSymbols = shortTokens.map((t) => t.symbol);
         // Get metadata
@@ -1656,24 +1854,36 @@ const useTokenSelectionMetadataStore = create((set) => ({
         })();
         // Max leverage (maximum across all tokens)
         const maxLeverage = (() => {
-            if (!perpMetaAssets)
+            if (!tokenMetadata)
                 return 0;
             const allSymbols = [...longSymbols, ...shortSymbols];
             if (allSymbols.length === 0)
                 return 0;
             let maxLev = 0;
             allSymbols.forEach((symbol) => {
-                const tokenUniverse = perpMetaAssets.find((u) => u.name === symbol);
-                if (tokenUniverse === null || tokenUniverse === void 0 ? void 0 : tokenUniverse.maxLeverage) {
-                    maxLev = Math.max(maxLev, tokenUniverse.maxLeverage);
+                const tokenDetail = tokenMetadata[symbol];
+                if (tokenDetail === null || tokenDetail === void 0 ? void 0 : tokenDetail.maxLeverage) {
+                    maxLev = Math.max(maxLev, tokenDetail.maxLeverage);
                 }
             });
             return maxLev;
         })();
-        // Min margin (10 * total number of tokens)
-        const minMargin = (() => {
-            const totalTokenCount = longTokens.length + shortTokens.length;
-            return 10 * totalTokenCount;
+        const minSize = (() => {
+            const allSymbols = [...longSymbols, ...shortSymbols];
+            const collateralCounts = {};
+            allSymbols.forEach((symbol) => {
+                var _a;
+                const collateralToken = (_a = tokenMetadata[symbol]) === null || _a === void 0 ? void 0 : _a.collateralToken;
+                if (collateralToken) {
+                    collateralCounts[collateralToken] =
+                        (collateralCounts[collateralToken] || 0) + 1;
+                }
+            });
+            const minSizeMap = {};
+            Object.entries(collateralCounts).forEach(([collateral, count]) => {
+                minSizeMap[collateral] = 11 * count;
+            });
+            return minSizeMap;
         })();
         // Whether all tokens have matching leverage
         const leverageMatched = (() => {
@@ -1708,7 +1918,7 @@ const useTokenSelectionMetadataStore = create((set) => ({
             volume,
             sumNetFunding,
             maxLeverage,
-            minMargin,
+            minSize,
             leverageMatched,
         });
     },
@@ -1723,11 +1933,10 @@ const useTokenSelectionMetadata = () => {
     const tokenMetadata = useHyperliquidData((state) => state.tokenMetadata);
     const marketData = useMarketData((state) => state.marketData);
     const { longTokens, shortTokens } = useUserSelection$1();
-    const { isLoading, isPriceDataReady, longTokensMetadata, shortTokensMetadata, weightedRatio, weightedRatio24h, priceRatio, priceRatio24h, openInterest, volume, sumNetFunding, maxLeverage, minMargin, leverageMatched, recompute, } = useTokenSelectionMetadataStore();
+    const { isLoading, isPriceDataReady, longTokensMetadata, shortTokensMetadata, weightedRatio, weightedRatio24h, priceRatio, priceRatio24h, openInterest, volume, sumNetFunding, maxLeverage, minSize, leverageMatched, recompute, } = useTokenSelectionMetadataStore();
     // Recompute derived metadata when inputs change
     useEffect(() => {
         recompute({
-            perpMetaAssets,
             tokenMetadata,
             marketData: marketData || null,
             longTokens,
@@ -1751,8 +1960,8 @@ const useTokenSelectionMetadata = () => {
         volume,
         sumNetFunding,
         maxLeverage,
-        minMargin,
         leverageMatched,
+        minSize,
     };
 };
 
@@ -1778,6 +1987,22 @@ const getIntervalSeconds = (interval) => {
         default: return 60;
     }
 };
+/**
+ * Merges overlapping or adjacent ranges to prevent unbounded growth
+ */
+const mergeRanges = (ranges, newRange) => {
+    const all = [...ranges, newRange].sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const r of all) {
+        if (merged.length === 0 || r.start > merged[merged.length - 1].end) {
+            merged.push({ start: r.start, end: r.end });
+        }
+        else {
+            merged[merged.length - 1].end = Math.max(merged[merged.length - 1].end, r.end);
+        }
+    }
+    return merged;
+};
 const useHistoricalPriceDataStore = create((set, get) => ({
     historicalPriceData: {},
     loadingTokens: new Set(),
@@ -1788,6 +2013,8 @@ const useHistoricalPriceDataStore = create((set, get) => ({
             if (!existing) {
                 // Create new entry
                 const sortedCandles = [...candles].sort((a, b) => a.t - b.t);
+                // If first fetch returns empty, mark that there's no data before the requested end time
+                const noDataBefore = sortedCandles.length === 0 ? range.end : null;
                 return {
                     historicalPriceData: {
                         ...state.historicalPriceData,
@@ -1796,7 +2023,9 @@ const useHistoricalPriceDataStore = create((set, get) => ({
                             interval,
                             candles: sortedCandles,
                             oldestTime: sortedCandles.length > 0 ? sortedCandles[0].t : null,
-                            latestTime: sortedCandles.length > 0 ? sortedCandles[sortedCandles.length - 1].t : null
+                            latestTime: sortedCandles.length > 0 ? sortedCandles[sortedCandles.length - 1].t : null,
+                            requestedRanges: [range],
+                            noDataBefore
                         }
                     }
                 };
@@ -1808,6 +2037,16 @@ const useHistoricalPriceDataStore = create((set, get) => ({
             // Update time pointers
             const oldestTime = mergedCandles.length > 0 ? mergedCandles[0].t : null;
             const latestTime = mergedCandles.length > 0 ? mergedCandles[mergedCandles.length - 1].t : null;
+            // Merge requested ranges
+            const mergedRanges = mergeRanges(existing.requestedRanges || [], range);
+            // Update noDataBefore boundary:
+            // If we fetched a range older than our current oldest data and got no new candles,
+            // it means there's no data before our current oldest time
+            let noDataBefore = existing.noDataBefore;
+            if (candles.length === 0 && existing.oldestTime !== null && range.end <= existing.oldestTime) {
+                // We tried to fetch older data and got nothing - set boundary to our oldest known data
+                noDataBefore = existing.oldestTime;
+            }
             return {
                 historicalPriceData: {
                     ...state.historicalPriceData,
@@ -1815,7 +2054,9 @@ const useHistoricalPriceDataStore = create((set, get) => ({
                         ...existing,
                         candles: mergedCandles,
                         oldestTime,
-                        latestTime
+                        latestTime,
+                        requestedRanges: mergedRanges,
+                        noDataBefore
                     }
                 }
             };
@@ -1825,8 +2066,24 @@ const useHistoricalPriceDataStore = create((set, get) => ({
         const { historicalPriceData } = get();
         const key = createKey(symbol, interval);
         const tokenData = historicalPriceData[key];
-        if (!tokenData || tokenData.oldestTime === null || tokenData.latestTime === null)
+        if (!tokenData)
             return false;
+        // Check if we've hit the "no data before" boundary
+        // If the requested range ends before or at the boundary, we know there's no data
+        if (tokenData.noDataBefore !== null && endTime <= tokenData.noDataBefore) {
+            return true; // No point fetching - we know there's no data before this point
+        }
+        // Check if we've already attempted to fetch this range
+        const requestedRanges = tokenData.requestedRanges || [];
+        for (const range of requestedRanges) {
+            if (range.start <= startTime && range.end >= endTime) {
+                return true; // Already attempted this fetch
+            }
+        }
+        // Check actual data coverage
+        if (tokenData.oldestTime === null || tokenData.latestTime === null) {
+            return false;
+        }
         const intervalMilisecond = getIntervalSeconds(interval) * 1000;
         const hasStartCoverage = tokenData.oldestTime <= startTime;
         const hasEndCoverage = tokenData.latestTime >= endTime ||
@@ -1841,6 +2098,27 @@ const useHistoricalPriceDataStore = create((set, get) => ({
             return [];
         return tokenData.candles.filter(candle => candle.t >= startTime && candle.t < endTime);
     },
+    getEffectiveDataBoundary: (symbols, interval) => {
+        var _a;
+        const { historicalPriceData } = get();
+        if (symbols.length === 0)
+            return null;
+        let maxBoundary = null;
+        for (const symbol of symbols) {
+            const key = createKey(symbol, interval);
+            const tokenData = historicalPriceData[key];
+            if (!tokenData)
+                continue;
+            // Use noDataBefore if set, otherwise use oldestTime
+            const boundary = (_a = tokenData.noDataBefore) !== null && _a !== void 0 ? _a : tokenData.oldestTime;
+            if (boundary !== null) {
+                if (maxBoundary === null || boundary > maxBoundary) {
+                    maxBoundary = boundary;
+                }
+            }
+        }
+        return maxBoundary;
+    },
     setTokenLoading: (symbol, loading) => {
         set(state => {
             const newLoadingTokens = new Set(state.loadingTokens);
@@ -5721,10 +5999,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 {
@@ -5734,8 +6012,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}`;
 }
 /**
@@ -5764,7 +6042,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 {
@@ -5772,11 +6050,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;
     });
@@ -5787,22 +6066,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
@@ -5816,31 +6109,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 {
@@ -5851,11 +6158,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);
+        }
     };
 }
 
@@ -5971,7 +6282,7 @@ const useHistoricalPriceData = () => {
     const shortTokens = useUserSelection$1((state) => state.shortTokens);
     const candleInterval = useUserSelection$1((state) => state.candleInterval);
     // Historical price data store
-    const { addHistoricalPriceData, hasHistoricalPriceData: storeHasData, getHistoricalPriceData: storeGetData, setTokenLoading, isTokenLoading, removeTokenPriceData, clearData, } = useHistoricalPriceDataStore();
+    const { addHistoricalPriceData, hasHistoricalPriceData: storeHasData, getHistoricalPriceData: storeGetData, getEffectiveDataBoundary: storeGetBoundary, setTokenLoading, isTokenLoading, removeTokenPriceData, clearData, } = useHistoricalPriceDataStore();
     // Track previous tokens and interval to detect changes
     const prevTokensRef = useRef(new Set());
     const prevIntervalRef = useRef(null);
@@ -6024,6 +6335,11 @@ const useHistoricalPriceData = () => {
     const getAllHistoricalPriceData = useCallback(async () => {
         return useHistoricalPriceDataStore.getState().historicalPriceData;
     }, []);
+    const getEffectiveDataBoundary = useCallback((interval) => {
+        const allTokens = getAllTokens();
+        const symbols = allTokens.map(t => t.symbol);
+        return storeGetBoundary(symbols, interval);
+    }, [getAllTokens, storeGetBoundary]);
     const fetchHistoricalPriceData = useCallback(async (startTime, endTime, interval, callback) => {
         const allTokens = getAllTokens();
         if (allTokens.length === 0) {
@@ -6081,6 +6397,7 @@ const useHistoricalPriceData = () => {
         hasHistoricalPriceData,
         getAllHistoricalPriceData,
         getHistoricalPriceData,
+        getEffectiveDataBoundary,
         isLoading,
         clearCache,
     };
@@ -6277,7 +6594,7 @@ const useBasketCandles = () => {
     const longTokens = useUserSelection$1((state) => state.longTokens);
     const shortTokens = useUserSelection$1((state) => state.shortTokens);
     const candleData = useHyperliquidData((s) => s.candleData);
-    const { fetchHistoricalPriceData, isLoading: tokenLoading, getAllHistoricalPriceData } = useHistoricalPriceData();
+    const { fetchHistoricalPriceData, isLoading: tokenLoading, getAllHistoricalPriceData, getEffectiveDataBoundary } = useHistoricalPriceData();
     const fetchBasketCandles = useCallback(async (startTime, endTime, interval) => {
         const tokenCandles = await fetchHistoricalPriceData(startTime, endTime, interval);
         const basket = computeBasketCandles(longTokens, shortTokens, tokenCandles);
@@ -6477,6 +6794,7 @@ const useBasketCandles = () => {
         fetchBasketCandles,
         fetchPerformanceCandles,
         fetchOverallPerformanceCandles,
+        getEffectiveDataBoundary,
         isLoading,
         addRealtimeListener,
         removeRealtimeListener,
@@ -6752,11 +7070,13 @@ async function updateLeverage(baseUrl, positionId, payload) {
     }
 }
 
-const calculatePositionAsset = (asset, currentPrice, totalInitialPositionSize, leverage, metadata, isLong = true) => {
+const calculatePositionAsset = (asset, currentPrice, totalInitialPositionSize, totalCurrentPositionSize, leverage, metadata, isLong = true) => {
     var _a;
     const entryNotional = asset.entryPrice * asset.size;
     const currentNotional = currentPrice * asset.size;
-    const marginUsed = currentNotional / (leverage || 1);
+    const effectiveLeverage = leverage || 1;
+    const marginUsed = currentNotional / effectiveLeverage;
+    const entryMarginUsed = entryNotional / effectiveLeverage;
     const unrealizedPnl = isLong
         ? currentNotional - entryNotional
         : entryNotional - currentNotional;
@@ -6766,11 +7086,14 @@ const calculatePositionAsset = (asset, currentPrice, totalInitialPositionSize, l
         actualSize: asset.size,
         leverage: leverage,
         marginUsed: marginUsed,
+        entryMarginUsed: entryMarginUsed,
         positionValue: currentNotional,
         unrealizedPnl: unrealizedPnl,
         entryPositionValue: entryNotional,
         initialWeight: totalInitialPositionSize > 0 ? entryNotional / totalInitialPositionSize : 0,
+        currentWeight: totalCurrentPositionSize > 0 ? currentNotional / totalCurrentPositionSize : 0,
         fundingPaid: (_a = asset.fundingPaid) !== null && _a !== void 0 ? _a : 0,
+        targetWeight: asset.targetWeight,
         metadata,
     };
 };
@@ -6791,20 +7114,32 @@ const buildPositionValue = (rawPositions, clearinghouseState, getAssetByName) =>
             takeProfit: position.takeProfit,
             stopLoss: position.stopLoss,
         };
+        let entryMarginUsed = 0;
         const totalInitialPositionSize = position.longAssets.reduce((acc, asset) => acc + asset.entryPrice * asset.size, 0) +
             position.shortAssets.reduce((acc, asset) => acc + asset.entryPrice * asset.size, 0);
+        const totalCurrentPositionSize = position.longAssets.reduce((acc, asset) => {
+            var _a, _b;
+            const currentPrice = (_b = (_a = getAssetByName(asset.coin)) === null || _a === void 0 ? void 0 : _a.currentPrice) !== null && _b !== void 0 ? _b : 0;
+            return acc + currentPrice * asset.size;
+        }, 0) +
+            position.shortAssets.reduce((acc, asset) => {
+                var _a, _b;
+                const currentPrice = (_b = (_a = getAssetByName(asset.coin)) === null || _a === void 0 ? void 0 : _a.currentPrice) !== null && _b !== void 0 ? _b : 0;
+                return acc + currentPrice * asset.size;
+            }, 0);
         mappedPosition.longAssets = position.longAssets.map((longAsset) => {
             var _a, _b, _c, _d;
             const metadata = getAssetByName(longAsset.coin);
             const currentPrice = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.currentPrice) !== null && _a !== void 0 ? _a : 0;
             const assetState = (_b = clearinghouseState.assetPositions.find((ap) => ap.position.coin === longAsset.coin)) === null || _b === void 0 ? void 0 : _b.position;
             const leverage = (_d = (_c = assetState === null || assetState === void 0 ? void 0 : assetState.leverage) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : longAsset.leverage;
-            const mappedPositionAssets = calculatePositionAsset(longAsset, currentPrice, totalInitialPositionSize, leverage, metadata, true);
+            const mappedPositionAssets = calculatePositionAsset(longAsset, currentPrice, totalInitialPositionSize, totalCurrentPositionSize, leverage, metadata, true);
             mappedPosition.entryPositionValue +=
                 mappedPositionAssets.entryPositionValue;
             mappedPosition.unrealizedPnl += mappedPositionAssets.unrealizedPnl;
             mappedPosition.positionValue += mappedPositionAssets.positionValue;
             mappedPosition.marginUsed += mappedPositionAssets.marginUsed;
+            entryMarginUsed += mappedPositionAssets.entryMarginUsed;
             mappedPosition.entryRatio *= Math.pow(longAsset.entryPrice, mappedPositionAssets.initialWeight);
             mappedPosition.markRatio *= Math.pow(currentPrice, mappedPositionAssets.initialWeight);
             return mappedPositionAssets;
@@ -6815,14 +7150,15 @@ const buildPositionValue = (rawPositions, clearinghouseState, getAssetByName) =>
             const currentPrice = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.currentPrice) !== null && _a !== void 0 ? _a : 0;
             const assetState = (_b = clearinghouseState.assetPositions.find((ap) => ap.position.coin === shortAsset.coin)) === null || _b === void 0 ? void 0 : _b.position;
             const leverage = (_d = (_c = assetState === null || assetState === void 0 ? void 0 : assetState.leverage) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : shortAsset.leverage;
-            const mappedPositionAssets = calculatePositionAsset(shortAsset, currentPrice, totalInitialPositionSize, leverage, metadata, false);
+            const mappedPositionAssets = calculatePositionAsset(shortAsset, currentPrice, totalInitialPositionSize, totalCurrentPositionSize, leverage, metadata, false);
             mappedPosition.entryPositionValue +=
                 mappedPositionAssets.entryPositionValue;
             mappedPosition.unrealizedPnl += mappedPositionAssets.unrealizedPnl;
             mappedPosition.positionValue += mappedPositionAssets.positionValue;
             mappedPosition.marginUsed += mappedPositionAssets.marginUsed;
+            entryMarginUsed += mappedPositionAssets.entryMarginUsed;
             mappedPosition.entryRatio *= Math.pow(shortAsset.entryPrice, -mappedPositionAssets.initialWeight);
-            mappedPosition.markRatio *= Math.pow(currentPrice, -mappedPositionAssets.initialWeight);
+            mappedPosition.markRatio *= Math.pow(currentPrice, -mappedPositionAssets.currentWeight);
             return mappedPositionAssets;
         });
         mappedPosition.positionValue =
@@ -6858,11 +7194,12 @@ const buildPositionValue = (rawPositions, clearinghouseState, getAssetByName) =>
             mappedPosition.markPriceRatio = shortMark;
         }
         mappedPosition.unrealizedPnlPercentage =
-            mappedPosition.unrealizedPnl / mappedPosition.marginUsed;
+            entryMarginUsed > 0 ? mappedPosition.unrealizedPnl / entryMarginUsed : 0;
         return mappedPosition;
     });
 };
 
+const MIN_TRADE_SIZE_USD = 11;
 function usePosition() {
     const context = useContext(PearHyperliquidContext);
     if (!context) {
@@ -6905,6 +7242,85 @@ function usePosition() {
             return null;
         return buildPositionValue(userOpenPositions, aggregatedClearingHouseState, getAssetByName);
     }, [userOpenPositions, aggregatedClearingHouseState, tokenMetadata, getAssetByName]);
+    const planRebalance = (positionId, targetWeights) => {
+        var _a;
+        if (!openPositions) {
+            throw new Error('Open positions not loaded');
+        }
+        const position = openPositions.find((p) => p.positionId === positionId);
+        if (!position) {
+            throw new Error(`Position ${positionId} not found`);
+        }
+        const assets = [];
+        const allAssets = [
+            ...position.longAssets.map((a) => ({ asset: a, side: 'long' })),
+            ...position.shortAssets.map((a) => ({ asset: a, side: 'short' })),
+        ];
+        const totalValue = allAssets.reduce((sum, { asset }) => sum + asset.positionValue, 0);
+        for (const { asset, side } of allAssets) {
+            const tw = (_a = targetWeights === null || targetWeights === void 0 ? void 0 : targetWeights[asset.coin]) !== null && _a !== void 0 ? _a : asset.targetWeight;
+            if (tw === undefined) {
+                assets.push({
+                    coin: asset.coin,
+                    side,
+                    currentWeight: totalValue > 0 ? (asset.positionValue / totalValue) * 100 : 0,
+                    targetWeight: 0,
+                    currentValue: asset.positionValue,
+                    targetValue: asset.positionValue,
+                    deltaValue: 0,
+                    currentSize: asset.actualSize,
+                    newSize: asset.actualSize,
+                    deltaSize: 0,
+                    skipped: true,
+                    skipReason: 'No target weight defined',
+                });
+                continue;
+            }
+            const currentWeight = totalValue > 0 ? (asset.positionValue / totalValue) * 100 : 0;
+            const targetValue = totalValue * (tw / 100);
+            const deltaValue = targetValue - asset.positionValue;
+            const currentPrice = asset.actualSize > 0 ? asset.positionValue / asset.actualSize : 0;
+            const deltaSize = currentPrice > 0 ? deltaValue / currentPrice : 0;
+            const newSize = asset.actualSize + deltaSize;
+            const belowMinimum = Math.abs(deltaValue) > 0 && Math.abs(deltaValue) < MIN_TRADE_SIZE_USD;
+            assets.push({
+                coin: asset.coin,
+                side,
+                currentWeight,
+                targetWeight: tw,
+                currentValue: asset.positionValue,
+                targetValue,
+                deltaValue,
+                currentSize: asset.actualSize,
+                newSize,
+                deltaSize,
+                skipped: belowMinimum,
+                skipReason: belowMinimum
+                    ? `Trade size $${Math.abs(deltaValue).toFixed(2)} is below minimum $${MIN_TRADE_SIZE_USD}`
+                    : undefined,
+            });
+        }
+        const canExecute = assets.some((a) => !a.skipped && Math.abs(a.deltaValue) > 0);
+        return { positionId, assets, canExecute };
+    };
+    const executeRebalance = async (positionId, targetWeights) => {
+        const plan = planRebalance(positionId, targetWeights);
+        if (!plan.canExecute) {
+            throw new Error('No executable rebalance changes — all below minimum trade size or no changes needed');
+        }
+        const executable = plan.assets.filter((a) => !a.skipped && Math.abs(a.deltaValue) > 0);
+        const payload = [
+            {
+                longAssets: executable
+                    .filter((a) => a.side === 'long')
+                    .map((a) => ({ asset: a.coin, size: a.newSize })),
+                shortAssets: executable
+                    .filter((a) => a.side === 'short')
+                    .map((a) => ({ asset: a.coin, size: a.newSize })),
+            },
+        ];
+        return adjustAdvancePosition$1(positionId, payload);
+    };
     return {
         createPosition: createPosition$1,
         updateRiskParameters: updateRiskParameters$1,
@@ -6915,6 +7331,8 @@ function usePosition() {
         updateLeverage: updateLeverage$1,
         openPositions,
         isLoading,
+        planRebalance,
+        executeRebalance,
     };
 }
 
@@ -7197,122 +7615,62 @@ function useNotifications() {
     };
 }
 
-// Convert a basket item to the expected type
-function enrichBasketItem(item) {
-    const enrichedLongs = item.longAssets.map((a) => ({
-        ...a,
-    }));
-    const enrichedShorts = item.shortAssets.map((a) => ({
-        ...a,
-    }));
+function enrichBasketWithMetadata(basket, tokenMetadata) {
     return {
-        ...item,
-        longAssets: enrichedLongs,
-        shortAssets: enrichedShorts,
-        collateralType: 'USDC', //TODO: change
+        ...basket,
+        longAssets: basket.longAssets.map((asset) => {
+            var _a;
+            return ({
+                ...asset,
+                metadata: (_a = tokenMetadata[asset.asset]) !== null && _a !== void 0 ? _a : null,
+            });
+        }),
+        shortAssets: basket.shortAssets.map((asset) => {
+            var _a;
+            return ({
+                ...asset,
+                metadata: (_a = tokenMetadata[asset.asset]) !== null && _a !== void 0 ? _a : null,
+            });
+        }),
     };
 }
-/**
- * Filter baskets by collateral type
- * - 'USDC': Only baskets where ALL assets use USDC (collateralType === 'USDC')
- * - 'USDH': Only baskets where ALL assets use USDH (collateralType === 'USDH')
- * - 'ALL' or undefined: No filtering, returns all baskets
- */
-function filterByCollateral(baskets, filter) {
-    if (!filter || filter === 'ALL') {
-        return baskets;
-    }
-    return baskets.filter((basket) => {
-        if (filter === 'USDC') {
-            // Include baskets that are purely USDC or have USDC assets
-            return (basket.collateralType === 'USDC' || basket.collateralType === 'MIXED');
-        }
-        if (filter === 'USDH') {
-            // Include baskets that are purely USDH or have USDH assets
-            return (basket.collateralType === 'USDH' || basket.collateralType === 'MIXED');
-        }
-        return true;
-    });
+function enrichBasketsWithMetadata(baskets, tokenMetadata) {
+    return baskets.map((basket) => enrichBasketWithMetadata(basket, tokenMetadata));
 }
-// Base selector for the full market-data payload (raw from WS)
-const useMarketDataPayload = () => {
-    return useMarketData((s) => s.marketData);
-};
-// Active baskets
-const useActiveBaskets = (collateralFilter) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        if (!(data === null || data === void 0 ? void 0 : data.active))
-            return [];
-        const enriched = data.active.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, collateralFilter]);
-};
-// Top gainers
-const useTopGainers = (limit, collateralFilter) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        var _a;
-        const list = (_a = data === null || data === void 0 ? void 0 : data.topGainers) !== null && _a !== void 0 ? _a : [];
-        const limited = typeof limit === 'number' ? list.slice(0, Math.max(0, limit)) : list;
-        const enriched = limited.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, limit, collateralFilter]);
-};
-// Top losers
-const useTopLosers = (limit, collateralFilter) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        var _a;
-        const list = (_a = data === null || data === void 0 ? void 0 : data.topLosers) !== null && _a !== void 0 ? _a : [];
-        const limited = typeof limit === 'number' ? list.slice(0, Math.max(0, limit)) : list;
-        const enriched = limited.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, limit, collateralFilter]);
-};
-// Highlighted baskets
-const useHighlightedBaskets = (collateralFilter) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        if (!(data === null || data === void 0 ? void 0 : data.highlighted))
-            return [];
-        const enriched = data.highlighted.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, collateralFilter]);
-};
-// Watchlist baskets
-const useWatchlistBaskets = (collateralFilter) => {
-    const data = useMarketDataPayload();
+const useMarketDataHook = (options = {}) => {
+    const { topGainersLimit, topLosersLimit } = options;
+    const data = useMarketData((s) => s.marketData);
+    const tokenMetadata = useHyperliquidData((s) => s.tokenMetadata);
     return useMemo(() => {
-        if (!(data === null || data === void 0 ? void 0 : data.watchlist))
-            return [];
-        const enriched = data.watchlist.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, collateralFilter]);
-};
-// Find a basket by its exact asset composition (order-insensitive)
-const useFindBasket = (longs, shorts) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        if (!data)
-            return undefined;
-        const normalize = (arr) => Array.isArray(arr)
-            ? arr
-                .map((v) => (typeof v === 'string' ? v : v === null || v === void 0 ? void 0 : v.asset))
-                .filter(Boolean)
-                .map((s) => s.toUpperCase())
-                .sort()
-                .join(',')
-            : '';
-        const lKey = normalize(longs);
-        const sKey = normalize(shorts);
-        const match = (item) => normalize(item.longAssets) === lKey &&
-            normalize(item.shortAssets) === sKey;
-        const found = data.active.find(match) || data.highlighted.find(match);
-        return found
-            ? enrichBasketItem(found)
-            : undefined;
-    }, [data, longs, shorts]);
+        var _a, _b, _c;
+        const activeBaskets = enrichBasketsWithMetadata((_a = data === null || data === void 0 ? void 0 : data.active) !== null && _a !== void 0 ? _a : [], tokenMetadata);
+        const topGainers = (() => {
+            var _a;
+            const list = (_a = data === null || data === void 0 ? void 0 : data.topGainers) !== null && _a !== void 0 ? _a : [];
+            const limited = typeof topGainersLimit === 'number'
+                ? list.slice(0, Math.max(0, topGainersLimit))
+                : list;
+            return enrichBasketsWithMetadata(limited, tokenMetadata);
+        })();
+        const topLosers = (() => {
+            var _a;
+            const list = (_a = data === null || data === void 0 ? void 0 : data.topLosers) !== null && _a !== void 0 ? _a : [];
+            const limited = typeof topLosersLimit === 'number'
+                ? list.slice(0, Math.max(0, topLosersLimit))
+                : list;
+            return enrichBasketsWithMetadata(limited, tokenMetadata);
+        })();
+        const highlightedBaskets = enrichBasketsWithMetadata((_b = data === null || data === void 0 ? void 0 : data.highlighted) !== null && _b !== void 0 ? _b : [], tokenMetadata);
+        const watchlistBaskets = enrichBasketsWithMetadata((_c = data === null || data === void 0 ? void 0 : data.watchlist) !== null && _c !== void 0 ? _c : [], tokenMetadata);
+        return {
+            marketData: data,
+            activeBaskets,
+            topGainers,
+            topLosers,
+            highlightedBaskets,
+            watchlistBaskets,
+        };
+    }, [data, tokenMetadata, topGainersLimit, topLosersLimit]);
 };
 
 async function toggleWatchlist(baseUrl, longAssets, shortAssets) {
@@ -7338,7 +7696,7 @@ function useWatchlist() {
     if (!context)
         throw new Error('useWatchlist must be used within a PearHyperliquidProvider');
     const { apiBaseUrl, isConnected } = context;
-    const marketData = useMarketDataPayload();
+    const marketData = useMarketData(s => s.marketData);
     const isLoading = useMemo(() => !marketData && isConnected, [marketData, isConnected]);
     const toggle = async (longAssets, shortAssets) => {
         const resp = await toggleWatchlist(apiBaseUrl, longAssets, shortAssets);
@@ -7408,20 +7766,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);
@@ -7432,7 +7804,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 },
@@ -7440,61 +7812,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();
@@ -7508,6 +7943,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;
@@ -7515,17 +7999,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) {
@@ -7540,12 +8028,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) {
@@ -7553,38 +8045,60 @@ 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);
     }
+    function clearSession() {
+        setAccessToken(null);
+        setRefreshToken(null);
+        setIsAuthenticated(false);
+    }
     return {
         isReady,
         isAuthenticated,
+        address,
         accessToken,
         refreshToken: refreshToken$1,
         getEip712,
@@ -7592,109 +8106,188 @@ function useAuth() {
         loginWithPrivyToken,
         refreshTokens,
         logout: logout$1,
+        clearSession,
+        setAddress,
     };
 }
 
 const useAllUserBalances = () => {
     const spotState = useUserData((state) => state.spotState);
-    const aggregatedClearingHouseState = useHyperliquidData((state) => state.aggregatedClearingHouseState);
-    const rawClearinghouseStates = useHyperliquidData((state) => state.rawClearinghouseStates);
     const { longTokensMetadata, shortTokensMetadata } = useTokenSelectionMetadata();
-    return useMemo(() => {
-        const isLoading = !spotState || !aggregatedClearingHouseState;
-        // Helper function to truncate to 2 decimal places without rounding
-        const truncateToTwoDecimals = (value) => {
-            return Math.floor(value * 100) / 100;
-        };
-        // Get spot balances from spotState
-        let spotUsdcBal = undefined;
-        let spotUsdhBal = undefined;
-        if (spotState) {
-            const balances = spotState.balances || [];
-            for (const balance of balances) {
+    const { longTokens, shortTokens } = useUserSelection$1();
+    const aggregatedClearingHouseState = useHyperliquidData((state) => state.aggregatedClearingHouseState);
+    const { spotBalances, availableToTrades, isLoading } = useMemo(() => {
+        const isLoading = !spotState;
+        const spotBalances = {};
+        const availableToTrades = {};
+        if (spotState === null || spotState === void 0 ? void 0 : spotState.balances) {
+            for (const balance of spotState.balances) {
                 const total = parseFloat(balance.total || '0');
-                if (balance.coin === 'USDC') {
-                    spotUsdcBal = truncateToTwoDecimals(total);
-                }
-                if (balance.coin === 'USDH') {
-                    spotUsdhBal = truncateToTwoDecimals(total);
-                }
+                spotBalances[balance.coin] = total;
             }
         }
-        // Get available to trade from tokenMetadata for both USDC and USDH markets
-        let availableToTradeUsdcFromAsset = 0;
-        let availableToTradeUsdhFromAsset = 0;
-        // Token metadata only contains availableToTrade for SELECTED tokens (user's long and short Tokens)
-        // It does NOT contain data for all tokens, so we cannot reliably use it for available to trade as used on hl trade page
-        // so intead, we rely on rawClearinghouseStates which provides market-specific data
-        const selectedMetadataEntries = [
-            ...Object.entries(longTokensMetadata),
-            ...Object.entries(shortTokensMetadata),
+        const allMetadataWithSource = [
+            ...Object.values(longTokensMetadata).map((m) => ({
+                metadata: m,
+                isLong: true,
+            })),
+            ...Object.values(shortTokensMetadata).map((m) => ({
+                metadata: m,
+                isLong: false,
+            })),
         ];
-        selectedMetadataEntries.forEach(([symbol, metadata]) => {
-            var _a;
-            const availableStr = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.availableToTrade) === null || _a === void 0 ? void 0 : _a[0];
-            if (!availableStr)
-                return;
-            const availableValue = truncateToTwoDecimals(parseFloat(availableStr || '0'));
-            if ((metadata === null || metadata === void 0 ? void 0 : metadata.collateralToken) === 'USDH') {
-                availableToTradeUsdhFromAsset = Math.max(availableToTradeUsdhFromAsset, availableValue);
-                return;
-            }
-            if ((metadata === null || metadata === void 0 ? void 0 : metadata.collateralToken) === 'USDC') {
-                availableToTradeUsdcFromAsset = Math.max(availableToTradeUsdcFromAsset, availableValue);
-                return;
-            }
-            if (symbol.includes(':')) {
-                const prefix = symbol.split(':')[0];
-                if (prefix === 'xyz') {
-                    availableToTradeUsdcFromAsset = Math.max(availableToTradeUsdcFromAsset, availableValue);
-                }
-                else {
-                    availableToTradeUsdhFromAsset = Math.max(availableToTradeUsdhFromAsset, availableValue);
-                }
-                return;
-            }
-            availableToTradeUsdcFromAsset = Math.max(availableToTradeUsdcFromAsset, availableValue);
-        });
-        // Calculate USDC available to trade
-        // Priority 1: Use value from activeAssetData if available (> 0)
-        // Priority 2: Calculate from USDC-specific clearinghouseState (empty prefix)
-        let availableToTradeUsdcValue = undefined;
-        if (availableToTradeUsdcFromAsset > 0) {
-            availableToTradeUsdcValue = availableToTradeUsdcFromAsset;
-        }
-        else if (rawClearinghouseStates) {
-            // Find USDC market (empty prefix)
-            const usdcMarket = rawClearinghouseStates.find(([prefix]) => prefix === '');
-            const usdcState = usdcMarket === null || usdcMarket === void 0 ? void 0 : usdcMarket[1];
-            if (usdcState === null || usdcState === void 0 ? void 0 : usdcState.marginSummary) {
-                const accountValue = parseFloat(usdcState.marginSummary.accountValue || '0');
-                const totalMarginUsed = parseFloat(usdcState.marginSummary.totalMarginUsed || '0');
-                const calculatedValue = Math.max(0, accountValue - totalMarginUsed);
-                availableToTradeUsdcValue = truncateToTwoDecimals(calculatedValue);
+        for (const { metadata, isLong } of allMetadataWithSource) {
+            if (!(metadata === null || metadata === void 0 ? void 0 : metadata.collateralToken) || !(metadata === null || metadata === void 0 ? void 0 : metadata.availableToTrade))
+                continue;
+            const collateralCoin = metadata.collateralToken;
+            const availableToTrade = metadata.availableToTrade;
+            let value = parseFloat(availableToTrade[isLong ? 0 : 1] || '0');
+            if (!(collateralCoin in availableToTrades) ||
+                value < availableToTrades[collateralCoin]) {
+                availableToTrades[collateralCoin] = value;
             }
         }
-        // Calculate USDH available to trade
-        // Priority 1: Use value from activeAssetData if available (> 0)
-        // Priority 2: Use spot USDH balance
-        const availableToTradeUsdhValue = availableToTradeUsdhFromAsset > 0
-            ? availableToTradeUsdhFromAsset
-            : spotUsdhBal;
+        if (!availableToTrades['USDC']) {
+            availableToTrades['USDC'] = Math.max(0, parseFloat((aggregatedClearingHouseState === null || aggregatedClearingHouseState === void 0 ? void 0 : aggregatedClearingHouseState.marginSummary.accountValue) || '0') -
+                parseFloat((aggregatedClearingHouseState === null || aggregatedClearingHouseState === void 0 ? void 0 : aggregatedClearingHouseState.marginSummary.totalMarginUsed) || '0'));
+        }
         return {
-            spotUsdcBalance: spotUsdcBal,
-            availableToTradeUsdc: availableToTradeUsdcValue,
-            spotUsdhBalance: spotUsdhBal,
-            availableToTradeUsdh: availableToTradeUsdhValue,
+            spotBalances,
+            availableToTrades,
             isLoading,
         };
     }, [
         spotState,
+        longTokensMetadata,
+        shortTokensMetadata,
         aggregatedClearingHouseState,
-        rawClearinghouseStates,
+    ]);
+    /**
+     * Calculate margin required for every collateral token based on asset leverages and size.
+     * Returns margin required per collateral and whether there's sufficient margin.
+     */
+    const getMarginRequired = useCallback((assetsLeverage, size) => {
+        const sizeValue = parseFloat(String(size)) || 0;
+        // Group tokens by collateral type and calculate margin required
+        const marginByCollateral = {};
+        // Process all tokens (long and short)
+        const allTokensWithMetadata = [
+            ...longTokens.map((t) => ({
+                ...t,
+                metadata: longTokensMetadata[t.symbol],
+            })),
+            ...shortTokens.map((t) => ({
+                ...t,
+                metadata: shortTokensMetadata[t.symbol],
+            })),
+        ];
+        let totalMarginRequired = 0;
+        allTokensWithMetadata.forEach((token) => {
+            var _a;
+            const weight = token.weight || 0;
+            const assetSize = (sizeValue * weight) / 100;
+            const assetLeverage = assetsLeverage[token.symbol] || 1;
+            const assetMargin = assetLeverage > 0 ? assetSize / assetLeverage : 0;
+            // Get collateral type from metadata, default to USDC
+            const collateralToken = ((_a = token.metadata) === null || _a === void 0 ? void 0 : _a.collateralToken) || 'USDC';
+            if (!marginByCollateral[collateralToken]) {
+                marginByCollateral[collateralToken] = 0;
+            }
+            marginByCollateral[collateralToken] += assetMargin;
+            totalMarginRequired += assetMargin;
+        });
+        const perCollateral = Object.entries(marginByCollateral).map(([collateral, marginRequired]) => {
+            var _a;
+            const collateralToken = collateral;
+            const availableBalance = (_a = availableToTrades[collateralToken]) !== null && _a !== void 0 ? _a : 0;
+            const hasEnough = marginRequired <= availableBalance;
+            const shortfall = Math.max(0, marginRequired - availableBalance);
+            return {
+                collateral: collateralToken,
+                marginRequired: Number(marginRequired.toFixed(2)),
+                availableBalance: Number(availableBalance.toFixed(2)),
+                hasEnough,
+                shortfall: Number(shortfall.toFixed(2)),
+            };
+        });
+        const hasEnoughTotal = perCollateral.every((c) => c.hasEnough);
+        return {
+            totalMarginRequired: Number(totalMarginRequired.toFixed(2)),
+            orderValue: sizeValue,
+            perCollateral,
+            hasEnoughTotal,
+        };
+    }, [
+        longTokens,
+        shortTokens,
         longTokensMetadata,
         shortTokensMetadata,
+        spotBalances,
+        availableToTrades,
     ]);
+    /**
+     * Calculate the maximum order size ($) based on available balances and asset leverages.
+     * Returns the overall maximum order size constrained by all collateral types.
+     */
+    const getMaxSize = useCallback((assetsLeverage) => {
+        const marginFactorByCollateral = {};
+        const allTokensWithMetadata = [
+            ...longTokens.map((t) => ({
+                ...t,
+                metadata: longTokensMetadata[t.symbol],
+            })),
+            ...shortTokens.map((t) => ({
+                ...t,
+                metadata: shortTokensMetadata[t.symbol],
+            })),
+        ];
+        // Calculate the margin factor for each collateral type
+        // marginFactor = sum of (weight / leverage) for all assets using that collateral
+        allTokensWithMetadata.forEach((token) => {
+            var _a;
+            const weight = token.weight || 0;
+            const assetLeverage = assetsLeverage[token.symbol] || 1;
+            const collateralToken = ((_a = token.metadata) === null || _a === void 0 ? void 0 : _a.collateralToken) || 'USDC';
+            // marginFactor represents how much margin is needed per $1 of order size
+            const marginFactor = assetLeverage > 0 ? weight / (100 * assetLeverage) : 0;
+            if (!marginFactorByCollateral[collateralToken]) {
+                marginFactorByCollateral[collateralToken] = 0;
+            }
+            marginFactorByCollateral[collateralToken] += marginFactor;
+        });
+        // Calculate max size for each collateral type
+        // maxSize = availableBalance / marginFactor
+        // Each maxSize represents the total order size that collateral can support
+        const maxSizePerCollateral = [];
+        Object.entries(marginFactorByCollateral).forEach(([collateral, marginFactor]) => {
+            var _a;
+            const collateralToken = collateral;
+            const availableBalance = (_a = availableToTrades[collateralToken]) !== null && _a !== void 0 ? _a : 0;
+            if (marginFactor > 0) {
+                const maxSize = availableBalance / marginFactor;
+                maxSizePerCollateral.push(maxSize);
+            }
+        });
+        if (maxSizePerCollateral.length === 0) {
+            return 0;
+        }
+        const overallMaxSize = Math.min(...maxSizePerCollateral);
+        return Number(overallMaxSize.toFixed(2));
+    }, [
+        longTokens,
+        shortTokens,
+        longTokensMetadata,
+        shortTokensMetadata,
+        availableToTrades,
+    ]);
+    return {
+        abstractionMode: useUserData((state) => state.userAbstractionMode),
+        spotBalances,
+        availableToTrades,
+        isLoading,
+        getMarginRequired,
+        getMaxSize,
+    };
 };
 
 /**
@@ -7829,13 +8422,426 @@ function useHyperliquidUserFills(options) {
     };
 }
 
+async function getTradeHistory(baseUrl, params) {
+    const url = joinUrl(baseUrl, '/trade-history');
+    try {
+        const resp = await apiClient.get(url, {
+            params,
+            timeout: 60000,
+        });
+        return { data: resp.data, status: resp.status, headers: resp.headers };
+    }
+    catch (error) {
+        throw toApiError(error);
+    }
+}
+
+// ─── helpers ────────────────────────────────────────────────────
+const EMPTY_SUMMARY = {
+    pnl: 0,
+    volume: 0,
+    winRate: 0,
+    wins: 0,
+    losses: 0,
+    totalProfit: 0,
+    totalLoss: 0,
+};
+const getTimeframeDays$1 = (tf) => {
+    switch (tf) {
+        case '2W':
+            return 14;
+        case '3W':
+            return 21;
+        case '2M':
+            return 60;
+        case '3M':
+            return 90;
+    }
+};
+const isWeekTimeframe = (tf) => tf === '2W' || tf === '3W';
+const toDateKey = (date) => {
+    const y = date.getFullYear();
+    const m = String(date.getMonth() + 1).padStart(2, '0');
+    const d = String(date.getDate()).padStart(2, '0');
+    return `${y}-${m}-${d}`;
+};
+const toMonthKey = (date) => {
+    const y = date.getFullYear();
+    const m = String(date.getMonth() + 1).padStart(2, '0');
+    return `${y}-${m}`;
+};
+const formatMonthLabel = (date) => date.toLocaleDateString('en-US', { month: 'short', year: 'numeric' });
+const getMonday = (date) => {
+    const d = new Date(date);
+    const day = d.getDay(); // 0=Sun … 6=Sat
+    const diff = day === 0 ? -6 : 1 - day;
+    d.setDate(d.getDate() + diff);
+    d.setHours(0, 0, 0, 0);
+    return d;
+};
+const toLocalMidnight = (input) => {
+    const d = typeof input === 'string' ? new Date(input + 'T00:00:00') : new Date(input);
+    d.setHours(0, 0, 0, 0);
+    return d;
+};
+const diffDays = (start, end) => {
+    return Math.round((end.getTime() - start.getTime()) / (1000 * 60 * 60 * 24)) + 1;
+};
+const toISODateString$1 = (input) => {
+    const d = typeof input === 'string' ? new Date(input + 'T00:00:00') : new Date(input);
+    return d.toISOString();
+};
+const round2 = (n) => Math.round(n * 100) / 100;
+const buildSummary = (days) => {
+    let pnl = 0;
+    let volume = 0;
+    let wins = 0;
+    let losses = 0;
+    let totalProfit = 0;
+    let totalLoss = 0;
+    for (const day of days) {
+        pnl += day.totalPnl;
+        volume += day.volume;
+        if (day.positionsClosed === 0)
+            continue;
+        if (day.totalPnl > 0) {
+            wins++;
+            totalProfit += day.totalPnl;
+        }
+        else if (day.totalPnl < 0) {
+            losses++;
+            totalLoss += Math.abs(day.totalPnl);
+        }
+    }
+    const total = wins + losses;
+    const winRate = total > 0 ? Math.round((wins / total) * 100) : 0;
+    return {
+        pnl: round2(pnl),
+        volume: round2(volume),
+        winRate,
+        wins,
+        losses,
+        totalProfit: round2(totalProfit),
+        totalLoss: round2(totalLoss),
+    };
+};
+const buildCalendarData = (tradeHistories, timeframe, rangeStart, rangeEnd, totalDays, useCustomDates, getAssetByName) => {
+    const startKey = toDateKey(rangeStart);
+    const endKey = toDateKey(rangeEnd);
+    // Build day buckets for the full range
+    const buckets = new Map();
+    for (let i = 0; i < totalDays; i++) {
+        const d = new Date(rangeStart);
+        d.setDate(rangeStart.getDate() + i);
+        buckets.set(toDateKey(d), {
+            pnl: 0,
+            volume: 0,
+            positionsClosed: 0,
+            trades: [],
+        });
+    }
+    // Populate buckets from trade histories
+    for (const trade of tradeHistories) {
+        if (!trade.createdAt)
+            continue;
+        const date = new Date(trade.createdAt);
+        if (isNaN(date.getTime()))
+            continue;
+        const dateKey = toDateKey(date);
+        if (dateKey < startKey || dateKey > endKey)
+            continue;
+        const bucket = buckets.get(dateKey);
+        if (!bucket)
+            continue;
+        const pnl = trade.realizedPnl;
+        bucket.pnl += isFinite(pnl) ? pnl : 0;
+        const vol = trade.totalValue;
+        bucket.volume += isFinite(vol) ? vol : 0;
+        bucket.positionsClosed += 1;
+        const tradePnl = trade.realizedPnl;
+        bucket.trades.push({
+            tradeHistoryId: trade.tradeHistoryId,
+            realizedPnl: tradePnl,
+            result: tradePnl > 0 ? 'profit' : tradePnl < 0 ? 'loss' : 'breakeven',
+            closedLongAssets: trade.closedLongAssets.map((a) => { var _a; return ({ coin: a.coin, metadata: (_a = getAssetByName(a.coin)) !== null && _a !== void 0 ? _a : null }); }),
+            closedShortAssets: trade.closedShortAssets.map((a) => { var _a; return ({ coin: a.coin, metadata: (_a = getAssetByName(a.coin)) !== null && _a !== void 0 ? _a : null }); }),
+        });
+    }
+    // Build day objects
+    const allDays = [];
+    const sortedKeys = Array.from(buckets.keys()).sort();
+    for (const key of sortedKeys) {
+        const bucket = buckets.get(key);
+        const roundedPnl = round2(bucket.pnl);
+        const result = roundedPnl > 0 ? 'profit' : roundedPnl < 0 ? 'loss' : 'breakeven';
+        allDays.push({
+            date: key,
+            totalPnl: roundedPnl,
+            volume: round2(bucket.volume),
+            positionsClosed: bucket.positionsClosed,
+            result,
+            trades: bucket.trades,
+        });
+    }
+    // Group into periods
+    let weeks = [];
+    let months = [];
+    const useWeekGrouping = useCustomDates
+        ? totalDays <= 28
+        : isWeekTimeframe(timeframe);
+    if (useWeekGrouping) {
+        const weekMap = new Map();
+        for (const day of allDays) {
+            const date = new Date(day.date + 'T00:00:00');
+            const monday = getMonday(date);
+            const mondayKey = toDateKey(monday);
+            if (!weekMap.has(mondayKey)) {
+                weekMap.set(mondayKey, []);
+            }
+            weekMap.get(mondayKey).push(day);
+        }
+        const sortedWeekKeys = Array.from(weekMap.keys()).sort();
+        weeks = sortedWeekKeys.map((mondayKey) => {
+            const days = weekMap.get(mondayKey);
+            const monday = new Date(mondayKey + 'T00:00:00');
+            const sunday = new Date(monday);
+            sunday.setDate(monday.getDate() + 6);
+            return {
+                weekStart: mondayKey,
+                weekEnd: toDateKey(sunday),
+                days,
+                summary: buildSummary(days),
+            };
+        });
+    }
+    else {
+        const monthMap = new Map();
+        for (const day of allDays) {
+            const date = new Date(day.date + 'T00:00:00');
+            const mk = toMonthKey(date);
+            if (!monthMap.has(mk)) {
+                monthMap.set(mk, { days: [], label: formatMonthLabel(date) });
+            }
+            monthMap.get(mk).days.push(day);
+        }
+        const sortedMonthKeys = Array.from(monthMap.keys()).sort();
+        months = sortedMonthKeys.map((mk) => {
+            const { days, label } = monthMap.get(mk);
+            return {
+                month: mk,
+                label,
+                days,
+                summary: buildSummary(days),
+            };
+        });
+    }
+    return {
+        timeframe,
+        weeks,
+        months,
+        overall: buildSummary(allDays),
+        isLoading: false,
+    };
+};
+// ─── hook ───────────────────────────────────────────────────────
+function usePnlCalendar(options) {
+    var _a;
+    const opts = typeof options === 'string'
+        ? { timeframe: options }
+        : options !== null && options !== void 0 ? options : {};
+    const timeframe = (_a = opts.timeframe) !== null && _a !== void 0 ? _a : '2W';
+    const customStart = opts.startDate;
+    const customEnd = opts.endDate;
+    const context = useContext(PearHyperliquidContext);
+    if (!context) {
+        throw new Error('usePnlCalendar must be used within a PearHyperliquidProvider');
+    }
+    const { apiBaseUrl } = context;
+    const isAuthenticated = useUserData((state) => state.isAuthenticated);
+    const { getAssetByName } = useMarket();
+    const [trades, setTrades] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const mountedRef = useRef(true);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => { mountedRef.current = false; };
+    }, []);
+    // Compute the date range
+    const useCustomDates = !!(customStart && customEnd);
+    let rangeStart;
+    let rangeEnd;
+    let totalDays;
+    if (useCustomDates) {
+        rangeStart = toLocalMidnight(customStart);
+        rangeEnd = toLocalMidnight(customEnd);
+        totalDays = diffDays(rangeStart, rangeEnd);
+    }
+    else {
+        totalDays = getTimeframeDays$1(timeframe);
+        rangeEnd = new Date();
+        rangeEnd.setHours(0, 0, 0, 0);
+        rangeStart = new Date(rangeEnd);
+        rangeStart.setDate(rangeEnd.getDate() - totalDays + 1);
+    }
+    const startIso = toISODateString$1(rangeStart);
+    const endIso = toISODateString$1(rangeEnd);
+    const fetchData = useCallback(async () => {
+        if (!isAuthenticated)
+            return;
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await getTradeHistory(apiBaseUrl, {
+                startDate: startIso,
+                endDate: endIso,
+                limit: totalDays * 50,
+            });
+            if (!mountedRef.current)
+                return;
+            setTrades(response.data);
+        }
+        catch (err) {
+            if (!mountedRef.current)
+                return;
+            setError(err instanceof Error ? err.message : 'Failed to fetch trade history');
+            setTrades(null);
+        }
+        finally {
+            if (mountedRef.current)
+                setIsLoading(false);
+        }
+    }, [apiBaseUrl, isAuthenticated, startIso, endIso, totalDays]);
+    useEffect(() => {
+        fetchData();
+    }, [fetchData]);
+    const result = useMemo(() => {
+        const empty = {
+            timeframe,
+            weeks: [],
+            months: [],
+            overall: EMPTY_SUMMARY,
+            isLoading: true,
+        };
+        if (!trades)
+            return empty;
+        if (totalDays <= 0)
+            return empty;
+        return buildCalendarData(trades, timeframe, rangeStart, rangeEnd, totalDays, useCustomDates, getAssetByName);
+    }, [trades, timeframe, startIso, endIso, getAssetByName]);
+    return { ...result, isLoading, error, refetch: fetchData };
+}
+
+const HEATMAP_LIMIT = 50;
+// ─── helpers ────────────────────────────────────────────────────
+const getTimeframeDays = (tf) => {
+    switch (tf) {
+        case '7D':
+            return 7;
+        case '30D':
+            return 30;
+        case '100D':
+            return 100;
+        case 'allTime':
+            return null;
+    }
+};
+const toISODateString = (date) => date.toISOString();
+const toCalendarTrade = (trade, getAssetByName) => {
+    const pnl = trade.realizedPnl;
+    return {
+        tradeHistoryId: trade.tradeHistoryId,
+        realizedPnl: pnl,
+        result: pnl > 0 ? 'profit' : pnl < 0 ? 'loss' : 'breakeven',
+        closedLongAssets: trade.closedLongAssets.map((a) => { var _a; return ({ coin: a.coin, metadata: (_a = getAssetByName(a.coin)) !== null && _a !== void 0 ? _a : null }); }),
+        closedShortAssets: trade.closedShortAssets.map((a) => { var _a; return ({ coin: a.coin, metadata: (_a = getAssetByName(a.coin)) !== null && _a !== void 0 ? _a : null }); }),
+    };
+};
+// ─── hook ───────────────────────────────────────────────────────
+function usePnlHeatmap(timeframe = 'allTime') {
+    const context = useContext(PearHyperliquidContext);
+    if (!context) {
+        throw new Error('usePnlHeatmap must be used within a PearHyperliquidProvider');
+    }
+    const { apiBaseUrl } = context;
+    const isAuthenticated = useUserData((state) => state.isAuthenticated);
+    const { getAssetByName } = useMarket();
+    const [trades, setTrades] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const mountedRef = useRef(true);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => { mountedRef.current = false; };
+    }, []);
+    const days = getTimeframeDays(timeframe);
+    let startIso;
+    if (days !== null) {
+        const start = new Date();
+        start.setHours(0, 0, 0, 0);
+        start.setDate(start.getDate() - days);
+        startIso = toISODateString(start);
+    }
+    const fetchData = useCallback(async () => {
+        if (!isAuthenticated)
+            return;
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await getTradeHistory(apiBaseUrl, {
+                ...(startIso ? { startDate: startIso } : {}),
+                limit: 5000,
+            });
+            if (!mountedRef.current)
+                return;
+            setTrades(response.data);
+        }
+        catch (err) {
+            if (!mountedRef.current)
+                return;
+            setError(err instanceof Error ? err.message : 'Failed to fetch trade history');
+            setTrades(null);
+        }
+        finally {
+            if (mountedRef.current)
+                setIsLoading(false);
+        }
+    }, [apiBaseUrl, isAuthenticated, startIso]);
+    useEffect(() => {
+        fetchData();
+    }, [fetchData]);
+    const result = useMemo(() => {
+        if (!trades)
+            return [];
+        const top = trades
+            .slice()
+            .sort((a, b) => Math.abs(b.realizedPnl) - Math.abs(a.realizedPnl))
+            .slice(0, HEATMAP_LIMIT);
+        const totalAbsPnl = top.reduce((sum, t) => sum + Math.abs(t.realizedPnl), 0);
+        return top.map((t) => ({
+            ...toCalendarTrade(t, getAssetByName),
+            percentage: totalAbsPnl > 0
+                ? Math.round((Math.abs(t.realizedPnl) / totalAbsPnl) * 10000) / 100
+                : 0,
+        }));
+    }, [trades, getAssetByName]);
+    return { timeframe, trades: result, isLoading, error, refetch: fetchData };
+}
+
 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);
+    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);
@@ -7866,20 +8872,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 = 'USDT';
+                        collateralToken = "USDT0";
                     }
                     const universeAssets = item.universe.map((asset) => ({
                         ...asset,
@@ -7907,8 +8913,6 @@ const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearpro
     }), [
         apiBaseUrl,
         wsUrl,
-        address,
-        setAddress,
         isConnected,
         lastError,
         nativeIsConnected,
@@ -7923,7 +8927,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;
 }
 
@@ -8175,4 +9179,4 @@ function getOrderTrailingInfo(order) {
     return undefined;
 }
 
-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, executeSpotOrder, getAssetByName, getCompleteTimestamps, getKalshiMarkets, getOrderDirection, getOrderLadderConfig, getOrderLeverage, getOrderReduceOnly, getOrderTpSlTriggerType, getOrderTrailingInfo, getOrderTriggerType, getOrderTriggerValue, getOrderTwapDuration, getOrderUsdValue, getPortfolio, isBtcDomOrder, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, selectTokenMetadataBySymbols, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useActiveBaskets, useAgentWallet, useAllUserBalances, useAuth, useBasketCandles, useFindBasket, useHighlightedBaskets, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidUserFills, useHyperliquidWebSocket, useMarket, useMarketData, useMarketDataPayload, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTopGainers, useTopLosers, useTradeHistories, useTwap, useUserSelection, useWatchlist, useWatchlistBaskets, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };
+export { ConflictDetector, MAX_ASSETS_PER_LEG, MINIMUM_ASSET_USD_VALUE, MaxAssetsPerLegError, MinimumPositionSizeError, PearHyperliquidProvider, adjustAdvancePosition, adjustOrder, adjustPosition, calculateMinimumPositionValue, calculateWeightedRatio, cancelOrder, cancelTwap, cancelTwapOrder, closeAllPositions, closePosition, computeBasketCandles, createCandleLookups, createPosition, executeSpotOrder, getCompleteTimestamps, getKalshiMarkets, getOrderDirection, getOrderLadderConfig, getOrderLeverage, getOrderReduceOnly, getOrderTpSlTriggerType, getOrderTrailingInfo, getOrderTriggerType, getOrderTriggerValue, getOrderTwapDuration, getOrderUsdValue, getPortfolio, isBtcDomOrder, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useAgentWallet, useAllUserBalances, useAuth, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidUserFills, useMarket, useMarketData, useMarketDataHook, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePnlCalendar, usePnlHeatmap, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTradeHistories, useTwap, useUserSelection, useWatchlist, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };