@pear-protocol/hyperliquid-sdk 0.1.18 → 0.1.20-pnl

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

@@ -0,0 +1,61 @@
+export type PnlCalendarTimeframe = '2W' | '3W' | '2M' | '3M';
+export interface PnlCalendarOptions {
+    timeframe?: PnlCalendarTimeframe;
+    startDate?: Date | string;
+    endDate?: Date | string;
+}
+export interface PnlCalendarAsset {
+    coin: string;
+    symbol: string;
+    assetName: string;
+    marketPrefix: string;
+    percentage: number;
+    collateralToken: string;
+}
+export interface PnlCalendarTrade {
+    tradeHistoryId: string;
+    realizedPnl: number;
+    result: 'profit' | 'loss' | 'breakeven';
+    collateralTypes: string[];
+    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 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/index.d.ts

@@ -286,6 +286,7 @@ interface PositionAssetDetailDto {
     initialWeight: number;
     currentWeight: number;
     fundingPaid?: number;
+    targetWeight?: number;
     metadata?: TokenMetadata | null;
 }
 interface TpSlThreshold {
@@ -763,6 +764,7 @@ interface RawAssetDto {
     side: string;
     fundingPaid?: number;
     leverage: number;
+    targetWeight?: number;
 }
 /**
  * Raw position data from open-positions channel
@@ -1295,6 +1297,25 @@ interface UpdateLeverageResponseDto {
 }
 declare function updateLeverage(baseUrl: string, positionId: string, payload: UpdateLeverageRequestInput): Promise<ApiResponse<UpdateLeverageResponseDto | null>>;
 
+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;
+}
+interface RebalancePlan {
+    positionId: string;
+    assets: RebalanceAssetPlan[];
+    canExecute: boolean;
+}
 declare function usePosition(): {
     readonly createPosition: (payload: CreatePositionRequestInput) => Promise<ApiResponse<CreatePositionResponseDto>>;
     readonly updateRiskParameters: (positionId: string, payload: UpdateRiskParametersRequestInput) => Promise<ApiResponse<UpdateRiskParametersResponseDto>>;
@@ -1305,6 +1326,8 @@ 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>>;
 };
 
 declare function useOrders(): {
@@ -1475,6 +1498,81 @@ interface UseHyperliquidUserFillsState {
  */
 declare function useHyperliquidUserFills(options: UseHyperliquidUserFillsOptions): UseHyperliquidUserFillsState;
 
+type PnlCalendarTimeframe = '2W' | '3W' | '2M' | '3M';
+interface PnlCalendarOptions {
+    timeframe?: PnlCalendarTimeframe;
+    startDate?: Date | string;
+    endDate?: Date | string;
+}
+interface PnlCalendarAsset {
+    coin: string;
+    symbol: string;
+    assetName: string;
+    marketPrefix: string;
+    percentage: number;
+    collateralToken: string;
+}
+interface PnlCalendarTrade {
+    tradeHistoryId: string;
+    realizedPnl: number;
+    result: 'profit' | 'loss' | 'breakeven';
+    collateralTypes: string[];
+    closedLongAssets: PnlCalendarAsset[];
+    closedShortAssets: PnlCalendarAsset[];
+}
+interface PnlCalendarDay {
+    date: string;
+    totalPnl: number;
+    volume: number;
+    positionsClosed: number;
+    result: 'profit' | 'loss' | 'breakeven';
+    trades: PnlCalendarTrade[];
+}
+interface PeriodSummary {
+    pnl: number;
+    volume: number;
+    winRate: number;
+    wins: number;
+    losses: number;
+    totalProfit: number;
+    totalLoss: number;
+}
+interface PnlCalendarWeek {
+    weekStart: string;
+    weekEnd: string;
+    days: PnlCalendarDay[];
+    summary: PeriodSummary;
+}
+interface PnlCalendarMonth {
+    month: string;
+    label: string;
+    days: PnlCalendarDay[];
+    summary: PeriodSummary;
+}
+interface UsePnlCalendarResult {
+    timeframe: PnlCalendarTimeframe;
+    weeks: PnlCalendarWeek[];
+    months: PnlCalendarMonth[];
+    overall: PeriodSummary;
+    isLoading: boolean;
+    error: string | null;
+    refetch: () => void;
+}
+declare function usePnlCalendar(options?: PnlCalendarTimeframe | PnlCalendarOptions): UsePnlCalendarResult;
+
+type PnlHeatmapTimeframe = 'allTime' | '100D' | '30D' | '7D';
+interface PnlHeatmapTrade extends PnlCalendarTrade {
+    percentage: number;
+}
+interface UsePnlHeatmapResult {
+    timeframe: PnlHeatmapTimeframe;
+    trades: PnlHeatmapTrade[];
+    isLoading: boolean;
+    error: string | null;
+    refetch: () => void;
+}
+declare function usePnlHeatmap(timeframe?: PnlHeatmapTimeframe): UsePnlHeatmapResult;
+
 /**
  * Mark notifications as read up to a given timestamp (ms)
  */
@@ -1749,5 +1847,5 @@ interface MarketDataState {
 }
 declare const useMarketData: zustand.UseBoundStore<zustand.StoreApi<MarketDataState>>;
 
-export { ConflictDetector, MAX_ASSETS_PER_LEG, MINIMUM_ASSET_USD_VALUE, MaxAssetsPerLegError, MinimumPositionSizeError, PearHyperliquidProvider, ReadyState, adjustAdvancePosition, adjustOrder, adjustPosition, calculateMinimumPositionValue, calculateWeightedRatio, cancelOrder, cancelTwap, cancelTwapOrder, closeAllPositions, closePosition, computeBasketCandles, createCandleLookups, createPosition, executeSpotOrder, getCompleteTimestamps, getKalshiMarkets, getOrderDirection, getOrderLadderConfig, getOrderLeverage, getOrderReduceOnly, getOrderTpSlTriggerType, getOrderTrailingInfo, getOrderTriggerType, getOrderTriggerValue, getOrderTwapDuration, getOrderUsdValue, getPortfolio, isBtcDomOrder, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useAgentWallet, useAllUserBalances, useAuth, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidUserFills, useMarket, useMarketData, useMarketDataHook, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTradeHistories, useTwap, useUserSelection, useWatchlist, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };
-export type { AccountSummaryResponseDto, ActiveAssetData, ActiveAssetGroupItem, ActiveAssetsAllResponse, ActiveAssetsResponse, AddressState, AdjustAdvanceAssetInput, AdjustAdvanceItemInput, AdjustAdvanceResponseDto, AdjustExecutionType, AdjustOrderRequestInput, AdjustOrderResponseDto, AdjustPositionRequestInput, AdjustPositionResponseDto, AgentWalletDto, AgentWalletState, AgentWalletStatus, AllDexsAssetCtxsData, AllDexsClearinghouseStateData, AllPerpMetasItem, AllPerpMetasResponse, ApiErrorResponse, ApiResponse, AssetCtx, AssetInformationDetail, AssetMarketData, AssetPosition, AuthenticateRequest, AuthenticateResponse, AvailableToTrades, BalanceSummaryDto, BaseTriggerOrderNotificationParams, BtcDomTriggerParams, CancelOrderResponseDto, CancelTwapResponseDto, CandleChartData, CandleData, CandleInterval, CandleSnapshotRequest, ChunkFillDto, ClearinghouseState, CloseAllPositionsResponseDto, CloseAllPositionsResultDto, CloseExecutionType, ClosePositionRequestInput, ClosePositionResponseDto, CollateralToken, CreateAgentWalletResponseDto, CreatePositionRequestInput, CreatePositionResponseDto, CrossAssetPriceTriggerParams, CrossMarginSummaryDto, CumFundingDto, EIP712AuthDetails, ExecutionType, ExternalFillDto, ExternalLiquidationDto, ExtraAgent, GetAgentWalletResponseDto, GetEIP712MessageResponse, GetKalshiMarketsParams, HLChannel, HLChannelDataMap, HLWebSocketResponse, HistoricalRange, KalshiMarket, KalshiMarketsResponse, KalshiMveLeg, KalshiPriceRange, LadderConfigInput, LadderOrderParameters, LeverageInfo, LogoutRequest, LogoutResponse, MarginRequiredPerCollateral, MarginRequiredResult, MarginSummaryDto, MarginTableDef, MarginTablesEntry, MarginTier, MarketOrderParameters, NotificationCategory, NotificationDto, OpenLimitOrderDto, OpenPositionDto, OrderAssetDto, OrderDirection, OrderParameters, OrderStatus, OrderType, PairAssetDto, PairAssetInput, PerformanceOverlay, PerpDex, PerpDexsResponse, PerpMetaAsset, PlatformAccountSummaryResponseDto, PortfolioBucketDto, PortfolioInterval, PortfolioIntervalsDto, PortfolioOverallDto, PortfolioResponseDto, PositionAdjustmentType, PositionAssetDetailDto, PredictionMarketOutcomeTriggerParams, PriceRatioTriggerParams, PriceTriggerParams, PrivyAuthDetails, RawAssetDto, RawPositionDto, RealtimeBar, RealtimeBarsCallback, RefreshTokenRequest, RefreshTokenResponse, SpotBalance, SpotBalances, SpotOrderFilledStatus, SpotOrderHyperliquidData, SpotOrderHyperliquidResult, SpotOrderRequestInput, SpotOrderResponseDto, SpotState, SyncFillsRequestDto, SyncFillsResponseDto, ToggleWatchlistResponseDto, TokenConflict, TokenEntry, TokenHistoricalPriceData, TokenMetadata, TokenSelection, TokenSelectorConfig, TpSlOrderParameters, TpSlThreshold, TpSlThresholdInput, TpSlThresholdType, TpSlTriggerType, TradeHistoryAssetDataDto, TradeHistoryDataDto, TriggerOrderNotificationAsset, TriggerOrderNotificationParams, TriggerOrderNotificationType, TriggerOrderParameters, TriggerType, TwapChunkStatus, TwapChunkStatusDto, TwapMonitoringDto, TwapOrderOverallStatus, TwapOrderParameters, TwapSliceFillResponseItem, UniverseAsset, UpdateLeverageRequestInput, UpdateLeverageResponseDto, UpdateRiskParametersRequestInput, UpdateRiskParametersResponseDto, UseAuthOptions, UseBasketCandlesReturn, UseHistoricalPriceDataReturn, UseHyperliquidUserFillsOptions, UseHyperliquidUserFillsState, UseNotificationsResult, UsePerformanceOverlaysReturn, UsePortfolioResult, UseSpotOrderResult, UseTokenSelectionMetadataReturn, UserAbstraction, UserProfile, UserSelectionState, WatchlistAssetDto, WatchlistItemDto, WebData3AssetCtx, WebData3PerpDexState, WebData3Response, WebData3UserState, WebSocketAckResponse, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketSubscribeMessage, WsAllMidsData };
+export { ConflictDetector, MAX_ASSETS_PER_LEG, MINIMUM_ASSET_USD_VALUE, MaxAssetsPerLegError, MinimumPositionSizeError, PearHyperliquidProvider, ReadyState, adjustAdvancePosition, adjustOrder, adjustPosition, calculateMinimumPositionValue, calculateWeightedRatio, cancelOrder, cancelTwap, cancelTwapOrder, closeAllPositions, closePosition, computeBasketCandles, createCandleLookups, createPosition, executeSpotOrder, getCompleteTimestamps, getKalshiMarkets, getOrderDirection, getOrderLadderConfig, getOrderLeverage, getOrderReduceOnly, getOrderTpSlTriggerType, getOrderTrailingInfo, getOrderTriggerType, getOrderTriggerValue, getOrderTwapDuration, getOrderUsdValue, getPortfolio, isBtcDomOrder, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useAgentWallet, useAllUserBalances, useAuth, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidUserFills, useMarket, useMarketData, useMarketDataHook, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePnlCalendar, usePnlHeatmap, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTradeHistories, useTwap, useUserSelection, useWatchlist, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };
+export type { AccountSummaryResponseDto, ActiveAssetData, ActiveAssetGroupItem, ActiveAssetsAllResponse, ActiveAssetsResponse, AddressState, AdjustAdvanceAssetInput, AdjustAdvanceItemInput, AdjustAdvanceResponseDto, AdjustExecutionType, AdjustOrderRequestInput, AdjustOrderResponseDto, AdjustPositionRequestInput, AdjustPositionResponseDto, AgentWalletDto, AgentWalletState, AgentWalletStatus, AllDexsAssetCtxsData, AllDexsClearinghouseStateData, AllPerpMetasItem, AllPerpMetasResponse, ApiErrorResponse, ApiResponse, AssetCtx, AssetInformationDetail, AssetMarketData, AssetPosition, AuthenticateRequest, AuthenticateResponse, AvailableToTrades, BalanceSummaryDto, BaseTriggerOrderNotificationParams, BtcDomTriggerParams, CancelOrderResponseDto, CancelTwapResponseDto, CandleChartData, CandleData, CandleInterval, CandleSnapshotRequest, ChunkFillDto, ClearinghouseState, CloseAllPositionsResponseDto, CloseAllPositionsResultDto, CloseExecutionType, ClosePositionRequestInput, ClosePositionResponseDto, CollateralToken, CreateAgentWalletResponseDto, CreatePositionRequestInput, CreatePositionResponseDto, CrossAssetPriceTriggerParams, CrossMarginSummaryDto, CumFundingDto, EIP712AuthDetails, ExecutionType, ExternalFillDto, ExternalLiquidationDto, ExtraAgent, GetAgentWalletResponseDto, GetEIP712MessageResponse, GetKalshiMarketsParams, HLChannel, HLChannelDataMap, HLWebSocketResponse, HistoricalRange, KalshiMarket, KalshiMarketsResponse, KalshiMveLeg, KalshiPriceRange, LadderConfigInput, LadderOrderParameters, LeverageInfo, LogoutRequest, LogoutResponse, MarginRequiredPerCollateral, MarginRequiredResult, MarginSummaryDto, MarginTableDef, MarginTablesEntry, MarginTier, MarketOrderParameters, NotificationCategory, NotificationDto, OpenLimitOrderDto, OpenPositionDto, OrderAssetDto, OrderDirection, OrderParameters, OrderStatus, OrderType, PairAssetDto, PairAssetInput, PerformanceOverlay, PeriodSummary, PerpDex, PerpDexsResponse, PerpMetaAsset, PlatformAccountSummaryResponseDto, PnlCalendarAsset, PnlCalendarDay, PnlCalendarMonth, PnlCalendarOptions, PnlCalendarTimeframe, PnlCalendarTrade, PnlCalendarWeek, PnlHeatmapTimeframe, PnlHeatmapTrade, PortfolioBucketDto, PortfolioInterval, PortfolioIntervalsDto, PortfolioOverallDto, PortfolioResponseDto, PositionAdjustmentType, PositionAssetDetailDto, PredictionMarketOutcomeTriggerParams, PriceRatioTriggerParams, PriceTriggerParams, PrivyAuthDetails, RawAssetDto, RawPositionDto, RealtimeBar, RealtimeBarsCallback, RebalanceAssetPlan, RebalancePlan, RefreshTokenRequest, RefreshTokenResponse, SpotBalance, SpotBalances, SpotOrderFilledStatus, SpotOrderHyperliquidData, SpotOrderHyperliquidResult, SpotOrderRequestInput, SpotOrderResponseDto, SpotState, SyncFillsRequestDto, SyncFillsResponseDto, ToggleWatchlistResponseDto, TokenConflict, TokenEntry, TokenHistoricalPriceData, TokenMetadata, TokenSelection, TokenSelectorConfig, TpSlOrderParameters, TpSlThreshold, TpSlThresholdInput, TpSlThresholdType, TpSlTriggerType, TradeHistoryAssetDataDto, TradeHistoryDataDto, TriggerOrderNotificationAsset, TriggerOrderNotificationParams, TriggerOrderNotificationType, TriggerOrderParameters, TriggerType, TwapChunkStatus, TwapChunkStatusDto, TwapMonitoringDto, TwapOrderOverallStatus, TwapOrderParameters, TwapSliceFillResponseItem, UniverseAsset, UpdateLeverageRequestInput, UpdateLeverageResponseDto, UpdateRiskParametersRequestInput, UpdateRiskParametersResponseDto, UseAuthOptions, UseBasketCandlesReturn, UseHistoricalPriceDataReturn, UseHyperliquidUserFillsOptions, UseHyperliquidUserFillsState, UseNotificationsResult, UsePerformanceOverlaysReturn, UsePnlCalendarResult, UsePnlHeatmapResult, UsePortfolioResult, UseSpotOrderResult, UseTokenSelectionMetadataReturn, UserAbstraction, UserProfile, UserSelectionState, WatchlistAssetDto, WatchlistItemDto, WebData3AssetCtx, WebData3PerpDexState, WebData3Response, WebData3UserState, WebSocketAckResponse, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketSubscribeMessage, WsAllMidsData };

package/dist/index.js

@@ -1576,11 +1576,6 @@ const useAccountSummary = () => {
     const aggregatedClearingHouseState = useHyperliquidData((state) => state.aggregatedClearingHouseState);
     const registeredAgentWallets = useUserData((state) => state.userExtraAgents);
     const isLoading = useMemo(() => {
-        console.log('[USE ACCOUNT SUMMARY DEBUG] Loading check:', {
-            platformAccountSummary,
-            registeredAgentWallets,
-            aggregatedClearingHouseState,
-        });
         return !platformAccountSummary || !registeredAgentWallets || !aggregatedClearingHouseState;
     }, [platformAccountSummary, registeredAgentWallets, aggregatedClearingHouseState]);
     // Create calculator and compute account summary
@@ -7098,6 +7093,7 @@ const calculatePositionAsset = (asset, currentPrice, totalInitialPositionSize, t
         initialWeight: totalInitialPositionSize > 0 ? entryNotional / totalInitialPositionSize : 0,
         currentWeight: totalCurrentPositionSize > 0 ? currentNotional / totalCurrentPositionSize : 0,
         fundingPaid: (_a = asset.fundingPaid) !== null && _a !== void 0 ? _a : 0,
+        targetWeight: asset.targetWeight,
         metadata,
     };
 };
@@ -7203,6 +7199,7 @@ const buildPositionValue = (rawPositions, clearinghouseState, getAssetByName) =>
     });
 };
 
