@pear-protocol/hyperliquid-sdk 0.0.4 → 0.0.7-2.1

package/dist/index.d.ts

@@ -1,73 +1,35 @@
 import React, { ReactNode } from 'react';
 
-/**
- * Raw value data for trade history positions
- */
-interface RawValueDto {
-    coin: string;
-    size: string;
-    leverage: number;
-    openPx: string;
-    closePx: string;
-    marginUsed: string;
-    positionValue: string;
-}
-/**
- * Trade history data structure from V1 API
- */
-interface TradeHistoryV1Dto {
-    pearId: string;
-    openedDate: string;
-    closedDate: string;
-    time: string;
-    pair: string;
-    direction: Record<string, string>;
-    closedPrice: number;
-    openedPrice: number;
-    size: string;
-    longPositionValue: number;
-    shortPositionValue: number;
-    positionValue: number;
-    fee: number;
-    builderFee: number;
-    closedPNL: number;
-    closedPnlPercentage: number;
-    leverage: number;
-    rawLongValue: RawValueDto;
-    rawShortValue: RawValueDto;
+interface PearHyperliquidContextType {
+    clientId: string;
+    apiBaseUrl: string;
+    wsUrl: string;
+    isConnected: boolean;
+    lastError: string | null;
+    nativeIsConnected: boolean;
+    nativeLastError: string | null;
 }
-/**
- * Request payload for syncing trade history
- */
-interface SyncTradeHistoryDto {
-    address: string;
-    data: TradeHistoryV1Dto[];
+interface PearHyperliquidProviderProps {
+    children: ReactNode;
+    apiBaseUrl?: string;
+    clientId?: string;
+    wsUrl?: string;
 }
 /**
- * Response from sync trade history endpoint
+ * React Provider for PearHyperliquidClient
  */
-interface SyncTradeHistoryResponseDto {
-    success: boolean;
-    positionId: string;
-    tradeHistoryId: string;
-    message: string;
-}
+declare const PearHyperliquidProvider: React.FC<PearHyperliquidProviderProps>;
 /**
- * Base API error response
+ * Hook to access the entire Pear Hyperliquid context.
+ * Prefer using the more specific hooks below when possible.
  */
+declare function usePearHyperliquid(): PearHyperliquidContextType;
+
 interface ApiErrorResponse {
     statusCode: number;
     message: string;
     error?: string;
 }
-/**
- * Configuration options for the SDK
- */
-interface PearHyperliquidConfig {
-    baseUrl: string;
-    timeout?: number;
-    headers?: Record<string, string>;
-}
 /**
  * HTTP client response wrapper
  */
@@ -76,136 +38,38 @@ interface ApiResponse<T> {
     status: number;
     headers: Record<string, string>;
 }
-/**
- * Hook state interface for migration operations
- */
-interface MigrationHookState<T> {
-    loading: boolean;
-    error: ApiErrorResponse | null;
-    data: T | null;
-}
-/**
- * PnL data structure for open positions
- */
-interface PnlDto {
-    value: number;
-    percentage: number;
-}
-/**
- * Take profit and stop loss data structure
- */
-interface TpSlDto {
-    takeProfit?: number;
-    stopLoss?: number;
+interface ExternalLiquidationDto {
+    liquidatedUser: string;
+    markPx: string;
+    method: string;
 }
-/**
- * Position side data structure for open positions
- */
-interface PositionSideDto {
+interface ExternalFillDto {
     coin: string;
-    size: string;
-    leverage: number;
-    entryPx: string;
-    marginUsed: string;
-    liquidationPx: string | undefined;
-    unrealizedPnl: string;
-    roe: string;
-    positionValue: string;
-    funding: string;
-}
-/**
- * Open position data structure from V1 API
- */
-interface OpenPositionV1Dto {
-    pair: string;
-    leverage: number;
-    size: number;
-    longPositionValue?: number;
-    shortPositionValue?: number;
-    positionValue: number;
-    entryPrice: number;
-    markPrice: number;
-    pnl: PnlDto;
-    liqPrice: string | number;
-    margin: number;
-    funding: number;
-    pearId: string;
-    openedDate: string;
-    tpsl: TpSlDto;
-    long: PositionSideDto;
-    short: PositionSideDto;
-}
-/**
- * Request payload for syncing open positions
- */
-interface SyncOpenPositionDto {
-    address: string;
-    data: OpenPositionV1Dto[];
-}
-/**
- * Response from sync open positions endpoint
- */
-interface SyncOpenPositionResponseDto {
-    success: boolean;
-    positionIds: string[];
-    count: number;
-    message: string;
-}
-/**
- * Open order data structure from V1 API
- */
-interface OpenOrderV1Dto {
-    id: string;
-    time: string;
-    pair: string;
-    type: string;
-    orderValue: number;
-    price: number;
-    triggerConditions: string;
-    status: string;
-    leverage?: string;
+    px: string;
+    sz: string;
+    side: 'B' | 'A';
+    time: number;
+    dir: string;
+    fee: string;
+    builderFee?: string;
+    oid?: string | number;
+    tid?: string | number;
+    cloid?: string | null;
+    hash?: string | null;
+    feeToken?: string | null;
+    liquidation?: ExternalLiquidationDto | null;
 }
-/**
- * Request payload for syncing open orders
- */
-interface SyncOpenOrderDto {
-    address: string;
-    data: OpenOrderV1Dto[];
+interface SyncFillsResponseDto {
+    insertedFills: number;
+    skippedDuplicates: number;
+    createdOrders: number;
+    updatedPositions: number;
+    createdPositions: number;
+    closedPositions: number;
 }
-/**
- * Response from sync open orders endpoint
- */
-interface SyncOpenOrderResponseDto {
-    success: boolean;
-    orderIds: string[];
-    count: number;
-    message: string;
-}
-/**
- * Migration hooks interface
- */
-interface MigrationHooks {
-    tradeHistory: {
-        sync: (payload: SyncTradeHistoryDto) => Promise<ApiResponse<SyncTradeHistoryResponseDto>>;
-        loading: boolean;
-        error: ApiErrorResponse | null;
-        data: SyncTradeHistoryResponseDto | null;
-        reset: () => void;
-    };
-    openPositions: {
-        sync: (payload: SyncOpenPositionDto) => Promise<ApiResponse<SyncOpenPositionResponseDto>>;
-        loading: boolean;
-        error: ApiErrorResponse | null;
-        data: SyncOpenPositionResponseDto | null;
-        reset: () => void;
-    };
-    openOrders: {
-        sync: (payload: SyncOpenOrderDto) => Promise<ApiResponse<SyncOpenOrderResponseDto>>;
-        loading: boolean;
-        error: ApiErrorResponse | null;
-        data: SyncOpenOrderResponseDto | null;
-        reset: () => void;
-    };
+interface TwapSliceFillResponseItem {
+    fill: ExternalFillDto;
+    twapId: number;
 }
 /**
  * WebSocket connection states
@@ -214,7 +78,7 @@ type WebSocketConnectionState = 'connecting' | 'connected' | 'disconnected' | 'e
 /**
  * WebSocket channels
  */
-type WebSocketChannel = 'trade-histories' | 'open-positions' | 'open-orders' | 'account-summary';
+type WebSocketChannel = 'trade-histories' | 'open-positions' | 'open-orders' | 'account-summary' | 'twap-details' | 'notifications' | 'market-data' | 'market-data-all' | 'webData3' | 'allMids' | 'activeAssetData';
 /**
  * WebSocket subscription message
  */
@@ -225,7 +89,7 @@ interface WebSocketSubscribeMessage {
 /**
  * WebSocket response message
  */
-interface WebSocketResponse {
+interface WebSocketAckResponse {
     success?: boolean;
     message?: string;
     error?: string;
@@ -237,17 +101,85 @@ interface WebSocketDataMessage<T = unknown> {
     channel: WebSocketChannel;
     data: T;
 }
+interface WatchlistAssetDto {
+    asset: string;
+    weight: number;
+}
+interface WatchlistItemDto {
+    id: string;
+    longAssets: WatchlistAssetDto[];
+    shortAssets: WatchlistAssetDto[];
+}
+interface ToggleWatchlistResponseDto {
+    items: WatchlistItemDto[];
+}
+type NotificationCategory = 'TRADE_OPENED_OUTSIDE_PEAR' | 'TRADE_CLOSED_OUTSIDE_PEAR' | 'POSITION_LIQUIDATED' | 'LIMIT_ORDER_FILLED' | 'LIMIT_ORDER_FAILED' | 'TP_ORDER_FILLED' | 'TP_ORDER_FAILED' | 'SL_ORDER_FILLED' | 'SL_ORDER_FAILED';
+interface NotificationDto {
+    id: string;
+    address: string;
+    category: NotificationCategory;
+    parameters: Record<string, any>;
+    is_read: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface ChunkFillDto {
+    fillId: string;
+    assetName: string;
+    price: number;
+    size: number;
+    executedAt: string;
+}
+type TwapChunkStatus = 'PENDING' | 'SCHEDULED' | 'EXECUTING' | 'COMPLETED' | 'FAILED' | 'CANCELLED';
+interface TwapChunkStatusDto {
+    chunkId: string;
+    chunkIndex: number;
+    scheduledTime: string;
+    executedTime?: string;
+    status: TwapChunkStatus;
+    chunkSize: number;
+    fills: ChunkFillDto[];
+    errorMessage?: string;
+}
+type TwapOrderOverallStatus = 'OPEN' | 'EXECUTING' | 'COMPLETED' | 'PARTIALLY_COMPLETED' | 'FAILED' | 'CANCELLED';
+interface TwapMonitoringDto {
+    orderId: string;
+    positionId?: string;
+    address: string;
+    orderType: string;
+    status: TwapOrderOverallStatus;
+    totalUsdValue: number;
+    filledUsdValue: number;
+    remainingUsdValue: number;
+    twapDuration: string;
+    twapIntervalSeconds?: number | null;
+    twapChunkUsdValue?: number | null;
+    randomizeExecution: boolean;
+    reduceOnly: boolean;
+    chunks: TwapChunkStatusDto[];
+    estimatedCompletionTime?: string;
+    actualCompletionTime?: string;
+    remainingChunks: number;
+    longAssets: OrderAssetDto[];
+    shortAssets: OrderAssetDto[];
+    createdAt: string;
+    updatedAt: string;
+}
 /**
  * Trade history asset data
  */
 interface TradeHistoryAssetDataDto {
     coin: string;
+    entryWeight: number;
     entryPrice: number;
     limitPrice: number;
+    leverage: number;
     size: number;
     externalFeePaid: number;
     builderFeePaid: number;
     realizedPnl: number;
+    marketPrefix?: string | null;
+    collateralToken?: CollateralToken;
 }
 /**
  * Trade history data structure
@@ -259,23 +191,19 @@ interface TradeHistoryDataDto {
     externalFeePaid: number;
     builderFeePaid: number;
     realizedPnl: number;
+    realizedPnlPercentage: number;
+    totalEntryValue: number;
     totalValue: number;
     entryRatio: number;
     exitRatio: number;
-    leverage: number;
-    longAssets: TradeHistoryAssetDataDto[];
-    shortAssets: TradeHistoryAssetDataDto[];
+    entryPriceRatio?: number;
+    exitpPriceRatio?: number;
+    closedLongAssets: TradeHistoryAssetDataDto[];
+    closedShortAssets: TradeHistoryAssetDataDto[];
+    positionLongAssets?: string[];
+    positionShortAssets?: string[];
     createdAt: string;
 }
-/**
- * Paginated trade history response
- */
-interface PaginatedTradeHistoryResponseDto {
-    data: TradeHistoryDataDto[];
-    hasMore: boolean;
-    nextCursor?: string;
-    count: number;
-}
 /**
  * Cumulative funding information
  */
@@ -292,36 +220,40 @@ interface PositionAssetDetailDto {
     entryPrice: number;
     platformSize: number;
     actualSize: number;
-    cumFunding: CumFundingDto;
+    leverage: number;
     marginUsed: number;
+    entryPositionValue: number;
     positionValue: number;
     unrealizedPnl: number;
     liquidationPrice: number;
-    isExternallyModified: boolean;
+    initialWeight: number;
+    fundingPaid?: number;
+    marketPrefix?: string | null;
+    collateralToken?: CollateralToken;
+}
+interface TpSlThreshold {
+    type: 'PERCENTAGE' | 'DOLLAR' | 'POSITION_VALUE';
+    value: number;
 }
-/**
- * Position sync status
- */
-type PositionSyncStatus = 'SYNCED' | 'EXTERNALLY_MODIFIED' | 'EXTERNALLY_CLOSED' | 'PAIR_BROKEN';
 /**
  * Open position data structure
  */
 interface OpenPositionDto {
     positionId: string;
     address: string;
-    leverage: number;
-    stopLoss: number | null;
-    takeProfit: number | null;
+    stopLoss: TpSlThreshold | null;
+    takeProfit: TpSlThreshold | null;
     entryRatio: number;
     markRatio: number;
-    netFunding: number;
+    entryPriceRatio?: number;
+    markPriceRatio?: number;
+    entryPositionValue: number;
     positionValue: number;
     marginUsed: number;
     unrealizedPnl: number;
+    unrealizedPnlPercentage: number;
     longAssets: PositionAssetDetailDto[];
     shortAssets: PositionAssetDetailDto[];
-    syncStatus: PositionSyncStatus;
-    lastSyncAt: string;
     createdAt: string;
     updatedAt: string;
 }
@@ -331,23 +263,40 @@ interface OpenPositionDto {
 interface OrderAssetDto {
     asset: string;
     weight: number;
+    marketPrefix?: string | null;
+    collateralToken?: CollateralToken;
 }
 /**
  * Order status
  */
 type OrderStatus = 'OPEN' | 'PARTIALLY_FILLED' | 'PROCESSING';
+/**
+ * Order type
+ */
+type OrderType = 'TP' | 'SL' | 'LIMIT' | 'MARKET' | 'LIMIT_BTCDOM' | 'TWAP';
+/**
+ * TP/SL trigger type
+ */
+type TpSlTriggerType = 'PERCENTAGE' | 'DOLLAR' | 'POSITION_VALUE';
+type OrderDirection = 'MORE_THAN' | 'LESS_THAN' | null;
 /**
  * Open limit order data structure
  */
 interface OpenLimitOrderDto {
     orderId: string;
     address: string;
+    clientId: string | null;
+    positionId?: string | null;
     leverage: number;
     usdValue: number;
-    limitRatio: number;
-    stopLoss: number | null;
-    takeProfit: number | null;
+    triggerValue?: number | null;
+    twapDuration?: string | null;
+    tpSlTriggerType?: TpSlTriggerType | null;
+    randomizeFlag: boolean;
+    reduceOnlyFlag: boolean;
     status: OrderStatus;
+    orderType: OrderType;
+    direction?: OrderDirection | null;
     longAssets: OrderAssetDto[];
     shortAssets: OrderAssetDto[];
     createdAt: string;
@@ -385,166 +334,1182 @@ interface BalanceSummaryDto {
  * Agent wallet information
  */
 interface AgentWalletDto {
-    address: string;
+    address?: string;
     status: string;
 }
+interface PlatformAccountSummaryResponseDto {
+    agentWalletAddress: string | null;
+    totalClosedTrades: number;
+    totalLimitOrderUsdValue?: number;
+    totalTwapChunkUsdValue?: number;
+    lastSyncedAt?: number;
+}
 /**
  * Account balance response (renamed to AccountSummaryResponseDto for consistency)
  */
 interface AccountSummaryResponseDto {
     balanceSummary: BalanceSummaryDto;
-    agentWallet: AgentWalletDto;
+    platformAccountSummary: PlatformAccountSummaryResponseDto | null;
+    agentWallet?: AgentWalletDto;
+}
+interface UseAuthOptions {
+    baseUrl: string;
+    clientId: string;
+}
+interface UserProfile {
+    userId: string;
+    address: string;
+    appId: string;
+}
+interface EIP712AuthDetails {
+    primaryType: string;
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: `0x${string}`;
+    };
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
+    message: Record<string, unknown>;
+    timestamp: number;
+}
+interface GetEIP712MessageResponse extends EIP712AuthDetails {
+}
+interface RefreshTokenResponse {
+    accessToken: string;
+    refreshToken: string;
+    tokenType: string;
+    expiresIn: number;
+}
+type AgentWalletStatus = 'ACTIVE' | 'EXPIRED' | 'NOT_FOUND';
+interface CreateAgentWalletResponseDto {
+    agentWalletAddress: string;
+    message: string;
+}
+interface ExtraAgent {
+    name: string;
+    address: string;
+    validUntil: number;
+}
+interface AgentWalletState {
+    address: string | null;
+    name: string | null;
+    status: AgentWalletStatus | 'PENDING' | null;
+    isActive: boolean;
+}
+/**
+ * WebSocket message from HyperLiquid native API
+ */
+interface WebSocketMessage {
+    method: 'subscribe' | 'unsubscribe';
+    subscription: {
+        type: string;
+        dex?: string;
+        coin?: string;
+        interval?: string;
+        user?: string;
+        aggregateByTime?: boolean;
+    };
+}
+/**
+ * WebSocket response from HyperLiquid native API
+ */
+type HLChannel = 'webData3' | 'allMids' | 'activeAssetData' | 'candle' | 'spotState' | 'allDexsClearinghouseState' | 'allDexsAssetCtxs';
+interface HLChannelDataMap {
+    webData3: WebData3Response;
+    allMids: WsAllMidsData;
+    activeAssetData: ActiveAssetData;
+    candle: CandleData;
+    spotState: {
+        user: string;
+        spotState: SpotState;
+    };
+    allDexsClearinghouseState: AllDexsClearinghouseStateData;
+    allDexsAssetCtxs: AllDexsAssetCtxsData;
+}
+interface WebData3UserState {
+    agentAddress?: string;
+    agentValidUntil?: number;
+    cumLedger: string;
+    serverTime: number;
+    isVault: boolean;
+    user: string;
+    dexAbstractionEnabled?: boolean;
+}
+interface WebData3AssetCtx {
+    funding: string;
+    openInterest: string;
+    prevDayPx: string;
+    dayNtlVlm: string;
+    premium: string | null;
+    oraclePx: string;
+    markPx: string;
+    midPx: string | null;
+    impactPxs: string[] | null;
+    dayBaseVlm: string;
 }
+interface WebData3PerpDexState {
+    clearinghouseState: ClearinghouseState;
+    totalVaultEquity: string;
+    assetCtxs: WebData3AssetCtx[];
+    perpsAtOpenInterestCap: string[];
+}
+interface WebData3Response {
+    userState: WebData3UserState;
+    perpDexStates: WebData3PerpDexState[];
+}
+interface AllDexsClearinghouseStateData {
+    user: string;
+    clearinghouseStates: [string, ClearinghouseState][];
+}
+interface AllDexsAssetCtxsData {
+    ctxs: [string, WebData3AssetCtx[]][];
+}
+interface HLWebSocketResponse<T extends HLChannel = HLChannel> {
+    channel: T;
+    data: HLChannelDataMap[T];
+}
+/**
+ * All mids data structure
+ */
+interface WsAllMidsData {
+    mids: Record<string, string>;
+}
+/**
+ * Asset context data
+ */
+interface AssetCtx {
+    funding: string;
+    openInterest: string;
+    prevDayPx: string;
+    dayNtlVlm: string;
+    markPx: string;
+    midPx?: string;
+    impactPxs?: string[];
+    oraclePx: string;
+}
+/**
+ * Collateral token type
+ * 0 = USDC
+ * 360 = USDH
+ */
+type CollateralToken = 'USDC' | 'USDH';
+/**
+ * Universe asset metadata
+ */
+interface UniverseAsset {
+    name: string;
+    szDecimals: number;
+    maxLeverage: number;
+    onlyIsolated?: boolean;
+    isDelisted?: boolean;
+    marketPrefix?: string;
+    collateralToken?: CollateralToken;
+}
+interface ClearinghouseState {
+    assetPositions: AssetPosition[];
+    crossMaintenanceMarginUsed: string;
+    crossMarginSummary: {
+        accountValue: string;
+        totalMarginUsed: string;
+        totalNtlPos: string;
+        totalRawUsd: string;
+    };
+    marginSummary: {
+        accountValue: string;
+        totalMarginUsed: string;
+        totalNtlPos: string;
+        totalRawUsd: string;
+    };
+    time: number;
+    withdrawable: string;
+}
+/**
+ * Asset position data
+ */
+interface AssetPosition {
+    position: {
+        coin: string;
+        entryPx?: string;
+        leverage: {
+            type: string;
+            value: number;
+        };
+        liquidationPx?: string;
+        marginUsed: string;
+        maxLeverage: number;
+        positionValue: string;
+        returnOnEquity: string;
+        szi: string;
+        unrealizedPnl: string;
+        cumFunding: {
+            allTime: string;
+            sinceChange: string;
+            sinceOpen: string;
+        };
+    };
+    type: string;
+}
+/**
+ * Asset information detail
+ */
+interface AssetInformationDetail {
+    name: string;
+    funding: string;
+    openInterest: string;
+    prevDayPx: string;
+    dayNtlVlm: string;
+    oraclePx: string;
+    markPx: string;
+    midPx?: string;
+    dayBaseVlm: string;
+    priceChange: number;
+    assetIndex: number;
+}
+/**
+ * Raw asset data from open-positions channel
+ */
+interface RawAssetDto {
+    coin: string;
+    entryPrice: number;
+    size: number;
+    side: string;
+    fundingPaid?: number;
+    marketPrefix?: string | null;
+    collateralToken?: CollateralToken;
+    leverage: number;
+}
+/**
+ * Raw position data from open-positions channel
+ */
+interface RawPositionDto {
+    positionId: string;
+    address: string;
+    stopLoss: number | null;
+    takeProfit: number | null;
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+    longAssets: RawAssetDto[];
+    shortAssets: RawAssetDto[];
+}
+/**
+ * Leverage information from activeAssetData
+ */
+interface LeverageInfo {
+    type: string;
+    value: number;
+}
+/**
+ * Active asset data from WebSocket
+ */
+interface ActiveAssetData {
+    user: string;
+    coin: string;
+    leverage: LeverageInfo;
+    maxTradeSzs: [string, string];
+    availableToTrade: [string, string];
+    markPx: string;
+}
+interface TokenMetadata {
+    currentPrice: number;
+    prevDayPrice: number;
+    priceChange24h: number;
+    priceChange24hPercent: number;
+    netFunding: number;
+    maxLeverage: number;
+    markPrice: number;
+    oraclePrice: number;
+    openInterest: string;
+    dayVolume: string;
+    leverage?: LeverageInfo;
+    maxTradeSzs?: [string, string];
+    availableToTrade?: [string, string];
+    collateralToken?: CollateralToken;
+}
+/**
+ * Enhanced token selection with weight and metadata for basket trading
+ */
+interface TokenSelection {
+    symbol: string;
+    weight: number;
+}
+/**
+ * Token conflict information for position conflicts
+ */
+interface TokenConflict {
+    symbol: string;
+    conflictType: 'long' | 'short';
+    conflictMessage: string;
+}
+interface AssetMarketData {
+    asset: WebData3AssetCtx | AssetCtx;
+    universe: UniverseAsset;
+}
+/**
+ * Nested market data structure for multi-market assets.
+ * Each symbol maps to its market variants (keyed by prefix).
+ * For non-HIP3 assets, use "default" as the key.
+ *
+ * @example
+ * ```ts
+ * {
+ *   "TSLA": {
+ *     "xyz": { asset: {...}, universe: { collateralToken: "USDC", ... } },
+ *     "flx": { asset: {...}, universe: { collateralToken: "USDH", ... } }
+ *   },
+ *   "BTC": {
+ *     "default": { asset: {...}, universe: {...} }
+ *   }
+ * }
+ * ```
+ */
+type MarketDataBySymbol = Record<string, Record<string, AssetMarketData>>;
+interface PairAssetDto {
+    asset: string;
+    weight: number;
+    collateralToken: CollateralToken;
+    marketPrefix: string | null;
+}
+interface ActiveAssetGroupItem {
+    longAssets: PairAssetDto[];
+    shortAssets: PairAssetDto[];
+    openInterest: string;
+    volume: string;
+    netFunding?: string;
+    ratio?: string;
+    prevRatio?: string;
+    change24h?: string;
+    weightedRatio?: string;
+    weightedPrevRatio?: string;
+    weightedChange24h?: string;
+    collateralType: 'USDC' | 'USDH' | 'MIXED';
+}
+interface ActiveAssetsResponse {
+    active: ActiveAssetGroupItem[];
+    topGainers: ActiveAssetGroupItem[];
+    topLosers: ActiveAssetGroupItem[];
+    highlighted: ActiveAssetGroupItem[];
+    watchlist: ActiveAssetGroupItem[];
+}
+interface ActiveAssetsAllResponse {
+    active: ActiveAssetGroupItem[];
+    all: ActiveAssetGroupItem[];
+    highlighted: ActiveAssetGroupItem[];
+    watchlist: ActiveAssetGroupItem[];
+}
+/**
+ * Candle interval options
+ */
+type CandleInterval = '1m' | '3m' | '5m' | '15m' | '30m' | '1h' | '2h' | '4h' | '8h' | '12h' | '1d' | '3d' | '1w' | '1M';
+/**
+ * Candle data structure from WebSocket
+ */
+interface CandleData {
+    s?: string;
+    t: number;
+    T: number;
+    o: number;
+    c: number;
+    h: number;
+    l: number;
+}
+/**
+ * Candle chart data organized by symbol only
+ * Since new candles always have latest timestamp, no need to store per interval
+ */
+type CandleChartData = Map<string, CandleData>;
+/**
+ * Historical candle data request
+ */
+interface CandleSnapshotRequest {
+    req: {
+        coin: string;
+        startTime: number;
+        endTime: number;
+        interval: CandleInterval;
+    };
+    type: 'candleSnapshot';
+}
+interface TokenSelectorConfig {
+    isLong: boolean;
+    index: number;
+}
+interface SpotBalance {
+    coin: string;
+    token: number;
+    total: string;
+    hold: string;
+    entryNtl: string;
+}
+interface SpotState {
+    user: string;
+    balances: SpotBalance[];
+}
+
+declare const useAccountSummary: () => {
+    data: AccountSummaryResponseDto | null;
+    isLoading: boolean;
+};
+
+declare const useTradeHistories: () => {
+    data: TradeHistoryDataDto[] | null;
+    isLoading: boolean;
+};
+declare const useOpenOrders: () => {
+    data: OpenLimitOrderDto[] | null;
+    isLoading: boolean;
+};
+
+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;
+}
+
+declare const useUserSelection: () => UserSelectionState;
 
 /**
- * Main SDK client for Pear Protocol Hyperliquid API integration
+ * Hook to access webData and native WebSocket state
  */
-declare class PearHyperliquidClient {
-    private httpClient;
-    private baseUrl;
-    constructor(config: PearHyperliquidConfig);
+declare const useWebData: () => {
+    clearinghouseState: ClearinghouseState | null;
+    perpsAtOpenInterestCap: string[] | null;
     /**
-     * Get the configured base URL
+     * Market data keyed by symbol, with nested market variants.
+     * Each symbol maps to its market variants (keyed by prefix).
+     * For non-HIP3 assets, use "default" as the key.
+     *
+     * @example
+     * ```ts
+     * // HIP-3 asset with multiple markets
+     * marketDataBySymbol["TSLA"]["xyz"]  // { asset, universe: { collateralToken: "USDC" } }
+     * marketDataBySymbol["TSLA"]["flx"]  // { asset, universe: { collateralToken: "USDH" } }
+     *
+     * // Regular asset
+     * marketDataBySymbol["BTC"]["default"]  // { asset, universe }
+     * ```
      */
-    getBaseUrl(): string;
-    /**
-     * Update request headers
-     */
-    setHeaders(headers: Record<string, string>): void;
-    /**
-     * Set authorization header
-     */
-    setAuthToken(token: string): void;
-    /**
-     * Make a generic HTTP request
-     */
-    private makeRequest;
-    /**
-     * Sync trade history data from old database structure to new database format
-     * @param payload - Trade history data with user address
-     * @returns Promise with sync result
-     */
-    syncTradeHistory(payload: SyncTradeHistoryDto): Promise<ApiResponse<SyncTradeHistoryResponseDto>>;
-    /**
-     * Sync open positions data from old database structure to new database format
-     * @param payload - Open positions data with user address
-     * @returns Promise with sync result
-     */
-    syncOpenPositions(payload: SyncOpenPositionDto): Promise<ApiResponse<SyncOpenPositionResponseDto>>;
-    /**
-     * Sync open orders data from old database structure to new database format
-     * @param payload - Open orders data with user address
-     * @returns Promise with sync result
-     */
-    syncOpenOrders(payload: SyncOpenOrderDto): Promise<ApiResponse<SyncOpenOrderResponseDto>>;
+    marketDataBySymbol: MarketDataBySymbol;
+    /** Map of display name -> all full market names (e.g., "TSLA" -> ["xyz:TSLA", "flx:TSLA"]) */
+    hip3Assets: Map<string, string[]>;
+    /** Map of full market name -> prefix (e.g., "xyz:TSLA" -> "xyz") */
+    hip3MarketPrefixes: Map<string, string>;
+    isConnected: boolean;
+    error: string | null;
+};
+
+interface UseTokenSelectionMetadataReturn {
+    isLoading: boolean;
+    isPriceDataReady: 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;
+}
+declare const useTokenSelectionMetadata: () => UseTokenSelectionMetadataReturn;
+
+interface HistoricalRange {
+    start: number;
+    end: number;
+}
+interface TokenHistoricalPriceData {
+    symbol: string;
+    interval: CandleInterval;
+    candles: CandleData[];
+    oldestTime: number | null;
+    latestTime: number | null;
+}
+declare const useHistoricalPriceDataStore: any;
+
+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[]>;
+    getAllHistoricalPriceData(): Promise<Record<string, TokenHistoricalPriceData>>;
+    isLoading: (symbol?: string) => boolean;
+    clearCache: () => void;
 }
+declare const useHistoricalPriceData: () => UseHistoricalPriceDataReturn;
 
+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[]>;
+    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;
 /**
- * Main Migration SDK Class - Simple request/response pattern
+ * Composes historical price fetching with basket candle computation.
+ * - Listens to `longTokens` and `shortTokens` from user selection.
+ * - Uses `fetchHistoricalPriceData` to retrieve token candles for the range.
+ * - Computes and returns weighted basket candles via `computeBasketCandles`.
  */
-declare class PearMigrationSDK {
-    private client;
-    private isTradeHistorySyncRunning;
-    private isOpenPositionsSyncRunning;
-    private isOpenOrdersSyncRunning;
-    constructor(client: PearHyperliquidClient);
-    /**
-     * Sync trade history data - can only run one at a time
-     * If called while already running, returns immediately without making request
-     */
-    syncTradeHistory(payload: SyncTradeHistoryDto): Promise<ApiResponse<SyncTradeHistoryResponseDto> | null>;
-    /**
-     * Sync open positions data - can only run one at a time
-     * If called while already running, returns immediately without making request
-     */
-    syncOpenPositions(payload: SyncOpenPositionDto): Promise<ApiResponse<SyncOpenPositionResponseDto> | null>;
-    /**
-     * Sync open orders data - can only run one at a time
-     * If called while already running, returns immediately without making request
-     */
-    syncOpenOrders(payload: SyncOpenOrderDto): Promise<ApiResponse<SyncOpenOrderResponseDto> | null>;
-    /**
-     * Check if any sync is currently running
-     */
-    isSyncInProgress(): boolean;
-    /**
-     * Check if trade history sync is currently running
-     */
-    isTradeHistorySyncInProgress(): boolean;
+declare const useBasketCandles: () => UseBasketCandlesReturn;
+
+interface PerformanceOverlay {
+    id: string;
+    symbol: string;
+    label: string;
+    color: string;
+    enabled: boolean;
+    type: 'asset' | 'portfolio';
+    weight?: number;
+}
+interface UsePerformanceOverlaysReturn {
+    overlays: PerformanceOverlay[];
+    generateOverlaySymbols: () => string[];
+}
+declare const usePerformanceOverlays: () => UsePerformanceOverlaysReturn;
+
+declare function useAgentWallet(): {
+    readonly refreshAgentWalletStatus: () => Promise<void>;
+    readonly createAgentWallet: () => Promise<CreateAgentWalletResponseDto>;
+    readonly notifyAgentWalletApproved: () => Promise<void>;
+};
+
+interface AutoSyncFillsOptions {
+    baseUrl: string;
+    address: string | null;
+    intervalMs?: number;
+    aggregateByTime?: boolean;
+}
+interface AutoSyncFillsState {
+    lastRunAt: number | null;
+    lastResult: SyncFillsResponseDto | null;
+    error: string | null;
+    isSyncing: boolean;
+    triggerSync: () => Promise<void>;
+}
+/**
+ * Listens to address changes and periodically syncs user fills
+ * Defaults: aggregate=true, interval=60s
+ */
+declare function useAutoSyncFills(options: AutoSyncFillsOptions): AutoSyncFillsState;
+
+interface AdjustOrderRequestInput {
+    limitRatio?: number;
+    usdValue?: number;
+}
+interface AdjustOrderResponseDto {
+    orderId: string;
+    limitRatio: number;
+    usdValue: number;
+    updatedAt: string;
+}
+declare function adjustOrder(baseUrl: string, orderId: string, payload: AdjustOrderRequestInput): Promise<ApiResponse<AdjustOrderResponseDto>>;
+interface CancelOrderResponseDto {
+    orderId: string;
+    status: string;
+    cancelledAt: string;
+}
+declare function cancelOrder(baseUrl: string, orderId: string): Promise<ApiResponse<CancelOrderResponseDto>>;
+interface CancelTwapResponseDto {
+    orderId: string;
+    status: string;
+    cancelledAt: string;
+}
+declare function cancelTwapOrder(baseUrl: string, orderId: string): Promise<ApiResponse<CancelTwapResponseDto>>;
+interface SpotOrderRequestInput {
+    /** Asset to buy/sell (e.g., "USDH") */
+    asset: string;
+    /** Whether to buy (true) or sell (false) the asset */
+    isBuy: boolean;
+    /** Amount of asset to buy/sell (minimum: 11) */
+    amount: number;
+}
+/** Filled order status from Hyperliquid */
+interface SpotOrderFilledStatus {
+    filled: {
+        totalSz: string;
+        avgPx: string;
+        oid: number;
+        cloid: string;
+    };
+}
+/** Hyperliquid order response data */
+interface SpotOrderHyperliquidData {
+    statuses: SpotOrderFilledStatus[];
+}
+/** Hyperliquid result from spot order execution */
+interface SpotOrderHyperliquidResult {
+    status: 'ok' | 'error';
+    response: {
+        type: 'order';
+        data: SpotOrderHyperliquidData;
+    };
+}
+interface SpotOrderResponseDto {
+    orderId: string;
+    status: 'EXECUTED' | 'FAILED' | 'PENDING';
+    asset: string;
+    createdAt: string;
+    hyperliquidResult?: SpotOrderHyperliquidResult;
+}
+/**
+ * Execute a spot order (swap) using Pear Hyperliquid service
+ * POST /orders/spot
+ */
+declare function executeSpotOrder(baseUrl: string, payload: SpotOrderRequestInput): Promise<ApiResponse<SpotOrderResponseDto>>;
+
+type ExecutionType = "MARKET" | "LIMIT" | "TWAP" | "LADDER" | "LIMIT_BTCDOM";
+type TpSlThresholdType = "PERCENTAGE" | "DOLLAR" | "POSITION_VALUE";
+interface PairAssetInput {
+    asset: string;
+    weight?: number;
+}
+interface TpSlThresholdInput {
+    type: TpSlThresholdType;
+    value: number;
+}
+interface LadderConfigInput {
+    ratioStart: number;
+    ratioEnd: number;
+    numberOfLevels: number;
+}
+interface CreatePositionRequestInput {
+    slippage: number;
+    executionType: ExecutionType;
+    leverage: number;
+    usdValue: number;
+    longAssets?: PairAssetInput[];
+    shortAssets?: PairAssetInput[];
+    triggerValue?: number;
+    direction?: "MORE_THAN" | "LESS_THAN";
+    twapDuration?: number;
+    twapIntervalSeconds?: number;
+    randomizeExecution?: boolean;
+    referralCode?: string;
+    ladderConfig?: LadderConfigInput;
+    takeProfit?: TpSlThresholdInput | null;
+    stopLoss?: TpSlThresholdInput | null;
+}
+type PositionResponseStatus = "SUCCESS" | "FAILED" | "PENDING" | "PARTIALLY_FILLED" | "OPEN";
+interface PositionAssetSummaryDto {
+    asset: string;
+    side: "LONG" | "SHORT";
+    size: number;
+    entryRatio: number;
+    usdValue: number;
+    orderId: string;
+}
+interface CreatePositionResponseDto {
+    positionId: string | null;
+    orderId: string;
+    status: PositionResponseStatus;
+    createdAt: string;
+    assets?: PositionAssetSummaryDto[];
+    stopLoss?: TpSlThresholdInput | null;
+    takeProfit?: TpSlThresholdInput | null;
+    hyperliquidResult?: any;
+}
+/**
+ * Create a position (MARKET/LIMIT/TWAP) using Pear Hyperliquid service
+ * Authorization is derived from headers (Axios defaults or browser localStorage fallback)
+ * @throws MinimumPositionSizeError if any asset has less than $11 USD value
+ * @throws MaxAssetsPerLegError if any leg exceeds the maximum allowed assets (15)
+ */
+declare function createPosition(baseUrl: string, payload: CreatePositionRequestInput, hip3Assets: Map<string, string[]>): Promise<ApiResponse<CreatePositionResponseDto>>;
+interface UpdateRiskParametersRequestInput {
+    stopLoss?: TpSlThresholdInput | null;
+    takeProfit?: TpSlThresholdInput | null;
+}
+interface UpdateRiskParametersResponseDto {
+    positionId: string;
+    stopLoss: TpSlThresholdInput | null;
+    takeProfit: TpSlThresholdInput | null;
+    updatedAt: string;
+}
+declare function updateRiskParameters(baseUrl: string, positionId: string, payload: UpdateRiskParametersRequestInput): Promise<ApiResponse<UpdateRiskParametersResponseDto>>;
+type CloseExecutionType = "MARKET" | "TWAP";
+interface ClosePositionRequestInput {
+    executionType: CloseExecutionType;
+    twapDuration?: number;
+    twapIntervalSeconds?: number;
+    randomizeExecution?: boolean;
+    referralCode?: string;
+}
+interface ClosePositionResponseDto {
+    orderId: string;
+    executionTime?: string;
+    chunksScheduled?: number;
+}
+declare function closePosition(baseUrl: string, positionId: string, payload: ClosePositionRequestInput): Promise<ApiResponse<ClosePositionResponseDto>>;
+interface CloseAllPositionsResultDto {
+    positionId: string;
+    success: boolean;
+    orderId?: string;
+    error?: string;
+}
+interface CloseAllPositionsResponseDto {
+    results: CloseAllPositionsResultDto[];
+}
+declare function closeAllPositions(baseUrl: string, payload: ClosePositionRequestInput): Promise<ApiResponse<CloseAllPositionsResponseDto>>;
+type AdjustExecutionType = "MARKET" | "LIMIT";
+type PositionAdjustmentType = "REDUCE" | "INCREASE";
+interface AdjustPositionRequestInput {
+    adjustmentType: PositionAdjustmentType;
+    adjustmentSize: number;
+    executionType: AdjustExecutionType;
+    limitRatio?: number;
+    referralCode?: string;
+}
+interface AdjustPositionResponseDto {
+    orderId: string;
+    status: string;
+    adjustmentType: PositionAdjustmentType;
+    adjustmentSize: number;
+    newSize: number;
+    executedAt: string;
+}
+declare function adjustPosition(baseUrl: string, positionId: string, payload: AdjustPositionRequestInput): Promise<ApiResponse<AdjustPositionResponseDto>>;
+interface AdjustAdvanceAssetInput {
+    asset: string;
+    size: number;
+}
+interface AdjustAdvanceItemInput {
+    longAssets?: AdjustAdvanceAssetInput[];
+    shortAssets?: AdjustAdvanceAssetInput[];
+}
+interface AdjustAdvanceResponseDto {
+    orderId: string;
+    status: string;
+    executedAt: string;
+}
+declare function adjustAdvancePosition(baseUrl: string, positionId: string, payload: AdjustAdvanceItemInput[], hip3Assets: Map<string, string[]>): Promise<ApiResponse<AdjustAdvanceResponseDto>>;
+declare function cancelTwap(baseUrl: string, orderId: string): Promise<ApiResponse<CancelTwapResponseDto>>;
+interface UpdateLeverageRequestInput {
+    leverage: number;
+}
+interface UpdateLeverageResponseDto {
+    message?: string;
+}
+declare function updateLeverage(baseUrl: string, positionId: string, payload: UpdateLeverageRequestInput): Promise<ApiResponse<UpdateLeverageResponseDto | null>>;
+
+declare function usePosition(): {
+    readonly createPosition: (payload: CreatePositionRequestInput) => Promise<ApiResponse<CreatePositionResponseDto>>;
+    readonly updateRiskParameters: (positionId: string, payload: UpdateRiskParametersRequestInput) => Promise<ApiResponse<UpdateRiskParametersResponseDto>>;
+    readonly closePosition: (positionId: string, payload: ClosePositionRequestInput) => Promise<ApiResponse<ClosePositionResponseDto>>;
+    readonly closeAllPositions: (payload: ClosePositionRequestInput) => Promise<ApiResponse<CloseAllPositionsResponseDto>>;
+    readonly adjustPosition: (positionId: string, payload: AdjustPositionRequestInput) => Promise<ApiResponse<AdjustPositionResponseDto>>;
+    readonly adjustAdvancePosition: (positionId: string, payload: AdjustAdvanceItemInput[]) => Promise<ApiResponse<AdjustAdvanceResponseDto>>;
+    readonly updateLeverage: (positionId: string, leverage: number) => Promise<ApiResponse<UpdateLeverageResponseDto | null>>;
+    readonly openPositions: OpenPositionDto[] | null;
+    readonly isLoading: boolean;
+};
+
+declare function useOrders(): {
+    readonly adjustOrder: (orderId: string, payload: AdjustOrderRequestInput) => Promise<ApiResponse<AdjustOrderResponseDto>>;
+    readonly cancelOrder: (orderId: string) => Promise<ApiResponse<CancelOrderResponseDto>>;
+    readonly cancelTwapOrder: (orderId: string) => Promise<ApiResponse<CancelTwapResponseDto>>;
+    readonly openOrders: OpenLimitOrderDto[] | null;
+    readonly isLoading: boolean;
+};
+
+interface UseSpotOrderResult {
+    executeSpotOrder: (payload: SpotOrderRequestInput) => Promise<ApiResponse<SpotOrderResponseDto>>;
+    isLoading: boolean;
+    error: ApiErrorResponse | null;
+    resetError: () => void;
+}
+/**
+ * Hook for executing spot orders (swaps) on Hyperliquid
+ * Use this to swap between USDC and USDH or other spot assets
+ */
+declare function useSpotOrder(): UseSpotOrderResult;
+
+declare function useTwap(): {
+    readonly orders: TwapMonitoringDto[];
+    readonly cancelTwap: (orderId: string) => Promise<ApiResponse<CancelTwapResponseDto>>;
+};
+
+interface UseNotificationsResult {
+    notifications: NotificationDto[] | null;
+    unreadCount: number;
+    markReadUntil: (timestampMs: number) => Promise<{
+        updated: number;
+    }>;
+    markReadById: (id: string) => Promise<{
+        updated: number;
+    }>;
+}
+/**
+ * Provides notifications and fills checkpoint data sourced from the SDK WebSocket.
+ * Data is persisted in the SDK's Zustand store.
+ */
+declare function useNotifications(): UseNotificationsResult;
+
+type CollateralFilter = 'USDC' | 'USDH' | 'ALL';
+declare const useMarketDataPayload: () => ActiveAssetsResponse | null;
+declare const useMarketDataAllPayload: () => ActiveAssetsAllResponse | null;
+declare const usePerpMetaAssets: () => UniverseAsset[] | null;
+declare const useActiveBaskets: (collateralFilter?: CollateralFilter) => ActiveAssetGroupItem[];
+declare const useTopGainers: (limit?: number, collateralFilter?: CollateralFilter) => ActiveAssetGroupItem[];
+declare const useTopLosers: (limit?: number, collateralFilter?: CollateralFilter) => ActiveAssetGroupItem[];
+declare const useHighlightedBaskets: (collateralFilter?: CollateralFilter) => ActiveAssetGroupItem[];
+declare const useWatchlistBaskets: (collateralFilter?: CollateralFilter) => ActiveAssetGroupItem[];
+declare const useAllBaskets: (collateralFilter?: CollateralFilter) => ActiveAssetGroupItem[];
+declare const useFindBasket: (longs: string[], shorts: string[]) => ActiveAssetGroupItem | undefined;
+
+declare function useWatchlist(): {
+    readonly watchlists: ActiveAssetGroupItem[] | null;
+    readonly isLoading: boolean;
+    readonly toggle: (longAssets: WatchlistAssetDto[], shortAssets: WatchlistAssetDto[]) => Promise<ApiResponse<ToggleWatchlistResponseDto>>;
+};
+
+type PortfolioInterval = '1d' | '1w' | '1m' | '1y' | 'all';
+interface PortfolioBucketDto {
+    periodStart: string;
+    periodEnd: string;
+    volume: number;
+    openInterest: number;
+    winningTradesCount: number;
+    winningTradesUsd: number;
+    losingTradesCount: number;
+    losingTradesUsd: number;
+}
+interface PortfolioOverallDto {
+    totalWinningTradesCount: number;
+    totalLosingTradesCount: number;
+    totalWinningUsd: number;
+    totalLosingUsd: number;
+    currentOpenInterest: number;
+    currentTotalVolume: number;
+    unrealizedPnl: number;
+    totalTrades: number;
+}
+interface PortfolioIntervalsDto {
+    oneDay: PortfolioBucketDto[];
+    oneWeek: PortfolioBucketDto[];
+    oneMonth: PortfolioBucketDto[];
+    oneYear: PortfolioBucketDto[];
+    all: PortfolioBucketDto[];
+}
+interface PortfolioResponseDto {
+    intervals: PortfolioIntervalsDto;
+    overall: PortfolioOverallDto;
+}
+/**
+ * Get portfolio summary buckets and overall metrics
+ * Returns bucketed volume, open interest snapshot, win/loss trade counts, and overall metrics filtered to PEAR fills (cloid LIKE 0x50454152%)
+ * Authorization is derived from headers (Axios defaults or browser localStorage fallback)
+ */
+declare function getPortfolio(baseUrl: string): Promise<ApiResponse<PortfolioResponseDto>>;
+
+interface UsePortfolioResult {
+    data: PortfolioResponseDto | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook to fetch and manage portfolio data
+ * Returns bucketed volume, open interest snapshot, win/loss trade counts,
+ * and overall metrics
+ */
+declare function usePortfolio(): UsePortfolioResult;
+
+declare function useAuth(): {
+    readonly isReady: boolean;
+    readonly isAuthenticated: any;
+    readonly accessToken: any;
+    readonly refreshToken: any;
+    readonly getEip712: (address: string) => Promise<GetEIP712MessageResponse>;
+    readonly loginWithSignedMessage: (address: string, signature: string, timestamp: number) => Promise<void>;
+    readonly loginWithPrivyToken: (address: string, appId: string, privyAccessToken: string) => Promise<void>;
+    readonly refreshTokens: () => Promise<RefreshTokenResponse>;
+    readonly logout: () => Promise<void>;
+};
+
+interface AllUserBalances {
+    spotUsdcBalance: number | undefined;
+    availableToTradeUsdc: number | undefined;
+    spotUsdhBalance: number | undefined;
+    availableToTradeUsdh: number | undefined;
+    isLoading: boolean;
+}
+declare const useAllUserBalances: () => AllUserBalances;
+
+interface UseHyperliquidWebSocketProps {
+    wsUrl: string;
+    address: string | null;
+    enabled?: boolean;
+}
+declare const useHyperliquidWebSocket: ({ wsUrl, address, enabled, }: UseHyperliquidWebSocketProps) => {
+    isConnected: boolean;
+    lastError: string | null;
+};
+
+interface UseHyperliquidNativeWebSocketProps {
+    address: string | null;
+    tokens?: string[];
+    enabled?: boolean;
+}
+interface UseHyperliquidNativeWebSocketReturn {
+    isConnected: boolean;
+    lastError: string | null;
+}
+declare const useHyperliquidNativeWebSocket: ({ address, enabled, }: UseHyperliquidNativeWebSocketProps) => UseHyperliquidNativeWebSocketReturn;
+
+/**
+ * Mark notifications as read up to a given timestamp (ms)
+ */
+declare function markNotificationsRead(baseUrl: string, timestampMs: number): Promise<ApiResponse<{
+    updated: number;
+}>>;
+/**
+ * Mark a single notification as read by id
+ */
+declare function markNotificationReadById(baseUrl: string, id: string): Promise<ApiResponse<{
+    updated: number;
+}>>;
+
+declare function toggleWatchlist(baseUrl: string, longAssets: WatchlistAssetDto[], shortAssets: WatchlistAssetDto[], hip3Assets: Map<string, string[]>): Promise<ApiResponse<ToggleWatchlistResponseDto>>;
+
+/**
+ * Account summary calculation utility class
+ */
+declare class AccountSummaryCalculator {
+    private clearinghouseState;
+    constructor(clearinghouseState: ClearinghouseState | null);
     /**
-     * Check if open positions sync is currently running
+     * Calculate account summary from real-time clearinghouse state and platform orders
      */
-    isOpenPositionsSyncInProgress(): boolean;
+    calculateAccountSummary(platformAccountSummary: PlatformAccountSummaryResponseDto | null, registeredAgentWallets: ExtraAgent[]): AccountSummaryResponseDto | null;
+    getClearinghouseState(): ClearinghouseState | null;
     /**
-     * Check if open orders sync is currently running
+     * Check if real-time data is available
      */
-    isOpenOrdersSyncInProgress(): boolean;
+    hasRealTimeData(): boolean;
+}
+
+/**
+ * Detects conflicts between selected tokens and existing positions
+ */
+declare class ConflictDetector {
     /**
-     * Get the underlying client instance
+     * Detects conflicts between token selections and open positions
+     * @param longTokens - Selected long tokens
+     * @param shortTokens - Selected short tokens
+     * @param openPositions - Current open positions from API
+     * @returns Array of detected conflicts
      */
-    getClient(): PearHyperliquidClient;
+    static detectConflicts(longTokens: TokenSelection[], shortTokens: TokenSelection[], openPositions: RawPositionDto[] | null): TokenConflict[];
+}
+
+/**
+ * Extracts token metadata from aggregated WebData3 contexts and AllMids data
+ */
+declare class TokenMetadataExtractor {
     /**
-     * Set authorization token on the client
+     * Extracts comprehensive token metadata
+     * @param symbol - Token symbol (base symbol without prefix, e.g., "TSLA")
+     * @param perpMetaAssets - Aggregated universe assets (flattened across dexes)
+     * @param finalAssetContexts - Aggregated asset contexts (flattened across dexes)
+     * @param allMids - AllMids data containing current prices
+     * @param activeAssetData - Optional active asset data containing leverage information
+     * @param marketPrefix - Optional market prefix (e.g., "xyz", "flx") for HIP3 multi-market assets
+     * @returns TokenMetadata or null if token not found
      */
-    setAuthToken(token: string): void;
+    static extractTokenMetadata(symbol: string, perpMetaAssets: UniverseAsset[] | null, finalAssetContexts: WebData3AssetCtx[] | null, allMids: WsAllMidsData | null, activeAssetData?: Record<string, ActiveAssetData> | null, marketPrefix?: string | null): TokenMetadata | null;
     /**
-     * Set custom headers on the client
+     * Extracts metadata for multiple tokens
+     * @param tokens - Array of token objects with symbol and optional marketPrefix
+     * @param perpMetaAssets - Aggregated universe assets
+     * @param finalAssetContexts - Aggregated asset contexts
+     * @param allMids - AllMids data
+     * @param activeAssetData - Optional active asset data containing leverage information
+     * @returns Record of unique key to TokenMetadata. Key is "{prefix}:{symbol}" for HIP3 assets, or just "{symbol}" otherwise
      */
-    setHeaders(headers: Record<string, string>): void;
+    static extractMultipleTokensMetadata(tokens: Array<{
+        symbol: string;
+        marketPrefix?: string | null;
+    }>, perpMetaAssets: UniverseAsset[] | null, finalAssetContexts: WebData3AssetCtx[] | null, allMids: WsAllMidsData | null, activeAssetData?: Record<string, ActiveAssetData> | null): Record<string, TokenMetadata | null>;
     /**
-     * Get base URL from client
+     * Checks if token data is available in aggregated universe assets
+     * @param symbol - Token symbol
+     * @param perpMetaAssets - Aggregated universe assets
+     * @returns boolean indicating if token exists in universe
      */
-    getBaseUrl(): string;
+    static isTokenAvailable(symbol: string, perpMetaAssets: UniverseAsset[] | null): boolean;
 }
 
-interface PearHyperliquidProviderProps {
-    config: PearHyperliquidConfig;
-    /**
-     * WebSocket server URL
-     * @default 'wss://hl-v2.pearprotocol.io/ws'
-     */
-    wsUrl?: string;
-    children: ReactNode;
-}
 /**
- * React Provider for PearHyperliquidClient
+ * Create efficient timestamp-based lookup maps for candle data
  */
-declare const PearHyperliquidProvider: React.FC<PearHyperliquidProviderProps>;
+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()
+ */
+declare const calculateWeightedRatio: (longTokens: TokenSelection[], shortTokens: TokenSelection[], candleLookups: Record<string, Map<number, CandleData>>, timestamp: number, priceType: "o" | "h" | "l" | "c") => number;
 /**
- * Hook to use PearHyperliquidClient from context
+ * Get all unique timestamps where ALL required symbols have data
+ * Optimized version that uses Map lookups
  */
-declare const usePearHyperliquidClient: () => PearHyperliquidClient;
+declare const getCompleteTimestamps: (candleLookups: Record<string, Map<number, CandleData>>, requiredSymbols: string[]) => number[];
 /**
- * Hook to use migration SDK from context
+ * Compute basket candles from individual token candles using weighted ratios
+ * Optimized version that creates lookup maps once and reuses them
  */
-declare const useMigrationSDK: () => PearMigrationSDK;
+declare const computeBasketCandles: (longTokens: TokenSelection[], shortTokens: TokenSelection[], tokenCandles: Record<string, CandleData[]>) => CandleData[];
 
 /**
- * Hook to manage address (login/logout functionality)
+ * Maps TradingView ResolutionString to CandleInterval
  */
-declare const useAddress: () => {
-    address: string | null;
-    setAddress: (address: string | null) => void;
-    clearAddress: () => void;
-    isLoggedIn: boolean;
+declare function mapTradingViewIntervalToCandleInterval(interval: string): CandleInterval;
+/**
+ * Maps CandleInterval to TradingView ResolutionString
+ */
+declare function mapCandleIntervalToTradingViewInterval(interval: CandleInterval): string;
+
+/**
+ * Minimum USD value required per asset when creating a position
+ */
+declare const MINIMUM_ASSET_USD_VALUE = 11;
+/**
+ * Maximum number of assets allowed per leg (long or short) in a position
+ */
+declare const MAX_ASSETS_PER_LEG = 15;
+/**
+ * Validation error for minimum position size
+ */
+declare class MinimumPositionSizeError extends Error {
+    assetName: string;
+    assetValue: number;
+    minimumRequired: number;
+    constructor(assetName: string, assetValue: number, minimumRequired: number);
+}
+/**
+ * Validation error for exceeding maximum assets per leg
+ */
+declare class MaxAssetsPerLegError extends Error {
+    leg: "long" | "short";
+    assetCount: number;
+    maxAllowed: number;
+    constructor(leg: "long" | "short", assetCount: number, maxAllowed: number);
+}
+/**
+ * Validates that each leg doesn't exceed the maximum number of assets
+ * @param longAssets Array of long assets
+ * @param shortAssets Array of short assets
+ * @throws MaxAssetsPerLegError if any leg exceeds the maximum allowed assets
+ */
+declare function validateMaxAssetsPerLeg(longAssets?: PairAssetInput[], shortAssets?: PairAssetInput[]): void;
+/**
+ * Validates that each asset in a position has at least the minimum USD value
+ * @param usdValue Total USD value for the position
+ * @param longAssets Array of long assets with weights
+ * @param shortAssets Array of short assets with weights
+ * @throws MinimumPositionSizeError if any asset has less than the minimum USD value
+ */
+declare function validateMinimumAssetSize(usdValue: number, longAssets?: PairAssetInput[], shortAssets?: PairAssetInput[]): void;
+/**
+ * Calculates the minimum USD value required for a position based on the number of assets
+ * @param longAssets Array of long assets
+ * @param shortAssets Array of short assets
+ * @returns The minimum total USD value required
+ */
+declare function calculateMinimumPositionValue(longAssets?: PairAssetInput[], shortAssets?: PairAssetInput[]): number;
+/**
+ * Validates and provides a user-friendly error message with suggestions
+ * @param usdValue Total USD value for the position
+ * @param longAssets Array of long assets with weights
+ * @param shortAssets Array of short assets with weights
+ * @returns Validation result with success flag and optional error message
+ */
+declare function validatePositionSize(usdValue: number, longAssets?: PairAssetInput[], shortAssets?: PairAssetInput[]): {
+    valid: boolean;
+    error?: string;
+    minimumRequired?: number;
 };
 
 /**
- * Hook to access trade histories
+ * Convert a full/prefixed symbol (e.g., "xyz:XYZ100") to a display symbol (e.g., "XYZ100").
+ */
+declare function toDisplaySymbol(symbol: string): string;
+/**
+ * Convert a display symbol back to backend form using a provided map.
+ * If mapping is missing, returns the original symbol.
+ * For multi-market assets, returns the first available market.
+ * @param displaySymbol e.g., "TSLA"
+ * @param hip3Assets map of display -> all full market names (e.g., "TSLA" -> ["xyz:TSLA", "flx:TSLA"])
  */
-declare const useTradeHistories: () => PaginatedTradeHistoryResponseDto | null;
+declare function toBackendSymbol(displaySymbol: string, hip3Assets: Map<string, string[]>): string;
 /**
- * Hook to access open positions
+ * Convert a display symbol to backend form for a specific market prefix.
+ * This is useful when an asset is available on multiple markets (e.g., xyz:TSLA and flx:TSLA).
+ * @param displaySymbol e.g., "TSLA"
+ * @param marketPrefix e.g., "xyz" or "flx"
+ * @param hip3Assets map of display -> all full market names
+ * @returns Full market name if found, null if prefix not specified for multi-market asset, otherwise displaySymbol with prefix
  */
-declare const useOpenPositions: () => OpenPositionDto[] | null;
+declare function toBackendSymbolWithMarket(displaySymbol: string, marketPrefix: string | undefined, hip3Assets: Map<string, string[]>): string | null;
 /**
- * Hook to access open orders
+ * Get all available markets for a display symbol.
+ * @param displaySymbol e.g., "TSLA"
+ * @param hip3Assets map of display -> all full market names
+ * @returns Array of full market names, e.g., ["xyz:TSLA", "flx:TSLA"]
  */
-declare const useOpenOrders: () => OpenLimitOrderDto[] | null;
+declare function getAvailableMarkets(displaySymbol: string, hip3Assets: Map<string, string[]>): string[];
 /**
- * Hook to access account summary
+ * Extract the market prefix from a full market name.
+ * @param fullSymbol e.g., "xyz:TSLA"
+ * @returns The prefix (e.g., "xyz") or undefined if no prefix
  */
-declare const useAccountSummary: () => AccountSummaryResponseDto | null;
+declare function getMarketPrefix(fullSymbol: string): string | undefined;
+/**
+ * Check if a symbol is a HIP-3 market (has a prefix).
+ * @param symbol e.g., "xyz:TSLA" or "TSLA"
+ * @returns true if the symbol has a market prefix
+ */
+declare function isHip3Market(symbol: string): boolean;
+
+declare const useMarketData: any;
 
-export { PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, PearHyperliquidClient as default, useAccountSummary, useAddress, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTradeHistories };
-export type { AccountSummaryResponseDto, AgentWalletDto, ApiErrorResponse, ApiResponse, BalanceSummaryDto, CrossMarginSummaryDto, CumFundingDto, MarginSummaryDto, MigrationHookState, MigrationHooks, OpenLimitOrderDto, OpenOrderV1Dto, OpenPositionDto, OpenPositionV1Dto, OrderAssetDto, OrderStatus, PaginatedTradeHistoryResponseDto, PearHyperliquidConfig, PnlDto, PositionAssetDetailDto, PositionSideDto, PositionSyncStatus, RawValueDto, SyncOpenOrderDto, SyncOpenOrderResponseDto, SyncOpenPositionDto, SyncOpenPositionResponseDto, SyncTradeHistoryDto, SyncTradeHistoryResponseDto, TpSlDto, TradeHistoryAssetDataDto, TradeHistoryDataDto, TradeHistoryV1Dto, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketResponse, WebSocketSubscribeMessage };
+export { AccountSummaryCalculator, ConflictDetector, MAX_ASSETS_PER_LEG, MINIMUM_ASSET_USD_VALUE, MaxAssetsPerLegError, MinimumPositionSizeError, PearHyperliquidProvider, TokenMetadataExtractor, adjustAdvancePosition, adjustOrder, adjustPosition, calculateMinimumPositionValue, calculateWeightedRatio, cancelOrder, cancelTwap, cancelTwapOrder, closeAllPositions, closePosition, computeBasketCandles, createCandleLookups, createPosition, executeSpotOrder, getAvailableMarkets, getCompleteTimestamps, getMarketPrefix, getPortfolio, isHip3Market, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, toBackendSymbol, toBackendSymbolWithMarket, toDisplaySymbol, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useActiveBaskets, useAgentWallet, useAllBaskets, useAllUserBalances, useAuth, useAutoSyncFills, useBasketCandles, useFindBasket, useHighlightedBaskets, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMarketData, useMarketDataAllPayload, useMarketDataPayload, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePerpMetaAssets, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTopGainers, useTopLosers, useTradeHistories, useTwap, useUserSelection, useWatchlist, useWatchlistBaskets, useWebData, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };
+export type { AccountSummaryResponseDto, ActiveAssetGroupItem, ActiveAssetsResponse, AdjustAdvanceAssetInput, AdjustAdvanceItemInput, AdjustAdvanceResponseDto, AdjustExecutionType, AdjustOrderRequestInput, AdjustOrderResponseDto, AdjustPositionRequestInput, AdjustPositionResponseDto, AgentWalletDto, AgentWalletState, ApiErrorResponse, ApiResponse, AssetCtx, AssetInformationDetail, AssetMarketData, AssetPosition, AutoSyncFillsOptions, AutoSyncFillsState, BalanceSummaryDto, CancelOrderResponseDto, CancelTwapResponseDto, CandleChartData, CandleData, CandleInterval, CandleSnapshotRequest, ClearinghouseState, CloseAllPositionsResponseDto, CloseAllPositionsResultDto, CloseExecutionType, ClosePositionRequestInput, ClosePositionResponseDto, CollateralFilter, CollateralToken, CreatePositionRequestInput, CreatePositionResponseDto, CrossMarginSummaryDto, CumFundingDto, ExecutionType, ExtraAgent, HLWebSocketResponse, HistoricalRange, LadderConfigInput, MarginSummaryDto, MarketDataBySymbol, NotificationCategory, NotificationDto, OpenLimitOrderDto, OpenPositionDto, OrderAssetDto, OrderStatus, PairAssetDto, PairAssetInput, PerformanceOverlay, PlatformAccountSummaryResponseDto, PortfolioBucketDto, PortfolioInterval, PortfolioIntervalsDto, PortfolioOverallDto, PortfolioResponseDto, PositionAdjustmentType, PositionAssetDetailDto, PositionAssetSummaryDto, PositionResponseStatus, RealtimeBar, RealtimeBarsCallback, SpotBalance, SpotOrderFilledStatus, SpotOrderHyperliquidData, SpotOrderHyperliquidResult, SpotOrderRequestInput, SpotOrderResponseDto, SpotState, ToggleWatchlistResponseDto, TokenConflict, TokenHistoricalPriceData, TokenMetadata, TokenSelection, TpSlThresholdInput, TpSlThresholdType, TradeHistoryAssetDataDto, TradeHistoryDataDto, TwapChunkStatusDto, TwapMonitoringDto, TwapSliceFillResponseItem, UniverseAsset, UpdateLeverageRequestInput, UpdateLeverageResponseDto, UpdateRiskParametersRequestInput, UpdateRiskParametersResponseDto, UseAuthOptions, UseBasketCandlesReturn, UseHistoricalPriceDataReturn, UseNotificationsResult, UsePerformanceOverlaysReturn, UsePortfolioResult, UseSpotOrderResult, UseTokenSelectionMetadataReturn, UserProfile, UserSelectionState, WatchlistItemDto, WebSocketAckResponse, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketSubscribeMessage, WsAllMidsData };