@pear-protocol/hyperliquid-sdk 0.0.20 → 0.0.22

package/dist/hooks/useBasketCandles.d.ts

@@ -1,8 +1,19 @@
-import type { WeightedCandleData } from '../types';
+import type { CandleInterval, WeightedCandleData } from '../types';
 export interface UseBasketCandlesReturn {
-    fetchBasketCandles: (startTime: number, endTime: number) => Promise<WeightedCandleData[]>;
+    fetchBasketCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<WeightedCandleData[]>;
     isLoading: boolean;
+    addRealtimeListener: (cb: RealtimeBarsCallback) => string;
+    removeRealtimeListener: (id: string) => void;
 }
+export type RealtimeBar = {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+};
+export type RealtimeBarsCallback = (bar: RealtimeBar) => void;
 /**
  * Composes historical price fetching with basket candle computation.
  * - Listens to `longTokens` and `shortTokens` from user selection.

package/dist/hooks/useHistoricalPriceData.d.ts

@@ -1,8 +1,8 @@
-import type { CandleData } from '../types';
+import type { CandleData, CandleInterval } from '../types';
 export interface UseHistoricalPriceDataReturn {
-    fetchHistoricalPriceData: (startTime: number, endTime: number, callback?: (data: Record<string, CandleData[]>) => void) => Promise<Record<string, CandleData[]>>;
-    hasHistoricalPriceData: (startTime: number, endTime: number) => boolean;
-    getHistoricalPriceData: (startTime: number, endTime: number) => Record<string, CandleData[]>;
+    fetchHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval, callback?: (data: Record<string, CandleData[]>) => void) => Promise<Record<string, CandleData[]>>;
+    hasHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval) => boolean;
+    getHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval) => Record<string, CandleData[]>;
     isLoading: (symbol?: string) => boolean;
     clearCache: () => void;
 }

package/dist/hyperliquid-websocket.d.ts

@@ -1,13 +1,11 @@
 import { ReadyState } from 'react-use-websocket';
-import type { CandleInterval } from './types';
 export interface UseHyperliquidNativeWebSocketProps {
     address: string | null;
     tokens?: string[];
-    candleInterval?: CandleInterval;
 }
 export interface UseHyperliquidNativeWebSocketReturn {
     connectionStatus: ReadyState;
     isConnected: boolean;
     lastError: string | null;
 }
-export declare const useHyperliquidNativeWebSocket: ({ address, tokens, candleInterval }: UseHyperliquidNativeWebSocketProps) => UseHyperliquidNativeWebSocketReturn;
+export declare const useHyperliquidNativeWebSocket: ({ address, }: UseHyperliquidNativeWebSocketProps) => UseHyperliquidNativeWebSocketReturn;

package/dist/index.d.ts

@@ -630,7 +630,7 @@ interface CandleData {
  * Candle chart data organized by symbol only
  * Since new candles always have latest timestamp, no need to store per interval
  */
-type CandleChartData = Record<string, CandleData>;
+type CandleChartData = Map<string, CandleData>;
 /**
  * Historical candle data request
  */
@@ -840,6 +840,7 @@ interface UserSelectionState {
     openConflictModal: boolean;
     conflicts: TokenConflict[];
     candleInterval: CandleInterval;
+    isWeightBalanced: boolean;
     setLongTokens: (tokens: TokenSelection[]) => void;
     setShortTokens: (tokens: TokenSelection[]) => void;
     setOpenTokenSelector: (open: boolean) => void;
@@ -883,18 +884,29 @@ interface UseTokenSelectionMetadataReturn {
 declare const useTokenSelectionMetadata: () => UseTokenSelectionMetadataReturn;
 
 interface UseHistoricalPriceDataReturn {
-    fetchHistoricalPriceData: (startTime: number, endTime: number, callback?: (data: Record<string, CandleData[]>) => void) => Promise<Record<string, CandleData[]>>;
-    hasHistoricalPriceData: (startTime: number, endTime: number) => boolean;
-    getHistoricalPriceData: (startTime: number, endTime: number) => Record<string, CandleData[]>;
+    fetchHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval, callback?: (data: Record<string, CandleData[]>) => void) => Promise<Record<string, CandleData[]>>;
+    hasHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval) => boolean;
+    getHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval) => Record<string, CandleData[]>;
     isLoading: (symbol?: string) => boolean;
     clearCache: () => void;
 }
 declare const useHistoricalPriceData: () => UseHistoricalPriceDataReturn;
 
 interface UseBasketCandlesReturn {
-    fetchBasketCandles: (startTime: number, endTime: number) => Promise<WeightedCandleData[]>;
+    fetchBasketCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<WeightedCandleData[]>;
     isLoading: boolean;
+    addRealtimeListener: (cb: RealtimeBarsCallback) => string;
+    removeRealtimeListener: (id: string) => void;
 }
+type RealtimeBar = {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+};
+type RealtimeBarsCallback = (bar: RealtimeBar) => void;
 /**
  * Composes historical price fetching with basket candle computation.
  * - Listens to `longTokens` and `shortTokens` from user selection.
@@ -916,14 +928,13 @@ declare const useHyperliquidWebSocket: ({ wsUrl, address }: UseHyperliquidWebSoc
 interface UseHyperliquidNativeWebSocketProps {
     address: string | null;
     tokens?: string[];
-    candleInterval?: CandleInterval;
 }
 interface UseHyperliquidNativeWebSocketReturn {
     connectionStatus: ReadyState;
     isConnected: boolean;
     lastError: string | null;
 }
-declare const useHyperliquidNativeWebSocket: ({ address, tokens, candleInterval }: UseHyperliquidNativeWebSocketProps) => UseHyperliquidNativeWebSocketReturn;
+declare const useHyperliquidNativeWebSocket: ({ address, }: UseHyperliquidNativeWebSocketProps) => UseHyperliquidNativeWebSocketReturn;
 
 /**
  * Account summary calculation utility class
@@ -1018,6 +1029,15 @@ declare const getCompleteTimestamps: (candleLookups: Record<string, Map<number,
  */
 declare const computeBasketCandles: (longTokens: TokenSelection[], shortTokens: TokenSelection[], tokenCandles: Record<string, CandleData[]>) => WeightedCandleData[];
 
