@pear-protocol/hyperliquid-sdk 0.0.26 → 0.0.29

package/dist/clients/orders.d.ts

@@ -0,0 +1,24 @@
+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, accessToken: string, orderId: string, payload: AdjustOrderRequestInput): Promise<ApiResponse<AdjustOrderResponseDto>>;
+export interface CancelOrderResponseDto {
+    orderId: string;
+    status: string;
+    cancelledAt: string;
+}
+export declare function cancelOrder(baseUrl: string, accessToken: string, orderId: string): Promise<ApiResponse<CancelOrderResponseDto>>;
+export interface CancelTwapResponseDto {
+    orderId: string;
+    status: string;
+    cancelledAt: string;
+}
+export declare function cancelTwapOrder(baseUrl: string, accessToken: string, orderId: string): Promise<ApiResponse<CancelTwapResponseDto>>;

package/dist/clients/positions.d.ts

@@ -47,3 +47,43 @@ export interface CreatePositionResponseDto {
  * 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/hooks/index.d.ts

@@ -10,3 +10,4 @@ export * from './useAuth';
 export * from './useAgentWallet';
 export * from './useAutoSyncFills';
 export * from './usePosition';
+export * from './useOrders';

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

@@ -1,7 +1,10 @@
-import { type CreatePositionRequestInput, type CreatePositionResponseDto } from '../clients/positions';
+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/index.d.ts

@@ -58,6 +58,7 @@ interface WebSocketDataMessage<T = unknown> {
  */
 interface TradeHistoryAssetDataDto {
     coin: string;
+    entryWeight: number;
     entryPrice: number;
     limitPrice: number;
     size: number;
@@ -615,6 +616,7 @@ interface UserSelectionState {
     addToken: (isLong: boolean) => void;
     removeToken: (isLong: boolean, index: number) => void;
     handleTokenSelect: (selectedToken: string) => void;
+    setTokenSelections: (longTokens: TokenSelection[], shortTokens: TokenSelection[]) => void;
     resetToDefaults: () => void;
 }
 
@@ -801,13 +803,88 @@ interface CreatePositionResponseDto {
  * Caller should supply an accessToken from localStorage.getItem('accessToken')
  */
 declare function createPosition(baseUrl: string, accessToken: string, payload: CreatePositionRequestInput): 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, accessToken: string, positionId: string, payload: UpdateRiskParametersRequestInput): Promise<ApiResponse<UpdateRiskParametersResponseDto>>;
+type CloseExecutionType = 'MARKET' | 'TWAP';
+interface ClosePositionRequestInput {
+    executionType: CloseExecutionType;
+    twapDuration?: number;
+    randomizeExecution?: boolean;
+}
+interface ClosePositionResponseDto {
+    orderId: string;
+    executionTime?: string;
+    chunksScheduled?: number;
+}
+declare function closePosition(baseUrl: string, accessToken: string, positionId: string, payload: ClosePositionRequestInput): Promise<ApiResponse<ClosePositionResponseDto>>;
+type AdjustExecutionType = 'MARKET' | 'LIMIT';
+type PositionAdjustmentType = 'REDUCE' | 'INCREASE';
+interface AdjustPositionRequestInput {
+    adjustmentType: PositionAdjustmentType;
+    adjustmentSize: number;
+    executionType: AdjustExecutionType;
+    limitRatio?: number;
+}
+interface AdjustPositionResponseDto {
+    orderId: string;
+    status: string;
+    adjustmentType: PositionAdjustmentType;
+    adjustmentSize: number;
+    newSize: number;
+    executedAt: string;
+}
+declare function adjustPosition(baseUrl: string, accessToken: string, positionId: string, payload: AdjustPositionRequestInput): Promise<ApiResponse<AdjustPositionResponseDto>>;
 
 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;
 };
 
+interface AdjustOrderRequestInput {
+    limitRatio?: number;
+    usdValue?: number;
+}
+interface AdjustOrderResponseDto {
+    orderId: string;
+    limitRatio: number;
+    usdValue: number;
+    updatedAt: string;
+}
+declare function adjustOrder(baseUrl: string, accessToken: string, orderId: string, payload: AdjustOrderRequestInput): Promise<ApiResponse<AdjustOrderResponseDto>>;
+interface CancelOrderResponseDto {
+    orderId: string;
+    status: string;
+    cancelledAt: string;
+}
+declare function cancelOrder(baseUrl: string, accessToken: string, orderId: string): Promise<ApiResponse<CancelOrderResponseDto>>;
+interface CancelTwapResponseDto {
+    orderId: string;
+    status: string;
+    cancelledAt: string;
+}
+declare function cancelTwapOrder(baseUrl: string, accessToken: string, orderId: string): Promise<ApiResponse<CancelTwapResponseDto>>;
+
+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 UseHyperliquidWebSocketProps {
     wsUrl: string;
     address: string | null;
@@ -931,5 +1008,5 @@ declare function mapTradingViewIntervalToCandleInterval(interval: string): Candl
  */
 declare function mapCandleIntervalToTradingViewInterval(interval: CandleInterval): string;
 
-export { AccountSummaryCalculator, AuthStatus, ConflictDetector, PearHyperliquidProvider, TokenMetadataExtractor, calculateWeightedRatio, computeBasketCandles, createCandleLookups, createPosition, getCompleteTimestamps, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, useAccountSummary, useAddress, useAgentWallet, useAuth, useAutoSyncFills, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useOpenOrders, usePearAgentWallet, usePearAuth, usePearHyperliquid, usePerformanceOverlays, usePosition, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };
-export type { AccountSummaryResponseDto, AgentWalletDto, AgentWalletState, ApiErrorResponse, ApiResponse, AssetCtx, AssetInformationDetail, AssetMarketData, AssetPosition, AutoSyncFillsOptions, AutoSyncFillsState, BalanceSummaryDto, CandleChartData, CandleData, CandleInterval, CandleSnapshotRequest, ClearinghouseState, CreatePositionRequestInput, CreatePositionResponseDto, CrossMarginSummaryDto, CumFundingDto, ExecutionType, HLWebSocketResponse, HistoricalRange, MarginSummaryDto, OpenLimitOrderDto, OpenPositionDto, OrderAssetDto, OrderStatus, PairAssetInput, PerformanceOverlay, PositionAssetDetailDto, PositionAssetSummaryDto, PositionResponseStatus, RealtimeBar, RealtimeBarsCallback, TokenConflict, TokenHistoricalPriceData, TokenMetadata, TokenSelection, TpSlThresholdInput, TpSlThresholdType, TradeHistoryAssetDataDto, TradeHistoryDataDto, UniverseAsset, UseAgentWalletOptions, UseAuthOptions, UseBasketCandlesReturn, UseHistoricalPriceDataReturn, UsePerformanceOverlaysReturn, UseTokenSelectionMetadataReturn, UserProfile, UserSelectionState, WebData2Response, WebSocketAckResponse, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketSubscribeMessage, WsAllMidsData };
+export { AccountSummaryCalculator, AuthStatus, ConflictDetector, PearHyperliquidProvider, TokenMetadataExtractor, adjustOrder, adjustPosition, calculateWeightedRatio, cancelOrder, cancelTwapOrder, closePosition, computeBasketCandles, createCandleLookups, createPosition, getCompleteTimestamps, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, updateRiskParameters, useAccountSummary, useAddress, useAgentWallet, useAuth, useAutoSyncFills, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useOpenOrders, useOrders, usePearAgentWallet, usePearAuth, usePearHyperliquid, usePerformanceOverlays, usePosition, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };
+export type { AccountSummaryResponseDto, AdjustExecutionType, AdjustOrderRequestInput, AdjustOrderResponseDto, AdjustPositionRequestInput, AdjustPositionResponseDto, AgentWalletDto, AgentWalletState, ApiErrorResponse, ApiResponse, AssetCtx, AssetInformationDetail, AssetMarketData, AssetPosition, AutoSyncFillsOptions, AutoSyncFillsState, BalanceSummaryDto, CancelOrderResponseDto, CancelTwapResponseDto, CandleChartData, CandleData, CandleInterval, CandleSnapshotRequest, ClearinghouseState, CloseExecutionType, ClosePositionRequestInput, ClosePositionResponseDto, CreatePositionRequestInput, CreatePositionResponseDto, CrossMarginSummaryDto, CumFundingDto, ExecutionType, HLWebSocketResponse, HistoricalRange, MarginSummaryDto, OpenLimitOrderDto, OpenPositionDto, OrderAssetDto, OrderStatus, PairAssetInput, PerformanceOverlay, PositionAdjustmentType, PositionAssetDetailDto, PositionAssetSummaryDto, PositionResponseStatus, RealtimeBar, RealtimeBarsCallback, TokenConflict, TokenHistoricalPriceData, TokenMetadata, TokenSelection, TpSlThresholdInput, TpSlThresholdType, TradeHistoryAssetDataDto, TradeHistoryDataDto, UniverseAsset, UpdateRiskParametersRequestInput, UpdateRiskParametersResponseDto, UseAgentWalletOptions, UseAuthOptions, UseBasketCandlesReturn, UseHistoricalPriceDataReturn, UsePerformanceOverlaysReturn, UseTokenSelectionMetadataReturn, UserProfile, UserSelectionState, WebData2Response, WebSocketAckResponse, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketSubscribeMessage, WsAllMidsData };

package/dist/index.js

@@ -2705,6 +2705,19 @@ const useUserSelection$1 = create((set, get) => ({
             }
         });
     },
+    setTokenSelections: (longTokens, shortTokens) => {
+        set((prev) => {
+            const longTotal = longTokens.reduce((s, t) => s + t.weight, 0);
+            const shortTotal = shortTokens.reduce((s, t) => s + t.weight, 0);
+            const isWeightBalanced = longTotal + shortTotal === 100;
+            return {
+                ...prev,
+                longTokens,
+                shortTokens,
+                isWeightBalanced,
+            };
+        });
+    },
     resetToDefaults: () => set((prev) => ({ ...prev, ...DEFAULT_STATE })),
 }));
 
