@metamask-previews/perps-controller 1.3.0-preview-a0caca0c0 → 1.3.0-preview-afe010990

package/dist/providers/HyperLiquidProvider.mjs

@@ -9,9 +9,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _HyperLiquidProvider_instances, _HyperLiquidProvider_deps, _HyperLiquidProvider_clientService, _HyperLiquidProvider_walletService, _HyperLiquidProvider_subscriptionService, _HyperLiquidProvider_symbolToAssetId, _HyperLiquidProvider_userFeeCache, _HyperLiquidProvider_maxLeverageCache, _HyperLiquidProvider_cachedMetaByDex, _HyperLiquidProvider_cachedSpotMeta, _HyperLiquidProvider_perpDexsCache, _HyperLiquidProvider_referralCheckCache, _HyperLiquidProvider_builderFeeCheckCache, _HyperLiquidProvider_ensureReadyPromise, _HyperLiquidProvider_pendingBuilderFeeApprovals, _HyperLiquidProvider_compiledAllowlistPatterns, _HyperLiquidProvider_compiledBlocklistPatterns, _HyperLiquidProvider_userFeeDiscountBips, _HyperLiquidProvider_hip3Enabled, _HyperLiquidProvider_allowlistMarkets, _HyperLiquidProvider_blocklistMarkets, _HyperLiquidProvider_useDexAbstraction, _HyperLiquidProvider_cachedValidatedDexs, _HyperLiquidProvider_cachedAllPerpDexs, _HyperLiquidProvider_pendingValidatedDexsPromise, _HyperLiquidProvider_cachedUsdcTokenId, _HyperLiquidProvider_errorMappings, _HyperLiquidProvider_clientsInitialized, _HyperLiquidProvider_initializationPromise, _HyperLiquidProvider_messenger, _HyperLiquidProvider_compilePatternsSafely, _HyperLiquidProvider_ensureClientsInitialized, _HyperLiquidProvider_ensureDexAbstractionEnabled, _HyperLiquidProvider_ensureReady, _HyperLiquidProvider_tradingSetupPromise, _HyperLiquidProvider_tradingSetupComplete, _HyperLiquidProvider_ensureReadyForTrading, _HyperLiquidProvider_getOrFetchPrice, _HyperLiquidProvider_filterFills, _HyperLiquidProvider_getAllAvailableDexs, _HyperLiquidProvider_getValidatedDexs, _HyperLiquidProvider_fetchValidatedDexsInternal, _HyperLiquidProvider_extractDexsFromAllowlist, _HyperLiquidProvider_getCachedMeta, _HyperLiquidProvider_getCachedSpotMeta, _HyperLiquidProvider_getCachedPerpDexs, _HyperLiquidProvider_calculateHip3FeeMultiplier, _HyperLiquidProvider_getCacheKey, _HyperLiquidProvider_fetchMarketsForDex, _HyperLiquidProvider_getUsdcTokenId, _HyperLiquidProvider_isUsdhCollateralDex, _HyperLiquidProvider_getSpotUsdhBalance, _HyperLiquidProvider_getSpotUsdcBalance, _HyperLiquidProvider_transferUsdcToSpot, _HyperLiquidProvider_swapUsdcToUsdh, _HyperLiquidProvider_ensureUsdhCollateralForOrder, _HyperLiquidProvider_buildAssetMapping, _HyperLiquidProvider_queryUserDataAcrossDexs, _HyperLiquidProvider_mapError, _HyperLiquidProvider_getErrorContext, _HyperLiquidProvider_checkBuilderFeeApproval, _HyperLiquidProvider_ensureBuilderFeeApproval, _HyperLiquidProvider_checkBuilderFeeStatus, _HyperLiquidProvider_getBalanceForDex, _HyperLiquidProvider_findSourceDexWithBalance, _HyperLiquidProvider_autoTransferForHip3Order, _HyperLiquidProvider_autoTransferBackAfterClose, _HyperLiquidProvider_calculateHip3RequiredMargin, _HyperLiquidProvider_handleHip3PostOrderRebalance, _HyperLiquidProvider_handleHip3OrderRollback, _HyperLiquidProvider_validateOrderBeforePlacement, _HyperLiquidProvider_getAssetInfo, _HyperLiquidProvider_prepareAssetForTrading, _HyperLiquidProvider_handleHip3PreOrder, _HyperLiquidProvider_submitOrderWithRollback, _HyperLiquidProvider_handleOrderError, _HyperLiquidProvider_getStandaloneValidatedDexs, _HyperLiquidProvider_isFeeCacheValid, _HyperLiquidProvider_getBuilderAddress, _HyperLiquidProvider_getReferralCode, _HyperLiquidProvider_ensureReferralSet, _HyperLiquidProvider_isReferralCodeReady, _HyperLiquidProvider_checkReferralSet, _HyperLiquidProvider_setReferralCode;
+var _HyperLiquidProvider_instances, _HyperLiquidProvider_deps, _HyperLiquidProvider_clientService, _HyperLiquidProvider_walletService, _HyperLiquidProvider_subscriptionService, _HyperLiquidProvider_symbolToAssetId, _HyperLiquidProvider_userFeeCache, _HyperLiquidProvider_maxLeverageCache, _HyperLiquidProvider_cachedMetaByDex, _HyperLiquidProvider_cachedMarketDataWithPrices, _HyperLiquidProvider_cachedSpotMeta, _HyperLiquidProvider_perpDexsCache, _HyperLiquidProvider_referralCheckCache, _HyperLiquidProvider_builderFeeCheckCache, _HyperLiquidProvider_ensureReadyPromise, _HyperLiquidProvider_pendingBuilderFeeApprovals, _HyperLiquidProvider_compiledAllowlistPatterns, _HyperLiquidProvider_compiledBlocklistPatterns, _HyperLiquidProvider_userFeeDiscountBips, _HyperLiquidProvider_hip3Enabled, _HyperLiquidProvider_allowlistMarkets, _HyperLiquidProvider_blocklistMarkets, _HyperLiquidProvider_useDexAbstraction, _HyperLiquidProvider_cachedValidatedDexs, _HyperLiquidProvider_cachedAllPerpDexs, _HyperLiquidProvider_dexDiscoveryComplete, _HyperLiquidProvider_pendingValidatedDexsPromise, _HyperLiquidProvider_cachedUsdcTokenId, _HyperLiquidProvider_errorMappings, _HyperLiquidProvider_clientsInitialized, _HyperLiquidProvider_initializationPromise, _HyperLiquidProvider_messenger, _HyperLiquidProvider_builderAddressTestnet, _HyperLiquidProvider_builderAddressMainnet, _HyperLiquidProvider_compilePatternsSafely, _HyperLiquidProvider_ensureClientsInitialized, _HyperLiquidProvider_ensureDexAbstractionEnabled, _HyperLiquidProvider_ensureReady, _HyperLiquidProvider_tradingSetupPromise, _HyperLiquidProvider_tradingSetupComplete, _HyperLiquidProvider_ensureReadyForTrading, _HyperLiquidProvider_getOrFetchPrice, _HyperLiquidProvider_filterFills, _HyperLiquidProvider_getAllAvailableDexs, _HyperLiquidProvider_getValidatedDexs, _HyperLiquidProvider_fetchValidatedDexsInternal, _HyperLiquidProvider_extractDexsFromAllowlist, _HyperLiquidProvider_getCachedMeta, _HyperLiquidProvider_backfillAssetMapForDex, _HyperLiquidProvider_getAssetIdWithRepair, _HyperLiquidProvider_getCachedSpotMeta, _HyperLiquidProvider_getCachedPerpDexs, _HyperLiquidProvider_calculateHip3FeeMultiplier, _HyperLiquidProvider_getCacheKey, _HyperLiquidProvider_fetchMarketsForDex, _HyperLiquidProvider_getUsdcTokenId, _HyperLiquidProvider_isUsdhCollateralDex, _HyperLiquidProvider_getSpotUsdhBalance, _HyperLiquidProvider_getSpotUsdcBalance, _HyperLiquidProvider_transferUsdcToSpot, _HyperLiquidProvider_swapUsdcToUsdh, _HyperLiquidProvider_ensureUsdhCollateralForOrder, _HyperLiquidProvider_buildAssetMapping, _HyperLiquidProvider_queryUserDataAcrossDexs, _HyperLiquidProvider_mapError, _HyperLiquidProvider_getErrorContext, _HyperLiquidProvider_checkBuilderFeeApproval, _HyperLiquidProvider_ensureBuilderFeeApproval, _HyperLiquidProvider_checkBuilderFeeStatus, _HyperLiquidProvider_getBalanceForDex, _HyperLiquidProvider_findSourceDexWithBalance, _HyperLiquidProvider_autoTransferForHip3Order, _HyperLiquidProvider_autoTransferBackAfterClose, _HyperLiquidProvider_calculateHip3RequiredMargin, _HyperLiquidProvider_handleHip3PostOrderRebalance, _HyperLiquidProvider_handleHip3OrderRollback, _HyperLiquidProvider_validateOrderBeforePlacement, _HyperLiquidProvider_getAssetInfo, _HyperLiquidProvider_prepareAssetForTrading, _HyperLiquidProvider_handleHip3PreOrder, _HyperLiquidProvider_submitOrderWithRollback, _HyperLiquidProvider_handleOrderError, _HyperLiquidProvider_getStandaloneValidatedDexs, _HyperLiquidProvider_getAllMids, _HyperLiquidProvider_fetchSingleDexFresh, _HyperLiquidProvider_mergeDexResultsInto, _HyperLiquidProvider_cacheFreshMarketDataSnapshot, _HyperLiquidProvider_getStaleMarketDataSnapshot, _HyperLiquidProvider_isFeeCacheValid, _HyperLiquidProvider_getBuilderAddress, _HyperLiquidProvider_getReferralCode, _HyperLiquidProvider_ensureReferralSet, _HyperLiquidProvider_isReferralCodeReady, _HyperLiquidProvider_checkReferralSet, _HyperLiquidProvider_setReferralCode;
 import { v4 as uuidv4 } from "uuid";
