@pear-protocol/hyperliquid-sdk 0.0.7 → 0.0.9

package/dist/index.esm.js

@@ -2743,8 +2743,8 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
         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'),
     });
@@ -2752,16 +2752,13 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
     // 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 +2780,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 +2790,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 +2798,6 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
             },
         };
         // Subscribe to allMids
-        console.log('[HyperLiquid WS] Subscribing to allMids');
         const subscribeAllMids = {
             method: 'subscribe',
             subscription: {
@@ -2815,7 +2809,6 @@ 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]);
@@ -2825,7 +2818,6 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
             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) {
@@ -2833,7 +2825,6 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
                     setLastError(message.error);
                 }
                 else {
-                    console.log('[HyperLiquid WS] Subscription success:', message);
                     setLastError(null);
                 }
                 return;
@@ -2841,14 +2832,11 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
             // 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:
@@ -2949,193 +2937,213 @@ const useAddress = () => {
     };
 };
 
-/**
- * Position side enum for calculations
- */
 var PositionSide;
 (function (PositionSide) {
     PositionSide["LONG"] = "LONG";
     PositionSide["SHORT"] = "SHORT";
 })(PositionSide || (PositionSide = {}));
-/**
- * Position calculation utility class
- */
-class PositionCalculator {
+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(`[PositionCalculator] 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
-     */
-    calculateOpenPositions(platformPositions) {
-        if (!(platformPositions === null || platformPositions === void 0 ? void 0 : platformPositions.length)) {
-            return [];
+    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
+                });
+            }
         }
-        const hyperliquidPositions = this.getUserPositions();
-        return platformPositions.map(position => this.syncPositionWithHyperliquid(position, hyperliquidPositions));
+        return totalsMap;
     }
-    /**
-     * Sync a single position with HyperLiquid data
-     */
-    syncPositionWithHyperliquid(position, hyperliquidPositions) {
-        // Create a map of HyperLiquid positions by coin for quick lookup
-        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);
-            }
-        });
-        // Combine all assets for processing
-        const allAssets = [
-            ...position.longAssets.map(asset => ({ ...asset, side: PositionSide.LONG })),
-            ...position.shortAssets.map(asset => ({ ...asset, side: PositionSide.SHORT }))
-        ];
-        // Group assets by base currency for multi-pair position handling
-        const assetsByBaseCurrency = this.groupAssetsByBaseCurrency(allAssets);
-        // Sync each asset group with HyperLiquid data
+    extractBaseCurrency(assetName) {
+        return assetName.split('/')[0] || assetName;
+    }
+    syncPositionWithAggregateData(position, hlPositionsMap, platformTotalsByAsset) {
         const syncResults = [];
-        for (const [baseCurrency, assets] of assetsByBaseCurrency.entries()) {
+        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 groupSyncResults = this.syncAssetGroupWithHyperliquid(assets, hlPosition);
-            syncResults.push(...groupSyncResults);
-        }
-        // Update position sync status based on asset sync results
-        const syncStatus = this.determineSyncStatus(syncResults);
-        // Rebuild position with synced data
-        return this.buildUpdatedPosition(position, syncResults, syncStatus);
-    }
-    /**
-     * Group assets by their base currency
-     */
-    groupAssetsByBaseCurrency(assets) {
-        const grouped = new Map();
-        for (const asset of assets) {
-            const baseCurrency = asset.coin.split('/')[0] || asset.coin;
-            if (!grouped.has(baseCurrency)) {
-                grouped.set(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;
             }
-            grouped.get(baseCurrency).push(asset);
         }
-        return grouped;
-    }
-    /**
-     * Sync a group of assets (same base currency) with HyperLiquid position data
-     */
-    syncAssetGroupWithHyperliquid(assets, hlPosition) {
-        const results = [];
-        // Calculate total platform size for this base currency
-        const totalPlatformSize = assets.reduce((sum, asset) => sum + asset.platformSize, 0);
-        const actualTotalSize = hlPosition ? Math.abs(Number(hlPosition.position.szi || 0)) : 0;
-        // Check if the total size matches (within tolerance)
-        const sizeDifference = Math.abs(actualTotalSize - totalPlatformSize);
-        const sizeDifferencePercentage = totalPlatformSize > 0
-            ? (sizeDifference / totalPlatformSize) * 100
-            : (actualTotalSize > 0 ? 100 : 0);
-        const isGroupExternallyModified = sizeDifferencePercentage > 0.1; // 0.1% tolerance
-        for (const asset of assets) {
-            const platformSize = asset.platformSize;
-            let actualSize = platformSize;
-            let isExternallyModified = isGroupExternallyModified;
-            let cumFunding = {
-                allTime: 0,
-                sinceChange: 0,
-                sinceOpen: 0
-            };
-            let unrealizedPnl = 0;
-            let liquidationPrice = 0;
-            if (hlPosition) {
-                // Proportionally distribute the actual size based on asset's contribution
-                const sizeRatio = totalPlatformSize > 0 ? platformSize / totalPlatformSize : 0;
-                actualSize = actualTotalSize * sizeRatio;
-                // Proportionally distribute funding and PnL based on asset's contribution
-                if (hlPosition.cumFunding) {
-                    cumFunding = {
-                        allTime: Number(hlPosition.cumFunding.allTime || 0),
-                        sinceChange: Number(hlPosition.cumFunding.sinceChange || 0) * sizeRatio,
-                        sinceOpen: Number(hlPosition.cumFunding.sinceOpen || 0) * sizeRatio
-                    };
-                }
-                unrealizedPnl = Number(hlPosition.position.unrealizedPnl || 0) * sizeRatio;
-                liquidationPrice = Number(hlPosition.position.liquidationPx || 0);
+        // 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++;
             }
-            else {
-                // Position doesn't exist on HyperLiquid - it was closed externally
-                actualSize = 0;
-                isExternallyModified = true;
+            if (syncResult.isExternallyModified) {
+                hasExternalModification = true;
+            }
+            if (syncResult.actualSize !== 0) {
+                allAssetsClosed = false;
             }
-            results.push({
-                asset,
-                actualSize,
-                isExternallyModified,
-                cumFunding,
-                unrealizedPnl,
-                liquidationPrice,
-                side: asset.side
-            });
         }
-        return results;
+        const syncStatus = this.determineSyncStatus(hasExternalModification, allAssetsClosed, longAssetStatuses, shortAssetStatuses);
+        return this.mapPositionToDtoWithSyncData(position, syncResults, syncStatus);
     }
-    /**
-     * Determine sync status based on asset sync results
-     */
-    determineSyncStatus(syncResults) {
-        const hasExternalModifications = syncResults.some(result => result.isExternallyModified);
-        const allAssetsClosed = syncResults.every(result => result.actualSize === 0);
-        const someAssetsClosed = syncResults.some(result => result.actualSize === 0) && !allAssetsClosed;
+    determineSyncStatus(hasExternalModification, allAssetsClosed, longAssetStatuses, shortAssetStatuses) {
         if (allAssetsClosed) {
             return 'EXTERNALLY_CLOSED';
         }
-        else if (someAssetsClosed) {
+        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';
         }
-        else if (hasExternalModifications) {
+        if (hasExternalModification) {
             return 'EXTERNALLY_MODIFIED';
         }
         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
+    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 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 / 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),
@@ -3143,117 +3151,81 @@ class PositionCalculator {
             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 (weighted long entry value / weighted short entry value)
-     */
     calculateEntryRatio(syncResults) {
-        const longResults = syncResults.filter(result => result.side === PositionSide.LONG);
-        const shortResults = syncResults.filter(result => result.side === PositionSide.SHORT);
+        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;
-        // Calculate total position value at entry prices
-        const totalPositionValue = syncResults.reduce((sum, result) => {
-            return sum + (result.actualSize * result.asset.entryPrice);
+        const longValue = longResults.reduce((sum, result) => {
+            return sum + (Number(result.asset.size || 0) * Number(result.asset.entryPrice || 0));
         }, 0);
-        if (totalPositionValue === 0)
-            return 0;
-        // Calculate weighted long portfolio entry value
-        const weightedLongValue = longResults.reduce((sum, result) => {
-            const entryPrice = result.asset.entryPrice;
-            const assetValue = result.actualSize * entryPrice;
-            const weight = assetValue / totalPositionValue;
-            return sum + (entryPrice * weight);
-        }, 0);
-        // Calculate weighted short portfolio entry value
-        const weightedShortValue = shortResults.reduce((sum, result) => {
-            const entryPrice = result.asset.entryPrice;
-            const assetValue = result.actualSize * entryPrice;
-            const weight = assetValue / totalPositionValue;
-            return sum + (entryPrice * weight);
+        const shortValue = shortResults.reduce((sum, result) => {
+            return sum + (Number(result.asset.size || 0) * Number(result.asset.entryPrice || 0));
         }, 0);
-        return weightedShortValue > 0 ? weightedLongValue / weightedShortValue : 0;
+        return shortValue > 0 ? longValue / shortValue : 0;
     }
-    /**
-     * Calculate mark ratio (weighted long mark value / weighted short mark value)
-     */
     calculateMarkRatio(syncResults) {
-        const longResults = syncResults.filter(result => result.side === PositionSide.LONG);
-        const shortResults = syncResults.filter(result => result.side === PositionSide.SHORT);
+        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;
-        // Calculate total position value at current market prices
-        const totalPositionValue = syncResults.reduce((sum, result) => {
+        const longValue = longResults.reduce((sum, result) => {
             const currentPrice = this.getMarketPrice(result.asset.coin);
             return sum + (result.actualSize * currentPrice);
         }, 0);
-        if (totalPositionValue === 0)
-            return 0;
-        // Calculate weighted long portfolio value
-        const weightedLongValue = longResults.reduce((sum, result) => {
-            const currentPrice = this.getMarketPrice(result.asset.coin);
-            const assetValue = result.actualSize * currentPrice;
-            const weight = assetValue / totalPositionValue;
-            return sum + (currentPrice * weight);
-        }, 0);
-        // Calculate weighted short portfolio value
-        const weightedShortValue = shortResults.reduce((sum, result) => {
+        const shortValue = shortResults.reduce((sum, result) => {
             const currentPrice = this.getMarketPrice(result.asset.coin);
-            const assetValue = result.actualSize * currentPrice;
-            const weight = assetValue / totalPositionValue;
-            return sum + (currentPrice * weight);
+            return sum + (result.actualSize * currentPrice);
         }, 0);
-        return weightedShortValue > 0 ? weightedLongValue / weightedShortValue : 0;
+        return shortValue > 0 ? longValue / shortValue : 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);
     }
 }
@@ -3263,32 +3235,18 @@ class PositionCalculator {
  */
 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 PositionCalculator(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;
 };
@@ -3307,19 +3265,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);
@@ -3346,12 +3296,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;
     }
     /**
@@ -3364,11 +3308,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;
     }
     /**
@@ -3392,35 +3331,17 @@ 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;
@@ -3472,5 +3393,5 @@ const useAccountSummary = () => {
     return calculatedAccountSummary;
 };
 
-export { AccountSummaryCalculator, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, PositionCalculator, 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