@pear-protocol/hyperliquid-sdk 0.0.5 → 0.0.7-2.2

package/dist/clients/agentWallet.d.ts

@@ -0,0 +1,3 @@
+import type { ApiResponse, GetAgentWalletResponseDto, CreateAgentWalletResponseDto } from '../types';
+export declare function getAgentWallet(baseUrl: string): Promise<ApiResponse<GetAgentWalletResponseDto>>;
+export declare function createAgentWallet(baseUrl: string): Promise<ApiResponse<CreateAgentWalletResponseDto>>;

package/dist/clients/auth.d.ts

@@ -0,0 +1,14 @@
+import type { ApiResponse, GetEIP712MessageResponse, AuthenticateRequest, AuthenticateResponse, RefreshTokenResponse, LogoutResponse } from '../types';
+export declare function getEIP712Message(baseUrl: string, address: string, clientId: string): Promise<ApiResponse<GetEIP712MessageResponse>>;
+export declare function authenticate(baseUrl: string, body: AuthenticateRequest): Promise<ApiResponse<AuthenticateResponse>>;
+/**
+ * Convenience wrapper for Privy access token authentication
+ */
+export declare function authenticateWithPrivy(baseUrl: string, params: {
+    address: string;
+    clientId: string;
+    appId: string;
+    accessToken: string;
+}): Promise<ApiResponse<AuthenticateResponse>>;
+export declare function refreshToken(baseUrl: string, refreshTokenVal: string): Promise<ApiResponse<RefreshTokenResponse>>;
+export declare function logout(baseUrl: string, refreshTokenVal: string): Promise<ApiResponse<LogoutResponse>>;

package/dist/clients/hyperliquid.d.ts

@@ -0,0 +1,25 @@
+import type { ApiResponse, CandleInterval, CandleData, ExternalFillDto, AllPerpMetasResponse, ExtraAgent, TwapSliceFillResponseItem } from '../types';
+/**
+ * Fetch historical candle data from HyperLiquid API
+ */
+export declare const fetchHistoricalCandles: (coin: string, startTime: number, endTime: number, interval: CandleInterval, hip3Assets: Map<string, string[]>) => Promise<ApiResponse<CandleData[]>>;
+/**
+ * Retrieve recent user fills from HyperLiquid and map to ExternalFillDto[]
+ */
+export declare const fetchUserFillsFromHyperliquid: (user: string, startTime: number, aggregateByTime?: boolean) => Promise<ApiResponse<ExternalFillDto[]>>;
+/**
+ * Retrieve user TWAP slice fills from HyperLiquid and map to ExternalFillDto within items
+ */
+export declare const fetchUserTwapSliceFillsByTime: (user: string, startTime: number, aggregateByTime?: boolean) => Promise<ApiResponse<TwapSliceFillResponseItem[]>>;
+/**
+ * Fetch all perp metas from HyperLiquid API
+ * Endpoint: https://api.hyperliquid.xyz/info
+ * Payload: { "type": "allPerpMetas" }
+ */
+export declare const fetchAllPerpMetas: () => Promise<ApiResponse<AllPerpMetasResponse>>;
+/**
+ * Fetch extra agent approvals for a given user from HyperLiquid API
+ * Endpoint: https://api.hyperliquid.xyz/info
+ * Payload: { "type": "extraAgents", "user": "0x..." }
+ */
+export declare const fetchExtraAgents: (user: string) => Promise<ApiResponse<ExtraAgent[]>>;

package/dist/clients/notifications.d.ts

@@ -0,0 +1,13 @@
+import type { ApiResponse } from '../types';
+/**
+ * Mark notifications as read up to a given timestamp (ms)
+ */
+export declare function markNotificationsRead(baseUrl: string, timestampMs: number): Promise<ApiResponse<{
+    updated: number;
+}>>;
+/**
+ * Mark a single notification as read by id
+ */
+export declare function markNotificationReadById(baseUrl: string, id: string): Promise<ApiResponse<{
+    updated: number;
+}>>;

package/dist/clients/orders.d.ts

