@pear-protocol/hyperliquid-sdk 0.1.0 → 0.1.3

package/dist/index.js

@@ -316,10 +316,10 @@ const getMarketInfoFromSymbol = (symbol) => {
         const name = symbol.slice(separatorIndex + 1);
         return {
             symbolName: name || symbol,
-            marketName: prefix || 'hyperliquid',
+            marketName: prefix || '',
         };
     }
-    return { symbolName: symbol, marketName: 'hyperliquid' };
+    return { symbolName: symbol, marketName: '' };
 };
 
 /**
@@ -341,40 +341,60 @@ function symbolsMatch(assetName, searchSymbol) {
  */
 class TokenMetadataExtractor {
     /**
-     * Extracts comprehensive token metadata
+     * Checks if token data is available in aggregated universe assets
+     * @param symbol - Token symbol
+     * @param perpMetaAssets - Aggregated universe assets
+     * @returns boolean indicating if token exists in universe
+     */
+    static isTokenAvailable(symbol, perpMetaAssets) {
+        if (!perpMetaAssets)
+            return false;
+        return perpMetaAssets.some((asset) => symbolsMatch(asset.name, symbol));
+    }
+    /**
+     * Extracts token metadata using DEX-aware lookup (correctly matches perpMetas to assetContexts)
      * @param symbol - Token symbol (e.g., "BTC", "TSLA")
-     * @param perpMetaAssets - Aggregated universe assets (flattened across dexes)
-     * @param finalAssetContexts - Aggregated asset contexts (flattened across dexes)
+     * @param perpMetasByDex - Map of DEX name to UniverseAsset[]
+     * @param assetContextsByDex - Map of DEX name to WebData3AssetCtx[]
      * @param allMids - AllMids data containing current prices
      * @param activeAssetData - Optional active asset data containing leverage information
+     * @param finalAtOICaps - Optional array of symbols at OI caps
      * @returns TokenMetadata or null if token not found
      */
-    static extractTokenMetadata(symbol, perpMetaAssets, finalAssetContexts, allMids, activeAssetData, finalAtOICaps) {
-        if (!perpMetaAssets || !finalAssetContexts || !allMids) {
-            return null;
+    static extractTokenMetadataByDex(symbol, perpMetasByDex, assetContextsByDex, allMids, activeAssetData, finalAtOICaps) {
+        let foundDexName = null;
+        let foundAssetIndex = -1;
+        let foundAsset = null;
+        for (const [dexName, assets] of perpMetasByDex) {
+            const assetIndex = assets.findIndex((asset) => symbolsMatch(asset.name, symbol));
+            if (assetIndex !== -1) {
+                foundDexName = dexName;
+                foundAssetIndex = assetIndex;
+                foundAsset = assets[assetIndex];
+                break;
+            }
         }
-        const universeIndex = perpMetaAssets.findIndex((asset) => symbolsMatch(asset.name, symbol));
-        if (universeIndex === -1) {
+        if (!foundDexName || foundAssetIndex === -1 || !foundAsset) {
             return null;
         }
-        const universeAsset = perpMetaAssets[universeIndex];
-        const assetCtx = finalAssetContexts[universeIndex];
+        const dexContexts = assetContextsByDex.get(foundDexName);
+        const assetCtx = dexContexts === null || dexContexts === void 0 ? void 0 : dexContexts[foundAssetIndex];
         if (!assetCtx) {
             return null;
         }
         // Get current price - prefer assetCtx.midPx as it's already index-matched,
         // fall back to allMids lookup if midPx is null
-        const actualSymbol = universeAsset.name;
+        const actualSymbol = foundAsset.name;
         let currentPrice = 0;
-        // Primary source: assetCtx.midPx (already properly indexed)
-        if (assetCtx.midPx) {
-            currentPrice = parseFloat(assetCtx.midPx);
-        }
-        // Fallback: allMids lookup
+        // Fallback: assetCtx.midPx (already properly indexed)
         if (!currentPrice || isNaN(currentPrice)) {
             const currentPriceStr = allMids.mids[actualSymbol] || allMids.mids[symbol];
             currentPrice = currentPriceStr ? parseFloat(currentPriceStr) : 0;
         }
+        // Primary source: allMids lookup
+        if (assetCtx.midPx) {
+            currentPrice = parseFloat(assetCtx.midPx);
+        }
         // Get previous day price
         const prevDayPrice = parseFloat(assetCtx.prevDayPx);
         // Calculate 24h price change
@@ -390,20 +410,17 @@ class TokenMetadataExtractor {
         const maxTradeSzs = tokenActiveData === null || tokenActiveData === void 0 ? void 0 : tokenActiveData.maxTradeSzs;
         const availableToTrade = tokenActiveData === null || tokenActiveData === void 0 ? void 0 : tokenActiveData.availableToTrade;
         const { symbolName, marketName } = getMarketInfoFromSymbol(actualSymbol);
-        const assetName = symbolName;
         return {
-            assetName,
+            assetName: foundAsset.name,
             symbolName,
             marketName,
-            isAtOiCaps: finalAtOICaps
-                ? finalAtOICaps.includes(symbol)
-                : false,
+            isAtOiCaps: finalAtOICaps ? finalAtOICaps.includes(symbol) : false,
             currentPrice,
             prevDayPrice,
             priceChange24h,
             priceChange24hPercent,
             netFunding,
-            maxLeverage: universeAsset.maxLeverage,
+            maxLeverage: foundAsset.maxLeverage,
             markPrice,
             oraclePrice,
             openInterest: assetCtx.openInterest,
@@ -411,54 +428,24 @@ class TokenMetadataExtractor {
             leverage,
             maxTradeSzs,
             availableToTrade,
-            collateralToken: universeAsset.collateralToken,
+            collateralToken: foundAsset.collateralToken,
         };
     }
-    /**
-     * Extracts metadata for multiple tokens
-     * @param tokens - Array of token strings (e.g., "BTC", "TSLA")
-     * @param perpMetaAssets - Aggregated universe assets
-     * @param finalAssetContexts - Aggregated asset contexts
-     * @param allMids - AllMids data
-     * @param activeAssetData - Optional active asset data containing leverage information
-     * @returns Record of token string to TokenMetadata (keys match input tokens exactly)
-     */
-    static extractMultipleTokensMetadata(tokens, perpMetaAssets, finalAssetContexts, allMids, activeAssetData, finalAtOICaps) {
-        const result = {};
-        for (const token of tokens) {
-            result[token] = this.extractTokenMetadata(token, perpMetaAssets, finalAssetContexts, allMids, activeAssetData, finalAtOICaps);
-        }
-        return result;
-    }
-    /**
-     * Checks if token data is available in aggregated universe assets
-     * @param symbol - Token symbol
-     * @param perpMetaAssets - Aggregated universe assets
-     * @returns boolean indicating if token exists in universe
-     */
-    static isTokenAvailable(symbol, perpMetaAssets) {
-        if (!perpMetaAssets)
-            return false;
-        return perpMetaAssets.some((asset) => symbolsMatch(asset.name, symbol));
-    }
 }
-
+// Helper functions for token metadata
 const buildOiCapSet = (finalAtOICaps) => new Set((finalAtOICaps !== null && finalAtOICaps !== void 0 ? finalAtOICaps : [])
     .filter(Boolean)
     .map((value) => value.toUpperCase()));
-const isAtOiCaps = (symbol, symbolName, oiCapSet) => oiCapSet.has(symbol.toUpperCase()) ||
-    oiCapSet.has(symbolName.toUpperCase());
+const isAtOiCaps = (assetName, oiCapSet) => oiCapSet.has(assetName.toUpperCase());
 const applyMetadataContext = (symbol, metadata, oiCapSet) => {
     if (!metadata)
         return null;
     const { symbolName, marketName } = getMarketInfoFromSymbol(symbol);
-    const assetName = symbolName;
     return {
         ...metadata,
-        assetName,
         symbolName,
         marketName,
-        isAtOiCaps: isAtOiCaps(symbol, symbolName, oiCapSet),
+        isAtOiCaps: isAtOiCaps(symbol, oiCapSet),
     };
 };
 const applyOiCapsToMetadataMap = (tokenMetadata, finalAtOICaps) => {
@@ -472,30 +459,79 @@ const applyOiCapsToMetadataMap = (tokenMetadata, finalAtOICaps) => {
     });
     return next;
 };
-const buildTokenMetadataMap = ({ perpMetaAssets, finalAssetContexts, allMids, activeAssetData, finalAtOICaps, }) => {
-    if (!perpMetaAssets || !finalAssetContexts || !allMids) {
+const shouldSkipToken = (asset, oiCapSet) => {
+    if (asset.isDelisted)
+        return true;
+    if (isAtOiCaps(asset.name, oiCapSet))
+        return true;
+    return false;
+};
+const buildTokenMetadataMap = ({ perpMetasByDex, assetContextsByDex, allMids, activeAssetData, finalAtOICaps, }) => {
+    if (!perpMetasByDex || !assetContextsByDex || !allMids) {
         return {};
     }
     const oiCapSet = buildOiCapSet(finalAtOICaps);
-    const symbols = perpMetaAssets.map((asset) => asset.name);
-    const metadataMap = TokenMetadataExtractor.extractMultipleTokensMetadata(symbols, perpMetaAssets, finalAssetContexts, allMids, activeAssetData, finalAtOICaps);
-    symbols.forEach((symbol) => {
-        metadataMap[symbol] = applyMetadataContext(symbol, metadataMap[symbol], oiCapSet);
-    });
+    const metadataMap = {};
+    // Iterate through all DEXes and their assets
+    for (const [, assets] of perpMetasByDex) {
+        for (const asset of assets) {
+            if (shouldSkipToken(asset, oiCapSet)) {
+                continue;
+            }
+            const symbol = asset.name;
+            const metadata = TokenMetadataExtractor.extractTokenMetadataByDex(symbol, perpMetasByDex, assetContextsByDex, allMids, activeAssetData, finalAtOICaps);
+            metadataMap[symbol] = applyMetadataContext(symbol, metadata, oiCapSet);
+        }
+    }
     return metadataMap;
 };
-const updateTokenMetadataForSymbols = (prev, symbols, { perpMetaAssets, finalAssetContexts, allMids, activeAssetData, finalAtOICaps, }) => {
-    if (!perpMetaAssets || !finalAssetContexts || !allMids) {
+const updateTokenMetadataForSymbols = (prev, symbols, { perpMetasByDex, assetContextsByDex, allMids, activeAssetData, finalAtOICaps, }) => {
+    if (!perpMetasByDex || !assetContextsByDex || !allMids) {
         return prev;
     }
     const oiCapSet = buildOiCapSet(finalAtOICaps);
     const next = { ...prev };
     symbols.forEach((symbol) => {
-        next[symbol] = applyMetadataContext(symbol, TokenMetadataExtractor.extractTokenMetadata(symbol, perpMetaAssets, finalAssetContexts, allMids, activeAssetData), oiCapSet);
+        // Find asset in any DEX
+        let foundAsset;
+        for (const [, assets] of perpMetasByDex) {
+            foundAsset = assets.find((a) => a.name === symbol);
+            if (foundAsset)
+                break;
+        }
+        if (foundAsset && shouldSkipToken(foundAsset, oiCapSet)) {
+            delete next[symbol];
+            return;
+        }
+        next[symbol] = applyMetadataContext(symbol, TokenMetadataExtractor.extractTokenMetadataByDex(symbol, perpMetasByDex, assetContextsByDex, allMids, activeAssetData, finalAtOICaps), oiCapSet);
     });
     return next;
 };
-const useHyperliquidData = create((set, get) => ({
+const refreshTokenMetadata = (state, overrides, options) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const inputs = {
+        perpMetaAssets: (_a = overrides.perpMetaAssets) !== null && _a !== void 0 ? _a : state.perpMetaAssets,
+        finalAssetContexts: (_b = overrides.finalAssetContexts) !== null && _b !== void 0 ? _b : state.finalAssetContexts,
+        allMids: (_c = overrides.allMids) !== null && _c !== void 0 ? _c : state.allMids,
+        activeAssetData: (_d = overrides.activeAssetData) !== null && _d !== void 0 ? _d : state.activeAssetData,
+        finalAtOICaps: (_e = overrides.finalAtOICaps) !== null && _e !== void 0 ? _e : state.finalAtOICaps,
+        // DEX-aware inputs
+        perpMetasByDex: (_f = overrides.perpMetasByDex) !== null && _f !== void 0 ? _f : state.perpMetasByDex,
+        assetContextsByDex: (_g = overrides.assetContextsByDex) !== null && _g !== void 0 ? _g : state.assetContextsByDex,
+    };
+    if (!inputs.perpMetasByDex || !inputs.assetContextsByDex || !inputs.allMids) {
+        return state.tokenMetadata;
+    }
+    if (options === null || options === void 0 ? void 0 : options.oiCapsOnly) {
+        return applyOiCapsToMetadataMap(state.tokenMetadata, inputs.finalAtOICaps);
+    }
+    if ((_h = options === null || options === void 0 ? void 0 : options.symbols) === null || _h === void 0 ? void 0 : _h.length) {
+        return updateTokenMetadataForSymbols(state.tokenMetadata, options.symbols, inputs);
+    }
+    return buildTokenMetadataMap(inputs);
+};
+
+const useHyperliquidData = create((set) => ({
     allMids: null,
     activeAssetData: null,
     candleData: null,
@@ -505,45 +541,30 @@ const useHyperliquidData = create((set, get) => ({
     rawClearinghouseStates: null,
     perpMetaAssets: null,
     tokenMetadata: {},
+    perpDexs: null,
+    perpMetasByDex: null,
+    assetContextsByDex: null,
     setAllMids: (value) => set((state) => ({
         allMids: value,
-        tokenMetadata: buildTokenMetadataMap({
-            perpMetaAssets: state.perpMetaAssets,
-            finalAssetContexts: state.finalAssetContexts,
-            allMids: value,
-            activeAssetData: state.activeAssetData,
-            finalAtOICaps: state.finalAtOICaps,
-        }),
+        tokenMetadata: refreshTokenMetadata(state, { allMids: value }),
     })),
     setActiveAssetData: (value) => set((state) => {
         const activeAssetData = typeof value === 'function' ? value(state.activeAssetData) : value;
         return {
             activeAssetData,
-            tokenMetadata: buildTokenMetadataMap({
-                perpMetaAssets: state.perpMetaAssets,
-                finalAssetContexts: state.finalAssetContexts,
-                allMids: state.allMids,
-                activeAssetData,
-                finalAtOICaps: state.finalAtOICaps,
-            }),
+            tokenMetadata: refreshTokenMetadata(state, { activeAssetData }),
         };
     }),
     deleteActiveAssetData: (key) => {
         set((state) => {
             if (!state.activeAssetData || !(key in state.activeAssetData)) {
-                return state; // No change if key doesn't exist
+                return state;
             }
-            const updated = { ...state.activeAssetData };
-            delete updated[key];
+            const activeAssetData = { ...state.activeAssetData };
+            delete activeAssetData[key];
             return {
-                activeAssetData: updated,
-                tokenMetadata: updateTokenMetadataForSymbols(state.tokenMetadata, [key], {
-                    perpMetaAssets: state.perpMetaAssets,
-                    finalAssetContexts: state.finalAssetContexts,
-                    allMids: state.allMids,
-                    activeAssetData: updated,
-                    finalAtOICaps: state.finalAtOICaps,
-                }),
+                activeAssetData,
+                tokenMetadata: refreshTokenMetadata(state, { activeAssetData }, { symbols: [key] }),
             };
         });
     },
@@ -568,47 +589,41 @@ const useHyperliquidData = create((set, get) => ({
     setCandleData: (value) => set({ candleData: value }),
     upsertActiveAssetData: (key, value) => set((state) => {
         var _a;
-        const activeAssetData = {
-            ...((_a = state.activeAssetData) !== null && _a !== void 0 ? _a : {}),
-            [key]: value,
-        };
+        const activeAssetData = { ...((_a = state.activeAssetData) !== null && _a !== void 0 ? _a : {}), [key]: value };
         return {
             activeAssetData,
-            tokenMetadata: updateTokenMetadataForSymbols(state.tokenMetadata, [key], {
-                perpMetaAssets: state.perpMetaAssets,
-                finalAssetContexts: state.finalAssetContexts,
-                allMids: state.allMids,
-                activeAssetData,
-                finalAtOICaps: state.finalAtOICaps,
-            }),
+            tokenMetadata: refreshTokenMetadata(state, { activeAssetData }, { symbols: [key] }),
         };
     }),
     setFinalAssetContexts: (value) => set((state) => ({
         finalAssetContexts: value,
-        tokenMetadata: buildTokenMetadataMap({
-            perpMetaAssets: state.perpMetaAssets,
-            finalAssetContexts: value,
-            allMids: state.allMids,
-            activeAssetData: state.activeAssetData,
-            finalAtOICaps: state.finalAtOICaps,
-        }),
+        tokenMetadata: refreshTokenMetadata(state, { finalAssetContexts: value }),
     })),
     setFinalAtOICaps: (value) => set((state) => ({
         finalAtOICaps: value,
-        tokenMetadata: applyOiCapsToMetadataMap(state.tokenMetadata, value),
+        tokenMetadata: refreshTokenMetadata(state, { finalAtOICaps: value }, { oiCapsOnly: true }),
     })),
     setAggregatedClearingHouseState: (value) => set({ aggregatedClearingHouseState: value }),
     setRawClearinghouseStates: (value) => set({ rawClearinghouseStates: value }),
     setPerpMetaAssets: (value) => set((state) => ({
         perpMetaAssets: value,
-        tokenMetadata: buildTokenMetadataMap({
-            perpMetaAssets: value,
-            finalAssetContexts: state.finalAssetContexts,
-            allMids: state.allMids,
-            activeAssetData: state.activeAssetData,
-            finalAtOICaps: state.finalAtOICaps,
+        tokenMetadata: refreshTokenMetadata(state, { perpMetaAssets: value }),
+    })),
+    setPerpDexs: (value) => set({ perpDexs: value }),
+    setPerpMetasByDex: (value) => set((state) => ({
+        perpMetasByDex: value,
+        tokenMetadata: refreshTokenMetadata(state, {
+            perpMetasByDex: value,
+            assetContextsByDex: state.assetContextsByDex,
+        }),
+    })),
+    setAssetContextsByDex: (value) => set((state) => ({
+        assetContextsByDex: value,
+        tokenMetadata: refreshTokenMetadata(state, {
+            assetContextsByDex: value,
+            perpMetasByDex: state.perpMetasByDex,
         }),
-    }))
+    })),
 }));
 
 /**
@@ -871,7 +886,7 @@ const useUserSelection$1 = create((set, get) => ({
 }));
 
 const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }) => {
-    const { setAllMids, setActiveAssetData, upsertActiveAssetData, setCandleData, deleteCandleSymbol, deleteActiveAssetData, addCandleData, setFinalAssetContexts, setFinalAtOICaps, setAggregatedClearingHouseState, setRawClearinghouseStates, } = useHyperliquidData();
+    const { setAllMids, setActiveAssetData, upsertActiveAssetData, setCandleData, deleteCandleSymbol, deleteActiveAssetData, addCandleData, setFinalAtOICaps, setAggregatedClearingHouseState, setRawClearinghouseStates, setAssetContextsByDex, } = useHyperliquidData();
     const { setSpotState } = useUserData();
     const { candleInterval } = useUserSelection$1();
     const userSummary = useUserData((state) => state.accountSummary);
@@ -924,22 +939,13 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
                     case 'allDexsAssetCtxs':
                         {
                             const data = response.data;
-                            // Filter out hyna to match perpMetaAssets filtering
-                            const FILTERED_DEX_PREFIXES = ['hyna'];
-                            const filtered = (data.ctxs || [])
-                                .filter(([prefix]) => !FILTERED_DEX_PREFIXES.includes((prefix || '').toLowerCase()))
-                                .sort((a, b) => {
-                                // Sort to match perpMetaAssets order: default market first, then alphabetically
-                                const prefixA = a[0] || '';
-                                const prefixB = b[0] || '';
-                                if (prefixA === '' && prefixB !== '')
-                                    return -1;
-                                if (prefixA !== '' && prefixB === '')
-                                    return 1;
-                                return prefixA.localeCompare(prefixB);
+                            // Store by DEX name, mapping '' to 'HYPERLIQUID'
+                            const assetContextsByDex = new Map();
+                            data.ctxs.forEach(([dexKey, ctxs]) => {
+                                const dexName = dexKey === '' ? 'HYPERLIQUID' : dexKey;
+                                assetContextsByDex.set(dexName, ctxs || []);
                             });
-                            const finalAssetContexts = filtered.flatMap(([, ctxs]) => ctxs || []);
-                            setFinalAssetContexts(finalAssetContexts);
+                            setAssetContextsByDex(assetContextsByDex);
                         }
                         break;
                     case 'allDexsClearinghouseState':
@@ -1020,10 +1026,10 @@ const useHyperliquidNativeWebSocket = ({ address, enabled = true, onUserFills, }
         setAllMids,
         upsertActiveAssetData,
         addCandleData,
-        setFinalAssetContexts,
         setFinalAtOICaps,
         setAggregatedClearingHouseState,
         setRawClearinghouseStates,
+        setAssetContextsByDex,
         setSpotState,
         onUserFills,
     ]);
@@ -1507,7 +1513,36 @@ const useOpenOrders = () => {
 };
 
 const useUserSelection = () => {
-    return useUserSelection$1();
+    const longTokens = useUserSelection$1((s) => s.longTokens);
+    const shortTokens = useUserSelection$1((s) => s.shortTokens);
+    const candleInterval = useUserSelection$1((s) => s.candleInterval);
+    const openTokenSelector = useUserSelection$1((s) => s.openTokenSelector);
+    const selectorConfig = useUserSelection$1((s) => s.selectorConfig);
+    const openConflictModal = useUserSelection$1((s) => s.openConflictModal);
+    const setLongTokens = useUserSelection$1((s) => s.setLongTokens);
+    const setShortTokens = useUserSelection$1((s) => s.setShortTokens);
+    const setCandleInterval = useUserSelection$1((s) => s.setCandleInterval);
+    const setTokenSelections = useUserSelection$1((s) => s.setTokenSelections);
+    const setOpenTokenSelector = useUserSelection$1((s) => s.setOpenTokenSelector);
+    const setSelectorConfig = useUserSelection$1((s) => s.setSelectorConfig);
+    const setOpenConflictModal = useUserSelection$1((s) => s.setOpenConflictModal);
+    const addToken = useUserSelection$1((s) => s.addToken);
+    return {
+        longTokens,
+        shortTokens,
+        candleInterval,
+        openTokenSelector,
+        selectorConfig,
+        openConflictModal,
+        setLongTokens,
+        setShortTokens,
+        setCandleInterval,
+        setTokenSelections,
+        setOpenTokenSelector,
+        setSelectorConfig,
+        setOpenConflictModal,
+        addToken,
+    };
 };
 
 const useTokenSelectionMetadataStore = create((set) => ({
@@ -1523,11 +1558,10 @@ const useTokenSelectionMetadataStore = create((set) => ({
     volume: "0",
     sumNetFunding: 0,
     maxLeverage: 0,
-    minMargin: 0,
+    minSize: {},
     leverageMatched: true,
-    recompute: ({ perpMetaAssets, tokenMetadata, marketData, longTokens, shortTokens, }) => {
+    recompute: ({ tokenMetadata, marketData, longTokens, shortTokens, }) => {
         const isPriceDataReady = Object.keys(tokenMetadata).length > 0;
-        // Get token symbols for lookups
         const longSymbols = longTokens.map((t) => t.symbol);
         const shortSymbols = shortTokens.map((t) => t.symbol);
         // Get metadata
@@ -1650,24 +1684,37 @@ const useTokenSelectionMetadataStore = create((set) => ({
         })();
         // Max leverage (maximum across all tokens)
         const maxLeverage = (() => {
-            if (!perpMetaAssets)
+            if (!tokenMetadata)
                 return 0;
             const allSymbols = [...longSymbols, ...shortSymbols];
             if (allSymbols.length === 0)
                 return 0;
             let maxLev = 0;
             allSymbols.forEach((symbol) => {
-                const tokenUniverse = perpMetaAssets.find((u) => u.name === symbol);
-                if (tokenUniverse === null || tokenUniverse === void 0 ? void 0 : tokenUniverse.maxLeverage) {
-                    maxLev = Math.max(maxLev, tokenUniverse.maxLeverage);
+                var _a;
+                const tokenDetail = tokenMetadata[symbol];
+                if ((_a = tokenDetail === null || tokenDetail === void 0 ? void 0 : tokenDetail.leverage) === null || _a === void 0 ? void 0 : _a.value) {
+                    maxLev = Math.max(maxLev, tokenDetail.leverage.value);
                 }
             });
             return maxLev;
         })();
-        // Min margin (10 * total number of tokens)
-        const minMargin = (() => {
-            const totalTokenCount = longTokens.length + shortTokens.length;
-            return 10 * totalTokenCount;
+        const minSize = (() => {
+            const allSymbols = [...longSymbols, ...shortSymbols];
+            const collateralCounts = {};
+            allSymbols.forEach((symbol) => {
+                var _a;
+                const collateralToken = (_a = tokenMetadata[symbol]) === null || _a === void 0 ? void 0 : _a.collateralToken;
+                if (collateralToken) {
+                    collateralCounts[collateralToken] =
+                        (collateralCounts[collateralToken] || 0) + 1;
+                }
+            });
+            const minSizeMap = {};
+            Object.entries(collateralCounts).forEach(([collateral, count]) => {
+                minSizeMap[collateral] = 11 * count;
+            });
+            return minSizeMap;
         })();
         // Whether all tokens have matching leverage
         const leverageMatched = (() => {
@@ -1702,7 +1749,7 @@ const useTokenSelectionMetadataStore = create((set) => ({
             volume,
             sumNetFunding,
             maxLeverage,
-            minMargin,
+            minSize,
             leverageMatched,
         });
     },
@@ -1717,11 +1764,10 @@ const useTokenSelectionMetadata = () => {
     const tokenMetadata = useHyperliquidData((state) => state.tokenMetadata);
     const marketData = useMarketData((state) => state.marketData);
     const { longTokens, shortTokens } = useUserSelection$1();
-    const { isLoading, isPriceDataReady, longTokensMetadata, shortTokensMetadata, weightedRatio, weightedRatio24h, priceRatio, priceRatio24h, openInterest, volume, sumNetFunding, maxLeverage, minMargin, leverageMatched, recompute, } = useTokenSelectionMetadataStore();
+    const { isLoading, isPriceDataReady, longTokensMetadata, shortTokensMetadata, weightedRatio, weightedRatio24h, priceRatio, priceRatio24h, openInterest, volume, sumNetFunding, maxLeverage, minSize, leverageMatched, recompute, } = useTokenSelectionMetadataStore();
     // Recompute derived metadata when inputs change
     useEffect(() => {
         recompute({
-            perpMetaAssets,
             tokenMetadata,
             marketData: marketData || null,
             longTokens,
@@ -1745,8 +1791,8 @@ const useTokenSelectionMetadata = () => {
         volume,
         sumNetFunding,
         maxLeverage,
-        minMargin,
         leverageMatched,
+        minSize,
     };
 };
 
@@ -5935,6 +5981,26 @@ const fetchExtraAgents = async (user) => {
         throw toApiError(error);
     }
 };
+/**
+ * Fetch perp dexes from HyperLiquid API
+ * Endpoint: https://api.hyperliquid.xyz/info
+ * Payload: { "type": "perpDexs" }
+ * Returns array where index 0 is null (HYPERLIQUID), index 1+ are named DEXes
+ */
+const fetchPerpDexs = async () => {
+    const request = { type: 'perpDexs' };
+    try {
+        const response = await axios$1.post('https://api.hyperliquid.xyz/info', request, { headers: { 'Content-Type': 'application/json' } });
+        return {
+            data: response.data,
+            status: response.status,
+            headers: response.headers,
+        };
+    }
+    catch (error) {
+        throw toApiError(error);
+    }
+};
 
 const useHistoricalPriceData = () => {
     const context = useContext(PearHyperliquidContext);
@@ -6496,7 +6562,6 @@ const usePerformanceOverlays = () => {
         overlays.forEach(overlay => {
             symbols.push(overlay.symbol);
         });
-        console.log("final symbols", symbols);
         return symbols;
     }, [overlays]);
     return {
@@ -7172,132 +7237,62 @@ function useNotifications() {
     };
 }
 
-// Convert a basket item to the expected type
-function enrichBasketItem(item) {
-    const enrichedLongs = item.longAssets.map((a) => ({
-        ...a,
-    }));
-    const enrichedShorts = item.shortAssets.map((a) => ({
-        ...a,
-    }));
-    // // Determine collateral type
-    // const allAssets = [...enrichedLongs, ...enrichedShorts];
-    // const hasUsdc = allAssets.some((a) => a.collateralToken === 'USDC');
-    // const hasUsdh = allAssets.some((a) => a.collateralToken === 'USDH');
-    // let collateralType: 'USDC' | 'USDH' | 'MIXED' = 'USDC';
-    // if (hasUsdc && hasUsdh) {
-    //   collateralType = 'MIXED';
-    // } else if (hasUsdh) {
-    //   collateralType = 'USDH';
-    // }
+function enrichBasketWithMetadata(basket, tokenMetadata) {
     return {
-        ...item,
-        longAssets: enrichedLongs,
-        shortAssets: enrichedShorts,
-        collateralType: 'USDC', //TODO: change
+        ...basket,
+        longAssets: basket.longAssets.map((asset) => {
+            var _a;
+            return ({
+                ...asset,
+                metadata: (_a = tokenMetadata[asset.asset]) !== null && _a !== void 0 ? _a : null,
+            });
+        }),
+        shortAssets: basket.shortAssets.map((asset) => {
+            var _a;
+            return ({
+                ...asset,
+                metadata: (_a = tokenMetadata[asset.asset]) !== null && _a !== void 0 ? _a : null,
+            });
+        }),
     };
 }
-/**
- * Filter baskets by collateral type
- * - 'USDC': Only baskets where ALL assets use USDC (collateralType === 'USDC')
- * - 'USDH': Only baskets where ALL assets use USDH (collateralType === 'USDH')
- * - 'ALL' or undefined: No filtering, returns all baskets
- */
-function filterByCollateral(baskets, filter) {
-    if (!filter || filter === 'ALL') {
-        return baskets;
-    }
-    return baskets.filter((basket) => {
-        if (filter === 'USDC') {
-            // Include baskets that are purely USDC or have USDC assets
-            return (basket.collateralType === 'USDC' || basket.collateralType === 'MIXED');
-        }
-        if (filter === 'USDH') {
-            // Include baskets that are purely USDH or have USDH assets
-            return (basket.collateralType === 'USDH' || basket.collateralType === 'MIXED');
-        }
-        return true;
-    });
+function enrichBasketsWithMetadata(baskets, tokenMetadata) {
+    return baskets.map((basket) => enrichBasketWithMetadata(basket, tokenMetadata));
 }
-// Base selector for the full market-data payload (raw from WS)
-const useMarketDataPayload = () => {
-    return useMarketData((s) => s.marketData);
-};
-// Active baskets
-const useActiveBaskets = (collateralFilter) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        if (!(data === null || data === void 0 ? void 0 : data.active))
-            return [];
-        const enriched = data.active.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, collateralFilter]);
-};
-// Top gainers
-const useTopGainers = (limit, collateralFilter) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        var _a;
-        const list = (_a = data === null || data === void 0 ? void 0 : data.topGainers) !== null && _a !== void 0 ? _a : [];
-        const limited = typeof limit === 'number' ? list.slice(0, Math.max(0, limit)) : list;
-        const enriched = limited.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, limit, collateralFilter]);
-};
-// Top losers
-const useTopLosers = (limit, collateralFilter) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        var _a;
-        const list = (_a = data === null || data === void 0 ? void 0 : data.topLosers) !== null && _a !== void 0 ? _a : [];
-        const limited = typeof limit === 'number' ? list.slice(0, Math.max(0, limit)) : list;
-        const enriched = limited.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, limit, collateralFilter]);
-};
-// Highlighted baskets
-const useHighlightedBaskets = (collateralFilter) => {
-    const data = useMarketDataPayload();
+const useMarketDataHook = (options = {}) => {
+    const { topGainersLimit, topLosersLimit } = options;
+    const data = useMarketData((s) => s.marketData);
+    const tokenMetadata = useHyperliquidData((s) => s.tokenMetadata);
     return useMemo(() => {
-        if (!(data === null || data === void 0 ? void 0 : data.highlighted))
-            return [];
-        const enriched = data.highlighted.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, collateralFilter]);
-};
-// Watchlist baskets
-const useWatchlistBaskets = (collateralFilter) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        if (!(data === null || data === void 0 ? void 0 : data.watchlist))
-            return [];
-        const enriched = data.watchlist.map((item) => enrichBasketItem(item));
-        return filterByCollateral(enriched, collateralFilter);
-    }, [data, collateralFilter]);
-};
-// Find a basket by its exact asset composition (order-insensitive)
-const useFindBasket = (longs, shorts) => {
-    const data = useMarketDataPayload();
-    return useMemo(() => {
-        if (!data)
-            return undefined;
-        const normalize = (arr) => Array.isArray(arr)
-            ? arr
-                .map((v) => (typeof v === 'string' ? v : v === null || v === void 0 ? void 0 : v.asset))
-                .filter(Boolean)
-                .map((s) => s.toUpperCase())
-                .sort()
-                .join(',')
-            : '';
-        const lKey = normalize(longs);
-        const sKey = normalize(shorts);
-        const match = (item) => normalize(item.longAssets) === lKey &&
-            normalize(item.shortAssets) === sKey;
-        const found = data.active.find(match) || data.highlighted.find(match);
-        return found
-            ? enrichBasketItem(found)
-            : undefined;
-    }, [data, longs, shorts]);
+        var _a, _b, _c;
+        const activeBaskets = enrichBasketsWithMetadata((_a = data === null || data === void 0 ? void 0 : data.active) !== null && _a !== void 0 ? _a : [], tokenMetadata);
+        const topGainers = (() => {
+            var _a;
+            const list = (_a = data === null || data === void 0 ? void 0 : data.topGainers) !== null && _a !== void 0 ? _a : [];
+            const limited = typeof topGainersLimit === 'number'
+                ? list.slice(0, Math.max(0, topGainersLimit))
+                : list;
+            return enrichBasketsWithMetadata(limited, tokenMetadata);
+        })();
+        const topLosers = (() => {
+            var _a;
+            const list = (_a = data === null || data === void 0 ? void 0 : data.topLosers) !== null && _a !== void 0 ? _a : [];
+            const limited = typeof topLosersLimit === 'number'
+                ? list.slice(0, Math.max(0, topLosersLimit))
+                : list;
+            return enrichBasketsWithMetadata(limited, tokenMetadata);
+        })();
+        const highlightedBaskets = enrichBasketsWithMetadata((_b = data === null || data === void 0 ? void 0 : data.highlighted) !== null && _b !== void 0 ? _b : [], tokenMetadata);
+        const watchlistBaskets = enrichBasketsWithMetadata((_c = data === null || data === void 0 ? void 0 : data.watchlist) !== null && _c !== void 0 ? _c : [], tokenMetadata);
+        return {
+            marketData: data,
+            activeBaskets,
+            topGainers,
+            topLosers,
+            highlightedBaskets,
+            watchlistBaskets,
+        };
+    }, [data, tokenMetadata, topGainersLimit, topLosersLimit]);
 };
 
 async function toggleWatchlist(baseUrl, longAssets, shortAssets) {
@@ -7323,7 +7318,7 @@ function useWatchlist() {
     if (!context)
         throw new Error('useWatchlist must be used within a PearHyperliquidProvider');
     const { apiBaseUrl, isConnected } = context;
-    const marketData = useMarketDataPayload();
+    const marketData = useMarketData(s => s.marketData);
     const isLoading = useMemo(() => !marketData && isConnected, [marketData, isConnected]);
     const toggle = async (longAssets, shortAssets) => {
         const resp = await toggleWatchlist(apiBaseUrl, longAssets, shortAssets);
@@ -7582,104 +7577,174 @@ function useAuth() {
 
 const useAllUserBalances = () => {
     const spotState = useUserData((state) => state.spotState);
-    const aggregatedClearingHouseState = useHyperliquidData((state) => state.aggregatedClearingHouseState);
-    const rawClearinghouseStates = useHyperliquidData((state) => state.rawClearinghouseStates);
     const { longTokensMetadata, shortTokensMetadata } = useTokenSelectionMetadata();
-    return useMemo(() => {
-        const isLoading = !spotState || !aggregatedClearingHouseState;
-        // Helper function to truncate to 2 decimal places without rounding
-        const truncateToTwoDecimals = (value) => {
-            return Math.floor(value * 100) / 100;
-        };
-        // Get spot balances from spotState
-        let spotUsdcBal = undefined;
-        let spotUsdhBal = undefined;
-        if (spotState) {
-            const balances = spotState.balances || [];
-            for (const balance of balances) {
+    const { longTokens, shortTokens } = useUserSelection$1();
+    const aggregatedClearingHouseState = useHyperliquidData((state) => state.aggregatedClearingHouseState);
+    const { spotBalances, availableToTrades, isLoading } = useMemo(() => {
+        const isLoading = !spotState;
+        const spotBalances = {};
+        const availableToTrades = {};
+        if (spotState === null || spotState === void 0 ? void 0 : spotState.balances) {
+            for (const balance of spotState.balances) {
                 const total = parseFloat(balance.total || '0');
-                if (balance.coin === 'USDC') {
-                    spotUsdcBal = truncateToTwoDecimals(total);
-                }
-                if (balance.coin === 'USDH') {
-                    spotUsdhBal = truncateToTwoDecimals(total);
-                }
+                spotBalances[balance.coin] = total;
             }
         }
-        // Get available to trade from tokenMetadata for both USDC and USDH markets
-        let availableToTradeUsdcFromAsset = 0;
-        let availableToTradeUsdhFromAsset = 0;
-        // Token metadata only contains availableToTrade for SELECTED tokens (user's long and short Tokens)
-        // It does NOT contain data for all tokens, so we cannot reliably use it for available to trade as used on hl trade page
-        // so intead, we rely on rawClearinghouseStates which provides market-specific data
-        const selectedMetadataEntries = [
-            ...Object.entries(longTokensMetadata),
-            ...Object.entries(shortTokensMetadata),
+        const allMetadataWithSource = [
+            ...Object.values(longTokensMetadata).map((m) => ({
+                metadata: m,
+                isLong: true,
+            })),
+            ...Object.values(shortTokensMetadata).map((m) => ({
+                metadata: m,
+                isLong: false,
+            })),
         ];
-        selectedMetadataEntries.forEach(([symbol, metadata]) => {
-            var _a;
-            const availableStr = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.availableToTrade) === null || _a === void 0 ? void 0 : _a[0];
-            if (!availableStr)
-                return;
-            const availableValue = truncateToTwoDecimals(parseFloat(availableStr || '0'));
-            if ((metadata === null || metadata === void 0 ? void 0 : metadata.collateralToken) === 'USDH') {
-                availableToTradeUsdhFromAsset = Math.max(availableToTradeUsdhFromAsset, availableValue);
-                return;
-            }
-            if ((metadata === null || metadata === void 0 ? void 0 : metadata.collateralToken) === 'USDC') {
-                availableToTradeUsdcFromAsset = Math.max(availableToTradeUsdcFromAsset, availableValue);
-                return;
-            }
-            if (symbol.includes(':')) {
-                const prefix = symbol.split(':')[0];
-                if (prefix === 'xyz') {
-                    availableToTradeUsdcFromAsset = Math.max(availableToTradeUsdcFromAsset, availableValue);
-                }
-                else {
-                    availableToTradeUsdhFromAsset = Math.max(availableToTradeUsdhFromAsset, availableValue);
-                }
-                return;
+        for (const { metadata, isLong } of allMetadataWithSource) {
+            if (!(metadata === null || metadata === void 0 ? void 0 : metadata.collateralToken) || !(metadata === null || metadata === void 0 ? void 0 : metadata.availableToTrade))
+                continue;
+            const collateralCoin = metadata.collateralToken;
+            const availableToTrade = metadata.availableToTrade;
+            let value = parseFloat(availableToTrade[isLong ? 0 : 1] || '0');
+            if (!(collateralCoin in availableToTrades) ||
+                value < availableToTrades[collateralCoin]) {
+                availableToTrades[collateralCoin] = value;
             }
-            availableToTradeUsdcFromAsset = Math.max(availableToTradeUsdcFromAsset, availableValue);
-        });
-        // Calculate USDC available to trade
-        // Priority 1: Use value from activeAssetData if available (> 0)
-        // Priority 2: Calculate from USDC-specific clearinghouseState (empty prefix)
-        let availableToTradeUsdcValue = undefined;
-        if (availableToTradeUsdcFromAsset > 0) {
-            availableToTradeUsdcValue = availableToTradeUsdcFromAsset;
         }
-        else if (rawClearinghouseStates) {
-            // Find USDC market (empty prefix)
-            const usdcMarket = rawClearinghouseStates.find(([prefix]) => prefix === '');
-            const usdcState = usdcMarket === null || usdcMarket === void 0 ? void 0 : usdcMarket[1];
-            if (usdcState === null || usdcState === void 0 ? void 0 : usdcState.marginSummary) {
-                const accountValue = parseFloat(usdcState.marginSummary.accountValue || '0');
-                const totalMarginUsed = parseFloat(usdcState.marginSummary.totalMarginUsed || '0');
-                const calculatedValue = Math.max(0, accountValue - totalMarginUsed);
-                availableToTradeUsdcValue = truncateToTwoDecimals(calculatedValue);
-            }
+        if (!availableToTrades['USDC']) {
+            availableToTrades['USDC'] = parseFloat((aggregatedClearingHouseState === null || aggregatedClearingHouseState === void 0 ? void 0 : aggregatedClearingHouseState.marginSummary.totalRawUsd) || '0');
         }
-        // Calculate USDH available to trade
-        // Priority 1: Use value from activeAssetData if available (> 0)
-        // Priority 2: Use spot USDH balance
-        const availableToTradeUsdhValue = availableToTradeUsdhFromAsset > 0
-            ? availableToTradeUsdhFromAsset
-            : spotUsdhBal;
         return {
-            spotUsdcBalance: spotUsdcBal,
-            availableToTradeUsdc: availableToTradeUsdcValue,
-            spotUsdhBalance: spotUsdhBal,
-            availableToTradeUsdh: availableToTradeUsdhValue,
+            spotBalances,
+            availableToTrades,
             isLoading,
         };
+    }, [spotState, longTokensMetadata, shortTokensMetadata, aggregatedClearingHouseState]);
+    /**
+     * Calculate margin required for every collateral token based on asset leverages and size.
+     * Returns margin required per collateral and whether there's sufficient margin.
+     */
+    const getMarginRequired = useCallback((assetsLeverage, size) => {
+        const sizeValue = parseFloat(String(size)) || 0;
+        // Group tokens by collateral type and calculate margin required
+        const marginByCollateral = {};
+        // Process all tokens (long and short)
+        const allTokensWithMetadata = [
+            ...longTokens.map((t) => ({
+                ...t,
+                metadata: longTokensMetadata[t.symbol],
+            })),
+            ...shortTokens.map((t) => ({
+                ...t,
+                metadata: shortTokensMetadata[t.symbol],
+            })),
+        ];
+        let totalMarginRequired = 0;
+        allTokensWithMetadata.forEach((token) => {
+            var _a;
+            const weight = token.weight || 0;
+            const assetSize = (sizeValue * weight) / 100;
+            const assetLeverage = assetsLeverage[token.symbol] || 1;
+            const assetMargin = assetLeverage > 0 ? assetSize / assetLeverage : 0;
+            // Get collateral type from metadata, default to USDC
+            const collateralToken = ((_a = token.metadata) === null || _a === void 0 ? void 0 : _a.collateralToken) || 'USDC';
+            if (!marginByCollateral[collateralToken]) {
+                marginByCollateral[collateralToken] = 0;
+            }
+            marginByCollateral[collateralToken] += assetMargin;
+            totalMarginRequired += assetMargin;
+        });
+        const perCollateral = Object.entries(marginByCollateral).map(([collateral, marginRequired]) => {
+            var _a;
+            const collateralToken = collateral;
+            const availableBalance = (_a = availableToTrades[collateralToken]) !== null && _a !== void 0 ? _a : 0;
+            const hasEnough = marginRequired <= availableBalance;
+            const shortfall = Math.max(0, marginRequired - availableBalance);
+            return {
+                collateral: collateralToken,
+                marginRequired: Number(marginRequired.toFixed(2)),
+                availableBalance: Number(availableBalance.toFixed(2)),
+                hasEnough,
+                shortfall: Number(shortfall.toFixed(2)),
+            };
+        });
+        const hasEnoughTotal = perCollateral.every((c) => c.hasEnough);
+        return {
+            totalMarginRequired: Number(totalMarginRequired.toFixed(2)),
+            orderValue: sizeValue,
+            perCollateral,
+            hasEnoughTotal,
+        };
     }, [
-        spotState,
-        aggregatedClearingHouseState,
-        rawClearinghouseStates,
+        longTokens,
+        shortTokens,
         longTokensMetadata,
         shortTokensMetadata,
+        spotBalances,
+        availableToTrades,
     ]);
+    /**
+     * Calculate the maximum order size ($) based on available balances and asset leverages.
+     * Returns the overall maximum order size constrained by all collateral types.
+     */
+    const getMaxSize = useCallback((assetsLeverage) => {
+        const marginFactorByCollateral = {};
+        const allTokensWithMetadata = [
+            ...longTokens.map((t) => ({
+                ...t,
+                metadata: longTokensMetadata[t.symbol],
+            })),
+            ...shortTokens.map((t) => ({
+                ...t,
+                metadata: shortTokensMetadata[t.symbol],
+            })),
+        ];
+        // Calculate the margin factor for each collateral type
+        // marginFactor = sum of (weight / leverage) for all assets using that collateral
+        allTokensWithMetadata.forEach((token) => {
+            var _a;
+            const weight = token.weight || 0;
+            const assetLeverage = assetsLeverage[token.symbol] || 1;
+            const collateralToken = ((_a = token.metadata) === null || _a === void 0 ? void 0 : _a.collateralToken) || 'USDC';
+            // marginFactor represents how much margin is needed per $1 of order size
+            const marginFactor = assetLeverage > 0 ? weight / (100 * assetLeverage) : 0;
+            if (!marginFactorByCollateral[collateralToken]) {
+                marginFactorByCollateral[collateralToken] = 0;
+            }
+            marginFactorByCollateral[collateralToken] += marginFactor;
+        });
+        // Calculate max size for each collateral type
+        // maxSize = availableBalance / marginFactor
+        // Each maxSize represents the total order size that collateral can support
+        const maxSizePerCollateral = [];
+        Object.entries(marginFactorByCollateral).forEach(([collateral, marginFactor]) => {
+            var _a;
+            const collateralToken = collateral;
+            const availableBalance = (_a = availableToTrades[collateralToken]) !== null && _a !== void 0 ? _a : 0;
+            if (marginFactor > 0) {
+                const maxSize = availableBalance / marginFactor;
+                maxSizePerCollateral.push(maxSize);
+            }
+        });
+        if (maxSizePerCollateral.length === 0) {
+            return 0;
+        }
+        const overallMaxSize = Math.min(...maxSizePerCollateral);
+        return Number(overallMaxSize.toFixed(2));
+    }, [
+        longTokens,
+        shortTokens,
+        longTokensMetadata,
+        shortTokensMetadata,
+        availableToTrades,
+    ]);
+    return {
+        spotBalances,
+        availableToTrades,
+        isLoading,
+        getMarginRequired,
+        getMaxSize,
+    };
 };
 
 /**
@@ -7821,9 +7886,10 @@ const PearHyperliquidContext = createContext(undefined);
 const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearprotocol.io', clientId = 'PEARPROTOCOLUI', wsUrl = 'wss://hl-ui.pearprotocol.io/ws', }) => {
     const address = useUserData((s) => s.address);
     const setAddress = useUserData((s) => s.setAddress);
-    const perpsMetaAssets = useHyperliquidData((state) => state.perpMetaAssets);
-    const setPerpMetaAssets = useHyperliquidData((state) => state.setPerpMetaAssets);
-    const websocketsEnabled = useMemo(() => Array.isArray(perpsMetaAssets) && perpsMetaAssets.length > 0, [perpsMetaAssets]);
+    const perpMetasByDex = useHyperliquidData((state) => state.perpMetasByDex);
+    const setPerpDexs = useHyperliquidData((state) => state.setPerpDexs);
+    const setPerpMetasByDex = useHyperliquidData((state) => state.setPerpMetasByDex);
+    const websocketsEnabled = useMemo(() => perpMetasByDex !== null && perpMetasByDex.size > 0, [perpMetasByDex]);
     const { handleUserFillsEvent } = useHyperliquidUserFills({
         baseUrl: apiBaseUrl,
         address,
@@ -7840,15 +7906,18 @@ const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearpro
         onUserFills: handleUserFillsEvent,
     });
     useEffect(() => {
-        if (perpsMetaAssets === null) {
-            fetchAllPerpMetas()
-                .then((res) => {
-                const allPerpMetas = [];
-                res.data.forEach((item) => {
-                    // Only include USDC and USDH collateral tokens
-                    if (item.collateralToken !== 360 && item.collateralToken !== 0) {
-                        return;
-                    }
+        if (perpMetasByDex === null) {
+            Promise.all([fetchPerpDexs(), fetchAllPerpMetas()])
+                .then(([perpDexsRes, perpMetasRes]) => {
+                const perpDexs = perpDexsRes.data;
+                const perpMetas = perpMetasRes.data;
+                setPerpDexs(perpDexs);
+                const metasByDex = new Map();
+                perpMetas.forEach((item, perpIndex) => {
+                    var _a, _b;
+                    const dexName = perpIndex === 0
+                        ? 'HYPERLIQUID'
+                        : ((_b = (_a = perpDexs[perpIndex]) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : `DEX_${perpIndex}`);
                     var collateralToken;
                     if (item.collateralToken === 360) {
                         collateralToken = 'USDH';
@@ -7856,22 +7925,23 @@ const PearHyperliquidProvider = ({ children, apiBaseUrl = 'https://hl-ui.pearpro
                     if (item.collateralToken === 0) {
                         collateralToken = 'USDC';
                     }
-                    item.universe.forEach((asset) => {
-                        const assetWithMeta = {
-                            ...asset,
-                            collateralToken,
-                        };
-                        allPerpMetas.push(assetWithMeta);
-                    });
+                    if (item.collateralToken === 235) {
+                        collateralToken = 'USDE';
+                    }
+                    if (item.collateralToken === 268) {
+                        collateralToken = 'USDT0';
+                    }
+                    const universeAssets = item.universe.map((asset) => ({
+                        ...asset,
+                        collateralToken,
+                    }));
+                    metasByDex.set(dexName, universeAssets);
                 });
-                setPerpMetaAssets(allPerpMetas);
+                setPerpMetasByDex(metasByDex);
             })
                 .catch(() => { });
         }
-    }, [
-        perpsMetaAssets,
-        setPerpMetaAssets,
-    ]);
+    }, [perpMetasByDex, setPerpDexs, setPerpMetasByDex]);
     const contextValue = useMemo(() => ({
         // Config
         clientId,
@@ -8155,4 +8225,4 @@ function getOrderTrailingInfo(order) {
     return undefined;
 }
 
-export { AccountSummaryCalculator, ConflictDetector, MAX_ASSETS_PER_LEG, MINIMUM_ASSET_USD_VALUE, MaxAssetsPerLegError, MinimumPositionSizeError, PearHyperliquidProvider, TokenMetadataExtractor, adjustAdvancePosition, adjustOrder, adjustPosition, calculateMinimumPositionValue, calculateWeightedRatio, cancelOrder, cancelTwap, cancelTwapOrder, closeAllPositions, closePosition, computeBasketCandles, createCandleLookups, createPosition, executeSpotOrder, getAssetByName, getCompleteTimestamps, getKalshiMarkets, getOrderDirection, getOrderLadderConfig, getOrderLeverage, getOrderReduceOnly, getOrderTpSlTriggerType, getOrderTrailingInfo, getOrderTriggerType, getOrderTriggerValue, getOrderTwapDuration, getOrderUsdValue, getPortfolio, isBtcDomOrder, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, selectTokenMetadataBySymbols, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useActiveBaskets, useAgentWallet, useAllUserBalances, useAuth, useBasketCandles, useFindBasket, useHighlightedBaskets, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidNativeWebSocket, useHyperliquidUserFills, useHyperliquidWebSocket, useMarket, useMarketData, useMarketDataPayload, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTopGainers, useTopLosers, useTradeHistories, useTwap, useUserSelection, useWatchlist, useWatchlistBaskets, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };
+export { ConflictDetector, MAX_ASSETS_PER_LEG, MINIMUM_ASSET_USD_VALUE, MaxAssetsPerLegError, MinimumPositionSizeError, PearHyperliquidProvider, adjustAdvancePosition, adjustOrder, adjustPosition, calculateMinimumPositionValue, calculateWeightedRatio, cancelOrder, cancelTwap, cancelTwapOrder, closeAllPositions, closePosition, computeBasketCandles, createCandleLookups, createPosition, executeSpotOrder, getCompleteTimestamps, getKalshiMarkets, getOrderDirection, getOrderLadderConfig, getOrderLeverage, getOrderReduceOnly, getOrderTpSlTriggerType, getOrderTrailingInfo, getOrderTriggerType, getOrderTriggerValue, getOrderTwapDuration, getOrderUsdValue, getPortfolio, isBtcDomOrder, mapCandleIntervalToTradingViewInterval, mapTradingViewIntervalToCandleInterval, markNotificationReadById, markNotificationsRead, toggleWatchlist, updateLeverage, updateRiskParameters, useAccountSummary, useAgentWallet, useAllUserBalances, useAuth, useBasketCandles, useHistoricalPriceData, useHistoricalPriceDataStore, useHyperliquidUserFills, useMarket, useMarketData, useMarketDataHook, useNotifications, useOpenOrders, useOrders, usePearHyperliquid, usePerformanceOverlays, usePortfolio, usePosition, useSpotOrder, useTokenSelectionMetadata, useTradeHistories, useTwap, useUserSelection, useWatchlist, validateMaxAssetsPerLeg, validateMinimumAssetSize, validatePositionSize };