-import { BASIS_POINTS_DIVISOR, BUILDER_FEE_CONFIG, FEE_RATES, getBridgeInfo, getChainId, HIP3_ASSET_MARKET_TYPES, HIP3_FEE_CONFIG, HIP3_MARGIN_CONFIG, HYPERLIQUID_WITHDRAWAL_MINUTES, MAINNET_HIP3_CONFIG, REFERRAL_CONFIG, TESTNET_HIP3_CONFIG, TRADING_DEFAULTS, USDC_DECIMALS, USDH_CONFIG } from "../constants/hyperLiquidConfig.mjs";
+import { BASIS_POINTS_DIVISOR, BUILDER_FEE_CONFIG, FEE_RATES, getBridgeInfo, getChainId, HIP3_ASSET_MARKET_TYPES, HIP3_FEE_CONFIG, HIP3_MARGIN_CONFIG, HYPERLIQUID_WITHDRAWAL_MINUTES, MAINNET_HIP3_CONFIG, REFERRAL_CONFIG, SPOT_ASSET_ID_OFFSET, TESTNET_HIP3_CONFIG, TRADING_DEFAULTS, USDC_DECIMALS, USDH_CONFIG } from "../constants/hyperLiquidConfig.mjs";
 import { ORDER_SLIPPAGE_CONFIG, PERFORMANCE_CONFIG, PERPS_CONSTANTS, TP_SL_CONFIG, WITHDRAWAL_CONSTANTS } from "../constants/perpsConfig.mjs";
 import { PERPS_TRANSACTIONS_HISTORY_CONSTANTS } from "../constants/transactionsHistoryConfig.mjs";
 import { PERPS_ERROR_CODES } from "../perpsErrorCodes.mjs";