@@ -0,0 +1,65 @@
+import type { ApiResponse } from '../types';
+export interface AdjustOrderRequestInput {
+    limitRatio?: number;
+    usdValue?: number;
+}
+export interface AdjustOrderResponseDto {
+    orderId: string;
+    limitRatio: number;
+    usdValue: number;
+    updatedAt: string;
+}
+export declare function adjustOrder(baseUrl: string, orderId: string, payload: AdjustOrderRequestInput): Promise<ApiResponse<AdjustOrderResponseDto>>;
+export interface CancelOrderResponseDto {
+    orderId: string;
+    status: string;
+    cancelledAt: string;
+}
+export declare function cancelOrder(baseUrl: string, orderId: string): Promise<ApiResponse<CancelOrderResponseDto>>;
+export interface CancelTwapResponseDto {
+    orderId: string;
+    status: string;
+    cancelledAt: string;
+}
+export declare function cancelTwapOrder(baseUrl: string, orderId: string): Promise<ApiResponse<CancelTwapResponseDto>>;
+export 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 */
+export interface SpotOrderFilledStatus {
+    filled: {
+        totalSz: string;
+        avgPx: string;
+        oid: number;
+        cloid: string;
+    };
+}
+/** Hyperliquid order response data */
+export interface SpotOrderHyperliquidData {
+    statuses: SpotOrderFilledStatus[];
+}
+/** Hyperliquid result from spot order execution */
+export interface SpotOrderHyperliquidResult {
+    status: 'ok' | 'error';
+    response: {
+        type: 'order';
+        data: SpotOrderHyperliquidData;
+    };
+}
+export 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
+ */
+export declare function executeSpotOrder(baseUrl: string, payload: SpotOrderRequestInput): Promise<ApiResponse<SpotOrderResponseDto>>;

package/dist/clients/portfolio.d.ts

@@ -0,0 +1,39 @@
+import type { ApiResponse } from '../types';
+export type PortfolioInterval = '1d' | '1w' | '1m' | '1y' | 'all';
+export interface PortfolioBucketDto {
+    periodStart: string;
+    periodEnd: string;
+    volume: number;
+    openInterest: number;
+    winningTradesCount: number;
+    winningTradesUsd: number;
+    losingTradesCount: number;
+    losingTradesUsd: number;
+}
+export interface PortfolioOverallDto {
+    totalWinningTradesCount: number;
+    totalLosingTradesCount: number;
+    totalWinningUsd: number;
+    totalLosingUsd: number;
+    currentOpenInterest: number;
+    currentTotalVolume: number;
+    unrealizedPnl: number;
+    totalTrades: number;
+}
+export interface PortfolioIntervalsDto {
+    oneDay: PortfolioBucketDto[];
+    oneWeek: PortfolioBucketDto[];
+    oneMonth: PortfolioBucketDto[];
+    oneYear: PortfolioBucketDto[];
+    all: PortfolioBucketDto[];
+}
+export 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)
+ */
+export declare function getPortfolio(baseUrl: string): Promise<ApiResponse<PortfolioResponseDto>>;

package/dist/clients/positions.d.ts

