@pear-protocol/hyperliquid-sdk 0.0.4 → 0.0.7

package/dist/index.esm.js

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import require$$0, { createContext, useMemo, useState, useEffect, useContext } from 'react';
+import require$$0, { useState, useEffect, useRef, createContext, useMemo, useContext } from 'react';
 import require$$1 from 'react-dom';
 
 /**
@@ -2629,15 +2629,7 @@ useEventSource$1.useEventSource = useEventSource;
 
 var useWebSocket = /*@__PURE__*/getDefaultExportFromCjs(dist);
 
-const PearHyperliquidContext = createContext(undefined);
-/**
- * React Provider for PearHyperliquidClient
- */
-const PearHyperliquidProvider = ({ config, wsUrl = 'wss://hl-v2.pearprotocol.io/ws', children, }) => {
-    const client = useMemo(() => new PearHyperliquidClient(config), [config]);
-    const migrationSDK = useMemo(() => new PearMigrationSDK(client), [client]);
-    // Address state
-    const [address, setAddress] = useState(null);
+const useHyperliquidWebSocket = ({ wsUrl, address }) => {
     // WebSocket data state
     const [data, setData] = useState({
         tradeHistories: null,
@@ -2732,6 +2724,171 @@ const PearHyperliquidProvider = ({ config, wsUrl = 'wss://hl-v2.pearprotocol.io/
             });
         }
     }, [isConnected, address, sendMessage]);
+    return {
+        data,
+        connectionStatus: readyState,
+        isConnected,
+        lastError,
+    };
+};
+
+const useHyperliquidNativeWebSocket = ({ address }) => {
+    const [webData2, setWebData2] = useState(null);
+    const [allMids, setAllMids] = useState(null);
+    const [lastError, setLastError] = useState(null);
+    const [subscribedAddress, setSubscribedAddress] = useState(null);
+    const pingIntervalRef = useRef(null);
+    // WebSocket connection to HyperLiquid native API
+    const { lastMessage, readyState, sendJsonMessage } = useWebSocket('wss://api.hyperliquid.xyz/ws', {
+        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'),
+        onError: (event) => console.error('[HyperLiquid WS] Connection error:', event),
+        onReconnectStop: () => console.error('[HyperLiquid WS] Reconnection stopped after 5 attempts'),
+    });
+    const isConnected = readyState === dist.ReadyState.OPEN;
+    // Setup ping mechanism
+    useEffect(() => {
+        if (isConnected) {
+            console.log('[HyperLiquid WS] Setting up ping mechanism (30s interval)');
+            // Send ping every 30 seconds
+            pingIntervalRef.current = setInterval(() => {
+                console.log('[HyperLiquid WS] Sending ping');
+                sendJsonMessage({ method: 'ping' });
+            }, 30000);
+        }
+        else {
+            if (pingIntervalRef.current) {
+                console.log('[HyperLiquid WS] Clearing ping interval');
+                clearInterval(pingIntervalRef.current);
+                pingIntervalRef.current = null;
+            }
+        }
+        return () => {
+            if (pingIntervalRef.current) {
+                clearInterval(pingIntervalRef.current);
+                pingIntervalRef.current = null;
+            }
+        };
+    }, [isConnected, sendJsonMessage]);
+    // Handle address subscription changes
+    useEffect(() => {
+        if (!isConnected)
+            return;
+        const DEFAULT_ADDRESS = '0x0000000000000000000000000000000000000000';
+        const userAddress = address || DEFAULT_ADDRESS;
+        if (subscribedAddress === userAddress)
+            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: {
+                    type: 'webData2',
+                    user: subscribedAddress,
+                },
+            };
+            sendJsonMessage(unsubscribeMessage);
+        }
+        // Subscribe to webData2 with new address
+        console.log(`[HyperLiquid WS] Subscribing to webData2 for address: ${userAddress}`);
+        const subscribeWebData2 = {
+            method: 'subscribe',
+            subscription: {
+                type: 'webData2',
+                user: userAddress,
+            },
+        };
+        // Subscribe to allMids
+        console.log('[HyperLiquid WS] Subscribing to allMids');
+        const subscribeAllMids = {
+            method: 'subscribe',
+            subscription: {
+                type: 'allMids',
+            },
+        };
+        sendJsonMessage(subscribeWebData2);
+        sendJsonMessage(subscribeAllMids);
+        setSubscribedAddress(userAddress);
+        // Clear previous data when address changes
+        if (subscribedAddress && subscribedAddress !== userAddress) {
+            console.log('[HyperLiquid WS] Address changed, clearing previous webData2');
+            setWebData2(null);
+        }
+    }, [isConnected, address, subscribedAddress, sendJsonMessage]);
+    // Handle incoming WebSocket messages
+    useEffect(() => {
+        if (!lastMessage)
+            return;
+        try {
+            const message = JSON.parse(lastMessage.data);
+            console.log('[HyperLiquid WS] Received message:', message);
+            // Handle subscription responses
+            if ('success' in message || 'error' in message) {
+                if (message.error) {
+                    console.error('[HyperLiquid WS] Subscription error:', message.error);
+                    setLastError(message.error);
+                }
+                else {
+                    console.log('[HyperLiquid WS] Subscription success:', message);
+                    setLastError(null);
+                }
+                return;
+            }
+            // Handle channel data messages
+            if ('channel' in message && 'data' in message) {
+                const response = message;
+                console.log(`[HyperLiquid WS] Received ${response.channel} data`);
+                switch (response.channel) {
+                    case 'webData2':
+                        console.log('[HyperLiquid WS] Setting webData2:', response.data);
+                        setWebData2(response.data);
+                        break;
+                    case 'allMids':
+                        console.log('[HyperLiquid WS] Setting allMids:', response.data);
+                        setAllMids(response.data);
+                        break;
+                    default:
+                        console.warn(`[HyperLiquid WS] Unknown channel: ${response.channel}`);
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = `Failed to parse message: ${error instanceof Error ? error.message : String(error)}`;
+            console.error('[HyperLiquid WS] Parse error:', errorMessage, 'Raw message:', lastMessage.data);
+            setLastError(errorMessage);
+        }
+    }, [lastMessage]);
+    return {
+        webData2,
+        allMids,
+        connectionStatus: readyState,
+        isConnected,
+        lastError,
+    };
+};
+
+const PearHyperliquidContext = createContext(undefined);
+/**
+ * React Provider for PearHyperliquidClient
+ */
+const PearHyperliquidProvider = ({ config, wsUrl = 'wss://hl-v2.pearprotocol.io/ws', children, }) => {
+    const client = useMemo(() => new PearHyperliquidClient(config), [config]);
+    const migrationSDK = useMemo(() => new PearMigrationSDK(client), [client]);
+    // Address state
+    const [address, setAddress] = useState(null);
+    // WebSocket connection and data (Pear API)
+    const { data, connectionStatus, isConnected, lastError } = useHyperliquidWebSocket({
+        wsUrl,
+        address,
+    });
+    // HyperLiquid native WebSocket connection
+    const { webData2, allMids, connectionStatus: nativeConnectionStatus, isConnected: nativeIsConnected, lastError: nativeLastError } = useHyperliquidNativeWebSocket({
+        address,
+    });
     const contextValue = useMemo(() => ({
         // Existing clients
         client,
@@ -2739,13 +2896,20 @@ const PearHyperliquidProvider = ({ config, wsUrl = 'wss://hl-v2.pearprotocol.io/
         // Address management
         address,
         setAddress,
-        // WebSocket state
-        connectionStatus: readyState,
+        // WebSocket state (Pear API)
+        connectionStatus,
         isConnected,
-        // WebSocket data
+        // WebSocket data (Pear API)
         data,
         lastError,
-    }), [client, migrationSDK, address, readyState, isConnected, data, lastError]);
+        // HyperLiquid native WebSocket state
+        nativeConnectionStatus,
+        nativeIsConnected,
+        nativeLastError,
+        // HyperLiquid native WebSocket data
+        webData2,
+        allMids,
+    }), [client, migrationSDK, address, connectionStatus, isConnected, data, lastError, nativeConnectionStatus, nativeIsConnected, nativeLastError, webData2, allMids]);
     return (jsxRuntimeExports.jsx(PearHyperliquidContext.Provider, { value: contextValue, children: children }));
 };
 /**
@@ -2785,6 +2949,483 @@ 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 {
+    constructor(webData2, allMids) {
+        this.webData2 = webData2;
+        this.allMids = allMids;
+    }
+    /**
+     * Get market price for a coin from allMids data
+     */
+    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 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 [];
+        }
+        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
+        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
+        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);
+    }
+    /**
+     * 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, []);
+            }
+            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);
+            }
+            else {
+                // Position doesn't exist on HyperLiquid - it was closed externally
+                actualSize = 0;
+                isExternallyModified = true;
+            }
+            results.push({
+                asset,
+                actualSize,
+                isExternallyModified,
+                cumFunding,
+                unrealizedPnl,
+                liquidationPrice,
+                side: asset.side
+            });
+        }
+        return results;
+    }
+    /**
+     * 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;
+        if (allAssetsClosed) {
+            return 'EXTERNALLY_CLOSED';
+        }
+        else if (someAssetsClosed) {
+            return 'PAIR_BROKEN';
+        }
+        else if (hasExternalModifications) {
+            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
+        const currentTotalPositionValue = this.calculateCurrentTotalPositionValue(syncResults);
+        const entryTotalPositionValue = this.calculateEntryTotalPositionValue(syncResults);
+        const totalMarginUsed = entryTotalPositionValue / originalPosition.leverage;
+        return {
+            ...originalPosition,
+            syncStatus,
+            entryRatio: this.calculateEntryRatio(syncResults),
+            markRatio: this.calculateMarkRatio(syncResults),
+            netFunding: this.calculateNetFundingFromSyncResults(syncResults),
+            positionValue: currentTotalPositionValue,
+            marginUsed: totalMarginUsed,
+            unrealizedPnl: this.calculateTotalUnrealizedPnlFromSyncResults(syncResults),
+            lastSyncAt: new Date().toISOString(),
+            longAssets: longSyncResults.map(result => this.mapSyncResultToAssetDto(result)),
+            shortAssets: shortSyncResults.map(result => this.mapSyncResultToAssetDto(result)),
+            updatedAt: new Date().toISOString()
+        };
+    }
+    /**
+     * 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;
+        return {
+            ...syncResult.asset,
+            actualSize: syncResult.actualSize,
+            isExternallyModified: syncResult.isExternallyModified,
+            cumFunding: syncResult.cumFunding,
+            marginUsed: entryValue,
+            positionValue: positionValue,
+            unrealizedPnl: syncResult.unrealizedPnl,
+            liquidationPrice: syncResult.liquidationPrice
+        };
+    }
+    /**
+     * 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);
+        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);
+        }, 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);
+        }, 0);
+        return weightedShortValue > 0 ? weightedLongValue / weightedShortValue : 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);
+        if (longResults.length === 0 || shortResults.length === 0)
+            return 0;
+        // Calculate total position value at current market prices
+        const totalPositionValue = syncResults.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 currentPrice = this.getMarketPrice(result.asset.coin);
+            const assetValue = result.actualSize * currentPrice;
+            const weight = assetValue / totalPositionValue;
+            return sum + (currentPrice * weight);
+        }, 0);
+        return weightedShortValue > 0 ? weightedLongValue / weightedShortValue : 0;
+    }
+    /**
+     * Calculate net funding from sync results
+     */
+    calculateNetFundingFromSyncResults(syncResults) {
+        return syncResults.reduce((sum, result) => sum + result.cumFunding.sinceOpen, 0);
+    }
+    /**
+     * 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);
+        }, 0);
+    }
+}
+
+/**
+ * Hook that calculates open positions by syncing platform positions with HyperLiquid real-time data
+ */
+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 (!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;
+    }, [platformPositions, webData2, allMids]);
+    return calculatedPositions;
+};
+
+/**
+ * Account summary calculation utility class
+ */
+class AccountSummaryCalculator {
+    constructor(webData2) {
+        this.webData2 = webData2;
+    }
+    /**
+     * Calculate account summary from webData2 and platform orders
+     */
+    calculateAccountSummary(platformAccountSummary, platformOpenOrders, agentWalletAddress, agentWalletStatus) {
+        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);
+        const accountSummary = {
+            balanceSummary: {
+                crossMaintenanceMarginUsed: clearinghouseState.crossMaintenanceMarginUsed || '0',
+                crossMarginSummary: {
+                    accountValue: ((_b = clearinghouseState.crossMarginSummary) === null || _b === void 0 ? void 0 : _b.accountValue) || '0',
+                    totalMarginUsed: ((_c = clearinghouseState.crossMarginSummary) === null || _c === void 0 ? void 0 : _c.totalMarginUsed) || '0',
+                    totalNtlPos: ((_d = clearinghouseState.crossMarginSummary) === null || _d === void 0 ? void 0 : _d.totalNtlPos) || '0',
+                    totalRawUsd: ((_e = clearinghouseState.crossMarginSummary) === null || _e === void 0 ? void 0 : _e.totalRawUsd) || '0'
+                },
+                marginSummary: {
+                    accountValue: ((_f = clearinghouseState.marginSummary) === null || _f === void 0 ? void 0 : _f.accountValue) || '0',
+                    totalMarginUsed: ((_g = clearinghouseState.marginSummary) === null || _g === void 0 ? void 0 : _g.totalMarginUsed) || '0',
+                    totalNtlPos: ((_h = clearinghouseState.marginSummary) === null || _h === void 0 ? void 0 : _h.totalNtlPos) || '0',
+                    totalRawUsd: ((_j = clearinghouseState.marginSummary) === null || _j === void 0 ? void 0 : _j.totalRawUsd) || '0'
+                },
+                time: clearinghouseState.time || Date.now(),
+                withdrawable: adjustedWithdrawable.toString()
+            },
+            agentWallet: {
+                address: agentWalletAddress || ((_k = platformAccountSummary === null || platformAccountSummary === void 0 ? void 0 : platformAccountSummary.agentWallet) === null || _k === void 0 ? void 0 : _k.address) || '',
+                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;
+    }
+    /**
+     * Calculate total USD value of open limit orders
+     */
+    calculateTotalLimitOrderValue(openOrders) {
+        if (!(openOrders === null || openOrders === void 0 ? void 0 : openOrders.length)) {
+            return 0;
+        }
+        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;
+    }
+    /**
+     * Get real-time clearinghouse state from webData2
+     */
+    getClearinghouseState() {
+        var _a;
+        return ((_a = this.webData2) === null || _a === void 0 ? void 0 : _a.clearinghouseState) || null;
+    }
+    /**
+     * Check if real-time data is available
+     */
+    hasRealTimeData() {
+        var _a;
+        return !!((_a = this.webData2) === null || _a === void 0 ? void 0 : _a.clearinghouseState);
+    }
+}
+
+/**
+ * Hook that calculates account summary by syncing platform data with HyperLiquid real-time data
+ */
+const useCalculatedAccountSummary = (platformAccountSummary, platformOpenOrders, webData2, agentWalletAddress, agentWalletStatus) => {
+    const calculatedAccountSummary = useMemo(() => {
+        var _a, _b, _c;
+        // Return null if we don't have platform account summary yet
+        if (!platformAccountSummary) {
+            console.log('[useCalculatedAccountSummary] No platform account summary available');
+            return null;
+        }
+        // If we don't have real-time data yet, return platform summary as-is
+        if (!(webData2 === null || webData2 === void 0 ? void 0 : webData2.clearinghouseState)) {
+            console.log('[useCalculatedAccountSummary] Missing webData2 clearinghouseState, returning platform summary');
+            return platformAccountSummary;
+        }
+        console.log('[useCalculatedAccountSummary] Calculating account summary with real-time data', {
+            hasPlatformSummary: !!platformAccountSummary,
+            hasWebData2: !!webData2,
+            hasClearinghouseState: !!webData2.clearinghouseState,
+            hasOpenOrders: !!platformOpenOrders,
+            openOrdersCount: (platformOpenOrders === null || platformOpenOrders === void 0 ? void 0 : platformOpenOrders.length) || 0,
+            agentWalletAddress,
+            agentWalletStatus
+        });
+        // Create calculator and compute account summary
+        const calculator = new AccountSummaryCalculator(webData2);
+        const calculated = calculator.calculateAccountSummary(platformAccountSummary, platformOpenOrders, agentWalletAddress, agentWalletStatus);
+        console.log('[useCalculatedAccountSummary] Calculation completed', {
+            hadPlatformSummary: !!platformAccountSummary,
+            calculatedSummary: !!calculated,
+            withdrawable: (_a = calculated === null || calculated === void 0 ? void 0 : calculated.balanceSummary) === null || _a === void 0 ? void 0 : _a.withdrawable,
+            accountValue: (_c = (_b = calculated === null || calculated === void 0 ? void 0 : calculated.balanceSummary) === null || _b === void 0 ? void 0 : _b.crossMarginSummary) === null || _c === void 0 ? void 0 : _c.accountValue
+        });
+        return calculated;
+    }, [platformAccountSummary, platformOpenOrders, webData2, agentWalletAddress, agentWalletStatus]);
+    return calculatedAccountSummary;
+};
+
 /**
  * Hook to access trade histories
  */
@@ -2796,14 +3437,16 @@ const useTradeHistories = () => {
     return context.data.tradeHistories;
 };
 /**
- * Hook to access open positions
+ * Hook to access open positions with real-time calculations
  */
 const useOpenPositions = () => {
     const context = useContext(PearHyperliquidContext);
     if (!context) {
         throw new Error('useOpenPositions must be used within a PearHyperliquidProvider');
     }
-    return context.data.openPositions;
+    // Use calculated positions that sync platform data with HyperLiquid real-time data
+    const calculatedPositions = useCalculatedOpenPositions(context.data.openPositions, context.webData2, context.allMids);
+    return calculatedPositions;
 };
 /**
  * Hook to access open orders
@@ -2816,15 +3459,18 @@ const useOpenOrders = () => {
     return context.data.openOrders;
 };
 /**
- * Hook to access account summary
+ * Hook to access account summary with real-time calculations
  */
 const useAccountSummary = () => {
+    var _a, _b, _c, _d;
     const context = useContext(PearHyperliquidContext);
     if (!context) {
         throw new Error('useAccountSummary must be used within a PearHyperliquidProvider');
     }
-    return context.data.accountSummary;
+    // Use calculated account summary that syncs platform data with HyperLiquid real-time data
+    const calculatedAccountSummary = useCalculatedAccountSummary(context.data.accountSummary, context.data.openOrders, context.webData2, (_b = (_a = context.data.accountSummary) === null || _a === void 0 ? void 0 : _a.agentWallet) === null || _b === void 0 ? void 0 : _b.address, (_d = (_c = context.data.accountSummary) === null || _c === void 0 ? void 0 : _c.agentWallet) === null || _d === void 0 ? void 0 : _d.status);
+    return calculatedAccountSummary;
 };
 
-export { PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, PearHyperliquidClient as default, useAccountSummary, useAddress, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTradeHistories };
+export { AccountSummaryCalculator, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, PositionCalculator, PositionSide, PearHyperliquidClient as default, useAccountSummary, useAddress, useCalculatedAccountSummary, useCalculatedOpenPositions, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTradeHistories };
 //# sourceMappingURL=index.esm.js.map