@metamask-previews/perps-controller 0.0.0-preview-685dbf46b → 1.0.0-preview-bc00f2c

package/dist/services/HyperLiquidSubscriptionService.mjs

@@ -0,0 +1,2195 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _HyperLiquidSubscriptionService_instances, _HyperLiquidSubscriptionService_clientService, _HyperLiquidSubscriptionService_walletService, _HyperLiquidSubscriptionService_hip3Enabled, _HyperLiquidSubscriptionService_enabledDexs, _HyperLiquidSubscriptionService_allowlistMarkets, _HyperLiquidSubscriptionService_blocklistMarkets, _HyperLiquidSubscriptionService_discoveredDexNames, _HyperLiquidSubscriptionService_dexDiscoveryPromise, _HyperLiquidSubscriptionService_dexDiscoveryResolver, _HyperLiquidSubscriptionService_expectedDexs, _HyperLiquidSubscriptionService_initializedDexs, _HyperLiquidSubscriptionService_priceSubscribers, _HyperLiquidSubscriptionService_positionSubscribers, _HyperLiquidSubscriptionService_orderFillSubscribers, _HyperLiquidSubscriptionService_orderSubscribers, _HyperLiquidSubscriptionService_accountSubscribers, _HyperLiquidSubscriptionService_marketDataSubscribers, _HyperLiquidSubscriptionService_orderBookSubscribers, _HyperLiquidSubscriptionService_globalAllMidsSubscription, _HyperLiquidSubscriptionService_globalAllMidsPromise, _HyperLiquidSubscriptionService_globalActiveAssetSubscriptions, _HyperLiquidSubscriptionService_globalBboSubscriptions, _HyperLiquidSubscriptionService_orderFillSubscriptions, _HyperLiquidSubscriptionService_symbolSubscriberCounts, _HyperLiquidSubscriptionService_dexSubscriberCounts, _HyperLiquidSubscriptionService_webData3Subscriptions, _HyperLiquidSubscriptionService_webData3SubscriptionPromise, _HyperLiquidSubscriptionService_positionSubscriberCount, _HyperLiquidSubscriptionService_orderSubscriberCount, _HyperLiquidSubscriptionService_accountSubscriberCount, _HyperLiquidSubscriptionService_oiCapSubscriberCount, _HyperLiquidSubscriptionService_dexPositionsCache, _HyperLiquidSubscriptionService_dexOrdersCache, _HyperLiquidSubscriptionService_dexAccountCache, _HyperLiquidSubscriptionService_cachedPositions, _HyperLiquidSubscriptionService_cachedOrders, _HyperLiquidSubscriptionService_cachedAccount, _HyperLiquidSubscriptionService_ordersCacheInitialized, _HyperLiquidSubscriptionService_positionsCacheInitialized, _HyperLiquidSubscriptionService_oiCapSubscribers, _HyperLiquidSubscriptionService_cachedOICaps, _HyperLiquidSubscriptionService_cachedOICapsHash, _HyperLiquidSubscriptionService_oiCapsCacheInitialized, _HyperLiquidSubscriptionService_cachedPriceData, _HyperLiquidSubscriptionService_cachedFills, _HyperLiquidSubscriptionService_fillsCacheInitialized, _HyperLiquidSubscriptionService_assetCtxsSubscriptions, _HyperLiquidSubscriptionService_dexAssetCtxsCache, _HyperLiquidSubscriptionService_assetCtxsSubscriptionPromises, _HyperLiquidSubscriptionService_clearinghouseStateSubscriptions, _HyperLiquidSubscriptionService_openOrdersSubscriptions, _HyperLiquidSubscriptionService_pendingClearinghouseSubscriptions, _HyperLiquidSubscriptionService_pendingOpenOrdersSubscriptions, _HyperLiquidSubscriptionService_dexMetaCache, _HyperLiquidSubscriptionService_orderBookCache, _HyperLiquidSubscriptionService_marketDataCache, _HyperLiquidSubscriptionService_isClearing, _HyperLiquidSubscriptionService_deps, _HyperLiquidSubscriptionService_logErrorUnlessClearing, _HyperLiquidSubscriptionService_getErrorContext, _HyperLiquidSubscriptionService_isDexEnabled, _HyperLiquidSubscriptionService_waitForDexDiscovery, _HyperLiquidSubscriptionService_hashPositions, _HyperLiquidSubscriptionService_hashOrders, _HyperLiquidSubscriptionService_hashAccountState, _HyperLiquidSubscriptionService_cachedPositionsHash, _HyperLiquidSubscriptionService_cachedOrdersHash, _HyperLiquidSubscriptionService_cachedAccountHash, _HyperLiquidSubscriptionService_extractTPSLFromOrders, _HyperLiquidSubscriptionService_mergeTPSLIntoPositions, _HyperLiquidSubscriptionService_aggregateAccountStates, _HyperLiquidSubscriptionService_ensureSharedWebData3Subscription, _HyperLiquidSubscriptionService_createUserDataSubscription, _HyperLiquidSubscriptionService_ensureClearinghouseStateSubscription, _HyperLiquidSubscriptionService_createClearinghouseSubscription, _HyperLiquidSubscriptionService_ensureOpenOrdersSubscription, _HyperLiquidSubscriptionService_createOpenOrdersSubscription, _HyperLiquidSubscriptionService_aggregateAndNotifySubscribers, _HyperLiquidSubscriptionService_cleanupSharedWebData3ISubscription, _HyperLiquidSubscriptionService_ensureOrderFillISubscription, _HyperLiquidSubscriptionService_createSubscription, _HyperLiquidSubscriptionService_createPriceUpdate, _HyperLiquidSubscriptionService_ensureGlobalAllMidsSubscription, _HyperLiquidSubscriptionService_ensureActiveAssetSubscription, _HyperLiquidSubscriptionService_cleanupActiveAssetSubscription, _HyperLiquidSubscriptionService_ensureAssetCtxsSubscription, _HyperLiquidSubscriptionService_createAssetCtxsSubscription, _HyperLiquidSubscriptionService_cleanupAssetCtxsSubscription, _HyperLiquidSubscriptionService_ensureBboSubscription, _HyperLiquidSubscriptionService_cleanupBboSubscription, _HyperLiquidSubscriptionService_processOrderBookData, _HyperLiquidSubscriptionService_notifyAllPriceSubscribers;
+import { TP_SL_CONFIG, PERPS_CONSTANTS } from "../constants/perpsConfig.mjs";
+import { calculateWeightedReturnOnEquity } from "../utils/accountUtils.mjs";
+import { ensureError } from "../utils/errorUtils.mjs";
+import { adaptPositionFromSDK, adaptOrderFromSDK, adaptAccountStateFromSDK, parseAssetName } from "../utils/hyperLiquidAdapter.mjs";
+import { processBboData } from "../utils/hyperLiquidOrderBookProcessor.mjs";
+import { calculateOpenInterestUSD } from "../utils/marketDataTransform.mjs";
+/**
+ * Service for managing HyperLiquid WebSocket subscriptions
+ * Implements singleton subscription architecture with reference counting
+ */
+export class HyperLiquidSubscriptionService {
+    constructor(clientService, walletService, platformDependencies, hip3Enabled, enabledDexs, allowlistMarkets, blocklistMarkets) {
+        _HyperLiquidSubscriptionService_instances.add(this);
+        // Service dependencies
+        _HyperLiquidSubscriptionService_clientService.set(this, void 0);
+        _HyperLiquidSubscriptionService_walletService.set(this, void 0);
+        // HIP-3 feature flag support
+        _HyperLiquidSubscriptionService_hip3Enabled.set(this, void 0);
+        _HyperLiquidSubscriptionService_enabledDexs.set(this, void 0); // DEX identification (maps webData3 indices to DEX names)
+        _HyperLiquidSubscriptionService_allowlistMarkets.set(this, void 0); // Market filtering (allowlist)
+        _HyperLiquidSubscriptionService_blocklistMarkets.set(this, void 0); // Market filtering (blocklist)
+        _HyperLiquidSubscriptionService_discoveredDexNames.set(this, []); // DEX order for mapping webData3 perpDexStates indices
+        // DEX discovery synchronization - allows subscriptions to wait for HIP-3 DEX discovery
+        _HyperLiquidSubscriptionService_dexDiscoveryPromise.set(this, null);
+        _HyperLiquidSubscriptionService_dexDiscoveryResolver.set(this, null);
+        // Track DEXs for synchronized position notifications
+        // Ensures all DEXs send initial data before notifying subscribers
+        _HyperLiquidSubscriptionService_expectedDexs.set(this, new Set());
+        _HyperLiquidSubscriptionService_initializedDexs.set(this, new Set());
+        // Subscriber collections
+        _HyperLiquidSubscriptionService_priceSubscribers.set(this, new Map());
+        _HyperLiquidSubscriptionService_positionSubscribers.set(this, new Set());
+        // Order fill subscribers keyed by accountId (normalized: undefined -> 'default')
+        _HyperLiquidSubscriptionService_orderFillSubscribers.set(this, new Map());
+        _HyperLiquidSubscriptionService_orderSubscribers.set(this, new Set());
+        _HyperLiquidSubscriptionService_accountSubscribers.set(this, new Set());
+        // Track which subscribers want market data
+        _HyperLiquidSubscriptionService_marketDataSubscribers.set(this, new Map());
+        // Track which subscribers want top-of-book (best bid/ask) data
+        _HyperLiquidSubscriptionService_orderBookSubscribers.set(this, new Map());
+        // Global singleton subscriptions
+        _HyperLiquidSubscriptionService_globalAllMidsSubscription.set(this, void 0);
+        _HyperLiquidSubscriptionService_globalAllMidsPromise.set(this, void 0); // Track in-progress subscription
+        _HyperLiquidSubscriptionService_globalActiveAssetSubscriptions.set(this, new Map());
+        _HyperLiquidSubscriptionService_globalBboSubscriptions.set(this, new Map());
+        // Order fill subscriptions keyed by accountId (normalized: undefined -> 'default')
+        _HyperLiquidSubscriptionService_orderFillSubscriptions.set(this, new Map());
+        _HyperLiquidSubscriptionService_symbolSubscriberCounts.set(this, new Map());
+        _HyperLiquidSubscriptionService_dexSubscriberCounts.set(this, new Map()); // Track subscribers per DEX for assetCtxs
+        // Multi-DEX webData3 subscription for all user data (positions, orders, account, OI caps)
+        _HyperLiquidSubscriptionService_webData3Subscriptions.set(this, new Map()); // Key: dex name ('' for main)
+        _HyperLiquidSubscriptionService_webData3SubscriptionPromise.set(this, void 0);
+        _HyperLiquidSubscriptionService_positionSubscriberCount.set(this, 0);
+        _HyperLiquidSubscriptionService_orderSubscriberCount.set(this, 0);
+        _HyperLiquidSubscriptionService_accountSubscriberCount.set(this, 0);
+        _HyperLiquidSubscriptionService_oiCapSubscriberCount.set(this, 0);
+        // Multi-DEX data caches
+        _HyperLiquidSubscriptionService_dexPositionsCache.set(this, new Map()); // Per-DEX positions
+        _HyperLiquidSubscriptionService_dexOrdersCache.set(this, new Map()); // Per-DEX orders
+        _HyperLiquidSubscriptionService_dexAccountCache.set(this, new Map()); // Per-DEX account state
+        _HyperLiquidSubscriptionService_cachedPositions.set(this, null); // Aggregated positions
+        _HyperLiquidSubscriptionService_cachedOrders.set(this, null); // Aggregated orders
+        _HyperLiquidSubscriptionService_cachedAccount.set(this, null); // Aggregated account
+        _HyperLiquidSubscriptionService_ordersCacheInitialized.set(this, false); // Track if orders cache has received WebSocket data
+        _HyperLiquidSubscriptionService_positionsCacheInitialized.set(this, false); // Track if positions cache has received WebSocket data
+        // OI Cap tracking (from webData3.perpDexStates[].perpsAtOpenInterestCap)
+        _HyperLiquidSubscriptionService_oiCapSubscribers.set(this, new Set());
+        _HyperLiquidSubscriptionService_cachedOICaps.set(this, []);
+        _HyperLiquidSubscriptionService_cachedOICapsHash.set(this, '');
+        _HyperLiquidSubscriptionService_oiCapsCacheInitialized.set(this, false);
+        // Global price data cache
+        _HyperLiquidSubscriptionService_cachedPriceData.set(this, null);
+        // Fills cache for cache-first pattern (similar to price caching)
+        _HyperLiquidSubscriptionService_cachedFills.set(this, null);
+        _HyperLiquidSubscriptionService_fillsCacheInitialized.set(this, false);
+        // HIP-3: assetCtxs subscriptions for multi-DEX market data
+        _HyperLiquidSubscriptionService_assetCtxsSubscriptions.set(this, new Map()); // Key: dex name ('' for main)
+        _HyperLiquidSubscriptionService_dexAssetCtxsCache.set(this, new Map()); // Per-DEX asset contexts
+        _HyperLiquidSubscriptionService_assetCtxsSubscriptionPromises.set(this, new Map()); // Track in-progress subscriptions
+        _HyperLiquidSubscriptionService_clearinghouseStateSubscriptions.set(this, new Map()); // Key: dex name ('' for main)
+        _HyperLiquidSubscriptionService_openOrdersSubscriptions.set(this, new Map()); // Key: dex name ('' for main)
+        // Pending subscription promises to prevent race conditions
+        // When multiple calls to ensure*Subscription happen concurrently, this ensures
+        // only one subscription is created per DEX (others wait for the pending promise)
+        _HyperLiquidSubscriptionService_pendingClearinghouseSubscriptions.set(this, new Map());
+        _HyperLiquidSubscriptionService_pendingOpenOrdersSubscriptions.set(this, new Map());
+        // Meta cache per DEX - populated by metaAndAssetCtxs, used by createAssetCtxsSubscription
+        // This avoids redundant meta() API calls since metaAndAssetCtxs already returns meta data
+        _HyperLiquidSubscriptionService_dexMetaCache.set(this, new Map());
+        // Order book data cache
+        _HyperLiquidSubscriptionService_orderBookCache.set(this, new Map());
+        // Market data caching for multi-channel consolidation
+        _HyperLiquidSubscriptionService_marketDataCache.set(this, new Map());
+        // Flag to suppress error logging during intentional disconnect
+        // Set in clearAll() and never reset (service instance is discarded after disconnect)
+        _HyperLiquidSubscriptionService_isClearing.set(this, false);
+        // Platform dependencies for logging
+        _HyperLiquidSubscriptionService_deps.set(this, void 0);
+        // Cache hashes to avoid recomputation
+        _HyperLiquidSubscriptionService_cachedPositionsHash.set(this, '');
+        _HyperLiquidSubscriptionService_cachedOrdersHash.set(this, '');
+        _HyperLiquidSubscriptionService_cachedAccountHash.set(this, '');
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_clientService, clientService, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_walletService, walletService, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_deps, platformDependencies, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_hip3Enabled, hip3Enabled ?? false, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_enabledDexs, enabledDexs ?? [], "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_discoveredDexNames, enabledDexs ?? [], "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_allowlistMarkets, allowlistMarkets ?? [], "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_blocklistMarkets, blocklistMarkets ?? [], "f");
+    }
+    /**
+     * Populate DEX meta cache with pre-fetched meta data
+     * Called by Provider after buildAssetMapping to share cached meta,
+     * avoiding redundant metaAndAssetCtxs/meta API calls during subscription setup
+     *
+     * @param dex - DEX key ('' for main DEX, 'xyz'/'flx'/etc for HIP-3)
+     * @param meta - Meta response containing universe data
+     * @param meta.universe - The array of asset universe entries from the meta response.
+     */
+    setDexMetaCache(dex, meta) {
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexMetaCache, "f").set(dex, meta);
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('[SubscriptionService] DEX meta cache populated', {
+            dex: dex || 'main',
+            universeSize: meta.universe.length,
+        });
+    }
+    /**
+     * Cache asset contexts for a specific DEX from API response
+     * This allows buildAssetMapping() to populate cache for getMarketDataWithPrices() to use
+     *
+     * @param dex - DEX name ('' for main perps)
+     * @param assetCtxs - Asset contexts from metaAndAssetCtxs response
+     */
+    setDexAssetCtxsCache(dex, assetCtxs) {
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAssetCtxsCache, "f").set(dex, assetCtxs);
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('[SubscriptionService] DEX assetCtxs cache populated', {
+            dex: dex || 'main',
+            ctxsCount: assetCtxs.length,
+        });
+    }
+    /**
+     * Get cached assetCtxs for a DEX
+     * Returns the cached asset contexts from WebSocket subscription if available
+     *
+     * @param dex - DEX key ('' for main DEX, 'xyz'/'flx'/etc for HIP-3)
+     * @returns Array of asset contexts or undefined if not cached
+     */
+    getDexAssetCtxsCache(dex) {
+        return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAssetCtxsCache, "f").get(dex);
+    }
+    /**
+     * Update feature flags for HIP-3 support
+     * Called when provider configuration changes at runtime
+     * Note: Market filtering is NOT applied in subscription service - only in Provider
+     *
+     * @param hip3Enabled - Whether HIP-3 multi-DEX support is enabled.
+     * @param enabledDexs - The array of enabled DEX identifiers.
+     * @param allowlistMarkets - The array of allowed market patterns.
+     * @param blocklistMarkets - The array of blocked market patterns.
+     */
+    async updateFeatureFlags(hip3Enabled, enabledDexs, allowlistMarkets, blocklistMarkets) {
+        const previousEnabledDexs = [...__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_enabledDexs, "f")];
+        const previousAllowlistMarkets = [...__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_allowlistMarkets, "f")];
+        const previousBlocklistMarkets = [...__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_blocklistMarkets, "f")];
+        const previousHip3Enabled = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_hip3Enabled, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_hip3Enabled, hip3Enabled, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_enabledDexs, enabledDexs, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_allowlistMarkets, allowlistMarkets, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_blocklistMarkets, blocklistMarkets, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_discoveredDexNames, enabledDexs, "f"); // Store DEX order for webData3 index mapping
+        // Resolve any pending DEX discovery wait now that DEXs are available
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexDiscoveryResolver, "f") && enabledDexs.length > 0) {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexDiscoveryResolver, "f").call(this);
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_dexDiscoveryPromise, null, "f");
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_dexDiscoveryResolver, null, "f");
+        }
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('Feature flags updated:', {
+            previousHip3Enabled,
+            hip3Enabled,
+            previousEnabledDexs,
+            enabledDexs,
+            previousAllowlistMarkets,
+            allowlistMarkets,
+            previousBlocklistMarkets,
+            blocklistMarkets,
+        });
+        // If equity was just enabled or new DEXs were added
+        const newDexs = enabledDexs.filter((dex) => !previousEnabledDexs.includes(dex));
+        if ((!previousHip3Enabled && hip3Enabled && enabledDexs.length > 0) ||
+            newDexs.length > 0) {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('Establishing subscriptions for new DEXs:', newDexs);
+            // Establish assetCtxs subscriptions for new DEXs (for market data)
+            const hasMarketDataSubscribers = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataSubscribers, "f").size > 0;
+            if (hasMarketDataSubscribers) {
+                await Promise.all(newDexs.map(async (dex) => {
+                    try {
+                        await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureAssetCtxsSubscription).call(this, dex);
+                    }
+                    catch (error) {
+                        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.updateFeatureFlags'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'updateFeatureFlags.ensureAssetCtxsSubscription', {
+                            dex,
+                        }));
+                    }
+                }));
+            }
+            // Establish clearinghouseState/openOrders subscriptions for new DEXs
+            // (needed for positions, orders, and account data when using individual subscriptions)
+            const hasUserDataSubscribers = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionSubscriberCount, "f") > 0 ||
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderSubscriberCount, "f") > 0 ||
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_accountSubscriberCount, "f") > 0;
+            if (hasUserDataSubscribers && __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_hip3Enabled, "f")) {
+                try {
+                    const userAddress = await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_walletService, "f").getUserAddressWithDefault();
+                    await Promise.all(newDexs.map(async (dex) => {
+                        try {
+                            await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureClearinghouseStateSubscription).call(this, userAddress, dex);
+                            await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureOpenOrdersSubscription).call(this, userAddress, dex);
+                            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`Established user data subscriptions for new DEX: ${dex}`);
+                        }
+                        catch (error) {
+                            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.updateFeatureFlags'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'updateFeatureFlags.ensureUserDataSubscription', { dex }));
+                        }
+                    }));
+                }
+                catch (error) {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.updateFeatureFlags'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'updateFeatureFlags.getUserAddress'));
+                }
+            }
+        }
+    }
+    /**
+     * Subscribe to live price updates with singleton subscription architecture
+     * Uses allMids for fast price updates and predictedFundings for accurate funding rates
+     *
+     * @param params - The subscription parameters including symbols and callbacks.
+     * @returns A cleanup function to unsubscribe from price updates.
+     */
+    async subscribeToPrices(params) {
+        const { symbols, callback, includeOrderBook = false, includeMarketData = false, } = params;
+        const unsubscribers = [];
+        symbols.forEach((symbol) => {
+            unsubscribers.push(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createSubscription).call(this, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_priceSubscribers, "f"), callback, symbol));
+            // Track market data subscribers separately
+            if (includeMarketData) {
+                unsubscribers.push(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createSubscription).call(this, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataSubscribers, "f"), callback, symbol));
+            }
+            // Track order book subscribers separately
+            if (includeOrderBook) {
+                unsubscribers.push(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createSubscription).call(this, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderBookSubscribers, "f"), callback, symbol));
+            }
+        });
+        await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").ensureSubscriptionClient(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_walletService, "f").createWalletAdapter());
+        const subscriptionClient = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").getSubscriptionClient();
+        if (!subscriptionClient) {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('SubscriptionClient not available for price subscription');
+            return () => unsubscribers.forEach((fn) => fn());
+        }
+        // Ensure global subscriptions are established
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureGlobalAllMidsSubscription).call(this);
+        // HIP-3: Establish assetCtxs subscriptions ONLY for DEXs with requested symbols
+        // Performance: Avoid unnecessary WebSocket connections for unused DEXs
+        if (includeMarketData) {
+            // Extract unique DEXs from requested symbols
+            const dexsNeeded = new Set();
+            symbols.forEach((symbol) => {
+                const { dex } = parseAssetName(symbol);
+                dexsNeeded.add(dex);
+            });
+            // Only subscribe to DEXs that have requested symbols
+            dexsNeeded.forEach((dex) => {
+                const dexName = dex ?? '';
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureAssetCtxsSubscription).call(this, dexName).catch((error) => {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.subscribeToPrices'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'subscribeToPrices.ensureAssetCtxsSubscription', { dex: dexName }));
+                });
+            });
+        }
+        // Note: Funding rates are now cached via assetCtxs WebSocket subscription
+        // (ensureAssetCtxsSubscription above), eliminating the need for a separate
+        // metaAndAssetCtxs API call here. The WebSocket callback in createAssetCtxsSubscription
+        // populates marketDataCache with funding rates as they arrive.
+        symbols.forEach((symbol) => {
+            // Subscribe to activeAssetCtx only when market data is requested
+            if (includeMarketData) {
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureActiveAssetSubscription).call(this, symbol);
+            }
+            if (includeOrderBook) {
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureBboSubscription).call(this, symbol);
+            }
+        });
+        // Send cached data immediately if available
+        symbols.forEach((symbol) => {
+            const cachedPrice = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f")?.get(symbol);
+            if (cachedPrice) {
+                callback([cachedPrice]);
+            }
+        });
+        // Return cleanup function
+        return () => {
+            unsubscribers.forEach((fn) => fn());
+            // Cleanup subscriptions with reference counting
+            symbols.forEach((symbol) => {
+                if (includeMarketData) {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_cleanupActiveAssetSubscription).call(this, symbol);
+                }
+                if (includeOrderBook) {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_cleanupBboSubscription).call(this, symbol);
+                }
+            });
+            // Cleanup DEX-level assetCtxs subscriptions
+            if (includeMarketData) {
+                // Extract unique DEXs from requested symbols
+                const dexsNeeded = new Set();
+                symbols.forEach((symbol) => {
+                    const { dex } = parseAssetName(symbol);
+                    dexsNeeded.add(dex);
+                });
+                // Cleanup assetCtxs subscription for each DEX
+                dexsNeeded.forEach((dex) => {
+                    const dexName = dex ?? '';
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_cleanupAssetCtxsSubscription).call(this, dexName);
+                });
+            }
+        };
+    }
+    /**
+     * Subscribe to live position updates with TP/SL data
+     *
+     * @param params - The subscription parameters including callback and account ID.
+     * @returns A cleanup function to unsubscribe from position updates.
+     */
+    subscribeToPositions(params) {
+        const { callback, accountId } = params;
+        const unsubscribe = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createSubscription).call(this, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionSubscribers, "f"), callback);
+        // Increment position subscriber count
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_positionSubscriberCount, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionSubscriberCount, "f") + 1, "f");
+        // Immediately provide cached data if available
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPositions, "f")) {
+            callback(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPositions, "f"));
+        }
+        // Ensure shared subscription is active
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureSharedWebData3Subscription).call(this, accountId).catch((error) => {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.subscribeToPositions'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'subscribeToPositions'));
+        });
+        return () => {
+            unsubscribe();
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_positionSubscriberCount, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionSubscriberCount, "f") - 1, "f");
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_cleanupSharedWebData3ISubscription).call(this);
+        };
+    }
+    /**
+     * Subscribe to open interest cap updates
+     * OI caps are extracted from webData2 subscription (zero additional overhead)
+     *
+     * @param params - The subscription parameters including callback and account ID.
+     * @returns A cleanup function to unsubscribe from OI cap updates.
+     */
+    subscribeToOICaps(params) {
+        const { callback, accountId } = params;
+        // Create subscription
+        const unsubscribe = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createSubscription).call(this, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_oiCapSubscribers, "f"), callback);
+        // Increment OI cap subscriber count
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_oiCapSubscriberCount, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_oiCapSubscriberCount, "f") + 1, "f");
+        // Immediately provide cached data if available
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedOICaps, "f")) {
+            callback(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedOICaps, "f"));
+        }
+        // Ensure webData3 subscription is active (OI caps come from webData3)
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureSharedWebData3Subscription).call(this, accountId).catch((error) => {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.subscribeToOICaps'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'subscribeToOICaps'));
+        });
+        return () => {
+            unsubscribe();
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_oiCapSubscriberCount, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_oiCapSubscriberCount, "f") - 1, "f");
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_cleanupSharedWebData3ISubscription).call(this);
+        };
+    }
+    /**
+     * Check if OI caps cache has been initialized
+     * Useful for preventing UI flashing before first data arrives
+     *
+     * @returns True if the condition is met.
+     */
+    isOICapsCacheInitialized() {
+        return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_oiCapsCacheInitialized, "f");
+    }
+    /**
+     * Subscribe to live order fill updates
+     * Shares subscriptions per accountId to avoid duplicate WebSocket connections
+     *
+     * @param params - The subscription parameters including callback and account ID.
+     * @returns A cleanup function to unsubscribe from order fill updates.
+     */
+    subscribeToOrderFills(params) {
+        const { callback, accountId } = params;
+        // Normalize accountId: undefined -> 'default' for Map key
+        const normalizedAccountId = accountId ?? 'default';
+        const unsubscribe = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createSubscription).call(this, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscribers, "f"), callback, normalizedAccountId);
+        // Ensure subscription is established for this accountId
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureOrderFillISubscription).call(this, accountId).catch((error) => {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.subscribeToOrderFills'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'subscribeToOrderFills'));
+        });
+        return () => {
+            unsubscribe();
+            // If no more subscribers for this accountId, clean up subscription
+            const subscribers = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscribers, "f").get(normalizedAccountId);
+            if (!subscribers || subscribers.size === 0) {
+                const subscription = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscriptions, "f").get(normalizedAccountId);
+                if (subscription) {
+                    subscription.unsubscribe().catch((error) => {
+                        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.subscribeToOrderFills'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'subscribeToOrderFills.unsubscribe'));
+                    });
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscriptions, "f").delete(normalizedAccountId);
+                }
+            }
+        };
+    }
+    /**
+     * Subscribe to live order updates
+     * Uses the shared webData2 subscription to avoid duplicate connections
+     *
+     * @param params - The subscription parameters including callback and account ID.
+     * @returns A cleanup function to unsubscribe from order updates.
+     */
+    subscribeToOrders(params) {
+        const { callback, accountId } = params;
+        const unsubscribe = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createSubscription).call(this, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderSubscribers, "f"), callback);
+        // Increment order subscriber count
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_orderSubscriberCount, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderSubscriberCount, "f") + 1, "f");
+        // Immediately provide cached data if available
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedOrders, "f")) {
+            callback(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedOrders, "f"));
+        }
+        // Ensure shared subscription is active
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureSharedWebData3Subscription).call(this, accountId).catch((error) => {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.subscribeToOrders'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'subscribeToOrders'));
+        });
+        return () => {
+            unsubscribe();
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_orderSubscriberCount, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderSubscriberCount, "f") - 1, "f");
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_cleanupSharedWebData3ISubscription).call(this);
+        };
+    }
+    /**
+     * Subscribe to live account updates
+     * Uses the shared webData2 subscription to avoid duplicate connections
+     *
+     * @param params - The subscription parameters including callback and account ID.
+     * @returns A cleanup function to unsubscribe from account updates.
+     */
+    subscribeToAccount(params) {
+        const { callback, accountId } = params;
+        const unsubscribe = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createSubscription).call(this, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_accountSubscribers, "f"), callback);
+        // Increment account subscriber count
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_accountSubscriberCount, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_accountSubscriberCount, "f") + 1, "f");
+        // Immediately provide cached data if available
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedAccount, "f")) {
+            callback(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedAccount, "f"));
+        }
+        // Ensure shared subscription is active (reuses existing connection)
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureSharedWebData3Subscription).call(this, accountId).catch((error) => {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.subscribeToAccount'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'subscribeToAccount'));
+        });
+        return () => {
+            unsubscribe();
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_accountSubscriberCount, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_accountSubscriberCount, "f") - 1, "f");
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_cleanupSharedWebData3ISubscription).call(this);
+        };
+    }
+    /**
+     * Check if orders cache has been initialized from WebSocket
+     *
+     * @returns true if WebSocket has sent at least one update, false otherwise
+     */
+    isOrdersCacheInitialized() {
+        return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_ordersCacheInitialized, "f");
+    }
+    /**
+     * Check if positions cache has been initialized from WebSocket
+     *
+     * @returns true if WebSocket has sent at least one update, false otherwise
+     */
+    isPositionsCacheInitialized() {
+        return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionsCacheInitialized, "f");
+    }
+    /**
+     * Get cached positions from WebSocket subscription
+     *
+     * @returns Cached positions array, or null if not initialized
+     */
+    getCachedPositions() {
+        return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPositions, "f");
+    }
+    /**
+     * Get cached orders from WebSocket subscription
+     *
+     * @returns Cached orders array, or null if not initialized
+     */
+    getCachedOrders() {
+        return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedOrders, "f");
+    }
+    /**
+     * Atomically get cached orders if initialized
+     * Prevents race condition between checking initialization and getting data
+     *
+     * @returns Cached orders array if initialized, null otherwise
+     */
+    getOrdersCacheIfInitialized() {
+        if (!__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_ordersCacheInitialized, "f")) {
+            return null;
+        }
+        return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedOrders, "f") ? [...__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedOrders, "f")] : [];
+    }
+    /**
+     * Get cached price for a symbol from WebSocket allMids subscription
+     * OPTIMIZATION: Use this instead of REST infoClient.allMids() to avoid rate limiting
+     *
+     * @param symbol - Asset symbol (e.g., 'BTC', 'ETH', 'xyz:TSLA')
+     * @returns Price string, or undefined if not cached
+     */
+    getCachedPrice(symbol) {
+        return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f")?.get(symbol)?.price;
+    }
+    /**
+     * Get cached fills from WebSocket userFills subscription
+     * OPTIMIZATION: Use this instead of REST userFills() to avoid rate limiting
+     *
+     * @returns Copy of cached fills array, or null if not cached
+     */
+    getCachedFills() {
+        return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedFills, "f") ? [...__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedFills, "f")] : null;
+    }
+    /**
+     * Get cached fills only if the cache has been initialized from WebSocket
+     * OPTIMIZATION: Distinguishes between "not initialized" (null) and "initialized but empty" ([])
+     * - Returns null if cache hasn't received WebSocket snapshot yet (caller should use REST)
+     * - Returns empty array [] if cache is initialized but user has no fills (caller can skip REST)
+     * - Returns fills array if cache has data
+     *
+     * @returns Fills array or empty array if initialized, null if not yet initialized
+     */
+    getFillsCacheIfInitialized() {
+        if (!__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_fillsCacheInitialized, "f")) {
+            return null;
+        }
+        return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedFills, "f") ? [...__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedFills, "f")] : [];
+    }
+    /**
+     * Subscribe to full order book updates with multiple depth levels
+     * Creates a dedicated L2Book subscription for the requested symbol
+     * and processes data into OrderBookData format for UI consumption
+     *
+     * @param params - Subscription parameters
+     * @returns Cleanup function to unsubscribe
+     */
+    subscribeToOrderBook(params) {
+        const { symbol, levels = 10, nSigFigs = 5, mantissa, callback, onError, } = params;
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f")
+            .ensureSubscriptionClient(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_walletService, "f").createWalletAdapter())
+            .catch(() => {
+            // Handled by getSubscriptionClient check below
+        });
+        const subscriptionClient = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").getSubscriptionClient();
+        if (!subscriptionClient) {
+            const error = new Error('Subscription client not available');
+            onError?.(error);
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('subscribeToOrderBook: Subscription client not available');
+            return () => {
+                // No-op cleanup
+            };
+        }
+        let subscription;
+        let cancelled = false;
+        subscriptionClient
+            .l2Book({ coin: symbol, nSigFigs, mantissa }, (data) => {
+            if (cancelled || data?.coin !== symbol || !data?.levels) {
+                return;
+            }
+            const orderBookData = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_processOrderBookData).call(this, data, levels);
+            callback(orderBookData);
+        })
+            .then(async (sub) => {
+            if (cancelled) {
+                try {
+                    await sub.unsubscribe();
+                }
+                catch (unsubError) {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(unsubError, 'HyperLiquidSubscriptionService.subscribeToOrderBook'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'subscribeToOrderBook.cleanup', { symbol }));
+                }
+                return undefined;
+            }
+            subscription = sub;
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`HyperLiquid: Order book subscription established for ${symbol}`);
+            return undefined;
+        })
+            .catch((error) => {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.subscribeToOrderBook'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'subscribeToOrderBook', { symbol }));
+            onError?.(ensureError(error, 'HyperLiquidSubscriptionService.subscribeToOrderBook'));
+        });
+        return () => {
+            cancelled = true;
+            if (subscription) {
+                subscription.unsubscribe().catch((error) => {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.subscribeToOrderBook'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'subscribeToOrderBook.unsubscribe', {
+                        symbol,
+                    }));
+                });
+            }
+        };
+    }
+    /**
+     * Restore all active subscriptions after WebSocket reconnection
+     * Re-establishes WebSocket subscriptions for all active subscribers
+     *
+     * IMPORTANT: This method verifies transport readiness before attempting
+     * any subscriptions to prevent "subscribe error: undefined" errors.
+     */
+    async restoreSubscriptions() {
+        // CRITICAL: Verify transport is ready before attempting any subscriptions
+        // This prevents race conditions where subscriptions are attempted while
+        // the WebSocket is still in CONNECTING state
+        try {
+            await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").ensureTransportReady({ timeoutMs: 5000 });
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('Transport not ready during subscription restore, will retry on next reconnect', { error: error instanceof Error ? error.message : String(error) });
+            return;
+        }
+        // Re-establish global allMids subscription if there are price subscribers
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_priceSubscribers, "f").size > 0) {
+            // Clear existing subscription reference (it's dead after reconnection)
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_globalAllMidsSubscription, undefined, "f");
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_globalAllMidsPromise, undefined, "f");
+            // Re-establish the subscription
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureGlobalAllMidsSubscription).call(this);
+        }
+        // Re-establish order fill subscriptions if there are fill subscribers
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscribers, "f").size > 0) {
+            // Clear existing subscription references (they're dead after reconnection)
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscriptions, "f").clear();
+            // Re-establish subscriptions for all accountIds with subscribers
+            // Note: normalizedAccountId is 'default' for undefined, need to convert back
+            const normalizedAccountIds = Array.from(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscribers, "f").keys());
+            await Promise.all(normalizedAccountIds.map((normalizedAccountId) => {
+                // Convert normalized key back to original accountId (undefined if 'default')
+                const accountId = normalizedAccountId === 'default'
+                    ? undefined
+                    : normalizedAccountId;
+                return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureOrderFillISubscription).call(this, accountId).catch(() => {
+                    // Ignore errors during order fill subscription restoration
+                });
+            }));
+        }
+        // Re-establish user data subscriptions if there are user data subscribers
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionSubscribers, "f").size > 0 ||
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderSubscribers, "f").size > 0 ||
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_accountSubscribers, "f").size > 0 ||
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_oiCapSubscribers, "f").size > 0) {
+            // Clear existing subscription references (they're dead after reconnection)
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_webData3Subscriptions, "f").clear();
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_webData3SubscriptionPromise, undefined, "f");
+            // Clear individual subscriptions (clearinghouseState + openOrders) for HIP-3 mode
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clearinghouseStateSubscriptions, "f").clear();
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_openOrdersSubscriptions, "f").clear();
+            // Re-establish the subscription (will use current account)
+            // This will set up webData2 for non-HIP-3, or individual subscriptions + webData3 (OI caps only) for HIP-3
+            await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureSharedWebData3Subscription).call(this);
+        }
+        // Re-establish activeAsset subscriptions if there are market data subscribers
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataSubscribers, "f").size > 0) {
+            // Clear existing subscriptions (they're dead after reconnection)
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalActiveAssetSubscriptions, "f").clear();
+            // Clear reference counts to prevent double-counting after reconnection
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_symbolSubscriberCounts, "f").clear();
+            // Re-establish subscriptions for all symbols with market data subscribers
+            const symbolsNeedingMarketData = Array.from(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataSubscribers, "f").keys());
+            symbolsNeedingMarketData.forEach((symbol) => {
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureActiveAssetSubscription).call(this, symbol);
+            });
+        }
+        // Re-establish BBO subscriptions if there are order book subscribers
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderBookSubscribers, "f").size > 0) {
+            // Clear existing subscriptions (they're dead after reconnection)
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalBboSubscriptions, "f").clear();
+            // Re-establish subscriptions for all symbols with order book subscribers
+            const symbolsNeedingOrderBook = Array.from(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderBookSubscribers, "f").keys());
+            symbolsNeedingOrderBook.forEach((symbol) => {
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureBboSubscription).call(this, symbol);
+            });
+        }
+        // Re-establish assetCtxs subscriptions if there are market data subscribers
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataSubscribers, "f").size > 0) {
+            // Clear existing subscriptions (they're dead after reconnection)
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptions, "f").clear();
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptionPromises, "f").clear();
+            // Clear reference counts to prevent double-counting after reconnection
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexSubscriberCounts, "f").clear();
+            // Re-establish subscriptions for all DEXs with market data subscribers
+            const dexsNeeded = new Set();
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataSubscribers, "f").forEach((_subscribers, symbol) => {
+                const { dex } = parseAssetName(symbol);
+                if (dex) {
+                    dexsNeeded.add(dex);
+                }
+            });
+            // Add main DEX if any main DEX symbols have subscribers
+            const hasMainDexSubscribers = Array.from(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataSubscribers, "f").keys()).some((symbol) => {
+                const { dex } = parseAssetName(symbol);
+                return !dex;
+            });
+            if (hasMainDexSubscribers) {
+                dexsNeeded.add('');
+            }
+            // Re-establish subscriptions
+            await Promise.all(Array.from(dexsNeeded).map((dex) => __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureAssetCtxsSubscription).call(this, dex).catch(() => {
+                // Ignore errors during assetCtxs subscription restoration
+            })));
+        }
+    }
+    /**
+     * Clear all subscriptions and cached data (multi-DEX support)
+     */
+    clearAll() {
+        // Suppress error logging for pending unsubscribe requests during intentional disconnect.
+        // The WebSocket will be closed after this, causing pending unsubscribe promises to reject
+        // with WebSocketRequestError - these are expected and should not be logged to Sentry.
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_isClearing, true, "f");
+        // Clear all local subscriber collections
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_priceSubscribers, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionSubscribers, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscribers, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderSubscribers, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_accountSubscribers, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataSubscribers, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderBookSubscribers, "f").clear();
+        // Clear order fill subscriptions
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscriptions, "f").forEach((subscription) => {
+            subscription.unsubscribe().catch(() => {
+                // Ignore errors during cleanup
+            });
+        });
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscriptions, "f").clear();
+        // Clear cached data
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedPriceData, null, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedPositions, null, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedOrders, null, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedAccount, null, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedFills, null, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_ordersCacheInitialized, false, "f"); // Reset cache initialization flag
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_positionsCacheInitialized, false, "f"); // Reset cache initialization flag
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_fillsCacheInitialized, false, "f"); // Reset fills cache initialization flag
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataCache, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderBookCache, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_symbolSubscriberCounts, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexSubscriberCounts, "f").clear();
+        // Clear hash caches
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedPositionsHash, '', "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedOrdersHash, '', "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedAccountHash, '', "f");
+        // Clear multi-DEX caches
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('HyperLiquidSubscriptionService: Clearing per-DEX caches', {
+            dexPositionsCacheSize: __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").size,
+            dexOrdersCacheSize: __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexOrdersCache, "f").size,
+            dexAccountCacheSize: __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAccountCache, "f").size,
+            dexAssetCtxsCacheSize: __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAssetCtxsCache, "f").size,
+            dexPositionsCacheKeys: Array.from(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").keys()),
+            dexAssetCtxsCacheKeys: Array.from(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAssetCtxsCache, "f").keys()),
+        });
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexOrdersCache, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAccountCache, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAssetCtxsCache, "f").clear();
+        // Clear subscription references (actual cleanup handled by client service)
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_globalAllMidsSubscription, undefined, "f");
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalActiveAssetSubscriptions, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalBboSubscriptions, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_webData3Subscriptions, "f").clear();
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_webData3SubscriptionPromise, undefined, "f");
+        // HIP-3: Clear assetCtxs subscriptions (clearinghouseState no longer needed with webData3)
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptions, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptionPromises, "f").clear();
+        // Cleanup individual subscriptions (clearinghouseState + openOrders)
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clearinghouseStateSubscriptions, "f").size > 0) {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clearinghouseStateSubscriptions, "f").forEach((subscription, dexName) => {
+                subscription.unsubscribe().catch((error) => {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.clearAll'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'clearAll.clearinghouseState', {
+                        dex: dexName,
+                    }));
+                });
+            });
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clearinghouseStateSubscriptions, "f").clear();
+        }
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_openOrdersSubscriptions, "f").size > 0) {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_openOrdersSubscriptions, "f").forEach((subscription, dexName) => {
+                subscription.unsubscribe().catch((error) => {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.clearAll'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'clearAll.openOrders', {
+                        dex: dexName,
+                    }));
+                });
+            });
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_openOrdersSubscriptions, "f").clear();
+        }
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('HyperLiquid: Subscription service cleared (multi-DEX with individual subscriptions)', {
+            timestamp: new Date().toISOString(),
+        });
+    }
+}
+_HyperLiquidSubscriptionService_clientService = new WeakMap(), _HyperLiquidSubscriptionService_walletService = new WeakMap(), _HyperLiquidSubscriptionService_hip3Enabled = new WeakMap(), _HyperLiquidSubscriptionService_enabledDexs = new WeakMap(), _HyperLiquidSubscriptionService_allowlistMarkets = new WeakMap(), _HyperLiquidSubscriptionService_blocklistMarkets = new WeakMap(), _HyperLiquidSubscriptionService_discoveredDexNames = new WeakMap(), _HyperLiquidSubscriptionService_dexDiscoveryPromise = new WeakMap(), _HyperLiquidSubscriptionService_dexDiscoveryResolver = new WeakMap(), _HyperLiquidSubscriptionService_expectedDexs = new WeakMap(), _HyperLiquidSubscriptionService_initializedDexs = new WeakMap(), _HyperLiquidSubscriptionService_priceSubscribers = new WeakMap(), _HyperLiquidSubscriptionService_positionSubscribers = new WeakMap(), _HyperLiquidSubscriptionService_orderFillSubscribers = new WeakMap(), _HyperLiquidSubscriptionService_orderSubscribers = new WeakMap(), _HyperLiquidSubscriptionService_accountSubscribers = new WeakMap(), _HyperLiquidSubscriptionService_marketDataSubscribers = new WeakMap(), _HyperLiquidSubscriptionService_orderBookSubscribers = new WeakMap(), _HyperLiquidSubscriptionService_globalAllMidsSubscription = new WeakMap(), _HyperLiquidSubscriptionService_globalAllMidsPromise = new WeakMap(), _HyperLiquidSubscriptionService_globalActiveAssetSubscriptions = new WeakMap(), _HyperLiquidSubscriptionService_globalBboSubscriptions = new WeakMap(), _HyperLiquidSubscriptionService_orderFillSubscriptions = new WeakMap(), _HyperLiquidSubscriptionService_symbolSubscriberCounts = new WeakMap(), _HyperLiquidSubscriptionService_dexSubscriberCounts = new WeakMap(), _HyperLiquidSubscriptionService_webData3Subscriptions = new WeakMap(), _HyperLiquidSubscriptionService_webData3SubscriptionPromise = new WeakMap(), _HyperLiquidSubscriptionService_positionSubscriberCount = new WeakMap(), _HyperLiquidSubscriptionService_orderSubscriberCount = new WeakMap(), _HyperLiquidSubscriptionService_accountSubscriberCount = new WeakMap(), _HyperLiquidSubscriptionService_oiCapSubscriberCount = new WeakMap(), _HyperLiquidSubscriptionService_dexPositionsCache = new WeakMap(), _HyperLiquidSubscriptionService_dexOrdersCache = new WeakMap(), _HyperLiquidSubscriptionService_dexAccountCache = new WeakMap(), _HyperLiquidSubscriptionService_cachedPositions = new WeakMap(), _HyperLiquidSubscriptionService_cachedOrders = new WeakMap(), _HyperLiquidSubscriptionService_cachedAccount = new WeakMap(), _HyperLiquidSubscriptionService_ordersCacheInitialized = new WeakMap(), _HyperLiquidSubscriptionService_positionsCacheInitialized = new WeakMap(), _HyperLiquidSubscriptionService_oiCapSubscribers = new WeakMap(), _HyperLiquidSubscriptionService_cachedOICaps = new WeakMap(), _HyperLiquidSubscriptionService_cachedOICapsHash = new WeakMap(), _HyperLiquidSubscriptionService_oiCapsCacheInitialized = new WeakMap(), _HyperLiquidSubscriptionService_cachedPriceData = new WeakMap(), _HyperLiquidSubscriptionService_cachedFills = new WeakMap(), _HyperLiquidSubscriptionService_fillsCacheInitialized = new WeakMap(), _HyperLiquidSubscriptionService_assetCtxsSubscriptions = new WeakMap(), _HyperLiquidSubscriptionService_dexAssetCtxsCache = new WeakMap(), _HyperLiquidSubscriptionService_assetCtxsSubscriptionPromises = new WeakMap(), _HyperLiquidSubscriptionService_clearinghouseStateSubscriptions = new WeakMap(), _HyperLiquidSubscriptionService_openOrdersSubscriptions = new WeakMap(), _HyperLiquidSubscriptionService_pendingClearinghouseSubscriptions = new WeakMap(), _HyperLiquidSubscriptionService_pendingOpenOrdersSubscriptions = new WeakMap(), _HyperLiquidSubscriptionService_dexMetaCache = new WeakMap(), _HyperLiquidSubscriptionService_orderBookCache = new WeakMap(), _HyperLiquidSubscriptionService_marketDataCache = new WeakMap(), _HyperLiquidSubscriptionService_isClearing = new WeakMap(), _HyperLiquidSubscriptionService_deps = new WeakMap(), _HyperLiquidSubscriptionService_cachedPositionsHash = new WeakMap(), _HyperLiquidSubscriptionService_cachedOrdersHash = new WeakMap(), _HyperLiquidSubscriptionService_cachedAccountHash = new WeakMap(), _HyperLiquidSubscriptionService_instances = new WeakSet(), _HyperLiquidSubscriptionService_logErrorUnlessClearing = function _HyperLiquidSubscriptionService_logErrorUnlessClearing(error, context) {
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_isClearing, "f")) {
+        return;
+    }
+    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").logger.error(error, context);
+}, _HyperLiquidSubscriptionService_getErrorContext = function _HyperLiquidSubscriptionService_getErrorContext(method, extra) {
+    return {
+        tags: {
+            feature: PERPS_CONSTANTS.FeatureName,
+            provider: 'hyperliquid',
+            network: __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").isTestnetMode() ? 'testnet' : 'mainnet',
+        },
+        context: {
+            name: 'HyperLiquidSubscriptionService',
+            data: {
+                method,
+                ...extra,
+            },
+        },
+    };
+}, _HyperLiquidSubscriptionService_isDexEnabled = function _HyperLiquidSubscriptionService_isDexEnabled(dex) {
+    if (dex === null) {
+        return true; // Main DEX always enabled
+    }
+    if (!__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_hip3Enabled, "f")) {
+        return false; // HIP-3 disabled entirely
+    }
+    return __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_enabledDexs, "f").includes(dex);
+}, _HyperLiquidSubscriptionService_waitForDexDiscovery = 
+/**
+ * Wait for DEX discovery to complete (with timeout)
+ * Used when HIP-3 is enabled but enabledDexs hasn't been populated yet.
+ * This allows subscriptions to wait for DEX discovery before creating per-DEX subscriptions.
+ *
+ * @param timeoutMs - The maximum time in milliseconds to wait for DEX discovery.
+ */
+async function _HyperLiquidSubscriptionService_waitForDexDiscovery(timeoutMs = 5000) {
+    // Already have DEXs, no need to wait
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_enabledDexs, "f").length > 0) {
+        return;
+    }
+    // Create promise if not exists
+    if (!__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexDiscoveryPromise, "f")) {
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_dexDiscoveryPromise, new Promise((resolve) => {
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_dexDiscoveryResolver, resolve, "f");
+        }), "f");
+    }
+    // Wait with timeout
+    let timeoutId;
+    const timeoutPromise = new Promise((_resolve, reject) => {
+        timeoutId = setTimeout(() => reject(new Error('DEX discovery timeout')), timeoutMs);
+    });
+    try {
+        await Promise.race([__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexDiscoveryPromise, "f"), timeoutPromise]);
+    }
+    catch {
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('DEX discovery wait timed out, proceeding with main DEX only');
+    }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    }
+}, _HyperLiquidSubscriptionService_hashPositions = function _HyperLiquidSubscriptionService_hashPositions(positions) {
+    if (!positions || positions.length === 0) {
+        return '0';
+    }
+    return positions
+        .map((pos) => `${pos.symbol}:${pos.size}:${pos.entryPrice}:${pos.leverage.value}:${pos.takeProfitPrice ?? ''}:${pos.stopLossPrice ?? ''}:${pos.takeProfitCount}:${pos.stopLossCount}:${pos.unrealizedPnl}:${pos.returnOnEquity}:${pos.liquidationPrice ?? ''}:${pos.marginUsed || ''}`)
+        .join('|');
+}, _HyperLiquidSubscriptionService_hashOrders = function _HyperLiquidSubscriptionService_hashOrders(orders) {
+    if (!orders || orders.length === 0) {
+        return '0';
+    }
+    return orders
+        .map((ord) => `${ord.symbol}:${ord.side}:${ord.size}:${ord.price}:${ord.orderType}`)
+        .join('|');
+}, _HyperLiquidSubscriptionService_hashAccountState = function _HyperLiquidSubscriptionService_hashAccountState(account) {
+    return `${account.availableBalance}:${account.totalBalance}:${account.marginUsed}:${account.unrealizedPnl}`;
+}, _HyperLiquidSubscriptionService_extractTPSLFromOrders = function _HyperLiquidSubscriptionService_extractTPSLFromOrders(orders, positions, cachedProcessedOrders) {
+    const tpslMap = new Map();
+    const tpslCountMap = new Map();
+    // If cached processed orders provided, extract TP/SL from them directly
+    if (cachedProcessedOrders) {
+        cachedProcessedOrders.forEach((order) => {
+            // Use triggerPrice for TP/SL (trigger condition price), falling back to price
+            // This ensures consistency with raw SDK order processing which uses triggerPx
+            const tpslPrice = order.triggerPrice ?? order.price;
+            if (order.isTrigger && tpslPrice) {
+                const isTakeProfit = order.detailedOrderType?.includes('Take Profit');
+                const isStop = order.detailedOrderType?.includes('Stop');
+                const matchingPosition = positions.find((pos) => pos.symbol === order.symbol);
+                // Determine TP vs SL classification for count and price updates
+                // Use order type first, fallback to price-based detection for ambiguous 'Trigger' types
+                let classifiedAsTakeProfit = isTakeProfit;
+                let classifiedAsStop = isStop;
+                if (!isTakeProfit && !isStop && matchingPosition) {
+                    // Fallback: determine based on trigger price vs entry price
+                    // This handles orders with ambiguous type 'Trigger'
+                    const triggerPrice = parseFloat(tpslPrice);
+                    const entryPrice = parseFloat(matchingPosition.entryPrice || '0');
+                    const isLong = parseFloat(matchingPosition.size) > 0;
+                    if (isLong) {
+                        if (triggerPrice > entryPrice) {
+                            classifiedAsTakeProfit = true;
+                        }
+                        else {
+                            classifiedAsStop = true;
+                        }
+                    }
+                    else if (triggerPrice < entryPrice) {
+                        classifiedAsTakeProfit = true;
+                    }
+                    else {
+                        classifiedAsStop = true;
+                    }
+                }
+                const currentTakeProfitCount = tpslCountMap.get(order.symbol)?.takeProfitCount ?? 0;
+                const currentStopLossCount = tpslCountMap.get(order.symbol)?.stopLossCount ?? 0;
+                tpslCountMap.set(order.symbol, {
+                    takeProfitCount: classifiedAsTakeProfit
+                        ? currentTakeProfitCount + 1
+                        : currentTakeProfitCount,
+                    stopLossCount: classifiedAsStop
+                        ? currentStopLossCount + 1
+                        : currentStopLossCount,
+                });
+                if (matchingPosition) {
+                    const existing = tpslMap.get(order.symbol) ?? {};
+                    if (classifiedAsTakeProfit) {
+                        existing.takeProfitPrice = tpslPrice;
+                    }
+                    else if (classifiedAsStop) {
+                        existing.stopLossPrice = tpslPrice;
+                    }
+                    tpslMap.set(order.symbol, existing);
+                }
+            }
+        });
+        return { tpslMap, tpslCountMap, processedOrders: cachedProcessedOrders };
+    }
+    // Process raw SDK orders
+    const processedOrders = [];
+    orders.forEach((order) => {
+        let position;
+        let positionForCoin;
+        const matchPositionToTpsl = (pos) => {
+            if (TP_SL_CONFIG.UsePositionBoundTpsl) {
+                return (pos.symbol === order.coin &&
+                    order.reduceOnly &&
+                    order.isPositionTpsl);
+            }
+            return (pos.symbol === order.coin &&
+                Math.abs(parseFloat(order.sz)) >= Math.abs(parseFloat(pos.size)));
+        };
+        const matchPositionToCoin = (pos) => pos.symbol === order.coin;
+        // Process trigger orders for TP/SL extraction
+        if (order.triggerPx) {
+            const isTakeProfit = order.orderType?.includes('Take Profit');
+            const isStop = order.orderType?.includes('Stop');
+            const { coin } = order;
+            position = positions.find(matchPositionToTpsl);
+            positionForCoin = positions.find(matchPositionToCoin);
+            // Determine TP vs SL classification for count and price updates
+            // Use order type first, fallback to price-based detection for ambiguous 'Trigger' types
+            // This matches the cached order processing logic for consistency
+            let classifiedAsTakeProfit = isTakeProfit;
+            let classifiedAsStop = isStop;
+            if (!isTakeProfit && !isStop && position) {
+                // Fallback: determine based on trigger price vs entry price
+                // This handles orders with ambiguous type 'Trigger'
+                const triggerPrice = parseFloat(order.triggerPx);
+                const entryPrice = parseFloat(position.entryPrice || '0');
+                const isLong = parseFloat(position.size) > 0;
+                if (isLong) {
+                    if (triggerPrice > entryPrice) {
+                        classifiedAsTakeProfit = true;
+                    }
+                    else {
+                        classifiedAsStop = true;
+                    }
+                }
+                else if (triggerPrice < entryPrice) {
+                    classifiedAsTakeProfit = true;
+                }
+                else {
+                    classifiedAsStop = true;
+                }
+            }
+            const currentTakeProfitCount = tpslCountMap.get(coin)?.takeProfitCount ?? 0;
+            const currentStopLossCount = tpslCountMap.get(coin)?.stopLossCount ?? 0;
+            tpslCountMap.set(coin, {
+                takeProfitCount: classifiedAsTakeProfit
+                    ? currentTakeProfitCount + 1
+                    : currentTakeProfitCount,
+                stopLossCount: classifiedAsStop
+                    ? currentStopLossCount + 1
+                    : currentStopLossCount,
+            });
+            if (position) {
+                const existing = tpslMap.get(coin) ?? {};
+                // Use classified values for price assignment (consistent with count logic)
+                if (classifiedAsTakeProfit) {
+                    existing.takeProfitPrice = order.triggerPx;
+                }
+                else if (classifiedAsStop) {
+                    existing.stopLossPrice = order.triggerPx;
+                }
+                tpslMap.set(coin, existing);
+            }
+        }
+        // Convert ALL open orders to Order format
+        const convertedOrder = adaptOrderFromSDK(order, position ?? positionForCoin);
+        processedOrders.push(convertedOrder);
+    });
+    return { tpslMap, tpslCountMap, processedOrders };
+}, _HyperLiquidSubscriptionService_mergeTPSLIntoPositions = function _HyperLiquidSubscriptionService_mergeTPSLIntoPositions(positions, tpslMap, tpslCountMap) {
+    return positions.map((position) => {
+        const tpsl = tpslMap.get(position.symbol) ?? {};
+        const tpslCount = tpslCountMap.get(position.symbol) ?? {};
+        return {
+            ...position,
+            takeProfitPrice: tpsl.takeProfitPrice ?? undefined,
+            stopLossPrice: tpsl.stopLossPrice ?? undefined,
+            takeProfitCount: tpslCount.takeProfitCount ?? 0,
+            stopLossCount: tpslCount.stopLossCount ?? 0,
+        };
+    });
+}, _HyperLiquidSubscriptionService_aggregateAccountStates = function _HyperLiquidSubscriptionService_aggregateAccountStates() {
+    const subAccountBreakdown = {};
+    let totalAvailableBalance = 0;
+    let totalBalance = 0;
+    let totalMarginUsed = 0;
+    let totalUnrealizedPnl = 0;
+    // Collect account states for weighted ROE calculation
+    const accountStatesForROE = [];
+    // Aggregate all cached account states
+    Array.from(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAccountCache, "f").entries()).forEach(([currentDex, state]) => {
+        const dexKey = currentDex === '' ? 'main' : currentDex;
+        subAccountBreakdown[dexKey] = {
+            availableBalance: state.availableBalance,
+            totalBalance: state.totalBalance,
+        };
+        totalAvailableBalance += parseFloat(state.availableBalance);
+        totalBalance += parseFloat(state.totalBalance);
+        totalMarginUsed += parseFloat(state.marginUsed);
+        totalUnrealizedPnl += parseFloat(state.unrealizedPnl);
+        // Collect data for weighted ROE calculation
+        accountStatesForROE.push({
+            unrealizedPnl: state.unrealizedPnl,
+            returnOnEquity: state.returnOnEquity,
+        });
+    });
+    // Use first DEX's account state as base and override aggregated values
+    const firstDexAccount = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAccountCache, "f").values().next().value ?? {};
+    // Calculate weighted returnOnEquity across all DEXs
+    const returnOnEquity = calculateWeightedReturnOnEquity(accountStatesForROE);
+    return {
+        ...firstDexAccount,
+        availableBalance: totalAvailableBalance.toString(),
+        totalBalance: totalBalance.toString(),
+        marginUsed: totalMarginUsed.toString(),
+        unrealizedPnl: totalUnrealizedPnl.toString(),
+        subAccountBreakdown,
+        returnOnEquity,
+    };
+}, _HyperLiquidSubscriptionService_ensureSharedWebData3Subscription = 
+/**
+ * Ensure shared webData3 subscription is active (singleton pattern with multi-DEX support)
+ * webData3 provides data for all DEXs (main + HIP-3) in a single subscription
+ *
+ * @param accountId - Optional CAIP account ID to subscribe for.
+ */
+async function _HyperLiquidSubscriptionService_ensureSharedWebData3Subscription(accountId) {
+    // Establish webData3 subscription (if not exists)
+    if (!__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_webData3Subscriptions, "f").has('')) {
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_webData3SubscriptionPromise, "f")) {
+            await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_webData3SubscriptionPromise, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_webData3SubscriptionPromise, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createUserDataSubscription).call(this, accountId), "f");
+            try {
+                await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_webData3SubscriptionPromise, "f");
+            }
+            catch (error) {
+                __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_webData3SubscriptionPromise, undefined, "f");
+                throw error;
+            }
+        }
+    }
+    // Note: webData3 includes all DEX data, so no separate HIP-3 subscriptions needed
+}, _HyperLiquidSubscriptionService_createUserDataSubscription = 
+/**
+ * Create WebSocket subscription for user data (positions, orders, account)
+ * - Uses webData2 when HIP-3 disabled (main DEX only)
+ * - Uses webData3 when HIP-3 enabled (main + HIP-3 DEXs)
+ *
+ * webData2 provides data for main DEX only
+ * webData3 provides perpDexStates[] array containing data for all DEXs:
+ * - Index 0: Main DEX (dexName = '')
+ * - Index 1+: HIP-3 DEXs in order of enabledDexs array
+ *
+ * @param accountId - Optional CAIP account ID to subscribe for.
+ * @returns A promise that resolves when the operation completes.
+ */
+async function _HyperLiquidSubscriptionService_createUserDataSubscription(accountId) {
+    await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").ensureSubscriptionClient(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_walletService, "f").createWalletAdapter());
+    const subscriptionClient = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").getSubscriptionClient();
+    if (!subscriptionClient) {
+        throw new Error('Subscription client not initialized');
+    }
+    const userAddress = await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_walletService, "f").getUserAddressWithDefault(accountId);
+    const dexName = ''; // Use empty string as key for single subscription
+    // Skip if subscription already exists
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_webData3Subscriptions, "f").has(dexName)) {
+        return undefined;
+    }
+    // Wait for DEX discovery if HIP-3 is enabled but DEXs haven't been discovered yet
+    // This ensures HIP-3 subscriptions are created together with main DEX
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_hip3Enabled, "f") && __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_enabledDexs, "f").length === 0) {
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('Waiting for DEX discovery before creating subscriptions...');
+        await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_waitForDexDiscovery).call(this);
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('DEX discovery complete, proceeding with subscriptions', {
+            enabledDexs: __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_enabledDexs, "f"),
+        });
+    }
+    return new Promise((resolve, reject) => {
+        // Choose channel based on HIP-3 master switch
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_hip3Enabled, "f")) {
+            // HIP-3 enabled: Use individual subscriptions for positions/orders/account
+            // webData3 is only used for OI caps extraction
+            // Determine which DEXs to subscribe to
+            const dexsToSubscribe = [
+                '', // Main DEX
+                ...__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_enabledDexs, "f").filter((dexId) => __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_isDexEnabled).call(this, dexId)),
+            ];
+            // Track expected DEXs for synchronized notifications
+            // Clear previous tracking and set new expected DEXs
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_expectedDexs, new Set(dexsToSubscribe), "f");
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_initializedDexs, new Set(), "f");
+            // Set up individual subscriptions for each DEX
+            const subscriptionPromises = [];
+            for (const currentDexName of dexsToSubscribe) {
+                // Set up clearinghouseState subscription for positions + account
+                subscriptionPromises.push(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureClearinghouseStateSubscription).call(this, userAddress, currentDexName));
+                // Set up openOrders subscription for orders
+                subscriptionPromises.push(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureOpenOrdersSubscription).call(this, userAddress, currentDexName));
+            }
+            // Also set up webData3 for OI caps only
+            const webData3Promise = subscriptionClient
+                .webData3({ user: userAddress }, (data) => {
+                try {
+                    // webData3 is ONLY used for OI caps extraction
+                    // Positions, orders, and account data come from individual subscriptions
+                    const allOICaps = [];
+                    data.perpDexStates.forEach((dexState, index) => {
+                        // Map webData3 index to DEX name
+                        // Index 0 = main DEX (null), Index 1+ = HIP-3 DEXs from discoveredDexNames
+                        const dexIdentifier = index === 0 ? null : __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_discoveredDexNames, "f")[index - 1];
+                        // Skip unknown DEXs (not in discoveredDexNames) to prevent main DEX cache corruption
+                        if (index > 0 && dexIdentifier === undefined) {
+                            return; // Unknown DEX - skip to prevent misidentifying as main DEX
+                        }
+                        // Only process DEXs we care about (skip others silently)
+                        if (!__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_isDexEnabled).call(this, dexIdentifier ?? null)) {
+                            return; // Skip this DEX - not enabled in our configuration
+                        }
+                        const currentDexName = dexIdentifier ?? '';
+                        const oiCaps = dexState.perpsAtOpenInterestCap ?? [];
+                        // Add DEX prefix for HIP-3 symbols (e.g., "xyz:TSLA")
+                        if (currentDexName) {
+                            allOICaps.push(...oiCaps.map((symbol) => `${currentDexName}:${symbol}`));
+                        }
+                        else {
+                            // Main DEX - no prefix needed
+                            allOICaps.push(...oiCaps);
+                        }
+                    });
+                    // Update OI caps cache and notify if changed
+                    const oiCapsHash = [...allOICaps]
+                        .sort((a, b) => a.localeCompare(b))
+                        .join(',');
+                    if (oiCapsHash !== __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedOICapsHash, "f")) {
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedOICaps, allOICaps, "f");
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedOICapsHash, oiCapsHash, "f");
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_oiCapsCacheInitialized, true, "f");
+                        // Notify all subscribers
+                        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_oiCapSubscribers, "f").forEach((callback) => callback(allOICaps));
+                    }
+                }
+                catch (error) {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.createUserDataSubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'webData3 callback error', {
+                        user: userAddress,
+                        hasPerpDexStates: data?.perpDexStates !== undefined,
+                        perpDexStatesLength: data?.perpDexStates?.length ?? 0,
+                    }));
+                }
+            })
+                .then((sub) => {
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_webData3Subscriptions, "f").set(dexName, sub);
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`webData3 subscription established for OI caps (main + HIP-3)`);
+                return undefined;
+            })
+                .catch((error) => {
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.createUserDataSubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'createUserDataSubscription (webData3)', {
+                    dex: dexName,
+                }));
+                throw error;
+            });
+            subscriptionPromises.push(webData3Promise);
+            // Wait for all subscriptions to be established
+            Promise.all(subscriptionPromises)
+                .then(() => {
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`HIP-3 user data subscriptions established for ${dexsToSubscribe.length} DEXs`);
+                resolve();
+                return undefined;
+            })
+                .catch((error) => {
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.createUserDataSubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'createUserDataSubscription (HIP-3)', {
+                    dexs: dexsToSubscribe,
+                }));
+                reject(ensureError(error, 'HyperLiquidSubscriptionService.createUserDataSubscription'));
+            });
+        }
+        else {
+            // HIP-3 disabled: Use webData2 (main DEX only)
+            subscriptionClient
+                .webData2({ user: userAddress }, (data) => {
+                try {
+                    // webData2 returns clearinghouseState for main DEX only
+                    const currentDexName = ''; // Main DEX
+                    // Check for removed fields before accessing
+                    if (!data.clearinghouseState) {
+                        return;
+                    }
+                    // Extract and process positions from clearinghouseState
+                    const positions = data.clearinghouseState.assetPositions
+                        .filter((assetPos) => assetPos.position.szi !== '0')
+                        .map((assetPos) => adaptPositionFromSDK(assetPos));
+                    // Extract TP/SL from orders
+                    const { tpslMap, tpslCountMap, processedOrders: orders, } = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_extractTPSLFromOrders).call(this, data.openOrders || [], positions);
+                    // Merge TP/SL data into positions
+                    const positionsWithTPSL = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_mergeTPSLIntoPositions).call(this, positions, tpslMap, tpslCountMap);
+                    // Extract account data (webData2 provides clearinghouseState)
+                    const accountState = adaptAccountStateFromSDK(data.clearinghouseState, undefined);
+                    // Store in caches (main DEX only)
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").set(currentDexName, positionsWithTPSL);
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexOrdersCache, "f").set(currentDexName, orders);
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAccountCache, "f").set(currentDexName, accountState);
+                    // OI caps (main DEX only)
+                    const oiCaps = data.perpsAtOpenInterestCap ?? [];
+                    const oiCapsHash = [...oiCaps]
+                        .sort((a, b) => a.localeCompare(b))
+                        .join(',');
+                    if (oiCapsHash !== __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedOICapsHash, "f")) {
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedOICaps, oiCaps, "f");
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedOICapsHash, oiCapsHash, "f");
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_oiCapsCacheInitialized, true, "f");
+                        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_oiCapSubscribers, "f").forEach((callback) => callback(oiCaps));
+                    }
+                    // Notify subscribers (no aggregation needed - only main DEX)
+                    const positionsHash = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_hashPositions).call(this, positionsWithTPSL);
+                    const ordersHash = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_hashOrders).call(this, orders);
+                    const accountHash = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_hashAccountState).call(this, accountState);
+                    if (positionsHash !== __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPositionsHash, "f")) {
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedPositions, positionsWithTPSL, "f");
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedPositionsHash, positionsHash, "f");
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_positionsCacheInitialized, true, "f");
+                        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionSubscribers, "f").forEach((callback) => callback(positionsWithTPSL));
+                    }
+                    if (ordersHash !== __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedOrdersHash, "f")) {
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedOrders, orders, "f");
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedOrdersHash, ordersHash, "f");
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_ordersCacheInitialized, true, "f");
+                        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderSubscribers, "f").forEach((callback) => callback(orders));
+                    }
+                    if (accountHash !== __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedAccountHash, "f")) {
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedAccount, accountState, "f");
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedAccountHash, accountHash, "f");
+                        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_accountSubscribers, "f").forEach((callback) => callback(accountState));
+                    }
+                }
+                catch (error) {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.createUserDataSubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'webData2 callback error', {
+                        user: userAddress,
+                        dataKeys: data ? Object.keys(data) : 'data is null/undefined',
+                        hasClearinghouseState: data?.clearinghouseState !== undefined,
+                        hasOpenOrders: data?.openOrders !== undefined,
+                        hasPerpsAtOpenInterestCap: data?.perpsAtOpenInterestCap !== undefined,
+                    }));
+                }
+            })
+                .then((subscription) => {
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_webData3Subscriptions, "f").set(dexName, subscription);
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('webData2 subscription established for main DEX only');
+                resolve();
+                return undefined;
+            })
+                .catch((error) => {
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.createUserDataSubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'createUserDataSubscription (webData2)', {
+                    dex: dexName,
+                }));
+                reject(ensureError(error, 'HyperLiquidSubscriptionService.createUserDataSubscription'));
+            });
+        }
+    });
+}, _HyperLiquidSubscriptionService_ensureClearinghouseStateSubscription = 
+/**
+ * Ensure clearinghouseState subscription exists for a DEX
+ * Uses pending promise tracking to prevent race conditions where multiple
+ * concurrent calls could create duplicate subscriptions
+ *
+ * @param userAddress - The user's wallet address.
+ * @param dexName - The DEX identifier (empty string for main DEX).
+ * @returns A promise that resolves when the subscription is established.
+ */
+async function _HyperLiquidSubscriptionService_ensureClearinghouseStateSubscription(userAddress, dexName) {
+    // Already subscribed
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clearinghouseStateSubscriptions, "f").has(dexName)) {
+        return;
+    }
+    // Another call is already in progress - wait for it instead of creating duplicate
+    const pending = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_pendingClearinghouseSubscriptions, "f").get(dexName);
+    if (pending) {
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`[ensureClearinghouseStateSubscription] Waiting for pending subscription for DEX: ${dexName || 'main'}`);
+        await pending;
+        return;
+    }
+    // Create subscription promise and track it
+    const subscriptionPromise = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createClearinghouseSubscription).call(this, userAddress, dexName);
+    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_pendingClearinghouseSubscriptions, "f").set(dexName, subscriptionPromise);
+    try {
+        await subscriptionPromise;
+    }
+    finally {
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_pendingClearinghouseSubscriptions, "f").delete(dexName);
+    }
+}, _HyperLiquidSubscriptionService_createClearinghouseSubscription = 
+/**
+ * Create the actual clearinghouseState subscription
+ * Separated from ensureClearinghouseStateSubscription to enable promise deduplication
+ *
+ * @param userAddress - The user's wallet address.
+ * @param dexName - The DEX identifier (empty string for main DEX).
+ */
+async function _HyperLiquidSubscriptionService_createClearinghouseSubscription(userAddress, dexName) {
+    await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").ensureSubscriptionClient(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_walletService, "f").createWalletAdapter());
+    const subscriptionClient = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").getSubscriptionClient();
+    if (!subscriptionClient) {
+        throw new Error('Subscription client not available');
+    }
+    try {
+        const subscription = await subscriptionClient.clearinghouseState({
+            user: userAddress,
+            dex: dexName || undefined, // Empty string -> undefined for main DEX
+        }, (data) => {
+            const cacheKey = data.dex || '';
+            // Update caches and notify subscribers if we have positions/account subscribers
+            if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionSubscriberCount, "f") > 0 ||
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_accountSubscriberCount, "f") > 0) {
+                // Process positions from clearinghouse state
+                const positions = data.clearinghouseState.assetPositions
+                    .filter((assetPos) => assetPos.position.szi !== '0')
+                    .map((assetPos) => adaptPositionFromSDK(assetPos));
+                // Get cached orders to preserve TP/SL data (prevents flickering)
+                // Orders are cached by openOrders subscription
+                const cachedOrders = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexOrdersCache, "f").get(cacheKey) ?? [];
+                // Re-extract TP/SL from cached orders for the new positions
+                // This ensures TP/SL data persists across clearinghouseState updates
+                let positionsWithTPSL = positions;
+                if (cachedOrders.length > 0) {
+                    const { tpslMap, tpslCountMap } = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_extractTPSLFromOrders).call(this, [], positions, cachedOrders);
+                    positionsWithTPSL = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_mergeTPSLIntoPositions).call(this, positions, tpslMap, tpslCountMap);
+                }
+                // Update account state
+                const accountState = adaptAccountStateFromSDK(data.clearinghouseState, undefined);
+                // Update caches
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").set(cacheKey, positionsWithTPSL);
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAccountCache, "f").set(cacheKey, accountState);
+                // Mark this DEX as initialized (has sent first data)
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_initializedDexs, "f").add(cacheKey);
+                // Trigger aggregation and notify subscribers
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_aggregateAndNotifySubscribers).call(this);
+            }
+        });
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clearinghouseStateSubscriptions, "f").set(dexName, subscription);
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`clearinghouseState subscription established for DEX: ${dexName || 'main'}`);
+    }
+    catch (error) {
+        // Remove this DEX from expected set so it doesn't block notifications for other DEXs
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_expectedDexs, "f").delete(dexName);
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.createClearinghouseSubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'ensureClearinghouseStateSubscription', {
+            dex: dexName,
+        }));
+        throw error;
+    }
+}, _HyperLiquidSubscriptionService_ensureOpenOrdersSubscription = 
+/**
+ * Ensure openOrders subscription exists for a DEX
+ * Uses pending promise tracking to prevent race conditions where multiple
+ * concurrent calls could create duplicate subscriptions
+ *
+ * @param userAddress - The user's wallet address.
+ * @param dexName - The DEX identifier (empty string for main DEX).
+ * @returns A promise that resolves when the subscription is established.
+ */
+async function _HyperLiquidSubscriptionService_ensureOpenOrdersSubscription(userAddress, dexName) {
+    // Already subscribed
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_openOrdersSubscriptions, "f").has(dexName)) {
+        return;
+    }
+    // Another call is already in progress - wait for it instead of creating duplicate
+    const pending = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_pendingOpenOrdersSubscriptions, "f").get(dexName);
+    if (pending) {
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`[ensureOpenOrdersSubscription] Waiting for pending subscription for DEX: ${dexName || 'main'}`);
+        await pending;
+        return;
+    }
+    // Create subscription promise and track it
+    const subscriptionPromise = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createOpenOrdersSubscription).call(this, userAddress, dexName);
+    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_pendingOpenOrdersSubscriptions, "f").set(dexName, subscriptionPromise);
+    try {
+        await subscriptionPromise;
+    }
+    finally {
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_pendingOpenOrdersSubscriptions, "f").delete(dexName);
+    }
+}, _HyperLiquidSubscriptionService_createOpenOrdersSubscription = 
+/**
+ * Create the actual openOrders subscription
+ * Separated from ensureOpenOrdersSubscription to enable promise deduplication
+ *
+ * @param userAddress - The user's wallet address.
+ * @param dexName - The DEX identifier (empty string for main DEX).
+ */
+async function _HyperLiquidSubscriptionService_createOpenOrdersSubscription(userAddress, dexName) {
+    await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").ensureSubscriptionClient(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_walletService, "f").createWalletAdapter());
+    const subscriptionClient = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").getSubscriptionClient();
+    if (!subscriptionClient) {
+        throw new Error('Subscription client not available');
+    }
+    try {
+        const subscription = await subscriptionClient.openOrders({
+            user: userAddress,
+            dex: dexName || undefined, // Empty string -> undefined for main DEX
+        }, (data) => {
+            const cacheKey = data.dex || '';
+            // Update caches and notify subscribers if we have order subscribers
+            if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderSubscriberCount, "f") > 0 ||
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionSubscriberCount, "f") > 0) {
+                // Get cached positions for TP/SL processing
+                const cachedPositions = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").get(cacheKey) ?? [];
+                // Extract TP/SL and process orders
+                const { tpslMap, tpslCountMap, processedOrders: orders, } = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_extractTPSLFromOrders).call(this, data.orders, cachedPositions);
+                // Update orders cache with processed orders
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexOrdersCache, "f").set(cacheKey, orders);
+                // Update positions with TP/SL if we have positions
+                if (cachedPositions.length > 0) {
+                    const positionsWithTPSL = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_mergeTPSLIntoPositions).call(this, cachedPositions, tpslMap, tpslCountMap);
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").set(cacheKey, positionsWithTPSL);
+                }
+                // Mark this DEX as initialized (has sent first data)
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_initializedDexs, "f").add(cacheKey);
+                // Trigger aggregation and notify subscribers
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_aggregateAndNotifySubscribers).call(this);
+            }
+        });
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_openOrdersSubscriptions, "f").set(dexName, subscription);
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`openOrders subscription established for DEX: ${dexName || 'main'}`);
+    }
+    catch (error) {
+        // Remove this DEX from expected set so it doesn't block notifications for other DEXs
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_expectedDexs, "f").delete(dexName);
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.createOpenOrdersSubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'ensureOpenOrdersSubscription', {
+            dex: dexName,
+        }));
+        throw error;
+    }
+}, _HyperLiquidSubscriptionService_aggregateAndNotifySubscribers = function _HyperLiquidSubscriptionService_aggregateAndNotifySubscribers() {
+    // Wait for all expected DEXs to send initial data before notifying
+    // This ensures positions from all DEXs appear simultaneously
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_expectedDexs, "f").size > 0) {
+        const allDexsInitialized = Array.from(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_expectedDexs, "f")).every((dex) => __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_initializedDexs, "f").has(dex));
+        if (!allDexsInitialized) {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('Waiting for all DEXs to send initial data', {
+                expected: Array.from(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_expectedDexs, "f")),
+                initialized: Array.from(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_initializedDexs, "f")),
+            });
+            return; // Don't notify yet - waiting for more DEXs
+        }
+    }
+    // Aggregate data from all DEX caches
+    // Order: Main DEX (crypto perps) first, then HIP-3 DEXs
+    const mainDexPositions = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").get('') ?? [];
+    const hip3DexPositions = Array.from(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").entries())
+        .filter(([key]) => key !== '')
+        .flatMap(([, positions]) => positions);
+    const aggregatedPositions = [...mainDexPositions, ...hip3DexPositions];
+    const mainDexOrders = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexOrdersCache, "f").get('') ?? [];
+    const hip3DexOrders = Array.from(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexOrdersCache, "f").entries())
+        .filter(([key]) => key !== '')
+        .flatMap(([, orders]) => orders);
+    const aggregatedOrders = [...mainDexOrders, ...hip3DexOrders];
+    const aggregatedAccount = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_aggregateAccountStates).call(this);
+    // Check if aggregated data changed using fast hash comparison
+    const positionsHash = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_hashPositions).call(this, aggregatedPositions);
+    const ordersHash = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_hashOrders).call(this, aggregatedOrders);
+    const accountHash = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_hashAccountState).call(this, aggregatedAccount);
+    const positionsChanged = positionsHash !== __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPositionsHash, "f");
+    const ordersChanged = ordersHash !== __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedOrdersHash, "f");
+    const accountChanged = accountHash !== __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedAccountHash, "f");
+    // Only notify subscribers if aggregated data changed
+    if (positionsChanged) {
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedPositions, aggregatedPositions, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedPositionsHash, positionsHash, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_positionsCacheInitialized, true, "f"); // Mark cache as initialized
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionSubscribers, "f").forEach((callback) => {
+            callback(aggregatedPositions);
+        });
+    }
+    if (ordersChanged) {
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedOrders, aggregatedOrders, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedOrdersHash, ordersHash, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_ordersCacheInitialized, true, "f"); // Mark cache as initialized
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderSubscribers, "f").forEach((callback) => {
+            callback(aggregatedOrders);
+        });
+    }
+    if (accountChanged) {
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedAccount, aggregatedAccount, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedAccountHash, accountHash, "f");
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_accountSubscribers, "f").forEach((callback) => {
+            callback(aggregatedAccount);
+        });
+    }
+}, _HyperLiquidSubscriptionService_cleanupSharedWebData3ISubscription = function _HyperLiquidSubscriptionService_cleanupSharedWebData3ISubscription() {
+    const totalSubscribers = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_positionSubscriberCount, "f") +
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderSubscriberCount, "f") +
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_accountSubscriberCount, "f") +
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_oiCapSubscriberCount, "f");
+    if (totalSubscribers <= 0) {
+        // Cleanup webData3 subscription (covers all DEXs)
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_webData3Subscriptions, "f").size > 0) {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_webData3Subscriptions, "f").forEach((subscription, dexName) => {
+                subscription.unsubscribe().catch((error) => {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.cleanupSharedWebData3ISubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'cleanupSharedWebData3ISubscription.webData3', {
+                        dex: dexName,
+                    }));
+                });
+            });
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_webData3Subscriptions, "f").clear();
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_webData3SubscriptionPromise, undefined, "f");
+        }
+        // Cleanup individual subscriptions (clearinghouseState + openOrders)
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clearinghouseStateSubscriptions, "f").size > 0) {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clearinghouseStateSubscriptions, "f").forEach((subscription, dexName) => {
+                subscription.unsubscribe().catch((error) => {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.cleanupSharedWebData3ISubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'cleanupSharedWebData3ISubscription.clearinghouseState', {
+                        dex: dexName,
+                    }));
+                });
+            });
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clearinghouseStateSubscriptions, "f").clear();
+        }
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_openOrdersSubscriptions, "f").size > 0) {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_openOrdersSubscriptions, "f").forEach((subscription, dexName) => {
+                subscription.unsubscribe().catch((error) => {
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.cleanupSharedWebData3ISubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'cleanupSharedWebData3ISubscription.openOrders', {
+                        dex: dexName,
+                    }));
+                });
+            });
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_openOrdersSubscriptions, "f").clear();
+        }
+        // Clear pending subscription promises (race condition prevention)
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_pendingClearinghouseSubscriptions, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_pendingOpenOrdersSubscriptions, "f").clear();
+        // Clear subscriber counts
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_positionSubscriberCount, 0, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_orderSubscriberCount, 0, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_accountSubscriberCount, 0, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_oiCapSubscriberCount, 0, "f");
+        // Clear per-DEX caches
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexPositionsCache, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexOrdersCache, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAccountCache, "f").clear();
+        // Clear DEX tracking for synchronized notifications
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_expectedDexs, "f").clear();
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_initializedDexs, "f").clear();
+        // Clear aggregated caches
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedPositions, null, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedOrders, null, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedAccount, null, "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_ordersCacheInitialized, false, "f"); // Reset cache initialization flag
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_positionsCacheInitialized, false, "f"); // Reset cache initialization flag
+        // Clear hash caches
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedPositionsHash, '', "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedOrdersHash, '', "f");
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedAccountHash, '', "f");
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('All multi-DEX subscriptions cleaned up (webData2/3 + individual subscriptions)');
+    }
+}, _HyperLiquidSubscriptionService_ensureOrderFillISubscription = 
+/**
+ * Ensure order fill subscription is active for the given accountId
+ * Shares subscription across all callbacks for the same accountId
+ *
+ * @param accountId - Optional CAIP account ID to subscribe for.
+ * @returns A promise that resolves when the subscription is established.
+ */
+async function _HyperLiquidSubscriptionService_ensureOrderFillISubscription(accountId) {
+    // Normalize accountId: undefined -> 'default' for Map key
+    const normalizedAccountId = accountId ?? 'default';
+    // If subscription already exists, no need to create another
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscriptions, "f").has(normalizedAccountId)) {
+        return;
+    }
+    const subscriptionClient = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").getSubscriptionClient();
+    if (!subscriptionClient) {
+        await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").ensureSubscriptionClient(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_walletService, "f").createWalletAdapter());
+        const client = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").getSubscriptionClient();
+        if (!client) {
+            throw new Error('SubscriptionClient not available');
+        }
+        await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_ensureOrderFillISubscription).call(this, accountId);
+        return;
+    }
+    const userAddress = await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_walletService, "f").getUserAddressWithDefault(accountId);
+    // userFills returns a Promise<ISubscription>, need to await it
+    const subscription = await subscriptionClient.userFills({ user: userAddress }, (data) => {
+        const orderFills = data.fills.map((fill) => ({
+            orderId: fill.oid.toString(),
+            symbol: fill.coin,
+            side: fill.side,
+            size: fill.sz,
+            price: fill.px,
+            fee: fill.fee,
+            timestamp: fill.time,
+            pnl: fill.closedPnl,
+            direction: fill.dir,
+            feeToken: fill.feeToken,
+            startPosition: fill.startPosition,
+            liquidation: fill.liquidation
+                ? {
+                    liquidatedUser: fill.liquidation.liquidatedUser,
+                    markPx: fill.liquidation.markPx,
+                    method: fill.liquidation.method,
+                }
+                : undefined,
+        }));
+        // Cache fills for cache-first pattern (similar to price caching)
+        // This allows getOrFetchFills() to return cached data without REST API calls
+        if (data.isSnapshot) {
+            // Snapshot: replace cache with initial historical data, sorted newest first
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedFills, [...orderFills]
+                .sort((a, b) => b.timestamp - a.timestamp)
+                .slice(0, 100), "f");
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_fillsCacheInitialized, true, "f");
+        }
+        else {
+            // Streaming: prepend new fills to existing (newest first)
+            __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedFills, [
+                ...orderFills,
+                ...(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedFills, "f") ?? []),
+            ].slice(0, 100), "f");
+        }
+        // Distribute to all callbacks for this accountId
+        const subscribers = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscribers, "f").get(normalizedAccountId);
+        if (subscribers) {
+            subscribers.forEach((callback) => {
+                callback(orderFills, data.isSnapshot);
+            });
+        }
+    });
+    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderFillSubscriptions, "f").set(normalizedAccountId, subscription);
+}, _HyperLiquidSubscriptionService_createSubscription = function _HyperLiquidSubscriptionService_createSubscription(subscribers, callback, key) {
+    if (subscribers instanceof Map && key) {
+        if (!subscribers.has(key)) {
+            subscribers.set(key, new Set());
+        }
+        subscribers.get(key)?.add(callback);
+    }
+    else if (subscribers instanceof Set) {
+        subscribers.add(callback);
+    }
+    return () => {
+        if (subscribers instanceof Map && key) {
+            const set = subscribers.get(key);
+            set?.delete(callback);
+            if (set?.size === 0) {
+                subscribers.delete(key);
+            }
+        }
+        else if (subscribers instanceof Set) {
+            subscribers.delete(callback);
+        }
+    };
+}, _HyperLiquidSubscriptionService_createPriceUpdate = function _HyperLiquidSubscriptionService_createPriceUpdate(symbol, price) {
+    const marketData = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataCache, "f").get(symbol);
+    const orderBookData = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderBookCache, "f").get(symbol);
+    const currentPrice = parseFloat(price);
+    let percentChange24h;
+    if (marketData?.prevDayPx !== undefined) {
+        const change = ((currentPrice - marketData.prevDayPx) / marketData.prevDayPx) * 100;
+        percentChange24h = change.toFixed(2);
+    }
+    // Check if any subscriber for this symbol wants market data
+    const hasMarketDataSubscribers = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataSubscribers, "f").has(symbol) &&
+        (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataSubscribers, "f").get(symbol)?.size ?? 0) > 0;
+    const priceUpdate = {
+        symbol,
+        price, // This is the mid price from allMids
+        timestamp: Date.now(),
+        percentChange24h,
+        // Add mark price from activeAssetCtx
+        markPrice: marketData?.oraclePrice
+            ? marketData.oraclePrice.toString()
+            : undefined,
+        // Add order book data if available
+        bestBid: orderBookData?.bestBid,
+        bestAsk: orderBookData?.bestAsk,
+        spread: orderBookData?.spread,
+        // Always include funding when available (don't default to 0, preserve undefined)
+        funding: marketData?.funding,
+        // Add market data only if requested by at least one subscriber
+        openInterest: hasMarketDataSubscribers
+            ? marketData?.openInterest
+            : undefined,
+        volume24h: hasMarketDataSubscribers ? marketData?.volume24h : undefined,
+    };
+    return priceUpdate;
+}, _HyperLiquidSubscriptionService_ensureGlobalAllMidsSubscription = function _HyperLiquidSubscriptionService_ensureGlobalAllMidsSubscription() {
+    // Check both the subscription AND the promise to prevent race conditions
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalAllMidsSubscription, "f") ?? __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalAllMidsPromise, "f")) {
+        return;
+    }
+    const subscriptionClient = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").getSubscriptionClient();
+    if (!subscriptionClient) {
+        return;
+    }
+    // Track WebSocket metrics
+    const wsMetrics = {
+        messagesReceived: 0,
+        lastMessageTime: Date.now(),
+        reconnectCount: 0,
+        startTime: Date.now(),
+    };
+    // Store the promise immediately to prevent duplicate calls
+    __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_globalAllMidsPromise, subscriptionClient
+        .allMids((data) => {
+        wsMetrics.messagesReceived += 1;
+        wsMetrics.lastMessageTime = Date.now();
+        // Initialize cache if needed
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedPriceData, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f") ?? new Map(), "f");
+        const subscribedSymbols = new Set();
+        // Collect all symbols that have subscribers
+        for (const [symbol, subscriberSet,] of __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_priceSubscribers, "f").entries()) {
+            if (subscriberSet.size > 0) {
+                subscribedSymbols.add(symbol);
+            }
+        }
+        // Track if any subscribed symbol was updated
+        let hasUpdates = false;
+        // Only process symbols that are actually subscribed to
+        for (const symbol in data.mids) {
+            // Skip if nobody is subscribed to this symbol
+            if (!subscribedSymbols.has(symbol)) {
+                continue;
+            }
+            const price = data.mids[symbol].toString();
+            const cachedPrice = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f").get(symbol);
+            // Skip if price hasn't changed
+            if (cachedPrice?.price === price) {
+                continue;
+            }
+            // Price changed or new symbol - update cache
+            const priceUpdate = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createPriceUpdate).call(this, symbol, price);
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f").set(symbol, priceUpdate);
+            hasUpdates = true;
+        }
+        // Only notify subscribers if we actually have updates
+        // This prevents unnecessary React re-renders when prices haven't changed
+        if (hasUpdates) {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_notifyAllPriceSubscribers).call(this);
+        }
+    })
+        .then((sub) => {
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_globalAllMidsSubscription, sub, "f");
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log('HyperLiquid: Global allMids subscription established');
+        // Notify existing subscribers with any cached data now that subscription is established
+        if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f") && __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f").size > 0) {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_notifyAllPriceSubscribers).call(this);
+        }
+        return undefined;
+    })
+        .catch((error) => {
+        // Clear the promise on error so it can be retried
+        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_globalAllMidsPromise, undefined, "f");
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.ensureGlobalAllMidsSubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'ensureGlobalAllMidsSubscription'));
+    }), "f");
+}, _HyperLiquidSubscriptionService_ensureActiveAssetSubscription = function _HyperLiquidSubscriptionService_ensureActiveAssetSubscription(symbol) {
+    // Increment subscriber count
+    const currentCount = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_symbolSubscriberCounts, "f").get(symbol) ?? 0;
+    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_symbolSubscriberCounts, "f").set(symbol, currentCount + 1);
+    // If subscription already exists, just return
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalActiveAssetSubscriptions, "f").has(symbol)) {
+        return;
+    }
+    const subscriptionClient = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").getSubscriptionClient();
+    if (!subscriptionClient) {
+        return;
+    }
+    // Track metrics for this subscription
+    const subscriptionMetrics = {
+        messagesReceived: 0,
+        startTime: Date.now(),
+    };
+    subscriptionClient
+        .activeAssetCtx({ coin: symbol }, (data) => {
+        subscriptionMetrics.messagesReceived += 1;
+        if (data.coin === symbol && data.ctx) {
+            // Type guard using SDK types: check if this is perps (has funding) or spot (no funding)
+            const isPerpsContext = (event) => 'funding' in event.ctx &&
+                'openInterest' in event.ctx &&
+                'oraclePx' in event.ctx;
+            const { ctx } = data;
+            // Cache market data for consolidation with price updates
+            const ctxPrice = ctx.midPx ?? ctx.markPx;
+            const openInterestUSD = isPerpsContext(data) && ctxPrice
+                ? calculateOpenInterestUSD(data.ctx.openInterest, ctxPrice)
+                : NaN;
+            const marketData = {
+                prevDayPx: ctx.prevDayPx
+                    ? parseFloat(ctx.prevDayPx.toString())
+                    : undefined,
+                // Cache funding rate from activeAssetCtx for real-time updates
+                // SDK defines funding as string (not nullable) in ActiveAssetCtxEvent
+                funding: isPerpsContext(data)
+                    ? parseFloat(data.ctx.funding.toString())
+                    : undefined,
+                openInterest: isNaN(openInterestUSD)
+                    ? undefined
+                    : openInterestUSD,
+                volume24h: ctx.dayNtlVlm
+                    ? parseFloat(ctx.dayNtlVlm.toString())
+                    : undefined,
+                oraclePrice: isPerpsContext(data)
+                    ? parseFloat(data.ctx.oraclePx.toString())
+                    : undefined,
+                lastUpdated: Date.now(),
+            };
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataCache, "f").set(symbol, marketData);
+            // Update cached price data with new 24h change if we have current price
+            const currentCachedPrice = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f")?.get(symbol);
+            if (currentCachedPrice) {
+                const updatedPrice = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createPriceUpdate).call(this, symbol, currentCachedPrice.price);
+                __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedPriceData, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f") ?? new Map(), "f");
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f").set(symbol, updatedPrice);
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_notifyAllPriceSubscribers).call(this);
+            }
+        }
+    })
+        .then((sub) => {
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalActiveAssetSubscriptions, "f").set(symbol, sub);
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`HyperLiquid: Market data subscription established for ${symbol}`);
+        return undefined;
+    })
+        .catch((error) => {
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.ensureActiveAssetSubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'ensureActiveAssetSubscription', { symbol }));
+    });
+}, _HyperLiquidSubscriptionService_cleanupActiveAssetSubscription = function _HyperLiquidSubscriptionService_cleanupActiveAssetSubscription(symbol) {
+    const currentCount = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_symbolSubscriberCounts, "f").get(symbol) ?? 0;
+    if (currentCount <= 1) {
+        // Last subscriber, cleanup subscription
+        const subscription = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalActiveAssetSubscriptions, "f").get(symbol);
+        if (subscription && typeof subscription.unsubscribe === 'function') {
+            const unsubscribeResult = Promise.resolve(subscription.unsubscribe());
+            unsubscribeResult.catch(() => {
+                // Ignore errors during cleanup
+            });
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalActiveAssetSubscriptions, "f").delete(symbol);
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_symbolSubscriberCounts, "f").delete(symbol);
+        }
+        else if (subscription) {
+            // Subscription exists but unsubscribe is not a function or doesn't return a Promise
+            // Just clean up the reference
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalActiveAssetSubscriptions, "f").delete(symbol);
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_symbolSubscriberCounts, "f").delete(symbol);
+        }
+    }
+    else {
+        // Still has subscribers, just decrement count
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_symbolSubscriberCounts, "f").set(symbol, currentCount - 1);
+    }
+}, _HyperLiquidSubscriptionService_ensureAssetCtxsSubscription = 
+/**
+ * Ensure assetCtxs subscription for specific DEX (HIP-3 support)
+ * Uses WebSocket instead of REST polling for market data
+ * Implements reference counting to track active subscribers per DEX
+ *
+ * @param dex - The DEX identifier (empty string for main DEX).
+ */
+async function _HyperLiquidSubscriptionService_ensureAssetCtxsSubscription(dex) {
+    const dexKey = dex || '';
+    // Increment subscriber count for this DEX
+    const currentCount = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexSubscriberCounts, "f").get(dexKey) ?? 0;
+    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexSubscriberCounts, "f").set(dexKey, currentCount + 1);
+    // Return if subscription already exists
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptions, "f").has(dexKey)) {
+        return;
+    }
+    // Await existing promise if subscription is being established
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptionPromises, "f").has(dexKey)) {
+        await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptionPromises, "f").get(dexKey);
+        return;
+    }
+    // Create new subscription promise
+    const promise = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createAssetCtxsSubscription).call(this, dex);
+    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptionPromises, "f").set(dexKey, promise);
+    try {
+        await promise;
+    }
+    catch (error) {
+        // Clear promise on error so it can be retried
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptionPromises, "f").delete(dexKey);
+        throw error;
+    }
+}, _HyperLiquidSubscriptionService_createAssetCtxsSubscription = 
+/**
+ * Create assetCtxs subscription for specific DEX
+ * Provides real-time market data for all assets on the DEX
+ *
+ * Performance: Uses cached meta from dexMetaCache (populated by metaAndAssetCtxs)
+ * to avoid redundant meta() API calls during subscription setup
+ *
+ * @param dex - The DEX identifier (empty string for main DEX).
+ */
+async function _HyperLiquidSubscriptionService_createAssetCtxsSubscription(dex) {
+    await __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").ensureSubscriptionClient(__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_walletService, "f").createWalletAdapter());
+    const subscriptionClient = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").getSubscriptionClient();
+    if (!subscriptionClient) {
+        throw new Error('Subscription client not initialized');
+    }
+    const dexKey = dex || '';
+    const dexIdentifier = dex ?? 'main DEX';
+    // Check cache first - populated by metaAndAssetCtxs in ensureAssetCtxsSubscription
+    let perpsMeta = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexMetaCache, "f").get(dexKey);
+    if (!perpsMeta) {
+        // Fallback: fetch meta if not in cache (shouldn't happen in normal flow)
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`Meta cache miss for ${dexIdentifier}, fetching from API`);
+        const infoClient = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").getInfoClient();
+        const fetchedMeta = await infoClient.meta({ dex: dex || undefined });
+        if (fetchedMeta?.universe) {
+            perpsMeta = fetchedMeta;
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexMetaCache, "f").set(dexKey, fetchedMeta);
+        }
+    }
+    if (!perpsMeta?.universe) {
+        const errorMessage = `No universe data available for ${dexIdentifier}`;
+        throw new Error(errorMessage);
+    }
+    // Capture narrowed perpsMeta in a const for use inside closures
+    const validatedMeta = perpsMeta;
+    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`Using ${__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexMetaCache, "f").has(dexKey) ? 'cached' : 'fetched'} meta for ${dexIdentifier}`, {
+        dex,
+        universeCount: validatedMeta.universe.length,
+        firstAssetSample: validatedMeta.universe[0]?.name,
+    });
+    return new Promise((resolve, reject) => {
+        const subscriptionParams = dex ? { dex } : {};
+        subscriptionClient
+            .assetCtxs(subscriptionParams, (data) => {
+            // Cache asset contexts for this DEX
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAssetCtxsCache, "f").set(dexKey, data.ctxs);
+            // Use cached meta to map ctxs array indices to symbols (no REST API call!)
+            validatedMeta.universe.forEach((asset, index) => {
+                const ctx = data.ctxs[index];
+                if (ctx && 'funding' in ctx) {
+                    // This is a perps context
+                    const ctxPrice = ctx.midPx ?? ctx.markPx;
+                    const openInterestUSD = calculateOpenInterestUSD(ctx.openInterest, ctxPrice);
+                    const marketData = {
+                        prevDayPx: ctx.prevDayPx
+                            ? parseFloat(ctx.prevDayPx.toString())
+                            : undefined,
+                        funding: parseFloat(ctx.funding.toString()),
+                        openInterest: isNaN(openInterestUSD)
+                            ? undefined
+                            : openInterestUSD,
+                        volume24h: ctx.dayNtlVlm
+                            ? parseFloat(ctx.dayNtlVlm.toString())
+                            : undefined,
+                        oraclePrice: parseFloat(ctx.oraclePx.toString()),
+                        lastUpdated: Date.now(),
+                    };
+                    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_marketDataCache, "f").set(asset.name, marketData);
+                    // HIP-3: Extract price from assetCtx and update cached prices
+                    const price = ctx.midPx?.toString() ?? ctx.markPx?.toString();
+                    if (price) {
+                        // For HIP-3 DEXs, meta() returns asset.name already containing the DEX prefix
+                        // (e.g., "xyz:XYZ100"), so use it directly
+                        const symbol = asset.name;
+                        const priceUpdate = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createPriceUpdate).call(this, symbol, price);
+                        __classPrivateFieldSet(this, _HyperLiquidSubscriptionService_cachedPriceData, __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f") ?? new Map(), "f");
+                        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f").set(symbol, priceUpdate);
+                    }
+                }
+            });
+            // Notify price subscribers with updated market data
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_notifyAllPriceSubscribers).call(this);
+        })
+            .then((sub) => {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptions, "f").set(dexKey, sub);
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`assetCtxs subscription established for ${dex ? `DEX: ${dex}` : 'main DEX'}`);
+            resolve();
+            return undefined;
+        })
+            .catch((error) => {
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.createAssetCtxsSubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'createAssetCtxsSubscription', { dex }));
+            reject(ensureError(error, 'HyperLiquidSubscriptionService.createAssetCtxsSubscription'));
+        });
+    });
+}, _HyperLiquidSubscriptionService_cleanupAssetCtxsSubscription = function _HyperLiquidSubscriptionService_cleanupAssetCtxsSubscription(dex) {
+    const dexKey = dex || '';
+    // Decrement subscriber count for this DEX
+    const currentCount = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexSubscriberCounts, "f").get(dexKey) ?? 0;
+    if (currentCount <= 1) {
+        // Last subscriber - cleanup the subscription
+        const subscription = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptions, "f").get(dexKey);
+        if (subscription) {
+            subscription.unsubscribe().catch((error) => {
+                __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.cleanupAssetCtxsSubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'cleanupAssetCtxsSubscription', { dex }));
+            });
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptions, "f").delete(dexKey);
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexAssetCtxsCache, "f").delete(dexKey);
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_assetCtxsSubscriptionPromises, "f").delete(dexKey);
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexSubscriberCounts, "f").delete(dexKey);
+            __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`Cleaned up assetCtxs subscription for ${dex ? `DEX: ${dex}` : 'main DEX'}`);
+        }
+    }
+    else {
+        // Still has subscribers - just decrement count
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_dexSubscriberCounts, "f").set(dexKey, currentCount - 1);
+    }
+}, _HyperLiquidSubscriptionService_ensureBboSubscription = function _HyperLiquidSubscriptionService_ensureBboSubscription(symbol) {
+    if (__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalBboSubscriptions, "f").has(symbol)) {
+        return;
+    }
+    const subscriptionClient = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_clientService, "f").getSubscriptionClient();
+    if (!subscriptionClient) {
+        return;
+    }
+    subscriptionClient
+        .bbo({ coin: symbol }, (data) => {
+        processBboData({
+            symbol,
+            data,
+            orderBookCache: __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderBookCache, "f"),
+            cachedPriceData: __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f"),
+            createPriceUpdate: __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_createPriceUpdate).bind(this),
+            notifySubscribers: __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_notifyAllPriceSubscribers).bind(this),
+        });
+    })
+        .then((sub) => {
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalBboSubscriptions, "f").set(symbol, sub);
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_deps, "f").debugLogger.log(`HyperLiquid: BBO subscription established for ${symbol}`);
+        return undefined;
+    })
+        .catch((error) => {
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_logErrorUnlessClearing).call(this, ensureError(error, 'HyperLiquidSubscriptionService.ensureBboSubscription'), __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_instances, "m", _HyperLiquidSubscriptionService_getErrorContext).call(this, 'ensureBboSubscription', { symbol }));
+    });
+}, _HyperLiquidSubscriptionService_cleanupBboSubscription = function _HyperLiquidSubscriptionService_cleanupBboSubscription(symbol) {
+    // If anyone still wants order book (top-of-book) data for this symbol, keep the subscription alive.
+    if ((__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderBookSubscribers, "f").get(symbol)?.size ?? 0) > 0) {
+        return;
+    }
+    const subscription = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalBboSubscriptions, "f").get(symbol);
+    if (subscription && typeof subscription.unsubscribe === 'function') {
+        const unsubscribeResult = Promise.resolve(subscription.unsubscribe());
+        unsubscribeResult.catch(() => {
+            // Ignore errors during cleanup
+        });
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalBboSubscriptions, "f").delete(symbol);
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderBookCache, "f").delete(symbol);
+    }
+    else if (subscription) {
+        // Subscription exists but unsubscribe is not a function or doesn't return a Promise
+        // Just clean up the reference
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_globalBboSubscriptions, "f").delete(symbol);
+        __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_orderBookCache, "f").delete(symbol);
+    }
+}, _HyperLiquidSubscriptionService_processOrderBookData = function _HyperLiquidSubscriptionService_processOrderBookData(data, levels) {
+    const bidsRaw = data?.levels?.[0] ?? [];
+    const asksRaw = data?.levels?.[1] ?? [];
+    // Process bids (buy orders) - highest price first
+    let bidCumulativeSize = 0;
+    let bidCumulativeNotional = 0;
+    const bids = bidsRaw.slice(0, levels).map((level) => {
+        const price = parseFloat(level.px);
+        const size = parseFloat(level.sz);
+        const notional = price * size;
+        bidCumulativeSize += size;
+        bidCumulativeNotional += notional;
+        return {
+            price: level.px,
+            size: level.sz,
+            total: bidCumulativeSize.toString(),
+            notional: notional.toFixed(2),
+            totalNotional: bidCumulativeNotional.toFixed(2),
+        };
+    });
+    // Process asks (sell orders) - lowest price first
+    let askCumulativeSize = 0;
+    let askCumulativeNotional = 0;
+    const asks = asksRaw.slice(0, levels).map((level) => {
+        const price = parseFloat(level.px);
+        const size = parseFloat(level.sz);
+        const notional = price * size;
+        askCumulativeSize += size;
+        askCumulativeNotional += notional;
+        return {
+            price: level.px,
+            size: level.sz,
+            total: askCumulativeSize.toString(),
+            notional: notional.toFixed(2),
+            totalNotional: askCumulativeNotional.toFixed(2),
+        };
+    });
+    // Calculate spread and mid price
+    const bestBid = bids[0];
+    const bestAsk = asks[0];
+    const bidPrice = bestBid ? parseFloat(bestBid.price) : 0;
+    const askPrice = bestAsk ? parseFloat(bestAsk.price) : 0;
+    const spread = askPrice > 0 && bidPrice > 0 ? askPrice - bidPrice : 0;
+    const midPrice = askPrice > 0 && bidPrice > 0 ? (askPrice + bidPrice) / 2 : 0;
+    const spreadPercentage = midPrice > 0 ? ((spread / midPrice) * 100).toFixed(4) : '0';
+    // Calculate max total for depth chart scaling
+    const maxTotal = Math.max(bidCumulativeSize, askCumulativeSize).toString();
+    return {
+        bids,
+        asks,
+        spread: spread.toFixed(5),
+        spreadPercentage,
+        midPrice: midPrice.toFixed(5),
+        lastUpdated: Date.now(),
+        maxTotal,
+    };
+}, _HyperLiquidSubscriptionService_notifyAllPriceSubscribers = function _HyperLiquidSubscriptionService_notifyAllPriceSubscribers() {
+    // If no price data exists yet, don't notify
+    if (!__classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f")) {
+        return;
+    }
+    const priceData = __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_cachedPriceData, "f");
+    // Group updates by subscriber to batch notifications
+    const subscriberUpdates = new Map();
+    __classPrivateFieldGet(this, _HyperLiquidSubscriptionService_priceSubscribers, "f").forEach((subscriberSet, symbol) => {
+        const priceUpdate = priceData.get(symbol);
+        if (priceUpdate) {
+            subscriberSet.forEach((callback) => {
+                if (!subscriberUpdates.has(callback)) {
+                    subscriberUpdates.set(callback, []);
+                }
+                const updates = subscriberUpdates.get(callback);
+                if (updates) {
+                    updates.push(priceUpdate);
+                }
+            });
+        }
+    });
+    // Send batched updates to each subscriber
+    subscriberUpdates.forEach((updates, callback) => {
+        if (updates.length > 0) {
+            callback(updates);
+        }
+    });
+};
+//# sourceMappingURL=HyperLiquidSubscriptionService.mjs.map