@@ -0,0 +1,135 @@
+import type { ApiResponse } from "../types";
+import type { CancelTwapResponseDto } from "./orders";
+export type ExecutionType = "MARKET" | "LIMIT" | "TWAP" | "LADDER" | "LIMIT_BTCDOM";
+export type TpSlThresholdType = "PERCENTAGE" | "DOLLAR" | "POSITION_VALUE";
+export interface PairAssetInput {
+    asset: string;
+    weight?: number;
+}
+export interface TpSlThresholdInput {
+    type: TpSlThresholdType;
+    value: number;
+}
+export interface LadderConfigInput {
+    ratioStart: number;
+    ratioEnd: number;
+    numberOfLevels: number;
+}
+export 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;
+}
+export type PositionResponseStatus = "SUCCESS" | "FAILED" | "PENDING" | "PARTIALLY_FILLED" | "OPEN";
+export interface PositionAssetSummaryDto {
+    asset: string;
+    side: "LONG" | "SHORT";
+    size: number;
+    entryRatio: number;
+    usdValue: number;
+    orderId: string;
+}
+export 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)
+ */
+export declare function createPosition(baseUrl: string, payload: CreatePositionRequestInput, hip3Assets: Map<string, string[]>): Promise<ApiResponse<CreatePositionResponseDto>>;
+export interface UpdateRiskParametersRequestInput {
+    stopLoss?: TpSlThresholdInput | null;
+    takeProfit?: TpSlThresholdInput | null;
+}
+export interface UpdateRiskParametersResponseDto {
+    positionId: string;
+    stopLoss: TpSlThresholdInput | null;
+    takeProfit: TpSlThresholdInput | null;
+    updatedAt: string;
+}
+export declare function updateRiskParameters(baseUrl: string, positionId: string, payload: UpdateRiskParametersRequestInput): Promise<ApiResponse<UpdateRiskParametersResponseDto>>;
+export type CloseExecutionType = "MARKET" | "TWAP";
+export interface ClosePositionRequestInput {
+    executionType: CloseExecutionType;
+    twapDuration?: number;
+    twapIntervalSeconds?: number;
+    randomizeExecution?: boolean;
+    referralCode?: string;
+}
+export interface ClosePositionResponseDto {
+    orderId: string;
+    executionTime?: string;
+    chunksScheduled?: number;
+}
+export declare function closePosition(baseUrl: string, positionId: string, payload: ClosePositionRequestInput): Promise<ApiResponse<ClosePositionResponseDto>>;
+export interface CloseAllPositionsResultDto {
+    positionId: string;
+    success: boolean;
+    orderId?: string;
+    error?: string;
+}
+export interface CloseAllPositionsResponseDto {
+    results: CloseAllPositionsResultDto[];
+}
+export declare function closeAllPositions(baseUrl: string, payload: ClosePositionRequestInput): Promise<ApiResponse<CloseAllPositionsResponseDto>>;
+export type AdjustExecutionType = "MARKET" | "LIMIT";
+export type PositionAdjustmentType = "REDUCE" | "INCREASE";
+export interface AdjustPositionRequestInput {
+    adjustmentType: PositionAdjustmentType;
+    adjustmentSize: number;
+    executionType: AdjustExecutionType;
+    limitRatio?: number;
+    referralCode?: string;
+}
+export interface AdjustPositionResponseDto {
+    orderId: string;
+    status: string;
+    adjustmentType: PositionAdjustmentType;
+    adjustmentSize: number;
+    newSize: number;
+    executedAt: string;
+}
+export declare function adjustPosition(baseUrl: string, positionId: string, payload: AdjustPositionRequestInput): Promise<ApiResponse<AdjustPositionResponseDto>>;
+export interface AdjustAdvanceAssetInput {
+    asset: string;
+    size: number;
+}
+export interface AdjustAdvanceItemInput {
+    longAssets?: AdjustAdvanceAssetInput[];
+    shortAssets?: AdjustAdvanceAssetInput[];
+}
+export interface AdjustAdvanceResponseDto {
+    orderId: string;
+    status: string;
+    executedAt: string;
+}
+export declare function adjustAdvancePosition(baseUrl: string, positionId: string, payload: AdjustAdvanceItemInput[], hip3Assets: Map<string, string[]>): Promise<ApiResponse<AdjustAdvanceResponseDto>>;
+export declare function cancelTwap(baseUrl: string, orderId: string): Promise<ApiResponse<CancelTwapResponseDto>>;
+export interface UpdateLeverageRequestInput {
+    leverage: number;
+}
+export interface UpdateLeverageResponseDto {
+    message?: string;
+}
+export declare function updateLeverage(baseUrl: string, positionId: string, payload: UpdateLeverageRequestInput): Promise<ApiResponse<UpdateLeverageResponseDto | null>>;

package/dist/clients/sync.d.ts

