fix: bugbots

Author: gambinish

packages/perps-controller/CHANGELOG.md

@@ -16,7 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - The collateral check fails open (treats the DEX as USDC-collateral) when the collateral token can't be resolved against spot metadata, so incomplete metadata doesn't spuriously block an otherwise-valid market.
   - Removed the now-unreachable USDH auto-swap machinery this replaces (spot USDH/USDC balance lookups, the USDC→USDH spot swap, and the auto-swap orchestration).
 - Subscribe to HyperLiquid's `fastAssetCtxs` WebSocket feed for mark/mid price updates, replacing `assetCtxs` as the latency-sensitive price source now that HyperLiquid has slowed the public `assetCtxs` feed cadence ([#9530](https://github.com/MetaMask/core/pull/9530))
-  - `assetCtxs` continues to populate funding, open interest, volume, and oracle price data, and remains the price source for any symbol `fastAssetCtxs` doesn't cover.
+  - `assetCtxs` continues to populate funding, open interest, volume, and oracle price data, and no longer writes prices for any symbol `fastAssetCtxs` covers, so a slower `assetCtxs` batch tick can't overwrite a fresher `fastAssetCtxs` price; it remains the price source only for symbols outside `fastAssetCtxs`' coverage (e.g. HIP-3 DEX markets).
   - `fastAssetCtxs` is a single global subscription (the HyperLiquid SDK exposes no per-DEX variant): the first message is a full snapshot keyed by coin, and later messages contain diffs for only the coins that changed. Coins without an active price subscriber are ignored.
   - Established alongside the global `allMids` subscription, restored together on WebSocket reconnect, and torn down on `clearAll()`. Subscribe attempts use the same 3-attempt/500ms-backoff retry as `assetCtxs` for transient SDK errors.
 

packages/perps-controller/src/services/HyperLiquidSubscriptionService.ts

