@lifi/perps-sdk-provider-hyperliquid 1.0.1 → 1.2.0

package/src/websocket/HyperliquidWsProvider.ts

@@ -12,7 +12,10 @@ import {
   wsLog,
 } from '@lifi/perps-sdk'
 import {
+  type MarketContext,
   type OpenOrder,
+  type OrderbookLevel,
+  type OrderbookResponse,
   OrderSide,
   OrderType,
   type Subscription,
@@ -23,18 +26,26 @@ import type {
   HlAssetPosition,
   HlOrderDetail,
   HlUserFill,
+  HlWsAllDexsAssetCtxsData,
   HlWsAllDexsClearinghouseStateData,
-  HlWsAllMidsData,
   HlWsCandleData,
+  HlWsCompressedL2Data,
+  HlWsFastAssetCtx,
   HlWsL2BookData,
+  HlWsL2Data,
   HlWsMessage,
+  HlWsPerpAssetCtx,
   HlWsSpotStateData,
+  HlWsTrade,
   HlWsUserFillsData,
 } from '../types/index.js'
 import {
+  decodeCompressedJson,
+  decodeFastAssetCtxs,
   isOpenAssetPosition,
   isTriggerOrder,
   mapFill,
+  mapMarketContext,
   mapOrderStatus,
   mapOrderType,
   mapPosition,
@@ -44,30 +55,27 @@ import {
   spotPriceById,
 } from '../utils/index.js'
 
-/** HL's `l2Book` returns at most this many levels per side (slow/default mode). */
+/** HL's compact `l2` snapshot carries 20 levels per side. */
 const HL_L2_BOOK_MAX_LEVELS_PER_SIDE = 20
 
 /**
  * `WsProviderFactory` constructor for Hyperliquid — pass to
  * `new PerpsWsClient(client, { wsProviders: { hyperliquid: hyperliquidWsProvider() } })`.
  *
- * Derives the active sub-DEX set from the `markets` list `PerpsWsClient`
- * passes in (the provider's own key and `'spot'` are excluded — they
- * aren't sub-DEX subscriptions on the HL wire). Higher-order shape mirrors
- * `lighterWsProvider(options)` so the two factories register identically.
+ * Higher-order shape mirrors `lighterWsProvider(options)` so the two factories
+ * register identically.
  *
  * @public
  */
 export const hyperliquidWsProvider =
   (): WsProviderFactory =>
-  ({ provider, wsUrl, markets, client }) => {
-    const subDexes = markets.filter((m) => m !== provider && m !== 'spot')
-    return new HyperliquidWsProvider(wsUrl, provider, subDexes, client)
-  }
+  ({ provider, wsUrl, client }) =>
+    new HyperliquidWsProvider(wsUrl, provider, client)
 
 /**
- * Hyperliquid realtime {@link WsProvider}: multiplexes prices, positions,
- * orders, fills and spot balances over a single {@link ReconnectingWebSocket}.
+ * Hyperliquid realtime {@link WsProvider}: multiplexes markets context,
+ * positions, orders, fills and spot balances over a single
+ * {@link ReconnectingWebSocket}.
  * Construct via {@link hyperliquidWsProvider}.
  *
  * `orderUpdates` supports a single address per provider instance: HL delivers
@@ -80,22 +88,26 @@ export const hyperliquidWsProvider =
  */
 export class HyperliquidWsProvider extends WsProviderBase<object> {
   private orderUpdatesKey: string | undefined
-  private readonly subDexes: string[]
   private readonly client: PerpsSDKClient | undefined
   private readonly registry: MarketRegistry | undefined
-  private midsBySubDex = new Map<string, Record<string, string>>()
-
-  constructor(
-    wsUrl: string,
-    providerKey: string,
-    subDexes: string[],
-    client?: PerpsSDKClient
-  ) {
+  private perpCtxBySubDex = new Map<string, Record<string, HlWsPerpAssetCtx>>()
+  private orderbookKeysByMarketId = new Map<string, Set<string>>()
+  private latestOrderbookByMarketId = new Map<string, OrderbookResponse>()
+  // Latest mid/mark per `Market.id` from the high-frequency `fastAssetCtxs`
+  // feed (all dexes, incl. builder/sub-dex coins). Merged incrementally —
+  // frames carry only changed coins — and overlaid onto the slower
+  // `allDexsAssetCtxs` context (which supplies oracle/funding/OI/metadata).
+  private fastCtxByMarketId: Record<string, HlWsFastAssetCtx> = {}
+  // `fastAssetCtxs` payloads are base64 + raw-DEFLATE; decode is async, so
+  // chain decodes to apply incremental frames in arrival order.
+  private fastDecodeChain: Promise<void> = Promise.resolve()
+  private orderbookDecodeChain: Promise<void> = Promise.resolve()
+
+  constructor(wsUrl: string, providerKey: string, client?: PerpsSDKClient) {
     super(
       new ReconnectingWebSocket(wsUrl, { pingPayload: '{"method":"ping"}' }),
       providerKey
     )
-    this.subDexes = subDexes
     this.client = client
     this.registry = client && getMarketRegistry(client, providerKey)
   }
@@ -130,9 +142,11 @@ export class HyperliquidWsProvider extends WsProviderBase<object> {
 
     await this.registry?.sync()
 
-    // Prices require multi-sub-dex allMids subscriptions under one logical key.
-    if (sub.channel === 'prices') {
-      const entries = this.getPriceSubEntries()
+    // Markets context aggregates the all-dexs perp asset-context feed
+    // (oracle, funding, OI, metadata) with the high-frequency `fastAssetCtxs`
+    // feed, which supplies fast mid + mark for every market across all dexes.
+    if (sub.channel === 'marketsContext') {
+      const entries = this.getMarketsContextSubEntries()
 
       for (const { subKey, payload } of entries) {
         await this.registerSub(subKey, payload)
@@ -147,14 +161,21 @@ export class HyperliquidWsProvider extends WsProviderBase<object> {
             JSON.stringify({ method: 'unsubscribe', subscription: payload })
           )
         }
-        this.midsBySubDex.clear()
+        this.perpCtxBySubDex.clear()
+        this.fastCtxByMarketId = {}
       }
     }
 
     // All other channels: single WS subscription per key
     const key = this.toKey(sub)
+    if (sub.channel === 'orderbook') {
+      this.claimOrderbookKey(sub.marketId, key)
+    }
     const payload = this.toHlPayload(sub)
     await this.registerSub(key, payload)
+    if (sub.channel === 'orderbook') {
+      this.registerOrderbook(sub.marketId, key)
+    }
 
     await this.rws.ready()
 
@@ -164,8 +185,14 @@ export class HyperliquidWsProvider extends WsProviderBase<object> {
         this.orderUpdatesKey = undefined
       }
       this.rws.send(
-        JSON.stringify({ method: 'unsubscribe', subscription: payload })
+        JSON.stringify({
+          method: 'unsubscribe',
+          subscription: payload,
+        })
       )
+      if (sub.channel === 'orderbook') {
+        this.releaseOrderbook(sub.marketId, key)
+      }
     }
   }
 
@@ -192,22 +219,69 @@ export class HyperliquidWsProvider extends WsProviderBase<object> {
     this.orderUpdatesKey = key
   }
 
-  /** Build sub-key + payload pairs for each sub-dex allMids subscription. */
-  private getPriceSubEntries(): Array<{ subKey: string; payload: object }> {
+  private claimOrderbookKey(marketId: string, key: string): void {
+    const activeKeys = this.orderbookKeysByMarketId.get(marketId)
+    if (activeKeys === undefined) {
+      return
+    }
+
+    for (const activeKey of [...activeKeys]) {
+      if (activeKey === key) {
+        continue
+      }
+      if (!this.closeChannelIfIdle(activeKey)) {
+        throw new Error(
+          `Hyperliquid supports one orderbook aggregation per market per ` +
+            `provider instance. Unsubscribe ${activeKey} before subscribing ${key}.`
+        )
+      }
+    }
+  }
+
+  /**
+   * Sub-key + payload pairs for the markets-context aggregation: the all-dexs
+   * perp asset-context feed (oracle/funding/OI/metadata) plus the compressed
+   * `fastAssetCtxs` feed (high-frequency mid + mark across every dex).
+   */
+  private getMarketsContextSubEntries(): Array<{
+    subKey: string
+    payload: object
+  }> {
     return [
-      {
-        subKey: 'allMids:default',
-        payload: { type: 'allMids' },
-      },
-      ...this.subDexes.map((dex) => ({
-        subKey: `allMids:${dex}`,
-        payload: { type: 'allMids', dex },
-      })),
+      { subKey: 'allDexsAssetCtxs', payload: { type: 'allDexsAssetCtxs' } },
+      { subKey: 'fastAssetCtxs', payload: { type: 'fastAssetCtxs' } },
     ]
   }
 
+  private registerOrderbook(marketId: string, orderbookKey: string): void {
+    let activeKeys = this.orderbookKeysByMarketId.get(marketId)
+    if (activeKeys === undefined) {
+      activeKeys = new Set()
+      this.orderbookKeysByMarketId.set(marketId, activeKeys)
+    }
+
+    activeKeys.add(orderbookKey)
+  }
+
+  private releaseOrderbook(marketId: string, orderbookKey: string): void {
+    const activeKeys = this.orderbookKeysByMarketId.get(marketId)
+    if (activeKeys === undefined) {
+      return
+    }
+
+    activeKeys.delete(orderbookKey)
+    if (activeKeys.size > 0) {
+      return
+    }
+
+    this.orderbookKeysByMarketId.delete(marketId)
+  }
+
   protected override onClose(): void {
-    this.midsBySubDex.clear()
+    this.perpCtxBySubDex.clear()
+    this.fastCtxByMarketId = {}
+    this.orderbookKeysByMarketId.clear()
+    this.latestOrderbookByMarketId.clear()
     this.orderUpdatesKey = undefined
   }
 
@@ -219,12 +293,17 @@ export class HyperliquidWsProvider extends WsProviderBase<object> {
 
   protected toKey(sub: Subscription): string {
     switch (sub.channel) {
-      case 'prices':
-        return 'allMids'
+      case 'marketsContext':
+        return 'marketsContext'
       case 'orderbook':
-        return `l2Book:${sub.marketId}`
+        return `l2:${sub.marketId}:${this.orderbookAggregationKey(
+          sub.marketId,
+          sub.priceStep
+        )}`
       case 'candle':
         return `candle:${sub.marketId}:${sub.interval}`
+      case 'trades':
+        return `trades:${sub.marketId}`
       case 'orderUpdates':
         return `orderUpdates:${sub.address.toLowerCase()}`
       case 'fills':
@@ -236,32 +315,61 @@ export class HyperliquidWsProvider extends WsProviderBase<object> {
     }
   }
 
+  private orderbookAggregation(
+    marketId: string,
+    priceStep: number | undefined
+  ): { nSigFigs?: number; mantissa?: number } {
+    if (priceStep === undefined) {
+      return {}
+    }
+    return priceStepToAggregation(
+      priceStep,
+      this.orderbookReferencePrice(marketId)
+    )
+  }
+
+  private orderbookAggregationKey(
+    marketId: string,
+    priceStep: number | undefined
+  ): string {
+    const aggregation = this.orderbookAggregation(marketId, priceStep)
+    const nSigFigs = aggregation.nSigFigs ?? null
+    const mantissa = aggregation.mantissa ?? null
+    if (nSigFigs === null && mantissa === null) {
+      return 'full'
+    }
+    return `s:${nSigFigs}:m:${mantissa}`
+  }
+
   private toHlPayload(sub: Subscription): object {
     switch (sub.channel) {
-      case 'prices':
-        // Prices are handled via getPriceSubEntries in subscribe()
-        // and never reach toHlPayload, but TS requires exhaustive cases.
-        return { type: 'allMids' }
-      case 'orderbook':
+      case 'marketsContext':
+        // Handled via getMarketsContextSubEntries in openChannel; never reaches
+        // toHlPayload, but TS requires an exhaustive switch.
+        return { type: 'allDexsAssetCtxs' }
+      case 'orderbook': {
+        const aggregation = this.orderbookAggregation(
+          sub.marketId,
+          sub.priceStep
+        )
         return {
-          type: 'l2Book',
-          coin: sub.marketId,
-          // HL's l2Book ignores any level-count field; it returns up to 20
-          // levels/side and controls granularity via nSigFigs (+ mantissa,
-          // valid only when nSigFigs === 5).
-          ...(sub.priceStep !== undefined
-            ? priceStepToAggregation(
-                sub.priceStep,
-                this.mergedMids().get(sub.marketId) ?? Number.NaN
-              )
-            : {}),
+          type: 'l2',
+          c: sub.marketId,
+          s: aggregation.nSigFigs ?? null,
+          m: aggregation.mantissa ?? null,
         }
+      }
       case 'candle':
         return {
           type: 'candle',
           coin: sub.marketId,
           interval: sub.interval,
         }
+      case 'trades':
+        return {
+          type: 'trades',
+          coin: sub.marketId,
+        }
       case 'orderUpdates':
         return { type: 'orderUpdates', user: sub.address }
       case 'fills':
@@ -301,8 +409,14 @@ export class HyperliquidWsProvider extends WsProviderBase<object> {
 
     try {
       switch (msg.channel) {
-        case 'allMids':
-          this.handleAllMids(msg.data as HlWsAllMidsData)
+        case 'allDexsAssetCtxs':
+          this.handleAllDexsAssetCtxs(msg.data as HlWsAllDexsAssetCtxsData)
+          break
+        case 'fastAssetCtxs':
+          this.handleFastAssetCtxs(msg.data as string)
+          break
+        case 'l2':
+          this.handleL2(msg.data as HlWsL2Data)
           break
         case 'l2Book':
           this.handleL2Book(msg.data as HlWsL2BookData)
@@ -310,6 +424,9 @@ export class HyperliquidWsProvider extends WsProviderBase<object> {
         case 'candle':
           this.handleCandle(msg.data as HlWsCandleData)
           break
+        case 'trades':
+          this.handleTrades(msg.data as HlWsTrade[])
+          break
         case 'orderUpdates':
           this.handleOrderUpdates(msg.data as HlOrderDetail[])
           break
@@ -330,44 +447,179 @@ export class HyperliquidWsProvider extends WsProviderBase<object> {
     }
   }
 
-  private handleAllMids(data: HlWsAllMidsData) {
-    const subDexKey = data.dex || 'default'
-    this.midsBySubDex.set(subDexKey, data.mids)
-
-    const merged: Record<string, string> = {}
-    for (const mids of this.midsBySubDex.values()) {
-      Object.assign(merged, mids)
+  private handleAllDexsAssetCtxs(data: HlWsAllDexsAssetCtxsData) {
+    for (const [dex, ctxs] of data.assetCtxs) {
+      const byMarketId: Record<string, HlWsPerpAssetCtx> = {}
+      for (const ctx of ctxs) {
+        byMarketId[ctx.coin] = ctx
+      }
+      this.perpCtxBySubDex.set(dex || 'default', byMarketId)
     }
+    this.emitMarketsContext()
+  }
+
+  /**
+   * Decode a `fastAssetCtxs` frame (base64 + raw-DEFLATE) and merge its changed
+   * coins into the per-market fast-context store. Frames are incremental, so a
+   * field absent from this frame keeps its prior value. Decodes are chained to
+   * preserve arrival order across the async boundary.
+   */
+  private handleFastAssetCtxs(base64: string) {
+    this.fastDecodeChain = this.fastDecodeChain
+      .then(async () => {
+        const ctxs = await decodeFastAssetCtxs(base64)
+        for (const [marketId, ctx] of Object.entries(ctxs)) {
+          const prev = this.fastCtxByMarketId[marketId]
+          this.fastCtxByMarketId[marketId] = {
+            markPx: 'markPx' in ctx ? ctx.markPx : prev?.markPx,
+            midPx: 'midPx' in ctx ? ctx.midPx : prev?.midPx,
+          }
+        }
+        this.emitMarketsContext()
+      })
+      .catch((error) => wsLog.handlerFailure(this.providerKey, error))
+  }
 
-    this.emit('allMids', { channel: 'prices', data: merged })
+  /**
+   * Build the all-markets context map: every perp asset context across sub-dexs
+   * (oracle/funding/OI/metadata), with mid + mark overlaid from the
+   * high-frequency `fastAssetCtxs` feed. A market present in `fastAssetCtxs` but
+   * without an asset-context frame yet (the aggregate feed is slow/idle) still
+   * gets a mid+mark entry, so price ticks without waiting on the aggregate.
+   */
+  private emitMarketsContext() {
+    const data: Record<string, MarketContext> = {}
+    for (const byMarketId of this.perpCtxBySubDex.values()) {
+      for (const [marketId, ctx] of Object.entries(byMarketId)) {
+        const base = mapMarketContext(marketId, ctx)
+        const fast = this.fastCtxByMarketId[marketId]
+        data[marketId] = {
+          ...base,
+          midPrice: fast?.midPx != null ? fast.midPx : base.midPrice,
+          markPrice: fast?.markPx != null ? fast.markPx : base.markPrice,
+        }
+      }
+    }
+    for (const [marketId, fast] of Object.entries(this.fastCtxByMarketId)) {
+      if (data[marketId] !== undefined) {
+        continue
+      }
+      // No asset-context frame for this market yet — each price stands in for
+      // the other where the fast feed carries only one of mid/mark.
+      const midPrice = fast.midPx ?? fast.markPx
+      const markPrice = fast.markPx ?? fast.midPx
+      if (midPrice != null && markPrice != null) {
+        data[marketId] = { marketId, midPrice, markPrice }
+      }
+    }
+    this.emit('marketsContext', { channel: 'marketsContext', data })
   }
 
-  /** Latest mid per `Market.id`, merged across sub-dex allMids frames. */
+  /** Latest mid per `Market.id` across the perp ctx feed and `fastAssetCtxs`. */
   private mergedMids(): Map<string, number> {
     const map = new Map<string, number>()
-    for (const mids of this.midsBySubDex.values()) {
-      for (const [id, mid] of Object.entries(mids)) {
+    for (const byMarketId of this.perpCtxBySubDex.values()) {
+      for (const [id, ctx] of Object.entries(byMarketId)) {
+        const mid = ctx.midPx ?? ctx.markPx
+        map.set(id, Number(mid))
+      }
+    }
+    for (const [id, fast] of Object.entries(this.fastCtxByMarketId)) {
+      const mid = fast.midPx ?? fast.markPx
+      if (mid != null) {
         map.set(id, Number(mid))
       }
     }
     return map
   }
 
+  private orderbookReferencePrice(marketId: string): number {
+    const mid = this.mergedMids().get(marketId)
+    if (mid !== undefined) {
+      return mid
+    }
+
+    const book = this.latestOrderbookByMarketId.get(marketId)
+    const bid = book?.bids[0]?.price
+    const ask = book?.asks[0]?.price
+    if (bid !== undefined && ask !== undefined) {
+      return (Number(bid) + Number(ask)) / 2
+    }
+
+    return Number.NaN
+  }
+
   private handleL2Book(data: HlWsL2BookData) {
-    this.emit(`l2Book:${data.coin}`, {
-      channel: 'orderbook',
-      data: {
-        provider: this.providerKey,
-        marketId: data.coin,
-        bids: data.levels[0]
-          .slice(0, HL_L2_BOOK_MAX_LEVELS_PER_SIDE)
-          .map((l) => ({ price: l.px, size: l.sz })),
-        asks: data.levels[1]
-          .slice(0, HL_L2_BOOK_MAX_LEVELS_PER_SIDE)
-          .map((l) => ({ price: l.px, size: l.sz })),
-        timestamp: data.time,
-      },
-    })
+    const book = {
+      provider: this.providerKey,
+      marketId: data.coin,
+      bids: data.levels[0]
+        .slice(0, HL_L2_BOOK_MAX_LEVELS_PER_SIDE)
+        .map((l) => ({ price: l.px, size: l.sz })),
+      asks: data.levels[1]
+        .slice(0, HL_L2_BOOK_MAX_LEVELS_PER_SIDE)
+        .map((l) => ({ price: l.px, size: l.sz })),
+      timestamp: data.time,
+    }
+    this.latestOrderbookByMarketId.set(data.coin, book)
+    this.emitOrderbook(data.coin, book)
+  }
+
+  private handleL2(data: HlWsL2Data) {
+    if (data.s !== undefined) {
+      this.handleL2Book(data.s)
+    }
+    if (data.u !== undefined) {
+      this.handleCompactL2Delta(data.u)
+    }
+    if (data.c === undefined) {
+      return
+    }
+    const compressed = data.c
+    this.orderbookDecodeChain = this.orderbookDecodeChain
+      .then(async () => {
+        this.handleCompactL2Delta(
+          await decodeCompressedJson<HlWsCompressedL2Data>(compressed)
+        )
+      })
+      .catch((error) => wsLog.handlerFailure(this.providerKey, error))
+  }
+
+  private handleCompactL2Delta(delta: HlWsCompressedL2Data) {
+    const previous = this.latestOrderbookByMarketId.get(delta.c)
+    if (previous === undefined) {
+      return
+    }
+
+    const book: OrderbookResponse = {
+      provider: this.providerKey,
+      marketId: delta.c,
+      bids: applyCompressedL2Side(
+        previous.bids,
+        delta.l[0],
+        delta.r?.[0] ?? [],
+        'bid'
+      ),
+      asks: applyCompressedL2Side(
+        previous.asks,
+        delta.l[1],
+        delta.r?.[1] ?? [],
+        'ask'
+      ),
+      timestamp: delta.t,
+    }
+    this.latestOrderbookByMarketId.set(delta.c, book)
+    this.emitOrderbook(delta.c, book)
+  }
+
+  private emitOrderbook(marketId: string, book: OrderbookResponse) {
+    const keys = this.orderbookKeysByMarketId.get(marketId)
+    if (keys === undefined) {
+      return
+    }
+    for (const key of keys) {
+      this.emit(key, { channel: 'orderbook', data: book })
+    }
   }
 
   private handleCandle(data: HlWsCandleData) {
@@ -384,6 +636,25 @@ export class HyperliquidWsProvider extends WsProviderBase<object> {
     })
   }
 
+  private handleTrades(data: HlWsTrade[]) {
+    for (const trade of data) {
+      this.emit(`trades:${trade.coin}`, {
+        channel: 'trades',
+        data: [
+          {
+            provider: this.providerKey,
+            marketId: trade.coin,
+            price: trade.px,
+            size: trade.sz,
+            timestamp: trade.time,
+            side: trade.side === 'B' ? 'buy' : 'sell',
+            id: trade.tid !== undefined ? String(trade.tid) : trade.hash,
+          },
+        ],
+      })
+    }
+  }
+
   private handleOrderUpdates(data: HlOrderDetail[]) {
     // Untagged frame: attributable only via the single-address invariant.
     const key = this.orderUpdatesKey
@@ -489,6 +760,47 @@ export class HyperliquidWsProvider extends WsProviderBase<object> {
 const isObject = (v: unknown): v is Record<string, unknown> =>
   typeof v === 'object' && v !== null
 
+function compactRemovalPrice(
+  levels: OrderbookLevel[],
+  value: number | string | { p: string }
+): string | undefined {
+  if (typeof value === 'number') {
+    return levels[value]?.price
+  }
+  return typeof value === 'string' ? value : value.p
+}
+
+function applyCompressedL2Side(
+  previous: OrderbookLevel[],
+  updates: HlWsCompressedL2Data['l'][number],
+  removals: NonNullable<HlWsCompressedL2Data['r']>[number],
+  side: 'bid' | 'ask'
+): OrderbookLevel[] {
+  const byPrice = new Map(previous.map((level) => [level.price, level.size]))
+  for (const removal of removals) {
+    const price = compactRemovalPrice(previous, removal)
+    if (price !== undefined) {
+      byPrice.delete(price)
+    }
+  }
+  for (const update of updates) {
+    if (Number(update.s) === 0) {
+      byPrice.delete(update.p)
+    } else {
+      byPrice.set(update.p, update.s)
+    }
+  }
+
+  return [...byPrice.entries()]
+    .map(([price, size]) => ({ price, size }))
+    .sort((a, b) =>
+      side === 'bid'
+        ? Number(b.price) - Number(a.price)
+        : Number(a.price) - Number(b.price)
+    )
+    .slice(0, HL_L2_BOOK_MAX_LEVELS_PER_SIDE)
+}
+
 /**
  * Minimal presence/type check of the channel-discriminating and required
  * fields the matching handler dereferences without its own guard. A frame
@@ -497,12 +809,16 @@ const isObject = (v: unknown): v is Record<string, unknown> =>
  * to the dispatch switch, which silently ignores them.
  */
 function isValidHlFrame(channel: string, data: unknown): boolean {
+  // `fastAssetCtxs` carries a base64 string payload, not an object.
+  if (channel === 'fastAssetCtxs') {
+    return typeof data === 'string'
+  }
   if (!isObject(data)) {
     return false
   }
   switch (channel) {
-    case 'allMids':
-      return isObject(data.mids)
+    case 'allDexsAssetCtxs':
+      return Array.isArray(data.assetCtxs)
     case 'l2Book':
       return (
         typeof data.coin === 'string' &&
@@ -511,8 +827,12 @@ function isValidHlFrame(channel: string, data: unknown): boolean {
         Array.isArray(data.levels[1]) &&
         typeof data.time === 'number'
       )
+    case 'l2':
+      return typeof data.c === 'string' || isObject(data.s) || isObject(data.u)
     case 'candle':
       return typeof data.s === 'string' && typeof data.i === 'string'
+    case 'trades':
+      return Array.isArray(data)
     case 'orderUpdates':
       return Array.isArray(data)
     case 'userFills':

package/dist/cjs/utils/mapMarketPrice.d.ts

@@ -1,4 +0,0 @@
-import type { MarketPrice } from '@lifi/perps-types';
-import type { HlAssetCtx } from '../types/index.js';
-export declare const mapMarketPrice: (marketId: string, assetCtx: HlAssetCtx, mid: string) => MarketPrice;
-//# sourceMappingURL=mapMarketPrice.d.ts.map

package/dist/cjs/utils/mapMarketPrice.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mapMarketPrice.d.ts","sourceRoot":"","sources":["../../../src/utils/mapMarketPrice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAUnD,eAAO,MAAM,cAAc,GACzB,UAAU,MAAM,EAChB,UAAU,UAAU,EACpB,KAAK,MAAM,KACV,WAiBF,CAAA"}