@pear-protocol/hyperliquid-sdk 0.0.7 → 0.0.8

package/dist/index.js

@@ -2962,9 +2962,9 @@ exports.PositionSide = void 0;
     PositionSide["SHORT"] = "SHORT";
 })(exports.PositionSide || (exports.PositionSide = {}));
 /**
- * Position calculation utility class
+ * Aggregate position calculation utility class that handles cross-position asset syncing
  */
-class PositionCalculator {
+class AggregatePositionCalculator {
     constructor(webData2, allMids) {
         this.webData2 = webData2;
         this.allMids = allMids;
@@ -2987,7 +2987,7 @@ class PositionCalculator {
         if (basePrice) {
             return Number(basePrice);
         }
-        console.warn(`[PositionCalculator] No market price found for coin: ${coin}`);
+        console.warn(`[AggregatePositionCalculator] No market price found for coin: ${coin}`);
         return 0;
     }
     /**
@@ -2999,19 +2999,16 @@ class PositionCalculator {
     }
     /**
      * 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();
-        return platformPositions.map(position => this.syncPositionWithHyperliquid(position, hyperliquidPositions));
-    }
-    /**
-     * Sync a single position with HyperLiquid data
-     */
-    syncPositionWithHyperliquid(position, hyperliquidPositions) {
-        // Create a map of HyperLiquid positions by coin for quick lookup
+        // 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;
@@ -3019,112 +3016,159 @@ class PositionCalculator {
                 hlPositionsMap.set(assetPos.position.coin, assetPos);
             }
         });
-        // Combine all assets for processing
-        const allAssets = [
-            ...position.longAssets.map(asset => ({ ...asset, side: exports.PositionSide.LONG })),
-            ...position.shortAssets.map(asset => ({ ...asset, side: exports.PositionSide.SHORT }))
-        ];
-        // Group assets by base currency for multi-pair position handling
-        const assetsByBaseCurrency = this.groupAssetsByBaseCurrency(allAssets);
-        // Sync each asset group with HyperLiquid data
-        const syncResults = [];
-        for (const [baseCurrency, assets] of assetsByBaseCurrency.entries()) {
-            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);
+        // Process each position with awareness of the aggregated totals
+        return platformPositions.map(position => this.syncPositionWithAggregateData(position, hlPositionsMap, platformTotalsByAsset));
     }
     /**
-     * Group assets by their base currency
+     * Calculate total platform sizes per asset across all positions
      */
-    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, []);
+    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) {
+                const baseCurrency = this.extractBaseCurrency(asset.coin);
+                if (!totalsMap.has(baseCurrency)) {
+                    totalsMap.set(baseCurrency, {
+                        totalSize: 0,
+                        positions: []
+                    });
+                }
+                const totals = totalsMap.get(baseCurrency);
+                const assetSize = asset.platformSize;
+                totals.totalSize += assetSize;
+                totals.positions.push({
+                    positionId: position.positionId,
+                    asset: asset,
+                    size: assetSize
+                });
             }
-            grouped.get(baseCurrency).push(asset);
         }
-        return grouped;
+        return totalsMap;
     }
     /**
-     * Sync a group of assets (same base currency) with HyperLiquid position data
+     * Extract base currency from asset name (handles "LINK/USD" -> "LINK")
      */
-    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
-                    };
+    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) {
+            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);
+            syncResults.push(syncResult);
+            // Track status by side
+            if (asset.side === exports.PositionSide.LONG) {
+                longAssetStatuses.total++;
+                if (syncResult.actualSize === 0) {
+                    longAssetStatuses.closed++;
                 }
-                unrealizedPnl = Number(hlPosition.position.unrealizedPnl || 0) * sizeRatio;
-                liquidationPrice = Number(hlPosition.position.liquidationPx || 0);
             }