@@ -66,6 +66,8 @@ export class HyperLiquidProvider {
         // Cache for raw meta responses (shared across methods to avoid redundant API calls)
         // Filtering is applied on-demand (cheap array operations) - no need for separate processed cache
         _HyperLiquidProvider_cachedMetaByDex.set(this, new Map());
+        // Last known-good market list for stale fallback when every enabled DEX fails in one fetch window.
+        _HyperLiquidProvider_cachedMarketDataWithPrices.set(this, null);
         // Session cache for spot metadata (contains USDC/USDH token info for HIP-3 collateral checks)
         // Pre-fetched in ensureReadyForTrading() to avoid API failures during order placement
         _HyperLiquidProvider_cachedSpotMeta.set(this, null);
@@ -95,6 +97,10 @@ export class HyperLiquidProvider {
         // Cache for validated DEXs to avoid redundant perpDexs() API calls
         _HyperLiquidProvider_cachedValidatedDexs.set(this, null);
         _HyperLiquidProvider_cachedAllPerpDexs.set(this, null);
+        // True once DEX discovery has succeeded with real data (not a fallback).
+        // When false, #ensureReadyPromise is reset after each init so the next
+        // caller retries DEX discovery instead of reusing a degraded mapping.
+        _HyperLiquidProvider_dexDiscoveryComplete.set(this, false);
         // Pending promise to deduplicate concurrent getValidatedDexs() calls
         _HyperLiquidProvider_pendingValidatedDexsPromise.set(this, null);
         // Cache for USDC token ID from spot metadata
@@ -109,6 +115,8 @@ export class HyperLiquidProvider {
         // Promise-based lock to prevent race conditions in concurrent initialization
         _HyperLiquidProvider_initializationPromise.set(this, null);
         _HyperLiquidProvider_messenger.set(this, void 0);
+        _HyperLiquidProvider_builderAddressTestnet.set(this, void 0);
+        _HyperLiquidProvider_builderAddressMainnet.set(this, void 0);
         /**
          * Ensure provider is ready for TRADING operations (signing required)
          *
@@ -126,6 +134,8 @@ export class HyperLiquidProvider {
         _HyperLiquidProvider_tradingSetupComplete.set(this, false);
         __classPrivateFieldSet(this, _HyperLiquidProvider_deps, options.platformDependencies, "f");
         __classPrivateFieldSet(this, _HyperLiquidProvider_messenger, options.messenger, "f");
+        __classPrivateFieldSet(this, _HyperLiquidProvider_builderAddressTestnet, options.builderAddressTestnet, "f");
+        __classPrivateFieldSet(this, _HyperLiquidProvider_builderAddressMainnet, options.builderAddressMainnet, "f");
         const isTestnet = options.isTestnet ?? false;
         // Dev-friendly defaults: Enable all markets by default for easier testing (discovery mode)
         __classPrivateFieldSet(this, _HyperLiquidProvider_hip3Enabled, options.hip3Enabled ?? false, "f");
@@ -283,7 +293,7 @@ export class HyperLiquidProvider {
             // Extract DEX name for API calls (main DEX = null)
             const { dex: dexName } = parseAssetName(params.symbol);
             // 1. Get asset info and current price
-            const { assetInfo, currentPrice } = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetInfo).call(this, {
+            const { assetInfo, currentPrice, meta } = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetInfo).call(this, {
                 symbol: params.symbol,
                 dexName,
             });
@@ -319,17 +329,11 @@ export class HyperLiquidProvider {
                 szDecimals: assetInfo.szDecimals,
             });
             // 4. Get asset ID and validate it exists
-            const assetId = __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").get(params.symbol);
-            if (assetId === undefined) {
-                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Asset ID lookup failed', {
-                    requestedCoin: params.symbol,
-                    dexName: dexName ?? 'main',
-                    mapSize: __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").size,
-                    mapContainsAsset: __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").has(params.symbol),
-                    allKeys: Array.from(__classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").keys()).slice(0, 20),
-                });
-                throw new Error(`Asset ID not found for ${params.symbol}`);
-            }
+            const assetId = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
+                symbol: params.symbol,
+                dexName,
+                meta,
+            });
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Resolved DEX-specific asset ID', {
                 coin: params.symbol,
                 dex: dexName ?? 'main',
@@ -506,10 +510,11 @@ export class HyperLiquidProvider {
                 price: orderPrice,
                 szDecimals: assetInfo.szDecimals,
             });
-            const assetId = __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").get(params.newOrder.symbol);
-            if (assetId === undefined) {
-                throw new Error(`Asset ID not found for ${params.newOrder.symbol}`);
-            }
+            const assetId = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
+                symbol: params.newOrder.symbol,
+                dexName,
+                meta,
+            });
             // Build new order parameters
             const newOrder = {
                 a: assetId,
@@ -567,10 +572,10 @@ export class HyperLiquidProvider {
             // Ensure provider is ready for trading (includes signing operations)
             await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
             const exchangeClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient();
-            const asset = __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").get(params.symbol);
-            if (asset === undefined) {
-                throw new Error(`Asset not found for symbol: ${params.symbol}`);
-            }
+            const asset = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
+                symbol: params.symbol,
+                dexName: parseAssetName(params.symbol).dex,
+            });
             const result = await exchangeClient.cancel({
                 cancels: [
                     {
@@ -618,16 +623,16 @@ export class HyperLiquidProvider {
             await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureReadyForTrading).call(this);
             const exchangeClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getExchangeClient();
             // Map orders to SDK format and validate coins
-            const cancelRequests = params.map((order) => {
-                const asset = __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").get(order.symbol);
-                if (asset === undefined) {
-                    throw new Error(`Asset not found for symbol: ${order.symbol}`);
-                }
+            const cancelRequests = await Promise.all(params.map(async (order) => {
+                const asset = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
+                    symbol: order.symbol,
+                    dexName: parseAssetName(order.symbol).dex,
+                });
                 return {
                     a: asset,
                     o: parseInt(order.orderId, 10),
                 };
-            });
+            }));
             // Single batch API call
             const result = await exchangeClient.cancel({
                 cancels: cancelRequests,
@@ -720,10 +725,11 @@ export class HyperLiquidProvider {
                     throw new Error(`Asset ${position.symbol} not found in ${dexName ?? 'main'} DEX universe`);
                 }
                 // Get asset ID
-                const assetId = __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").get(position.symbol);
-                if (assetId === undefined) {
-                    throw new Error(`Asset ID not found for ${position.symbol}`);
-                }
+                const assetId = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
+                    symbol: position.symbol,
+                    dexName,
+                    meta,
+                });
                 // Calculate position details (always full close)
                 const positionSize = parseFloat(position.size);
                 const isBuy = positionSize < 0; // Close opposite side
@@ -896,10 +902,10 @@ export class HyperLiquidProvider {
             // Cancel existing TP/SL orders for this position
             // OPTIMIZATION: Use WebSocket cache first (0 weight), fall back to single-DEX REST (20 weight)
             // Previously: queryUserDataAcrossDexs queried ALL DEXs (20 weight × N DEXs = 40+ weight)
-            const assetId = __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").get(symbol);
-            if (assetId === undefined) {
-                throw new Error(`Asset ID not found for ${symbol}`);
-            }
+            const assetId = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
+                symbol,
+                dexName,
+            });
             let cancelRequests = [];
             // Use atomic getter to prevent race condition between check and get
             const cachedOrders = __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").getOrdersCacheIfInitialized();
@@ -1205,10 +1211,10 @@ export class HyperLiquidProvider {
             // Determine position direction
             const isBuy = parseFloat(position.size) > 0; // true for long, false for short
             // Get asset ID for the symbol
-            const assetId = __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").get(symbol);
-            if (assetId === undefined) {
-                throw new Error(`Asset ID not found for ${symbol}`);
-            }
+            const assetId = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAssetIdWithRepair).call(this, {
+                symbol,
+                dexName: parseAssetName(symbol).dex,
+            });
             // Convert amount to micro-units (HyperLiquid SDK requirement)
             const amountFloat = parseFloat(amount);
             const ntli = Math.floor(amountFloat * 1e6);
@@ -1299,10 +1305,18 @@ export class HyperLiquidProvider {
             const infoClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient();
             const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault(params?.accountId);
             // Query positions and orders across all enabled DEXs in parallel
-            const [stateResults, orderResults] = await Promise.all([
+            const [stateResponse, orderResponse] = await Promise.all([
                 __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_queryUserDataAcrossDexs).call(this, { user: userAddress }, (userParam) => infoClient.clearinghouseState(userParam)),
                 __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_queryUserDataAcrossDexs).call(this, { user: userAddress }, (userParam) => infoClient.frontendOpenOrders(userParam)),
             ]);
+            const { results: stateResults, failedDexs: failedStateDexs } = stateResponse;
+            const { results: orderResults, failedDexs: failedOrderDexs } = orderResponse;
+            if (failedStateDexs.length > 0 || failedOrderDexs.length > 0) {
+                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Partial multi-DEX position fetch completed with failures', {
+                    failedStateDexs: failedStateDexs.map(({ dex, error }) => `${dex ?? 'main'}:${error.message}`),
+                    failedOrderDexs: failedOrderDexs.map(({ dex, error }) => `${dex ?? 'main'}:${error.message}`),
+                });
+            }
             // Combine all orders from all DEXs for TP/SL lookup
             const allOrders = orderResults.flatMap((result) => result.data);
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Frontend open orders (all DEXs):', {
@@ -1601,7 +1615,12 @@ export class HyperLiquidProvider {
             const infoClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient();
             const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault(params?.accountId);
             // Query orders across all enabled DEXs in parallel
-            const orderResults = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_queryUserDataAcrossDexs).call(this, { user: userAddress }, (userParam) => infoClient.frontendOpenOrders(userParam));
+            const { results: orderResults, failedDexs } = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_queryUserDataAcrossDexs).call(this, { user: userAddress }, (userParam) => infoClient.frontendOpenOrders(userParam));
+            if (failedDexs.length > 0) {
+                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Partial multi-DEX open order fetch completed with failures', {
+                    failedDexs: failedDexs.map(({ dex, error }) => `${dex ?? 'main'}:${error.message}`),
+                });
+            }
             // Combine all orders from all DEXs
             const rawOrders = orderResults.flatMap((result) => result.data);
             // Get positions for order context (already multi-DEX aware)
@@ -1816,11 +1835,43 @@ export class HyperLiquidProvider {
             const userAddress = await __classPrivateFieldGet(this, _HyperLiquidProvider_walletService, "f").getUserAddressWithDefault(params?.accountId);
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('User address for account state:', userAddress);
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Network mode:', __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").isTestnetMode() ? 'TESTNET' : 'MAINNET');
-            // Get Spot balance (global, not DEX-specific) and Perps states across all DEXs
-            const [spotState, perpsStateResults] = await Promise.all([
+            // Get Spot balance (global, not DEX-specific) and Perps states across all DEXs.
+            // One transient DEX failure should not blank the entire account state.
+            const [spotStateResult, perpsStateResult] = await Promise.allSettled([
                 infoClient.spotClearinghouseState({ user: userAddress }),
                 __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_queryUserDataAcrossDexs).call(this, { user: userAddress }, (userParam) => infoClient.clearinghouseState(userParam)),
             ]);
+            const spotState = spotStateResult.status === 'fulfilled' ? spotStateResult.value : null;
+            const perpsResponse = perpsStateResult.status === 'fulfilled'
+                ? perpsStateResult.value
+                : {
+                    results: [],
+                    failedDexs: [
+                        {
+                            dex: null,
+                            error: ensureError(perpsStateResult.reason, 'HyperLiquidProvider.getAccountState.perps'),
+                        },
+                    ],
+                };
+            const perpsStateResults = perpsResponse.results;
+            const failedPerpsDexs = perpsResponse.failedDexs;
+            if (spotStateResult.status === 'rejected') {
+                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Spot state fetch failed during account state aggregation', {
+                    error: ensureError(spotStateResult.reason, 'HyperLiquidProvider.getAccountState.spot').message,
+                });
+            }
+            if (failedPerpsDexs.length > 0) {
+                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Perps account state completed with partial DEX failures', {
+                    failedDexs: failedPerpsDexs.map(({ dex, error }) => `${dex ?? 'main'}:${error.message}`),
+                });
+            }
+            if (perpsStateResults.length === 0) {
+                const failedDexNames = failedPerpsDexs.map(({ dex }) => dex ?? 'main');
+                const spotErrorMessage = spotStateResult.status === 'rejected'
+                    ? ensureError(spotStateResult.reason, 'HyperLiquidProvider.getAccountState.spot').message
+                    : undefined;
+                throw new Error(`Failed to fetch account state (failedDexs=[${failedDexNames.join(',')}], spotError=${spotErrorMessage ?? 'none'})`);
+            }
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Spot state:', spotState);
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Perps states (all DEXs):', {
                 dexCount: perpsStateResults.length,
@@ -1866,7 +1917,7 @@ export class HyperLiquidProvider {
             }));
             // Re-throw the error so the controller can handle it properly
             // This allows the UI to show proper error messages instead of zeros
-            throw error;
+            throw ensureError(error, 'HyperLiquidProvider.getAccountState');
         }
     }
     /**
@@ -2043,7 +2094,7 @@ export class HyperLiquidProvider {
      * Note: This is called once during initialization and cached by PerpsStreamManager.
      * Real-time price updates come from WebSocket subscriptions, not this method.
      *
-     * @returns A promise that resolves to the result.
+     * @returns A promise that resolves to the combined market data from all enabled DEXs.
      */
     async getMarketDataWithPrices() {
         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Getting market data with prices via HyperLiquid SDK');
@@ -2057,106 +2108,131 @@ export class HyperLiquidProvider {
         const infoClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient({ useHttp: true });
         // Get enabled DEXs respecting feature flags (uses cached perpDexs)
         const enabledDexs = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getValidatedDexs).call(this);
-        // Fetch meta, assetCtxs, and allMids for each enabled DEX in parallel
-        // Optimization: Check cache first to avoid redundant API calls when buildAssetMapping
-        // has already fetched, or populate cache for buildAssetMapping to reuse
+        // Fetch meta, assetCtxs, and allMids for each enabled DEX in parallel.
+        // Check the meta cache first to avoid redundant API calls when buildAssetMapping
+        // has already populated it; on cache miss, delegate to #fetchSingleDexFresh.
         const dexDataResults = await Promise.all(enabledDexs.map(async (dex) => {
             const dexKey = dex ?? '';
             const dexParam = dex ?? '';
-            try {
-                let meta = null;
-                let assetCtxs = [];
-                // Check if meta is already cached (e.g., from previous fetch or buildAssetMapping)
-                const cachedMeta = __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").get(dexKey);
-                if (cachedMeta) {
-                    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`[getMarketDataWithPrices] Using cached meta for ${dex ?? 'main'}`, { universeSize: cachedMeta.universe.length });
-                    meta = cachedMeta;
-                    // Try to get cached assetCtxs from subscription service
-                    const cachedCtxs = __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").getDexAssetCtxsCache(dexKey);
-                    if (cachedCtxs) {
-                        assetCtxs = cachedCtxs;
-                    }
-                    else {
-                        // Need fresh assetCtxs, fetch via metaAndAssetCtxs (meta will be same)
-                        const metaAndCtxs = await infoClient.metaAndAssetCtxs(dexParam ? { dex: dexParam } : undefined);
-                        assetCtxs = metaAndCtxs?.[1] || [];
-                        // Cache assetCtxs for future calls
-                        __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexAssetCtxsCache(dexKey, assetCtxs);
+            const cachedMeta = __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").get(dexKey);
+            if (!cachedMeta) {
+                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`[getMarketDataWithPrices] Cache miss for ${dex ?? 'main'}, fetching`);
+                return __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchSingleDexFresh).call(this, infoClient, dex);
+            }
+            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`[getMarketDataWithPrices] Using cached meta for ${dex ?? 'main'}`, { universeSize: cachedMeta.universe.length });
+            let metaForDex = cachedMeta;
+            let assetCtxs = __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").getDexAssetCtxsCache(dexKey) ?? [];
+            let failedStep;
+            let errorMessage;
+            if (assetCtxs.length !== metaForDex.universe.length) {
+                try {
+                    const freshResult = await infoClient.metaAndAssetCtxs(dexParam ? { dex: dexParam } : undefined);
+                    const freshMeta = freshResult?.[0] ?? null;
+                    const freshAssetCtxs = freshResult?.[1] ?? [];
+                    if (freshAssetCtxs.length !== freshMeta?.universe?.length) {
+                        return {
+                            dex,
+                            meta: null,
+                            assetCtxs: [],
+                            allMids: {},
+                            success: false,
+                            failedStep: 'metaAndAssetCtxs',
+                            errorMessage: 'metaAndAssetCtxs returned mismatched universe/assetCtxs lengths',
+                        };
                     }
+                    metaForDex = freshMeta;
+                    assetCtxs = freshAssetCtxs;
+                    __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").set(dexKey, freshMeta);
+                    __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexMetaCache(dexKey, freshMeta);
+                    __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexAssetCtxsCache(dexKey, assetCtxs);
+                    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_backfillAssetMapForDex).call(this, dex, freshMeta);
                 }
-                else {
-                    // Cache miss - fetch and populate cache for buildAssetMapping to reuse
-                    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`[getMarketDataWithPrices] Cache miss for ${dex ?? 'main'}, fetching`);
-                    const metaAndCtxs = await infoClient.metaAndAssetCtxs(dexParam ? { dex: dexParam } : undefined);
-                    meta = metaAndCtxs?.[0] || null;
-                    assetCtxs = metaAndCtxs?.[1] || [];
-                    // IMPORTANT: Populate cache for buildAssetMapping and other methods to reuse
-                    if (meta?.universe) {
-                        __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").set(dexKey, meta);
-                        __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexMetaCache(dexKey, meta);
-                        // Also cache assetCtxs for consistency with buildAssetMapping
-                        __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexAssetCtxsCache(dexKey, assetCtxs);
-                        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`[getMarketDataWithPrices] Cached meta for ${dex ?? 'main'}`, { universeSize: meta.universe.length });
-                    }
+                catch (error) {
+                    return {
+                        dex,
+                        meta: null,
+                        assetCtxs: [],
+                        allMids: {},
+                        success: false,
+                        failedStep: 'metaAndAssetCtxs',
+                        errorMessage: ensureError(error, 'HyperLiquidProvider.getMarketDataWithPrices.metaAndAssetCtxs').message,
+                    };
                 }
-                // Always fetch fresh allMids for current prices
-                const dexAllMids = await infoClient.allMids(dexParam ? { dex: dexParam } : undefined);
-                return {
-                    dex,
-                    meta,
-                    assetCtxs,
-                    allMids: dexAllMids || {},
-                    success: true,
-                };
+            }
+            let dexAllMids = {};
+            try {
+                dexAllMids = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAllMids).call(this, infoClient, dexParam || undefined);
             }
             catch (error) {
-                // Log per-DEX failures locally only — the aggregate error at the end
-                // of this method reports to Sentry, avoiding duplicate events.
-                __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`[getMarketDataWithPrices] DEX fetch failed for ${dex ?? 'main'}`, {
-                    error: ensureError(error, 'HyperLiquidProvider.getMarketDataWithPrices').message,
-                });
-                return {
-                    dex,
-                    meta: null,
-                    assetCtxs: [],
-                    allMids: {},
-                    success: false,
-                };
+                failedStep = 'allMids';
+                errorMessage = ensureError(error, 'HyperLiquidProvider.getMarketDataWithPrices.allMids').message;
             }
+            return {
+                dex,
+                meta: metaForDex,
+                assetCtxs,
+                allMids: dexAllMids,
+                success: true,
+                failedStep,
+                errorMessage,
+            };
         }));
         // Combine universe, assetCtxs, and allMids from all DEXs
         const combinedUniverse = [];
         const combinedAssetCtxs = [];
         const combinedAllMids = {};
