@pear-protocol/hyperliquid-sdk 0.0.20 → 0.0.24

package/dist/index.js

@@ -1,4 +1,4 @@
-import require$$0, { useState, useEffect, useRef, createContext, useMemo, useContext, useCallback } from 'react';
+import require$$0, { useState, useEffect, useMemo, useRef, createContext, useContext, useCallback } from 'react';
 import require$$1 from 'react-dom';
 import { create } from 'zustand';
 
@@ -6653,21 +6653,19 @@ const useHyperliquidData = create((set, get) => ({
     },
     addCandleData(symbol, candle) {
         set((state) => {
-            return {
-                candleData: {
-                    ...state.candleData,
-                    [symbol]: candle
-                }
-            };
+            var _a;
+            const map = (_a = state.candleData) !== null && _a !== void 0 ? _a : new Map();
+            const updatedMap = new Map(map);
+            updatedMap.set(symbol, candle); // store latest only
+            return { candleData: updatedMap };
         });
     },
     deleteCandleSymbol(symbol) {
         set((state) => {
-            if (!state.candleData || !(symbol in state.candleData)) {
-                return state; // No change if symbol doesn't exist
-            }
-            const updated = { ...state.candleData };
-            delete updated[symbol];
+            if (!state.candleData)
+                return state;
+            const updated = new Map(state.candleData);
+            updated.delete(symbol);
             return { candleData: updated };
         });
     },
@@ -6680,13 +6678,141 @@ const useHyperliquidData = create((set, get) => ({
     }))
 }));
 
