@pear-protocol/hyperliquid-sdk 0.1.22 → 0.1.24

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

@@ -1512,6 +1512,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)
  */
@@ -1799,5 +1874,5 @@ interface MarketDataState {
 }
 declare const useMarketData: zustand.UseBoundStore<zustand.StoreApi<MarketDataState>>;
 
-export { ClosePositionValidationError, 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, validateClosePositionRequest, 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, CloseAllExecutionType, CloseAllPositionsRequestInput, CloseAllPositionsResponseDto, CloseAllPositionsResultDto, CloseExecutionType, ClosePositionExecutionType, ClosePositionRequestInput, ClosePositionResponseDto, CloseTriggerType, 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, 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, UsePortfolioResult, UseSpotOrderResult, UseTokenSelectionMetadataReturn, UserAbstraction, UserProfile, UserSelectionState, WatchlistAssetDto, WatchlistItemDto, WebData3AssetCtx, WebData3PerpDexState, WebData3Response, WebData3UserState, WebSocketAckResponse, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketSubscribeMessage, WsAllMidsData };
+export { ClosePositionValidationError, 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, validateClosePositionRequest, 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, CloseAllExecutionType, CloseAllPositionsRequestInput, CloseAllPositionsResponseDto, CloseAllPositionsResultDto, CloseExecutionType, ClosePositionExecutionType, ClosePositionRequestInput, ClosePositionResponseDto, CloseTriggerType, 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

@@ -820,17 +820,8 @@ function validateClosePositionRequest(payload) {
 }
 
 const DEFAULT_STATE = {
-    longTokens: [
-        { symbol: "HYPE", weight: 25 },
-        { symbol: "BTC", weight: 25 },
-    ],
-    shortTokens: [
-        { symbol: "AVAX", weight: 10 },
-        { symbol: "SEI", weight: 10 },
-        { symbol: "ADA", weight: 10 },
-        { symbol: "TRUMP", weight: 10 },
-        { symbol: "SUI", weight: 10 },
-    ],
+    longTokens: [],
+    shortTokens: [],
     openTokenSelector: false,
     selectorConfig: null,
     openConflictModal: false,
@@ -8474,6 +8465,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
@@ -8825,4 +9266,4 @@ function getOrderTrailingInfo(order) {
     return undefined;
 }
 
-export { ClosePositionValidationError, 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, validateClosePositionRequest, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };
+export { ClosePositionValidationError, 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, validateClosePositionRequest, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };

package/package.json

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