@pear-protocol/hyperliquid-sdk 0.1.2 → 0.1.4-pnl

package/dist/clients/auth.d.ts

@@ -1,4 +1,4 @@
-import type { ApiResponse, GetEIP712MessageResponse, AuthenticateRequest, AuthenticateResponse, RefreshTokenResponse, LogoutResponse } from '../types';
+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>>;
 /**

package/dist/clients/positions.d.ts

@@ -1,48 +1,5 @@
-import type { ApiResponse, ExternalFillDto } from "../types";
+import type { ApiResponse, CreatePositionRequestInput, CreatePositionResponseDto, TpSlThresholdInput } from "../types";
 import type { CancelTwapResponseDto } from "./orders";
-export type ExecutionType = "MARKET" | "TRIGGER" | "TWAP" | "LADDER" | "TP" | "SL" | "SPOT_MARKET" | "SPOT_LIMIT" | "SPOT_TWAP";
-export type TriggerType = "PRICE" | "PRICE_RATIO" | "WEIGHTED_RATIO" | "BTC_DOM" | "CROSS_ASSET_PRICE" | "PREDICTION_MARKET_OUTCOME";
-export type TpSlThresholdType = "PERCENTAGE" | "DOLLAR" | "POSITION_VALUE" | "PRICE" | "PRICE_RATIO" | "WEIGHTED_RATIO";
-export interface PairAssetInput {
-    asset: string;
-    weight?: number;
-}
-export interface TpSlThresholdInput {
-    type: TpSlThresholdType;
-    value?: number;
-    isTrailing?: boolean;
-    trailingDeltaValue?: number;
-    trailingActivationValue?: 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?: string | number;
-    triggerType?: TriggerType;
-    direction?: "MORE_THAN" | "LESS_THAN";
-    assetName?: string;
-    marketCode?: string;
-    twapDuration?: number;
-    twapIntervalSeconds?: number;
-    randomizeExecution?: boolean;
-    referralCode?: string;
-    ladderConfig?: LadderConfigInput;
-    takeProfit?: TpSlThresholdInput | null;
-    stopLoss?: TpSlThresholdInput | null;
-}
-export interface CreatePositionResponseDto {
-    orderId: string;
-    fills?: ExternalFillDto[];
-}
 /**
  * Create a position (MARKET/LIMIT/TWAP) using Pear Hyperliquid service
  * Authorization is derived from headers (Axios defaults or browser localStorage fallback)

package/dist/clients/tradeHistory.d.ts

@@ -0,0 +1,7 @@
+import type { ApiResponse, TradeHistoryDataDto } from '../types';
+export interface GetTradeHistoryParams {
+    startDate?: string;
+    endDate?: string;
+    limit?: number;
+}
+export declare function getTradeHistory(baseUrl: string, params?: GetTradeHistoryParams): Promise<ApiResponse<TradeHistoryDataDto[]>>;

package/dist/hooks/index.d.ts

@@ -18,3 +18,5 @@ export * from './usePortfolio';
 export * from './useAuth';
 export * from './useAllUserBalances';
 export * from './useHyperliquidUserFills';
+export * from './usePnlCalendar';
+export * from './usePnlHeatmap';

package/dist/hooks/useAgentWallet.d.ts

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

package/dist/hooks/useAllUserBalances.d.ts

@@ -1,9 +1,24 @@
-interface AllUserBalances {
-    spotUsdcBalance: number | undefined;
-    availableToTradeUsdc: number | undefined;
-    spotUsdhBalance: number | undefined;
-    availableToTradeUsdh: number | undefined;
+import { AvailableToTrades, SpotBalances, CollateralToken, UserAbstraction } from '../types';
+export interface MarginRequiredPerCollateral {
+    collateral: CollateralToken;
+    marginRequired: number;
+    availableBalance: number;
+    hasEnough: boolean;
+    shortfall: number;
+}
+export interface MarginRequiredResult {
+    totalMarginRequired: number;
+    orderValue: number;
+    perCollateral: MarginRequiredPerCollateral[];
+    hasEnoughTotal: boolean;
+}
+interface AllUserBalancesResult {
+    spotBalances: SpotBalances;
+    availableToTrades: AvailableToTrades;
     isLoading: boolean;
+    abstractionMode: UserAbstraction | null;
+    getMarginRequired: (assetsLeverage: Record<string, number>, size: number) => MarginRequiredResult;
+    getMaxSize: (assetsLeverage: Record<string, number>) => number;
 }
-export declare const useAllUserBalances: () => AllUserBalances;
+export declare const useAllUserBalances: () => AllUserBalancesResult;
 export {};

package/dist/hooks/useAuth.d.ts

@@ -1,7 +1,8 @@
-import type { GetEIP712MessageResponse } from "../types";
+import type { GetEIP712MessageResponse } from '../types';
 export declare function useAuth(): {
     readonly isReady: boolean;
     readonly isAuthenticated: boolean;
+    readonly address: string | null;
     readonly accessToken: string | null;
     readonly refreshToken: string | null;
     readonly getEip712: (address: string) => Promise<GetEIP712MessageResponse>;
@@ -9,4 +10,6 @@ export declare function useAuth(): {
     readonly loginWithPrivyToken: (address: string, appId: string, privyAccessToken: string) => Promise<void>;
     readonly refreshTokens: () => Promise<import("../types").RefreshTokenResponse>;
     readonly logout: () => Promise<void>;
+    readonly clearSession: () => void;
+    readonly setAddress: (address: string | null) => void;
 };

package/dist/hooks/useBasketCandles.d.ts

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

package/dist/hooks/useHistoricalPriceData.d.ts

@@ -4,6 +4,7 @@ export interface UseHistoricalPriceDataReturn {
     fetchHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval, callback?: (data: Record<string, CandleData[]>) => void) => Promise<Record<string, CandleData[]>>;
     hasHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval) => boolean;
     getHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval) => Record<string, CandleData[]>;
+    getEffectiveDataBoundary: (interval: CandleInterval) => number | null;
     getAllHistoricalPriceData(): Promise<Record<string, TokenHistoricalPriceData>>;
     isLoading: (symbol?: string) => boolean;
     clearCache: () => void;

package/dist/hooks/useMarketData.d.ts

@@ -1,9 +1,15 @@
 import type { ActiveAssetGroupItem, ActiveAssetsResponse } from '../types';
-export type CollateralFilter = 'USDC' | 'USDH' | 'ALL';
-export declare const useMarketDataPayload: () => ActiveAssetsResponse | 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 useFindBasket: (longs: string[], shorts: string[]) => ActiveAssetGroupItem | undefined;
+interface UseMarketDataHookOptions {
+    topGainersLimit?: number;
+    topLosersLimit?: number;
+}
+interface UseMarketDataHookResult {
+    marketData: ActiveAssetsResponse | null;
+    activeBaskets: ActiveAssetGroupItem[];
+    topGainers: ActiveAssetGroupItem[];
+    topLosers: ActiveAssetGroupItem[];
+    highlightedBaskets: ActiveAssetGroupItem[];
+    watchlistBaskets: ActiveAssetGroupItem[];
+}
+export declare const useMarketDataHook: (options?: UseMarketDataHookOptions) => UseMarketDataHookResult;
+export {};

package/dist/hooks/usePnlCalendar.d.ts

@@ -0,0 +1,57 @@
+import type { TokenMetadata } from '../types';
+export type PnlCalendarTimeframe = '2W' | '3W' | '2M' | '3M';
+export interface PnlCalendarOptions {
+    timeframe?: PnlCalendarTimeframe;
+    startDate?: Date | string;
+    endDate?: Date | string;
+}
+export interface PnlCalendarAsset {
+    coin: string;
+    metadata: TokenMetadata | null;
+}
+export interface PnlCalendarTrade {
+    tradeHistoryId: string;
+    realizedPnl: number;
+    result: 'profit' | 'loss' | 'breakeven';
+    closedLongAssets: PnlCalendarAsset[];
+    closedShortAssets: PnlCalendarAsset[];
+}
+export interface PnlCalendarDay {
+    date: string;
+    totalPnl: number;
+    volume: number;
+    positionsClosed: number;
+    result: 'profit' | 'loss' | 'breakeven';
+    trades: PnlCalendarTrade[];
+}
+export interface PeriodSummary {
+    pnl: number;
+    volume: number;
+    winRate: number;
+    wins: number;
+    losses: number;
+    totalProfit: number;
+    totalLoss: number;
+}
+export interface PnlCalendarWeek {
+    weekStart: string;
+    weekEnd: string;
+    days: PnlCalendarDay[];
+    summary: PeriodSummary;
+}
+export interface PnlCalendarMonth {
+    month: string;
+    label: string;
+    days: PnlCalendarDay[];
+    summary: PeriodSummary;
+}
+export interface UsePnlCalendarResult {
+    timeframe: PnlCalendarTimeframe;
+    weeks: PnlCalendarWeek[];
+    months: PnlCalendarMonth[];
+    overall: PeriodSummary;
+    isLoading: boolean;
+    error: string | null;
+    refetch: () => void;
+}
+export declare function usePnlCalendar(options?: PnlCalendarTimeframe | PnlCalendarOptions): UsePnlCalendarResult;

package/dist/hooks/usePnlHeatmap.d.ts

@@ -0,0 +1,13 @@
+import type { PnlCalendarTrade } from './usePnlCalendar';
+export type PnlHeatmapTimeframe = 'allTime' | '100D' | '30D' | '7D';
+export interface PnlHeatmapTrade extends PnlCalendarTrade {
+    percentage: number;
+}
+export interface UsePnlHeatmapResult {
+    timeframe: PnlHeatmapTimeframe;
+    trades: PnlHeatmapTrade[];
+    isLoading: boolean;
+    error: string | null;
+    refetch: () => void;
+}
+export declare function usePnlHeatmap(timeframe?: PnlHeatmapTimeframe): UsePnlHeatmapResult;

package/dist/hooks/usePosition.d.ts

@@ -1,5 +1,24 @@
-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';
+import { 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, CreatePositionRequestInput, CreatePositionResponseDto, OpenPositionDto } from '../types';
+export interface RebalanceAssetPlan {
+    coin: string;
+    side: 'long' | 'short';
+    currentWeight: number;
+    targetWeight: number;
+    currentValue: number;
+    targetValue: number;
+    deltaValue: number;
+    currentSize: number;
+    newSize: number;
+    deltaSize: number;
+    skipped: boolean;
+    skipReason?: string;
+}
+export interface RebalancePlan {
+    positionId: string;
+    assets: RebalanceAssetPlan[];
+    canExecute: boolean;
+}
 export declare function usePosition(): {
     readonly createPosition: (payload: CreatePositionRequestInput) => Promise<ApiResponse<CreatePositionResponseDto>>;
     readonly updateRiskParameters: (positionId: string, payload: UpdateRiskParametersRequestInput) => Promise<ApiResponse<UpdateRiskParametersResponseDto>>;
@@ -10,4 +29,6 @@ export declare function usePosition(): {
     readonly updateLeverage: (positionId: string, leverage: number) => Promise<ApiResponse<UpdateLeverageResponseDto | null>>;
     readonly openPositions: OpenPositionDto[] | null;
     readonly isLoading: boolean;
+    readonly planRebalance: (positionId: string, targetWeights?: Record<string, number>) => RebalancePlan;
+    readonly executeRebalance: (positionId: string, targetWeights?: Record<string, number>) => Promise<ApiResponse<AdjustAdvanceResponseDto>>;
 };

package/dist/hooks/useTokenSelectionMetadata.d.ts

@@ -12,7 +12,7 @@ export interface UseTokenSelectionMetadataReturn {
     volume: string;
     sumNetFunding: number;
     maxLeverage: number;
-    minMargin: number;
     leverageMatched: boolean;
+    minSize: Record<string, number>;
 }
 export declare const useTokenSelectionMetadata: () => UseTokenSelectionMetadataReturn;

package/dist/hooks/useUserSelection.d.ts

@@ -1,3 +1,18 @@
 import type { UserSelectionState } from "../store/userSelection";
-export declare const useUserSelection: () => UserSelectionState;
+export declare const useUserSelection: () => {
+    longTokens: import("..").TokenSelection[];
+    shortTokens: import("..").TokenSelection[];
+    candleInterval: import("..").CandleInterval;
+    openTokenSelector: boolean;
+    selectorConfig: import("..").TokenSelectorConfig | null;
+    openConflictModal: boolean;
+    setLongTokens: (tokens: import("..").TokenSelection[]) => void;
+    setShortTokens: (tokens: import("..").TokenSelection[]) => void;
+    setCandleInterval: (interval: import("..").CandleInterval) => void;
+    setTokenSelections: (longTokens: import("..").TokenSelection[], shortTokens: import("..").TokenSelection[]) => void;
+    setOpenTokenSelector: (open: boolean) => void;
+    setSelectorConfig: (config: import("..").TokenSelectorConfig | null) => void;
+    setOpenConflictModal: (open: boolean) => void;
+    addToken: (isLong: boolean) => boolean;
+};
 export type { UserSelectionState };