fix: add meta() fallback when metaAndAssetCtxs returns null meta

gambinish · gambinish · commit 54bf15057929 · 2026-01-31T11:04:43.000-08:00
diff --git a/app/components/UI/Perps/controllers/providers/HyperLiquidProvider.test.ts b/app/components/UI/Perps/controllers/providers/HyperLiquidProvider.test.ts
@@ -2968,7 +2968,7 @@ describe('HyperLiquidProvider', () => {
 
   describe('Additional Error Handling and Edge Cases', () => {
     describe('ensureReady and buildAssetMapping', () => {
-      it('should handle meta fetch failure in buildAssetMapping', async () => {
+      it('should handle meta fetch failure in buildAssetMapping when both endpoints fail', async () => {
         // Create a fresh provider to test buildAssetMapping
         const freshProvider = new HyperLiquidProvider();
 
@@ -3001,6 +3001,74 @@ describe('HyperLiquidProvider', () => {
         expect(result.error).toContain('Network timeout');
       });
 
+      it('should fallback to meta() in buildAssetMapping when metaAndAssetCtxs returns null meta', async () => {
+        // Create a fresh provider to test buildAssetMapping fallback
+        const freshProvider = new HyperLiquidProvider();
+
+        const mockMeta = {
+          universe: [
+            { name: 'BTC', szDecimals: 3, maxLeverage: 50 },
+            { name: 'ETH', szDecimals: 4, maxLeverage: 50 },
+          ],
+        };
+
+        const mockMetaFn = jest.fn().mockResolvedValue(mockMeta);
+
+        mockClientService.getInfoClient = jest.fn().mockReturnValue(
+          createMockInfoClient({
+            // meta() returns valid data as fallback
+            meta: mockMetaFn,
+            // metaAndAssetCtxs returns null meta (simulating partial failure)
+            metaAndAssetCtxs: jest.fn().mockResolvedValue([null, []]),
+            allMids: jest.fn().mockResolvedValue({ BTC: '50000', ETH: '3000' }),
+          }),
+        );
+
+        MockedHyperLiquidClientService.mockImplementation(
+          () => mockClientService,
+        );
+
+        // Trigger ensureReady -> buildAssetMapping by calling getMarkets
+        const markets = await freshProvider.getMarkets();
+
+        // Should have used the meta() fallback
+        expect(mockMetaFn).toHaveBeenCalled();
+        // Should return the markets from the fallback
+        expect(markets.length).toBeGreaterThan(0);
+      });
+
+      it('should handle buildAssetMapping when meta() fallback also fails', async () => {
+        // Create a fresh provider to test buildAssetMapping
+        const freshProvider = new HyperLiquidProvider();
+
+        mockClientService.getInfoClient = jest.fn().mockReturnValue(
+          createMockInfoClient({
+            // meta() also fails
+            meta: jest.fn().mockRejectedValue(new Error('Fallback failed')),
+            // metaAndAssetCtxs returns null meta
+            metaAndAssetCtxs: jest.fn().mockResolvedValue([null, []]),
+          }),
+        );
+
+        MockedHyperLiquidClientService.mockImplementation(
+          () => mockClientService,
+        );
+
+        // Try to place an order which will trigger ensureReady -> buildAssetMapping
+        const orderParams: OrderParams = {
+          coin: 'BTC',
+          isBuy: true,
+          size: '0.1',
+          orderType: 'market',
+          currentPrice: 50000,
+        };
+
+        const result = await freshProvider.placeOrder(orderParams);
+
+        // Should fail because asset mapping couldn't be built
+        expect(result.success).toBe(false);
+      });
+
       it('should handle string response from meta endpoint', async () => {
         // Test updatePositionTPSL with string meta response (invalid data type)
         mockClientService.getInfoClient = jest.fn().mockReturnValue(
@@ -3311,7 +3379,7 @@ describe('HyperLiquidProvider', () => {
     });
 
     describe('getMarketDataWithPrices error scenarios', () => {
-      it('should handle missing perpsMeta', async () => {
+      it('should handle missing perpsMeta when both metaAndAssetCtxs and meta() return null', async () => {
         mockClientService.getInfoClient = jest.fn().mockReturnValue(
           createMockInfoClient({
             meta: jest.fn().mockResolvedValue(null),
@@ -3326,6 +3394,76 @@ describe('HyperLiquidProvider', () => {
         );
       });
 
+      it('should fallback to meta() when metaAndAssetCtxs returns null meta', async () => {
+        const mockMeta = {
+          universe: [{ name: 'BTC', szDecimals: 3, maxLeverage: 50 }],
+        };
+
+        mockClientService.getInfoClient = jest.fn().mockReturnValue(
+          createMockInfoClient({
+            // meta() returns valid data as fallback
+            meta: jest.fn().mockResolvedValue(mockMeta),
+            allMids: jest.fn().mockResolvedValue({ BTC: '50000' }),
+            predictedFundings: jest.fn().mockResolvedValue([]),
+            // metaAndAssetCtxs returns null meta (simulating partial failure)
+            metaAndAssetCtxs: jest.fn().mockResolvedValue([null, []]),
+          }),
+        );
+
+        // Create fresh provider to avoid cached state from other tests
+        const freshProvider = new HyperLiquidProvider();
+
+        // Should succeed by falling back to meta()
+        const result = await freshProvider.getMarketDataWithPrices();
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBeGreaterThan(0);
+        expect(result[0].symbol).toBe('BTC');
+      });
+
+      it('should fallback to meta() when metaAndAssetCtxs returns undefined meta', async () => {
+        const mockMeta = {
+          universe: [{ name: 'ETH', szDecimals: 4, maxLeverage: 50 }],
+        };
+
+        mockClientService.getInfoClient = jest.fn().mockReturnValue(
+          createMockInfoClient({
+            // meta() returns valid data as fallback
+            meta: jest.fn().mockResolvedValue(mockMeta),
+            allMids: jest.fn().mockResolvedValue({ ETH: '3000' }),
+            predictedFundings: jest.fn().mockResolvedValue([]),
+            // metaAndAssetCtxs returns undefined (simulating malformed response)
+            metaAndAssetCtxs: jest.fn().mockResolvedValue([undefined, []]),
+          }),
+        );
+
+        // Create fresh provider to avoid cached state from other tests
+        const freshProvider = new HyperLiquidProvider();
+
+        // Should succeed by falling back to meta()
+        const result = await freshProvider.getMarketDataWithPrices();
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBeGreaterThan(0);
+        expect(result[0].symbol).toBe('ETH');
+      });
+
+      it('should handle meta() fallback failure gracefully', async () => {
+        mockClientService.getInfoClient = jest.fn().mockReturnValue(
+          createMockInfoClient({
+            // meta() also fails
+            meta: jest.fn().mockRejectedValue(new Error('Network timeout')),
+            allMids: jest.fn().mockResolvedValue({ BTC: '50000' }),
+            predictedFundings: jest.fn().mockResolvedValue([]),
+            // metaAndAssetCtxs returns null meta
+            metaAndAssetCtxs: jest.fn().mockResolvedValue([null, []]),
+          }),
+        );
+
+        // Should still throw the "no markets available" error
+        await expect(provider.getMarketDataWithPrices()).rejects.toThrow(
+          'Failed to fetch market data - no markets available',
+        );
+      });
+
       it('should handle missing allMids', async () => {
         // Set up mock BEFORE creating fresh provider
         mockClientService.getInfoClient = jest.fn().mockReturnValue(
diff --git a/app/components/UI/Perps/controllers/providers/HyperLiquidProvider.ts b/app/components/UI/Perps/controllers/providers/HyperLiquidProvider.ts
@@ -1483,9 +1483,41 @@ export class HyperLiquidProvider implements IPerpsProvider {
         const dexParam = dex || undefined;
         return infoClient
           .metaAndAssetCtxs(dexParam ? { dex: dexParam } : undefined)
-          .then((result) => {
-            const meta = result?.[0] || null;
+          .then(async (result) => {
+            let meta = result?.[0] || null;
             const assetCtxs = result?.[1] || [];
+
+            // FALLBACK: If combined endpoint returns null/empty meta, try dedicated meta endpoint
+            if (!meta?.universe) {
+              Logger.error(
+                new Error(
+                  'metaAndAssetCtxs returned null meta, attempting fallback to meta()',
+                ),
+                this.getErrorContext('buildAssetMapping.metaFallback', {
+                  dex: dex ?? 'main',
+                  hasMetaAndCtxsResponse: !!result,
+                  hasMetaAtIndex0: !!result?.[0],
+                  assetCtxsLength: assetCtxs?.length ?? 0,
+                }),
+              );
+              try {
+                meta = await infoClient.meta(
+                  dexParam ? { dex: dexParam } : undefined,
+                );
+                if (meta?.universe) {
+                  DevLogger.log(
+                    `[buildAssetMapping] meta() fallback succeeded for ${dex || 'main'}`,
+                    { universeSize: meta.universe.length },
+                  );
+                }
+              } catch (fallbackError) {
+                DevLogger.log(
+                  `[buildAssetMapping] meta() fallback also failed for ${dex || 'main'}`,
+                  fallbackError,
+                );
+              }
+            }
+
             // Cache meta for later use by getCachedMeta
             if (meta?.universe) {
               this.cachedMetaByDex.set(dexKey, meta);
@@ -1494,7 +1526,10 @@ export class HyperLiquidProvider implements IPerpsProvider {
               // Cache assetCtxs for getMarketDataWithPrices (avoids duplicate metaAndAssetCtxs calls)
               this.subscriptionService.setDexAssetCtxsCache(dexKey, assetCtxs);
             }
-            return { dex, meta, success: true as const };
+
+            // Return success only if we have valid meta with universe
+            const success = !!meta?.universe;
+            return { dex, meta, success: success as typeof success };
           })
           .catch((error) => {
             DevLogger.log(
@@ -4894,6 +4929,37 @@ export class HyperLiquidProvider implements IPerpsProvider {
             meta = metaAndCtxs?.[0] || null;
             assetCtxs = metaAndCtxs?.[1] || [];
 
+            // FALLBACK: If combined endpoint returns null/empty meta, try dedicated meta endpoint
+            if (!meta?.universe) {
+              Logger.error(
+                new Error(
+                  'metaAndAssetCtxs returned null meta, attempting fallback to meta()',
+                ),
+                this.getErrorContext('getMarketDataWithPrices.metaFallback', {
+                  dex: dex ?? 'main',
+                  hasMetaAndCtxsResponse: !!metaAndCtxs,
+                  hasMetaAtIndex0: !!metaAndCtxs?.[0],
+                  assetCtxsLength: assetCtxs?.length ?? 0,
+                }),
+              );
+              try {
+                meta = await infoClient.meta(
+                  dexParam ? { dex: dexParam } : undefined,
+                );
+                if (meta?.universe) {
+                  DevLogger.log(
+                    `[getMarketDataWithPrices] meta() fallback succeeded for ${dex || 'main'}`,
+                    { universeSize: meta.universe.length },
+                  );
+                }
+              } catch (fallbackError) {
+                DevLogger.log(
+                  `[getMarketDataWithPrices] meta() fallback also failed for ${dex || 'main'}`,
+                  fallbackError,
+                );
+              }
+            }
+
             // IMPORTANT: Populate cache for buildAssetMapping and other methods to reuse
             if (meta?.universe) {
               this.cachedMetaByDex.set(dexKey, meta);
@@ -4912,12 +4978,13 @@ export class HyperLiquidProvider implements IPerpsProvider {
             dexParam ? { dex: dexParam } : undefined,
           );
 
+          // Return success only if we have valid meta with universe
           return {
             dex,
             meta,
             assetCtxs,
             allMids: dexAllMids || {},
-            success: true,
+            success: !!meta?.universe,
           };
         } catch (error) {
           Logger.error(
