@pear-protocol/hyperliquid-sdk 0.0.22 → 0.0.26

package/dist/clients/positions.d.ts

@@ -0,0 +1,49 @@
+import type { ApiResponse } from '../types';
+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 CreatePositionRequestInput {
+    slippage: number;
+    executionType: ExecutionType;
+    leverage: number;
+    usdValue: number;
+    longAssets?: PairAssetInput[];
+    shortAssets?: PairAssetInput[];
+    triggerValue?: number;
+    direction?: 'MORE_THAN' | 'LESS_THAN';
+    twapDuration?: number;
+    randomizeExecution?: boolean;
+    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
+ * Caller should supply an accessToken from localStorage.getItem('accessToken')
+ */
+export declare function createPosition(baseUrl: string, accessToken: string, payload: CreatePositionRequestInput): Promise<ApiResponse<CreatePositionResponseDto>>;

package/dist/clients/sync.d.ts

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

package/dist/hooks/index.d.ts

@@ -5,3 +5,8 @@ export * from './useWebData';
 export * from './useTokenSelectionMetadata';
 export * from './useHistoricalPriceData';
 export * from './useBasketCandles';
+export * from './usePerformanceOverlays';
+export * from './useAuth';
+export * from './useAgentWallet';
+export * from './useAutoSyncFills';
+export * from './usePosition';

package/dist/hooks/useAgentWallet.d.ts

@@ -0,0 +1,10 @@
+import type { GetAgentWalletResponseDto, CreateAgentWalletResponseDto, UseAgentWalletOptions, AgentWalletState } from '../types';
+export declare function useAgentWallet({ baseUrl }: UseAgentWalletOptions): {
+    readonly agentWallet: AgentWalletState;
+    readonly isReady: boolean;
+    readonly loading: false;
+    readonly error: null;
+    readonly refreshAgentWalletStatus: () => Promise<GetAgentWalletResponseDto>;
+    readonly createAgentWallet: () => Promise<CreateAgentWalletResponseDto>;
+    readonly notifyAgentWalletApproved: () => Promise<GetAgentWalletResponseDto>;
+};

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,12 @@
+export declare function useAuth(): {
+    readonly status: import("..").AuthStatus;
+    readonly isAuthenticated: boolean;
+    readonly accessToken: string | null;
+    readonly user: import("..").UserProfile | null;
+    readonly error: string | null;
+    readonly getEip712: (address: string) => Promise<any>;
+    readonly loginWithSignedMessage: (address: string, signature: string, timestamp: number) => Promise<void>;
+    readonly loginWithPrivyToken: (address: string, appId: string, accessToken: string) => Promise<void>;
+    readonly refreshTokens: () => Promise<any>;
+    readonly logout: () => Promise<void>;
+};

package/dist/hooks/useAutoSyncFills.d.ts

@@ -0,0 +1,21 @@
+import type { SyncFillsResponseDto } from '../types';
+export interface AutoSyncFillsOptions {
+    baseUrl: string;
+    accessToken: string;
+    address: string | null;
+    intervalMs?: number;
+    aggregateByTime?: boolean;
+    enabled?: 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

@@ -1,6 +1,8 @@
-import type { CandleInterval, WeightedCandleData } from '../types';
+import type { CandleData, CandleInterval } from '../types';
 export interface UseBasketCandlesReturn {
-    fetchBasketCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<WeightedCandleData[]>;
+    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;

package/dist/hooks/useHistoricalPriceData.d.ts

@@ -1,8 +1,10 @@
+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;
 }

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/usePosition.d.ts

@@ -0,0 +1,7 @@
+import { type CreatePositionRequestInput, type CreatePositionResponseDto } from '../clients/positions';
+import type { ApiResponse, OpenPositionDto } from '../types';
+export declare function usePosition(): {
+    readonly createPosition: (payload: CreatePositionRequestInput) => Promise<ApiResponse<CreatePositionResponseDto>>;
+    readonly openPositions: OpenPositionDto[] | null;
+    readonly isLoading: boolean;
+};

package/dist/hooks/useTrading.d.ts

@@ -1,20 +1,9 @@
 import type { AccountSummaryResponseDto, OpenLimitOrderDto } from '../types';
 import type { TradeHistoryDataDto } from '../types';
-import type { OpenPositionDto } from '../types';
 export declare const useTradeHistories: () => {
     data: TradeHistoryDataDto[] | null;
     isLoading: boolean;
 };
-/**
- * Hook to access open positions with real-time calculations and loading state
- */
-export declare const useOpenPositions: () => {
-    data: null;
-    isLoading: boolean;
-} | {
-    data: OpenPositionDto[];
-    isLoading: boolean;
-};
 /**
  * Hook to access open orders with loading state
  */