@pear-protocol/hyperliquid-sdk 0.0.12 → 0.0.15

package/dist/provider.d.ts

@@ -3,25 +3,10 @@ import { ReadyState } from 'react-use-websocket';
 import { PearHyperliquidClient } from './client';
 import { PearHyperliquidConfig } from './types';
 import { PearMigrationSDK } from './migration-sdk';
-import type { RawPositionDto, OpenLimitOrderDto, AccountSummaryResponseDto, WebData2Response, WsAllMidsData, TradeHistoryDataDto, TokenSelection, TokenConflict } from './types';
-interface WebSocketData {
-    tradeHistories: TradeHistoryDataDto[] | null;
-    openPositions: RawPositionDto[] | null;
-    openOrders: OpenLimitOrderDto[] | null;
-    accountSummary: AccountSummaryResponseDto | null;
-}
 export interface TokenSelectorConfig {
     isLong: boolean;
     index: number;
 }
-interface TokenSelectionState {
-    longTokens: TokenSelection[];
-    shortTokens: TokenSelection[];
-    openTokenSelector: boolean;
-    selectorConfig: TokenSelectorConfig | null;
-    openConflictModal: boolean;
-    conflicts: TokenConflict[];
-}
 export interface PearHyperliquidContextType {
     client: PearHyperliquidClient;
     migrationSDK: PearMigrationSDK;
@@ -29,15 +14,10 @@ export interface PearHyperliquidContextType {
     setAddress: (address: string | null) => void;
     connectionStatus: ReadyState;
     isConnected: boolean;
-    data: WebSocketData;
     lastError: string | null;
     nativeConnectionStatus: ReadyState;
     nativeIsConnected: boolean;
     nativeLastError: string | null;
-    webData2: WebData2Response | null;
-    allMids: WsAllMidsData | null;
-    tokenSelection: TokenSelectionState;
-    setTokenSelection: React.Dispatch<React.SetStateAction<TokenSelectionState>>;
 }
 export declare const PearHyperliquidContext: React.Context<PearHyperliquidContextType | undefined>;
 interface PearHyperliquidProviderProps {

package/dist/store/historicalPriceDataStore.d.ts

@@ -0,0 +1,14 @@
+import type { CandleData, CandleInterval } from "../types";
+interface HistoricalRange {
+    start: number;
+    end: number;
+}
+interface TokenHistoricalPriceData {
+    symbol: string;
+    interval: CandleInterval;
+    candles: CandleData[];
+    oldestTime: number | null;
+    latestTime: number | null;
+}
+export declare const useHistoricalPriceDataStore: any;
+export type { HistoricalRange, TokenHistoricalPriceData };

package/dist/store/hyperliquidDataStore.d.ts

@@ -0,0 +1 @@
+export declare const useHyperliquidData: any;

package/dist/store/tokenSelectionMetadataStore.d.ts

@@ -0,0 +1,21 @@
+import type { ActiveAssetData, TokenSelection, TokenMetadata, WebData2Response, WsAllMidsData } from "../types";
+export interface TokenSelectionMetadataState {
+    isPriceDataReady: boolean;
+    isLoading: boolean;
+    longTokensMetadata: Record<string, TokenMetadata | null>;
+    shortTokensMetadata: Record<string, TokenMetadata | null>;
+    weightedRatio: number;
+    weightedRatio24h: number;
+    sumNetFunding: number;
+    maxLeverage: number;
+    minMargin: number;
+    leverageMatched: boolean;
+    recompute: (args: {
+        webData2: WebData2Response | null;
+        allMids: WsAllMidsData | null;
+        activeAssetData: Record<string, ActiveAssetData> | null;
+        longTokens: TokenSelection[];
+        shortTokens: TokenSelection[];
+    }) => void;
+}
+export declare const useTokenSelectionMetadataStore: any;

package/dist/store/userDataStore.d.ts

@@ -0,0 +1 @@
+export declare const useUserData: any;

package/dist/{hooks/useTokenSelection.d.ts → store/userSelection.d.ts}

@@ -1,33 +1,25 @@
-import type { TokenSelection, TokenConflict } from '../types';
-import { TokenSelectorConfig } from '../provider';
-export type { TokenSelectorConfig };
-export interface UseTokenSelectionReturn {
+import type { CandleInterval, TokenConflict, TokenSelection } from "../types";
+import type { TokenSelectorConfig } from "../provider";
+interface UserSelectionState {
     longTokens: TokenSelection[];
     shortTokens: TokenSelection[];
     openTokenSelector: boolean;
     selectorConfig: TokenSelectorConfig | null;
     openConflictModal: boolean;
     conflicts: TokenConflict[];
-    isLoading: boolean;
-    isPriceDataReady: boolean;
-    weightedRatio: number;
-    weightedRatio24h: number;
-    sumNetFunding: number;
-    maxLeverage: number;
-    minMargin: number;
+    candleInterval: CandleInterval;
     setLongTokens: (tokens: TokenSelection[]) => void;
     setShortTokens: (tokens: TokenSelection[]) => void;
-    updateTokenWeight: (isLong: boolean, index: number, newWeight: number) => void;
-    addToken: (isLong: boolean) => void;
-    removeToken: (isLong: boolean, index: number) => void;
-    handleTokenSelect: (selectedToken: string) => void;
     setOpenTokenSelector: (open: boolean) => void;
     setSelectorConfig: (config: TokenSelectorConfig | null) => void;
     setOpenConflictModal: (open: boolean) => void;
     setConflicts: (conflicts: TokenConflict[]) => void;
+    setCandleInterval: (interval: CandleInterval) => void;
+    updateTokenWeight: (isLong: boolean, index: number, newWeight: number) => void;
+    addToken: (isLong: boolean) => void;
+    removeToken: (isLong: boolean, index: number) => void;
+    handleTokenSelect: (selectedToken: string) => void;
     resetToDefaults: () => void;
 }
-/**
- * Hook to access token selection state using provider's WebSocket data
- */
-export declare const useTokenSelection: () => UseTokenSelectionReturn;
+export declare const useUserSelection: any;
+export type { UserSelectionState };

package/dist/types.d.ts

@@ -212,7 +212,7 @@ export type WebSocketConnectionState = 'connecting' | 'connected' | 'disconnecte
 /**
  * WebSocket channels
  */
-export type WebSocketChannel = 'trade-histories' | 'open-positions' | 'open-orders' | 'account-summary' | 'webData2' | 'allMids';
+export type WebSocketChannel = 'trade-histories' | 'open-positions' | 'open-orders' | 'account-summary' | 'webData2' | 'allMids' | 'activeAssetData';
 /**
  * WebSocket subscription message
  */
@@ -452,7 +452,8 @@ export interface UniverseAsset {
     name: string;
     szDecimals: number;
     maxLeverage: number;
-    onlyIsolated: boolean;
+    onlyIsolated?: boolean;
+    isDelisted?: boolean;
 }
 /**
  * WebData2 response structure
@@ -548,6 +549,24 @@ export interface RawPositionDto {
     longAssets: RawAssetDto[];
     shortAssets: RawAssetDto[];
 }
+/**
+ * Leverage information from activeAssetData
+ */
+export interface LeverageInfo {
+    type: string;
+    value: number;
+}
+/**
+ * Active asset data from WebSocket
+ */
+export interface ActiveAssetData {
+    user: string;
+    coin: string;
+    leverage: LeverageInfo;
+    maxTradeSzs: [string, string];
+    availableToTrade: [string, string];
+    markPx: string;
+}
 /**
  * Token metadata from WebData2 and AllMids
  */
@@ -562,6 +581,9 @@ export interface TokenMetadata {
     oraclePrice: number;
     openInterest: string;
     dayVolume: string;
+    leverage?: LeverageInfo;
+    maxTradeSzs?: [string, string];
+    availableToTrade?: [string, string];
 }
 /**
  * Enhanced token selection with weight and metadata for basket trading
@@ -569,7 +591,6 @@ export interface TokenMetadata {
 export interface TokenSelection {
     symbol: string;
     weight: number;
-    metadata?: TokenMetadata;
 }
 /**
  * Token conflict information for position conflicts
@@ -579,3 +600,56 @@ export interface TokenConflict {
     conflictType: 'long' | 'short';
     conflictMessage: string;
 }
+export interface AssetMarketData {
+    asset: AssetCtx;
+    universe: UniverseAsset;
+}
+/**
+ * Candle interval options
+ */
+export type CandleInterval = "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "8h" | "12h" | "1d" | "3d" | "1w" | "1M";
+/**
+ * Candle data structure from WebSocket
+ */
+export interface CandleData {
+    t: number;
+    T: number;
+    s: string;
+    i: string;
+    o: string;
+    c: string;
+    h: string;
+    l: string;
+    v: string;
+    n: number;
+}
+/**
+ * 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>;
+/**
+ * Historical candle data request
+ */
+export interface CandleSnapshotRequest {
+    req: {
+        coin: string;
+        startTime: number;
+        endTime: number;
+        interval: CandleInterval;
+    };
+    type: "candleSnapshot";
+}
+/**
+ * Weighted candle data for chart visualization
+ */
+export interface WeightedCandleData {
+    t: number;
+    T: number;
+    o: number;
+    c: number;
+    h: number;
+    l: number;
+    v: number;
+    n: number;
+}

package/dist/utils/basket-calculator.d.ts

@@ -0,0 +1,24 @@
+import type { CandleData, TokenSelection, WeightedCandleData } from '../types';
+/**
+ * Create efficient timestamp-based lookup maps for candle data
+ */
+export declare const createCandleLookups: (tokenCandles: Record<string, CandleData[]>) => Record<string, Map<number, CandleData>>;
+/**
+ * Calculate weighted ratio for a specific price type (open, high, low, close)
+ * Uses the formula: LONG_PRODUCT * SHORT_PRODUCT
+ * Where LONG_PRODUCT = ∏(PRICE^(WEIGHT/100)) for long tokens
+ * And SHORT_PRODUCT = ∏(PRICE^-(WEIGHT/100)) for short tokens
+ *
+ * Optimized version that uses Map lookups instead of Array.find()
+ */
+export declare const calculateWeightedRatio: (longTokens: TokenSelection[], shortTokens: TokenSelection[], candleLookups: Record<string, Map<number, CandleData>>, timestamp: number, priceType: "o" | "h" | "l" | "c") => number;
+/**
+ * Get all unique timestamps where ALL required symbols have data
+ * Optimized version that uses Map lookups
+ */
+export declare const getCompleteTimestamps: (candleLookups: Record<string, Map<number, CandleData>>, requiredSymbols: string[]) => number[];
+/**
+ * Compute basket candles from individual token candles using weighted ratios
+ * Optimized version that creates lookup maps once and reuses them
+ */
+export declare const computeBasketCandles: (longTokens: TokenSelection[], shortTokens: TokenSelection[], tokenCandles: Record<string, CandleData[]>) => WeightedCandleData[];

package/dist/utils/token-metadata-extractor.d.ts

@@ -1,4 +1,4 @@
-import type { WebData2Response, WsAllMidsData, TokenMetadata } from '../types';
+import type { WebData2Response, WsAllMidsData, TokenMetadata, ActiveAssetData } from '../types';
 /**
  * Extracts token metadata from WebData2 and AllMids data
  */
@@ -8,17 +8,19 @@ export declare class TokenMetadataExtractor {
      * @param symbol - Token symbol
      * @param webData2 - WebData2 response containing asset context and universe data
      * @param allMids - AllMids data containing current prices
+     * @param activeAssetData - Optional active asset data containing leverage information
      * @returns TokenMetadata or null if token not found
      */
-    static extractTokenMetadata(symbol: string, webData2: WebData2Response | null, allMids: WsAllMidsData | null): TokenMetadata | null;
+    static extractTokenMetadata(symbol: string, webData2: WebData2Response | null, allMids: WsAllMidsData | null, activeAssetData?: Record<string, ActiveAssetData> | null): TokenMetadata | null;
     /**
      * Extracts metadata for multiple tokens
      * @param symbols - Array of token symbols
      * @param webData2 - WebData2 response
      * @param allMids - AllMids data
+     * @param activeAssetData - Optional active asset data containing leverage information
      * @returns Record of symbol to TokenMetadata
      */
-    static extractMultipleTokensMetadata(symbols: string[], webData2: WebData2Response | null, allMids: WsAllMidsData | null): Record<string, TokenMetadata | null>;
+    static extractMultipleTokensMetadata(symbols: string[], webData2: WebData2Response | null, allMids: WsAllMidsData | null, activeAssetData?: Record<string, ActiveAssetData> | null): Record<string, TokenMetadata | null>;
     /**
      * Checks if token data is available in WebData2
      * @param symbol - Token symbol

package/dist/websocket.d.ts

@@ -1,20 +1,10 @@
 import { ReadyState } from 'react-use-websocket';
-import type { OpenLimitOrderDto, AccountSummaryResponseDto, RawPositionDto, TradeHistoryDataDto } from './types';
-interface WebSocketData {
-    tradeHistories: TradeHistoryDataDto[] | null;
-    openPositions: RawPositionDto[] | null;
-    openOrders: OpenLimitOrderDto[] | null;
-    accountSummary: AccountSummaryResponseDto | null;
-}
 export interface UseHyperliquidWebSocketProps {
     wsUrl: string;
     address: string | null;
 }
-export interface UseHyperliquidWebSocketReturn {
-    data: WebSocketData;
+export declare const useHyperliquidWebSocket: ({ wsUrl, address }: UseHyperliquidWebSocketProps) => {
     connectionStatus: ReadyState;
     isConnected: boolean;
     lastError: string | null;
-}
-export declare const useHyperliquidWebSocket: ({ wsUrl, address }: UseHyperliquidWebSocketProps) => UseHyperliquidWebSocketReturn;
-export {};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/hyperliquid-sdk",
-  "version": "0.0.12",
+  "version": "0.0.15",
   "description": "React SDK for Pear Protocol Hyperliquid API integration",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -15,12 +15,12 @@
     "clean": "rimraf dist"
   },
   "dependencies": {
-    "axios": "^1.6.0"
+    "react-use-websocket": "^4.8.1"
   },
   "peerDependencies": {
     "react": ">=16.8.0",
     "react-dom": ">=16.8.0",
-    "react-use-websocket": "^4.8.1"
+    "axios": "^1.6.0"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^25.0.0",

package/dist/hooks/useCalculatedAccountSummary.d.ts

@@ -1,5 +0,0 @@
-import type { AccountSummaryResponseDto, WebData2Response, OpenLimitOrderDto } from '../types';
-/**
- * Hook that calculates account summary by syncing platform data with HyperLiquid real-time data
- */
-export declare const useCalculatedAccountSummary: (platformAccountSummary: AccountSummaryResponseDto | null, platformOpenOrders: OpenLimitOrderDto[] | null, webData2: WebData2Response | null, agentWalletAddress?: string, agentWalletStatus?: string) => AccountSummaryResponseDto | null;

package/dist/hooks/useCalculatedPositions.d.ts

@@ -1,5 +0,0 @@
-import type { OpenPositionDto, RawPositionDto, WebData2Response, WsAllMidsData } from '../types';
-/**
- * Hook that calculates open positions by syncing platform positions with HyperLiquid real-time data
- */
-export declare const useCalculatedOpenPositions: (platformPositions: RawPositionDto[] | null, webData2: WebData2Response | null, allMids: WsAllMidsData | null) => OpenPositionDto[] | null;