@pear-protocol/hyperliquid-sdk 0.1.0 → 0.1.2

package/dist/clients/hyperliquid.d.ts

@@ -1,4 +1,4 @@
-import type { ApiResponse, CandleInterval, CandleData, ExternalFillDto, AllPerpMetasResponse, ExtraAgent, TwapSliceFillResponseItem } from '../types';
+import type { ApiResponse, CandleInterval, CandleData, ExternalFillDto, AllPerpMetasResponse, ExtraAgent, TwapSliceFillResponseItem, PerpDexsResponse } from '../types';
 /**
  * Fetch historical candle data from HyperLiquid API
  */
@@ -23,3 +23,10 @@ export declare const fetchAllPerpMetas: () => Promise<ApiResponse<AllPerpMetasRe
  * Payload: { "type": "extraAgents", "user": "0x..." }
  */
 export declare const fetchExtraAgents: (user: string) => Promise<ApiResponse<ExtraAgent[]>>;
+/**
+ * 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
+ */
+export declare const fetchPerpDexs: () => Promise<ApiResponse<PerpDexsResponse>>;

package/dist/index.d.ts

@@ -599,8 +599,10 @@ interface AssetCtx {
  * Collateral token type
  * 0 = USDC
  * 360 = USDH
+ * 235 = USDE
+ * 268 = USDT
  */
-type CollateralToken = 'USDC' | 'USDH';
+type CollateralToken = 'USDC' | 'USDH' | 'USDE' | 'USDT';
 /**
  * Universe asset metadata
  */
@@ -1483,26 +1485,6 @@ declare class ConflictDetector {
  * Extracts token metadata from aggregated WebData3 contexts and AllMids data
  */
 declare class TokenMetadataExtractor {
-    /**
-     * Extracts comprehensive token metadata
-     * @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 allMids - AllMids data containing current prices
-     * @param activeAssetData - Optional active asset data containing leverage information
-     * @returns TokenMetadata or null if token not found
-     */
-    static extractTokenMetadata(symbol: string, perpMetaAssets: UniverseAsset[] | null, finalAssetContexts: WebData3AssetCtx[] | null, allMids: WsAllMidsData | null, activeAssetData?: Record<string, ActiveAssetData> | null, finalAtOICaps?: string[] | null): TokenMetadata | null;
-    /**
-     * 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: string[], perpMetaAssets: UniverseAsset[] | null, finalAssetContexts: WebData3AssetCtx[] | null, allMids: WsAllMidsData | null, activeAssetData?: Record<string, ActiveAssetData> | null, finalAtOICaps?: string[] | null): Record<string, TokenMetadata | null>;
     /**
      * Checks if token data is available in aggregated universe assets
      * @param symbol - Token symbol
@@ -1510,6 +1492,17 @@ declare class TokenMetadataExtractor {
      * @returns boolean indicating if token exists in universe
      */
     static isTokenAvailable(symbol: string, perpMetaAssets: UniverseAsset[] | null): boolean;
+    /**
+     * Extracts token metadata using DEX-aware lookup (correctly matches perpMetas to assetContexts)
+     * @param symbol - Token symbol (e.g., "BTC", "TSLA")
+     * @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 extractTokenMetadataByDex(symbol: string, perpMetasByDex: Map<string, UniverseAsset[]>, assetContextsByDex: Map<string, WebData3AssetCtx[]>, allMids: WsAllMidsData, activeAssetData?: Record<string, ActiveAssetData> | null, finalAtOICaps?: string[] | null): TokenMetadata | null;
 }
 
 type TokenMetadataBySymbol = Record<string, TokenMetadata | null>;

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,
     ]);
@@ -5935,6 +5941,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 +6522,6 @@ const usePerformanceOverlays = () => {
         overlays.forEach(overlay => {
             symbols.push(overlay.symbol);
         });
-        console.log("final symbols", symbols);
         return symbols;
     }, [overlays]);
     return {
@@ -7180,16 +7205,6 @@ function enrichBasketItem(item) {
     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';
-    // }
     return {
         ...item,
         longAssets: enrichedLongs,
@@ -7821,9 +7836,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 +7856,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 +7875,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 = 'USDT';
+                    }
+                    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,

package/dist/store/hyperliquidDataStore.d.ts

@@ -1,5 +1,5 @@
-import { ActiveAssetData, CandleChartData, CandleData, ClearinghouseState, TokenMetadata, UniverseAsset, WebData3AssetCtx, WsAllMidsData } from '../types';
-type TokenMetadataBySymbol = Record<string, TokenMetadata | null>;
+import { ActiveAssetData, CandleChartData, CandleData, ClearinghouseState, UniverseAsset, WebData3AssetCtx, WsAllMidsData, PerpDexsResponse } from '../types';
+import { TokenMetadataBySymbol } from '../utils/token-metadata-extractor';
 interface HyperliquidDataState {
     allMids: WsAllMidsData | null;
     activeAssetData: Record<string, ActiveAssetData> | null;
@@ -10,6 +10,9 @@ interface HyperliquidDataState {
     rawClearinghouseStates: [string, ClearinghouseState][] | null;
     perpMetaAssets: UniverseAsset[] | null;
     tokenMetadata: TokenMetadataBySymbol;
+    perpDexs: PerpDexsResponse | null;
+    perpMetasByDex: Map<string, UniverseAsset[]> | null;
+    assetContextsByDex: Map<string, WebData3AssetCtx[]> | null;
     setAllMids: (value: WsAllMidsData | null) => void;
     setActiveAssetData: (value: Record<string, ActiveAssetData> | null | ((prev: Record<string, ActiveAssetData> | null) => Record<string, ActiveAssetData> | null)) => void;
     deleteActiveAssetData: (key: string) => void;
@@ -22,6 +25,9 @@ interface HyperliquidDataState {
     setAggregatedClearingHouseState: (value: ClearinghouseState | null) => void;
     setRawClearinghouseStates: (value: [string, ClearinghouseState][] | null) => void;
     setPerpMetaAssets: (value: UniverseAsset[] | null) => void;
+    setPerpDexs: (value: PerpDexsResponse | null) => void;
+    setPerpMetasByDex: (value: Map<string, UniverseAsset[]> | null) => void;
+    setAssetContextsByDex: (value: Map<string, WebData3AssetCtx[]> | null) => void;
 }
 export declare const useHyperliquidData: import("zustand").UseBoundStore<import("zustand").StoreApi<HyperliquidDataState>>;
 export {};

package/dist/types.d.ts

@@ -628,8 +628,10 @@ export interface AssetCtx {
  * Collateral token type
  * 0 = USDC
  * 360 = USDH
+ * 235 = USDE
+ * 268 = USDT
  */
-export type CollateralToken = 'USDC' | 'USDH';
+export type CollateralToken = 'USDC' | 'USDH' | 'USDE' | 'USDT';
 /**
  * Universe asset metadata
  */
@@ -884,3 +886,16 @@ export interface TokenEntry {
     symbol: string;
     data: AssetMarketData;
 }
+export interface PerpDex {
+    name: string;
+    fullName: string;
+    deployer: string;
+    oracleUpdater: string | null;
+    feeRecipient: string | null;
+    deployerFeeScale: string;
+    assetToStreamingOiCap: [string, string][];
+    assetToFundingMultiplier: [string, string][];
+    subDeployers: [string, string[]][];
+    lastDeployerFeeScaleChangeTime: string;
+}
+export type PerpDexsResponse = (PerpDex | null)[];

package/dist/utils/token-metadata-extractor.d.ts

@@ -3,26 +3,6 @@ import type { WsAllMidsData, TokenMetadata, ActiveAssetData, UniverseAsset, WebD
  * Extracts token metadata from aggregated WebData3 contexts and AllMids data
  */
 export declare class TokenMetadataExtractor {
-    /**
-     * Extracts comprehensive token metadata
-     * @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 allMids - AllMids data containing current prices
-     * @param activeAssetData - Optional active asset data containing leverage information
-     * @returns TokenMetadata or null if token not found
-     */
-    static extractTokenMetadata(symbol: string, perpMetaAssets: UniverseAsset[] | null, finalAssetContexts: WebData3AssetCtx[] | null, allMids: WsAllMidsData | null, activeAssetData?: Record<string, ActiveAssetData> | null, finalAtOICaps?: string[] | null): TokenMetadata | null;
-    /**
-     * 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: string[], perpMetaAssets: UniverseAsset[] | null, finalAssetContexts: WebData3AssetCtx[] | null, allMids: WsAllMidsData | null, activeAssetData?: Record<string, ActiveAssetData> | null, finalAtOICaps?: string[] | null): Record<string, TokenMetadata | null>;
     /**
      * Checks if token data is available in aggregated universe assets
      * @param symbol - Token symbol
@@ -30,4 +10,39 @@ export declare class TokenMetadataExtractor {
      * @returns boolean indicating if token exists in universe
      */
     static isTokenAvailable(symbol: string, perpMetaAssets: UniverseAsset[] | null): boolean;
+    /**
+     * Extracts token metadata using DEX-aware lookup (correctly matches perpMetas to assetContexts)
+     * @param symbol - Token symbol (e.g., "BTC", "TSLA")
+     * @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 extractTokenMetadataByDex(symbol: string, perpMetasByDex: Map<string, UniverseAsset[]>, assetContextsByDex: Map<string, WebData3AssetCtx[]>, allMids: WsAllMidsData, activeAssetData?: Record<string, ActiveAssetData> | null, finalAtOICaps?: string[] | null): TokenMetadata | null;
 }
+export type TokenMetadataBySymbol = Record<string, TokenMetadata | null>;
+export type TokenMetadataInputs = {
+    perpMetaAssets: UniverseAsset[] | null;
+    finalAssetContexts: WebData3AssetCtx[] | null;
+    allMids: WsAllMidsData | null;
+    activeAssetData: Record<string, ActiveAssetData> | null;
+    finalAtOICaps: string[] | null;
+    perpMetasByDex?: Map<string, UniverseAsset[]> | null;
+    assetContextsByDex?: Map<string, WebData3AssetCtx[]> | null;
+};
+export type RefreshTokenMetadataOptions = {
+    symbols?: string[];
+    oiCapsOnly?: boolean;
+};
+export declare const refreshTokenMetadata: (state: {
+    perpMetaAssets: UniverseAsset[] | null;
+    finalAssetContexts: WebData3AssetCtx[] | null;
+    allMids: WsAllMidsData | null;
+    activeAssetData: Record<string, ActiveAssetData> | null;
+    finalAtOICaps: string[] | null;
+    tokenMetadata: TokenMetadataBySymbol;
+    perpMetasByDex?: Map<string, UniverseAsset[]> | null;
+    assetContextsByDex?: Map<string, WebData3AssetCtx[]> | null;
+}, overrides: Partial<TokenMetadataInputs>, options?: RefreshTokenMetadataOptions) => TokenMetadataBySymbol;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/hyperliquid-sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "React SDK for Pear Protocol Hyperliquid API integration",
   "type": "module",
   "main": "dist/index.js",