-        dexDataResults.forEach((result) => {
-            if (result.success && result.meta?.universe) {
-                // Apply market filtering for HIP-3 DEXs only (main DEX returns all markets)
-                const marketsFromDex = result.meta.universe;
-                const filteredMarkets = result.dex === null
-                    ? marketsFromDex // Main DEX: no filtering
-                    : marketsFromDex.filter((asset) => shouldIncludeMarket(asset.name, result.dex, __classPrivateFieldGet(this, _HyperLiquidProvider_hip3Enabled, "f"), __classPrivateFieldGet(this, _HyperLiquidProvider_compiledAllowlistPatterns, "f"), __classPrivateFieldGet(this, _HyperLiquidProvider_compiledBlocklistPatterns, "f")));
-                combinedUniverse.push(...filteredMarkets);
-                combinedAssetCtxs.push(...result.assetCtxs);
-                // Merge price data from this DEX into combined prices
-                Object.assign(combinedAllMids, result.allMids);
-            }
-        });
+        let latestDexResults = dexDataResults;
+        __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_mergeDexResultsInto).call(this, dexDataResults, combinedUniverse, combinedAssetCtxs, combinedAllMids);
         if (combinedUniverse.length === 0) {
-            const failedDexs = dexDataResults
-                .filter((result) => !result.success)
-                .map((result) => result.dex ?? 'main');
-            const succeededDexs = dexDataResults
-                .filter((result) => result.success)
-                .map((result) => result.dex ?? 'main');
-            const wsState = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getConnectionState();
-            throw new Error(`Failed to fetch market data - no markets available (enabledDexs=${enabledDexs.length}, failed=[${failedDexs.join(',')}], succeeded=[${succeededDexs.join(',')}], wsState=${wsState})`);
+            combinedUniverse.length = 0;
+            combinedAssetCtxs.length = 0;
+            for (const key of Object.keys(combinedAllMids)) {
+                delete combinedAllMids[key];
+            }
+            const retryDelayMs = 2000;
+            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`[getMarketDataWithPrices] All DEXs returned empty, retrying in ${retryDelayMs}ms`);
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+            const retryResults = await Promise.all(enabledDexs.map((dex) => __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_fetchSingleDexFresh).call(this, infoClient, dex)));
+            __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_mergeDexResultsInto).call(this, retryResults, combinedUniverse, combinedAssetCtxs, combinedAllMids);
+            latestDexResults = retryResults;
+            if (combinedUniverse.length === 0) {
+                const failedDexs = retryResults
+                    .filter((result) => !result.success)
+                    .map((result) => result.dex ?? 'main');
+                const succeededDexs = retryResults
+                    .filter((result) => result.success)
+                    .map((result) => result.dex ?? 'main');
+                const failedDetails = retryResults
+                    .filter((result) => result.errorMessage)
+                    .map((result) => `${result.dex ?? 'main'}:${result.failedStep ?? 'unknown'}:${result.errorMessage}`);
+                const staleMarketData = __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getStaleMarketDataSnapshot).call(this);
+                if (staleMarketData) {
+                    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[getMarketDataWithPrices] Returning stale cached market data after retry failure', {
+                        failedDexs,
+                        failedDetails,
+                        cachedAt: __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMarketDataWithPrices, "f")?.timestamp ?? Date.now(),
+                    });
+                    return staleMarketData;
+                }
+                const wsState = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getConnectionState();
+                throw new Error(`Failed to fetch market data - no markets available (enabledDexs=${enabledDexs.length}, failed=[${failedDexs.join(',')}], succeeded=[${succeededDexs.join(',')}], wsState=${wsState}, details=[${failedDetails.join(';')}])`);
+            }
+            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[getMarketDataWithPrices] Retry succeeded', {
+                marketCount: combinedUniverse.length,
+            });
+        }
+        const partialFailures = latestDexResults.filter((result) => result.errorMessage);
+        if (partialFailures.length > 0) {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Market data fetch completed with partial per-DEX failures', {
+                failures: partialFailures.map((result) => `${result.dex ?? 'main'}:${result.failedStep ?? 'unknown'}:${result.errorMessage}`),
+            });
         }
         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquidProvider: Aggregated market data from all DEXs', {
             dexCount: enabledDexs.length,
             totalMarkets: combinedUniverse.length,
