@pear-protocol/hyperliquid-sdk 0.0.24 → 0.0.28

package/dist/clients/positions.d.ts

@@ -0,0 +1,89 @@
+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>>;
+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, accessToken: string, positionId: string, payload: UpdateRiskParametersRequestInput): Promise<ApiResponse<UpdateRiskParametersResponseDto>>;
+export type CloseExecutionType = 'MARKET' | 'TWAP';
+export interface ClosePositionRequestInput {
+    executionType: CloseExecutionType;
+    twapDuration?: number;
+    randomizeExecution?: boolean;
+}
+export interface ClosePositionResponseDto {
+    orderId: string;
+    executionTime?: string;
+    chunksScheduled?: number;
+}
+export declare function closePosition(baseUrl: string, accessToken: string, positionId: string, payload: ClosePositionRequestInput): Promise<ApiResponse<ClosePositionResponseDto>>;
+export type AdjustExecutionType = 'MARKET' | 'LIMIT';
+export type PositionAdjustmentType = 'REDUCE' | 'INCREASE';
+export interface AdjustPositionRequestInput {
+    adjustmentType: PositionAdjustmentType;
+    adjustmentSize: number;
+    executionType: AdjustExecutionType;
+    limitRatio?: number;
+}
+export interface AdjustPositionResponseDto {
+    orderId: string;
+    status: string;
+    adjustmentType: PositionAdjustmentType;
+    adjustmentSize: number;
+    newSize: number;
+    executedAt: string;
+}
+export declare function adjustPosition(baseUrl: string, accessToken: string, positionId: string, payload: AdjustPositionRequestInput): Promise<ApiResponse<AdjustPositionResponseDto>>;

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { type CreatePositionRequestInput, type CreatePositionResponseDto, type UpdateRiskParametersRequestInput, type UpdateRiskParametersResponseDto, type ClosePositionRequestInput, type ClosePositionResponseDto, type AdjustPositionRequestInput, type AdjustPositionResponseDto } 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 adjustPosition: (positionId: string, payload: AdjustPositionRequestInput) => Promise<ApiResponse<AdjustPositionResponseDto>>;
+    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
  */