@pear-protocol/hyperliquid-sdk 0.1.4 → 0.1.6

package/dist/hooks/useBasketCandles.d.ts

@@ -3,6 +3,7 @@ export interface UseBasketCandlesReturn {
     fetchBasketCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<CandleData[]>;
     fetchPerformanceCandles: (startTime: number, endTime: number, interval: CandleInterval, symbol: string) => Promise<CandleData[]>;
     fetchOverallPerformanceCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<CandleData[]>;
+    getEffectiveDataBoundary: (interval: CandleInterval) => number | null;
     isLoading: boolean;
     addRealtimeListener: (cb: RealtimeBarsCallback) => string;
     removeRealtimeListener: (id: string) => void;

package/dist/hooks/useHistoricalPriceData.d.ts

@@ -4,6 +4,7 @@ export interface UseHistoricalPriceDataReturn {
     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[]>;
+    getEffectiveDataBoundary: (interval: CandleInterval) => number | null;
     getAllHistoricalPriceData(): Promise<Record<string, TokenHistoricalPriceData>>;
     isLoading: (symbol?: string) => boolean;
     clearCache: () => void;

package/dist/index.d.ts

@@ -1068,6 +1068,8 @@ interface TokenHistoricalPriceData {
     candles: CandleData[];
     oldestTime: number | null;
     latestTime: number | null;
+    requestedRanges: HistoricalRange[];
+    noDataBefore: number | null;
 }
 interface HistoricalPriceDataState {
     historicalPriceData: Record<string, TokenHistoricalPriceData>;
@@ -1075,6 +1077,7 @@ interface HistoricalPriceDataState {
     addHistoricalPriceData: (symbol: string, interval: CandleInterval, candles: CandleData[], range: HistoricalRange) => void;
     hasHistoricalPriceData: (symbol: string, interval: CandleInterval, startTime: number, endTime: number) => boolean;
     getHistoricalPriceData: (symbol: string, interval: CandleInterval, startTime: number, endTime: number) => CandleData[];
+    getEffectiveDataBoundary: (symbols: string[], interval: CandleInterval) => number | null;
     setTokenLoading: (symbol: string, loading: boolean) => void;
     isTokenLoading: (symbol: string) => boolean;
     removeTokenPriceData: (symbol: string, interval: CandleInterval) => void;
@@ -1086,6 +1089,7 @@ interface UseHistoricalPriceDataReturn {
     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[]>;
+    getEffectiveDataBoundary: (interval: CandleInterval) => number | null;
     getAllHistoricalPriceData(): Promise<Record<string, TokenHistoricalPriceData>>;
     isLoading: (symbol?: string) => boolean;
     clearCache: () => void;
@@ -1096,6 +1100,7 @@ interface UseBasketCandlesReturn {
     fetchBasketCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<CandleData[]>;
     fetchPerformanceCandles: (startTime: number, endTime: number, interval: CandleInterval, symbol: string) => Promise<CandleData[]>;
     fetchOverallPerformanceCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<CandleData[]>;
+    getEffectiveDataBoundary: (interval: CandleInterval) => number | null;
     isLoading: boolean;
     addRealtimeListener: (cb: RealtimeBarsCallback) => string;
     removeRealtimeListener: (id: string) => void;

package/dist/index.js

@@ -1819,6 +1819,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(),
@@ -1829,6 +1845,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,
@@ -1837,7 +1855,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
                         }
                     }
                 };
@@ -1849,6 +1869,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,
@@ -1856,7 +1886,9 @@ const useHistoricalPriceDataStore = create((set, get) => ({
                         ...existing,
                         candles: mergedCandles,
                         oldestTime,
-                        latestTime
+                        latestTime,
+                        requestedRanges: mergedRanges,
+                        noDataBefore
                     }
                 }
             };
@@ -1866,8 +1898,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 ||
@@ -1882,6 +1930,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);
@@ -6012,7 +6081,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);
@@ -6065,6 +6134,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) {
@@ -6122,6 +6196,7 @@ const useHistoricalPriceData = () => {
         hasHistoricalPriceData,
         getAllHistoricalPriceData,
         getHistoricalPriceData,
+        getEffectiveDataBoundary,
         isLoading,
         clearCache,
     };
@@ -6318,7 +6393,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);
@@ -6518,6 +6593,7 @@ const useBasketCandles = () => {
         fetchBasketCandles,
         fetchPerformanceCandles,
         fetchOverallPerformanceCandles,
+        getEffectiveDataBoundary,
         isLoading,
         addRealtimeListener,
         removeRealtimeListener,

package/dist/store/historicalPriceDataStore.d.ts

@@ -9,6 +9,8 @@ interface TokenHistoricalPriceData {
     candles: CandleData[];
     oldestTime: number | null;
     latestTime: number | null;
+    requestedRanges: HistoricalRange[];
+    noDataBefore: number | null;
 }
 interface HistoricalPriceDataState {
     historicalPriceData: Record<string, TokenHistoricalPriceData>;
@@ -16,6 +18,7 @@ interface HistoricalPriceDataState {
     addHistoricalPriceData: (symbol: string, interval: CandleInterval, candles: CandleData[], range: HistoricalRange) => void;
     hasHistoricalPriceData: (symbol: string, interval: CandleInterval, startTime: number, endTime: number) => boolean;
     getHistoricalPriceData: (symbol: string, interval: CandleInterval, startTime: number, endTime: number) => CandleData[];
+    getEffectiveDataBoundary: (symbols: string[], interval: CandleInterval) => number | null;
     setTokenLoading: (symbol: string, loading: boolean) => void;
     isTokenLoading: (symbol: string) => boolean;
     removeTokenPriceData: (symbol: string, interval: CandleInterval) => void;

package/package.json

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