@pear-protocol/hyperliquid-sdk 0.0.8 → 0.0.9

package/dist/index.js

@@ -2747,8 +2747,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'),
     });
@@ -2756,16 +2756,13 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
     // Setup ping mechanism
     require$$0.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;
             }
@@ -2787,7 +2784,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: {
@@ -2798,7 +2794,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: {
@@ -2807,7 +2802,6 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
             },
         };
         // Subscribe to allMids
-        console.log('[HyperLiquid WS] Subscribing to allMids');
         const subscribeAllMids = {
             method: 'subscribe',
             subscription: {
@@ -2819,7 +2813,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]);
@@ -2829,7 +2822,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) {
@@ -2837,7 +2829,6 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
                     setLastError(message.error);
                 }
                 else {
-                    console.log('[HyperLiquid WS] Subscription success:', message);
                     setLastError(null);
                 }
                 return;
@@ -2845,14 +2836,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:
@@ -2953,84 +2941,76 @@ const useAddress = () => {
     };
 };
 
-/**
- * Position side enum for calculations
- */
-exports.PositionSide = void 0;
+var PositionSide;
 (function (PositionSide) {
     PositionSide["LONG"] = "LONG";
     PositionSide["SHORT"] = "SHORT";
-})(exports.PositionSide || (exports.PositionSide = {}));
-/**
- * Aggregate position calculation utility class that handles cross-position asset syncing
- */
-class AggregatePositionCalculator {
+})(PositionSide || (PositionSide = {}));
+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: exports.PositionSide.LONG })),
-                ...position.shortAssets.map(asset => ({ ...asset, side: exports.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, {
@@ -3039,7 +3019,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,
@@ -3050,47 +3030,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: exports.PositionSide.LONG })),
-            ...position.shortAssets.map(asset => ({ ...asset, side: exports.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 === exports.PositionSide.LONG) {
-                longAssetStatuses.total++;
-                if (syncResult.actualSize === 0) {
-                    longAssetStatuses.closed++;
-                }
+            longAssetStatuses.total++;
+            if (syncResult.actualSize === 0) {
+                longAssetStatuses.closed++;
             }
-            else if (asset.side === exports.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;
             }
@@ -3098,17 +3075,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,
@@ -3116,27 +3103,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,
@@ -3144,46 +3127,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 === exports.PositionSide.LONG);
-        const shortSyncResults = syncResults.filter(result => result.side === exports.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),
@@ -3191,51 +3155,50 @@ 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 === exports.PositionSide.LONG);
-        const shortResults = syncResults.filter(result => result.side === exports.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;
         const longValue = longResults.reduce((sum, result) => {
-            return sum + (result.actualSize * result.asset.entryPrice);
+            return sum + (Number(result.asset.size || 0) * Number(result.asset.entryPrice || 0));
         }, 0);
         const shortValue = shortResults.reduce((sum, result) => {
-            return sum + (result.actualSize * result.asset.entryPrice);
+            return sum + (Number(result.asset.size || 0) * Number(result.asset.entryPrice || 0));
         }, 0);
         return shortValue > 0 ? longValue / shortValue : 0;
     }
-    /**
-     * Calculate mark ratio using actual sizes and current prices
-     */
     calculateMarkRatio(syncResults) {
-        const longResults = syncResults.filter(result => result.side === exports.PositionSide.LONG);
-        const shortResults = syncResults.filter(result => result.side === exports.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;
         const longValue = longResults.reduce((sum, result) => {
@@ -3248,33 +3211,25 @@ class AggregatePositionCalculator {
         }, 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);
     }
 }
@@ -3284,32 +3239,18 @@ class AggregatePositionCalculator {
  */
 const useCalculatedOpenPositions = (platformPositions, webData2, allMids) => {
     const calculatedPositions = require$$0.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;
 };
@@ -3328,19 +3269,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);
@@ -3367,12 +3300,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;
     }
     /**
@@ -3385,11 +3312,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;
     }
     /**
@@ -3413,35 +3335,17 @@ class AccountSummaryCalculator {
  */
 const useCalculatedAccountSummary = (platformAccountSummary, platformOpenOrders, webData2, agentWalletAddress, agentWalletStatus) => {
     const calculatedAccountSummary = require$$0.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;
@@ -3494,7 +3398,6 @@ const useAccountSummary = () => {
 };
 
 exports.AccountSummaryCalculator = AccountSummaryCalculator;
-exports.AggregatePositionCalculator = AggregatePositionCalculator;
 exports.PearHyperliquidClient = PearHyperliquidClient;
 exports.PearHyperliquidProvider = PearHyperliquidProvider;
 exports.PearMigrationSDK = PearMigrationSDK;