@@ -145,6 +145,14 @@ export class HyperLiquidSubscriptionService {
 
   #globalFastAssetCtxsPromise?: Promise<void>; // Track in-progress subscription
 
+  // Coins seen in any fastAssetCtxs event (snapshot or diff). Once a coin
+  // appears here, the per-DEX assetCtxs handler stops writing its price into
+  // #cachedPriceData, since fastAssetCtxs is the fresher/authoritative source
+  // for that coin going forward. Cleared on clearAll() and when the
+  // fastAssetCtxs subscription is re-established after a reconnect, so
+  // assetCtxs can serve prices again until a fresh snapshot arrives.
+  readonly #fastAssetCtxsCoins = new Set<string>();
+
   readonly #globalActiveAssetSubscriptions = new Map<string, ISubscription>();
 
   // Track in-progress activeAssetCtx subscription promises to prevent leaks
@@ -3133,6 +3141,16 @@ export class HyperLiquidSubscriptionService {
       const changedSymbols = new Set<string>();
 
       for (const coin in data) {
+        if (!hasProperty(data, coin)) {
+          continue;
+        }
+
+        // Mark this coin as covered by fastAssetCtxs regardless of whether
+        // there's currently a subscriber, so the slower per-DEX assetCtxs
+        // handler knows to defer to this feed for the coin's price once
+        // there is one.
+        this.#fastAssetCtxsCoins.add(coin);
+
         // Skip coins nobody is subscribed to (snapshot messages include
         // every asset on the exchange, most of which have no subscriber)
         if (!this.#priceSubscribers.get(coin)?.size) {
@@ -3141,7 +3159,7 @@ export class HyperLiquidSubscriptionService {
 
         const ctx = data[coin];
         const priceRaw = ctx.midPx ?? ctx.markPx;
-        if (priceRaw === undefined) {
+        if (priceRaw === undefined || priceRaw === null) {
           continue;
         }
 
@@ -3634,9 +3652,13 @@ export class HyperLiquidSubscriptionService {
 
             this.#marketDataCache.set(asset.name, marketData);
 
-            // HIP-3: Extract price from assetCtx and update cached prices
+            // HIP-3: Extract price from assetCtx and update cached prices.
+            // Skip symbols fastAssetCtxs already covers (TAT-3387 owns their
+            // price path with fresher, ~5s-cadence data); assetCtxs remains
+            // the price source only for symbols outside fastAssetCtxs'
+            // coverage, e.g. HIP-3 dex:SYMBOL assets.
             const price = ctx.midPx?.toString() ?? ctx.markPx?.toString();
-            if (price) {
+            if (price && !this.#fastAssetCtxsCoins.has(asset.name)) {
               // For HIP-3 DEXs, meta() returns asset.name already containing the DEX prefix
               // (e.g., "xyz:XYZ100"), so use it directly
               const symbol = asset.name;
@@ -4176,9 +4198,12 @@ export class HyperLiquidSubscriptionService {
       // Re-establish the subscription
       this.#ensureGlobalAllMidsSubscription();
 
-      // Re-establish the fastAssetCtxs subscription alongside allMids (TAT-3387)
+      // Re-establish the fastAssetCtxs subscription alongside allMids (TAT-3387).
+      // Clear fastAssetCtxsCoins so assetCtxs can serve prices in the gap
+      // until the fresh post-reconnect snapshot re-establishes coverage.
       this.#globalFastAssetCtxsSubscription = undefined;
       this.#globalFastAssetCtxsPromise = undefined;
+      this.#fastAssetCtxsCoins.clear();
       this.#ensureGlobalFastAssetCtxsSubscription();
     }
 
@@ -4466,6 +4491,7 @@ export class HyperLiquidSubscriptionService {
     }
     this.#globalFastAssetCtxsSubscription = undefined;
     this.#globalFastAssetCtxsPromise = undefined;
+    this.#fastAssetCtxsCoins.clear();
 
     this.#globalActiveAssetSubscriptions.forEach((sub, symbol) => {
       sub.unsubscribe().catch((error: Error) => {

packages/perps-controller/tests/src/services/HyperLiquidSubscriptionService.market-data.test.ts

@@ -3103,6 +3103,119 @@ describe('HyperLiquidSubscriptionService', () => {
 
       unsubscribe();
     });
+
+    it('does not let a slower assetCtxs batch update overwrite a price already covered by fastAssetCtxs', async () => {
+      let fastAssetCtxsCallback: ((data: any) => void) | undefined;
+      let assetCtxsCallback: ((data: any) => void) | undefined;
+
+      service.setDexMetaCache('', { universe: [{ name: 'BTC' }] } as any);
+
+      mockSubscriptionClient.fastAssetCtxs.mockImplementation(
+        (callback: any) => {
+          fastAssetCtxsCallback = callback;
+          return Promise.resolve({
+            unsubscribe: jest.fn().mockResolvedValue(undefined),
+          });
+        },
+      );
+
+      mockSubscriptionClient.assetCtxs.mockImplementation(
+        (_params: any, callback: any) => {
+          assetCtxsCallback = callback;
+          return Promise.resolve({
+            unsubscribe: jest.fn().mockResolvedValue(undefined),
+          });
+        },
+      );
+
+      const listCallback = jest.fn();
+      const unsubscribe = await service.subscribeToPrices({
+        symbols: ['BTC'],
+        callback: listCallback,
+      });
+
+      await jest.runAllTimersAsync();
+
+      // fastAssetCtxs establishes the authoritative price for BTC
+      fastAssetCtxsCallback?.({ BTC: { midPx: '52000' } });
+      await jest.runAllTimersAsync();
+
+      listCallback.mockClear();
+
+      // A slower assetCtxs batch tick fires for BTC with a different price.
+      // It should not overwrite the fresher fastAssetCtxs price.
+      assetCtxsCallback?.({
+        ctxs: [
+          {
+            prevDayPx: '49000',
+            funding: '0.01',
+            openInterest: '1000000',
+            dayNtlVlm: '50000000',
+            oraclePx: '50100',
+            midPx: '50200',
+          },
+        ],
+      });
+      await jest.runAllTimersAsync();
+
+      expect(listCallback).not.toHaveBeenCalledWith([
+        expect.objectContaining({ symbol: 'BTC', price: '50200' }),
+      ]);
+
+      unsubscribe();
+    });
+
+    it('lets assetCtxs update the price for a symbol not covered by fastAssetCtxs (e.g. a HIP-3 dex:symbol asset)', async () => {
+      let assetCtxsCallback: ((data: any) => void) | undefined;
+
+      jest.mocked(parseAssetName).mockImplementation((symbol: string) => ({
+        symbol,
+        dex: symbol === 'xyz:STOCK1' ? 'xyz' : null,
+      }));
+
+      service.setDexMetaCache('xyz', {
+        universe: [{ name: 'xyz:STOCK1' }],
+      } as any);
+
+      mockSubscriptionClient.assetCtxs.mockImplementation(
+        (_params: any, callback: any) => {
+          assetCtxsCallback = callback;
+          return Promise.resolve({
+            unsubscribe: jest.fn().mockResolvedValue(undefined),
+          });
+        },
+      );
+
+      const listCallback = jest.fn();
+      const unsubscribe = await service.subscribeToPrices({
+        symbols: ['xyz:STOCK1'],
+        callback: listCallback,
+      });
+
+      await jest.runAllTimersAsync();
+
+      listCallback.mockClear();
+
+      assetCtxsCallback?.({
+        ctxs: [
+          {
+            prevDayPx: '9',
+            funding: '0.01',
+            openInterest: '1000',
+            dayNtlVlm: '5000',
+            oraclePx: '10',
+            midPx: '10.5',
+          },
+        ],
+      });
+      await jest.runAllTimersAsync();
+
+      expect(listCallback).toHaveBeenCalledWith([
+        expect.objectContaining({ symbol: 'xyz:STOCK1', price: '10.5' }),
+      ]);
+
+      unsubscribe();
+    });
   });
 
   describe('Market tradability (isTradable)', () => {

packages/perps-controller/tests/src/services/HyperLiquidSubscriptionService.streams.test.ts

@@ -792,6 +792,45 @@ describe('HyperLiquidSubscriptionService', () => {
 
       unsubscribe();
     });
+
+    it('skips a coin with a null midPx and no markPx in a fastAssetCtxs update without throwing', async () => {
+      const btcCallback = jest.fn();
+      const ethCallback = jest.fn();
+
+      const unsubscribeBtc = await service.subscribeToPrices({
+        symbols: ['BTC'],
+        callback: btcCallback,
+      });
+      const unsubscribeEth = await service.subscribeToPrices({
+        symbols: ['ETH'],
+        callback: ethCallback,
+      });
+
+      await jest.runAllTimersAsync();
+      btcCallback.mockClear();
+      ethCallback.mockClear();
+
+      const fastAssetCtxsCallback =
+        mockSubscriptionClient.fastAssetCtxs.mock.calls[0][0];
+
+      // BTC has a null midPx (and no markPx), which the SDK types allow at
+      // runtime; ETH is a valid update (with a price change from the allMids
+      // baseline of 3000) in the same payload.
+      expect(() =>
+        fastAssetCtxsCallback({
+          BTC: { midPx: null },
+          ETH: { midPx: '3100' },
+        }),
+      ).not.toThrow();
+
+      expect(btcCallback).not.toHaveBeenCalled();
+      expect(ethCallback).toHaveBeenCalledWith([
+        expect.objectContaining({ symbol: 'ETH', price: '3100' }),
+      ]);
+
+      unsubscribeBtc();
+      unsubscribeEth();
+    });
   });
 
   describe('Position Subscriptions', () => {