-            mainDexMarkets: dexDataResults[0]?.meta?.universe?.length ?? 0,
+            mainDexMarkets: latestDexResults[0]?.meta?.universe?.length ?? 0,
             hip3Markets: combinedUniverse.length -
-                (dexDataResults[0]?.meta?.universe?.length ?? 0),
+                (latestDexResults[0]?.meta?.universe?.length ?? 0),
         });
         // Debug: Log combinedAllMids to diagnose price lookup issues
         const hip3Keys = Object.keys(combinedAllMids).filter((key) => key.includes(':'));
@@ -2168,11 +2244,12 @@ export class HyperLiquidProvider {
             samplePrices: Object.fromEntries(Object.entries(combinedAllMids).slice(0, 5)),
         });
         // Transform to UI-friendly format using standalone utility
-        return transformMarketData({
+        const transformedMarketData = transformMarketData({
             universe: combinedUniverse,
             assetCtxs: combinedAssetCtxs,
             allMids: combinedAllMids,
         }, __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").marketDataFormatters, HIP3_ASSET_MARKET_TYPES);
+        return __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_cacheFreshMarketDataSnapshot).call(this, transformedMarketData, latestDexResults);
     }
     /**
      * Validate deposit parameters according to HyperLiquid-specific rules
@@ -3304,6 +3381,7 @@ export class HyperLiquidProvider {
             __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").clear();
             __classPrivateFieldSet(this, _HyperLiquidProvider_cachedSpotMeta, null, "f");
             __classPrivateFieldSet(this, _HyperLiquidProvider_perpDexsCache, { data: null, timestamp: 0 }, "f");
+            __classPrivateFieldSet(this, _HyperLiquidProvider_dexDiscoveryComplete, false, "f");
             // Await pending initialization before clearing to prevent the IIFE from
             // setting clientsInitialized = true after disconnect completes
             const pendingInit = __classPrivateFieldGet(this, _HyperLiquidProvider_initializationPromise, "f");
@@ -3452,6 +3530,15 @@ export class HyperLiquidProvider {
             throw error;
         }
     }
+    async fetchHistoricalCandles(options) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").ensureInitialized();
+        const result = await __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").fetchHistoricalCandles(options);
+        return (result ?? {
+            symbol: options.symbol,
+            interval: options.interval,
+            candles: [],
+        });
+    }
     /**
      * Get block explorer URL for an address or just the base URL
      *
@@ -3469,7 +3556,7 @@ export class HyperLiquidProvider {
         return `${baseUrl}/explorer`;
     }
 }
-_HyperLiquidProvider_deps = new WeakMap(), _HyperLiquidProvider_clientService = new WeakMap(), _HyperLiquidProvider_walletService = new WeakMap(), _HyperLiquidProvider_subscriptionService = new WeakMap(), _HyperLiquidProvider_symbolToAssetId = new WeakMap(), _HyperLiquidProvider_userFeeCache = new WeakMap(), _HyperLiquidProvider_maxLeverageCache = new WeakMap(), _HyperLiquidProvider_cachedMetaByDex = new WeakMap(), _HyperLiquidProvider_cachedSpotMeta = new WeakMap(), _HyperLiquidProvider_perpDexsCache = new WeakMap(), _HyperLiquidProvider_referralCheckCache = new WeakMap(), _HyperLiquidProvider_builderFeeCheckCache = new WeakMap(), _HyperLiquidProvider_ensureReadyPromise = new WeakMap(), _HyperLiquidProvider_pendingBuilderFeeApprovals = new WeakMap(), _HyperLiquidProvider_compiledAllowlistPatterns = new WeakMap(), _HyperLiquidProvider_compiledBlocklistPatterns = new WeakMap(), _HyperLiquidProvider_userFeeDiscountBips = new WeakMap(), _HyperLiquidProvider_hip3Enabled = new WeakMap(), _HyperLiquidProvider_allowlistMarkets = new WeakMap(), _HyperLiquidProvider_blocklistMarkets = new WeakMap(), _HyperLiquidProvider_useDexAbstraction = new WeakMap(), _HyperLiquidProvider_cachedValidatedDexs = new WeakMap(), _HyperLiquidProvider_cachedAllPerpDexs = new WeakMap(), _HyperLiquidProvider_pendingValidatedDexsPromise = new WeakMap(), _HyperLiquidProvider_cachedUsdcTokenId = new WeakMap(), _HyperLiquidProvider_errorMappings = new WeakMap(), _HyperLiquidProvider_clientsInitialized = new WeakMap(), _HyperLiquidProvider_initializationPromise = new WeakMap(), _HyperLiquidProvider_messenger = new WeakMap(), _HyperLiquidProvider_tradingSetupPromise = new WeakMap(), _HyperLiquidProvider_tradingSetupComplete = new WeakMap(), _HyperLiquidProvider_instances = new WeakSet(), _HyperLiquidProvider_compilePatternsSafely = function _HyperLiquidProvider_compilePatternsSafely(patterns, listName) {
+_HyperLiquidProvider_deps = new WeakMap(), _HyperLiquidProvider_clientService = new WeakMap(), _HyperLiquidProvider_walletService = new WeakMap(), _HyperLiquidProvider_subscriptionService = new WeakMap(), _HyperLiquidProvider_symbolToAssetId = new WeakMap(), _HyperLiquidProvider_userFeeCache = new WeakMap(), _HyperLiquidProvider_maxLeverageCache = new WeakMap(), _HyperLiquidProvider_cachedMetaByDex = new WeakMap(), _HyperLiquidProvider_cachedMarketDataWithPrices = new WeakMap(), _HyperLiquidProvider_cachedSpotMeta = new WeakMap(), _HyperLiquidProvider_perpDexsCache = new WeakMap(), _HyperLiquidProvider_referralCheckCache = new WeakMap(), _HyperLiquidProvider_builderFeeCheckCache = new WeakMap(), _HyperLiquidProvider_ensureReadyPromise = new WeakMap(), _HyperLiquidProvider_pendingBuilderFeeApprovals = new WeakMap(), _HyperLiquidProvider_compiledAllowlistPatterns = new WeakMap(), _HyperLiquidProvider_compiledBlocklistPatterns = new WeakMap(), _HyperLiquidProvider_userFeeDiscountBips = new WeakMap(), _HyperLiquidProvider_hip3Enabled = new WeakMap(), _HyperLiquidProvider_allowlistMarkets = new WeakMap(), _HyperLiquidProvider_blocklistMarkets = new WeakMap(), _HyperLiquidProvider_useDexAbstraction = new WeakMap(), _HyperLiquidProvider_cachedValidatedDexs = new WeakMap(), _HyperLiquidProvider_cachedAllPerpDexs = new WeakMap(), _HyperLiquidProvider_dexDiscoveryComplete = new WeakMap(), _HyperLiquidProvider_pendingValidatedDexsPromise = new WeakMap(), _HyperLiquidProvider_cachedUsdcTokenId = new WeakMap(), _HyperLiquidProvider_errorMappings = new WeakMap(), _HyperLiquidProvider_clientsInitialized = new WeakMap(), _HyperLiquidProvider_initializationPromise = new WeakMap(), _HyperLiquidProvider_messenger = new WeakMap(), _HyperLiquidProvider_builderAddressTestnet = new WeakMap(), _HyperLiquidProvider_builderAddressMainnet = new WeakMap(), _HyperLiquidProvider_tradingSetupPromise = new WeakMap(), _HyperLiquidProvider_tradingSetupComplete = new WeakMap(), _HyperLiquidProvider_instances = new WeakSet(), _HyperLiquidProvider_compilePatternsSafely = function _HyperLiquidProvider_compilePatternsSafely(patterns, listName) {
     const compiled = [];
     for (const pattern of patterns) {
         try {
@@ -3665,8 +3752,8 @@ async function _HyperLiquidProvider_ensureReady() {
         await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_ensureClientsInitialized).call(this);
         // Verify clients are properly initialized
         __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").ensureInitialized();
-        // Build asset mapping on first call only (flags are immutable)
-        if (__classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").size === 0) {
+        // Build asset mapping on first call, or retry if DEX discovery previously failed
+        if (__classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").size === 0 || !__classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryComplete, "f")) {
             __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquidProvider: Building asset mapping', {
                 hip3Enabled: __classPrivateFieldGet(this, _HyperLiquidProvider_hip3Enabled, "f"),
                 allowlistMarkets: __classPrivateFieldGet(this, _HyperLiquidProvider_allowlistMarkets, "f"),
@@ -3679,8 +3766,15 @@ async function _HyperLiquidProvider_ensureReady() {
         // This prevents QR popups when just viewing the Perps section (critical for hardware wallets)
     })(), "f");
     // Await initialization - keep the promise so subsequent calls resolve immediately
-    // The promise is only reset in disconnect() for clean reconnection
+    // The promise is only reset in disconnect() for clean reconnection,
+    // or when DEX discovery was degraded so the next caller retries.
     await __classPrivateFieldGet(this, _HyperLiquidProvider_ensureReadyPromise, "f");
+    if (!__classPrivateFieldGet(this, _HyperLiquidProvider_dexDiscoveryComplete, "f")) {
+        // DEX discovery failed transiently — reset so next call retries.
+        // Trading still works (main DEX mapping is populated), but HIP-3 markets
+        // will be re-discovered on the next #ensureReady() call.
+        __classPrivateFieldSet(this, _HyperLiquidProvider_ensureReadyPromise, null, "f");
+    }
     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[ensureReady] Initialization complete');
 }, _HyperLiquidProvider_ensureReadyForTrading = async function _HyperLiquidProvider_ensureReadyForTrading() {
     // First ensure basic initialization is complete
@@ -3883,20 +3977,23 @@ async function _HyperLiquidProvider_fetchValidatedDexsInternal() {
         allDexs = await infoClient.perpDexs();
     }
     catch (error) {
-        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").logger.error(ensureError(error, 'HyperLiquidProvider.fetchValidatedDexsInternal'), __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getErrorContext).call(this, 'getValidatedDexs.perpDexs'));
-        __classPrivateFieldSet(this, _HyperLiquidProvider_cachedAllPerpDexs, [null], "f");
-        __classPrivateFieldSet(this, _HyperLiquidProvider_cachedValidatedDexs, [null], "f");
-        return __classPrivateFieldGet(this, _HyperLiquidProvider_cachedValidatedDexs, "f");
+        // debugLogger not logger.error: this is a handled transient failure — the app
+        // recovers to main DEX via return [null]. Sending to Sentry as error() is noise.
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[fetchValidatedDexsInternal] perpDexs() call failed, falling back to main DEX', {
+            error: String(error),
+            ...__classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getErrorContext).call(this, 'getValidatedDexs.perpDexs'),
+        });
+        // Do not cache — transient error, allow retry on next call
+        return [null];
     }
-    // Cache for buildAssetMapping() to avoid duplicate call
-    __classPrivateFieldSet(this, _HyperLiquidProvider_cachedAllPerpDexs, allDexs, "f");
     // Validate API response
     if (!allDexs || !Array.isArray(allDexs)) {
         __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquidProvider: Failed to fetch DEX list (invalid response), falling back to main DEX only', { allDexs });
-        __classPrivateFieldSet(this, _HyperLiquidProvider_cachedAllPerpDexs, [null], "f");
-        __classPrivateFieldSet(this, _HyperLiquidProvider_cachedValidatedDexs, [null], "f");
-        return __classPrivateFieldGet(this, _HyperLiquidProvider_cachedValidatedDexs, "f");
+        // Do not cache — may be transient, allow retry on next call
+        return [null];
     }
+    // Cache for buildAssetMapping() to avoid duplicate call
+    __classPrivateFieldSet(this, _HyperLiquidProvider_cachedAllPerpDexs, allDexs, "f");
     // Extract HIP-3 DEX names (filter out null which represents main DEX)
     const availableHip3Dexs = [];
     allDexs.forEach((dex) => {
@@ -4028,19 +4125,105 @@ async function _HyperLiquidProvider_getCachedMeta(params) {
     }
     // Cache miss or skipCache=true - fetch from API
     const infoClient = __classPrivateFieldGet(this, _HyperLiquidProvider_clientService, "f").getInfoClient();
-    const meta = await infoClient.meta({ dex: dexKey });
+    // Pass dex only for HIP-3 DEXs; omit for main DEX (empty string).
+    // Testnet API returns null when dex="" is explicitly sent.
+    const meta = await infoClient.meta(dexKey ? { dex: dexKey } : undefined);
     // Defensive validation before caching
     if (!meta?.universe || !Array.isArray(meta.universe)) {
         throw new Error(`[HyperLiquidProvider] Invalid meta response for DEX ${dexDisplayName}: universe is ${meta?.universe ? 'not an array' : 'missing'}`);
     }
     // Store raw meta response for reuse
     __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").set(dexKey, meta);
+    await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_backfillAssetMapForDex).call(this, dexName, meta);
     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[getCachedMeta] Fetched and cached meta response', {
         dex: dexDisplayName,
         universeSize: meta.universe.length,
         skipCache,
     });
     return meta;
+}, _HyperLiquidProvider_backfillAssetMapForDex = 
+/**
+ * Backfill the asset ID map for a single DEX from a fresh meta response.
+ * Used to repair partial asset mapping when an individual DEX becomes available later.
+ *
+ * @param dex - DEX name (null for main DEX).
+ * @param meta - Meta response containing the DEX universe.
+ * @returns True if the mapping was rebuilt for the DEX.
+ */
+async function _HyperLiquidProvider_backfillAssetMapForDex(dex, meta) {
+    if (!meta?.universe || !Array.isArray(meta.universe)) {
+        return false;
+    }
+    if (!__classPrivateFieldGet(this, _HyperLiquidProvider_cachedAllPerpDexs, "f")) {
+        try {
+            await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getValidatedDexs).call(this);
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[backfillAssetMapForDex] Unable to refresh validated DEXs before rebuilding asset map', {
+                dex: dex ?? 'main',
+                error: ensureError(error, 'HyperLiquidProvider.backfillAssetMapForDex').message,
+            });
+        }
+    }
+    const allPerpDexs = __classPrivateFieldGet(this, _HyperLiquidProvider_cachedAllPerpDexs, "f") ?? [null];
+    const perpDexIndex = allPerpDexs.findIndex((entry) => {
+        if (dex === null) {
+            return entry === null;
+        }
+        return entry !== null && entry.name === dex;
+    });
+    if (perpDexIndex === -1) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[backfillAssetMapForDex] Could not find perpDexIndex for DEX', { dex: dex ?? 'main' });
+        return false;
+    }
+    const { symbolToAssetId } = buildAssetMapping({
+        metaUniverse: meta.universe,
+        dex,
+        perpDexIndex,
+    });
+    symbolToAssetId.forEach((assetId, coin) => {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").set(coin, assetId);
+    });
+    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[backfillAssetMapForDex] Rebuilt asset mapping for DEX', {
+        dex: dex ?? 'main',
+        dexAssetCount: symbolToAssetId.size,
+        totalAssetCount: __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").size,
+    });
+    return symbolToAssetId.size > 0;
+}, _HyperLiquidProvider_getAssetIdWithRepair = 
+/**
+ * Resolve an asset ID, repairing the DEX-specific map when meta is available but the map is stale.
+ *
+ * @param params - Resolution parameters.
+ * @param params.symbol - Asset symbol to resolve.
+ * @param params.dexName - DEX name (null for main DEX).
+ * @param params.meta - Optional pre-fetched meta for the DEX.
+ * @returns The asset ID.
+ */
+async function _HyperLiquidProvider_getAssetIdWithRepair(params) {
+    const { symbol, dexName } = params;
+    const existingAssetId = __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").get(symbol);
+    if (existingAssetId !== undefined) {
+        return existingAssetId;
+    }
+    const meta = params.meta ?? (await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getCachedMeta).call(this, { dexName: dexName ?? null }));
+    const assetExistsInMeta = meta.universe.some((asset) => asset.name === symbol);
+    if (assetExistsInMeta) {
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_backfillAssetMapForDex).call(this, dexName, meta);
+        const repairedAssetId = __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").get(symbol);
+        if (repairedAssetId !== undefined) {
+            return repairedAssetId;
+        }
+    }
+    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('Asset ID lookup failed', {
+        requestedCoin: symbol,
+        dexName: dexName ?? 'main',
+        mapSize: __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").size,
+        mapContainsAsset: __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").has(symbol),
+        assetExistsInMeta,
+        allKeys: Array.from(__classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").keys()).slice(0, 20),
+    });
+    throw new Error(`Asset ID not found for ${symbol}`);
 }, _HyperLiquidProvider_getCachedSpotMeta = 
 /**
  * Fetch spot metadata with session-based caching
@@ -4337,7 +4520,7 @@ async function _HyperLiquidProvider_swapUsdcToUsdh(amount) {
     if (!usdhUsdcPair) {
         return { success: false, error: PERPS_ERROR_CODES.SPOT_PAIR_NOT_FOUND };
     }
-    const spotAssetId = 10000 + usdhUsdcPair.index;
+    const spotAssetId = SPOT_ASSET_ID_OFFSET + usdhUsdcPair.index;
     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquidProvider: Found USDH/USDC spot pair', {
         pairIndex: usdhUsdcPair.index,
         pairName: usdhUsdcPair.name,
@@ -4507,12 +4690,23 @@ async function _HyperLiquidProvider_ensureUsdhCollateralForOrder(dexName, requir
  */
 async function _HyperLiquidProvider_buildAssetMapping() {
     // Get feature-flag-validated DEXs to map (respects hip3Enabled and enabledDexs)
-    const dexsToMap = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getValidatedDexs).call(this);
-    // Use cached perpDexs array (populated by getValidatedDexs)
-    const allPerpDexs = __classPrivateFieldGet(this, _HyperLiquidProvider_cachedAllPerpDexs, "f");
-    if (!allPerpDexs) {
-        throw new Error('perpDexs not cached - getValidatedDexs must be called first');
-    }
+    let dexsToMap;
+    try {
+        dexsToMap = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getValidatedDexs).call(this);
+    }
+    catch (dexError) {
+        // If getValidatedDexs fails, fall back to main DEX only to keep the provider
+        // functional. Without this, a transient perpDexs() failure would permanently
+        // brick #ensureReady via the cached rejected promise.
+        // Do not set #cachedAllPerpDexs or #cachedValidatedDexs here — leave them null
+        // so #getValidatedDexs retries on the next call (same as #fetchValidatedDexsInternal).
+        __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[buildAssetMapping] getValidatedDexs failed, falling back to main DEX', { error: String(dexError) });
+        dexsToMap = [null];
+    }
+    // Local fallback only — never write [null] into #cachedAllPerpDexs here.
+    // That cache is owned exclusively by #fetchValidatedDexsInternal; writing a
+    // fallback here would prevent subsequent callers from retrying perpDexs().
+    const allPerpDexs = __classPrivateFieldGet(this, _HyperLiquidProvider_cachedAllPerpDexs, "f") ?? [null];
     __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('HyperLiquidProvider: Starting asset mapping rebuild', {
         dexs: dexsToMap,
         previousMapSize: __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").size,
@@ -4565,6 +4759,7 @@ async function _HyperLiquidProvider_buildAssetMapping() {
     }));
     // Build mapping with DEX prefixes for HIP-3 DEXs using the utility function
     __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").clear();
