@pear-protocol/hyperliquid-sdk 0.0.5 → 0.0.7-3.beta

package/dist/provider.d.ts

@@ -1,56 +1,27 @@
-import React, { ReactNode } from 'react';
-import { ReadyState } from 'react-use-websocket';
-import { PearHyperliquidClient } from './client';
-import { PearHyperliquidConfig } from './types';
-import { PearMigrationSDK } from './migration-sdk';
-import { HyperliquidService } from './hyperliquid-service';
-import type { PaginatedTradeHistoryResponseDto, OpenPositionDto, OpenLimitOrderDto, AccountSummaryResponseDto } from './types';
-interface WebSocketData {
-    tradeHistories: PaginatedTradeHistoryResponseDto | null;
-    openPositions: OpenPositionDto[] | null;
-    openOrders: OpenLimitOrderDto[] | null;
-    accountSummary: AccountSummaryResponseDto | null;
-}
+import React, { ReactNode } from "react";
 export interface PearHyperliquidContextType {
-    client: PearHyperliquidClient;
-    migrationSDK: PearMigrationSDK;
-    hyperliquidService: HyperliquidService;
-    address: string | null;
-    setAddress: (address: string | null) => void;
-    connectionStatus: ReadyState;
+    clientId: string;
+    apiBaseUrl: string;
+    wsUrl: string;
     isConnected: boolean;
-    data: WebSocketData;
     lastError: string | null;
+    nativeIsConnected: boolean;
+    nativeLastError: string | null;
 }
 export declare const PearHyperliquidContext: React.Context<PearHyperliquidContextType | undefined>;
 interface PearHyperliquidProviderProps {
-    config: PearHyperliquidConfig;
-    /**
-     * WebSocket server URL
-     * @default 'wss://hl-v2.pearprotocol.io/ws'
-     */
-    wsUrl?: string;
-    /**
-     * Hyperliquid WebSocket URL
-     * @default 'wss://api.hyperliquid.xyz/ws'
-     */
-    hyperliquidWsUrl?: string;
     children: ReactNode;
+    apiBaseUrl?: string;
+    clientId?: string;
+    wsUrl?: string;
 }
 /**
  * React Provider for PearHyperliquidClient
  */
 export declare const PearHyperliquidProvider: React.FC<PearHyperliquidProviderProps>;
 /**
- * Hook to use PearHyperliquidClient from context
- */
-export declare const usePearHyperliquidClient: () => PearHyperliquidClient;
-/**
- * Hook to use migration SDK from context
- */
-export declare const useMigrationSDK: () => PearMigrationSDK;
-/**
- * Hook to use Hyperliquid service from context
+ * Hook to access the entire Pear Hyperliquid context.
+ * Prefer using the more specific hooks below when possible.
  */
-export declare const useHyperliquidService: () => HyperliquidService;
+export declare function usePearHyperliquid(): PearHyperliquidContextType;
 export {};

package/dist/store/historicalPriceDataStore.d.ts

@@ -0,0 +1,25 @@
+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;
+}
+interface HistoricalPriceDataState {
+    historicalPriceData: Record<string, TokenHistoricalPriceData>;
+    loadingTokens: Set<string>;
+    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[];
+    setTokenLoading: (symbol: string, loading: boolean) => void;
+    isTokenLoading: (symbol: string) => boolean;
+    removeTokenPriceData: (symbol: string, interval: CandleInterval) => void;
+    clearData: () => void;
+}
+export declare const useHistoricalPriceDataStore: import("zustand").UseBoundStore<import("zustand").StoreApi<HistoricalPriceDataState>>;
+export type { HistoricalRange, TokenHistoricalPriceData };

package/dist/store/hyperliquidDataStore.d.ts

@@ -0,0 +1,25 @@
+import { ActiveAssetData, CandleChartData, CandleData, ClearinghouseState, UniverseAsset, WebData3AssetCtx, WsAllMidsData } from "../types";
+interface HyperliquidDataState {
+    allMids: WsAllMidsData | null;
+    activeAssetData: Record<string, ActiveAssetData> | null;
+    candleData: CandleChartData | null;
+    finalAssetContexts: WebData3AssetCtx[] | null;
+    finalAtOICaps: string[] | null;
+    aggregatedClearingHouseState: ClearinghouseState | null;
+    perpMetaAssets: UniverseAsset[] | null;
+    hip3DisplayToFull: Map<string, string>;
+    setAllMids: (value: WsAllMidsData | null) => void;
+    setActiveAssetData: (value: Record<string, ActiveAssetData> | null | ((prev: Record<string, ActiveAssetData> | null) => Record<string, ActiveAssetData> | null)) => void;
+    deleteActiveAssetData: (key: string) => void;
+    addCandleData: (symbol: string, candle: CandleData) => void;
+    deleteCandleSymbol: (symbol: string) => void;
+    setCandleData: (value: CandleChartData | null) => void;
+    upsertActiveAssetData: (key: string, value: ActiveAssetData) => void;
+    setFinalAssetContexts: (value: WebData3AssetCtx[] | null) => void;
+    setFinalAtOICaps: (value: string[] | null) => void;
+    setAggregatedClearingHouseState: (value: ClearinghouseState | null) => void;
+    setPerpMetaAssets: (value: UniverseAsset[] | null) => void;
+    setHip3DisplayToFull: (value: Map<string, string>) => void;
+}
+export declare const useHyperliquidData: import("zustand").UseBoundStore<import("zustand").StoreApi<HyperliquidDataState>>;
+export {};