-            else {
-                // Position doesn't exist on HyperLiquid - it was closed externally
-                actualSize = 0;
-                isExternallyModified = true;
+            else if (asset.side === exports.PositionSide.SHORT) {
+                shortAssetStatuses.total++;
+                if (syncResult.actualSize === 0) {
+                    shortAssetStatuses.closed++;
+                }
             }
-            results.push({
+            // Update flags
+            if (syncResult.isExternallyModified) {
+                hasExternalModification = true;
+            }
+            if (syncResult.actualSize !== 0) {
+                allAssetsClosed = false;
+            }
+        }
+        // Determine sync status
+        const syncStatus = this.determineSyncStatus(hasExternalModification, allAssetsClosed, longAssetStatuses, shortAssetStatuses);
+        return this.buildUpdatedPosition(position, syncResults, syncStatus);
+    }
+    /**
+     * 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
+        if (!hlPosition || !hlPosition.position || !hlPosition.position.szi) {
+            return {
                 asset,
-                actualSize,
-                isExternallyModified,
-                cumFunding,
-                unrealizedPnl,
-                liquidationPrice,
+                actualSize: 0,
+                isExternallyModified: true,
+                cumFunding: { allTime: 0, sinceChange: 0, sinceOpen: 0 },
+                unrealizedPnl: 0,
+                liquidationPrice: 0,
                 side: asset.side
-            });
+            };
         }
-        return results;
+        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 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
+        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
+        };
+        // 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,
+            actualSize,
+            isExternallyModified,
+            cumFunding,
+            unrealizedPnl,
+            liquidationPrice,
+            side: asset.side
+        };
     }
     /**
-     * Determine sync status based on asset sync results
+     * Determine sync status with sophisticated side-aware logic
      */
-    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) {
+        // All assets closed externally
         if (allAssetsClosed) {
             return 'EXTERNALLY_CLOSED';
         }
-        else if (someAssetsClosed) {
+        // 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';
         }
-        else if (hasExternalModifications) {
+        // External modification detected
+        if (hasExternalModification) {
             return 'EXTERNALLY_MODIFIED';
         }
+        // Everything synced properly
         return 'SYNCED';
     }
     /**
@@ -3171,65 +3215,38 @@ class PositionCalculator {
         };
     }
     /**
-     * Calculate entry ratio (weighted long entry value / weighted short entry value)
+     * 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);
         if (longResults.length === 0 || shortResults.length === 0)
             return 0;
-        // Calculate total position value at entry prices
-        const totalPositionValue = syncResults.reduce((sum, result) => {
+        const longValue = longResults.reduce((sum, result) => {
             return sum + (result.actualSize * result.asset.entryPrice);
         }, 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 + (result.actualSize * result.asset.entryPrice);
         }, 0);
-        return weightedShortValue > 0 ? weightedLongValue / weightedShortValue : 0;
+        return shortValue > 0 ? longValue / shortValue : 0;
     }
     /**
-     * Calculate mark ratio (weighted long mark value / weighted short mark value)
+     * 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);
         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 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);
-        }, 0);
-        // Calculate weighted short portfolio value
-        const weightedShortValue = 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
@@ -3286,7 +3303,7 @@ const useCalculatedOpenPositions = (platformPositions, webData2, allMids) => {
             availableMids: Object.keys(allMids.mids || {}).length
         });
         // Create calculator and compute positions
-        const calculator = new PositionCalculator(webData2, allMids);
+        const calculator = new AggregatePositionCalculator(webData2, allMids);
         const calculated = calculator.calculateOpenPositions(platformPositions);
         console.log('[useCalculatedOpenPositions] Calculation completed', {
             inputCount: platformPositions.length,
@@ -3477,10 +3494,10 @@ const useAccountSummary = () => {
 };
 
 exports.AccountSummaryCalculator = AccountSummaryCalculator;
+exports.AggregatePositionCalculator = AggregatePositionCalculator;
 exports.PearHyperliquidClient = PearHyperliquidClient;
 exports.PearHyperliquidProvider = PearHyperliquidProvider;
 exports.PearMigrationSDK = PearMigrationSDK;
-exports.PositionCalculator = PositionCalculator;
 exports.default = PearHyperliquidClient;
 exports.useAccountSummary = useAccountSummary;
 exports.useAddress = useAddress;