@pear-protocol/hyperliquid-sdk 0.1.3 → 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;
@@ -1560,7 +1730,7 @@ const useTokenSelectionMetadataStore = create((set) => ({
     maxLeverage: 0,
     minSize: {},
     leverageMatched: true,
-    recompute: ({ tokenMetadata, marketData, longTokens, shortTokens, }) => {
+    recompute: ({ tokenMetadata, marketData, longTokens, shortTokens }) => {
         const isPriceDataReady = Object.keys(tokenMetadata).length > 0;
         const longSymbols = longTokens.map((t) => t.symbol);
         const shortSymbols = shortTokens.map((t) => t.symbol);
@@ -1691,10 +1861,9 @@ const useTokenSelectionMetadataStore = create((set) => ({
                 return 0;
             let maxLev = 0;
             allSymbols.forEach((symbol) => {
-                var _a;
                 const tokenDetail = tokenMetadata[symbol];
-                if ((_a = tokenDetail === null || tokenDetail === void 0 ? void 0 : tokenDetail.leverage) === null || _a === void 0 ? void 0 : _a.value) {
-                    maxLev = Math.max(maxLev, tokenDetail.leverage.value);
+                if (tokenDetail === null || tokenDetail === void 0 ? void 0 : tokenDetail.maxLeverage) {
+                    maxLev = Math.max(maxLev, tokenDetail.maxLeverage);
                 }
             });
             return maxLev;
@@ -1818,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(),
@@ -1828,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,
@@ -1836,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
                         }
                     }
                 };
@@ -1848,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,
@@ -1855,7 +2054,9 @@ const useHistoricalPriceDataStore = create((set, get) => ({
                         ...existing,
                         candles: mergedCandles,
                         oldestTime,
-                        latestTime
+                        latestTime,
+                        requestedRanges: mergedRanges,
+                        noDataBefore
                     }
                 }
             };
@@ -1865,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 ||
@@ -1881,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);
@@ -5761,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 {
@@ -5774,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}`;
 }
 /**
@@ -5804,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 {
@@ -5812,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;
     });
@@ -5827,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
@@ -5856,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 {
@@ -5891,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);
+        }
     };
 }
 
@@ -6011,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);
@@ -6064,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) {
@@ -6121,6 +6397,7 @@ const useHistoricalPriceData = () => {
         hasHistoricalPriceData,
         getAllHistoricalPriceData,
         getHistoricalPriceData,
+        getEffectiveDataBoundary,
         isLoading,
         clearCache,
     };
@@ -6317,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);
@@ -6517,6 +6794,7 @@ const useBasketCandles = () => {
         fetchBasketCandles,
         fetchPerformanceCandles,
         fetchOverallPerformanceCandles,
+        getEffectiveDataBoundary,
         isLoading,
         addRealtimeListener,
         removeRealtimeListener,
@@ -6792,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;
@@ -6806,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,
     };
 };
@@ -6831,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;
@@ -6855,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 =
@@ -6898,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) {
@@ -6945,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,
@@ -6955,6 +7331,8 @@ function usePosition() {
         updateLeverage: updateLeverage$1,
         openPositions,
         isLoading,
+        planRebalance,
+        executeRebalance,
     };
 }
 
@@ -7388,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);
@@ -7412,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 },
@@ -7420,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();
@@ -7488,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;
@@ -7495,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) {
@@ -7520,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) {
@@ -7533,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,
@@ -7572,6 +8106,8 @@ function useAuth() {
         loginWithPrivyToken,
         refreshTokens,
         logout: logout$1,
+        clearSession,
+        setAddress,
     };
 }
 
@@ -7612,14 +8148,20 @@ const useAllUserBalances = () => {
             }
         }
         if (!availableToTrades['USDC']) {
-            availableToTrades['USDC'] = parseFloat((aggregatedClearingHouseState === null || aggregatedClearingHouseState === void 0 ? void 0 : aggregatedClearingHouseState.marginSummary.totalRawUsd) || '0');
+            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 {
             spotBalances,
             availableToTrades,
             isLoading,
         };
-    }, [spotState, longTokensMetadata, shortTokensMetadata, aggregatedClearingHouseState]);
+    }, [
+        spotState,
+        longTokensMetadata,
+        shortTokensMetadata,
+        aggregatedClearingHouseState,
+    ]);
     /**
      * Calculate margin required for every collateral token based on asset leverages and size.
      * Returns margin required per collateral and whether there's sufficient margin.
@@ -7739,6 +8281,7 @@ const useAllUserBalances = () => {
         availableToTrades,
     ]);
     return {
+        abstractionMode: useUserData((state) => state.userAbstractionMode),
         spotBalances,
         availableToTrades,
         isLoading,
@@ -7879,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);
@@ -7916,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 = 'USDT0';
+                        collateralToken = "USDT0";
                     }
                     const universeAssets = item.universe.map((asset) => ({
                         ...asset,
@@ -7957,8 +8913,6 @@ const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearpro
     }), [
         apiBaseUrl,
         wsUrl,
-        address,
-        setAddress,
         isConnected,
         lastError,
         nativeIsConnected,
@@ -7973,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;
 }
 
@@ -8225,4 +9179,4 @@ function getOrderTrailingInfo(order) {
     return undefined;
 }
 
-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, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTradeHistories, useTwap, useUserSelection, useWatchlist, 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 };