@@ -0,0 +1,9 @@
+import type { ApiResponse, AssetPosition, SyncFillsRequestDto, SyncFillsResponseDto } from '../types';
+/**
+ * Sync external fills into Pear Hyperliquid service (POST /sync/fills)
+ */
+export declare const syncFills: (baseUrl: string, payload: SyncFillsRequestDto) => Promise<ApiResponse<SyncFillsResponseDto>>;
+/**
+ * Convenience: fetch user fills from HyperLiquid, then sync them to Pear backend
+ */
+export declare const syncUserFillsFromHyperliquid: (baseUrl: string, user: string, aggregateByTime: boolean | undefined, lastSyncAt: number | null | undefined, assetPositions: AssetPosition[]) => Promise<ApiResponse<SyncFillsResponseDto>>;

package/dist/clients/watchlist.d.ts

@@ -0,0 +1,2 @@
+import type { ApiResponse, ToggleWatchlistResponseDto, WatchlistAssetDto } from '../types';
+export declare function toggleWatchlist(baseUrl: string, longAssets: WatchlistAssetDto[], shortAssets: WatchlistAssetDto[], hip3Assets: Map<string, string[]>): Promise<ApiResponse<ToggleWatchlistResponseDto>>;

package/dist/hooks/index.d.ts

@@ -1,2 +1,20 @@
-export { useAddress } from './useAddress';
-export { useTradeHistories, useOpenPositions, useOpenOrders, useAccountSummary } from './useTrading';
+export * from './useAccountSummary';
+export * from './useTrading';
+export * from './useUserSelection';
+export * from './useWebData';
+export * from './useTokenSelectionMetadata';
+export * from './useHistoricalPriceData';
+export * from './useBasketCandles';
+export * from './usePerformanceOverlays';
+export * from './useAgentWallet';
+export * from './useAutoSyncFills';
+export * from './usePosition';
+export * from './useOrders';
+export * from './useSpotOrder';
+export * from './useTwap';
+export * from './useNotifications';
+export * from './useMarketData';
+export * from './useWatchlist';
+export * from './usePortfolio';
+export * from './useAuth';
+export * from './useAllUserBalances';

package/dist/hooks/useAccountSummary.d.ts

@@ -0,0 +1,5 @@
+import { AccountSummaryResponseDto } from "../types";
+export declare const useAccountSummary: () => {
+    data: AccountSummaryResponseDto | null;
+    isLoading: boolean;
+};

package/dist/hooks/useAgentWallet.d.ts

@@ -0,0 +1,5 @@
+export declare function useAgentWallet(): {
+    readonly refreshAgentWalletStatus: () => Promise<void>;
+    readonly createAgentWallet: () => Promise<import("../types").CreateAgentWalletResponseDto>;
+    readonly notifyAgentWalletApproved: () => Promise<void>;
+};

package/dist/hooks/useAllUserBalances.d.ts

@@ -0,0 +1,9 @@
+interface AllUserBalances {
+    spotUsdcBalance: number | undefined;
+    availableToTradeUsdc: number | undefined;
+    spotUsdhBalance: number | undefined;
+    availableToTradeUsdh: number | undefined;
+    isLoading: boolean;
+}
+export declare const useAllUserBalances: () => AllUserBalances;
+export {};

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,12 @@
+import type { GetEIP712MessageResponse } from "../types";
+export declare function useAuth(): {
+    readonly isReady: boolean;
+    readonly isAuthenticated: boolean;
+    readonly accessToken: string | null;
+    readonly refreshToken: string | null;
+    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<import("../types").RefreshTokenResponse>;
+    readonly logout: () => Promise<void>;
+};

package/dist/hooks/useAutoSyncFills.d.ts

@@ -0,0 +1,19 @@
+import type { SyncFillsResponseDto } from '../types';
+export interface AutoSyncFillsOptions {
+    baseUrl: string;
+    address: string | null;
+    intervalMs?: number;
+    aggregateByTime?: boolean;
+}
+export 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
+ */
+export declare function useAutoSyncFills(options: AutoSyncFillsOptions): AutoSyncFillsState;

package/dist/hooks/useBasketCandles.d.ts