+    let dexDiscoveryComplete = __classPrivateFieldGet(this, _HyperLiquidProvider_cachedValidatedDexs, "f") !== null;
     allMetas.forEach((result) => {
         if (result.status === 'fulfilled' &&
             result.value.success &&
@@ -4576,6 +4771,7 @@ async function _HyperLiquidProvider_buildAssetMapping() {
                     hasUniverse: Boolean(meta.universe),
                     isArray: Array.isArray(meta.universe),
                 });
+                dexDiscoveryComplete = false;
                 return;
             }
             // Find perpDexIndex for this DEX in the perpDexs array
@@ -4589,6 +4785,7 @@ async function _HyperLiquidProvider_buildAssetMapping() {
             });
             if (perpDexIndex === -1) {
                 __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log(`HyperLiquidProvider: Could not find perpDexIndex for DEX ${dex ?? 'main'}`);
+                dexDiscoveryComplete = false;
                 return;
             }
             // Use the utility function to build mapping for this DEX
@@ -4602,7 +4799,11 @@ async function _HyperLiquidProvider_buildAssetMapping() {
                 __classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").set(coin, assetId);
             });
         }
+        else {
+            dexDiscoveryComplete = false;
+        }
     });
+    __classPrivateFieldSet(this, _HyperLiquidProvider_dexDiscoveryComplete, dexDiscoveryComplete, "f");
     const allKeys = Array.from(__classPrivateFieldGet(this, _HyperLiquidProvider_symbolToAssetId, "f").keys());
     const mainDexKeys = allKeys.filter((key) => !key.includes(':')).slice(0, 5);
     const hip3Keys = allKeys.filter((key) => key.includes(':')).slice(0, 10);