+/**
+ * Maps TradingView ResolutionString to CandleInterval
+ */
+declare function mapTradingViewIntervalToCandleInterval(interval: string): CandleInterval;
+/**
+ * Maps CandleInterval to TradingView ResolutionString
+ */
+declare function mapCandleIntervalToTradingViewInterval(interval: CandleInterval): string;
+
 interface HistoricalRange {
     start: number;
     end: number;
@@ -1031,5 +1051,5 @@ interface TokenHistoricalPriceData {
 }
 declare const useHistoricalPriceDataStore: any;
 
-export { AccountSummaryCalculator, ConflictDetector, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, TokenMetadataExtractor, calculateWeightedRatio, computeBasketCandles, createCandleLookups, PearHyperliquidClient as default, getCompleteTimestamps, useAccountSummary, useAddress, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };
-export type { AccountSummaryResponseDto, AgentWalletDto, ApiErrorResponse, ApiResponse, AssetCtx, AssetInformationDetail, AssetMarketData, AssetPosition, BalanceSummaryDto, CandleChartData, CandleData, CandleInterval, CandleSnapshotRequest, ClearinghouseState, CrossMarginSummaryDto, CumFundingDto, HLWebSocketResponse, HistoricalRange, MarginSummaryDto, MigrationHookState, MigrationHooks, OpenLimitOrderDto, OpenOrderV1Dto, OpenPositionDto, OpenPositionV1Dto, OrderAssetDto, OrderStatus, PearHyperliquidConfig, PnlDto, PositionAssetDetailDto, PositionSideDto, PositionSyncStatus, RawValueDto, SyncOpenOrderDto, SyncOpenOrderResponseDto, SyncOpenPositionDto, SyncOpenPositionResponseDto, SyncTradeHistoryDto, SyncTradeHistoryResponseDto, TokenConflict, TokenHistoricalPriceData, TokenMetadata, TokenSelection, TpSlDto, TradeHistoryAssetDataDto, TradeHistoryDataDto, TradeHistoryV1Dto, UniverseAsset, UseBasketCandlesReturn, UseHistoricalPriceDataReturn, UseTokenSelectionMetadataReturn, UserSelectionState, WebData2Response, WebSocketAckResponse, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketSubscribeMessage, WeightedCandleData, WsAllMidsData };
+export { AccountSummaryCalculator, ConflictDetector, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, TokenMetadataExtractor, calculateWeightedRatio, computeBasketCandles, createCandleLookups, PearHyperliquidClient as default, getCompleteTimestamps, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, useAccountSummary, useAddress, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };
+export type { AccountSummaryResponseDto, AgentWalletDto, ApiErrorResponse, ApiResponse, AssetCtx, AssetInformationDetail, AssetMarketData, AssetPosition, BalanceSummaryDto, CandleChartData, CandleData, CandleInterval, CandleSnapshotRequest, ClearinghouseState, CrossMarginSummaryDto, CumFundingDto, HLWebSocketResponse, HistoricalRange, MarginSummaryDto, MigrationHookState, MigrationHooks, OpenLimitOrderDto, OpenOrderV1Dto, OpenPositionDto, OpenPositionV1Dto, OrderAssetDto, OrderStatus, PearHyperliquidConfig, PnlDto, PositionAssetDetailDto, PositionSideDto, PositionSyncStatus, RawValueDto, RealtimeBar, RealtimeBarsCallback, SyncOpenOrderDto, SyncOpenOrderResponseDto, SyncOpenPositionDto, SyncOpenPositionResponseDto, SyncTradeHistoryDto, SyncTradeHistoryResponseDto, TokenConflict, TokenHistoricalPriceData, TokenMetadata, TokenSelection, TpSlDto, TradeHistoryAssetDataDto, TradeHistoryDataDto, TradeHistoryV1Dto, UniverseAsset, UseBasketCandlesReturn, UseHistoricalPriceDataReturn, UseTokenSelectionMetadataReturn, UserSelectionState, WebData2Response, WebSocketAckResponse, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketSubscribeMessage, WeightedCandleData, WsAllMidsData };

package/dist/index.js

@@ -1,4 +1,4 @@
-import require$$0, { useState, useEffect, useRef, createContext, useMemo, useContext, useCallback } from 'react';
+import require$$0, { useState, useEffect, useMemo, useRef, createContext, useContext, useCallback } from 'react';
 import require$$1 from 'react-dom';
 import { create } from 'zustand';
 
@@ -6653,21 +6653,19 @@ const useHyperliquidData = create((set, get) => ({
     },
     addCandleData(symbol, candle) {
         set((state) => {
-            return {
-                candleData: {
-                    ...state.candleData,
-                    [symbol]: candle
-                }
-            };
+            var _a;
+            const map = (_a = state.candleData) !== null && _a !== void 0 ? _a : new Map();
+            const updatedMap = new Map(map);
+            updatedMap.set(symbol, candle); // store latest only
+            return { candleData: updatedMap };
         });
     },
     deleteCandleSymbol(symbol) {
         set((state) => {
-            if (!state.candleData || !(symbol in state.candleData)) {
-                return state; // No change if symbol doesn't exist
-            }
-            const updated = { ...state.candleData };
-            delete updated[symbol];
+            if (!state.candleData)
+                return state;
+            const updated = new Map(state.candleData);
+            updated.delete(symbol);
             return { candleData: updated };
         });
     },
@@ -6680,13 +6678,141 @@ const useHyperliquidData = create((set, get) => ({
     }))
 }));
 