@@ -0,0 +1,25 @@
+import type { CandleData, CandleInterval } from '../types';
+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[]>;
+    isLoading: boolean;
+    addRealtimeListener: (cb: RealtimeBarsCallback) => string;
+    removeRealtimeListener: (id: string) => void;
+}
+export type RealtimeBar = {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+};
+export type RealtimeBarsCallback = (bar: RealtimeBar) => void;
+/**
+ * Composes historical price fetching with basket candle computation.
+ * - Listens to `longTokens` and `shortTokens` from user selection.
+ * - Uses `fetchHistoricalPriceData` to retrieve token candles for the range.
+ * - Computes and returns weighted basket candles via `computeBasketCandles`.
+ */
+export declare const useBasketCandles: () => UseBasketCandlesReturn;

package/dist/hooks/useHistoricalPriceData.d.ts

@@ -0,0 +1,11 @@
+import { TokenHistoricalPriceData } from '../store/historicalPriceDataStore';
+import type { CandleData, CandleInterval } from '../types';
+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[]>;
+    getAllHistoricalPriceData(): Promise<Record<string, TokenHistoricalPriceData>>;
+    isLoading: (symbol?: string) => boolean;
+    clearCache: () => void;
+}
+export declare const useHistoricalPriceData: () => UseHistoricalPriceDataReturn;

package/dist/hooks/useMarketData.d.ts

@@ -0,0 +1,12 @@
+import type { ActiveAssetGroupItem, ActiveAssetsResponse, ActiveAssetsAllResponse, UniverseAsset } from '../types';
+export type CollateralFilter = 'USDC' | 'USDH' | 'ALL';
+export declare const useMarketDataPayload: () => ActiveAssetsResponse | null;
+export declare const useMarketDataAllPayload: () => ActiveAssetsAllResponse | null;
+export declare const usePerpMetaAssets: () => UniverseAsset[] | null;
+export declare const useActiveBaskets: (collateralFilter?: CollateralFilter) => ActiveAssetGroupItem[];
+export declare const useTopGainers: (limit?: number, collateralFilter?: CollateralFilter) => ActiveAssetGroupItem[];
+export declare const useTopLosers: (limit?: number, collateralFilter?: CollateralFilter) => ActiveAssetGroupItem[];
+export declare const useHighlightedBaskets: (collateralFilter?: CollateralFilter) => ActiveAssetGroupItem[];
+export declare const useWatchlistBaskets: (collateralFilter?: CollateralFilter) => ActiveAssetGroupItem[];
+export declare const useAllBaskets: (collateralFilter?: CollateralFilter) => ActiveAssetGroupItem[];
+export declare const useFindBasket: (longs: string[], shorts: string[]) => ActiveAssetGroupItem | undefined;

package/dist/hooks/useNotifications.d.ts

@@ -0,0 +1,16 @@
+import type { NotificationDto } from '../types';
+export 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.
+ */
+export declare function useNotifications(): UseNotificationsResult;

package/dist/hooks/useOrders.d.ts

@@ -0,0 +1,10 @@
+import type { ApiResponse } from '../types';
+import type { OpenLimitOrderDto } from '../types';
+import { type AdjustOrderRequestInput, type AdjustOrderResponseDto, type CancelOrderResponseDto, type CancelTwapResponseDto } from '../clients/orders';
+export 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;
+};

package/dist/hooks/usePerformanceOverlays.d.ts

@@ -0,0 +1,14 @@
+export interface PerformanceOverlay {
+    id: string;
+    symbol: string;
+    label: string;
+    color: string;
+    enabled: boolean;
+    type: 'asset' | 'portfolio';
+    weight?: number;
+}
+export interface UsePerformanceOverlaysReturn {
+    overlays: PerformanceOverlay[];
+    generateOverlaySymbols: () => string[];
+}
+export declare const usePerformanceOverlays: () => UsePerformanceOverlaysReturn;

package/dist/hooks/usePortfolio.d.ts

@@ -0,0 +1,13 @@
+import { type PortfolioResponseDto } from '../clients/portfolio';
+export 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
+ */
+export declare function usePortfolio(): UsePortfolioResult;

package/dist/hooks/usePosition.d.ts

