@pear-protocol/hyperliquid-sdk 0.0.9 → 0.0.11

package/dist/index.esm.js

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import require$$0, { useState, useEffect, useRef, createContext, useMemo, useContext } from 'react';
+import require$$0, { useState, useEffect, useRef, createContext, useMemo, useContext, useCallback } from 'react';
 import require$$1 from 'react-dom';
 
 /**
@@ -2638,21 +2638,17 @@ const useHyperliquidWebSocket = ({ wsUrl, address }) => {
         accountSummary: null,
     });
     const [lastError, setLastError] = useState(null);
+    const [lastSubscribedAddress, setLastSubscribedAddress] = useState(null);
     // WebSocket connection
-    const { lastMessage, readyState, sendMessage } = useWebSocket(address ? wsUrl : null, // Only connect when address is set
-    {
+    const { readyState, sendMessage } = useWebSocket(wsUrl, {
         shouldReconnect: () => true,
         reconnectAttempts: 5,
         reconnectInterval: 3000,
-    });
-    const isConnected = readyState === dist.ReadyState.OPEN;
-    // Handle incoming WebSocket messages
-    useEffect(() => {
-        if (lastMessage !== null) {
+        onMessage: (event) => {
             try {
-                const message = JSON.parse(lastMessage.data);
-                // Handle subscription responses
-                if ('success' in message || 'error' in message) {
+                const message = JSON.parse(event.data);
+                // Handle subscription responses (only if they don't have channel data)
+                if (('success' in message || 'error' in message) && !('channel' in message)) {
                     if (message.error) {
                         setLastError(message.error);
                     }
@@ -2664,30 +2660,42 @@ const useHyperliquidWebSocket = ({ wsUrl, address }) => {
                 // Handle channel data messages
                 if ('channel' in message && 'data' in message) {
                     const dataMessage = message;
+                    // Validate data exists and is not null/undefined
+                    if (dataMessage.data === null || dataMessage.data === undefined) {
+                        return;
+                    }
                     switch (dataMessage.channel) {
                         case 'trade-histories':
-                            setData(prev => ({
-                                ...prev,
-                                tradeHistories: dataMessage.data
-                            }));
+                            if (Array.isArray(dataMessage.data)) {
+                                setData(prev => ({
+                                    ...prev,
+                                    tradeHistories: dataMessage.data
+                                }));
+                            }
                             break;
                         case 'open-positions':
-                            setData(prev => ({
-                                ...prev,
-                                openPositions: dataMessage.data
-                            }));
+                            if (Array.isArray(dataMessage.data)) {
+                                setData(prev => ({
+                                    ...prev,
+                                    openPositions: dataMessage.data
+                                }));
+                            }
                             break;
                         case 'open-orders':
-                            setData(prev => ({
-                                ...prev,
-                                openOrders: dataMessage.data
-                            }));
+                            if (Array.isArray(dataMessage.data)) {
+                                setData(prev => ({
+                                    ...prev,
+                                    openOrders: dataMessage.data
+                                }));
+                            }
                             break;
                         case 'account-summary':
-                            setData(prev => ({
-                                ...prev,
-                                accountSummary: dataMessage.data
-                            }));
+                            if (typeof dataMessage.data === 'object' && dataMessage.data !== null) {
+                                setData(prev => ({
+                                    ...prev,
+                                    accountSummary: dataMessage.data
+                                }));
+                            }
                             break;
                     }
                 }
@@ -2696,34 +2704,47 @@ const useHyperliquidWebSocket = ({ wsUrl, address }) => {
                 setLastError(`Failed to parse message: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-    }, [lastMessage]);
-    // Handle address changes - subscribe/unsubscribe
+    });
+    const isConnected = readyState === dist.ReadyState.OPEN;
+    // Handle subscription management
     useEffect(() => {
-        if (isConnected && address) {
+        if (isConnected && address && address !== lastSubscribedAddress) {
+            // Unsubscribe from previous address if exists
+            if (lastSubscribedAddress) {
+                sendMessage(JSON.stringify({
+                    action: 'unsubscribe',
+                    address: lastSubscribedAddress
+                }));
+            }
             // Subscribe to new address
             sendMessage(JSON.stringify({
                 action: 'subscribe',
                 address: address
             }));
-            // Clear previous data
-            setData({
-                tradeHistories: null,
-                openPositions: null,
-                openOrders: null,
-                accountSummary: null,
-            });
+            setLastSubscribedAddress(address);
             setLastError(null);
         }
-        else if (isConnected && !address) {
-            // Clear data when address is removed
+        else if (isConnected && !address && lastSubscribedAddress) {
+            // Send unsubscribe action when address is removed
+            sendMessage(JSON.stringify({
+                action: 'unsubscribe',
+                address: lastSubscribedAddress
+            }));
+            setLastSubscribedAddress(null);
+        }
+    }, [isConnected, address, lastSubscribedAddress, sendMessage]);
+    // Clear data when address changes
+    useEffect(() => {
+        if (address !== lastSubscribedAddress) {
             setData({
                 tradeHistories: null,
                 openPositions: null,
                 openOrders: null,
                 accountSummary: null,
             });
+            setLastError(null);
         }
-    }, [isConnected, address, sendMessage]);
+    }, [address, lastSubscribedAddress]);
     return {
         data,
         connectionStatus: readyState,
@@ -2739,7 +2760,7 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
     const [subscribedAddress, setSubscribedAddress] = useState(null);
     const pingIntervalRef = useRef(null);
     // WebSocket connection to HyperLiquid native API
-    const { lastMessage, readyState, sendJsonMessage } = useWebSocket('wss://api.hyperliquid.xyz/ws', {
+    const { readyState, sendJsonMessage } = useWebSocket('wss://api.hyperliquid.xyz/ws', {
         shouldReconnect: () => true,
         reconnectAttempts: 5,
         reconnectInterval: 3000,
@@ -2747,6 +2768,41 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
         onClose: () => { },
         onError: (event) => console.error('[HyperLiquid WS] Connection error:', event),
         onReconnectStop: () => console.error('[HyperLiquid WS] Reconnection stopped after 5 attempts'),
+        onMessage: (event) => {
+            try {
+                const message = JSON.parse(event.data);
+                // Handle subscription responses
+                if ('success' in message || 'error' in message) {
+                    if (message.error) {
+                        console.error('[HyperLiquid WS] Subscription error:', message.error);
+                        setLastError(message.error);
+                    }
+                    else {
+                        setLastError(null);
+                    }
+                    return;
+                }
+                // Handle channel data messages
+                if ('channel' in message && 'data' in message) {
+                    const response = message;
+                    switch (response.channel) {
+                        case 'webData2':
+                            setWebData2(response.data);
+                            break;
+                        case 'allMids':
+                            setAllMids(response.data);
+                            break;
+                        default:
+                            console.warn(`[HyperLiquid WS] Unknown channel: ${response.channel}`);
+                    }
+                }
+            }
+            catch (error) {
+                const errorMessage = `Failed to parse message: ${error instanceof Error ? error.message : String(error)}`;
+                console.error('[HyperLiquid WS] Parse error:', errorMessage, 'Raw message:', event.data);
+                setLastError(errorMessage);
+            }
+        }
     });
     const isConnected = readyState === dist.ReadyState.OPEN;
     // Setup ping mechanism
@@ -2812,44 +2868,6 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
             setWebData2(null);
         }
     }, [isConnected, address, subscribedAddress, sendJsonMessage]);
-    // Handle incoming WebSocket messages
-    useEffect(() => {
-        if (!lastMessage)
-            return;
-        try {
-            const message = JSON.parse(lastMessage.data);
-            // Handle subscription responses
-            if ('success' in message || 'error' in message) {
-                if (message.error) {
-                    console.error('[HyperLiquid WS] Subscription error:', message.error);
-                    setLastError(message.error);
-                }
-                else {
-                    setLastError(null);
-                }
-                return;
-            }
-            // Handle channel data messages
-            if ('channel' in message && 'data' in message) {
-                const response = message;
-                switch (response.channel) {
-                    case 'webData2':
-                        setWebData2(response.data);
-                        break;
-                    case 'allMids':
-                        setAllMids(response.data);
-                        break;
-                    default:
-                        console.warn(`[HyperLiquid WS] Unknown channel: ${response.channel}`);
-                }
-            }
-        }
-        catch (error) {
-            const errorMessage = `Failed to parse message: ${error instanceof Error ? error.message : String(error)}`;
-            console.error('[HyperLiquid WS] Parse error:', errorMessage, 'Raw message:', lastMessage.data);
-            setLastError(errorMessage);
-        }
-    }, [lastMessage]);
     return {
         webData2,
         allMids,
@@ -2859,6 +2877,23 @@ const useHyperliquidNativeWebSocket = ({ address }) => {
     };
 };
 
+const DEFAULT_TOKEN_SELECTION_STATE = {
+    longTokens: [
+        { symbol: 'HYPE', weight: 25 },
+        { symbol: 'BTC', weight: 25 }
+    ],
+    shortTokens: [
+        { symbol: 'AVAX', weight: 10 },
+        { symbol: 'SEI', weight: 10 },
+        { symbol: 'ADA', weight: 10 },
+        { symbol: 'TRUMP', weight: 10 },
+        { symbol: 'SUI', weight: 10 }
+    ],
+    openTokenSelector: false,
+    selectorConfig: null,
+    openConflictModal: false,
+    conflicts: [],
+};
 const PearHyperliquidContext = createContext(undefined);
 /**
  * React Provider for PearHyperliquidClient
@@ -2868,6 +2903,8 @@ const PearHyperliquidProvider = ({ config, wsUrl = 'wss://hl-v2.pearprotocol.io/
     const migrationSDK = useMemo(() => new PearMigrationSDK(client), [client]);
     // Address state
     const [address, setAddress] = useState(null);
+    // Token selection state
+    const [tokenSelection, setTokenSelection] = useState(DEFAULT_TOKEN_SELECTION_STATE);
     // WebSocket connection and data (Pear API)
     const { data, connectionStatus, isConnected, lastError } = useHyperliquidWebSocket({
         wsUrl,
@@ -2897,7 +2934,10 @@ const PearHyperliquidProvider = ({ config, wsUrl = 'wss://hl-v2.pearprotocol.io/
         // HyperLiquid native WebSocket data
         webData2,
         allMids,
-    }), [client, migrationSDK, address, connectionStatus, isConnected, data, lastError, nativeConnectionStatus, nativeIsConnected, nativeLastError, webData2, allMids]);
+        // Token selection state
+        tokenSelection,
+        setTokenSelection,
+    }), [client, migrationSDK, address, connectionStatus, isConnected, data, lastError, nativeConnectionStatus, nativeIsConnected, nativeLastError, webData2, allMids, tokenSelection, setTokenSelection]);
     return (jsxRuntimeExports.jsx(PearHyperliquidContext.Provider, { value: contextValue, children: children }));
 };
 /**
@@ -3180,32 +3220,24 @@ class PositionProcessor {
         };
     }
     calculateEntryRatio(syncResults) {
+        var _a, _b;
         const longResults = syncResults.filter(result => result.asset.side === PositionSide.LONG);
         const shortResults = syncResults.filter(result => result.asset.side === PositionSide.SHORT);
         if (longResults.length === 0 || shortResults.length === 0)
             return 0;
-        const longValue = longResults.reduce((sum, result) => {
-            return sum + (Number(result.asset.size || 0) * Number(result.asset.entryPrice || 0));
-        }, 0);
-        const shortValue = shortResults.reduce((sum, result) => {
-            return sum + (Number(result.asset.size || 0) * Number(result.asset.entryPrice || 0));
-        }, 0);
-        return shortValue > 0 ? longValue / shortValue : 0;
+        const longEntryPrice = ((_a = longResults[0]) === null || _a === void 0 ? void 0 : _a.asset.entryPrice) ? Number(longResults[0].asset.entryPrice) : 0;
+        const shortEntryPrice = ((_b = shortResults[0]) === null || _b === void 0 ? void 0 : _b.asset.entryPrice) ? Number(shortResults[0].asset.entryPrice) : 0;
+        return shortEntryPrice > 0 ? longEntryPrice / shortEntryPrice : 0;
     }
     calculateMarkRatio(syncResults) {
+        var _a, _b;
         const longResults = syncResults.filter(result => result.asset.side === PositionSide.LONG);
         const shortResults = syncResults.filter(result => result.asset.side === PositionSide.SHORT);
         if (longResults.length === 0 || shortResults.length === 0)
             return 0;
-        const longValue = longResults.reduce((sum, result) => {
-            const currentPrice = this.getMarketPrice(result.asset.coin);
-            return sum + (result.actualSize * currentPrice);
-        }, 0);
-        const shortValue = shortResults.reduce((sum, result) => {
-            const currentPrice = this.getMarketPrice(result.asset.coin);
-            return sum + (result.actualSize * currentPrice);
-        }, 0);
-        return shortValue > 0 ? longValue / shortValue : 0;
+        const longMarkPrice = ((_a = longResults[0]) === null || _a === void 0 ? void 0 : _a.asset.coin) ? this.getMarketPrice(longResults[0].asset.coin) : 0;
+        const shortMarkPrice = ((_b = shortResults[0]) === null || _b === void 0 ? void 0 : _b.asset.coin) ? this.getMarketPrice(shortResults[0].asset.coin) : 0;
+        return shortMarkPrice > 0 ? longMarkPrice / shortMarkPrice : 0;
     }
     calculateNetFundingFromSyncResults(syncResults) {
         const netFunding = syncResults.reduce((sum, result) => {
@@ -3348,17 +3380,24 @@ const useCalculatedAccountSummary = (platformAccountSummary, platformOpenOrders,
 };
 
 /**
- * Hook to access trade histories
+ * Hook to access trade histories with loading state
  */
 const useTradeHistories = () => {
     const context = useContext(PearHyperliquidContext);
     if (!context) {
         throw new Error('useTradeHistories must be used within a PearHyperliquidProvider');
     }
-    return context.data.tradeHistories;
+    const isLoading = useMemo(() => {
+        // Loading is true initially and becomes false once we get the first data
+        return context.data.tradeHistories === null && context.isConnected;
+    }, [context.data.tradeHistories, context.isConnected]);
+    return {
+        data: context.data.tradeHistories,
+        isLoading
+    };
 };
 /**
- * Hook to access open positions with real-time calculations
+ * Hook to access open positions with real-time calculations and loading state
  */
 const useOpenPositions = () => {
     const context = useContext(PearHyperliquidContext);
@@ -3367,20 +3406,38 @@ const useOpenPositions = () => {
     }
     // Use calculated positions that sync platform data with HyperLiquid real-time data
     const calculatedPositions = useCalculatedOpenPositions(context.data.openPositions, context.webData2, context.allMids);
-    return calculatedPositions;
+    const isLoading = useMemo(() => {
+        // Loading is true initially and becomes false only when:
+        // 1. WebSocket has open-positions data
+        // 2. webData2 and allMids are ready (required for calculations)
+        // 3. Connection is established
+        return (context.isConnected &&
+            (context.data.openPositions === null || !context.webData2 || !context.allMids));
+    }, [context.data.openPositions, context.webData2, context.allMids, context.isConnected]);
+    return {
+        data: calculatedPositions,
+        isLoading
+    };
 };
 /**
- * Hook to access open orders
+ * Hook to access open orders with loading state
  */
 const useOpenOrders = () => {
     const context = useContext(PearHyperliquidContext);
     if (!context) {
         throw new Error('useOpenOrders must be used within a PearHyperliquidProvider');
     }
-    return context.data.openOrders;
+    const isLoading = useMemo(() => {
+        // Loading is true initially and becomes false once we get the first data
+        return context.data.openOrders === null && context.isConnected;
+    }, [context.data.openOrders, context.isConnected]);
+    return {
+        data: context.data.openOrders,
+        isLoading
+    };
 };
 /**
- * Hook to access account summary with real-time calculations
+ * Hook to access account summary with real-time calculations and loading state
  */
 const useAccountSummary = () => {
     var _a, _b, _c, _d;
@@ -3390,8 +3447,462 @@ const useAccountSummary = () => {
     }
     // Use calculated account summary that syncs platform data with HyperLiquid real-time data
     const calculatedAccountSummary = useCalculatedAccountSummary(context.data.accountSummary, context.data.openOrders, context.webData2, (_b = (_a = context.data.accountSummary) === null || _a === void 0 ? void 0 : _a.agentWallet) === null || _b === void 0 ? void 0 : _b.address, (_d = (_c = context.data.accountSummary) === null || _c === void 0 ? void 0 : _c.agentWallet) === null || _d === void 0 ? void 0 : _d.status);
-    return calculatedAccountSummary;
+    const isLoading = useMemo(() => {
+        // Loading is true initially and becomes false once we get the first data
+        return context.data.accountSummary === null && context.isConnected;
+    }, [context.data.accountSummary, context.isConnected]);
+    return {
+        data: calculatedAccountSummary,
+        isLoading
+    };
+};
+
+/**
+ * Extracts token metadata from WebData2 and AllMids data
+ */
+class TokenMetadataExtractor {
+    /**
+     * Extracts comprehensive token metadata
+     * @param symbol - Token symbol
+     * @param webData2 - WebData2 response containing asset context and universe data
+     * @param allMids - AllMids data containing current prices
+     * @returns TokenMetadata or null if token not found
+     */
+    static extractTokenMetadata(symbol, webData2, allMids) {
+        if (!webData2 || !allMids) {
+            return null;
+        }
+        // Find token index in universe
+        const universeIndex = webData2.meta.universe.findIndex(asset => asset.name === symbol);
+        if (universeIndex === -1) {
+            return null;
+        }
+        const universeAsset = webData2.meta.universe[universeIndex];
+        const assetCtx = webData2.assetCtxs[universeIndex];
+        if (!assetCtx) {
+            return null;
+        }
+        // Get current price from allMids
+        const currentPriceStr = allMids.mids[symbol];
+        const currentPrice = currentPriceStr ? parseFloat(currentPriceStr) : 0;
+        // Get previous day price
+        const prevDayPrice = parseFloat(assetCtx.prevDayPx);
+        // Calculate 24h price change
+        const priceChange24h = currentPrice - prevDayPrice;
+        const priceChange24hPercent = prevDayPrice !== 0 ? (priceChange24h / prevDayPrice) * 100 : 0;
+        // Parse other metadata
+        const netFunding = parseFloat(assetCtx.funding);
+        const markPrice = parseFloat(assetCtx.markPx);
+        const oraclePrice = parseFloat(assetCtx.oraclePx);
+        return {
+            currentPrice,
+            prevDayPrice,
+            priceChange24h,
+            priceChange24hPercent,
+            netFunding,
+            maxLeverage: universeAsset.maxLeverage,
+            markPrice,
+            oraclePrice,
+            openInterest: assetCtx.openInterest,
+            dayVolume: assetCtx.dayNtlVlm,
+        };
+    }
+    /**
+     * Extracts metadata for multiple tokens
+     * @param symbols - Array of token symbols
+     * @param webData2 - WebData2 response
+     * @param allMids - AllMids data
+     * @returns Record of symbol to TokenMetadata
+     */
+    static extractMultipleTokensMetadata(symbols, webData2, allMids) {
+        const result = {};
+        for (const symbol of symbols) {
+            result[symbol] = this.extractTokenMetadata(symbol, webData2, allMids);
+        }
+        return result;
+    }
+    /**
+     * Checks if token data is available in WebData2
+     * @param symbol - Token symbol
+     * @param webData2 - WebData2 response
+     * @returns boolean indicating if token exists in universe
+     */
+    static isTokenAvailable(symbol, webData2) {
+        if (!webData2)
+            return false;
+        return webData2.meta.universe.some(asset => asset.name === symbol);
+    }
+}
+
+/**
+ * Hook to access token selection state using provider's WebSocket data
+ */
+const useTokenSelection = () => {
+    var _a;
+    const context = useContext(PearHyperliquidContext);
+    if (!context) {
+        throw new Error('useTokenSelection must be used within PearHyperliquidProvider');
+    }
+    const { webData2, allMids, tokenSelection, setTokenSelection } = context;
+    // Loading states
+    const isPriceDataReady = useMemo(() => {
+        return !!(webData2 && allMids);
+    }, [webData2, allMids]);
+    const isLoading = useMemo(() => {
+        // Check if any tokens have missing metadata when price data is available
+        if (!isPriceDataReady)
+            return true;
+        const allTokens = [...tokenSelection.longTokens, ...tokenSelection.shortTokens];
+        if (allTokens.length === 0)
+            return false;
+        // Loading if any token is missing metadata
+        return allTokens.some(token => !token.metadata);
+    }, [isPriceDataReady, tokenSelection.longTokens, tokenSelection.shortTokens]);
+    // Auto-update token metadata when WebSocket data changes
+    useEffect(() => {
+        if (!webData2 || !allMids)
+            return;
+        const allTokenSymbols = [...tokenSelection.longTokens, ...tokenSelection.shortTokens].map(t => t.symbol);
+        if (allTokenSymbols.length === 0)
+            return;
+        const metadataMap = TokenMetadataExtractor.extractMultipleTokensMetadata(allTokenSymbols, webData2, allMids);
+        setTokenSelection(prev => ({
+            ...prev,
+            longTokens: prev.longTokens.map(token => ({
+                ...token,
+                metadata: metadataMap[token.symbol] || undefined
+            })),
+            shortTokens: prev.shortTokens.map(token => ({
+                ...token,
+                metadata: metadataMap[token.symbol] || undefined
+            }))
+        }));
+    }, [webData2, allMids, setTokenSelection]);
+    // Calculate weighted ratio: LONG^WEIGHT * SHORT^-WEIGHT
+    const weightedRatio = useMemo(() => {
+        let longProduct = 1;
+        let shortProduct = 1;
+        // Calculate long side product: PRICE^(WEIGHT/100)
+        tokenSelection.longTokens.forEach(token => {
+            var _a;
+            if (((_a = token.metadata) === null || _a === void 0 ? void 0 : _a.currentPrice) && token.weight > 0) {
+                const weightFactor = token.weight / 100;
+                longProduct *= Math.pow(token.metadata.currentPrice, weightFactor);
+            }
+        });
+        // Calculate short side product: PRICE^-(WEIGHT/100)
+        tokenSelection.shortTokens.forEach(token => {
+            var _a;
+            if (((_a = token.metadata) === null || _a === void 0 ? void 0 : _a.currentPrice) && token.weight > 0) {
+                const weightFactor = token.weight / 100;
+                shortProduct *= Math.pow(token.metadata.currentPrice, -weightFactor);
+            }
+        });
+        return longProduct * shortProduct;
+    }, [tokenSelection.longTokens, tokenSelection.shortTokens]);
+    // Calculate 24h weighted ratio using previous day prices
+    const weightedRatio24h = useMemo(() => {
+        let longProduct = 1;
+        let shortProduct = 1;
+        // Calculate long side product: PREV_PRICE^(WEIGHT/100)
+        tokenSelection.longTokens.forEach(token => {
+            var _a;
+            if (((_a = token.metadata) === null || _a === void 0 ? void 0 : _a.prevDayPrice) && token.weight > 0) {
+                const weightFactor = token.weight / 100;
+                longProduct *= Math.pow(token.metadata.prevDayPrice, weightFactor);
+            }
+        });
+        // Calculate short side product: PREV_PRICE^-(WEIGHT/100)
+        tokenSelection.shortTokens.forEach(token => {
+            var _a;
+            if (((_a = token.metadata) === null || _a === void 0 ? void 0 : _a.prevDayPrice) && token.weight > 0) {
+                const weightFactor = token.weight / 100;
+                shortProduct *= Math.pow(token.metadata.prevDayPrice, -weightFactor);
+            }
+        });
+        return longProduct * shortProduct;
+    }, [tokenSelection.longTokens, tokenSelection.shortTokens]);
+    // Calculate sum of weighted net funding
+    const sumNetFunding = useMemo(() => {
+        let totalFunding = 0;
+        // Add long funding weighted by allocation
+        tokenSelection.longTokens.forEach(token => {
+            var _a;
+            if (((_a = token.metadata) === null || _a === void 0 ? void 0 : _a.netFunding) && token.weight > 0) {
+                const weightFactor = token.weight / 100;
+                totalFunding += token.metadata.netFunding * weightFactor;
+            }
+        });
+        // Subtract short funding weighted by allocation (since we're short)
+        tokenSelection.shortTokens.forEach(token => {
+            var _a;
+            if (((_a = token.metadata) === null || _a === void 0 ? void 0 : _a.netFunding) && token.weight > 0) {
+                const weightFactor = token.weight / 100;
+                totalFunding -= token.metadata.netFunding * weightFactor;
+            }
+        });
+        return totalFunding;
+    }, [tokenSelection.longTokens, tokenSelection.shortTokens]);
+    // Calculate max leverage (minimum of all token maxLeverages)
+    const maxLeverage = useMemo(() => {
+        var _a;
+        if (!((_a = webData2 === null || webData2 === void 0 ? void 0 : webData2.meta) === null || _a === void 0 ? void 0 : _a.universe))
+            return 0;
+        const allTokenSymbols = [...tokenSelection.longTokens, ...tokenSelection.shortTokens].map(t => t.symbol);
+        if (allTokenSymbols.length === 0)
+            return 0;
+        let minLeverage = Infinity;
+        allTokenSymbols.forEach(symbol => {
+            const tokenUniverse = webData2.meta.universe.find(u => u.name === symbol);
+            if (tokenUniverse === null || tokenUniverse === void 0 ? void 0 : tokenUniverse.maxLeverage) {
+                minLeverage = Math.min(minLeverage, tokenUniverse.maxLeverage);
+            }
+        });
+        return minLeverage === Infinity ? 0 : minLeverage;
+    }, [(_a = webData2 === null || webData2 === void 0 ? void 0 : webData2.meta) === null || _a === void 0 ? void 0 : _a.universe, tokenSelection.longTokens, tokenSelection.shortTokens]);
+    // Calculate minimum margin (10 * total number of tokens)
+    const minMargin = useMemo(() => {
+        const totalTokenCount = tokenSelection.longTokens.length + tokenSelection.shortTokens.length;
+        return 10 * totalTokenCount;
+    }, [tokenSelection.longTokens.length, tokenSelection.shortTokens.length]);
+    // Actions
+    const setLongTokens = useCallback((tokens) => {
+        setTokenSelection(prev => ({ ...prev, longTokens: tokens }));
+    }, [setTokenSelection]);
+    const setShortTokens = useCallback((tokens) => {
+        setTokenSelection(prev => ({ ...prev, shortTokens: tokens }));
+    }, [setTokenSelection]);
+    const updateTokenWeight = useCallback((isLong, index, newWeight) => {
+        const clampedWeight = Math.max(1, Math.min(100, newWeight));
+        setTokenSelection(prev => {
+            var _a, _b;
+            const currentLongTotal = prev.longTokens.reduce((sum, token) => sum + token.weight, 0);
+            const currentShortTotal = prev.shortTokens.reduce((sum, token) => sum + token.weight, 0);
+            if (isLong) {
+                const oldWeight = ((_a = prev.longTokens[index]) === null || _a === void 0 ? void 0 : _a.weight) || 0;
+                const weightDiff = clampedWeight - oldWeight;
+                const newLongTotal = currentLongTotal + weightDiff;
+                if (newLongTotal + currentShortTotal > 100) {
+                    const maxAllowedWeight = Math.max(1, 100 - currentShortTotal - (currentLongTotal - oldWeight));
+                    const updated = [...prev.longTokens];
+                    updated[index] = { ...updated[index], weight: maxAllowedWeight };
+                    return { ...prev, longTokens: updated };
+                }
+                else {
+                    const updated = [...prev.longTokens];
+                    updated[index] = { ...updated[index], weight: clampedWeight };
+                    return { ...prev, longTokens: updated };
+                }
+            }
+            else {
+                const oldWeight = ((_b = prev.shortTokens[index]) === null || _b === void 0 ? void 0 : _b.weight) || 0;
+                const weightDiff = clampedWeight - oldWeight;
+                const newShortTotal = currentShortTotal + weightDiff;
+                if (currentLongTotal + newShortTotal > 100) {
+                    const maxAllowedWeight = Math.max(1, 100 - currentLongTotal - (currentShortTotal - oldWeight));
+                    const updated = [...prev.shortTokens];
+                    updated[index] = { ...updated[index], weight: maxAllowedWeight };
+                    return { ...prev, shortTokens: updated };
+                }
+                else {
+                    const updated = [...prev.shortTokens];
+                    updated[index] = { ...updated[index], weight: clampedWeight };
+                    return { ...prev, shortTokens: updated };
+                }
+            }
+        });
+    }, [setTokenSelection]);
+    const addToken = useCallback((isLong) => {
+        const currentTokens = isLong ? tokenSelection.longTokens : tokenSelection.shortTokens;
+        const newIndex = currentTokens.length;
+        setTokenSelection(prev => ({
+            ...prev,
+            selectorConfig: { isLong, index: newIndex },
+            openTokenSelector: true,
+        }));
+    }, [tokenSelection.longTokens, tokenSelection.shortTokens, setTokenSelection]);
+    const removeToken = useCallback((isLong, index) => {
+        setTokenSelection(prev => {
+            if (isLong) {
+                const updated = prev.longTokens.filter((_, i) => i !== index);
+                return { ...prev, longTokens: updated };
+            }
+            else {
+                const updated = prev.shortTokens.filter((_, i) => i !== index);
+                return { ...prev, shortTokens: updated };
+            }
+        });
+    }, [setTokenSelection]);
+    const setOpenTokenSelector = useCallback((open) => {
+        setTokenSelection(prev => ({ ...prev, openTokenSelector: open }));
+    }, [setTokenSelection]);
+    const setSelectorConfig = useCallback((config) => {
+        setTokenSelection(prev => ({ ...prev, selectorConfig: config }));
+    }, [setTokenSelection]);
+    const setOpenConflictModal = useCallback((open) => {
+        setTokenSelection(prev => ({ ...prev, openConflictModal: open }));
+    }, [setTokenSelection]);
+    const setConflicts = useCallback((conflicts) => {
+        setTokenSelection(prev => ({ ...prev, conflicts }));
+    }, [setTokenSelection]);
+    const resetToDefaults = useCallback(() => {
+        setTokenSelection(prev => ({
+            ...prev,
+            longTokens: [
+                { symbol: 'HYPE', weight: 25 },
+                { symbol: 'BTC', weight: 25 }
+            ],
+            shortTokens: [
+                { symbol: 'AVAX', weight: 10 },
+                { symbol: 'SEI', weight: 10 },
+                { symbol: 'ADA', weight: 10 },
+                { symbol: 'TRUMP', weight: 10 },
+                { symbol: 'SUI', weight: 10 }
+            ],
+            openTokenSelector: false,
+            selectorConfig: null,
+            openConflictModal: false,
+        }));
+    }, [setTokenSelection]);
+    const handleTokenSelect = useCallback((selectedToken) => {
+        if (!tokenSelection.selectorConfig)
+            return;
+        const { isLong, index } = tokenSelection.selectorConfig;
+        const existingTokens = isLong ? tokenSelection.longTokens : tokenSelection.shortTokens;
+        // Check if token already exists
+        if (existingTokens.some(t => t.symbol === selectedToken))
+            return;
+        // Get metadata for new token
+        const metadata = TokenMetadataExtractor.extractTokenMetadata(selectedToken, webData2, allMids);
+        setTokenSelection(prev => {
+            if (index >= existingTokens.length) {
+                // Adding new token - calculate safe weight
+                const currentLongTotal = prev.longTokens.reduce((sum, token) => sum + token.weight, 0);
+                const currentShortTotal = prev.shortTokens.reduce((sum, token) => sum + token.weight, 0);
+                const currentTotal = currentLongTotal + currentShortTotal;
+                const maxAvailableWeight = Math.max(1, 100 - currentTotal);
+                const safeWeight = Math.min(20, maxAvailableWeight);
+                const newToken = {
+                    symbol: selectedToken,
+                    weight: safeWeight,
+                    metadata: metadata || undefined
+                };
+                if (isLong) {
+                    return { ...prev, longTokens: [...prev.longTokens, newToken] };
+                }
+                else {
+                    return { ...prev, shortTokens: [...prev.shortTokens, newToken] };
+                }
+            }
+            else {
+                // Replacing existing token
+                if (isLong) {
+                    const updated = [...prev.longTokens];
+                    updated[index] = {
+                        ...updated[index],
+                        symbol: selectedToken,
+                        metadata: metadata || undefined
+                    };
+                    return { ...prev, longTokens: updated };
+                }
+                else {
+                    const updated = [...prev.shortTokens];
+                    updated[index] = {
+                        ...updated[index],
+                        symbol: selectedToken,
+                        metadata: metadata || undefined
+                    };
+                    return { ...prev, shortTokens: updated };
+                }
+            }
+        });
+    }, [tokenSelection.selectorConfig, tokenSelection.longTokens, tokenSelection.shortTokens, webData2, allMids, setTokenSelection]);
+    // updateTokenMetadata is now handled automatically by the useEffect above
+    return {
+        // State
+        longTokens: tokenSelection.longTokens,
+        shortTokens: tokenSelection.shortTokens,
+        openTokenSelector: tokenSelection.openTokenSelector,
+        selectorConfig: tokenSelection.selectorConfig,
+        openConflictModal: tokenSelection.openConflictModal,
+        conflicts: tokenSelection.conflicts,
+        // Loading states
+        isLoading,
+        isPriceDataReady,
+        // Calculated values
+        weightedRatio,
+        weightedRatio24h,
+        sumNetFunding,
+        maxLeverage,
+        minMargin,
+        // Actions
+        setLongTokens,
+        setShortTokens,
+        updateTokenWeight,
+        addToken,
+        removeToken,
+        handleTokenSelect,
+        setOpenTokenSelector,
+        setSelectorConfig,
+        setOpenConflictModal,
+        setConflicts,
+        resetToDefaults,
+    };
 };
 
