@pear-protocol/hyperliquid-sdk 0.1.28 → 0.1.30

package/dist/index.d.ts

@@ -888,6 +888,7 @@ type CandleInterval = '1m' | '3m' | '5m' | '15m' | '30m' | '1h' | '2h' | '4h' |
  */
 interface CandleData {
     s?: string;
+    i?: CandleInterval;
     t: number;
     T: number;
     o: number;

package/dist/index.js

@@ -972,6 +972,20 @@ const useUserSelection$1 = create((set, get) => ({
     resetToDefaults: () => set((prev) => ({ ...prev, ...DEFAULT_STATE })),
 }));
 
+const CANDLE_STALE_WARNING_MS = 90000;
+const getCandleSubscriptionKey = (coin, interval) => `${coin}:${interval}`;
+const debugHyperliquidWs = (message, payload) => {
+    if (typeof window === "undefined")
+        return;
+    if (window.localStorage.getItem("pear:debug:hl-ws") !== "1")
+        return;
+    if (payload === undefined) {
+        console.debug(`[HyperLiquid WS] ${message}`);
+    }
+    else {
+        console.debug(`[HyperLiquid WS] ${message}`, payload);
+    }
+};
 const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }) => {
     const { setAllMids, setActiveAssetData, upsertActiveAssetData, setCandleData, deleteCandleSymbol, deleteActiveAssetData, addCandleData, setFinalAtOICaps, setAggregatedClearingHouseState, setRawClearinghouseStates, setAssetContextsByDex, } = useHyperliquidData();
     const { setSpotState, setUserAbstractionMode } = useUserData();
@@ -986,7 +1000,10 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
     const [subscribedCandleTokens, setSubscribedCandleTokens] = useState([]);
     const [clearinghouseStateReceived, setClearinghouseStateReceived] = useState(false);
     const prevCandleIntervalRef = useRef(null);
+    const currentCandleIntervalRef = useRef(candleInterval);
     const prevActiveAssetAddressRef = useRef(null);
+    const lastCandleMessageAtRef = useRef(null);
+    const lastCandleBySubscriptionRef = useRef(new Map());
     const pingIntervalRef = useRef(null);
     const wsRef = useRef(null);
     const reconnectAttemptsRef = useRef(0);
@@ -998,8 +1015,11 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
     useEffect(() => {
         onUserFillsRef.current = onUserFills;
     }, [onUserFills]);
+    useEffect(() => {
+        currentCandleIntervalRef.current = candleInterval;
+    }, [candleInterval]);
     const handleMessage = useCallback((event) => {
-        var _a;
+        var _a, _b;
         try {
             const message = JSON.parse(event.data);
             // Handle subscription responses
@@ -1097,7 +1117,27 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
                         {
                             const candleDataItem = response.data;
                             const symbol = candleDataItem.s || "";
+                            const messageInterval = (_b = candleDataItem.i) !== null && _b !== void 0 ? _b : currentCandleIntervalRef.current;
+                            if (messageInterval !== currentCandleIntervalRef.current) {
+                                debugHyperliquidWs("ignoring stale candle interval", {
+                                    symbol,
+                                    messageInterval,
+                                    currentInterval: currentCandleIntervalRef.current,
+                                    t: candleDataItem.t,
+                                    T: candleDataItem.T,
+                                });
+                                break;
+                            }
                             addCandleData(symbol, candleDataItem);
+                            const now = Date.now();
+                            lastCandleMessageAtRef.current = now;
+                            lastCandleBySubscriptionRef.current.set(getCandleSubscriptionKey(symbol, messageInterval), now);
+                            debugHyperliquidWs("candle received", {
+                                symbol,
+                                interval: messageInterval,
+                                t: candleDataItem.t,
+                                T: candleDataItem.T,
+                            });
                         }
                         break;
                     case "spotState":
@@ -1166,6 +1206,7 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
                 setSubscribedAddress(null);
                 setSubscribedTokens([]);
                 setSubscribedCandleTokens([]);
+                lastCandleBySubscriptionRef.current.clear();
                 setClearinghouseStateReceived(false);
                 if (!manualCloseRef.current) {
                     reconnectAttemptsRef.current += 1;
@@ -1197,6 +1238,7 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
             setSubscribedAddress(null);
             setSubscribedTokens([]);
             setSubscribedCandleTokens([]);
+            lastCandleBySubscriptionRef.current.clear();
             setClearinghouseStateReceived(false);
             // Close existing socket if in a bad state
             if (wsRef.current &&
@@ -1486,9 +1528,13 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         if (!isConnected)
             return;
         const effectiveTokens = selectedTokenSymbols;
-        // Unsubscribe from previous candle subscriptions if interval changed
         const prevInterval = prevCandleIntervalRef.current;
-        if (prevInterval && prevInterval !== candleInterval) {
+        const intervalChanged = prevInterval !== null && prevInterval !== candleInterval;
+        const activeSubscribedCandleTokens = intervalChanged
+            ? []
+            : subscribedCandleTokens;
+        // Unsubscribe from previous candle subscriptions if interval changed
+        if (intervalChanged && prevInterval !== null) {
             subscribedCandleTokens.forEach((token) => {
                 const unsubscribeMessage = {
                     method: "unsubscribe",
@@ -1499,12 +1545,17 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
                     },
                 };
                 sendJsonMessage(unsubscribeMessage);
+                lastCandleBySubscriptionRef.current.delete(getCandleSubscriptionKey(token, prevInterval));
+                debugHyperliquidWs("candle unsubscribe", {
+                    token,
+                    interval: prevInterval,
+                    reason: "interval-change",
+                });
             });
             setCandleData(new Map());
-            setSubscribedCandleTokens([]);
         }
-        const tokensToSubscribe = effectiveTokens.filter((token) => token && !subscribedCandleTokens.includes(token));
-        const tokensToUnsubscribe = subscribedCandleTokens.filter((token) => !effectiveTokens.includes(token));
+        const tokensToSubscribe = effectiveTokens.filter((token) => token && !activeSubscribedCandleTokens.includes(token));
+        const tokensToUnsubscribe = activeSubscribedCandleTokens.filter((token) => !effectiveTokens.includes(token));
         // Unsubscribe from tokens no longer in the list
         tokensToUnsubscribe.forEach((token) => {
             const unsubscribeMessage = {
@@ -1516,6 +1567,12 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
                 },
             };
             sendJsonMessage(unsubscribeMessage);
+            lastCandleBySubscriptionRef.current.delete(getCandleSubscriptionKey(token, candleInterval));
+            debugHyperliquidWs("candle unsubscribe", {
+                token,
+                interval: candleInterval,
+                reason: "token-removed",
+            });
         });
         // Subscribe to new tokens
         tokensToSubscribe.forEach((token) => {
@@ -1528,6 +1585,11 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
                 },
             };
             sendJsonMessage(subscribeMessage);
+            lastCandleBySubscriptionRef.current.delete(getCandleSubscriptionKey(token, candleInterval));
+            debugHyperliquidWs("candle subscribe", {
+                token,
+                interval: candleInterval,
+            });
         });
         // Update subscribed state
         if (tokensToSubscribe.length > 0 ||
@@ -1544,7 +1606,48 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         subscribedCandleTokens,
         sendJsonMessage,
         setCandleData,
+        deleteCandleSymbol,
     ]);
+    useEffect(() => {
+        if (!isConnected)
+            return;
+        const checkCandleSubscriptionHealth = () => {
+            const effectiveTokens = selectedTokenSymbols.filter((token) => token);
+            if (effectiveTokens.length === 0)
+                return;
+            const now = Date.now();
+            const missingSubscriptionState = effectiveTokens.filter((token) => !subscribedCandleTokens.includes(token));
+            const missingCandles = effectiveTokens.filter((token) => {
+                const key = getCandleSubscriptionKey(token, candleInterval);
+                return !lastCandleBySubscriptionRef.current.has(key);
+            });
+            const staleCandles = effectiveTokens.filter((token) => {
+                const key = getCandleSubscriptionKey(token, candleInterval);
+                const lastSeenAt = lastCandleBySubscriptionRef.current.get(key);
+                return (lastSeenAt !== undefined &&
+                    now - lastSeenAt > CANDLE_STALE_WARNING_MS);
+            });
+            if (missingSubscriptionState.length === 0 &&
+                missingCandles.length === 0 &&
+                staleCandles.length === 0) {
+                return;
+            }
+            debugHyperliquidWs("candle subscription health", {
+                interval: candleInterval,
+                selectedTokens: effectiveTokens,
+                subscribedTokens: subscribedCandleTokens,
+                missingSubscriptionState,
+                missingCandles,
+                staleCandles,
+                lastAnyCandleAgeMs: lastCandleMessageAtRef.current === null
+                    ? null
+                    : now - lastCandleMessageAtRef.current,
+            });
+        };
+        checkCandleSubscriptionHealth();
+        const healthInterval = setInterval(checkCandleSubscriptionHealth, 30000);
+        return () => clearInterval(healthInterval);
+    }, [isConnected, selectedTokenSymbols, candleInterval, subscribedCandleTokens]);
     return {
         isConnected,
         lastError,
@@ -6633,6 +6736,22 @@ const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
     return basketCandles;
 };
 
+const CANDLE_INTERVAL_MS = {
+    '1m': 60 * 1000,
+    '3m': 3 * 60 * 1000,
+    '5m': 5 * 60 * 1000,
+    '15m': 15 * 60 * 1000,
+    '30m': 30 * 60 * 1000,
+    '1h': 60 * 60 * 1000,
+    '2h': 2 * 60 * 60 * 1000,
+    '4h': 4 * 60 * 60 * 1000,
+    '8h': 8 * 60 * 60 * 1000,
+    '12h': 12 * 60 * 60 * 1000,
+    '1d': 24 * 60 * 60 * 1000,
+    '3d': 3 * 24 * 60 * 60 * 1000,
+    '1w': 7 * 24 * 60 * 60 * 1000,
+    '1M': 30 * 24 * 60 * 60 * 1000,
+};
 /**
  * Composes historical price fetching with basket candle computation.
  * - Listens to `longTokens` and `shortTokens` from user selection.
@@ -6642,6 +6761,7 @@ const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
 const useBasketCandles = () => {
     const longTokens = useUserSelection$1((state) => state.longTokens);
     const shortTokens = useUserSelection$1((state) => state.shortTokens);
+    const candleInterval = useUserSelection$1((state) => state.candleInterval);
     const candleData = useHyperliquidData((s) => s.candleData);
     const { fetchHistoricalPriceData, isLoading: tokenLoading, getAllHistoricalPriceData, getEffectiveDataBoundary } = useHistoricalPriceData();
     const fetchBasketCandles = useCallback(async (startTime, endTime, interval) => {
@@ -6747,40 +6867,56 @@ const useBasketCandles = () => {
     const removeRealtimeListener = useCallback((id) => {
         listenersRef.current.delete(id);
     }, []);
-    // Helper: compute weighted bar from latest snapshot if all tokens aligned
+    // Helper: compute weighted bar from latest snapshot, carrying forward lagging
+    // symbols so one sparse feed does not suppress every realtime chart update.
     const computeRealtimeBar = useCallback(() => {
         if (!candleData)
             return null;
         const allTokens = [...longTokens, ...shortTokens];
         if (allTokens.length === 0)
             return null;
-        // Collect candles, ensure presence and alignment
         const symbolSet = new Set(allTokens.map((t) => t.symbol));
         const snapshot = {};
+        let t = null;
+        let T = null;
         for (const symbol of symbolSet) {
             const c = candleData.get(symbol);
             if (!c)
                 return null; // missing latest candle for symbol
             snapshot[symbol] = c;
-        }
-        // Verify same interval window (t and T match across symbols)
-        let t = null;
-        let T = null;
-        for (const symbol of symbolSet) {
-            const c = snapshot[symbol];
-            if (t === null) {
+            if (t === null || c.t > t) {
                 t = c.t;
                 T = c.T;
             }
-            else if (c.t !== t || c.T !== T) {
-                return null; // not aligned yet
-            }
         }
+        if (t === null || T === null)
+            return null;
+        const intervalMs = CANDLE_INTERVAL_MS[candleInterval];
+        const maxCarryForwardMs = intervalMs * 2;
+        const getCandleForTargetWindow = (symbol) => {
+            const c = snapshot[symbol];
+            if (c.t === t)
+                return c;
+            if (c.t > t || t - c.t > maxCarryForwardMs)
+                return null;
+            const price = c.c;
+            if (!(price > 0))
+                return null;
+            return {
+                s: c.s,
+                t,
+                T,
+                o: price,
+                h: price,
+                l: price,
+                c: price,
+            };
+        };
         // Compute weighted OHLC similar to computeBasketCandles
         let longOpen = 1, longHigh = 1, longLow = 1, longClose = 1;
         let shortOpen = 1, shortHigh = 1, shortLow = 1, shortClose = 1;
         for (const token of longTokens) {
-            const c = snapshot[token.symbol];
+            const c = getCandleForTargetWindow(token.symbol);
             if (!c)
                 return null;
             const w = token.weight / 100;
@@ -6793,7 +6929,7 @@ const useBasketCandles = () => {
             longClose *= Math.pow(cl, w);
         }
         for (const token of shortTokens) {
-            const c = snapshot[token.symbol];
+            const c = getCandleForTargetWindow(token.symbol);
             if (!c)
                 return null;
             const w = -(token.weight / 100);
@@ -6805,8 +6941,6 @@ const useBasketCandles = () => {
             shortLow *= Math.pow(l, w);
             shortClose *= Math.pow(cl, w);
         }
-        if (t === null || T === null)
-            return null;
         const weighted = {
             t,
             T,
@@ -6816,8 +6950,8 @@ const useBasketCandles = () => {
             c: longClose * shortClose,
         };
         return weighted;
-    }, [candleData, longTokens, shortTokens]);
-    // Emit realtime bars when aligned snapshot updates
+    }, [candleData, candleInterval, longTokens, shortTokens]);
+    // Emit realtime bars when the latest snapshot can produce a valid bar.
     useEffect(() => {
         if (listenersRef.current.size === 0)
             return;
@@ -7157,7 +7291,9 @@ const calculatePositionAsset = (asset, currentPrice, totalInitialPositionSize, t
     };
 };
 const buildPositionValue = (rawPositions, clearinghouseState, getAssetByName) => {
-    return rawPositions.map((position) => {
+    const ifHip4Position = (position) => position.longAssets.some((a) => a.coin.startsWith("#")) ||
+        position.shortAssets.some((a) => a.coin.startsWith("#"));
+    return rawPositions.filter((p) => !ifHip4Position(p)).map((position) => {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         let mappedPosition = {
             positionId: position.positionId,
@@ -7300,7 +7436,12 @@ function usePosition() {
             Object.keys(tokenMetadata).length === 0)
             return null;
         return buildPositionValue(userOpenPositions, aggregatedClearingHouseState, getAssetByName);
-    }, [userOpenPositions, aggregatedClearingHouseState, tokenMetadata, getAssetByName]);
+    }, [
+        userOpenPositions,
+        aggregatedClearingHouseState,
+        tokenMetadata,
+        getAssetByName,
+    ]);
     const planRebalance = (positionId, targetWeights) => {
         var _a;
         if (!openPositions) {
@@ -7313,7 +7454,10 @@ function usePosition() {
         const assets = [];
         const allAssets = [
             ...position.longAssets.map((a) => ({ asset: a, side: 'long' })),
-            ...position.shortAssets.map((a) => ({ asset: a, side: 'short' })),
+            ...position.shortAssets.map((a) => ({
+                asset: a,
+                side: 'short',
+            })),
         ];
         const totalValue = allAssets.reduce((sum, { asset }) => sum + asset.positionValue, 0);
         for (const { asset, side } of allAssets) {

package/dist/types.d.ts

@@ -860,6 +860,7 @@ export type CandleInterval = '1m' | '3m' | '5m' | '15m' | '30m' | '1h' | '2h' |
  */
 export interface CandleData {
     s?: string;
+    i?: CandleInterval;
     t: number;
     T: number;
     o: number;

package/package.json

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