@@ -0,0 +1,13 @@
+import { type CreatePositionRequestInput, type CreatePositionResponseDto, type UpdateRiskParametersRequestInput, type UpdateRiskParametersResponseDto, type ClosePositionRequestInput, type ClosePositionResponseDto, type CloseAllPositionsResponseDto, type AdjustPositionRequestInput, type AdjustPositionResponseDto, type AdjustAdvanceItemInput, type AdjustAdvanceResponseDto, type UpdateLeverageResponseDto } from '../clients/positions';
+import type { ApiResponse, OpenPositionDto } from '../types';
+export 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;
+};

package/dist/hooks/useSpotOrder.d.ts

@@ -0,0 +1,13 @@
+import type { ApiResponse, ApiErrorResponse } from '../types';
+import { type SpotOrderRequestInput, type SpotOrderResponseDto } from '../clients/orders';
+export 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
+ */
+export declare function useSpotOrder(): UseSpotOrderResult;

package/dist/hooks/useTokenSelectionMetadata.d.ts

@@ -0,0 +1,18 @@
+import { TokenMetadata } from "../types";
+export 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;
+}
+export declare const useTokenSelectionMetadata: () => UseTokenSelectionMetadataReturn;

package/dist/hooks/useTrading.d.ts

@@ -1,29 +1,10 @@
-import { OpenPositionDto, AccountSummaryResponseDto } from '../types';
-/**
- * Hook to access trade histories
- */
-export declare const useTradeHistories: () => import("../types").PaginatedTradeHistoryResponseDto | null;
-/**
- * Hook to access open positions with enhanced real-time synchronization
- */
-export declare const useOpenPositions: () => {
-    positions: OpenPositionDto[];
+import type { OpenLimitOrderDto } from '../types';
+import type { TradeHistoryDataDto } from '../types';
+export declare const useTradeHistories: () => {
+    data: TradeHistoryDataDto[] | null;
     isLoading: boolean;
-    lastSyncTime: Date | null;
-    rawWsPositions: OpenPositionDto[] | null;
-    resync: () => Promise<void>;
 };
-/**
- * Hook to access open orders
- */
-export declare const useOpenOrders: () => import("../types").OpenLimitOrderDto[] | null;
-/**
- * Hook to access account summary with enhanced real-time data from Hyperliquid
- */
-export declare const useAccountSummary: () => {
-    summary: AccountSummaryResponseDto | null;
+export declare const useOpenOrders: () => {
+    data: OpenLimitOrderDto[] | null;
     isLoading: boolean;
-    lastSyncTime: Date | null;
-    rawWsSummary: AccountSummaryResponseDto | null;
-    resync: () => Promise<void>;
 };

package/dist/hooks/useTwap.d.ts

@@ -0,0 +1,6 @@
+import type { ApiResponse, TwapMonitoringDto } from '../types';
+import type { CancelTwapResponseDto } from '../clients/orders';
+export declare function useTwap(): {
+    readonly orders: TwapMonitoringDto[];
+    readonly cancelTwap: (orderId: string) => Promise<ApiResponse<CancelTwapResponseDto>>;
+};

package/dist/hooks/useUserSelection.d.ts

@@ -0,0 +1,3 @@
+import type { UserSelectionState } from "../store/userSelection";
+export declare const useUserSelection: () => UserSelectionState;
+export type { UserSelectionState };

package/dist/hooks/useWatchlist.d.ts

@@ -0,0 +1,6 @@
+import type { ApiResponse, ToggleWatchlistResponseDto, WatchlistAssetDto, ActiveAssetGroupItem } from '../types';
+export declare function useWatchlist(): {
+    readonly watchlists: ActiveAssetGroupItem[] | null;
+    readonly isLoading: boolean;
+    readonly toggle: (longAssets: WatchlistAssetDto[], shortAssets: WatchlistAssetDto[]) => Promise<ApiResponse<ToggleWatchlistResponseDto>>;
+};

package/dist/hooks/useWebData.d.ts

@@ -0,0 +1,30 @@
+import type { ClearinghouseState, MarketDataBySymbol } from '../types';
+/**
+ * Hook to access webData and native WebSocket state
+ */
+export declare const useWebData: () => {
+    clearinghouseState: ClearinghouseState | null;
+    perpsAtOpenInterestCap: string[] | null;
+    /**
+     * 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 }
+     * ```
+     */
+    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;
+};