+const MIN_TRADE_SIZE_USD = 11;
 function usePosition() {
     const context = useContext(PearHyperliquidContext);
     if (!context) {
@@ -7245,6 +7242,85 @@ function usePosition() {
             return null;
         return buildPositionValue(userOpenPositions, aggregatedClearingHouseState, getAssetByName);
     }, [userOpenPositions, aggregatedClearingHouseState, tokenMetadata, getAssetByName]);
+    const planRebalance = (positionId, targetWeights) => {
+        var _a;
+        if (!openPositions) {
+            throw new Error('Open positions not loaded');
+        }
+        const position = openPositions.find((p) => p.positionId === positionId);
+        if (!position) {
+            throw new Error(`Position ${positionId} not found`);
+        }
+        const assets = [];
+        const allAssets = [
+            ...position.longAssets.map((a) => ({ asset: a, side: 'long' })),
+            ...position.shortAssets.map((a) => ({ asset: a, side: 'short' })),
+        ];
+        const totalValue = allAssets.reduce((sum, { asset }) => sum + asset.positionValue, 0);
+        for (const { asset, side } of allAssets) {
+            const tw = (_a = targetWeights === null || targetWeights === void 0 ? void 0 : targetWeights[asset.coin]) !== null && _a !== void 0 ? _a : asset.targetWeight;
+            if (tw === undefined) {
+                assets.push({
+                    coin: asset.coin,
+                    side,
+                    currentWeight: totalValue > 0 ? (asset.positionValue / totalValue) * 100 : 0,
+                    targetWeight: 0,
+                    currentValue: asset.positionValue,
+                    targetValue: asset.positionValue,
+                    deltaValue: 0,
+                    currentSize: asset.actualSize,
+                    newSize: asset.actualSize,
+                    deltaSize: 0,
+                    skipped: true,
+                    skipReason: 'No target weight defined',
+                });
+                continue;
+            }
+            const currentWeight = totalValue > 0 ? (asset.positionValue / totalValue) * 100 : 0;
+            const targetValue = totalValue * (tw / 100);
+            const deltaValue = targetValue - asset.positionValue;
+            const currentPrice = asset.actualSize > 0 ? asset.positionValue / asset.actualSize : 0;
+            const deltaSize = currentPrice > 0 ? deltaValue / currentPrice : 0;
+            const newSize = asset.actualSize + deltaSize;
+            const belowMinimum = Math.abs(deltaValue) > 0 && Math.abs(deltaValue) < MIN_TRADE_SIZE_USD;
+            assets.push({
+                coin: asset.coin,
+                side,
+                currentWeight,
+                targetWeight: tw,
+                currentValue: asset.positionValue,
+                targetValue,
+                deltaValue,
+                currentSize: asset.actualSize,
+                newSize,
+                deltaSize,
+                skipped: belowMinimum,
+                skipReason: belowMinimum
+                    ? `Trade size $${Math.abs(deltaValue).toFixed(2)} is below minimum $${MIN_TRADE_SIZE_USD}`
+                    : undefined,
+            });
+        }
+        const canExecute = assets.some((a) => !a.skipped && Math.abs(a.deltaValue) > 0);
+        return { positionId, assets, canExecute };
+    };
+    const executeRebalance = async (positionId, targetWeights) => {
+        const plan = planRebalance(positionId, targetWeights);
+        if (!plan.canExecute) {
+            throw new Error('No executable rebalance changes — all below minimum trade size or no changes needed');
+        }
+        const executable = plan.assets.filter((a) => !a.skipped && Math.abs(a.deltaValue) > 0);
+        const payload = [
+            {
+                longAssets: executable
+                    .filter((a) => a.side === 'long')
+                    .map((a) => ({ asset: a.coin, size: a.newSize })),
+                shortAssets: executable
+                    .filter((a) => a.side === 'short')
+                    .map((a) => ({ asset: a.coin, size: a.newSize })),
+            },
+        ];
+        return adjustAdvancePosition$1(positionId, payload);
+    };
     return {
         createPosition: createPosition$1,
         updateRiskParameters: updateRiskParameters$1,
@@ -7255,6 +7331,8 @@ function usePosition() {
         updateLeverage: updateLeverage$1,
         openPositions,
         isLoading,
+        planRebalance,
+        executeRebalance,
     };
 }
 
@@ -8070,14 +8148,20 @@ const useAllUserBalances = () => {
             }
         }
         if (!availableToTrades['USDC']) {
-            availableToTrades['USDC'] = parseFloat((aggregatedClearingHouseState === null || aggregatedClearingHouseState === void 0 ? void 0 : aggregatedClearingHouseState.marginSummary.accountValue) || '0') - parseFloat((aggregatedClearingHouseState === null || aggregatedClearingHouseState === void 0 ? void 0 : aggregatedClearingHouseState.marginSummary.totalMarginUsed) || '0');
+            availableToTrades['USDC'] = Math.max(0, parseFloat((aggregatedClearingHouseState === null || aggregatedClearingHouseState === void 0 ? void 0 : aggregatedClearingHouseState.marginSummary.accountValue) || '0') -
+                parseFloat((aggregatedClearingHouseState === null || aggregatedClearingHouseState === void 0 ? void 0 : aggregatedClearingHouseState.marginSummary.totalMarginUsed) || '0'));
         }
         return {
             spotBalances,
             availableToTrades,
             isLoading,
         };