@@ -4633,14 +4834,26 @@ async function _HyperLiquidProvider_buildAssetMapping() {
  */
 async function _HyperLiquidProvider_queryUserDataAcrossDexs(baseParams, queryFn) {
     const enabledDexs = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getValidatedDexs).call(this);
-    const results = await Promise.all(enabledDexs.map(async (dex) => {
+    const settledResults = await Promise.allSettled(enabledDexs.map(async (dex) => {
         const params = dex
             ? { ...baseParams, dex }
             : baseParams;
-        const data = await queryFn(params);
-        return { dex, data };
+        return queryFn(params);
     }));
-    return results;
+    const results = [];
+    const failedDexs = [];
+    settledResults.forEach((result, index) => {
+        const dex = enabledDexs[index];
+        if (result.status === 'fulfilled') {
+            results.push({ dex, data: result.value });
+            return;
+        }
+        failedDexs.push({
+            dex,
+            error: ensureError(result.reason, 'HyperLiquidProvider.queryUserDataAcrossDexs'),
+        });
+    });
+    return { results, failedDexs };
 }, _HyperLiquidProvider_mapError = function _HyperLiquidProvider_mapError(error) {
     const { message } = ensureError(error, 'HyperLiquidProvider.mapError');
     for (const [pattern, code] of Object.entries(__classPrivateFieldGet(this, _HyperLiquidProvider_errorMappings, "f"))) {
@@ -5442,6 +5655,11 @@ async function _HyperLiquidProvider_getStandaloneValidatedDexs() {
     if (!allDexs || !Array.isArray(allDexs)) {
         return [null];
     }
+    // Populate #cachedAllPerpDexs so buildAssetMapping can compute perpDexIndex.
+    // Without this, getValidatedDexs returns from #cachedValidatedDexs (string names)
+    // but #cachedAllPerpDexs (raw objects for index computation) stays null,
+    // causing "Could not find perpDexIndex for DEX xyz" failures.
+    __classPrivateFieldSet(this, _HyperLiquidProvider_cachedAllPerpDexs, allDexs, "f");
     // Extract HIP-3 DEX names (filter out null which represents main DEX)
     const availableHip3Dexs = [];
     allDexs.forEach((dex) => {
@@ -5458,6 +5676,100 @@ async function _HyperLiquidProvider_getStandaloneValidatedDexs() {
     const filteredDexs = availableHip3Dexs.filter((dex) => allowedDexsFromAllowlist.includes(dex));
     __classPrivateFieldSet(this, _HyperLiquidProvider_cachedValidatedDexs, [null, ...filteredDexs], "f");
     return __classPrivateFieldGet(this, _HyperLiquidProvider_cachedValidatedDexs, "f");
+}, _HyperLiquidProvider_getAllMids = 
+/**
+ * Get allMids for a DEX — uses WS snapshot as primary source, REST as fallback.
+ *
+ * @param infoClient - The HyperLiquid info client (used only on cold start).
+ * @param dexParam - Optional DEX parameter (empty string for main DEX).
+ * @returns allMids record.
+ */
+async function _HyperLiquidProvider_getAllMids(infoClient, dexParam) {
+    const wsSnapshot = __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").getLastAllMidsSnapshot?.(dexParam);
+    if (wsSnapshot) {
+        return wsSnapshot;
+    }
+    __classPrivateFieldGet(this, _HyperLiquidProvider_deps, "f").debugLogger.log('[getMarketDataWithPrices] No WS allMids snapshot, falling back to REST', { dexParam: dexParam ?? 'main' });
+    const mids = await infoClient.allMids(dexParam ? { dex: dexParam } : undefined);
+    return mids ?? {};
+}, _HyperLiquidProvider_fetchSingleDexFresh = async function _HyperLiquidProvider_fetchSingleDexFresh(infoClient, dex) {
+    const dexParam = dex ?? '';
+    let metaAndCtxs = null;
+    try {
+        metaAndCtxs = (await infoClient.metaAndAssetCtxs(dexParam ? { dex: dexParam } : undefined));
+    }
+    catch (error) {
+        return {
+            dex,
+            meta: null,
+            assetCtxs: [],
+            allMids: {},
+            success: false,
+            failedStep: 'metaAndAssetCtxs',
+            errorMessage: ensureError(error, 'HyperLiquidProvider.getMarketDataWithPrices.metaAndAssetCtxs').message,
+        };
+    }
+    const meta = metaAndCtxs?.[0] ?? null;
+    const assetCtxs = metaAndCtxs?.[1] ?? [];
+    let dexAllMids = {};
+    let allMidsErrorMessage;
+    try {
+        dexAllMids = await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_getAllMids).call(this, infoClient, dexParam || undefined);
+    }
+    catch (error) {
+        allMidsErrorMessage = ensureError(error, 'HyperLiquidProvider.getMarketDataWithPrices.allMids').message;
+    }
+    if (meta?.universe) {
+        __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMetaByDex, "f").set(dexParam, meta);
+        __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexMetaCache(dexParam, meta);
+        __classPrivateFieldGet(this, _HyperLiquidProvider_subscriptionService, "f").setDexAssetCtxsCache(dexParam, assetCtxs);
+        await __classPrivateFieldGet(this, _HyperLiquidProvider_instances, "m", _HyperLiquidProvider_backfillAssetMapForDex).call(this, dex, meta);
+    }
+    return {
+        dex,
+        meta,
+        assetCtxs,
+        allMids: dexAllMids,
+        success: Boolean(meta?.universe),
+        failedStep: allMidsErrorMessage ? 'allMids' : undefined,
+        errorMessage: allMidsErrorMessage,
+    };
+}, _HyperLiquidProvider_mergeDexResultsInto = function _HyperLiquidProvider_mergeDexResultsInto(results, combinedUniverse, combinedAssetCtxs, combinedAllMids) {
+    results.forEach((result) => {
+        if (result.success && result.meta?.universe) {
+            const marketsFromDex = result.meta.universe;
+            const filteredMarkets = result.dex === null
+                ? marketsFromDex
+                : marketsFromDex.filter((asset) => shouldIncludeMarket(asset.name, result.dex, __classPrivateFieldGet(this, _HyperLiquidProvider_hip3Enabled, "f"), __classPrivateFieldGet(this, _HyperLiquidProvider_compiledAllowlistPatterns, "f"), __classPrivateFieldGet(this, _HyperLiquidProvider_compiledBlocklistPatterns, "f")));
+            combinedUniverse.push(...filteredMarkets);
+            combinedAssetCtxs.push(...result.assetCtxs);
+            Object.assign(combinedAllMids, result.allMids);
+        }
+    });
+}, _HyperLiquidProvider_cacheFreshMarketDataSnapshot = function _HyperLiquidProvider_cacheFreshMarketDataSnapshot(marketData, results) {
+    const freshMarketData = marketData.map((market) => ({
+        ...market,
+        isStale: false,
+    }));
+    __classPrivateFieldSet(this, _HyperLiquidProvider_cachedMarketDataWithPrices, {
+        data: freshMarketData.map((market) => ({ ...market })),
+        timestamp: Date.now(),
+        contributingDexs: results
+            .filter((result) => result.success && result.meta?.universe)
+            .map((result) => result.dex ?? 'main'),
+        failedDexs: results
+            .filter((result) => !result.success)
+            .map((result) => result.dex ?? 'main'),
+    }, "f");
+    return freshMarketData;
+}, _HyperLiquidProvider_getStaleMarketDataSnapshot = function _HyperLiquidProvider_getStaleMarketDataSnapshot() {
+    if (!__classPrivateFieldGet(this, _HyperLiquidProvider_cachedMarketDataWithPrices, "f")) {
+        return null;
+    }
+    return __classPrivateFieldGet(this, _HyperLiquidProvider_cachedMarketDataWithPrices, "f").data.map((market) => ({
+        ...market,
+        isStale: true,
+    }));
 }, _HyperLiquidProvider_isFeeCacheValid = function _HyperLiquidProvider_isFeeCacheValid(userAddress) {
     const cached = __classPrivateFieldGet(this, _HyperLiquidProvider_userFeeCache, "f").get(userAddress);
     if (!cached) {
@@ -5465,9 +5777,13 @@ async function _HyperLiquidProvider_getStandaloneValidatedDexs() {
     }
     return Date.now() - cached.timestamp < cached.ttl;
 }, _HyperLiquidProvider_getBuilderAddress = function _HyperLiquidProvider_getBuilderAddress(isTestnet) {
-    return isTestnet
-        ? BUILDER_FEE_CONFIG.TestnetBuilder
-        : BUILDER_FEE_CONFIG.MainnetBuilder;
+    // || intentional: env vars default to '' which must fall through to the hardcoded default
+    if (isTestnet) {
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        return __classPrivateFieldGet(this, _HyperLiquidProvider_builderAddressTestnet, "f") || BUILDER_FEE_CONFIG.TestnetBuilder;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+    return __classPrivateFieldGet(this, _HyperLiquidProvider_builderAddressMainnet, "f") || BUILDER_FEE_CONFIG.MainnetBuilder;
 }, _HyperLiquidProvider_getReferralCode = function _HyperLiquidProvider_getReferralCode(isTestnet) {
     return isTestnet
         ? REFERRAL_CONFIG.TestnetCode