-const useHyperliquidNativeWebSocket = ({ address, tokens = [], candleInterval = "1h" }) => {
+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 },
+    ],
+    openTokenSelector: false,
+    selectorConfig: null,
+    openConflictModal: false,
+    conflicts: [],
+    candleInterval: "1h",
+    isWeightBalanced: true,
+};
+const useUserSelection$1 = create((set, get) => ({
+    ...DEFAULT_STATE,
+    setLongTokens: (tokens) => set((state) => ({ ...state, longTokens: tokens })),
+    setShortTokens: (tokens) => set((state) => ({ ...state, shortTokens: tokens })),
+    setOpenTokenSelector: (open) => set((state) => ({ ...state, openTokenSelector: open })),
+    setSelectorConfig: (config) => set((state) => ({ ...state, selectorConfig: config })),
+    setOpenConflictModal: (open) => set((state) => ({ ...state, openConflictModal: open })),
+    setConflicts: (conflicts) => set((state) => ({ ...state, conflicts })),
+    setCandleInterval: (interval) => set((state) => ({ ...state, candleInterval: interval })),
+    updateTokenWeight: (isLong, index, newWeight) => {
+        set((prev) => {
+            if (isLong) {
+                const updated = [...prev.longTokens];
+                updated[index] = { ...updated[index], weight: newWeight };
+                const longTotal = updated.reduce((sum, t) => sum + t.weight, 0);
+                const shortTotal = prev.shortTokens.reduce((sum, t) => sum + t.weight, 0);
+                const isWeightBalanced = longTotal + shortTotal === 100;
+                return { ...prev, longTokens: updated, isWeightBalanced };
+            }
+            else {
+                const updated = [...prev.shortTokens];
+                updated[index] = { ...updated[index], weight: newWeight };
+                const longTotal = prev.longTokens.reduce((sum, t) => sum + t.weight, 0);
+                const shortTotal = updated.reduce((sum, t) => sum + t.weight, 0);
+                const isWeightBalanced = longTotal + shortTotal === 100;
+                return { ...prev, shortTokens: updated, isWeightBalanced };
+            }
+        });
+    },
+    addToken: (isLong) => {
+        const currentTokens = isLong ? get().longTokens : get().shortTokens;
+        const newIndex = currentTokens.length;
+        set((prev) => ({
+            ...prev,
+            selectorConfig: { isLong, index: newIndex },
+            openTokenSelector: true,
+        }));
+    },
+    removeToken: (isLong, index) => {
+        set((prev) => {
+            if (isLong) {
+                const updated = prev.longTokens.filter((_, i) => i !== index);
+                const longTotal = updated.reduce((sum, t) => sum + t.weight, 0);
+                const shortTotal = prev.shortTokens.reduce((sum, t) => sum + t.weight, 0);
+                const isWeightBalanced = longTotal + shortTotal === 100;
+                return { ...prev, longTokens: updated, isWeightBalanced };
+            }
+            else {
+                const updated = prev.shortTokens.filter((_, i) => i !== index);
+                const longTotal = prev.longTokens.reduce((sum, t) => sum + t.weight, 0);
+                const shortTotal = updated.reduce((sum, t) => sum + t.weight, 0);
+                const isWeightBalanced = longTotal + shortTotal === 100;
+                return { ...prev, shortTokens: updated, isWeightBalanced };
+            }
+        });
+    },
+    handleTokenSelect: (selectedToken) => {
+        const { selectorConfig, longTokens, shortTokens } = get();
+        if (!selectorConfig)
+            return;
+        const { isLong, index } = selectorConfig;
+        const existingTokens = isLong ? longTokens : shortTokens;
+        if (existingTokens.some((t) => t.symbol === selectedToken))
+            return;
+        set((prev) => {
+            if (index >= existingTokens.length) {
+                const newToken = { symbol: selectedToken, weight: 1 };
+                if (isLong) {
+                    const updatedLongTokens = [...prev.longTokens, newToken];
+                    const longTotal = updatedLongTokens.reduce((s, t) => s + t.weight, 0);
+                    const shortTotal = prev.shortTokens.reduce((s, t) => s + t.weight, 0);
+                    const isWeightBalanced = longTotal + shortTotal === 100;
+                    return {
+                        ...prev,
+                        longTokens: updatedLongTokens,
+                        isWeightBalanced,
+                    };
+                }
+                const updatedShortTokens = [...prev.shortTokens, newToken];
+                const longTotal = prev.longTokens.reduce((s, t) => s + t.weight, 0);
+                const shortTotal = updatedShortTokens.reduce((s, t) => s + t.weight, 0);
+                const isWeightBalanced = longTotal + shortTotal === 100;
+                return {
+                    ...prev,
+                    shortTokens: updatedShortTokens,
+                    isWeightBalanced,
+                };
+            }
+            else {
+                if (isLong) {
+                    const updated = [...prev.longTokens];
+                    updated[index] = { ...updated[index], symbol: selectedToken };
+                    return { ...prev, longTokens: updated };
+                }
+                else {
+                    const updated = [...prev.shortTokens];
+                    updated[index] = { ...updated[index], symbol: selectedToken };
+                    return { ...prev, shortTokens: updated };
+                }
+            }
+        });
+    },
+    resetToDefaults: () => set((prev) => ({ ...prev, ...DEFAULT_STATE })),
+}));
+
+const useHyperliquidNativeWebSocket = ({ address, }) => {
     const { setWebData2, setAllMids, setActiveAssetData, upsertActiveAssetData, setCandleData, deleteCandleSymbol, deleteActiveAssetData, addCandleData } = useHyperliquidData();
+    const { candleInterval } = useUserSelection$1();
+    const longTokens = useUserSelection$1((s) => s.longTokens);
+    const shortTokens = useUserSelection$1((s) => s.shortTokens);
+    const selectedTokenSymbols = useMemo(() => ([...longTokens, ...shortTokens].map((t) => t.symbol)), [longTokens, shortTokens]);
     const [lastError, setLastError] = useState(null);
     const [subscribedAddress, setSubscribedAddress] = useState(null);
     const [subscribedTokens, setSubscribedTokens] = useState([]);
     const [subscribedCandleTokens, setSubscribedCandleTokens] = useState([]);
-    const [subscribedCandleInterval, setSubscribedCandleInterval] = useState(null);
+    const prevCandleIntervalRef = useRef(null);
     const pingIntervalRef = useRef(null);
     const { readyState, sendJsonMessage } = useWebSocket('wss://api.hyperliquid.xyz/ws', {
         shouldReconnect: () => true,
@@ -6726,7 +6852,7 @@ const useHyperliquidNativeWebSocket = ({ address, tokens = [], candleInterval =
                             break;
                         case 'candle':
                             const candleDataItem = response.data;
-                            addCandleData(candleDataItem.c, candleDataItem);
+                            addCandleData(candleDataItem.s, candleDataItem);
                             break;
                         default:
                             console.warn(`[HyperLiquid WS] Unknown channel: ${response.channel}`);
@@ -6808,8 +6934,9 @@ const useHyperliquidNativeWebSocket = ({ address, tokens = [], candleInterval =
     useEffect(() => {
         if (!isConnected || !address)
             return;
-        const tokensToSubscribe = tokens.filter(token => token && !subscribedTokens.includes(token));
-        const tokensToUnsubscribe = subscribedTokens.filter(token => !tokens.includes(token));
+        const effectiveTokens = selectedTokenSymbols;
+        const tokensToSubscribe = effectiveTokens.filter((token) => token && !subscribedTokens.includes(token));
+        const tokensToUnsubscribe = subscribedTokens.filter((token) => !effectiveTokens.includes(token));
         // Unsubscribe from tokens no longer in the list
         tokensToUnsubscribe.forEach(token => {
             const unsubscribeMessage = {
@@ -6835,34 +6962,36 @@ const useHyperliquidNativeWebSocket = ({ address, tokens = [], candleInterval =
             sendJsonMessage(subscribeMessage);
         });
         if (tokensToSubscribe.length > 0 || tokensToUnsubscribe.length > 0) {
-            setSubscribedTokens(tokens.filter(token => token));
-            tokensToSubscribe.forEach(token => deleteActiveAssetData(token));
+            setSubscribedTokens(effectiveTokens.filter((token) => token));
+            tokensToSubscribe.forEach((token) => deleteActiveAssetData(token));
         }
-    }, [isConnected, address, tokens, subscribedTokens, sendJsonMessage, setActiveAssetData]);
+    }, [isConnected, address, selectedTokenSymbols, subscribedTokens, sendJsonMessage, setActiveAssetData]);
     // Handle candle subscriptions for tokens and interval changes
     useEffect(() => {
         if (!isConnected)
             return;
+        const effectiveTokens = selectedTokenSymbols;
         // Unsubscribe from previous candle subscriptions if interval changed
-        if (subscribedCandleInterval && subscribedCandleInterval !== candleInterval) {
+        const prevInterval = prevCandleIntervalRef.current;
+        if (prevInterval && prevInterval !== candleInterval) {
             subscribedCandleTokens.forEach(token => {
                 const unsubscribeMessage = {
                     method: 'unsubscribe',
                     subscription: {
                         type: 'candle',
                         coin: token,
-                        interval: subscribedCandleInterval,
+                        interval: prevInterval,
                     },
                 };
                 sendJsonMessage(unsubscribeMessage);
             });
-            setCandleData({});
+            setCandleData(new Map());
             setSubscribedCandleTokens([]);
         }
-        const tokensToSubscribe = tokens.filter(token => token && !subscribedCandleTokens.includes(token));
-        const tokensToUnsubscribe = subscribedCandleTokens.filter(token => !tokens.includes(token));
+        const tokensToSubscribe = effectiveTokens.filter((token) => token && !subscribedCandleTokens.includes(token));
+        const tokensToUnsubscribe = subscribedCandleTokens.filter((token) => !effectiveTokens.includes(token));
         // Unsubscribe from tokens no longer in the list
-        tokensToUnsubscribe.forEach(token => {
+        tokensToUnsubscribe.forEach((token) => {
             const unsubscribeMessage = {
                 method: 'unsubscribe',
                 subscription: {
@@ -6874,7 +7003,7 @@ const useHyperliquidNativeWebSocket = ({ address, tokens = [], candleInterval =
             sendJsonMessage(unsubscribeMessage);
         });
         // Subscribe to new tokens
-        tokensToSubscribe.forEach(token => {
+        tokensToSubscribe.forEach((token) => {
             const subscribeMessage = {
                 method: 'subscribe',
                 subscription: {
@@ -6886,12 +7015,12 @@ const useHyperliquidNativeWebSocket = ({ address, tokens = [], candleInterval =
             sendJsonMessage(subscribeMessage);
         });
         // Update subscribed state
-        if (tokensToSubscribe.length > 0 || tokensToUnsubscribe.length > 0 || subscribedCandleInterval !== candleInterval) {
-            setSubscribedCandleTokens(tokens.filter(token => token));
-            setSubscribedCandleInterval(candleInterval);
-            tokensToUnsubscribe.forEach(token => deleteCandleSymbol(token));
+        if (tokensToSubscribe.length > 0 || tokensToUnsubscribe.length > 0 || prevInterval !== candleInterval) {
+            setSubscribedCandleTokens(effectiveTokens.filter((token) => token));
+            prevCandleIntervalRef.current = candleInterval;
+            tokensToUnsubscribe.forEach((token) => deleteCandleSymbol(token));
         }
-    }, [isConnected, tokens, candleInterval, subscribedCandleTokens, subscribedCandleInterval, sendJsonMessage, setCandleData]);
+    }, [isConnected, selectedTokenSymbols, candleInterval, subscribedCandleTokens, sendJsonMessage, setCandleData]);
     return {
         connectionStatus: readyState,
         isConnected,
@@ -7047,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
+            entryRatio: 1,
+            marginUsed: 0,
+            markRatio: 1,
+            unrealizedPnl: 0,
+            netFunding: 0,
+            positionValue: 0,
         };
-    }
-    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
-        };
-    }
-    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);
@@ -7360,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
@@ -7400,138 +7311,6 @@ const useAccountSummary = () => {
     return { data: calculated, isLoading };
 };
 
-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 },
-    ],
-    openTokenSelector: false,
-    selectorConfig: null,
-    openConflictModal: false,
-    conflicts: [],
-    candleInterval: "1h",
-};
-const useUserSelection$1 = create((set, get) => ({
-    ...DEFAULT_STATE,
-    setLongTokens: (tokens) => set((state) => ({ ...state, longTokens: tokens })),
-    setShortTokens: (tokens) => set((state) => ({ ...state, shortTokens: tokens })),
-    setOpenTokenSelector: (open) => set((state) => ({ ...state, openTokenSelector: open })),
-    setSelectorConfig: (config) => set((state) => ({ ...state, selectorConfig: config })),
-    setOpenConflictModal: (open) => set((state) => ({ ...state, openConflictModal: open })),
-    setConflicts: (conflicts) => set((state) => ({ ...state, conflicts })),
-    setCandleInterval: (interval) => set((state) => ({ ...state, candleInterval: interval })),
-    updateTokenWeight: (isLong, index, newWeight) => {
-        const clampedWeight = Math.max(1, Math.min(100, newWeight));
-        set((prev) => {
-            var _a, _b;
-            const currentLongTotal = prev.longTokens.reduce((sum, t) => sum + t.weight, 0);
-            const currentShortTotal = prev.shortTokens.reduce((sum, t) => sum + t.weight, 0);
-            if (isLong) {
-                const oldWeight = ((_a = prev.longTokens[index]) === null || _a === void 0 ? void 0 : _a.weight) || 0;
-                const weightDiff = clampedWeight - oldWeight;
-                const newLongTotal = currentLongTotal + weightDiff;
-                if (newLongTotal + currentShortTotal > 100) {
-                    const maxAllowedWeight = Math.max(1, 100 - currentShortTotal - (currentLongTotal - oldWeight));
-                    const updated = [...prev.longTokens];
-                    updated[index] = { ...updated[index], weight: maxAllowedWeight };
-                    return { ...prev, longTokens: updated };
-                }
-                else {
-                    const updated = [...prev.longTokens];
-                    updated[index] = { ...updated[index], weight: clampedWeight };
-                    return { ...prev, longTokens: updated };
-                }
-            }
-            else {
-                const oldWeight = ((_b = prev.shortTokens[index]) === null || _b === void 0 ? void 0 : _b.weight) || 0;
-                const weightDiff = clampedWeight - oldWeight;
-                const newShortTotal = currentShortTotal + weightDiff;
-                if (currentLongTotal + newShortTotal > 100) {
-                    const maxAllowedWeight = Math.max(1, 100 - currentLongTotal - (currentShortTotal - oldWeight));
-                    const updated = [...prev.shortTokens];
-                    updated[index] = { ...updated[index], weight: maxAllowedWeight };
-                    return { ...prev, shortTokens: updated };
-                }
-                else {
-                    const updated = [...prev.shortTokens];
-                    updated[index] = { ...updated[index], weight: clampedWeight };
-                    return { ...prev, shortTokens: updated };
-                }
-            }
-        });
-    },
-    addToken: (isLong) => {
-        const currentTokens = isLong ? get().longTokens : get().shortTokens;
-        const newIndex = currentTokens.length;
-        set((prev) => ({
-            ...prev,
-            selectorConfig: { isLong, index: newIndex },
-            openTokenSelector: true,
-        }));
-    },
-    removeToken: (isLong, index) => {
-        set((prev) => {
-            if (isLong) {
-                const updated = prev.longTokens.filter((_, i) => i !== index);
-                return { ...prev, longTokens: updated };
-            }
-            else {
-                const updated = prev.shortTokens.filter((_, i) => i !== index);
-                return { ...prev, shortTokens: updated };
-            }
-        });
-    },
-    handleTokenSelect: (selectedToken) => {
-        const { selectorConfig, longTokens, shortTokens } = get();
-        if (!selectorConfig)
-            return;
-        const { isLong, index } = selectorConfig;
-        const existingTokens = isLong ? longTokens : shortTokens;
-        if (existingTokens.some((t) => t.symbol === selectedToken))
-            return;
-        set((prev) => {
-            const longTotal = prev.longTokens.reduce((s, t) => s + t.weight, 0);
-            const shortTotal = prev.shortTokens.reduce((s, t) => s + t.weight, 0);
-            const currentTotal = longTotal + shortTotal;
-            if (index >= existingTokens.length) {
-                const maxAvailableWeight = Math.max(1, 100 - currentTotal);
-                const safeWeight = Math.min(20, maxAvailableWeight);
-                const newToken = { symbol: selectedToken, weight: safeWeight };
-                if (isLong) {
-                    return {
-                        ...prev,
-                        longTokens: [...prev.longTokens, newToken],
-                    };
-                }
-                return {
-                    ...prev,
-                    shortTokens: [...prev.shortTokens, newToken],
-                };
-            }
-            else {
-                if (isLong) {
-                    const updated = [...prev.longTokens];
-                    updated[index] = { ...updated[index], symbol: selectedToken };
-                    return { ...prev, longTokens: updated };
-                }
-                else {
-                    const updated = [...prev.shortTokens];
-                    updated[index] = { ...updated[index], symbol: selectedToken };
-                    return { ...prev, shortTokens: updated };
-                }
-            }
-        });
-    },
-    resetToDefaults: () => set((prev) => ({ ...prev, ...DEFAULT_STATE })),
-}));
-
 // Re-expose as a React hook without Zustand's selector signature
 const useUserSelection = () => {
     return useUserSelection$1();
@@ -7842,6 +7621,25 @@ const useTokenSelectionMetadata = () => {
 const createKey = (symbol, interval) => {
     return `${symbol}-${interval}`;
 };
+const getIntervalSeconds = (interval) => {
+    switch (interval) {
+        case "1m": return 60;
+        case "3m": return 3 * 60;
+        case "5m": return 5 * 60;
+        case "15m": return 15 * 60;
+        case "30m": return 30 * 60;
+        case "1h": return 60 * 60;
+        case "2h": return 2 * 60 * 60;
+        case "4h": return 4 * 60 * 60;
+        case "8h": return 8 * 60 * 60;
+        case "12h": return 12 * 60 * 60;
+        case "1d": return 24 * 60 * 60;
+        case "3d": return 3 * 24 * 60 * 60;
+        case "1w": return 7 * 24 * 60 * 60;
+        case "1M": return 30 * 24 * 60 * 60; // Approximate month
+        default: return 60;
+    }
+};
 const useHistoricalPriceDataStore = create((set, get) => ({
     historicalPriceData: {},
     loadingTokens: new Set(),
@@ -7891,8 +7689,11 @@ const useHistoricalPriceDataStore = create((set, get) => ({
         const tokenData = historicalPriceData[key];
         if (!tokenData || tokenData.oldestTime === null || tokenData.latestTime === null)
             return false;
-        // Check if our cached data covers the requested time range
-        return tokenData.oldestTime <= startTime && tokenData.latestTime >= endTime;
+        const intervalMilisecond = getIntervalSeconds(interval) * 1000;
+        const hasStartCoverage = tokenData.oldestTime <= startTime;
+        const hasEndCoverage = tokenData.latestTime >= endTime ||
+            (tokenData.latestTime + intervalMilisecond >= endTime);
+        return hasStartCoverage && hasEndCoverage;
     },
     getHistoricalPriceData: (symbol, interval, startTime, endTime) => {
         const { historicalPriceData } = get();
@@ -7900,8 +7701,7 @@ const useHistoricalPriceDataStore = create((set, get) => ({
         const tokenData = historicalPriceData[key];
         if (!tokenData)
             return [];
-        // Filter candles within the requested time range
-        return tokenData.candles.filter(candle => candle.t >= startTime && candle.T <= endTime);
+        return tokenData.candles.filter(candle => candle.t >= startTime && candle.t < endTime);
     },
     setTokenLoading: (symbol, loading) => {
         set(state => {
@@ -7948,8 +7748,6 @@ const useHistoricalPriceData = () => {
     const longTokens = useUserSelection$1((state) => state.longTokens);
     const shortTokens = useUserSelection$1((state) => state.shortTokens);
     const candleInterval = useUserSelection$1((state) => state.candleInterval);
-    // Get real-time candle data from WebSocket
-    const candleData = useHyperliquidData((state) => state.candleData);
     // Historical price data store
     const { addHistoricalPriceData, hasHistoricalPriceData: storeHasData, getHistoricalPriceData: storeGetData, setTokenLoading, isTokenLoading, removeTokenPriceData, clearData, } = useHistoricalPriceDataStore();
     // Track previous tokens and interval to detect changes
@@ -7980,32 +7778,20 @@ const useHistoricalPriceData = () => {
         prevTokensRef.current = currentTokens;
         prevIntervalRef.current = candleInterval;
     }, [longTokens, shortTokens, candleInterval, removeTokenPriceData, clearData, getAllTokens]);
-    useEffect(() => {
-        if (!candleData)
-            return;
-        const allTokenSymbols = new Set(getAllTokens().map(token => token.symbol));
-        Object.entries(candleData).forEach(([symbol, candle]) => {
-            if (allTokenSymbols.has(symbol)) {
-                if (candle.i === candleInterval) {
-                    addHistoricalPriceData(symbol, candleInterval, [candle], { start: candle.t, end: candle.T });
-                }
-            }
-        });
-    }, [candleData, getAllTokens, candleInterval, addHistoricalPriceData]);
-    const hasHistoricalPriceData = useCallback((startTime, endTime) => {
+    const hasHistoricalPriceData = useCallback((startTime, endTime, interval) => {
         const allTokens = getAllTokens();
         if (allTokens.length === 0)
             return false;
-        return allTokens.every(token => storeHasData(token.symbol, candleInterval, startTime, endTime));
-    }, [getAllTokens, candleInterval, storeHasData]);
-    const getHistoricalPriceData = useCallback((startTime, endTime) => {
+        return allTokens.every(token => storeHasData(token.symbol, interval, startTime, endTime));
+    }, [getAllTokens, storeHasData]);
+    const getHistoricalPriceData = useCallback((startTime, endTime, interval) => {
         const allTokens = getAllTokens();
         const result = {};
         allTokens.forEach(token => {
-            result[token.symbol] = storeGetData(token.symbol, candleInterval, startTime, endTime);
+            result[token.symbol] = storeGetData(token.symbol, interval, startTime, endTime);
         });
         return result;
-    }, [getAllTokens, candleInterval, storeGetData]);
+    }, [getAllTokens, storeGetData]);
     const isLoading = useCallback((symbol) => {
         if (symbol) {
             return isTokenLoading(symbol);
@@ -8013,16 +7799,19 @@ const useHistoricalPriceData = () => {
         const allTokens = getAllTokens();
         return allTokens.some(token => isTokenLoading(token.symbol));
     }, [getAllTokens, isTokenLoading]);
-    const fetchHistoricalPriceData = useCallback(async (startTime, endTime, callback) => {
+    const getAllHistoricalPriceData = useCallback(async () => {
+        return useHistoricalPriceDataStore.getState().historicalPriceData;
+    }, []);
+    const fetchHistoricalPriceData = useCallback(async (startTime, endTime, interval, callback) => {
         const allTokens = getAllTokens();
         if (allTokens.length === 0) {
             const emptyResult = {};
             callback === null || callback === void 0 ? void 0 : callback(emptyResult);
             return emptyResult;
         }
-        const tokensToFetch = allTokens.filter(token => !storeHasData(token.symbol, candleInterval, startTime, endTime));
+        const tokensToFetch = allTokens.filter(token => !storeHasData(token.symbol, interval, startTime, endTime));
         if (tokensToFetch.length === 0) {
-            const cachedData = getHistoricalPriceData(startTime, endTime);
+            const cachedData = getHistoricalPriceData(startTime, endTime, interval);
             callback === null || callback === void 0 ? void 0 : callback(cachedData);
             return cachedData;
         }
@@ -8032,8 +7821,8 @@ const useHistoricalPriceData = () => {
         try {
             const fetchPromises = tokensToFetch.map(async (token) => {
                 try {
-                    const response = await client.fetchHistoricalCandles(token.symbol, startTime, endTime, candleInterval);
-                    addHistoricalPriceData(token.symbol, candleInterval, response.data, { start: startTime, end: endTime });
+                    const response = await client.fetchHistoricalCandles(token.symbol, startTime, endTime, interval);
+                    addHistoricalPriceData(token.symbol, interval, response.data, { start: startTime, end: endTime });
                     return { symbol: token.symbol, candles: response.data, success: true };
                 }
                 catch (error) {
@@ -8042,7 +7831,7 @@ const useHistoricalPriceData = () => {
                 }
             });
             await Promise.all(fetchPromises);
-            const allData = getHistoricalPriceData(startTime, endTime);
+            const allData = getHistoricalPriceData(startTime, endTime, interval);
             callback === null || callback === void 0 ? void 0 : callback(allData);
             return allData;
         }
@@ -8064,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,
     };
@@ -8104,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);
@@ -8119,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);
@@ -8181,7 +7980,7 @@ const getCompleteTimestamps = (candleLookups, requiredSymbols) => {
  */
 const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
     var _a, _b;
-    if (longTokens.length === 0 || shortTokens.length === 0) {
+    if (longTokens.length === 0 && shortTokens.length === 0) {
         return [];
     }
     // Create efficient lookup maps once
@@ -8193,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
@@ -8205,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;
@@ -8217,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;
         }
@@ -8232,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;
@@ -8244,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;
         }
@@ -8258,8 +8051,6 @@ const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
             h: longHigh * shortHigh,
             l: longLow * shortLow,
             c: longClose * shortClose,
-            v: totalVolume,
-            n: totalTrades,
         });
     }
     return basketCandles;
@@ -8274,17 +8065,258 @@ const computeBasketCandles = (longTokens, shortTokens, tokenCandles) => {
 const useBasketCandles = () => {
     const longTokens = useUserSelection$1((state) => state.longTokens);
     const shortTokens = useUserSelection$1((state) => state.shortTokens);
-    const { fetchHistoricalPriceData, isLoading: tokenLoading } = useHistoricalPriceData();
-    const fetchBasketCandles = useCallback(async (startTime, endTime) => {
-        const tokenCandles = await fetchHistoricalPriceData(startTime, endTime);
+    const candleData = useHyperliquidData((s) => s.candleData);
+    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
+    const listenersRef = useRef(new Map());
+    const lastEmittedRef = useRef(null);
+    const addRealtimeListener = useCallback((cb) => {
+        const id = Math.random().toString(36).slice(2);
+        listenersRef.current.set(id, cb);
+        return id;
+    }, []);
+    const removeRealtimeListener = useCallback((id) => {
+        listenersRef.current.delete(id);
+    }, []);
+    // Helper: compute weighted bar from latest snapshot if all tokens aligned
+    const computeRealtimeBar = useCallback(() => {
+        if (!candleData)
+            return null;
+        const allTokens = [...longTokens, ...shortTokens];
+        if (allTokens.length === 0)
+            return null;
+        // Collect candles, ensure presence and alignment
+        const symbolSet = new Set(allTokens.map((t) => t.symbol));
+        const snapshot = {};
+        for (const symbol of symbolSet) {
+            const c = candleData.get(symbol);
+            if (!c)
+                return null; // missing latest candle for symbol
+            snapshot[symbol] = c;
+        }
+        // Verify same interval window (t and T match across symbols)
+        let t = null;
+        let T = null;
+        for (const symbol of symbolSet) {
+            const c = snapshot[symbol];
+            if (t === null) {
+                t = c.t;
+                T = c.T;
+            }
+            else if (c.t !== t || c.T !== T) {
+                return null; // not aligned yet
+            }
+        }
+        // Compute weighted OHLC similar to computeBasketCandles
+        let longOpen = 1, longHigh = 1, longLow = 1, longClose = 1;
+        let shortOpen = 1, shortHigh = 1, shortLow = 1, shortClose = 1;
+        for (const token of longTokens) {
+            const c = snapshot[token.symbol];
+            if (!c)
+                return null;
+            const w = token.weight / 100;
+            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);
+        }
+        for (const token of shortTokens) {
+            const c = snapshot[token.symbol];
+            if (!c)
+                return null;
+            const w = -(token.weight / 100);
+            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);
+        }
+        if (t === null || T === null)
+            return null;
+        const weighted = {
+            t,
+            T,
+            o: longOpen * shortOpen,
+            h: longHigh * shortHigh,
+            l: longLow * shortLow,
+            c: longClose * shortClose,
+        };
+        return weighted;
+    }, [candleData, longTokens, shortTokens]);
+    // Emit realtime bars when aligned snapshot updates
+    useEffect(() => {
+        if (listenersRef.current.size === 0)
+            return;
+        const bar = computeRealtimeBar();
+        if (!bar)
+            return;
+        lastEmittedRef.current = bar.t;
+        const tvBar = {
+            time: bar.t,
+            open: bar.o,
+            high: bar.h,
+            low: bar.l,
+            close: bar.c,
+        };
+        listenersRef.current.forEach((cb) => {
+            try {
+                cb(tvBar);
+            }
+            catch (e) { /* noop */ }
+        });
+    }, [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,
     };
 };
 
@@ -8330,4 +8362,49 @@ class ConflictDetector {
     }
 }
 
-export { AccountSummaryCalculator, ConflictDetector, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, TokenMetadataExtractor, calculateWeightedRatio, computeBasketCandles, createCandleLookups, PearHyperliquidClient as default, getCompleteTimestamps, useAccountSummary, useAddress, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTokenSelectionMetadata, useTradeHistories, useUserSelection, useWebData };
+/**
+ * Maps TradingView ResolutionString to CandleInterval
+ */
+function mapTradingViewIntervalToCandleInterval(interval) {
+    switch (interval) {
+        case '1': return '1m';
+        case '3': return '3m';
+        case '5': return '5m';
+        case '15': return '15m';
+        case '30': return '30m';
+        case '60': return '1h';
+        case '120': return '2h';
+        case '240': return '4h';
+        case '480': return '8h';
+        case '720': return '12h';
+        case '1D': return '1d';
+        case '3D': return '3d';
+        case '1W': return '1w';
+        case '1M': return '1M';
+        default: return '1h'; // fallback to 1 hour
+    }
+}
+/**
+ * Maps CandleInterval to TradingView ResolutionString
+ */
+function mapCandleIntervalToTradingViewInterval(interval) {
+    switch (interval) {
+        case '1m': return '1';
+        case '3m': return '3';
+        case '5m': return '5';
+        case '15m': return '15';
+        case '30m': return '30';
+        case '1h': return '60';
+        case '2h': return '120';
+        case '4h': return '240';
+        case '8h': return '480';
+        case '12h': return '720';
+        case '1d': return '1D';
+        case '3d': return '3D';
+        case '1w': return '1W';
+        case '1M': return '1M';
+        default: return '60'; // fallback to 1 hour
+    }
+}
+
+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 };