-    }, [spotState, longTokensMetadata, shortTokensMetadata, aggregatedClearingHouseState]);
+    }, [
+        spotState,
+        longTokensMetadata,
+        shortTokensMetadata,
+        aggregatedClearingHouseState,
+    ]);
     /**
      * Calculate margin required for every collateral token based on asset leverages and size.
      * Returns margin required per collateral and whether there's sufficient margin.
@@ -8338,6 +8422,456 @@ function useHyperliquidUserFills(options) {
     };
 }
 
+async function getTradeHistory(baseUrl, params) {
+    const url = joinUrl(baseUrl, '/trade-history');
+    try {
+        const resp = await apiClient.get(url, {
+            params,
+            timeout: 60000,
+        });
+        return { data: resp.data, status: resp.status, headers: resp.headers };
+    }
+    catch (error) {
+        throw toApiError(error);
+    }
+}
+
+// ─── helpers ────────────────────────────────────────────────────
+const EMPTY_SUMMARY = {
+    pnl: 0,
+    volume: 0,
+    winRate: 0,
+    wins: 0,
+    losses: 0,
+    totalProfit: 0,
+    totalLoss: 0,
+};
+const getTimeframeDays$1 = (tf) => {
+    switch (tf) {
+        case '2W':
+            return 14;
+        case '3W':
+            return 21;
+        case '2M':
+            return 60;
+        case '3M':
+            return 90;
+    }
+};
+const isWeekTimeframe = (tf) => tf === '2W' || tf === '3W';
+const toDateKey = (date) => {
+    const y = date.getFullYear();
+    const m = String(date.getMonth() + 1).padStart(2, '0');
+    const d = String(date.getDate()).padStart(2, '0');
+    return `${y}-${m}-${d}`;
+};
+const toMonthKey = (date) => {
+    const y = date.getFullYear();
+    const m = String(date.getMonth() + 1).padStart(2, '0');
+    return `${y}-${m}`;
+};
+const formatMonthLabel = (date) => date.toLocaleDateString('en-US', { month: 'short', year: 'numeric' });
+const getMonday = (date) => {
+    const d = new Date(date);
+    const day = d.getDay(); // 0=Sun … 6=Sat
+    const diff = day === 0 ? -6 : 1 - day;
+    d.setDate(d.getDate() + diff);
+    d.setHours(0, 0, 0, 0);
+    return d;
+};
+const toLocalMidnight = (input) => {
+    const d = typeof input === 'string' ? new Date(input + 'T00:00:00') : new Date(input);
+    d.setHours(0, 0, 0, 0);
+    return d;
+};
+const diffDays = (start, end) => {
+    return Math.round((end.getTime() - start.getTime()) / (1000 * 60 * 60 * 24)) + 1;
+};
+const toISODateString$1 = (input) => {
+    const d = typeof input === 'string' ? new Date(input + 'T00:00:00') : new Date(input);
+    return d.toISOString();
+};
+const round2 = (n) => Math.round(n * 100) / 100;
+const mapAsset$1 = (asset, getAssetByName) => {
+    var _a, _b, _c, _d;
+    const metadata = getAssetByName(asset.coin);
+    const marketInfo = getMarketInfoFromSymbol(asset.coin);
+    return {
+        coin: asset.coin,
+        symbol: (_a = metadata === null || metadata === void 0 ? void 0 : metadata.symbolName) !== null && _a !== void 0 ? _a : marketInfo.symbolName,
+        assetName: (_b = metadata === null || metadata === void 0 ? void 0 : metadata.assetName) !== null && _b !== void 0 ? _b : asset.coin,
+        marketPrefix: (_c = metadata === null || metadata === void 0 ? void 0 : metadata.marketName) !== null && _c !== void 0 ? _c : marketInfo.marketName,
+        percentage: asset.closeWeight * 100,
+        collateralToken: (_d = metadata === null || metadata === void 0 ? void 0 : metadata.collateralToken) !== null && _d !== void 0 ? _d : 'USDC',
+    };
+};
+const getCollateralTypes$1 = (assets) => {
+    const set = new Set();
+    for (const a of assets)
+        set.add(a.collateralToken);
+    return set.size > 0 ? Array.from(set) : ['USDC'];
+};
+const buildSummary = (days) => {
+    let pnl = 0;
+    let volume = 0;
+    let wins = 0;
+    let losses = 0;
+    let totalProfit = 0;
+    let totalLoss = 0;
+    for (const day of days) {
+        pnl += day.totalPnl;
+        volume += day.volume;
+        if (day.positionsClosed === 0)
+            continue;
+        if (day.totalPnl > 0) {
+            wins++;
+            totalProfit += day.totalPnl;
+        }
+        else if (day.totalPnl < 0) {
+            losses++;
+            totalLoss += Math.abs(day.totalPnl);
+        }
+    }
+    const total = wins + losses;
+    const winRate = total > 0 ? Math.round((wins / total) * 100) : 0;
+    return {
+        pnl: round2(pnl),
+        volume: round2(volume),
+        winRate,
+        wins,
+        losses,
+        totalProfit: round2(totalProfit),
+        totalLoss: round2(totalLoss),
+    };
+};
+const buildCalendarData = (tradeHistories, timeframe, rangeStart, rangeEnd, totalDays, useCustomDates, getAssetByName) => {
+    const startKey = toDateKey(rangeStart);
+    const endKey = toDateKey(rangeEnd);
+    // Build day buckets for the full range
+    const buckets = new Map();
+    for (let i = 0; i < totalDays; i++) {
+        const d = new Date(rangeStart);
+        d.setDate(rangeStart.getDate() + i);
+        buckets.set(toDateKey(d), {
+            pnl: 0,
+            volume: 0,
+            positionsClosed: 0,
+            trades: [],
+        });
+    }
+    // Populate buckets from trade histories
+    for (const trade of tradeHistories) {
+        if (!trade.createdAt)
+            continue;
+        const date = new Date(trade.createdAt);
+        if (isNaN(date.getTime()))
+            continue;
+        const dateKey = toDateKey(date);
+        if (dateKey < startKey || dateKey > endKey)
+            continue;
+        const bucket = buckets.get(dateKey);
+        if (!bucket)
+            continue;
+        const pnl = trade.realizedPnl;
+        bucket.pnl += isFinite(pnl) ? pnl : 0;
+        const vol = trade.totalValue;
+        bucket.volume += isFinite(vol) ? vol : 0;
+        bucket.positionsClosed += 1;
+        const tradePnl = trade.realizedPnl;
+        const longAssets = trade.closedLongAssets.map((a) => mapAsset$1(a, getAssetByName));
+        const shortAssets = trade.closedShortAssets.map((a) => mapAsset$1(a, getAssetByName));
+        bucket.trades.push({
+            tradeHistoryId: trade.tradeHistoryId,
+            realizedPnl: tradePnl,
+            result: tradePnl > 0 ? 'profit' : tradePnl < 0 ? 'loss' : 'breakeven',
+            collateralTypes: getCollateralTypes$1([...longAssets, ...shortAssets]),
+            closedLongAssets: longAssets,
+            closedShortAssets: shortAssets,
+        });
+    }
+    // Build day objects
+    const allDays = [];
+    const sortedKeys = Array.from(buckets.keys()).sort();
+    for (const key of sortedKeys) {
+        const bucket = buckets.get(key);
+        const roundedPnl = round2(bucket.pnl);
+        const result = roundedPnl > 0 ? 'profit' : roundedPnl < 0 ? 'loss' : 'breakeven';
+        allDays.push({
+            date: key,
+            totalPnl: roundedPnl,
+            volume: round2(bucket.volume),
+            positionsClosed: bucket.positionsClosed,
+            result,
+            trades: bucket.trades,
+        });
+    }
+    // Group into periods
+    let weeks = [];
+    let months = [];
+    const useWeekGrouping = useCustomDates
+        ? totalDays <= 28
+        : isWeekTimeframe(timeframe);
+    if (useWeekGrouping) {
+        const weekMap = new Map();
+        for (const day of allDays) {
+            const date = new Date(day.date + 'T00:00:00');
+            const monday = getMonday(date);
+            const mondayKey = toDateKey(monday);
+            if (!weekMap.has(mondayKey)) {
+                weekMap.set(mondayKey, []);
+            }
+            weekMap.get(mondayKey).push(day);
+        }
+        const sortedWeekKeys = Array.from(weekMap.keys()).sort();
+        weeks = sortedWeekKeys.map((mondayKey) => {
+            const days = weekMap.get(mondayKey);
+            const monday = new Date(mondayKey + 'T00:00:00');
+            const sunday = new Date(monday);
+            sunday.setDate(monday.getDate() + 6);
+            return {
+                weekStart: mondayKey,
+                weekEnd: toDateKey(sunday),
+                days,
+                summary: buildSummary(days),
+            };
+        });
+    }
+    else {
+        const monthMap = new Map();
+        for (const day of allDays) {
+            const date = new Date(day.date + 'T00:00:00');
+            const mk = toMonthKey(date);
+            if (!monthMap.has(mk)) {
+                monthMap.set(mk, { days: [], label: formatMonthLabel(date) });
+            }
+            monthMap.get(mk).days.push(day);
+        }
+        const sortedMonthKeys = Array.from(monthMap.keys()).sort();
+        months = sortedMonthKeys.map((mk) => {
+            const { days, label } = monthMap.get(mk);
+            return {
+                month: mk,
+                label,
+                days,
+                summary: buildSummary(days),
+            };
+        });
+    }
+    return {
+        timeframe,
+        weeks,
+        months,
+        overall: buildSummary(allDays),
+        isLoading: false,
+    };
+};
+// ─── hook ───────────────────────────────────────────────────────
+function usePnlCalendar(options) {
+    var _a;
+    const opts = typeof options === 'string'
+        ? { timeframe: options }
+        : options !== null && options !== void 0 ? options : {};
+    const timeframe = (_a = opts.timeframe) !== null && _a !== void 0 ? _a : '2W';
+    const customStart = opts.startDate;
+    const customEnd = opts.endDate;
+    const context = useContext(PearHyperliquidContext);
+    if (!context) {
+        throw new Error('usePnlCalendar must be used within a PearHyperliquidProvider');
+    }
+    const { apiBaseUrl } = context;
+    const isAuthenticated = useUserData((state) => state.isAuthenticated);
+    const { getAssetByName } = useMarket();
+    const [trades, setTrades] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const mountedRef = useRef(true);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => { mountedRef.current = false; };
+    }, []);
+    // Compute the date range
+    const useCustomDates = !!(customStart && customEnd);
+    let rangeStart;
+    let rangeEnd;
+    let totalDays;
+    if (useCustomDates) {
+        rangeStart = toLocalMidnight(customStart);
+        rangeEnd = toLocalMidnight(customEnd);
+        totalDays = diffDays(rangeStart, rangeEnd);
+    }
+    else {
+        totalDays = getTimeframeDays$1(timeframe);
+        rangeEnd = new Date();
+        rangeEnd.setHours(0, 0, 0, 0);
+        rangeStart = new Date(rangeEnd);
+        rangeStart.setDate(rangeEnd.getDate() - totalDays + 1);
+    }
+    const startIso = toISODateString$1(rangeStart);
+    const endIso = toISODateString$1(rangeEnd);
+    const fetchData = useCallback(async () => {
+        if (!isAuthenticated)
+            return;
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await getTradeHistory(apiBaseUrl, {
+                startDate: startIso,
+                endDate: endIso,
+                limit: totalDays * 50,
+            });
+            if (!mountedRef.current)
+                return;
+            setTrades(response.data);
+        }
+        catch (err) {
+            if (!mountedRef.current)
+                return;
+            setError(err instanceof Error ? err.message : 'Failed to fetch trade history');
+            setTrades(null);
+        }
+        finally {
+            if (mountedRef.current)
+                setIsLoading(false);
+        }
+    }, [apiBaseUrl, isAuthenticated, startIso, endIso, totalDays]);
+    useEffect(() => {
+        fetchData();
+    }, [fetchData]);
+    const result = useMemo(() => {
+        const empty = {
+            timeframe,
+            weeks: [],
+            months: [],
+            overall: EMPTY_SUMMARY,
+            isLoading: true,
+        };
+        if (!trades)
+            return empty;
+        if (totalDays <= 0)
+            return empty;
+        return buildCalendarData(trades, timeframe, rangeStart, rangeEnd, totalDays, useCustomDates, getAssetByName);
+    }, [trades, timeframe, startIso, endIso, getAssetByName]);
+    return { ...result, isLoading, error, refetch: fetchData };
+}
+
+const HEATMAP_LIMIT = 50;
+// ─── helpers ────────────────────────────────────────────────────
+const getTimeframeDays = (tf) => {
+    switch (tf) {
+        case '7D':
+            return 7;
+        case '30D':
+            return 30;
+        case '100D':
+            return 100;
+        case 'allTime':
+            return null;
+    }
+};
+const toISODateString = (date) => date.toISOString();
+const mapAsset = (asset, getAssetByName) => {
+    var _a, _b, _c, _d;
+    const metadata = getAssetByName(asset.coin);
+    const marketInfo = getMarketInfoFromSymbol(asset.coin);
+    return {
+        coin: asset.coin,
+        symbol: (_a = metadata === null || metadata === void 0 ? void 0 : metadata.symbolName) !== null && _a !== void 0 ? _a : marketInfo.symbolName,
+        assetName: (_b = metadata === null || metadata === void 0 ? void 0 : metadata.assetName) !== null && _b !== void 0 ? _b : asset.coin,
+        marketPrefix: (_c = metadata === null || metadata === void 0 ? void 0 : metadata.marketName) !== null && _c !== void 0 ? _c : marketInfo.marketName,
+        percentage: asset.closeWeight * 100,
+        collateralToken: (_d = metadata === null || metadata === void 0 ? void 0 : metadata.collateralToken) !== null && _d !== void 0 ? _d : 'USDC',
+    };
+};
+const getCollateralTypes = (assets) => {
+    const set = new Set();
+    for (const a of assets)
+        set.add(a.collateralToken);
+    return set.size > 0 ? Array.from(set) : ['USDC'];
+};
+const toCalendarTrade = (trade, getAssetByName) => {
+    const pnl = trade.realizedPnl;
+    const longAssets = trade.closedLongAssets.map((a) => mapAsset(a, getAssetByName));
+    const shortAssets = trade.closedShortAssets.map((a) => mapAsset(a, getAssetByName));
+    return {
+        tradeHistoryId: trade.tradeHistoryId,
+        realizedPnl: pnl,
+        result: pnl > 0 ? 'profit' : pnl < 0 ? 'loss' : 'breakeven',
+        collateralTypes: getCollateralTypes([...longAssets, ...shortAssets]),
+        closedLongAssets: longAssets,
+        closedShortAssets: shortAssets,
+    };
+};
+// ─── hook ───────────────────────────────────────────────────────
+function usePnlHeatmap(timeframe = 'allTime') {
+    const context = useContext(PearHyperliquidContext);
+    if (!context) {
+        throw new Error('usePnlHeatmap must be used within a PearHyperliquidProvider');
+    }
+    const { apiBaseUrl } = context;
+    const isAuthenticated = useUserData((state) => state.isAuthenticated);
+    const { getAssetByName } = useMarket();
+    const [trades, setTrades] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const mountedRef = useRef(true);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => { mountedRef.current = false; };
+    }, []);
+    const days = getTimeframeDays(timeframe);
+    let startIso;
+    if (days !== null) {
+        const start = new Date();
+        start.setHours(0, 0, 0, 0);
+        start.setDate(start.getDate() - days);
+        startIso = toISODateString(start);
+    }
+    const fetchData = useCallback(async () => {
+        if (!isAuthenticated)
+            return;
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await getTradeHistory(apiBaseUrl, {
+                ...(startIso ? { startDate: startIso } : {}),
+                limit: 5000,
+            });
+            if (!mountedRef.current)
+                return;
+            setTrades(response.data);
+        }
+        catch (err) {
+            if (!mountedRef.current)
+                return;
+            setError(err instanceof Error ? err.message : 'Failed to fetch trade history');
+            setTrades(null);
+        }
+        finally {
+            if (mountedRef.current)
+                setIsLoading(false);
+        }
+    }, [apiBaseUrl, isAuthenticated, startIso]);
+    useEffect(() => {
+        fetchData();
+    }, [fetchData]);
+    const result = useMemo(() => {
+        if (!trades)
+            return [];
+        const top = trades
+            .slice()
+            .sort((a, b) => Math.abs(b.realizedPnl) - Math.abs(a.realizedPnl))
+            .slice(0, HEATMAP_LIMIT);
+        const totalAbsPnl = top.reduce((sum, t) => sum + Math.abs(t.realizedPnl), 0);
+        return top.map((t) => ({
+            ...toCalendarTrade(t, getAssetByName),
+            percentage: totalAbsPnl > 0
+                ? Math.round((Math.abs(t.realizedPnl) / totalAbsPnl) * 10000) / 100
+                : 0,
+        }));
+    }, [trades, getAssetByName]);
+    return { timeframe, trades: result, isLoading, error, refetch: fetchData };
+}
+
 const PearHyperliquidContext = createContext(undefined);
 /**
  * React Provider for PearHyperliquidClient
@@ -8689,4 +9223,4 @@ function getOrderTrailingInfo(order) {
     return undefined;
 }
 
-export { ConflictDetector, MAX_ASSETS_PER_LEG, MINIMUM_ASSET_USD_VALUE, MaxAssetsPerLegError, MinimumPositionSizeError, PearHyperliquidProvider, adjustAdvancePosition, adjustOrder, adjustPosition, calculateMinimumPositionValue, calculateWeightedRatio, cancelOrder, cancelTwap, cancelTwapOrder, closeAllPositions, closePosition, computeBasketCandles, createCandleLookups, createPosition, executeSpotOrder, getCompleteTimestamps, getKalshiMarkets, getOrderDirection, getOrderLadderConfig, getOrderLeverage, getOrderReduceOnly, getOrderTpSlTriggerType, getOrderTrailingInfo, getOrderTriggerType, getOrderTriggerValue, getOrderTwapDuration, getOrderUsdValue, getPortfolio, isBtcDomOrder, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useAgentWallet, useAllUserBalances, useAuth, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidUserFills, useMarket, useMarketData, useMarketDataHook, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTradeHistories, useTwap, useUserSelection, useWatchlist, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };
+export { ConflictDetector, MAX_ASSETS_PER_LEG, MINIMUM_ASSET_USD_VALUE, MaxAssetsPerLegError, MinimumPositionSizeError, PearHyperliquidProvider, adjustAdvancePosition, adjustOrder, adjustPosition, calculateMinimumPositionValue, calculateWeightedRatio, cancelOrder, cancelTwap, cancelTwapOrder, closeAllPositions, closePosition, computeBasketCandles, createCandleLookups, createPosition, executeSpotOrder, getCompleteTimestamps, getKalshiMarkets, getOrderDirection, getOrderLadderConfig, getOrderLeverage, getOrderReduceOnly, getOrderTpSlTriggerType, getOrderTrailingInfo, getOrderTriggerType, getOrderTriggerValue, getOrderTwapDuration, getOrderUsdValue, getPortfolio, isBtcDomOrder, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useAgentWallet, useAllUserBalances, useAuth, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidUserFills, useMarket, useMarketData, useMarketDataHook, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePnlCalendar, usePnlHeatmap, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTradeHistories, useTwap, useUserSelection, useWatchlist, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };

package/dist/types.d.ts

@@ -258,6 +258,7 @@ export interface PositionAssetDetailDto {
     initialWeight: number;
     currentWeight: number;
     fundingPaid?: number;
+    targetWeight?: number;
     metadata?: TokenMetadata | null;
 }
 export interface TpSlThreshold {
@@ -735,6 +736,7 @@ export interface RawAssetDto {
     side: string;
     fundingPaid?: number;
     leverage: number;
+    targetWeight?: number;
 }
 /**
  * Raw position data from open-positions channel

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/hyperliquid-sdk",
-  "version": "0.1.18",
+  "version": "0.1.20-pnl",
   "description": "React SDK for Pear Protocol Hyperliquid API integration",
   "type": "module",
   "main": "dist/index.js",
@@ -28,8 +28,8 @@
     "zustand": "^5.0.9"
   },
   "peerDependencies": {
-    "react": "^18.0.0",
-    "react-dom": "^18.0.0"
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^25.0.0",