-const useHyperliquidNativeWebSocket = ({ address, tokens = [], candleInterval = "1h" }) => {
+const DEFAULT_STATE = {
+    longTokens: [
+        { symbol: "HYPE", weight: 25 },
+        { symbol: "BTC", weight: 25 },
+    ],
+    shortTokens: [
+        { symbol: "AVAX", weight: 10 },
+        { symbol: "SEI", weight: 10 },
+        { symbol: "ADA", weight: 10 },
+        { symbol: "TRUMP", weight: 10 },
+        { symbol: "SUI", weight: 10 },
+    ],
+    openTokenSelector: false,
+    selectorConfig: null,
+    openConflictModal: false,
+    conflicts: [],
+    candleInterval: "1h",
+    isWeightBalanced: true,
+};
+const useUserSelection$1 = create((set, get) => ({
+    ...DEFAULT_STATE,
+    setLongTokens: (tokens) => set((state) => ({ ...state, longTokens: tokens })),
+    setShortTokens: (tokens) => set((state) => ({ ...state, shortTokens: tokens })),
+    setOpenTokenSelector: (open) => set((state) => ({ ...state, openTokenSelector: open })),
+    setSelectorConfig: (config) => set((state) => ({ ...state, selectorConfig: config })),
+    setOpenConflictModal: (open) => set((state) => ({ ...state, openConflictModal: open })),
+    setConflicts: (conflicts) => set((state) => ({ ...state, conflicts })),
+    setCandleInterval: (interval) => set((state) => ({ ...state, candleInterval: interval })),
+    updateTokenWeight: (isLong, index, newWeight) => {
+        set((prev) => {
+            if (isLong) {
+                const updated = [...prev.longTokens];
+                updated[index] = { ...updated[index], weight: newWeight };
+                const longTotal = updated.reduce((sum, t) => sum + t.weight, 0);
+                const shortTotal = prev.shortTokens.reduce((sum, t) => sum + t.weight, 0);
+                const isWeightBalanced = longTotal + shortTotal === 100;
+                return { ...prev, longTokens: updated, isWeightBalanced };
+            }
+            else {
+                const updated = [...prev.shortTokens];
+                updated[index] = { ...updated[index], weight: newWeight };
+                const longTotal = prev.longTokens.reduce((sum, t) => sum + t.weight, 0);
+                const shortTotal = updated.reduce((sum, t) => sum + t.weight, 0);
+                const isWeightBalanced = longTotal + shortTotal === 100;
+                return { ...prev, shortTokens: updated, isWeightBalanced };
+            }
+        });
+    },
+    addToken: (isLong) => {
+        const currentTokens = isLong ? get().longTokens : get().shortTokens;
+        const newIndex = currentTokens.length;
+        set((prev) => ({
+            ...prev,
+            selectorConfig: { isLong, index: newIndex },
+            openTokenSelector: true,
+        }));
+    },
+    removeToken: (isLong, index) => {
+        set((prev) => {
+            if (isLong) {
+                const updated = prev.longTokens.filter((_, i) => i !== index);
+                const longTotal = updated.reduce((sum, t) => sum + t.weight, 0);
+                const shortTotal = prev.shortTokens.reduce((sum, t) => sum + t.weight, 0);
+                const isWeightBalanced = longTotal + shortTotal === 100;
+                return { ...prev, longTokens: updated, isWeightBalanced };
+            }
+            else {
+                const updated = prev.shortTokens.filter((_, i) => i !== index);
+                const longTotal = prev.longTokens.reduce((sum, t) => sum + t.weight, 0);
+                const shortTotal = updated.reduce((sum, t) => sum + t.weight, 0);
+                const isWeightBalanced = longTotal + shortTotal === 100;
+                return { ...prev, shortTokens: updated, isWeightBalanced };
+            }
+        });
+    },
+    handleTokenSelect: (selectedToken) => {
+        const { selectorConfig, longTokens, shortTokens } = get();
+        if (!selectorConfig)
+            return;
+        const { isLong, index } = selectorConfig;
+        const existingTokens = isLong ? longTokens : shortTokens;
+        if (existingTokens.some((t) => t.symbol === selectedToken))
+            return;
+        set((prev) => {
+            if (index >= existingTokens.length) {
+                const newToken = { symbol: selectedToken, weight: 1 };
+                if (isLong) {
+                    const updatedLongTokens = [...prev.longTokens, newToken];
+                    const longTotal = updatedLongTokens.reduce((s, t) => s + t.weight, 0);
+                    const shortTotal = prev.shortTokens.reduce((s, t) => s + t.weight, 0);
+                    const isWeightBalanced = longTotal + shortTotal === 100;
+                    return {
+                        ...prev,
+                        longTokens: updatedLongTokens,
+                        isWeightBalanced,
+                    };
+                }
+                const updatedShortTokens = [...prev.shortTokens, newToken];
+                const longTotal = prev.longTokens.reduce((s, t) => s + t.weight, 0);
+                const shortTotal = updatedShortTokens.reduce((s, t) => s + t.weight, 0);
+                const isWeightBalanced = longTotal + shortTotal === 100;
+                return {
+                    ...prev,
+                    shortTokens: updatedShortTokens,
+                    isWeightBalanced,
+                };
+            }
+            else {
+                if (isLong) {
+                    const updated = [...prev.longTokens];
+                    updated[index] = { ...updated[index], symbol: selectedToken };
+                    return { ...prev, longTokens: updated };
+                }
+                else {
+                    const updated = [...prev.shortTokens];
+                    updated[index] = { ...updated[index], symbol: selectedToken };
+                    return { ...prev, shortTokens: updated };
+                }
+            }
+        });
+    },
+    resetToDefaults: () => set((prev) => ({ ...prev, ...DEFAULT_STATE })),
+}));
+
+const useHyperliquidNativeWebSocket = ({ address, }) => {
     const { setWebData2, setAllMids, setActiveAssetData, upsertActiveAssetData, setCandleData, deleteCandleSymbol, deleteActiveAssetData, addCandleData } = useHyperliquidData();
+    const { candleInterval } = useUserSelection$1();
+    const longTokens = useUserSelection$1((s) => s.longTokens);
+    const shortTokens = useUserSelection$1((s) => s.shortTokens);
+    const selectedTokenSymbols = useMemo(() => ([...longTokens, ...shortTokens].map((t) => t.symbol)), [longTokens, shortTokens]);
     const [lastError, setLastError] = useState(null);
     const [subscribedAddress, setSubscribedAddress] = useState(null);
     const [subscribedTokens, setSubscribedTokens] = useState([]);
     const [subscribedCandleTokens, setSubscribedCandleTokens] = useState([]);
-    const [subscribedCandleInterval, setSubscribedCandleInterval] = useState(null);
+    const prevCandleIntervalRef = useRef(null);
     const pingIntervalRef = useRef(null);
     const { readyState, sendJsonMessage } = useWebSocket('wss://api.hyperliquid.xyz/ws', {
         shouldReconnect: () => true,
@@ -6726,7 +6852,7 @@ const useHyperliquidNativeWebSocket = ({ address, tokens = [], candleInterval =
                             break;
                         case 'candle':
                             const candleDataItem = response.data;
-                            addCandleData(candleDataItem.c, candleDataItem);
+                            addCandleData(candleDataItem.s, candleDataItem);
                             break;
                         default:
                             console.warn(`[HyperLiquid WS] Unknown channel: ${response.channel}`);
@@ -6808,8 +6934,9 @@ const useHyperliquidNativeWebSocket = ({ address, tokens = [], candleInterval =
     useEffect(() => {
         if (!isConnected || !address)
             return;
-        const tokensToSubscribe = tokens.filter(token => token && !subscribedTokens.includes(token));
-        const tokensToUnsubscribe = subscribedTokens.filter(token => !tokens.includes(token));
+        const effectiveTokens = selectedTokenSymbols;
+        const tokensToSubscribe = effectiveTokens.filter((token) => token && !subscribedTokens.includes(token));
+        const tokensToUnsubscribe = subscribedTokens.filter((token) => !effectiveTokens.includes(token));
         // Unsubscribe from tokens no longer in the list
         tokensToUnsubscribe.forEach(token => {
             const unsubscribeMessage = {
@@ -6835,34 +6962,36 @@ const useHyperliquidNativeWebSocket = ({ address, tokens = [], candleInterval =
             sendJsonMessage(subscribeMessage);
         });
         if (tokensToSubscribe.length > 0 || tokensToUnsubscribe.length > 0) {
-            setSubscribedTokens(tokens.filter(token => token));
-            tokensToSubscribe.forEach(token => deleteActiveAssetData(token));
+            setSubscribedTokens(effectiveTokens.filter((token) => token));
+            tokensToSubscribe.forEach((token) => deleteActiveAssetData(token));
         }
-    }, [isConnected, address, tokens, subscribedTokens, sendJsonMessage, setActiveAssetData]);
+    }, [isConnected, address, selectedTokenSymbols, subscribedTokens, sendJsonMessage, setActiveAssetData]);
     // Handle candle subscriptions for tokens and interval changes
     useEffect(() => {
         if (!isConnected)
             return;
+        const effectiveTokens = selectedTokenSymbols;
         // Unsubscribe from previous candle subscriptions if interval changed
-        if (subscribedCandleInterval && subscribedCandleInterval !== candleInterval) {
+        const prevInterval = prevCandleIntervalRef.current;
+        if (prevInterval && prevInterval !== candleInterval) {
             subscribedCandleTokens.forEach(token => {
                 const unsubscribeMessage = {
                     method: 'unsubscribe',
                     subscription: {
                         type: 'candle',
                         coin: token,
-                        interval: subscribedCandleInterval,
+                        interval: prevInterval,
                     },
                 };
                 sendJsonMessage(unsubscribeMessage);
             });
-            setCandleData({});
+            setCandleData(new Map());
             setSubscribedCandleTokens([]);
         }
-        const tokensToSubscribe = tokens.filter(token => token && !subscribedCandleTokens.includes(token));
-        const tokensToUnsubscribe = subscribedCandleTokens.filter(token => !tokens.includes(token));
+        const tokensToSubscribe = effectiveTokens.filter((token) => token && !subscribedCandleTokens.includes(token));
+        const tokensToUnsubscribe = subscribedCandleTokens.filter((token) => !effectiveTokens.includes(token));
         // Unsubscribe from tokens no longer in the list
-        tokensToUnsubscribe.forEach(token => {
+        tokensToUnsubscribe.forEach((token) => {
             const unsubscribeMessage = {
                 method: 'unsubscribe',
                 subscription: {
@@ -6874,7 +7003,7 @@ const useHyperliquidNativeWebSocket = ({ address, tokens = [], candleInterval =
             sendJsonMessage(unsubscribeMessage);
         });
         // Subscribe to new tokens
-        tokensToSubscribe.forEach(token => {
+        tokensToSubscribe.forEach((token) => {
             const subscribeMessage = {
                 method: 'subscribe',
                 subscription: {
@@ -6886,12 +7015,12 @@ const useHyperliquidNativeWebSocket = ({ address, tokens = [], candleInterval =
             sendJsonMessage(subscribeMessage);
         });
         // Update subscribed state
-        if (tokensToSubscribe.length > 0 || tokensToUnsubscribe.length > 0 || subscribedCandleInterval !== candleInterval) {
-            setSubscribedCandleTokens(tokens.filter(token => token));
-            setSubscribedCandleInterval(candleInterval);
-            tokensToUnsubscribe.forEach(token => deleteCandleSymbol(token));
+        if (tokensToSubscribe.length > 0 || tokensToUnsubscribe.length > 0 || prevInterval !== candleInterval) {
+            setSubscribedCandleTokens(effectiveTokens.filter((token) => token));
+            prevCandleIntervalRef.current = candleInterval;
+            tokensToUnsubscribe.forEach((token) => deleteCandleSymbol(token));
         }
-    }, [isConnected, tokens, candleInterval, subscribedCandleTokens, subscribedCandleInterval, sendJsonMessage, setCandleData]);
+    }, [isConnected, selectedTokenSymbols, candleInterval, subscribedCandleTokens, sendJsonMessage, setCandleData]);
     return {
         connectionStatus: readyState,
         isConnected,
@@ -7400,138 +7529,6 @@ const useAccountSummary = () => {
     return { data: calculated, isLoading };
 };
 
-const DEFAULT_STATE = {
-    longTokens: [
-        { symbol: "HYPE", weight: 25 },
-        { symbol: "BTC", weight: 25 },
-    ],
-    shortTokens: [
-        { symbol: "AVAX", weight: 10 },
-        { symbol: "SEI", weight: 10 },
-        { symbol: "ADA", weight: 10 },
-        { symbol: "TRUMP", weight: 10 },
-        { symbol: "SUI", weight: 10 },
-    ],
-    openTokenSelector: false,
-    selectorConfig: null,
-    openConflictModal: false,
-    conflicts: [],
-    candleInterval: "1h",
-};
-const useUserSelection$1 = create((set, get) => ({
-    ...DEFAULT_STATE,
-    setLongTokens: (tokens) => set((state) => ({ ...state, longTokens: tokens })),
-    setShortTokens: (tokens) => set((state) => ({ ...state, shortTokens: tokens })),
-    setOpenTokenSelector: (open) => set((state) => ({ ...state, openTokenSelector: open })),
-    setSelectorConfig: (config) => set((state) => ({ ...state, selectorConfig: config })),
-    setOpenConflictModal: (open) => set((state) => ({ ...state, openConflictModal: open })),
-    setConflicts: (conflicts) => set((state) => ({ ...state, conflicts })),
-    setCandleInterval: (interval) => set((state) => ({ ...state, candleInterval: interval })),
-    updateTokenWeight: (isLong, index, newWeight) => {
-        const clampedWeight = Math.max(1, Math.min(100, newWeight));
-        set((prev) => {
-            var _a, _b;
-            const currentLongTotal = prev.longTokens.reduce((sum, t) => sum + t.weight, 0);
-            const currentShortTotal = prev.shortTokens.reduce((sum, t) => sum + t.weight, 0);
-            if (isLong) {
-                const oldWeight = ((_a = prev.longTokens[index]) === null || _a === void 0 ? void 0 : _a.weight) || 0;
-                const weightDiff = clampedWeight - oldWeight;
-                const newLongTotal = currentLongTotal + weightDiff;
-                if (newLongTotal + currentShortTotal > 100) {
-                    const maxAllowedWeight = Math.max(1, 100 - currentShortTotal - (currentLongTotal - oldWeight));
-                    const updated = [...prev.longTokens];
-                    updated[index] = { ...updated[index], weight: maxAllowedWeight };
-                    return { ...prev, longTokens: updated };
-                }
-                else {
-                    const updated = [...prev.longTokens];
-                    updated[index] = { ...updated[index], weight: clampedWeight };
-                    return { ...prev, longTokens: updated };
-                }
-            }
-            else {
-                const oldWeight = ((_b = prev.shortTokens[index]) === null || _b === void 0 ? void 0 : _b.weight) || 0;
-                const weightDiff = clampedWeight - oldWeight;
-                const newShortTotal = currentShortTotal + weightDiff;
-                if (currentLongTotal + newShortTotal > 100) {
-                    const maxAllowedWeight = Math.max(1, 100 - currentLongTotal - (currentShortTotal - oldWeight));
-                    const updated = [...prev.shortTokens];
-                    updated[index] = { ...updated[index], weight: maxAllowedWeight };
-                    return { ...prev, shortTokens: updated };
-                }
-                else {
-                    const updated = [...prev.shortTokens];
-                    updated[index] = { ...updated[index], weight: clampedWeight };
-                    return { ...prev, shortTokens: updated };
-                }
-            }
-        });
-    },
-    addToken: (isLong) => {
-        const currentTokens = isLong ? get().longTokens : get().shortTokens;
-        const newIndex = currentTokens.length;
-        set((prev) => ({
-            ...prev,
-            selectorConfig: { isLong, index: newIndex },
-            openTokenSelector: true,
-        }));
-    },
-    removeToken: (isLong, index) => {
-        set((prev) => {
-            if (isLong) {
-                const updated = prev.longTokens.filter((_, i) => i !== index);
-                return { ...prev, longTokens: updated };
-            }
-            else {
-                const updated = prev.shortTokens.filter((_, i) => i !== index);
-                return { ...prev, shortTokens: updated };
-            }
-        });
-    },
-    handleTokenSelect: (selectedToken) => {
-        const { selectorConfig, longTokens, shortTokens } = get();
-        if (!selectorConfig)
-            return;
-        const { isLong, index } = selectorConfig;
-        const existingTokens = isLong ? longTokens : shortTokens;
-        if (existingTokens.some((t) => t.symbol === selectedToken))
-            return;
-        set((prev) => {
-            const longTotal = prev.longTokens.reduce((s, t) => s + t.weight, 0);
-            const shortTotal = prev.shortTokens.reduce((s, t) => s + t.weight, 0);
-            const currentTotal = longTotal + shortTotal;
-            if (index >= existingTokens.length) {
-                const maxAvailableWeight = Math.max(1, 100 - currentTotal);
-                const safeWeight = Math.min(20, maxAvailableWeight);
-                const newToken = { symbol: selectedToken, weight: safeWeight };
-                if (isLong) {
-                    return {
-                        ...prev,
-                        longTokens: [...prev.longTokens, newToken],
-                    };
-                }
-                return {
-                    ...prev,
-                    shortTokens: [...prev.shortTokens, newToken],
-                };
-            }
-            else {
-                if (isLong) {
-                    const updated = [...prev.longTokens];
-                    updated[index] = { ...updated[index], symbol: selectedToken };
-                    return { ...prev, longTokens: updated };
-                }
-                else {
-                    const updated = [...prev.shortTokens];
-                    updated[index] = { ...updated[index], symbol: selectedToken };
-                    return { ...prev, shortTokens: updated };
-                }
-            }
-        });
-    },
-    resetToDefaults: () => set((prev) => ({ ...prev, ...DEFAULT_STATE })),
-}));
-
 // Re-expose as a React hook without Zustand's selector signature
 const useUserSelection = () => {
     return useUserSelection$1();
@@ -7842,6 +7839,25 @@ const useTokenSelectionMetadata = () => {
 const createKey = (symbol, interval) => {
     return `${symbol}-${interval}`;
 };
+const getIntervalSeconds = (interval) => {
+    switch (interval) {
+        case "1m": return 60;
+        case "3m": return 3 * 60;
+        case "5m": return 5 * 60;
+        case "15m": return 15 * 60;
+        case "30m": return 30 * 60;
+        case "1h": return 60 * 60;
+        case "2h": return 2 * 60 * 60;
+        case "4h": return 4 * 60 * 60;
+        case "8h": return 8 * 60 * 60;
+        case "12h": return 12 * 60 * 60;
+        case "1d": return 24 * 60 * 60;
+        case "3d": return 3 * 24 * 60 * 60;
+        case "1w": return 7 * 24 * 60 * 60;
+        case "1M": return 30 * 24 * 60 * 60; // Approximate month
+        default: return 60;
+    }
+};
 const useHistoricalPriceDataStore = create((set, get) => ({
     historicalPriceData: {},
     loadingTokens: new Set(),
@@ -7891,8 +7907,11 @@ const useHistoricalPriceDataStore = create((set, get) => ({
         const tokenData = historicalPriceData[key];
         if (!tokenData || tokenData.oldestTime === null || tokenData.latestTime === null)
             return false;
-        // Check if our cached data covers the requested time range
-        return tokenData.oldestTime <= startTime && tokenData.latestTime >= endTime;
+        const intervalMilisecond = getIntervalSeconds(interval) * 1000;
+        const hasStartCoverage = tokenData.oldestTime <= startTime;
+        const hasEndCoverage = tokenData.latestTime >= endTime ||
+            (tokenData.latestTime + intervalMilisecond >= endTime);
+        return hasStartCoverage && hasEndCoverage;
     },
     getHistoricalPriceData: (symbol, interval, startTime, endTime) => {
         const { historicalPriceData } = get();
@@ -7900,8 +7919,7 @@ const useHistoricalPriceDataStore = create((set, get) => ({
         const tokenData = historicalPriceData[key];
         if (!tokenData)
             return [];
-        // Filter candles within the requested time range
-        return tokenData.candles.filter(candle => candle.t >= startTime && candle.T <= endTime);
+        return tokenData.candles.filter(candle => candle.t >= startTime && candle.t < endTime);
     },
     setTokenLoading: (symbol, loading) => {
         set(state => {
@@ -7948,8 +7966,6 @@ const useHistoricalPriceData = () => {
     const longTokens = useUserSelection$1((state) => state.longTokens);
     const shortTokens = useUserSelection$1((state) => state.shortTokens);
     const candleInterval = useUserSelection$1((state) => state.candleInterval);
-    // Get real-time candle data from WebSocket
-    const candleData = useHyperliquidData((state) => state.candleData);
     // Historical price data store
     const { addHistoricalPriceData, hasHistoricalPriceData: storeHasData, getHistoricalPriceData: storeGetData, setTokenLoading, isTokenLoading, removeTokenPriceData, clearData, } = useHistoricalPriceDataStore();
     // Track previous tokens and interval to detect changes
@@ -7980,32 +7996,20 @@ const useHistoricalPriceData = () => {
         prevTokensRef.current = currentTokens;
         prevIntervalRef.current = candleInterval;
     }, [longTokens, shortTokens, candleInterval, removeTokenPriceData, clearData, getAllTokens]);
-    useEffect(() => {
-        if (!candleData)
-            return;
-        const allTokenSymbols = new Set(getAllTokens().map(token => token.symbol));
-        Object.entries(candleData).forEach(([symbol, candle]) => {
-            if (allTokenSymbols.has(symbol)) {
-                if (candle.i === candleInterval) {
-                    addHistoricalPriceData(symbol, candleInterval, [candle], { start: candle.t, end: candle.T });
-                }
-            }
-        });
-    }, [candleData, getAllTokens, candleInterval, addHistoricalPriceData]);
-    const hasHistoricalPriceData = useCallback((startTime, endTime) => {
+    const hasHistoricalPriceData = useCallback((startTime, endTime, interval) => {
         const allTokens = getAllTokens();
         if (allTokens.length === 0)
             return false;
-        return allTokens.every(token => storeHasData(token.symbol, candleInterval, startTime, endTime));
-    }, [getAllTokens, candleInterval, storeHasData]);
-    const getHistoricalPriceData = useCallback((startTime, endTime) => {
+        return allTokens.every(token => storeHasData(token.symbol, interval, startTime, endTime));
+    }, [getAllTokens, storeHasData]);
+    const getHistoricalPriceData = useCallback((startTime, endTime, interval) => {
         const allTokens = getAllTokens();
         const result = {};
         allTokens.forEach(token => {
-            result[token.symbol] = storeGetData(token.symbol, candleInterval, startTime, endTime);
+            result[token.symbol] = storeGetData(token.symbol, interval, startTime, endTime);
         });
         return result;
-    }, [getAllTokens, candleInterval, storeGetData]);
+    }, [getAllTokens, storeGetData]);
     const isLoading = useCallback((symbol) => {
         if (symbol) {
             return isTokenLoading(symbol);
@@ -8013,16 +8017,16 @@ const useHistoricalPriceData = () => {
         const allTokens = getAllTokens();
         return allTokens.some(token => isTokenLoading(token.symbol));
     }, [getAllTokens, isTokenLoading]);
-    const fetchHistoricalPriceData = useCallback(async (startTime, endTime, callback) => {
+    const fetchHistoricalPriceData = useCallback(async (startTime, endTime, interval, callback) => {
         const allTokens = getAllTokens();
         if (allTokens.length === 0) {
             const emptyResult = {};
             callback === null || callback === void 0 ? void 0 : callback(emptyResult);
             return emptyResult;
         }
-        const tokensToFetch = allTokens.filter(token => !storeHasData(token.symbol, candleInterval, startTime, endTime));
+        const tokensToFetch = allTokens.filter(token => !storeHasData(token.symbol, interval, startTime, endTime));
         if (tokensToFetch.length === 0) {
-            const cachedData = getHistoricalPriceData(startTime, endTime);
+            const cachedData = getHistoricalPriceData(startTime, endTime, interval);
             callback === null || callback === void 0 ? void 0 : callback(cachedData);
             return cachedData;
         }
@@ -8032,8 +8036,8 @@ const useHistoricalPriceData = () => {
         try {
             const fetchPromises = tokensToFetch.map(async (token) => {
                 try {
-                    const response = await client.fetchHistoricalCandles(token.symbol, startTime, endTime, candleInterval);
-                    addHistoricalPriceData(token.symbol, candleInterval, response.data, { start: startTime, end: endTime });
+                    const response = await client.fetchHistoricalCandles(token.symbol, startTime, endTime, interval);
+                    addHistoricalPriceData(token.symbol, interval, response.data, { start: startTime, end: endTime });
                     return { symbol: token.symbol, candles: response.data, success: true };
                 }
                 catch (error) {
@@ -8042,7 +8046,7 @@ const useHistoricalPriceData = () => {
                 }
             });
             await Promise.all(fetchPromises);
-            const allData = getHistoricalPriceData(startTime, endTime);
+            const allData = getHistoricalPriceData(startTime, endTime, interval);
             callback === null || callback === void 0 ? void 0 : callback(allData);
             return allData;
         }
@@ -8181,7 +8185,7 @@ const getCompleteTimestamps = (candleLookups, requiredSymbols) => {
  */
 const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
     var _a, _b;
-    if (longTokens.length === 0 || shortTokens.length === 0) {
+    if (longTokens.length === 0 && shortTokens.length === 0) {
         return [];
     }
     // Create efficient lookup maps once
@@ -8274,17 +8278,132 @@ const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
 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 } = useHistoricalPriceData();
-    const fetchBasketCandles = useCallback(async (startTime, endTime) => {
-        const tokenCandles = await fetchHistoricalPriceData(startTime, endTime);
+    const fetchBasketCandles = useCallback(async (startTime, endTime, interval) => {
+        const tokenCandles = await fetchHistoricalPriceData(startTime, endTime, interval);
         const basket = computeBasketCandles(longTokens, shortTokens, tokenCandles);
         return basket;
     }, [fetchHistoricalPriceData, longTokens, shortTokens]);
     // Aggregate loading across selected tokens via underlying hook
     const isLoading = tokenLoading();
+    // Realtime listeners management
+    const listenersRef = useRef(new Map());
+    const lastEmittedRef = useRef(null);
+    const addRealtimeListener = useCallback((cb) => {
+        const id = Math.random().toString(36).slice(2);
+        listenersRef.current.set(id, cb);
+        return id;
+    }, []);
+    const removeRealtimeListener = useCallback((id) => {
+        listenersRef.current.delete(id);
+    }, []);
+    // Helper: compute weighted bar from latest snapshot if all tokens aligned
+    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 = {};
+        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) {
+                t = c.t;
+                T = c.T;
+            }
+            else if (c.t !== t || c.T !== T) {
+                return null; // not aligned yet
+            }
+        }
+        // Compute weighted OHLC similar to computeBasketCandles
+        let longOpen = 1, longHigh = 1, longLow = 1, longClose = 1;
+        let shortOpen = 1, shortHigh = 1, shortLow = 1, shortClose = 1;
+        let totalVolume = 0;
+        let totalTrades = 0;
+        for (const token of longTokens) {
+            const c = snapshot[token.symbol];
+            if (!c)
+                return null;
+            const w = token.weight / 100;
+            const o = parseFloat(c.o), h = parseFloat(c.h), l = parseFloat(c.l), cl = parseFloat(c.c);
+            if (!(o > 0 && h > 0 && l > 0 && cl > 0))
+                return null;
+            longOpen *= Math.pow(o, w);
+            longHigh *= Math.pow(h, w);
+            longLow *= Math.pow(l, w);
+            longClose *= Math.pow(cl, w);
+            totalVolume += parseFloat(c.v);
+            totalTrades += c.n;
+        }
+        for (const token of shortTokens) {
+            const c = snapshot[token.symbol];
+            if (!c)
+                return null;
+            const w = -(token.weight / 100);
+            const o = parseFloat(c.o), h = parseFloat(c.h), l = parseFloat(c.l), cl = parseFloat(c.c);
+            if (!(o > 0 && h > 0 && l > 0 && cl > 0))
+                return null;
+            shortOpen *= Math.pow(o, w);
+            shortHigh *= Math.pow(h, w);
+            shortLow *= Math.pow(l, w);
+            shortClose *= Math.pow(cl, w);
+            totalVolume += parseFloat(c.v);
+            totalTrades += c.n;
+        }
+        if (t === null || T === null)
+            return null;
+        const weighted = {
+            t,
+            T,
+            o: longOpen * shortOpen,
+            h: longHigh * shortHigh,
+            l: longLow * shortLow,
+            c: longClose * shortClose,
+            v: totalVolume,
+            n: totalTrades,
+        };
+        return weighted;
+    }, [candleData, longTokens, shortTokens]);
+    // Emit realtime bars when aligned snapshot updates
+    useEffect(() => {
+        if (listenersRef.current.size === 0)
+            return;
+        const bar = computeRealtimeBar();
+        if (!bar)
+            return;
+        lastEmittedRef.current = bar.t;
+        const tvBar = {
+            time: bar.t,
+            open: bar.o,
+            high: bar.h,
+            low: bar.l,
+            close: bar.c,
+            volume: bar.v,
+        };
+        listenersRef.current.forEach((cb) => {
+            try {
+                cb(tvBar);
+            }
+            catch (e) { /* noop */ }
+        });
+    }, [computeRealtimeBar]);
     return {
         fetchBasketCandles,
         isLoading,
+        addRealtimeListener,
+        removeRealtimeListener,
     };
 };
 
@@ -8330,4 +8449,49 @@ class ConflictDetector {
     }
 }
 
-export { AccountSummaryCalculator, ConflictDetector, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, TokenMetadataExtractor, calculateWeightedRatio, computeBasketCandles, createCandleLookups, PearHyperliquidClient as default, getCompleteTimestamps, useAccountSummary, useAddress, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };
+/**
+ * Maps TradingView ResolutionString to CandleInterval
+ */
+function mapTradingViewIntervalToCandleInterval(interval) {
+    switch (interval) {
+        case '1': return '1m';
+        case '3': return '3m';
+        case '5': return '5m';
+        case '15': return '15m';
+        case '30': return '30m';
+        case '60': return '1h';
+        case '120': return '2h';
+        case '240': return '4h';
+        case '480': return '8h';
+        case '720': return '12h';
+        case '1D': return '1d';
+        case '3D': return '3d';
+        case '1W': return '1w';
+        case '1M': return '1M';
+        default: return '1h'; // fallback to 1 hour
+    }
+}
+/**
+ * Maps CandleInterval to TradingView ResolutionString
+ */
+function mapCandleIntervalToTradingViewInterval(interval) {
+    switch (interval) {
+        case '1m': return '1';
+        case '3m': return '3';
+        case '5m': return '5';
+        case '15m': return '15';
+        case '30m': return '30';
+        case '1h': return '60';
+        case '2h': return '120';
+        case '4h': return '240';
+        case '8h': return '480';
+        case '12h': return '720';
+        case '1d': return '1D';
+        case '3d': return '3D';
+        case '1w': return '1W';
+        case '1M': return '1M';
+        default: return '60'; // fallback to 1 hour
+    }
+}
+
+export { AccountSummaryCalculator, ConflictDetector, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, TokenMetadataExtractor, calculateWeightedRatio, computeBasketCandles, createCandleLookups, PearHyperliquidClient as default, getCompleteTimestamps, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, useAccountSummary, useAddress, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };

package/dist/store/userSelection.d.ts

@@ -8,6 +8,7 @@ interface UserSelectionState {
     openConflictModal: boolean;
     conflicts: TokenConflict[];
     candleInterval: CandleInterval;
+    isWeightBalanced: boolean;
     setLongTokens: (tokens: TokenSelection[]) => void;
     setShortTokens: (tokens: TokenSelection[]) => void;
     setOpenTokenSelector: (open: boolean) => void;

package/dist/types.d.ts

@@ -635,7 +635,7 @@ export interface CandleData {
  * Candle chart data organized by symbol only
  * Since new candles always have latest timestamp, no need to store per interval
  */
-export type CandleChartData = Record<string, CandleData>;
+export type CandleChartData = Map<string, CandleData>;
 /**
  * Historical candle data request
  */

package/dist/utils/chart-interval-mappers.d.ts

@@ -0,0 +1,9 @@
+import type { CandleInterval } from '../types';
+/**
+ * Maps TradingView ResolutionString to CandleInterval
+ */
+export declare function mapTradingViewIntervalToCandleInterval(interval: string): CandleInterval;
+/**
+ * Maps CandleInterval to TradingView ResolutionString
+ */
+export declare function mapCandleIntervalToTradingViewInterval(interval: CandleInterval): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/hyperliquid-sdk",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "React SDK for Pear Protocol Hyperliquid API integration",
   "type": "module",
   "main": "dist/index.js",
@@ -18,6 +18,8 @@
   "scripts": {
     "build": "rollup -c",
     "dev": "rollup -c -w",
+    "copy-watch": "nodemon --watch dist --exec \"npm run copy-to-node-modules\"",
+    "copy-to-node-modules": "cp -r dist/* ../node_modules/@pear-protocol/hyperliquid-sdk/dist/",
     "type-check": "tsc --noEmit",
     "clean": "rimraf dist"
   },
@@ -35,9 +37,10 @@
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^11.0.0",
     "@types/react": "^18.0.0",
+    "concurrently": "^9.2.1",
+    "esbuild": "^0.25.9",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "esbuild": "^0.25.9",
     "rimraf": "^5.0.0",
     "rollup": "^3.0.0",
     "rollup-plugin-dts": "^6.0.0",