@pear-protocol/hyperliquid-sdk 0.0.22 → 0.0.24

package/dist/hooks/index.d.ts

@@ -5,3 +5,4 @@ export * from './useWebData';
 export * from './useTokenSelectionMetadata';
 export * from './useHistoricalPriceData';
 export * from './useBasketCandles';
+export * from './usePerformanceOverlays';

package/dist/hooks/useBasketCandles.d.ts

@@ -1,6 +1,8 @@
-import type { CandleInterval, WeightedCandleData } from '../types';
+import type { CandleData, CandleInterval } from '../types';
 export interface UseBasketCandlesReturn {
-    fetchBasketCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<WeightedCandleData[]>;
+    fetchBasketCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<CandleData[]>;
+    fetchPerformanceCandles: (startTime: number, endTime: number, interval: CandleInterval, symbol: string) => Promise<CandleData[]>;
+    fetchOverallPerformanceCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<CandleData[]>;
     isLoading: boolean;
     addRealtimeListener: (cb: RealtimeBarsCallback) => string;
     removeRealtimeListener: (id: string) => void;

package/dist/hooks/useHistoricalPriceData.d.ts

@@ -1,8 +1,11 @@
+import { TokenHistoricalPriceData } from '../store/historicalPriceDataStore';
 import type { CandleData, CandleInterval } from '../types';
 export interface UseHistoricalPriceDataReturn {
     fetchHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval, callback?: (data: Record<string, CandleData[]>) => void) => Promise<Record<string, CandleData[]>>;
     hasHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval) => boolean;
     getHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval) => Record<string, CandleData[]>;
+    getAllHistoricalPriceData(): Promise<Record<string, TokenHistoricalPriceData>>;
+    fetchFirstCandle: (symbol: string, interval: CandleInterval) => Promise<CandleData | null>;
     isLoading: (symbol?: string) => boolean;
     clearCache: () => void;
 }

package/dist/hooks/usePerformanceOverlays.d.ts

@@ -0,0 +1,14 @@
+export interface PerformanceOverlay {
+    id: string;
+    symbol: string;
+    label: string;
+    color: string;
+    enabled: boolean;
+    type: 'asset' | 'portfolio';
+    weight?: number;
+}
+export interface UsePerformanceOverlaysReturn {
+    overlays: PerformanceOverlay[];
+    generateOverlaySymbols: () => string[];
+}
+export declare const usePerformanceOverlays: () => UsePerformanceOverlaysReturn;

package/dist/index.d.ts

@@ -291,6 +291,7 @@ interface PositionAssetDetailDto {
     unrealizedPnl: number;
     liquidationPrice: number;
     isExternallyModified: boolean;
+    initialWeight: number;
 }
 /**
  * Position sync status
@@ -615,16 +616,13 @@ type CandleInterval = "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" |
  * Candle data structure from WebSocket
  */
 interface CandleData {
+    s?: string;
     t: number;
     T: number;
-    s: string;
-    i: string;
-    o: string;
-    c: string;
-    h: string;
-    l: string;
-    v: string;
-    n: number;
+    o: number;
+    c: number;
+    h: number;
+    l: number;
 }
 /**
  * Candle chart data organized by symbol only
@@ -643,19 +641,6 @@ interface CandleSnapshotRequest {
     };
     type: "candleSnapshot";
 }
-/**
- * Weighted candle data for chart visualization
- */
-interface WeightedCandleData {
-    t: number;
-    T: number;
-    o: number;
-    c: number;
-    h: number;
-    l: number;
-    v: number;
-    n: number;
-}
 
 /**
  * Main SDK client for Pear Protocol Hyperliquid API integration
@@ -883,17 +868,34 @@ interface UseTokenSelectionMetadataReturn {
 }
 declare const useTokenSelectionMetadata: () => UseTokenSelectionMetadataReturn;
 
+interface HistoricalRange {
+    start: number;
+    end: number;
+}
+interface TokenHistoricalPriceData {
+    symbol: string;
+    interval: CandleInterval;
+    candles: CandleData[];
+    oldestTime: number | null;
+    latestTime: number | null;
+}
+declare const useHistoricalPriceDataStore: any;
+
 interface UseHistoricalPriceDataReturn {
     fetchHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval, callback?: (data: Record<string, CandleData[]>) => void) => Promise<Record<string, CandleData[]>>;
     hasHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval) => boolean;
     getHistoricalPriceData: (startTime: number, endTime: number, interval: CandleInterval) => Record<string, CandleData[]>;
+    getAllHistoricalPriceData(): Promise<Record<string, TokenHistoricalPriceData>>;
+    fetchFirstCandle: (symbol: string, interval: CandleInterval) => Promise<CandleData | null>;
     isLoading: (symbol?: string) => boolean;
     clearCache: () => void;
 }
 declare const useHistoricalPriceData: () => UseHistoricalPriceDataReturn;
 
 interface UseBasketCandlesReturn {
-    fetchBasketCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<WeightedCandleData[]>;
+    fetchBasketCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<CandleData[]>;
+    fetchPerformanceCandles: (startTime: number, endTime: number, interval: CandleInterval, symbol: string) => Promise<CandleData[]>;
+    fetchOverallPerformanceCandles: (startTime: number, endTime: number, interval: CandleInterval) => Promise<CandleData[]>;
     isLoading: boolean;
     addRealtimeListener: (cb: RealtimeBarsCallback) => string;
     removeRealtimeListener: (id: string) => void;
@@ -915,6 +917,21 @@ type RealtimeBarsCallback = (bar: RealtimeBar) => void;
  */
 declare const useBasketCandles: () => UseBasketCandlesReturn;
 