@@ -6883,7 +6896,7 @@ function useAgentWallet({ baseUrl }) {
     const setAccountSummary = useUserData((state) => state.setAccountSummary);
     const agentWallet = {
         address: ((_a = accountSummary === null || accountSummary === void 0 ? void 0 : accountSummary.agentWallet) === null || _a === void 0 ? void 0 : _a.address) || null,
-        name: 'Trading Agent',
+        name: 'Pear Protocol',
         status: ((_b = accountSummary === null || accountSummary === void 0 ? void 0 : accountSummary.agentWallet) === null || _b === void 0 ? void 0 : _b.status) || null,
         isActive: ((_c = accountSummary === null || accountSummary === void 0 ? void 0 : accountSummary.agentWallet) === null || _c === void 0 ? void 0 : _c.status) === 'ACTIVE',
     };
@@ -7297,14 +7310,14 @@ const useTokenSelectionMetadataStore = create((set) => ({
                 const metadata = longTokensMetadata[token.symbol];
                 if ((metadata === null || metadata === void 0 ? void 0 : metadata.netFunding) && token.weight > 0) {
                     const weightFactor = token.weight / 100;
-                    totalFunding += metadata.netFunding * weightFactor;
+                    totalFunding += -metadata.netFunding * weightFactor;
                 }
             });
             shortTokens.forEach((token) => {
                 const metadata = shortTokensMetadata[token.symbol];
                 if ((metadata === null || metadata === void 0 ? void 0 : metadata.netFunding) && token.weight > 0) {
                     const weightFactor = token.weight / 100;
-                    totalFunding -= metadata.netFunding * weightFactor;
+                    totalFunding += metadata.netFunding * weightFactor;
                 }
             });
             return totalFunding;
@@ -7522,35 +7535,33 @@ const useHistoricalPriceDataStore = create((set, get) => ({
 }));
 
 /**
-   * Fetch historical candle data from HyperLiquid API
-   * @param coin - Token symbol (e.g., 'BTC', 'ETH')
-   * @param startTime - Start time in milliseconds
-   * @param endTime - End time in milliseconds
-   * @param interval - Candle interval
-   * @returns Promise with historical candle data
-   */
+ * Fetch historical candle data from HyperLiquid API
+ */
 const fetchHistoricalCandles = async (coin, startTime, endTime, interval) => {
     const request = {
-        req: {
-            coin,
-            startTime,
-            endTime,
-            interval
-        },
-        type: "candleSnapshot"
+        req: { coin, startTime, endTime, interval },
+        type: 'candleSnapshot',
     };
     try {
         const response = await axios$1.post('https://api.hyperliquid.xyz/info', request, {
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            timeout: 30000,
+            headers: { 'Content-Type': 'application/json' },
         });
-        return {
-            data: response.data,
-            status: response.status,
-            headers: response.headers,
-        };
+        return { data: response.data, status: response.status, headers: response.headers };
+    }
+    catch (error) {
+        throw toApiError(error);
+    }
+};
+/**
+ * Retrieve recent user fills from HyperLiquid and map to ExternalFillDto[]
+ */
+const fetchUserFillsFromHyperliquid = async (user, aggregateByTime = true) => {
+    const request = { type: 'userFills', user, aggregateByTime };
+    try {
+        const response = await axios$1.post('https://api.hyperliquid.xyz/info', request, {
+            headers: { 'Content-Type': 'application/json' },
+        });
+        return { data: response.data, status: response.status, headers: response.headers };
     }
     catch (error) {
         throw toApiError(error);
@@ -8144,22 +8155,6 @@ function useAuth() {
     };
 }
 
-/**
- * Retrieve recent user fills from HyperLiquid and map to ExternalFillDto[]
- */
-const fetchUserFillsFromHyperliquid = async (user, aggregateByTime = true) => {
-    const request = { type: 'userFills', user, aggregateByTime };
-    try {
-        const response = await axios$1.post('https://api.hyperliquid.xyz/info', request, {
-            headers: { 'Content-Type': 'application/json' },
-        });
-        return { data: response.data, status: response.status, headers: response.headers };
-    }
-    catch (error) {
-        throw toApiError(error);
-    }
-};
-
 /**
  * Sync external fills into Pear Hyperliquid service (POST /sync/fills)
  */
@@ -8266,6 +8261,36 @@ async function createPosition(baseUrl, accessToken, payload) {
         throw toApiError(error);
     }
 }
+async function updateRiskParameters(baseUrl, accessToken, positionId, payload) {
+    const url = joinUrl(baseUrl, `/positions/${positionId}/riskParameters`);
+    try {
+        const resp = await axios$1.put(url, payload, { headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${accessToken}` }, timeout: 60000 });
+        return { data: resp.data, status: resp.status, headers: resp.headers };
+    }
+    catch (error) {
+        throw toApiError(error);
+    }
+}
+async function closePosition(baseUrl, accessToken, positionId, payload) {
+    const url = joinUrl(baseUrl, `/positions/${positionId}/close`);
+    try {
+        const resp = await axios$1.post(url, payload, { headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${accessToken}` }, timeout: 60000 });
+        return { data: resp.data, status: resp.status, headers: resp.headers };
+    }
+    catch (error) {
+        throw toApiError(error);
+    }
+}
+async function adjustPosition(baseUrl, accessToken, positionId, payload) {
+    const url = joinUrl(baseUrl, `/positions/${positionId}/adjust`);
+    try {
+        const resp = await axios$1.post(url, payload, { headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${accessToken}` }, timeout: 60000 });
+        return { data: resp.data, status: resp.status, headers: resp.headers };
+    }
+    catch (error) {
+        throw toApiError(error);
+    }
+}
 
 const calculatePositionAsset = (asset, currentPrice, totalInitialPositionSize, leverage, cumFunding, isLong = true) => {
     const initialPositionValue = asset.entryPrice * asset.size;
@@ -8302,6 +8327,8 @@ const buildPositionValue = (rawPositions, webData2, allMids) => {
             unrealizedPnl: 0,
             netFunding: 0,
             positionValue: 0,
+            takeProfit: position.takeProfit,
+            stopLoss: position.stopLoss,
         };
         const totalInitialPositionSize = position.longAssets.reduce((acc, asset) => acc + (asset.entryPrice * asset.size), 0) +
             position.shortAssets.reduce((acc, asset) => acc + (asset.entryPrice * asset.size), 0);
@@ -8350,6 +8377,24 @@ function usePosition() {
             throw new Error('Not authenticated');
         return createPosition(apiBaseUrl, accessToken, payload);
     };
+    // Update TP/SL risk parameters for a position
+    const updateRiskParameters$1 = async (positionId, payload) => {
+        if (!accessToken)
+            throw new Error('Not authenticated');
+        return updateRiskParameters(apiBaseUrl, accessToken, positionId, payload);
+    };
+    // Close a position (MARKET or TWAP)
+    const closePosition$1 = async (positionId, payload) => {
+        if (!accessToken)
+            throw new Error('Not authenticated');
+        return closePosition(apiBaseUrl, accessToken, positionId, payload);
+    };
+    // Adjust a position (REDUCE/INCREASE by %; MARKET or LIMIT)
+    const adjustPosition$1 = async (positionId, payload) => {
+        if (!accessToken)
+            throw new Error('Not authenticated');
+        return adjustPosition(apiBaseUrl, accessToken, positionId, payload);
+    };
     // Open positions using WS data, with derived values
     const userOpenPositions = useUserData((state) => state.rawOpenPositions);
     const webData2 = useHyperliquidData((state) => state.webData2);
@@ -8362,7 +8407,99 @@ function usePosition() {
             return null;
         return buildPositionValue(userOpenPositions, webData2, allMids);
     }, [userOpenPositions, webData2, allMids]);
-    return { createPosition: createPosition$1, openPositions, isLoading };
+    return { createPosition: createPosition$1, updateRiskParameters: updateRiskParameters$1, closePosition: closePosition$1, adjustPosition: adjustPosition$1, openPositions, isLoading };
+}
+
+async function adjustOrder(baseUrl, accessToken, orderId, payload) {
+    const url = joinUrl(baseUrl, `/orders/${orderId}/adjust`);
+    try {
+        const resp = await axios$1.put(url, payload, { headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${accessToken}` }, timeout: 60000 });
+        return { data: resp.data, status: resp.status, headers: resp.headers };
+    }
+    catch (error) {
+        throw toApiError(error);
+    }
+}
+async function cancelOrder(baseUrl, accessToken, orderId) {
+    const url = joinUrl(baseUrl, `/orders/${orderId}/cancel`);
+    try {
+        const resp = await axios$1.delete(url, { headers: { Authorization: `Bearer ${accessToken}` }, timeout: 60000 });
+        return { data: resp.data, status: resp.status, headers: resp.headers };
+    }
+    catch (error) {
+        throw toApiError(error);
+    }
+}
+async function cancelTwapOrder(baseUrl, accessToken, orderId) {
+    const url = joinUrl(baseUrl, `/orders/${orderId}/twap/cancel`);
+    try {
+        const resp = await axios$1.post(url, {}, { headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${accessToken}` }, timeout: 60000 });
+        return { data: resp.data, status: resp.status, headers: resp.headers };
+    }
+    catch (error) {
+        throw toApiError(error);
+    }
+}
+
+function useOrders() {
+    const context = useContext(PearHyperliquidContext);
+    if (!context)
+        throw new Error('useOrders must be used within a PearHyperliquidProvider');
+    const { apiBaseUrl, accessToken } = context;
+    const openOrders = useUserData((state) => state.openOrders);
+    const isLoading = useMemo(() => openOrders === null && context.isConnected, [openOrders, context.isConnected]);
+    const { openPositions } = usePosition();
+    const positionsById = useMemo(() => {
+        const map = new Map();
+        if (openPositions) {
+            for (const p of openPositions)
+                map.set(p.positionId, p);
+        }
+        return map;
+    }, [openPositions]);
+    const enrichedOpenOrders = useMemo(() => {
+        if (!openOrders)
+            return null;
+        return openOrders.map((ord) => {
+            var _a, _b, _c, _d;
+            const isTpSl = ord.orderType === 'TP' || ord.orderType === 'SL';
+            const hasAssets = ((_b = (_a = ord.longAssets) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0 || ((_d = (_c = ord.shortAssets) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0;
+            const pos = positionsById.get(ord.positionId);
+            if (!isTpSl || !pos)
+                return ord;
+            // Build order assets from position weights when TP/SL has no assets
+            const mapAssets = (arr) => arr.map((a) => ({ asset: a.coin, weight: a.initialWeight }));
+            if (!hasAssets) {
+                return {
+                    ...ord,
+                    leverage: pos.leverage,
+                    longAssets: mapAssets(pos.longAssets),
+                    shortAssets: mapAssets(pos.shortAssets),
+                };
+            }
+            // Always sync leverage from position for TP/SL
+            if (ord.leverage !== pos.leverage) {
+                return { ...ord, leverage: pos.leverage };
+            }
+            return ord;
+        });
+    }, [openOrders, positionsById]);
+    const adjustOrder$1 = async (orderId, payload) => {
+        if (!accessToken)
+            throw new Error('Not authenticated');
+        return adjustOrder(apiBaseUrl, accessToken, orderId, payload);
+    };
+    const cancelOrder$1 = async (orderId) => {
+        if (!accessToken)
+            throw new Error('Not authenticated');
+        return cancelOrder(apiBaseUrl, accessToken, orderId);
+    };
+    const cancelTwapOrder$1 = async (orderId) => {
+        if (!accessToken)
+            throw new Error('Not authenticated');
+        return cancelTwapOrder(apiBaseUrl, accessToken, orderId);
+    };
+    return { adjustOrder: adjustOrder$1, cancelOrder: cancelOrder$1, cancelTwapOrder: cancelTwapOrder$1, openOrders: enrichedOpenOrders, isLoading };
 }
 
 const PearHyperliquidContext = createContext(undefined);
@@ -8663,4 +8800,4 @@ function mapCandleIntervalToTradingViewInterval(interval) {
     }
 }
 
-export { AccountSummaryCalculator, AuthStatus, ConflictDetector, PearHyperliquidProvider, TokenMetadataExtractor, calculateWeightedRatio, computeBasketCandles, createCandleLookups, createPosition, getCompleteTimestamps, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, useAccountSummary, useAddress, useAgentWallet, useAuth, useAutoSyncFills, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useOpenOrders, usePearAgentWallet, usePearAuth, usePearHyperliquid, usePerformanceOverlays, usePosition, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };
+export { AccountSummaryCalculator, AuthStatus, ConflictDetector, PearHyperliquidProvider, TokenMetadataExtractor, adjustOrder, adjustPosition, calculateWeightedRatio, cancelOrder, cancelTwapOrder, closePosition, computeBasketCandles, createCandleLookups, createPosition, getCompleteTimestamps, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, updateRiskParameters, useAccountSummary, useAddress, useAgentWallet, useAuth, useAutoSyncFills, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useOpenOrders, useOrders, usePearAgentWallet, usePearAuth, usePearHyperliquid, usePerformanceOverlays, usePosition, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };

package/dist/store/userSelection.d.ts

@@ -19,6 +19,7 @@ interface UserSelectionState {
     addToken: (isLong: boolean) => void;
     removeToken: (isLong: boolean, index: number) => void;
     handleTokenSelect: (selectedToken: string) => void;
+    setTokenSelections: (longTokens: TokenSelection[], shortTokens: TokenSelection[]) => void;
     resetToDefaults: () => void;
 }
 export declare const useUserSelection: any;

package/dist/types.d.ts

@@ -79,6 +79,7 @@ export interface WebSocketDataMessage<T = unknown> {
  */
 export interface TradeHistoryAssetDataDto {
     coin: string;
+    entryWeight: number;
     entryPrice: number;
     limitPrice: number;
     size: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/hyperliquid-sdk",
-  "version": "0.0.26",
+  "version": "0.0.29",
   "description": "React SDK for Pear Protocol Hyperliquid API integration",
   "type": "module",
   "main": "dist/index.js",

package/dist/client.d.ts

@@ -1,36 +0,0 @@
-import { ApiResponse, CandleInterval, CandleData, SyncFillsRequestDto, SyncFillsResponseDto, ExternalFillDto, GetEIP712MessageResponse, AuthenticateRequest, AuthenticateResponse, RefreshTokenResponse, LogoutResponse, GetAgentWalletResponseDto, CreateAgentWalletResponseDto } from "./types";
-/**
-   * Fetch historical candle data from HyperLiquid API
-   * @param coin - Token symbol (e.g., 'BTC', 'ETH')
-   * @param startTime - Start time in milliseconds
-   * @param endTime - End time in milliseconds
-   * @param interval - Candle interval
-   * @returns Promise with historical candle data
-   */
-export declare const fetchHistoricalCandles: (coin: string, startTime: number, endTime: number, interval: CandleInterval) => Promise<ApiResponse<CandleData[]>>;
-/**
- * Retrieve recent fills for a user from HyperLiquid and map to ExternalFillDto[]
- * @param user - EVM address (0x...)
- * @param aggregateByTime - Combine partial fills for the same crossing order
- */
-export declare const fetchUserFillsFromHyperliquid: (user: string, aggregateByTime?: boolean) => Promise<ApiResponse<ExternalFillDto[]>>;
-/**
- * Convenience: fetch user fills from HyperLiquid, then sync them to Pear backend
- * Returns the Pear backend SyncFillsResponseDto
- */
-export declare const syncUserFillsFromHyperliquid: (baseUrl: string, accessToken: string, user: string, aggregateByTime?: boolean) => Promise<ApiResponse<SyncFillsResponseDto>>;
-export declare function getEIP712Message(baseUrl: string, address: string, clientId: string): Promise<ApiResponse<GetEIP712MessageResponse>>;
-export declare function authenticate(baseUrl: string, body: AuthenticateRequest): 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>>;
-export declare function getAgentWallet(baseUrl: string, accessToken: string): Promise<ApiResponse<GetAgentWalletResponseDto>>;
-export declare function createAgentWallet(baseUrl: string, accessToken: string): Promise<ApiResponse<CreateAgentWalletResponseDto>>;
-/**
- * Sync external fills into Pear Hyperliquid service
- * Mirrors POST /sync/fills in pear-hyperliquid service
- * @param baseUrl - Base URL of Pear Hyperliquid API (e.g., 'http://localhost:3000')
- * @param accessToken - Bearer access token for Authorization header
- * @param payload - Sync fills request body
- * @returns Promise with sync result summary
- */
-export declare const syncFills: (baseUrl: string, accessToken: string, payload: SyncFillsRequestDto) => Promise<ApiResponse<SyncFillsResponseDto>>;