package/dist/store/marketDataStore.d.ts

@@ -0,0 +1,10 @@
+import type { ActiveAssetsAllResponse, ActiveAssetsResponse } from '../types';
+interface MarketDataState {
+    marketData: ActiveAssetsResponse | null;
+    marketDataAll: ActiveAssetsAllResponse | null;
+    setMarketData: (value: ActiveAssetsResponse | null) => void;
+    setMarketDataAll: (value: ActiveAssetsAllResponse | null) => void;
+    clean: () => void;
+}
+export declare const useMarketData: import("zustand").UseBoundStore<import("zustand").StoreApi<MarketDataState>>;
+export {};

package/dist/store/tokenSelectionMetadataStore.d.ts

@@ -0,0 +1,27 @@
+import type { ActiveAssetData, TokenSelection, TokenMetadata, WsAllMidsData, ActiveAssetsResponse, UniverseAsset, WebData3AssetCtx } from "../types";
+export interface TokenSelectionMetadataState {
+    isPriceDataReady: boolean;
+    isLoading: boolean;
+    longTokensMetadata: Record<string, TokenMetadata | null>;
+    shortTokensMetadata: Record<string, TokenMetadata | null>;
+    weightedRatio: number;
+    weightedRatio24h: number;
+    priceRatio: number;
+    priceRatio24h: number;
+    openInterest: string;
+    volume: string;
+    sumNetFunding: number;
+    maxLeverage: number;
+    minMargin: number;
+    leverageMatched: boolean;
+    recompute: (args: {
+        perpMetaAssets: UniverseAsset[] | null;
+        finalAssetContexts: WebData3AssetCtx[] | null;
+        allMids: WsAllMidsData | null;
+        activeAssetData: Record<string, ActiveAssetData> | null;
+        marketData: ActiveAssetsResponse | null;
+        longTokens: TokenSelection[];
+        shortTokens: TokenSelection[];
+    }) => void;
+}
+export declare const useTokenSelectionMetadataStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TokenSelectionMetadataState>>;

package/dist/store/userDataStore.d.ts

@@ -0,0 +1,30 @@
+import { PlatformAccountSummaryResponseDto, OpenLimitOrderDto, RawPositionDto, TradeHistoryDataDto, TwapMonitoringDto, NotificationDto, ExtraAgent } from "../types";
+interface UserDataState {
+    accessToken: string | null;
+    refreshToken: string | null;
+    isAuthenticated: boolean;
+    isReady: boolean;
+    address: string | null;
+    tradeHistories: TradeHistoryDataDto[] | null;
+    rawOpenPositions: RawPositionDto[] | null;
+    openOrders: OpenLimitOrderDto[] | null;
+    accountSummary: PlatformAccountSummaryResponseDto | null;
+    twapDetails: TwapMonitoringDto[] | null;
+    notifications: NotificationDto[] | null;
+    userExtraAgents: ExtraAgent[] | null;
+    setAccessToken: (token: string | null) => void;
+    setRefreshToken: (token: string | null) => void;
+    setIsAuthenticated: (value: boolean) => void;
+    setIsReady: (value: boolean) => void;
+    setAddress: (address: string | null) => void;
+    setTradeHistories: (value: TradeHistoryDataDto[] | null) => void;
+    setRawOpenPositions: (value: RawPositionDto[] | null) => void;
+    setOpenOrders: (value: OpenLimitOrderDto[] | null) => void;
+    setAccountSummary: (value: PlatformAccountSummaryResponseDto | null) => void;
+    setUserExtraAgents: (value: ExtraAgent[] | null) => void;
+    setTwapDetails: (value: TwapMonitoringDto[] | null) => void;
+    setNotifications: (value: NotificationDto[] | null) => void;
+    clean: () => void;
+}
+export declare const useUserData: import("zustand").UseBoundStore<import("zustand").StoreApi<UserDataState>>;
+export {};

package/dist/store/userSelection.d.ts

@@ -0,0 +1,27 @@
+import type { CandleInterval, TokenConflict, TokenSelection, TokenSelectorConfig } from "../types";
+interface UserSelectionState {
+    longTokens: TokenSelection[];
+    shortTokens: TokenSelection[];
+    openTokenSelector: boolean;
+    selectorConfig: TokenSelectorConfig | null;
+    openConflictModal: boolean;
+    conflicts: TokenConflict[];
+    candleInterval: CandleInterval;
+    isWeightBalanced: boolean;
+    setLongTokens: (tokens: TokenSelection[]) => void;
+    setShortTokens: (tokens: TokenSelection[]) => 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) => boolean;
+    canAddToken: (isLong: boolean) => boolean;
+    removeToken: (isLong: boolean, index: number) => void;
+    handleTokenSelect: (selectedToken: string) => void;
+    setTokenSelections: (longTokens: TokenSelection[], shortTokens: TokenSelection[]) => void;
+    resetToDefaults: () => void;
+}
+export declare const useUserSelection: import("zustand").UseBoundStore<import("zustand").StoreApi<UserSelectionState>>;
+export type { UserSelectionState };