+interface PerformanceOverlay {
+    id: string;
+    symbol: string;
+    label: string;
+    color: string;
+    enabled: boolean;
+    type: 'asset' | 'portfolio';
+    weight?: number;
+}
+interface UsePerformanceOverlaysReturn {
+    overlays: PerformanceOverlay[];
+    generateOverlaySymbols: () => string[];
+}
+declare const usePerformanceOverlays: () => UsePerformanceOverlaysReturn;
+
 interface UseHyperliquidWebSocketProps {
     wsUrl: string;
     address: string | null;
@@ -1027,7 +1044,7 @@ declare const getCompleteTimestamps: (candleLookups: Record<string, Map<number,
  * Compute basket candles from individual token candles using weighted ratios
  * Optimized version that creates lookup maps once and reuses them
  */
-declare const computeBasketCandles: (longTokens: TokenSelection[], shortTokens: TokenSelection[], tokenCandles: Record<string, CandleData[]>) => WeightedCandleData[];
+declare const computeBasketCandles: (longTokens: TokenSelection[], shortTokens: TokenSelection[], tokenCandles: Record<string, CandleData[]>) => CandleData[];
 
 /**
  * Maps TradingView ResolutionString to CandleInterval
@@ -1038,18 +1055,5 @@ declare function mapTradingViewIntervalToCandleInterval(interval: string): Candl
  */
 declare function mapCandleIntervalToTradingViewInterval(interval: CandleInterval): string;
 
-interface HistoricalRange {
-    start: number;
-    end: number;
-}
-interface TokenHistoricalPriceData {
-    symbol: string;
-    interval: CandleInterval;
-    candles: CandleData[];
-    oldestTime: number | null;
-    latestTime: number | null;
-}
-declare const useHistoricalPriceDataStore: any;
-
-export { AccountSummaryCalculator, ConflictDetector, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, TokenMetadataExtractor, calculateWeightedRatio, computeBasketCandles, createCandleLookups, PearHyperliquidClient as default, getCompleteTimestamps, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, useAccountSummary, useAddress, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };
-export type { AccountSummaryResponseDto, AgentWalletDto, ApiErrorResponse, ApiResponse, AssetCtx, AssetInformationDetail, AssetMarketData, AssetPosition, BalanceSummaryDto, CandleChartData, CandleData, CandleInterval, CandleSnapshotRequest, ClearinghouseState, CrossMarginSummaryDto, CumFundingDto, HLWebSocketResponse, HistoricalRange, MarginSummaryDto, MigrationHookState, MigrationHooks, OpenLimitOrderDto, OpenOrderV1Dto, OpenPositionDto, OpenPositionV1Dto, OrderAssetDto, OrderStatus, PearHyperliquidConfig, PnlDto, PositionAssetDetailDto, PositionSideDto, PositionSyncStatus, RawValueDto, RealtimeBar, RealtimeBarsCallback, SyncOpenOrderDto, SyncOpenOrderResponseDto, SyncOpenPositionDto, SyncOpenPositionResponseDto, SyncTradeHistoryDto, SyncTradeHistoryResponseDto, TokenConflict, TokenHistoricalPriceData, TokenMetadata, TokenSelection, TpSlDto, TradeHistoryAssetDataDto, TradeHistoryDataDto, TradeHistoryV1Dto, UniverseAsset, UseBasketCandlesReturn, UseHistoricalPriceDataReturn, UseTokenSelectionMetadataReturn, UserSelectionState, WebData2Response, WebSocketAckResponse, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketSubscribeMessage, WeightedCandleData, WsAllMidsData };
+export { AccountSummaryCalculator, ConflictDetector, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, TokenMetadataExtractor, calculateWeightedRatio, computeBasketCandles, createCandleLookups, PearHyperliquidClient as default, getCompleteTimestamps, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, useAccountSummary, useAddress, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, usePerformanceOverlays, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };
+export type { AccountSummaryResponseDto, AgentWalletDto, ApiErrorResponse, ApiResponse, AssetCtx, AssetInformationDetail, AssetMarketData, AssetPosition, BalanceSummaryDto, CandleChartData, CandleData, CandleInterval, CandleSnapshotRequest, ClearinghouseState, CrossMarginSummaryDto, CumFundingDto, HLWebSocketResponse, HistoricalRange, MarginSummaryDto, MigrationHookState, MigrationHooks, OpenLimitOrderDto, OpenOrderV1Dto, OpenPositionDto, OpenPositionV1Dto, OrderAssetDto, OrderStatus, PearHyperliquidConfig, PerformanceOverlay, PnlDto, PositionAssetDetailDto, PositionSideDto, PositionSyncStatus, RawValueDto, RealtimeBar, RealtimeBarsCallback, SyncOpenOrderDto, SyncOpenOrderResponseDto, SyncOpenPositionDto, SyncOpenPositionResponseDto, SyncTradeHistoryDto, SyncTradeHistoryResponseDto, TokenConflict, TokenHistoricalPriceData, TokenMetadata, TokenSelection, TpSlDto, TradeHistoryAssetDataDto, TradeHistoryDataDto, TradeHistoryV1Dto, UniverseAsset, UseBasketCandlesReturn, UseHistoricalPriceDataReturn, UsePerformanceOverlaysReturn, UseTokenSelectionMetadataReturn, UserSelectionState, WebData2Response, WebSocketAckResponse, WebSocketChannel, WebSocketConnectionState, WebSocketDataMessage, WebSocketMessage, WebSocketSubscribeMessage, WsAllMidsData };

package/dist/index.js

@@ -7176,290 +7176,73 @@ class AccountSummaryCalculator {
     }
 }
 
-var PositionSide;
-(function (PositionSide) {
-    PositionSide["LONG"] = "LONG";
-    PositionSide["SHORT"] = "SHORT";
-})(PositionSide || (PositionSide = {}));
-class PositionProcessor {
-    constructor(webData2, allMids) {
-        this.webData2 = webData2;
-        this.allMids = allMids;
-    }
-    execute(rawPositions) {
-        if (!rawPositions || rawPositions.length === 0) {
-            return [];
-        }
-        const userHyperliquidPositions = this.getUserPositions();
-        const platformTotalsByAsset = this.calculatePlatformTotalsByAsset(rawPositions);
-        const hlPositionsMap = new Map();
-        (userHyperliquidPositions || []).forEach(assetPos => {
-            var _a;
-            if ((_a = assetPos.position) === null || _a === void 0 ? void 0 : _a.coin) {
-                hlPositionsMap.set(assetPos.position.coin, assetPos);
-            }
-        });
-        const openPositionDtos = [];
-        for (const position of rawPositions) {
-            const syncedPositionDto = this.syncPositionWithAggregateData(position, hlPositionsMap, platformTotalsByAsset);
-            openPositionDtos.push(syncedPositionDto);
-        }
-        return openPositionDtos;
-    }
-    getUserPositions() {
-        var _a, _b;
-        return ((_b = (_a = this.webData2) === null || _a === void 0 ? void 0 : _a.clearinghouseState) === null || _b === void 0 ? void 0 : _b.assetPositions) || [];
-    }
-    getMarketPrice(coin) {
-        var _a;
-        if (!((_a = this.allMids) === null || _a === void 0 ? void 0 : _a.mids))
-            return 0;
-        const exactPrice = this.allMids.mids[coin];
-        if (exactPrice) {
-            return Number(exactPrice);
-        }
-        const baseCurrency = this.extractBaseCurrency(coin);
-        const basePrice = this.allMids.mids[baseCurrency];
-        if (basePrice) {
-            return Number(basePrice);
-        }
-        return 0;
-    }
-    calculatePlatformTotalsByAsset(positions) {
-        const totalsMap = new Map();
-        for (const position of positions) {
-            for (const asset of position.longAssets || []) {
-                const baseCurrency = this.extractBaseCurrency(asset.coin);
-                if (!totalsMap.has(baseCurrency)) {
-                    totalsMap.set(baseCurrency, {
-                        totalSize: 0,
-                        positions: []
-                    });
-                }
-                const totals = totalsMap.get(baseCurrency);
-                const assetSize = Number(asset.size || 0);
-                totals.totalSize += assetSize;
-                totals.positions.push({
-                    positionId: position.positionId,
-                    asset: asset,
-                    size: assetSize
-                });
-            }
-            for (const asset of position.shortAssets || []) {
-                const baseCurrency = this.extractBaseCurrency(asset.coin);
-                if (!totalsMap.has(baseCurrency)) {
-                    totalsMap.set(baseCurrency, {
-                        totalSize: 0,
-                        positions: []
-                    });
-                }
-                const totals = totalsMap.get(baseCurrency);
-                const assetSize = Number(asset.size || 0);
-                totals.totalSize += assetSize;
-                totals.positions.push({
-                    positionId: position.positionId,
-                    asset: asset,
-                    size: assetSize
-                });
-            }
-        }
-        return totalsMap;
-    }
-    extractBaseCurrency(assetName) {
-        return assetName.split('/')[0] || assetName;
-    }
-    syncPositionWithAggregateData(position, hlPositionsMap, platformTotalsByAsset) {
-        const syncResults = [];
-        let hasExternalModification = false;
-        let allAssetsClosed = true;
-        let longAssetStatuses = { total: 0, closed: 0 };
-        let shortAssetStatuses = { total: 0, closed: 0 };
-        // Process long assets
-        for (const asset of position.longAssets || []) {
-            const baseCurrency = this.extractBaseCurrency(asset.coin);
-            const hlPosition = hlPositionsMap.get(baseCurrency);
-            const platformTotals = platformTotalsByAsset.get(baseCurrency);
-            const syncResult = this.syncAssetWithAggregateData({ ...asset, side: PositionSide.LONG }, hlPosition, (platformTotals === null || platformTotals === void 0 ? void 0 : platformTotals.totalSize) || 0);
-            syncResults.push(syncResult);
-            longAssetStatuses.total++;
-            if (syncResult.actualSize === 0) {
-                longAssetStatuses.closed++;
-            }
-            if (syncResult.isExternallyModified) {
-                hasExternalModification = true;
-            }
-            if (syncResult.actualSize !== 0) {
-                allAssetsClosed = false;
-            }
-        }
-        // Process short assets
-        for (const asset of position.shortAssets || []) {
-            const baseCurrency = this.extractBaseCurrency(asset.coin);
-            const hlPosition = hlPositionsMap.get(baseCurrency);
-            const platformTotals = platformTotalsByAsset.get(baseCurrency);
-            const syncResult = this.syncAssetWithAggregateData({ ...asset, side: PositionSide.SHORT }, hlPosition, (platformTotals === null || platformTotals === void 0 ? void 0 : platformTotals.totalSize) || 0);
-            syncResults.push(syncResult);
-            shortAssetStatuses.total++;
-            if (syncResult.actualSize === 0) {
-                shortAssetStatuses.closed++;
-            }
-            if (syncResult.isExternallyModified) {
-                hasExternalModification = true;
-            }
-            if (syncResult.actualSize !== 0) {
-                allAssetsClosed = false;
-            }
-        }
-        const syncStatus = this.determineSyncStatus(hasExternalModification, allAssetsClosed, longAssetStatuses, shortAssetStatuses);
-        return this.mapPositionToDtoWithSyncData(position, syncResults, syncStatus);
-    }
-    determineSyncStatus(hasExternalModification, allAssetsClosed, longAssetStatuses, shortAssetStatuses) {
-        if (allAssetsClosed) {
-            return 'EXTERNALLY_CLOSED';
-        }
-        const allLongsClosed = longAssetStatuses.total > 0 &&
-            longAssetStatuses.closed === longAssetStatuses.total;
-        const allShortsClosed = shortAssetStatuses.total > 0 &&
-            shortAssetStatuses.closed === shortAssetStatuses.total;
-        if ((allLongsClosed && !allShortsClosed) || (!allLongsClosed && allShortsClosed)) {
-            return 'PAIR_BROKEN';
-        }
-        if (hasExternalModification) {
-            return 'EXTERNALLY_MODIFIED';
-        }
-        return 'SYNCED';
-    }
-    syncAssetWithAggregateData(asset, hlPosition, platformTotal) {
-        const platformSize = Number(asset.size || 0);
-        if (!hlPosition || !hlPosition.position || !hlPosition.position.szi) {
-            return {
-                asset,
-                actualSize: 0,
-                isExternallyModified: true,
-                cumFunding: { allTime: 0, sinceChange: 0, sinceOpen: 0 },
-                unrealizedPnl: 0,
-                liquidationPrice: 0
-            };
+const calculatePositionAsset = (asset, currentPrice, totalInitialPositionSize, leverage, cumFunding, isLong = true) => {
+    const initialPositionValue = asset.entryPrice * asset.size;
+    const positionValue = currentPrice * asset.size;
+    const marginUsed = positionValue / leverage;
+    const unrealizedPnl = isLong
+        ? positionValue - initialPositionValue
+        : initialPositionValue - positionValue;
+    return {
+        coin: asset.coin,
+        entryPrice: asset.entryPrice,
+        actualSize: asset.size,
+        marginUsed: marginUsed,
+        positionValue: positionValue,
+        unrealizedPnl: unrealizedPnl,
+        initialWeight: initialPositionValue / totalInitialPositionSize,
+        cumFunding: {
+            allTime: parseFloat((cumFunding === null || cumFunding === void 0 ? void 0 : cumFunding.allTime) || "0"),
+            sinceChange: parseFloat((cumFunding === null || cumFunding === void 0 ? void 0 : cumFunding.sinceChange) || "0"),
+            sinceOpen: parseFloat((cumFunding === null || cumFunding === void 0 ? void 0 : cumFunding.sinceOpen) || "0"),
         }
-        const hlTotalSize = Math.abs(Number(hlPosition.position.szi || 0));
-        const totalDifference = Math.abs(hlTotalSize - platformTotal);
-        const tolerance = platformTotal * 0.001;
-        const isExternallyModified = totalDifference > tolerance;
-        const proportion = platformTotal > 0 ? platformSize / platformTotal : 0;
-        const actualSize = hlTotalSize * proportion;
-        // Get cumFunding from hlPosition.position.cumFunding
-        const rawCumFunding = hlPosition.position.cumFunding;
-        const cumFunding = {
-            allTime: Number((rawCumFunding === null || rawCumFunding === void 0 ? void 0 : rawCumFunding.allTime) || 0),
-            sinceChange: Number((rawCumFunding === null || rawCumFunding === void 0 ? void 0 : rawCumFunding.sinceChange) || 0) * proportion,
-            sinceOpen: Number((rawCumFunding === null || rawCumFunding === void 0 ? void 0 : rawCumFunding.sinceOpen) || 0) * proportion
-        };
-        const unrealizedPnl = Number(hlPosition.position.unrealizedPnl || 0) * proportion;
-        const liquidationPrice = Number(hlPosition.position.liquidationPx || 0);
-        return {
-            asset,
-            actualSize,
-            isExternallyModified,
-            cumFunding,
-            unrealizedPnl,
-            liquidationPrice
-        };
-    }
-    mapPositionToDtoWithSyncData(position, syncResults, syncStatus) {
-        var _a, _b;
-        const longAssets = ((_a = position.longAssets) === null || _a === void 0 ? void 0 : _a.filter(asset => asset)) || [];
-        const shortAssets = ((_b = position.shortAssets) === null || _b === void 0 ? void 0 : _b.filter(asset => asset)) || [];
-        const syncResultsMap = new Map();
-        syncResults.forEach(result => {
-            syncResultsMap.set(`${result.asset.coin}-${result.asset.side}`, result);
-        });
-        const currentTotalPositionValue = this.calculateCurrentTotalPositionValue(syncResults);
-        const entryTotalPositionValue = this.calculateEntryTotalPositionValue(syncResults);
-        const totalMarginUsed = entryTotalPositionValue / position.leverage;
-        return {
-            syncStatus: syncStatus,
+    };
+};
+const buildPositionValue = (rawPositions, webData2, allMids) => {
+    return rawPositions.map((position) => {
+        let mappedPosition = {
             positionId: position.positionId,
             address: position.address,
             leverage: position.leverage,
-            stopLoss: position.stopLoss,
-            takeProfit: position.takeProfit,
-            entryRatio: this.calculateEntryRatio(syncResults),
-            markRatio: this.calculateMarkRatio(syncResults),
-            netFunding: this.calculateNetFundingFromSyncResults(syncResults),
-            positionValue: currentTotalPositionValue,
-            marginUsed: totalMarginUsed,
-            unrealizedPnl: this.calculateTotalUnrealizedPnlFromSyncResults(syncResults),
-            lastSyncAt: new Date().toISOString(),
-            longAssets: longAssets.map(asset => this.mapAssetToDetailDto(asset, syncResultsMap.get(`${asset.coin}-LONG`))),
-            shortAssets: shortAssets.map(asset => this.mapAssetToDetailDto(asset, syncResultsMap.get(`${asset.coin}-SHORT`))),
-            createdAt: position.createdAt,
-            updatedAt: position.updatedAt
-        };
-    }
-    mapAssetToDetailDto(asset, syncData) {
-        const currentPrice = this.getMarketPrice(asset.coin);
-        const actualSize = (syncData === null || syncData === void 0 ? void 0 : syncData.actualSize) || Number(asset.size || 0);
-        const positionValue = actualSize * currentPrice;
-        const entryValue = Number(asset.size || 0) * Number(asset.entryPrice || 0);
-        return {
-            coin: asset.coin,
-            entryPrice: Number(asset.entryPrice || 0),
-            platformSize: Number(asset.size || 0),
-            actualSize: actualSize,
-            isExternallyModified: (syncData === null || syncData === void 0 ? void 0 : syncData.isExternallyModified) || false,
-            cumFunding: (syncData === null || syncData === void 0 ? void 0 : syncData.cumFunding) || {
-                allTime: 0,
-                sinceChange: 0,
-                sinceOpen: 0
-            },
-            marginUsed: entryValue,
-            positionValue: positionValue,
-            unrealizedPnl: (syncData === null || syncData === void 0 ? void 0 : syncData.unrealizedPnl) || 0,
-            liquidationPrice: (syncData === null || syncData === void 0 ? void 0 : syncData.liquidationPrice) || 0
+            entryRatio: 1,
+            marginUsed: 0,
+            markRatio: 1,
+            unrealizedPnl: 0,
+            netFunding: 0,
+            positionValue: 0,
         };
-    }
-    calculateEntryRatio(syncResults) {
-        var _a, _b;
-        const longResults = syncResults.filter(result => result.asset.side === PositionSide.LONG);
-        const shortResults = syncResults.filter(result => result.asset.side === PositionSide.SHORT);
-        if (longResults.length === 0 || shortResults.length === 0)
-            return 0;
-        const longEntryPrice = ((_a = longResults[0]) === null || _a === void 0 ? void 0 : _a.asset.entryPrice) ? Number(longResults[0].asset.entryPrice) : 0;
-        const shortEntryPrice = ((_b = shortResults[0]) === null || _b === void 0 ? void 0 : _b.asset.entryPrice) ? Number(shortResults[0].asset.entryPrice) : 0;
-        return shortEntryPrice > 0 ? longEntryPrice / shortEntryPrice : 0;
-    }
-    calculateMarkRatio(syncResults) {
-        var _a, _b;
-        const longResults = syncResults.filter(result => result.asset.side === PositionSide.LONG);
-        const shortResults = syncResults.filter(result => result.asset.side === PositionSide.SHORT);
-        if (longResults.length === 0 || shortResults.length === 0)
-            return 0;
-        const longMarkPrice = ((_a = longResults[0]) === null || _a === void 0 ? void 0 : _a.asset.coin) ? this.getMarketPrice(longResults[0].asset.coin) : 0;
-        const shortMarkPrice = ((_b = shortResults[0]) === null || _b === void 0 ? void 0 : _b.asset.coin) ? this.getMarketPrice(shortResults[0].asset.coin) : 0;
-        return shortMarkPrice > 0 ? longMarkPrice / shortMarkPrice : 0;
-    }
-    calculateNetFundingFromSyncResults(syncResults) {
-        const netFunding = syncResults.reduce((sum, result) => {
-            const funding = result.cumFunding.sinceOpen;
-            return sum + funding;
-        }, 0);
-        return netFunding;
-    }
-    calculateTotalUnrealizedPnlFromSyncResults(syncResults) {
-        return syncResults.reduce((sum, result) => sum + result.unrealizedPnl, 0);
-    }
-    calculateCurrentTotalPositionValue(syncResults) {
-        return syncResults.reduce((sum, result) => {
-            const currentPrice = this.getMarketPrice(result.asset.coin);
-            return sum + (result.actualSize * currentPrice);
-        }, 0);
-    }
-    calculateEntryTotalPositionValue(syncResults) {
-        return syncResults.reduce((sum, result) => {
-            return sum + (Number(result.asset.size || 0) * Number(result.asset.entryPrice || 0));
-        }, 0);
-    }
-}
+        const totalInitialPositionSize = position.longAssets.reduce((acc, asset) => acc + (asset.entryPrice * asset.size), 0) +
+            position.shortAssets.reduce((acc, asset) => acc + (asset.entryPrice * asset.size), 0);
+        mappedPosition.longAssets = position.longAssets.map(longAsset => {
+            var _a;
+            const currentPrice = parseFloat(allMids.mids[longAsset.coin]);
+            const cumFunding = (_a = webData2.clearinghouseState.assetPositions.find(ap => ap.position.coin === longAsset.coin)) === null || _a === void 0 ? void 0 : _a.position.cumFunding;
+            const mappedPositionAssets = calculatePositionAsset(longAsset, currentPrice, totalInitialPositionSize, mappedPosition.leverage, cumFunding, true);
+            mappedPosition.unrealizedPnl += mappedPositionAssets.unrealizedPnl;
+            mappedPosition.positionValue += mappedPositionAssets.positionValue;
+            mappedPosition.marginUsed += mappedPositionAssets.marginUsed;
+            mappedPosition.netFunding += mappedPositionAssets.cumFunding.sinceOpen;
+            // Calculate weighted entry and mark ratios for long positions
+            mappedPosition.entryRatio *= Math.pow(longAsset.entryPrice, mappedPositionAssets.initialWeight);
+            mappedPosition.markRatio *= Math.pow(currentPrice, mappedPositionAssets.initialWeight);
+            return mappedPositionAssets;
+        });
+        mappedPosition.shortAssets = position.shortAssets.map(shortAsset => {
+            var _a;
+            const currentPrice = parseFloat(allMids.mids[shortAsset.coin]);
+            const cumFunding = (_a = webData2.clearinghouseState.assetPositions.find(ap => ap.position.coin === shortAsset.coin)) === null || _a === void 0 ? void 0 : _a.position.cumFunding;
+            const mappedPositionAssets = calculatePositionAsset(shortAsset, currentPrice, totalInitialPositionSize, mappedPosition.leverage, cumFunding, false);
+            mappedPosition.netFunding += mappedPositionAssets.cumFunding.sinceOpen;
+            mappedPosition.unrealizedPnl += mappedPositionAssets.unrealizedPnl;
+            mappedPosition.positionValue += mappedPositionAssets.positionValue;
+            mappedPosition.marginUsed += mappedPositionAssets.marginUsed;
+            mappedPosition.entryRatio *= Math.pow(shortAsset.entryPrice, -mappedPositionAssets.initialWeight);
+            mappedPosition.markRatio *= Math.pow(currentPrice, -mappedPositionAssets.initialWeight);
+            return mappedPositionAssets;
+        });
+        return mappedPosition;
+    });
+};
 
 const useTradeHistories = () => {
     const context = useContext(PearHyperliquidContext);
@@ -7489,9 +7272,8 @@ const useOpenPositions = () => {
     if (!userOpenPositions || !webData2 || !allMids) {
         return { data: null, isLoading };
     }
-    const processor = new PositionProcessor(webData2, allMids);
-    const processed = processor.execute(userOpenPositions);
-    return { data: processed, isLoading };
+    const positions = buildPositionValue(userOpenPositions, webData2, allMids);
+    return { data: positions, isLoading };
 };
 /**
  * Hook to access open orders with loading state
@@ -8017,6 +7799,9 @@ const useHistoricalPriceData = () => {
         const allTokens = getAllTokens();
         return allTokens.some(token => isTokenLoading(token.symbol));
     }, [getAllTokens, isTokenLoading]);
+    const getAllHistoricalPriceData = useCallback(async () => {
+        return useHistoricalPriceDataStore.getState().historicalPriceData;
+    }, []);
     const fetchHistoricalPriceData = useCallback(async (startTime, endTime, interval, callback) => {
         const allTokens = getAllTokens();
         if (allTokens.length === 0) {
@@ -8068,13 +7853,23 @@ const useHistoricalPriceData = () => {
         client,
         addHistoricalPriceData,
     ]);
+    const fetchFirstCandle = useCallback(async (symbol, interval) => {
+        const key = `${symbol}-${interval}`;
+        const storeData = useHistoricalPriceDataStore.getState().historicalPriceData[key];
+        if (storeData && storeData.candles.length > 0) {
+            return storeData.candles[0];
+        }
+        return null;
+    }, [client, addHistoricalPriceData]);
     const clearCache = useCallback(() => {
         clearData();
     }, [clearData]);
     return {
         fetchHistoricalPriceData,
         hasHistoricalPriceData,
+        getAllHistoricalPriceData,
         getHistoricalPriceData,
+        fetchFirstCandle,
         isLoading,
         clearCache,
     };
@@ -8108,7 +7903,7 @@ const calculateWeightedRatio = (longTokens, shortTokens, candleLookups, timestam
         const lookup = candleLookups[token.symbol];
         const candle = lookup === null || lookup === void 0 ? void 0 : lookup.get(timestamp);
         if (candle) {
-            const price = parseFloat(candle[priceType]);
+            const price = candle[priceType];
             if (price > 0) {
                 const weightFactor = token.weight / 100;
                 longProduct *= Math.pow(price, weightFactor);
@@ -8123,7 +7918,7 @@ const calculateWeightedRatio = (longTokens, shortTokens, candleLookups, timestam
         const lookup = candleLookups[token.symbol];
         const candle = lookup === null || lookup === void 0 ? void 0 : lookup.get(timestamp);
         if (candle) {
-            const price = parseFloat(candle[priceType]);
+            const price = candle[priceType];
             if (price > 0) {
                 const weightFactor = token.weight / 100;
                 shortProduct *= Math.pow(price, -weightFactor);
@@ -8197,8 +7992,6 @@ const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
         // Compute all OHLC products in a single pass per side
         let longOpen = 1, longHigh = 1, longLow = 1, longClose = 1;
         let shortOpen = 1, shortHigh = 1, shortLow = 1, shortClose = 1;
-        let totalVolume = 0;
-        let totalTrades = 0;
         let candleDuration = 0;
         let missing = false;
         // Accumulate volume/trades and compute long side contributions
@@ -8209,10 +8002,10 @@ const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
                 break;
             }
             const weightFactor = token.weight / 100;
-            const o = parseFloat(candle.o);
-            const h = parseFloat(candle.h);
-            const l = parseFloat(candle.l);
-            const c = parseFloat(candle.c);
+            const o = candle.o;
+            const h = candle.h;
+            const l = candle.l;
+            const c = candle.c;
             if (!(o > 0 && h > 0 && l > 0 && c > 0)) {
                 missing = true;
                 break;
@@ -8221,8 +8014,6 @@ const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
             longHigh *= Math.pow(h, weightFactor);
             longLow *= Math.pow(l, weightFactor);
             longClose *= Math.pow(c, weightFactor);
-            totalVolume += parseFloat(candle.v);
-            totalTrades += candle.n;
             if (candleDuration === 0)
                 candleDuration = candle.T - candle.t;
         }
@@ -8236,10 +8027,10 @@ const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
                 break;
             }
             const weightFactor = -(token.weight / 100);
-            const o = parseFloat(candle.o);
-            const h = parseFloat(candle.h);
-            const l = parseFloat(candle.l);
-            const c = parseFloat(candle.c);
+            const o = candle.o;
+            const h = candle.h;
+            const l = candle.l;
+            const c = candle.c;
             if (!(o > 0 && h > 0 && l > 0 && c > 0)) {
                 missing = true;
                 break;
@@ -8248,8 +8039,6 @@ const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
             shortHigh *= Math.pow(h, weightFactor);
             shortLow *= Math.pow(l, weightFactor);
             shortClose *= Math.pow(c, weightFactor);
-            totalVolume += parseFloat(candle.v);
-            totalTrades += candle.n;
             if (candleDuration === 0)
                 candleDuration = candle.T - candle.t;
         }
@@ -8262,8 +8051,6 @@ const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
             h: longHigh * shortHigh,
             l: longLow * shortLow,
             c: longClose * shortClose,
-            v: totalVolume,
-            n: totalTrades,
         });
     }
     return basketCandles;
@@ -8279,12 +8066,97 @@ const useBasketCandles = () => {
     const longTokens = useUserSelection$1((state) => state.longTokens);
     const shortTokens = useUserSelection$1((state) => state.shortTokens);
     const candleData = useHyperliquidData((s) => s.candleData);
-    const { fetchHistoricalPriceData, isLoading: tokenLoading } = useHistoricalPriceData();
+    const { fetchHistoricalPriceData, isLoading: tokenLoading, getAllHistoricalPriceData } = useHistoricalPriceData();
     const fetchBasketCandles = useCallback(async (startTime, endTime, interval) => {
         const tokenCandles = await fetchHistoricalPriceData(startTime, endTime, interval);
         const basket = computeBasketCandles(longTokens, shortTokens, tokenCandles);
         return basket;
     }, [fetchHistoricalPriceData, longTokens, shortTokens]);
+    const fetchPerformanceCandles = useCallback(async (startTime, endTime, interval, symbol) => {
+        const assetSymbol = symbol.split(" ")[1];
+        const tokenCandles = await fetchHistoricalPriceData(startTime, endTime, interval);
+        const assetCandles = tokenCandles[assetSymbol];
+        if (!assetCandles)
+            return [];
+        return assetCandles;
+    }, [fetchHistoricalPriceData, longTokens, shortTokens]);
+    const fetchOverallPerformanceCandles = useCallback(async (startTime, endTime, interval) => {
+        await fetchHistoricalPriceData(startTime, endTime, interval);
+        const allCandles = await getAllHistoricalPriceData();
+        const allTokens = [...longTokens, ...shortTokens];
+        if (allTokens.length === 0)
+            return [];
+        const symbolsData = {};
+        const baselinePrices = {};
+        for (const token of allTokens) {
+            const candles = allCandles[`${token.symbol}-${interval}`].candles;
+            if (!candles || candles.length === 0)
+                continue;
+            symbolsData[token.symbol] = candles;
+            const firstCandle = symbolsData[token.symbol][0];
+            baselinePrices[token.symbol] = firstCandle.o;
+        }
+        if (Object.keys(symbolsData).length === 0)
+            return [];
+        const allTimestamps = new Set();
+        const symbolCandlesByTimestamp = {};
+        Object.entries(symbolsData).forEach(([symbol, candles]) => {
+            const candleMap = new Map();
+            candles.forEach(candle => {
+                allTimestamps.add(candle.t);
+                candleMap.set(candle.t, candle);
+            });
+            symbolCandlesByTimestamp[symbol] = candleMap;
+        });
+        const sortedTimestamps = Array.from(allTimestamps).sort((a, b) => a - b);
+        const performanceCandles = [];
+        const initialPortfolioValue = 1000;
+        const lastKnownPrices = {};
+        for (const timestamp of sortedTimestamps) {
+            let portfolioValue = 0;
+            let hasAllData = true;
+            for (const token of allTokens) {
+                const candleMap = symbolCandlesByTimestamp[token.symbol];
+                if (!candleMap) {
+                    hasAllData = false;
+                    break;
+                }
+                let candle = candleMap.get(timestamp);
+                if (!candle) {
+                    candle = lastKnownPrices[token.symbol];
+                    if (!candle) {
+                        hasAllData = false;
+                        break;
+                    }
+                }
+                else {
+                    lastKnownPrices[token.symbol] = candle;
+                }
+                const currentPrice = candle.c;
+                const baselinePrice = baselinePrices[token.symbol];
+                const allocation = (token.weight / 100) * initialPortfolioValue;
+                const priceRatio = currentPrice / baselinePrice;
+                if (longTokens.includes(token)) {
+                    portfolioValue += allocation * priceRatio;
+                }
+                else {
+                    portfolioValue += allocation / priceRatio;
+                }
+            }
+            if (!hasAllData)
+                continue;
+            const performanceCandle = {
+                t: timestamp,
+                T: timestamp,
+                o: portfolioValue,
+                h: portfolioValue,
+                l: portfolioValue,
+                c: portfolioValue,
+            };
+            performanceCandles.push(performanceCandle);
+        }
+        return performanceCandles;
+    }, [fetchHistoricalPriceData, getAllHistoricalPriceData, longTokens, shortTokens]);
     // Aggregate loading across selected tokens via underlying hook
     const isLoading = tokenLoading();
     // Realtime listeners management
@@ -8330,37 +8202,31 @@ const useBasketCandles = () => {
         // Compute weighted OHLC similar to computeBasketCandles
         let longOpen = 1, longHigh = 1, longLow = 1, longClose = 1;
         let shortOpen = 1, shortHigh = 1, shortLow = 1, shortClose = 1;
-        let totalVolume = 0;
-        let totalTrades = 0;
         for (const token of longTokens) {
             const c = snapshot[token.symbol];
             if (!c)
                 return null;
             const w = token.weight / 100;
-            const o = parseFloat(c.o), h = parseFloat(c.h), l = parseFloat(c.l), cl = parseFloat(c.c);
+            const o = c.o, h = c.h, l = c.l, cl = c.c;
             if (!(o > 0 && h > 0 && l > 0 && cl > 0))
                 return null;
             longOpen *= Math.pow(o, w);
             longHigh *= Math.pow(h, w);
             longLow *= Math.pow(l, w);
             longClose *= Math.pow(cl, w);
-            totalVolume += parseFloat(c.v);
-            totalTrades += c.n;
         }
         for (const token of shortTokens) {
             const c = snapshot[token.symbol];
             if (!c)
                 return null;
             const w = -(token.weight / 100);
-            const o = parseFloat(c.o), h = parseFloat(c.h), l = parseFloat(c.l), cl = parseFloat(c.c);
+            const o = c.o, h = c.h, l = c.l, cl = c.c;
             if (!(o > 0 && h > 0 && l > 0 && cl > 0))
                 return null;
             shortOpen *= Math.pow(o, w);
             shortHigh *= Math.pow(h, w);
             shortLow *= Math.pow(l, w);
             shortClose *= Math.pow(cl, w);
-            totalVolume += parseFloat(c.v);
-            totalTrades += c.n;
         }
         if (t === null || T === null)
             return null;
@@ -8371,8 +8237,6 @@ const useBasketCandles = () => {
             h: longHigh * shortHigh,
             l: longLow * shortLow,
             c: longClose * shortClose,
-            v: totalVolume,
-            n: totalTrades,
         };
         return weighted;
     }, [candleData, longTokens, shortTokens]);
@@ -8390,7 +8254,6 @@ const useBasketCandles = () => {
             high: bar.h,
             low: bar.l,
             close: bar.c,
-            volume: bar.v,
         };
         listenersRef.current.forEach((cb) => {
             try {
@@ -8401,12 +8264,62 @@ const useBasketCandles = () => {
     }, [computeRealtimeBar]);
     return {
         fetchBasketCandles,
+        fetchPerformanceCandles,
+        fetchOverallPerformanceCandles,
         isLoading,
         addRealtimeListener,
         removeRealtimeListener,
     };
 };
 
+// Color palette for overlays
+const LONG_COLORS = [
+    '#22C55E', '#16A34A', '#15803D', '#166534', '#14532D', // Green shades
+    '#84CC16', '#65A30D', '#4D7C0F', '#365314', '#1A2E05' // Lime shades
+];
+const SHORT_COLORS = [
+    '#EF4444', '#DC2626', '#B91C1C', '#991B1B', '#7F1D1D', // Red shades
+    '#F97316', '#EA580C', '#C2410C', '#9A3412', '#7C2D12' // Orange/red shades
+];
+const usePerformanceOverlays = () => {
+    const longTokens = useUserSelection$1((state) => state.longTokens);
+    const shortTokens = useUserSelection$1((state) => state.shortTokens);
+    // Generate performance overlays from current portfolio - all enabled by default
+    const overlays = [
+        ...longTokens.map((token, index) => ({
+            id: `perf_long_${token.symbol}`,
+            symbol: `LONG ${token.symbol}`,
+            label: `${token.symbol} (${token.weight}%)`,
+            color: LONG_COLORS[index % LONG_COLORS.length], // Green shades for long positions
+            enabled: true, // Always enabled
+            type: 'asset',
+            weight: token.weight,
+        })),
+        ...shortTokens.map((token, index) => ({
+            id: `perf_short_${token.symbol}`,
+            symbol: `SHORT ${token.symbol}`,
+            label: `${token.symbol} (-${token.weight}%)`,
+            color: SHORT_COLORS[index % SHORT_COLORS.length], // Red shades for short positions
+            enabled: true, // Always enabled
+            type: 'asset',
+            weight: -token.weight,
+        }))
+    ];
+    const generateOverlaySymbols = useCallback(() => {
+        const symbols = [];
+        // Always include all asset overlays
+        overlays.forEach(overlay => {
+            symbols.push(overlay.symbol);
+        });
+        console.log("final symbols", symbols);
+        return symbols;
+    }, [overlays]);
+    return {
+        overlays,
+        generateOverlaySymbols,
+    };
+};
+
 /**
  * Detects conflicts between selected tokens and existing positions
  */
@@ -8494,4 +8407,4 @@ function mapCandleIntervalToTradingViewInterval(interval) {
     }
 }
 
-export { AccountSummaryCalculator, ConflictDetector, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, TokenMetadataExtractor, calculateWeightedRatio, computeBasketCandles, createCandleLookups, PearHyperliquidClient as default, getCompleteTimestamps, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, useAccountSummary, useAddress, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };
+export { AccountSummaryCalculator, ConflictDetector, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, TokenMetadataExtractor, calculateWeightedRatio, computeBasketCandles, createCandleLookups, PearHyperliquidClient as default, getCompleteTimestamps, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, useAccountSummary, useAddress, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, usePerformanceOverlays, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };

package/dist/types.d.ts

@@ -287,6 +287,7 @@ export interface PositionAssetDetailDto {
     unrealizedPnl: number;
     liquidationPrice: number;
     isExternallyModified: boolean;
+    initialWeight: number;
 }
 /**
  * Position sync status
@@ -620,16 +621,13 @@ export type CandleInterval = "1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" |
  * Candle data structure from WebSocket
  */
 export interface CandleData {
+    s?: string;
     t: number;
     T: number;
-    s: string;
-    i: string;
-    o: string;
-    c: string;
-    h: string;
-    l: string;
-    v: string;
-    n: number;
+    o: number;
+    c: number;
+    h: number;
+    l: number;
 }
 /**
  * Candle chart data organized by symbol only
@@ -648,16 +646,3 @@ export interface CandleSnapshotRequest {
     };
     type: "candleSnapshot";
 }
-/**
- * Weighted candle data for chart visualization
- */
-export interface WeightedCandleData {
-    t: number;
-    T: number;
-    o: number;
-    c: number;
-    h: number;
-    l: number;
-    v: number;
-    n: number;
-}

package/dist/utils/basket-calculator.d.ts

@@ -1,4 +1,4 @@
-import type { CandleData, TokenSelection, WeightedCandleData } from '../types';
+import type { CandleData, TokenSelection } from '../types';
 /**
  * Create efficient timestamp-based lookup maps for candle data
  */
@@ -21,4 +21,4 @@ export declare const getCompleteTimestamps: (candleLookups: Record<string, Map<n
  * Compute basket candles from individual token candles using weighted ratios
  * Optimized version that creates lookup maps once and reuses them
  */
-export declare const computeBasketCandles: (longTokens: TokenSelection[], shortTokens: TokenSelection[], tokenCandles: Record<string, CandleData[]>) => WeightedCandleData[];
+export declare const computeBasketCandles: (longTokens: TokenSelection[], shortTokens: TokenSelection[], tokenCandles: Record<string, CandleData[]>) => CandleData[];

package/dist/utils/position-processor.d.ts

@@ -1,22 +1,2 @@
-import type { OpenPositionDto, WebData2Response, WsAllMidsData, RawPositionDto } from '../types';
-export declare class PositionProcessor {
-    private webData2;
-    private allMids;
-    constructor(webData2: WebData2Response | null, allMids: WsAllMidsData | null);
-    execute(rawPositions: RawPositionDto[]): OpenPositionDto[];
-    private getUserPositions;
-    private getMarketPrice;
-    private calculatePlatformTotalsByAsset;
-    private extractBaseCurrency;
-    private syncPositionWithAggregateData;
-    private determineSyncStatus;
-    private syncAssetWithAggregateData;
-    private mapPositionToDtoWithSyncData;
-    private mapAssetToDetailDto;
-    private calculateEntryRatio;
-    private calculateMarkRatio;
-    private calculateNetFundingFromSyncResults;
-    private calculateTotalUnrealizedPnlFromSyncResults;
-    private calculateCurrentTotalPositionValue;
-    private calculateEntryTotalPositionValue;
-}
+import { OpenPositionDto, RawPositionDto, WebData2Response, WsAllMidsData } from "../types";
+export declare const buildPositionValue: (rawPositions: RawPositionDto[], webData2: WebData2Response, allMids: WsAllMidsData) => OpenPositionDto[];

package/package.json

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