@pear-protocol/hyperliquid-sdk 0.0.8 → 0.0.10

package/dist/index.esm.js

@@ -2638,21 +2638,17 @@ const useHyperliquidWebSocket = ({ wsUrl, address }) => {
         accountSummary: null,
     });
     const [lastError, setLastError] = useState(null);
+    const [lastSubscribedAddress, setLastSubscribedAddress] = useState(null);
     // WebSocket connection
-    const { lastMessage, readyState, sendMessage } = useWebSocket(address ? wsUrl : null, // Only connect when address is set
-    {
+    const { readyState, sendMessage } = useWebSocket(wsUrl, {
         shouldReconnect: () => true,
         reconnectAttempts: 5,
         reconnectInterval: 3000,
-    });
-    const isConnected = readyState === dist.ReadyState.OPEN;
-    // Handle incoming WebSocket messages
-    useEffect(() => {
-        if (lastMessage !== null) {
+        onMessage: (event) => {
             try {
-                const message = JSON.parse(lastMessage.data);
-                // Handle subscription responses
-                if ('success' in message || 'error' in message) {
+                const message = JSON.parse(event.data);
+                // Handle subscription responses (only if they don't have channel data)
+                if (('success' in message || 'error' in message) && !('channel' in message)) {
                     if (message.error) {
                         setLastError(message.error);
                     }
@@ -2664,30 +2660,42 @@ const useHyperliquidWebSocket = ({ wsUrl, address }) => {
                 // Handle channel data messages
                 if ('channel' in message && 'data' in message) {
                     const dataMessage = message;
+                    // Validate data exists and is not null/undefined
+                    if (dataMessage.data === null || dataMessage.data === undefined) {
+                        return;
+                    }
                     switch (dataMessage.channel) {
                         case 'trade-histories':
-                            setData(prev => ({
-                                ...prev,
-                                tradeHistories: dataMessage.data
-                            }));
+                            if (Array.isArray(dataMessage.data)) {
+                                setData(prev => ({
+                                    ...prev,
+                                    tradeHistories: dataMessage.data
+                                }));
+                            }
                             break;
                         case 'open-positions':
-                            setData(prev => ({
-                                ...prev,
-                                openPositions: dataMessage.data
-                            }));
+                            if (Array.isArray(dataMessage.data)) {
+                                setData(prev => ({
+                                    ...prev,
+                                    openPositions: dataMessage.data
+                                }));
+                            }
                             break;
                         case 'open-orders':
-                            setData(prev => ({
-                                ...prev,
-                                openOrders: dataMessage.data
-                            }));
+                            if (Array.isArray(dataMessage.data)) {
+                                setData(prev => ({
+                                    ...prev,
+                                    openOrders: dataMessage.data
+                                }));
+                            }
                             break;
                         case 'account-summary':
-                            setData(prev => ({
-                                ...prev,
-                                accountSummary: dataMessage.data
-                            }));
+                            if (typeof dataMessage.data === 'object' && dataMessage.data !== null) {
+                                setData(prev => ({
+                                    ...prev,
+                                    accountSummary: dataMessage.data
+                                }));
+                            }
                             break;
                     }
                 }
@@ -2696,34 +2704,47 @@ const useHyperliquidWebSocket = ({ wsUrl, address }) => {
                 setLastError(`Failed to parse message: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-    }, [lastMessage]);
-    // Handle address changes - subscribe/unsubscribe
+    });
+    const isConnected = readyState === dist.ReadyState.OPEN;
+    // Handle subscription management
     useEffect(() => {
-        if (isConnected && address) {
+        if (isConnected && address && address !== lastSubscribedAddress) {
+            // Unsubscribe from previous address if exists
+            if (lastSubscribedAddress) {
+                sendMessage(JSON.stringify({
+                    action: 'unsubscribe',
+                    address: lastSubscribedAddress
+                }));
+            }
             // Subscribe to new address
             sendMessage(JSON.stringify({
                 action: 'subscribe',
                 address: address
             }));
-            // Clear previous data
-            setData({
-                tradeHistories: null,
-                openPositions: null,
-                openOrders: null,
-                accountSummary: null,
-            });
+            setLastSubscribedAddress(address);
             setLastError(null);
         }
-        else if (isConnected && !address) {
-            // Clear data when address is removed
+        else if (isConnected && !address && lastSubscribedAddress) {
+            // Send unsubscribe action when address is removed
+            sendMessage(JSON.stringify({
+                action: 'unsubscribe',
+                address: lastSubscribedAddress
+            }));
+            setLastSubscribedAddress(null);
+        }
+    }, [isConnected, address, lastSubscribedAddress, sendMessage]);
+    // Clear data when address changes
+    useEffect(() => {
+        if (address !== lastSubscribedAddress) {
             setData({
                 tradeHistories: null,
                 openPositions: null,
                 openOrders: null,
                 accountSummary: null,
             });
+            setLastError(null);
         }
-    }, [isConnected, address, sendMessage]);
+    }, [address, lastSubscribedAddress]);
     return {
         data,
         connectionStatus: readyState,
@@ -2739,29 +2760,61 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
     const [subscribedAddress, setSubscribedAddress] = useState(null);
     const pingIntervalRef = useRef(null);
     // WebSocket connection to HyperLiquid native API
-    const { lastMessage, readyState, sendJsonMessage } = useWebSocket('wss://api.hyperliquid.xyz/ws', {
+    const { readyState, sendJsonMessage } = useWebSocket('wss://api.hyperliquid.xyz/ws', {
         shouldReconnect: () => true,
         reconnectAttempts: 5,
         reconnectInterval: 3000,
-        onOpen: () => console.log('[HyperLiquid WS] Connected to wss://api.hyperliquid.xyz/ws'),
-        onClose: () => console.log('[HyperLiquid WS] Connection closed'),
+        onOpen: () => { },
+        onClose: () => { },
         onError: (event) => console.error('[HyperLiquid WS] Connection error:', event),
         onReconnectStop: () => console.error('[HyperLiquid WS] Reconnection stopped after 5 attempts'),
+        onMessage: (event) => {
+            try {
+                const message = JSON.parse(event.data);
+                // Handle subscription responses
+                if ('success' in message || 'error' in message) {
+                    if (message.error) {
+                        console.error('[HyperLiquid WS] Subscription error:', message.error);
+                        setLastError(message.error);
+                    }
+                    else {
+                        setLastError(null);
+                    }
+                    return;
+                }
+                // Handle channel data messages
+                if ('channel' in message && 'data' in message) {
+                    const response = message;
+                    switch (response.channel) {
+                        case 'webData2':
+                            setWebData2(response.data);
+                            break;
+                        case 'allMids':
+                            setAllMids(response.data);
+                            break;
+                        default:
+                            console.warn(`[HyperLiquid WS] Unknown channel: ${response.channel}`);
+                    }
+                }
+            }
+            catch (error) {
+                const errorMessage = `Failed to parse message: ${error instanceof Error ? error.message : String(error)}`;
+                console.error('[HyperLiquid WS] Parse error:', errorMessage, 'Raw message:', event.data);
+                setLastError(errorMessage);
+            }
+        }
     });
     const isConnected = readyState === dist.ReadyState.OPEN;
     // Setup ping mechanism
     useEffect(() => {
         if (isConnected) {
-            console.log('[HyperLiquid WS] Setting up ping mechanism (30s interval)');
             // Send ping every 30 seconds
             pingIntervalRef.current = setInterval(() => {
-                console.log('[HyperLiquid WS] Sending ping');
                 sendJsonMessage({ method: 'ping' });
             }, 30000);
         }
         else {
             if (pingIntervalRef.current) {
-                console.log('[HyperLiquid WS] Clearing ping interval');
                 clearInterval(pingIntervalRef.current);
                 pingIntervalRef.current = null;
             }
@@ -2783,7 +2836,6 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
             return;
         // Unsubscribe from previous address if exists
         if (subscribedAddress) {
-            console.log(`[HyperLiquid WS] Unsubscribing from webData2 for previous address: ${subscribedAddress}`);
             const unsubscribeMessage = {
                 method: 'unsubscribe',
                 subscription: {
@@ -2794,7 +2846,6 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
             sendJsonMessage(unsubscribeMessage);
         }
         // Subscribe to webData2 with new address
-        console.log(`[HyperLiquid WS] Subscribing to webData2 for address: ${userAddress}`);
         const subscribeWebData2 = {
             method: 'subscribe',
             subscription: {
@@ -2803,7 +2854,6 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
             },
         };
         // Subscribe to allMids
-        console.log('[HyperLiquid WS] Subscribing to allMids');
         const subscribeAllMids = {
             method: 'subscribe',
             subscription: {
@@ -2815,53 +2865,9 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
         setSubscribedAddress(userAddress);
         // Clear previous data when address changes
         if (subscribedAddress && subscribedAddress !== userAddress) {
-            console.log('[HyperLiquid WS] Address changed, clearing previous webData2');
             setWebData2(null);
         }
     }, [isConnected, address, subscribedAddress, sendJsonMessage]);
-    // Handle incoming WebSocket messages
-    useEffect(() => {
-        if (!lastMessage)
-            return;
-        try {
-            const message = JSON.parse(lastMessage.data);
-            console.log('[HyperLiquid WS] Received message:', message);
-            // Handle subscription responses
-            if ('success' in message || 'error' in message) {
-                if (message.error) {
-                    console.error('[HyperLiquid WS] Subscription error:', message.error);
-                    setLastError(message.error);
-                }
-                else {
-                    console.log('[HyperLiquid WS] Subscription success:', message);
-                    setLastError(null);
-                }
-                return;
-            }
-            // Handle channel data messages
-            if ('channel' in message && 'data' in message) {
-                const response = message;
-                console.log(`[HyperLiquid WS] Received ${response.channel} data`);
-                switch (response.channel) {
-                    case 'webData2':
-                        console.log('[HyperLiquid WS] Setting webData2:', response.data);
-                        setWebData2(response.data);
-                        break;
-                    case 'allMids':
-                        console.log('[HyperLiquid WS] Setting allMids:', response.data);
-                        setAllMids(response.data);
-                        break;
-                    default:
-                        console.warn(`[HyperLiquid WS] Unknown channel: ${response.channel}`);
-                }
-            }
-        }
-        catch (error) {
-            const errorMessage = `Failed to parse message: ${error instanceof Error ? error.message : String(error)}`;
-            console.error('[HyperLiquid WS] Parse error:', errorMessage, 'Raw message:', lastMessage.data);
-            setLastError(errorMessage);
-        }
-    }, [lastMessage]);
     return {
         webData2,
         allMids,
@@ -2949,84 +2955,76 @@ const useAddress = () => {
     };
 };
 
-/**
- * Position side enum for calculations
- */
 var PositionSide;
 (function (PositionSide) {
     PositionSide["LONG"] = "LONG";
     PositionSide["SHORT"] = "SHORT";
 })(PositionSide || (PositionSide = {}));
-/**
- * Aggregate position calculation utility class that handles cross-position asset syncing
- */
-class AggregatePositionCalculator {
+class PositionProcessor {
     constructor(webData2, allMids) {
         this.webData2 = webData2;
         this.allMids = allMids;
     }
-    /**
-     * Get market price for a coin from allMids data
-     */
+    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;
-        // Try exact match first
         const exactPrice = this.allMids.mids[coin];
         if (exactPrice) {
             return Number(exactPrice);
         }
-        // If coin has a slash (like "BTC/USD"), try just the base currency
-        const baseCurrency = coin.split('/')[0];
+        const baseCurrency = this.extractBaseCurrency(coin);
         const basePrice = this.allMids.mids[baseCurrency];
         if (basePrice) {
             return Number(basePrice);
         }
-        console.warn(`[AggregatePositionCalculator] No market price found for coin: ${coin}`);
         return 0;
     }
-    /**
-     * Get user positions from webData2
-     */
-    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) || [];
-    }
-    /**
-     * Calculate updated open positions by syncing platform positions with HyperLiquid data
-     * Uses aggregate totals across all positions for accurate cross-position sync
-     */
-    calculateOpenPositions(platformPositions) {
-        if (!(platformPositions === null || platformPositions === void 0 ? void 0 : platformPositions.length)) {
-            return [];
-        }
-        const hyperliquidPositions = this.getUserPositions();
-        // Build a map of total platform sizes per asset across ALL positions
-        const platformTotalsByAsset = this.calculatePlatformTotalsByAsset(platformPositions);
-        // Create a map of HyperLiquid positions by coin
-        const hlPositionsMap = new Map();
-        hyperliquidPositions.forEach(assetPos => {
-            var _a;
-            if ((_a = assetPos.position) === null || _a === void 0 ? void 0 : _a.coin) {
-                hlPositionsMap.set(assetPos.position.coin, assetPos);
-            }
-        });
-        // Process each position with awareness of the aggregated totals
-        return platformPositions.map(position => this.syncPositionWithAggregateData(position, hlPositionsMap, platformTotalsByAsset));
-    }
-    /**
-     * Calculate total platform sizes per asset across all positions
-     */
     calculatePlatformTotalsByAsset(positions) {
         const totalsMap = new Map();
         for (const position of positions) {
-            // Combine all assets from both sides
-            const allAssets = [
-                ...position.longAssets.map(asset => ({ ...asset, side: PositionSide.LONG })),
-                ...position.shortAssets.map(asset => ({ ...asset, side: PositionSide.SHORT }))
-            ];
-            for (const asset of allAssets) {
+            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, {
@@ -3035,7 +3033,7 @@ class AggregatePositionCalculator {
                     });
                 }
                 const totals = totalsMap.get(baseCurrency);
-                const assetSize = asset.platformSize;
+                const assetSize = Number(asset.size || 0);
                 totals.totalSize += assetSize;
                 totals.positions.push({
                     positionId: position.positionId,
@@ -3046,47 +3044,44 @@ class AggregatePositionCalculator {
         }
         return totalsMap;
     }
-    /**
-     * Extract base currency from asset name (handles "LINK/USD" -> "LINK")
-     */
     extractBaseCurrency(assetName) {
         return assetName.split('/')[0] || assetName;
     }
-    /**
-     * Sync a single position with HyperLiquid data using aggregate totals
-     */
     syncPositionWithAggregateData(position, hlPositionsMap, platformTotalsByAsset) {
         const syncResults = [];
         let hasExternalModification = false;
         let allAssetsClosed = true;
-        // Separate tracking for long and short sides
         let longAssetStatuses = { total: 0, closed: 0 };
         let shortAssetStatuses = { total: 0, closed: 0 };
-        // Process all assets
-        const allAssets = [
-            ...position.longAssets.map(asset => ({ ...asset, side: PositionSide.LONG })),
-            ...position.shortAssets.map(asset => ({ ...asset, side: PositionSide.SHORT }))
-        ];
-        for (const asset of allAssets) {
+        // 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, hlPosition, (platformTotals === null || platformTotals === void 0 ? void 0 : platformTotals.totalSize) || 0);
+            const syncResult = this.syncAssetWithAggregateData({ ...asset, side: PositionSide.LONG }, hlPosition, (platformTotals === null || platformTotals === void 0 ? void 0 : platformTotals.totalSize) || 0);
             syncResults.push(syncResult);
-            // Track status by side
-            if (asset.side === PositionSide.LONG) {
-                longAssetStatuses.total++;
-                if (syncResult.actualSize === 0) {
-                    longAssetStatuses.closed++;
-                }
+            longAssetStatuses.total++;
+            if (syncResult.actualSize === 0) {
+                longAssetStatuses.closed++;
             }
-            else if (asset.side === PositionSide.SHORT) {
-                shortAssetStatuses.total++;
-                if (syncResult.actualSize === 0) {
-                    shortAssetStatuses.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++;
             }
-            // Update flags
             if (syncResult.isExternallyModified) {
                 hasExternalModification = true;
             }
@@ -3094,17 +3089,27 @@ class AggregatePositionCalculator {
                 allAssetsClosed = false;
             }
         }
-        // Determine sync status
         const syncStatus = this.determineSyncStatus(hasExternalModification, allAssetsClosed, longAssetStatuses, shortAssetStatuses);
-        return this.buildUpdatedPosition(position, syncResults, syncStatus);
+        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';
     }
-    /**
-     * Sync individual asset with aggregate data awareness
-     */
     syncAssetWithAggregateData(asset, hlPosition, platformTotal) {
-        var _a, _b, _c;
-        const platformSize = asset.platformSize;
-        // No position on HyperLiquid - asset was closed
+        const platformSize = Number(asset.size || 0);
         if (!hlPosition || !hlPosition.position || !hlPosition.position.szi) {
             return {
                 asset,
@@ -3112,27 +3117,23 @@ class AggregatePositionCalculator {
                 isExternallyModified: true,
                 cumFunding: { allTime: 0, sinceChange: 0, sinceOpen: 0 },
                 unrealizedPnl: 0,
-                liquidationPrice: 0,
-                side: asset.side
+                liquidationPrice: 0
             };
         }
         const hlTotalSize = Math.abs(Number(hlPosition.position.szi || 0));
-        // Check if the TOTAL platform size matches HyperLiquid total
         const totalDifference = Math.abs(hlTotalSize - platformTotal);
-        const tolerance = platformTotal * 0.001; // 0.1% tolerance
+        const tolerance = platformTotal * 0.001;
         const isExternallyModified = totalDifference > tolerance;
-        // Calculate this position's proportional share of the HyperLiquid position
         const proportion = platformTotal > 0 ? platformSize / platformTotal : 0;
         const actualSize = hlTotalSize * proportion;
-        // Distribute funding proportionally
+        // Get cumFunding from hlPosition.position.cumFunding
+        const rawCumFunding = hlPosition.position.cumFunding;
         const cumFunding = {
-            allTime: Number(((_a = hlPosition.cumFunding) === null || _a === void 0 ? void 0 : _a.allTime) || 0),
-            sinceChange: Number(((_b = hlPosition.cumFunding) === null || _b === void 0 ? void 0 : _b.sinceChange) || 0) * proportion,
-            sinceOpen: Number(((_c = hlPosition.cumFunding) === null || _c === void 0 ? void 0 : _c.sinceOpen) || 0) * proportion
+            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
         };
-        // Distribute PnL proportionally
         const unrealizedPnl = Number(hlPosition.position.unrealizedPnl || 0) * proportion;
-        // Liquidation price is the same for all positions of the same asset
         const liquidationPrice = Number(hlPosition.position.liquidationPx || 0);
         return {
             asset,
@@ -3140,46 +3141,27 @@ class AggregatePositionCalculator {
             isExternallyModified,
             cumFunding,
             unrealizedPnl,
-            liquidationPrice,
-            side: asset.side
+            liquidationPrice
         };
     }
-    /**
-     * Determine sync status with sophisticated side-aware logic
-     */
-    determineSyncStatus(hasExternalModification, allAssetsClosed, longAssetStatuses, shortAssetStatuses) {
-        // All assets closed externally
-        if (allAssetsClosed) {
-            return 'EXTERNALLY_CLOSED';
-        }
-        // Check if pair is broken (one entire side 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';
-        }
-        // External modification detected
-        if (hasExternalModification) {
-            return 'EXTERNALLY_MODIFIED';
-        }
-        // Everything synced properly
-        return 'SYNCED';
-    }
-    /**
-     * Build updated position with synced data
-     */
-    buildUpdatedPosition(originalPosition, syncResults, syncStatus) {
-        const longSyncResults = syncResults.filter(result => result.side === PositionSide.LONG);
-        const shortSyncResults = syncResults.filter(result => result.side === PositionSide.SHORT);
-        // Calculate position metrics
+    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 / originalPosition.leverage;
+        const totalMarginUsed = entryTotalPositionValue / position.leverage;
         return {
-            ...originalPosition,
-            syncStatus,
+            syncStatus: syncStatus,
+            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),
@@ -3187,90 +3169,73 @@ class AggregatePositionCalculator {
             marginUsed: totalMarginUsed,
             unrealizedPnl: this.calculateTotalUnrealizedPnlFromSyncResults(syncResults),
             lastSyncAt: new Date().toISOString(),
-            longAssets: longSyncResults.map(result => this.mapSyncResultToAssetDto(result)),
-            shortAssets: shortSyncResults.map(result => this.mapSyncResultToAssetDto(result)),
-            updatedAt: 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
         };
     }
-    /**
-     * Map sync result to PositionAssetDetailDto
-     */
-    mapSyncResultToAssetDto(syncResult) {
-        const currentPrice = this.getMarketPrice(syncResult.asset.coin);
-        const positionValue = syncResult.actualSize * currentPrice;
-        const entryValue = syncResult.actualSize * syncResult.asset.entryPrice;
+    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 {
-            ...syncResult.asset,
-            actualSize: syncResult.actualSize,
-            isExternallyModified: syncResult.isExternallyModified,
-            cumFunding: syncResult.cumFunding,
+            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: syncResult.unrealizedPnl,
-            liquidationPrice: syncResult.liquidationPrice
+            unrealizedPnl: (syncData === null || syncData === void 0 ? void 0 : syncData.unrealizedPnl) || 0,
+            liquidationPrice: (syncData === null || syncData === void 0 ? void 0 : syncData.liquidationPrice) || 0
         };
     }
-    /**
-     * Calculate entry ratio using actual sizes from sync results
-     */
     calculateEntryRatio(syncResults) {
-        const longResults = syncResults.filter(result => result.side === PositionSide.LONG);
-        const shortResults = syncResults.filter(result => result.side === PositionSide.SHORT);
+        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 longValue = longResults.reduce((sum, result) => {
-            return sum + (result.actualSize * result.asset.entryPrice);
-        }, 0);
-        const shortValue = shortResults.reduce((sum, result) => {
-            return sum + (result.actualSize * result.asset.entryPrice);
-        }, 0);
-        return shortValue > 0 ? longValue / shortValue : 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;
     }
-    /**
-     * Calculate mark ratio using actual sizes and current prices
-     */
     calculateMarkRatio(syncResults) {
-        const longResults = syncResults.filter(result => result.side === PositionSide.LONG);
-        const shortResults = syncResults.filter(result => result.side === PositionSide.SHORT);
+        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 longValue = longResults.reduce((sum, result) => {
-            const currentPrice = this.getMarketPrice(result.asset.coin);
-            return sum + (result.actualSize * currentPrice);
-        }, 0);
-        const shortValue = shortResults.reduce((sum, result) => {
-            const currentPrice = this.getMarketPrice(result.asset.coin);
-            return sum + (result.actualSize * currentPrice);
-        }, 0);
-        return shortValue > 0 ? longValue / shortValue : 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;
     }
-    /**
-     * Calculate net funding from sync results
-     */
     calculateNetFundingFromSyncResults(syncResults) {
-        return syncResults.reduce((sum, result) => sum + result.cumFunding.sinceOpen, 0);
+        const netFunding = syncResults.reduce((sum, result) => {
+            const funding = result.cumFunding.sinceOpen;
+            return sum + funding;
+        }, 0);
+        return netFunding;
     }
-    /**
-     * Calculate total unrealized PnL from sync results
-     */
     calculateTotalUnrealizedPnlFromSyncResults(syncResults) {
         return syncResults.reduce((sum, result) => sum + result.unrealizedPnl, 0);
     }
-    /**
-     * Calculate current total position value using market prices
-     */
     calculateCurrentTotalPositionValue(syncResults) {
         return syncResults.reduce((sum, result) => {
             const currentPrice = this.getMarketPrice(result.asset.coin);
             return sum + (result.actualSize * currentPrice);
         }, 0);
     }
-    /**
-     * Calculate entry total position value using entry prices
-     */
     calculateEntryTotalPositionValue(syncResults) {
         return syncResults.reduce((sum, result) => {
-            return sum + (result.actualSize * result.asset.entryPrice);
+            return sum + (Number(result.asset.size || 0) * Number(result.asset.entryPrice || 0));
         }, 0);
     }
 }
@@ -3280,32 +3245,18 @@ class AggregatePositionCalculator {
  */
 const useCalculatedOpenPositions = (platformPositions, webData2, allMids) => {
     const calculatedPositions = useMemo(() => {
-        var _a, _b;
         // Return null if we don't have platform positions yet
         if (!platformPositions) {
-            console.log('[useCalculatedOpenPositions] No platform positions available');
             return null;
         }
-        // If we don't have real-time data yet, return platform positions as-is
+        // If we don't have real-time data yet, we can't calculate properly, return null
         if (!webData2 || !allMids) {
-            console.log('[useCalculatedOpenPositions] Missing real-time data, returning platform positions');
-            return platformPositions;
-        }
-        console.log('[useCalculatedOpenPositions] Calculating positions with real-time data', {
-            platformPositionsCount: platformPositions.length,
-            hasWebData2: !!webData2,
-            hasAllMids: !!allMids,
-            hyperliquidPositionsCount: ((_b = (_a = webData2.clearinghouseState) === null || _a === void 0 ? void 0 : _a.assetPositions) === null || _b === void 0 ? void 0 : _b.length) || 0,
-            availableMids: Object.keys(allMids.mids || {}).length
-        });
-        // Create calculator and compute positions
-        const calculator = new AggregatePositionCalculator(webData2, allMids);
-        const calculated = calculator.calculateOpenPositions(platformPositions);
-        console.log('[useCalculatedOpenPositions] Calculation completed', {
-            inputCount: platformPositions.length,
-            outputCount: calculated.length
-        });
-        return calculated;
+            return null;
+        }
+        // Create processor and compute positions
+        const processor = new PositionProcessor(webData2, allMids);
+        const processed = processor.execute(platformPositions);
+        return processed;
     }, [platformPositions, webData2, allMids]);
     return calculatedPositions;
 };
@@ -3324,19 +3275,11 @@ class AccountSummaryCalculator {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         // If we don't have webData2, return platform data as-is
         if (!((_a = this.webData2) === null || _a === void 0 ? void 0 : _a.clearinghouseState)) {
-            console.log('[AccountSummaryCalculator] No webData2 clearinghouseState available, returning platform data');
             return platformAccountSummary;
         }
-        console.log('[AccountSummaryCalculator] Calculating account summary with real-time data', {
-            hasPlatformSummary: !!platformAccountSummary,
-            hasOpenOrders: !!platformOpenOrders,
-            openOrdersCount: (platformOpenOrders === null || platformOpenOrders === void 0 ? void 0 : platformOpenOrders.length) || 0,
-            hasAgentWallet: !!agentWalletAddress
-        });
         const clearinghouseState = this.webData2.clearinghouseState;
         // Calculate total limit order value from platform orders
         const totalLimitOrderValue = this.calculateTotalLimitOrderValue(platformOpenOrders || []);
-        console.log('[AccountSummaryCalculator] Total limit order value:', totalLimitOrderValue);
         // Use real-time data from webData2 clearinghouseState
         const withdrawableAmount = parseFloat(clearinghouseState.withdrawable || '0');
         const adjustedWithdrawable = Math.max(0, withdrawableAmount - totalLimitOrderValue);
@@ -3363,12 +3306,6 @@ class AccountSummaryCalculator {
                 status: agentWalletStatus || ((_l = platformAccountSummary === null || platformAccountSummary === void 0 ? void 0 : platformAccountSummary.agentWallet) === null || _l === void 0 ? void 0 : _l.status) || 'UNKNOWN'
             }
         };
-        console.log('[AccountSummaryCalculator] Calculated account summary:', {
-            accountValue: accountSummary.balanceSummary.crossMarginSummary.accountValue,
-            withdrawable: accountSummary.balanceSummary.withdrawable,
-            totalMarginUsed: accountSummary.balanceSummary.crossMarginSummary.totalMarginUsed,
-            agentWalletAddress: accountSummary.agentWallet.address
-        });
         return accountSummary;
     }
     /**
@@ -3381,11 +3318,6 @@ class AccountSummaryCalculator {
         const totalValue = openOrders
             .filter(order => order.status === 'OPEN' || order.status === 'PROCESSING')
             .reduce((sum, order) => sum + order.usdValue, 0);
-        console.log('[AccountSummaryCalculator] Calculated limit order value:', {
-            totalOrders: openOrders.length,
-            openOrders: openOrders.filter(order => order.status === 'OPEN' || order.status === 'PROCESSING').length,
-            totalValue
-        });
         return totalValue;
     }
     /**
@@ -3409,52 +3341,41 @@ class AccountSummaryCalculator {
  */
 const useCalculatedAccountSummary = (platformAccountSummary, platformOpenOrders, webData2, agentWalletAddress, agentWalletStatus) => {
     const calculatedAccountSummary = useMemo(() => {
-        var _a, _b, _c;
         // Return null if we don't have platform account summary yet
         if (!platformAccountSummary) {
-            console.log('[useCalculatedAccountSummary] No platform account summary available');
             return null;
         }
         // If we don't have real-time data yet, return platform summary as-is
         if (!(webData2 === null || webData2 === void 0 ? void 0 : webData2.clearinghouseState)) {
-            console.log('[useCalculatedAccountSummary] Missing webData2 clearinghouseState, returning platform summary');
             return platformAccountSummary;
         }
-        console.log('[useCalculatedAccountSummary] Calculating account summary with real-time data', {
-            hasPlatformSummary: !!platformAccountSummary,
-            hasWebData2: !!webData2,
-            hasClearinghouseState: !!webData2.clearinghouseState,
-            hasOpenOrders: !!platformOpenOrders,
-            openOrdersCount: (platformOpenOrders === null || platformOpenOrders === void 0 ? void 0 : platformOpenOrders.length) || 0,
-            agentWalletAddress,
-            agentWalletStatus
-        });
         // Create calculator and compute account summary
         const calculator = new AccountSummaryCalculator(webData2);
         const calculated = calculator.calculateAccountSummary(platformAccountSummary, platformOpenOrders, agentWalletAddress, agentWalletStatus);
-        console.log('[useCalculatedAccountSummary] Calculation completed', {
-            hadPlatformSummary: !!platformAccountSummary,
-            calculatedSummary: !!calculated,
-            withdrawable: (_a = calculated === null || calculated === void 0 ? void 0 : calculated.balanceSummary) === null || _a === void 0 ? void 0 : _a.withdrawable,
-            accountValue: (_c = (_b = calculated === null || calculated === void 0 ? void 0 : calculated.balanceSummary) === null || _b === void 0 ? void 0 : _b.crossMarginSummary) === null || _c === void 0 ? void 0 : _c.accountValue
-        });
         return calculated;
     }, [platformAccountSummary, platformOpenOrders, webData2, agentWalletAddress, agentWalletStatus]);
     return calculatedAccountSummary;
 };
 
 /**
- * Hook to access trade histories
+ * Hook to access trade histories with loading state
  */
 const useTradeHistories = () => {
     const context = useContext(PearHyperliquidContext);
     if (!context) {
         throw new Error('useTradeHistories must be used within a PearHyperliquidProvider');
     }
-    return context.data.tradeHistories;
+    const isLoading = useMemo(() => {
+        // Loading is true initially and becomes false once we get the first data
+        return context.data.tradeHistories === null && context.isConnected;
+    }, [context.data.tradeHistories, context.isConnected]);
+    return {
+        data: context.data.tradeHistories,
+        isLoading
+    };
 };
 /**
- * Hook to access open positions with real-time calculations
+ * Hook to access open positions with real-time calculations and loading state
  */
 const useOpenPositions = () => {
     const context = useContext(PearHyperliquidContext);
@@ -3463,20 +3384,38 @@ const useOpenPositions = () => {
     }
     // Use calculated positions that sync platform data with HyperLiquid real-time data
     const calculatedPositions = useCalculatedOpenPositions(context.data.openPositions, context.webData2, context.allMids);
-    return calculatedPositions;
+    const isLoading = useMemo(() => {
+        // Loading is true initially and becomes false only when:
+        // 1. WebSocket has open-positions data
+        // 2. webData2 and allMids are ready (required for calculations)
+        // 3. Connection is established
+        return (context.isConnected &&
+            (context.data.openPositions === null || !context.webData2 || !context.allMids));
+    }, [context.data.openPositions, context.webData2, context.allMids, context.isConnected]);
+    return {
+        data: calculatedPositions,
+        isLoading
+    };
 };
 /**
- * Hook to access open orders
+ * Hook to access open orders with loading state
  */
 const useOpenOrders = () => {
     const context = useContext(PearHyperliquidContext);
     if (!context) {
         throw new Error('useOpenOrders must be used within a PearHyperliquidProvider');
     }
-    return context.data.openOrders;
+    const isLoading = useMemo(() => {
+        // Loading is true initially and becomes false once we get the first data
+        return context.data.openOrders === null && context.isConnected;
+    }, [context.data.openOrders, context.isConnected]);
+    return {
+        data: context.data.openOrders,
+        isLoading
+    };
 };
 /**
- * Hook to access account summary with real-time calculations
+ * Hook to access account summary with real-time calculations and loading state
  */
 const useAccountSummary = () => {
     var _a, _b, _c, _d;
@@ -3486,8 +3425,15 @@ const useAccountSummary = () => {
     }
     // Use calculated account summary that syncs platform data with HyperLiquid real-time data
     const calculatedAccountSummary = useCalculatedAccountSummary(context.data.accountSummary, context.data.openOrders, context.webData2, (_b = (_a = context.data.accountSummary) === null || _a === void 0 ? void 0 : _a.agentWallet) === null || _b === void 0 ? void 0 : _b.address, (_d = (_c = context.data.accountSummary) === null || _c === void 0 ? void 0 : _c.agentWallet) === null || _d === void 0 ? void 0 : _d.status);
-    return calculatedAccountSummary;
+    const isLoading = useMemo(() => {
+        // Loading is true initially and becomes false once we get the first data
+        return context.data.accountSummary === null && context.isConnected;
+    }, [context.data.accountSummary, context.isConnected]);
+    return {
+        data: calculatedAccountSummary,
+        isLoading
+    };
 };
 
-export { AccountSummaryCalculator, AggregatePositionCalculator, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, PositionSide, PearHyperliquidClient as default, useAccountSummary, useAddress, useCalculatedAccountSummary, useCalculatedOpenPositions, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTradeHistories };
+export { AccountSummaryCalculator, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, PearHyperliquidClient as default, useAccountSummary, useAddress, useCalculatedAccountSummary, useCalculatedOpenPositions, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTradeHistories };
 //# sourceMappingURL=index.esm.js.map