-export { AccountSummaryCalculator, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, PearHyperliquidClient as default, useAccountSummary, useAddress, useCalculatedAccountSummary, useCalculatedOpenPositions, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTradeHistories };
+/**
+ * Detects conflicts between selected tokens and existing positions
+ */
+class ConflictDetector {
+    /**
+     * Detects conflicts between token selections and open positions
+     * @param longTokens - Selected long tokens
+     * @param shortTokens - Selected short tokens
+     * @param openPositions - Current open positions from API
+     * @returns Array of detected conflicts
+     */
+    static detectConflicts(longTokens, shortTokens, openPositions) {
+        const detectedConflicts = [];
+        if (!openPositions) {
+            return detectedConflicts;
+        }
+        // Check long tokens against existing short positions
+        longTokens.forEach((token) => {
+            const existingShortPosition = openPositions.find((pos) => {
+                var _a;
+                // Check multiple possible property names and side values
+                const symbol = pos.coin || pos.symbol || pos.asset;
+                const side = (_a = pos.side) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+                return symbol === token.symbol && (side === 'short' || side === 'sell');
+            });
+            if (existingShortPosition) {
+                detectedConflicts.push({
+                    symbol: token.symbol,
+                    conflictType: 'short',
+                    conflictMessage: `${token.symbol} Long conflicts with existing ${token.symbol} Short position`
+                });
+            }
+        });
+        // Check short tokens against existing long positions
+        shortTokens.forEach((token) => {
+            const existingLongPosition = openPositions.find((pos) => {
+                var _a;
+                // Check multiple possible property names and side values
+                const symbol = pos.coin || pos.symbol || pos.asset;
+                const side = (_a = pos.side) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+                return symbol === token.symbol && (side === 'long' || side === 'buy');
+            });
+            if (existingLongPosition) {
+                detectedConflicts.push({
+                    symbol: token.symbol,
+                    conflictType: 'long',
+                    conflictMessage: `${token.symbol} Short conflicts with existing ${token.symbol} Long position`
+                });
+            }
+        });
+        return detectedConflicts;
+    }
+}
+
+export { AccountSummaryCalculator, ConflictDetector, PearHyperliquidClient, PearHyperliquidProvider, PearMigrationSDK, TokenMetadataExtractor, PearHyperliquidClient as default, useAccountSummary, useAddress, useCalculatedAccountSummary, useCalculatedOpenPositions, useHyperliquidNativeWebSocket, useHyperliquidWebSocket, useMigrationSDK, useOpenOrders, useOpenPositions, usePearHyperliquidClient, useTokenSelection, useTradeHistories };
 //# sourceMappingURL=index.esm.js.map