tardis-machine 18.2.1 → 18.3.0

package/node_modules/tardis-dev/src/mappers/bithumb.ts

@@ -0,0 +1,104 @@
+import { fromMicroSecondsToDate, upperCaseSymbols } from '../handy.ts'
+import { BookChange, BookPriceLevel, Trade } from '../types.ts'
+import { Mapper } from './mapper.ts'
+import { exchangeMappers } from './registry.ts'
+
+export const bithumbMappers = exchangeMappers({
+  bithumb: {
+    trades: () => new BithumbTradesMapper(),
+    bookChanges: () => new BithumbBookChangeMapper()
+  }
+})
+
+class BithumbTradesMapper implements Mapper<'bithumb', Trade> {
+  canHandle(message: BithumbTrade) {
+    return message.type === 'trade' && message.stream_type === 'REALTIME'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'trade', symbols: upperCaseSymbols(symbols) } as const]
+  }
+
+  *map(message: BithumbTrade, localTimestamp: Date): IterableIterator<Trade> {
+    yield {
+      type: 'trade',
+      symbol: message.code,
+      exchange: 'bithumb',
+      id: message.sequential_id,
+      price: message.trade_price,
+      amount: message.trade_volume,
+      side: message.ask_bid === 'ASK' ? 'sell' : 'buy',
+      timestamp: new Date(message.trade_timestamp),
+      localTimestamp
+    }
+  }
+}
+
+class BithumbBookChangeMapper implements Mapper<'bithumb', BookChange> {
+  canHandle(message: BithumbOrderBook) {
+    return message.type === 'orderbook'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'orderbook', symbols: upperCaseSymbols(symbols) } as const]
+  }
+
+  *map(message: BithumbOrderBook, localTimestamp: Date): IterableIterator<BookChange> {
+    const asks: BookPriceLevel[] = []
+    const bids: BookPriceLevel[] = []
+
+    for (const level of message.orderbook_units) {
+      if (level.ask_price > 0 && level.ask_size > 0) {
+        asks.push({ price: level.ask_price, amount: level.ask_size })
+      }
+
+      if (level.bid_price > 0 && level.bid_size > 0) {
+        bids.push({ price: level.bid_price, amount: level.bid_size })
+      }
+    }
+
+    yield {
+      type: 'book_change',
+      symbol: message.code,
+      exchange: 'bithumb',
+      isSnapshot: true,
+      asks,
+      bids,
+      timestamp: fromMicroSecondsToDate(message.timestamp),
+      localTimestamp
+    }
+  }
+}
+
+/** @see https://apidocs.bithumb.com/reference/%EC%B2%B4%EA%B2%B0-trade */
+type BithumbTrade = {
+  type: 'trade'
+  code: string
+  trade_price: number
+  trade_volume: number
+  ask_bid: 'ASK' | 'BID'
+  prev_closing_price: number
+  change: 'RISE' | 'EVEN' | 'FALL'
+  change_price: number
+  trade_date: string
+  trade_time: string
+  trade_timestamp: number
+  /** Bithumb sends this as a JSON number, but ingestion preserves it as a string because it exceeds Number.MAX_SAFE_INTEGER. */
+  sequential_id: string
+  timestamp: number
+  stream_type: BithumbStreamType
+}
+
+/** @see https://apidocs.bithumb.com/reference/%ED%98%B8%EA%B0%80-orderbook */
+type BithumbOrderBook = {
+  type: 'orderbook'
+  code: string
+  total_ask_size: number
+  total_bid_size: number
+  orderbook_units: { ask_price: number; bid_price: number; ask_size: number; bid_size: number }[]
+  timestamp: number
+  level: number
+  stream_type: BithumbStreamType
+}
+
+type BithumbStreamType = 'SNAPSHOT' | 'REALTIME'

package/node_modules/tardis-dev/src/mappers/bitvavo.ts

@@ -0,0 +1,256 @@
+import { asNonZeroNumberOrUndefined, CircularBuffer, fromMicroSecondsToDate, upperCaseSymbols } from '../handy.ts'
+import { BookChange, BookTicker, Trade } from '../types.ts'
+import { Mapper } from './mapper.ts'
+import { exchangeMappers, isRealTime } from './registry.ts'
+
+export const bitvavoMappers = exchangeMappers({
+  bitvavo: {
+    trades: () => new BitvavoTradesMapper(),
+    bookChanges: (localTimestamp) => new BitvavoBookChangeMapper({ validateSequence: isRealTime(localTimestamp) }),
+    bookTickers: () => new BitvavoBookTickerMapper()
+  }
+})
+
+class BitvavoTradesMapper implements Mapper<'bitvavo', Trade> {
+  canHandle(message: BitvavoMessage) {
+    return message.event === 'trade'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'trade', symbols: upperCaseSymbols(symbols) } as const]
+  }
+
+  *map(message: BitvavoTradeMessage, localTimestamp: Date): IterableIterator<Trade> {
+    yield {
+      type: 'trade',
+      symbol: message.market,
+      exchange: 'bitvavo',
+      id: message.id,
+      price: Number(message.price),
+      amount: Number(message.amount),
+      side: message.side,
+      timestamp: message.timestampNs === undefined ? new Date(message.timestamp) : fromNanoseconds(message.timestampNs),
+      localTimestamp
+    }
+  }
+}
+
+class BitvavoBookChangeMapper implements Mapper<'bitvavo', BookChange> {
+  private readonly depthInfoBySymbol = new Map<string, BitvavoDepthInfo>()
+
+  constructor(private readonly options: { validateSequence: boolean }) {}
+
+  canHandle(message: BitvavoMessage) {
+    return message.event === 'book' || message.action === 'getBook'
+  }
+
+  getFilters(symbols?: string[]) {
+    const normalizedSymbols = upperCaseSymbols(symbols)
+    return [{ channel: 'book', symbols: normalizedSymbols } as const, { channel: 'getBook', symbols: normalizedSymbols } as const]
+  }
+
+  *map(message: BitvavoBookMessage | BitvavoBookSnapshotMessage, localTimestamp: Date): IterableIterator<BookChange> {
+    if ('action' in message) {
+      const snapshot = message.response
+      const depthInfo = this.getDepthInfo(snapshot.market)
+      if (depthInfo.snapshotProcessed) {
+        return
+      }
+
+      const snapshotSequence = snapshot.mdSeqNo ?? snapshot.nonce
+      depthInfo.sequence = snapshotSequence
+      depthInfo.snapshotProcessed = true
+
+      yield {
+        type: 'book_change',
+        symbol: snapshot.market,
+        exchange: 'bitvavo',
+        isSnapshot: true,
+        bids: snapshot.bids.map(mapBookLevel),
+        asks: snapshot.asks.map(mapBookLevel),
+        timestamp: fromNanoseconds(snapshot.timestamp),
+        localTimestamp
+      }
+
+      for (const update of depthInfo.bufferedUpdates.items()) {
+        const mapped = this.mapUpdate(update, localTimestamp, depthInfo)
+        if (mapped !== undefined) {
+          yield mapped
+        }
+      }
+      depthInfo.bufferedUpdates.clear()
+      return
+    }
+
+    const depthInfo = this.getDepthInfo(message.market)
+    if (!depthInfo.snapshotProcessed) {
+      depthInfo.bufferedUpdates.append(message)
+      return
+    }
+
+    const mapped = this.mapUpdate(message, localTimestamp, depthInfo)
+    if (mapped !== undefined) {
+      yield mapped
+    }
+  }
+
+  private mapUpdate(message: BitvavoBookMessage, localTimestamp: Date, depthInfo: BitvavoDepthInfo): BookChange | undefined {
+    const firstSequence = message.startMdSeqNo ?? message.nonce
+    const lastSequence = message.endMdSeqNo ?? message.nonce
+    if (lastSequence <= depthInfo.sequence!) {
+      return
+    }
+    // Recorder validates historical continuity; direct live feeds must detect gaps themselves.
+    if (this.options.validateSequence && firstSequence > depthInfo.sequence! + 1) {
+      throw new Error(
+        `Bitvavo book update sequence gap for ${message.market}: expected ${depthInfo.sequence! + 1}, received ${firstSequence}-${lastSequence}`
+      )
+    }
+
+    depthInfo.sequence = lastSequence
+    return {
+      type: 'book_change',
+      symbol: message.market,
+      exchange: 'bitvavo',
+      isSnapshot: false,
+      bids: message.bids.map(mapBookLevel),
+      asks: message.asks.map(mapBookLevel),
+      timestamp: fromNanoseconds(message.timestamp),
+      localTimestamp
+    }
+  }
+
+  private getDepthInfo(symbol: string) {
+    let depthInfo = this.depthInfoBySymbol.get(symbol)
+    if (depthInfo === undefined) {
+      depthInfo = { bufferedUpdates: new CircularBuffer<BitvavoBookMessage>(2000) }
+      this.depthInfoBySymbol.set(symbol, depthInfo)
+    }
+    return depthInfo
+  }
+}
+
+class BitvavoBookTickerMapper implements Mapper<'bitvavo', BookTicker> {
+  private readonly quotesByMarket = new Map<string, BitvavoQuote>()
+
+  canHandle(message: BitvavoMessage) {
+    return message.event === 'ticker'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'ticker', symbols: upperCaseSymbols(symbols) } as const]
+  }
+
+  *map(message: BitvavoTickerMessage, localTimestamp: Date): IterableIterator<BookTicker> {
+    let quote = this.quotesByMarket.get(message.market)
+    if (quote === undefined) {
+      quote = { askAmount: undefined, askPrice: undefined, bidAmount: undefined, bidPrice: undefined }
+      this.quotesByMarket.set(message.market, quote)
+    }
+
+    // Recorded ticker payloads omit unchanged fields, so retain the previous quote per market.
+    let hasQuoteUpdate = false
+    if (message.bestAskSize !== undefined) {
+      quote.askAmount = asNonZeroNumberOrUndefined(message.bestAskSize)
+      hasQuoteUpdate = true
+    }
+    if (message.bestAsk !== undefined) {
+      quote.askPrice = asNonZeroNumberOrUndefined(message.bestAsk)
+      hasQuoteUpdate = true
+    }
+    if (message.bestBidSize !== undefined) {
+      quote.bidAmount = asNonZeroNumberOrUndefined(message.bestBidSize)
+      hasQuoteUpdate = true
+    }
+    if (message.bestBid !== undefined) {
+      quote.bidPrice = asNonZeroNumberOrUndefined(message.bestBid)
+      hasQuoteUpdate = true
+    }
+
+    if (!hasQuoteUpdate) {
+      return
+    }
+
+    yield {
+      type: 'book_ticker',
+      symbol: message.market,
+      exchange: 'bitvavo',
+      ...quote,
+      timestamp: localTimestamp,
+      localTimestamp
+    }
+  }
+}
+
+function mapBookLevel([price, amount]: BitvavoBookLevel) {
+  return {
+    price: Number(price),
+    amount: Number(amount)
+  }
+}
+
+function fromNanoseconds(nanoseconds: string) {
+  return fromMicroSecondsToDate(Number(nanoseconds.slice(0, -3)))
+}
+
+type BitvavoMessage = { event?: string; action?: string }
+
+type BitvavoTradeMessage = {
+  event: 'trade'
+  id: string
+  amount: string
+  price: string
+  timestamp: number
+  timestampNs?: string
+  market: string
+  side: 'buy' | 'sell'
+}
+
+type BitvavoBookMessage = {
+  event: 'book'
+  market: string
+  nonce: number
+  bids: BitvavoBookLevel[]
+  asks: BitvavoBookLevel[]
+  timestamp: string
+  startMdSeqNo?: number
+  endMdSeqNo?: number
+}
+
+type BitvavoBookSnapshotMessage = {
+  action: 'getBook'
+  requestId: number
+  response: {
+    market: string
+    nonce: number
+    bids: BitvavoBookLevel[]
+    asks: BitvavoBookLevel[]
+    timestamp: string
+    mdSeqNo?: number
+  }
+}
+
+type BitvavoBookLevel = [string, string]
+
+type BitvavoTickerMessage = {
+  event: 'ticker'
+  market: string
+  bestAsk?: string
+  bestAskSize?: string
+  bestBid?: string
+  bestBidSize?: string
+  lastPrice?: string
+}
+
+type BitvavoQuote = {
+  askAmount: number | undefined
+  askPrice: number | undefined
+  bidAmount: number | undefined
+  bidPrice: number | undefined
+}
+
+type BitvavoDepthInfo = {
+  bufferedUpdates: CircularBuffer<BitvavoBookMessage>
+  snapshotProcessed?: boolean
+  sequence?: number
+}

package/node_modules/tardis-dev/src/mappers/index.ts

@@ -7,9 +7,11 @@ import { binanceEuropeanOptionsMappers } from './binanceeuropeanoptions.ts'
 import { bitfinexMappers } from './bitfinex.ts'
 import { bitflyerMappers } from './bitflyer.ts'
 import { bitgetMappers } from './bitget.ts'
+import { bithumbMappers } from './bithumb.ts'
 import { bitmexMappers } from './bitmex.ts'
 import { bitnomialMappers } from './bitnomial.ts'
 import { bitstampMappers } from './bitstamp.ts'
+import { bitvavoMappers } from './bitvavo.ts'
 import { blockchainComMappers } from './blockchaincom.ts'
 import { bullishMappers } from './bullish.ts'
 import { bybitMappers } from './bybit.ts'
@@ -63,9 +65,11 @@ const registeredMappers = mergeExchangeMappers(
   bitfinexMappers,
   bitflyerMappers,
   bitgetMappers,
+  bithumbMappers,
   bitmexMappers,
   bitnomialMappers,
   bitstampMappers,
+  bitvavoMappers,
   blockchainComMappers,
   bullishMappers,
   bybitMappers,

package/node_modules/tardis-dev/src/mappers/lighter.ts

@@ -4,15 +4,22 @@ import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
 import { exchangeMappers } from './registry.ts'
 
 export const lighterMappers = exchangeMappers({
-  lighter: {
-    trades: () => new LighterTradesMapper(),
-    bookChanges: () => new LighterBookChangeMapper(),
-    derivativeTickers: () => new LighterDerivativeTickerMapper(),
-    liquidations: () => new LighterLiquidationMapper(),
-    bookTickers: () => new LighterBookTickerMapper()
-  }
+  lighter: createLighterMappers('lighter'),
+  'lighter-rh': createLighterMappers('lighter-rh')
 })
 
+type LighterExchange = 'lighter' | 'lighter-rh'
+
+function createLighterMappers<T extends LighterExchange>(exchange: T) {
+  return {
+    trades: () => new LighterTradesMapper(exchange),
+    bookChanges: () => new LighterBookChangeMapper(exchange),
+    derivativeTickers: () => new LighterDerivativeTickerMapper(exchange),
+    liquidations: () => new LighterLiquidationMapper(exchange),
+    bookTickers: () => new LighterBookTickerMapper(exchange)
+  }
+}
+
 function parseChannelMarketId(channel: string): string | undefined {
   const colonIndex = channel.indexOf(':')
   if (colonIndex < 0) {
@@ -25,7 +32,9 @@ function parseChannelMarketId(channel: string): string | undefined {
   return suffix
 }
 
-class LighterTradesMapper implements Mapper<'lighter', Trade> {
+class LighterTradesMapper<T extends LighterExchange> implements Mapper<T, Trade> {
+  constructor(private readonly exchange: T) {}
+
   canHandle(message: LighterTradeMessage) {
     return message.type === 'update/trade'
   }
@@ -44,7 +53,7 @@ class LighterTradesMapper implements Mapper<'lighter', Trade> {
       yield {
         type: 'trade',
         symbol: trade.market_id.toString(),
-        exchange: 'lighter',
+        exchange: this.exchange,
         id: trade.trade_id_str,
         price: Number(trade.price),
         amount: Number(trade.size),
@@ -56,7 +65,9 @@ class LighterTradesMapper implements Mapper<'lighter', Trade> {
   }
 }
 
-class LighterLiquidationMapper implements Mapper<'lighter', Liquidation> {
+class LighterLiquidationMapper<T extends LighterExchange> implements Mapper<T, Liquidation> {
+  constructor(private readonly exchange: T) {}
+
   canHandle(message: LighterTradeMessage) {
     return message.type === 'update/trade'
   }
@@ -83,7 +94,7 @@ class LighterLiquidationMapper implements Mapper<'lighter', Liquidation> {
       yield {
         type: 'liquidation',
         symbol: trade.market_id.toString(),
-        exchange: 'lighter',
+        exchange: this.exchange,
         id: trade.trade_id_str,
         price: Number(trade.price),
         amount: Number(trade.size),
@@ -95,7 +106,9 @@ class LighterLiquidationMapper implements Mapper<'lighter', Liquidation> {
   }
 }
 
-class LighterBookChangeMapper implements Mapper<'lighter', BookChange> {
+class LighterBookChangeMapper<T extends LighterExchange> implements Mapper<T, BookChange> {
+  constructor(private readonly exchange: T) {}
+
   canHandle(message: LighterOrderBookMessage) {
     return message.type === 'subscribed/order_book' || message.type === 'update/order_book'
   }
@@ -116,7 +129,7 @@ class LighterBookChangeMapper implements Mapper<'lighter', BookChange> {
     yield {
       type: 'book_change',
       symbol,
-      exchange: 'lighter',
+      exchange: this.exchange,
       isSnapshot: message.type === 'subscribed/order_book',
       bids: message.order_book.bids.map(this.mapLevel),
       asks: message.order_book.asks.map(this.mapLevel),
@@ -133,9 +146,11 @@ class LighterBookChangeMapper implements Mapper<'lighter', BookChange> {
   }
 }
 
-class LighterBookTickerMapper implements Mapper<'lighter', BookTicker> {
+class LighterBookTickerMapper<T extends LighterExchange> implements Mapper<T, BookTicker> {
+  constructor(private readonly exchange: T) {}
+
   canHandle(message: LighterTickerMessage) {
-    return message.type === 'update/ticker'
+    return message.type === 'update/ticker' || message.type === 'subscribed/ticker'
   }
 
   getFilters(symbols?: string[]) {
@@ -154,7 +169,7 @@ class LighterBookTickerMapper implements Mapper<'lighter', BookTicker> {
     yield {
       type: 'book_ticker',
       symbol,
-      exchange: 'lighter',
+      exchange: this.exchange,
       askAmount: asNonZeroNumberOrUndefined(message.ticker?.a?.size),
       askPrice: asNonZeroNumberOrUndefined(message.ticker?.a?.price),
       bidPrice: asNonZeroNumberOrUndefined(message.ticker?.b?.price),
@@ -165,11 +180,13 @@ class LighterBookTickerMapper implements Mapper<'lighter', BookTicker> {
   }
 }
 
-class LighterDerivativeTickerMapper implements Mapper<'lighter', DerivativeTicker> {
+class LighterDerivativeTickerMapper<T extends LighterExchange> implements Mapper<T, DerivativeTicker> {
   private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
 
+  constructor(private readonly exchange: T) {}
+
   canHandle(message: LighterMarketStatsMessage) {
-    return message.type === 'update/market_stats'
+    return message.type === 'update/market_stats' || message.type === 'subscribed/market_stats'
   }
 
   getFilters(_symbols?: string[]) {
@@ -183,11 +200,13 @@ class LighterDerivativeTickerMapper implements Mapper<'lighter', DerivativeTicke
 
   *map(message: LighterMarketStatsMessage, localTimestamp: Date): IterableIterator<DerivativeTicker> {
     for (const entry of this.iterateMarketStats(message)) {
-      const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(entry.market_id.toString(), 'lighter')
+      const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(entry.market_id.toString(), this.exchange)
 
       pendingTickerInfo.updateMarkPrice(Number(entry.mark_price))
       pendingTickerInfo.updateIndexPrice(Number(entry.index_price))
-      pendingTickerInfo.updateFundingRate(Number(entry.current_funding_rate))
+      // WS funding is an hourly percentage; normalized fundingRate is a decimal fraction.
+      // https://docs.lighter.xyz/trading/funding#funding-rate-calculation
+      pendingTickerInfo.updateFundingRate(Number(entry.current_funding_rate) / 100)
       pendingTickerInfo.updateLastPrice(Number(entry.last_trade_price))
       pendingTickerInfo.updateOpenInterest(Number(entry.open_interest))
 
@@ -210,12 +229,12 @@ class LighterDerivativeTickerMapper implements Mapper<'lighter', DerivativeTicke
   }
 }
 
-type LighterLevel = {
+export type LighterLevel = {
   price: string
   size: string
 }
 
-type LighterOrderBook = {
+export type LighterOrderBook = {
   asks: LighterLevel[]
   bids: LighterLevel[]
   code: number
@@ -225,7 +244,7 @@ type LighterOrderBook = {
   last_updated_at: number
 }
 
-type LighterOrderBookMessage = {
+export type LighterOrderBookMessage = {
   type: 'subscribed/order_book' | 'update/order_book'
   channel: `order_book:${number}`
   last_updated_at: number
@@ -234,14 +253,14 @@ type LighterOrderBookMessage = {
   order_book: LighterOrderBook
 }
 
-type LighterTicker = {
+export type LighterTicker = {
   s: string
   a?: Partial<LighterLevel>
   b?: Partial<LighterLevel>
   last_updated_at: number
 }
 
-type LighterTickerMessage = {
+export type LighterTickerMessage = {
   type: 'subscribed/ticker' | 'update/ticker'
   channel: `ticker:${number}`
   last_updated_at: number
@@ -250,7 +269,7 @@ type LighterTickerMessage = {
   timestamp: number
 }
 
-type LighterTrade = {
+export type LighterTrade = {
   trade_id: number
   trade_id_str: string
   tx_hash: string
@@ -278,17 +297,26 @@ type LighterTrade = {
   taker_initial_margin_fraction_before?: number
   taker_position_sign_changed?: boolean
   taker_allocated_margin_usdc_before?: number
+  taker_allocated_margin_usdc_after?: number
   maker_fee?: number
   maker_position_size_before?: string
   maker_entry_quote_before?: string
   maker_initial_margin_fraction_before?: number
   maker_position_sign_changed?: boolean
+  maker_allocated_margin_usdc_before?: number
+  maker_allocated_margin_usdc_after?: number
   transaction_time: number
   ask_account_pnl?: string
   bid_account_pnl?: string
+  integrator_taker_fee?: number
+  integrator_taker_fee_collector_index?: number
+  integrator_maker_fee?: number
+  integrator_maker_fee_collector_index?: number
+  ask_order_version?: number
+  bid_order_version?: number
 }
 
-type LighterTradeMessage = {
+export type LighterTradeMessage = {
   type: 'subscribed/trade' | 'update/trade'
   channel: `trade:${number}`
   nonce: number
@@ -296,12 +324,14 @@ type LighterTradeMessage = {
   liquidation_trades?: LighterTrade[]
 }
 
-type LighterMarketStats = {
+export type LighterMarketStats = {
   symbol: string
   market_id: number
   index_price: string
   mark_price: string
   mid_price: string
+  best_ask_price: string
+  best_bid_price: string
   open_interest: string
   open_interest_limit: string
   funding_clamp_small: string
@@ -315,29 +345,33 @@ type LighterMarketStats = {
   daily_price_low: number
   daily_price_high: number
   daily_price_change: number
+  base_interest_rate: string
+  premium?: string
 }
 
-type LighterMarketStatsAllMessage = {
+export type LighterMarketStatsAllMessage = {
   type: 'subscribed/market_stats' | 'update/market_stats'
   channel: 'market_stats:all'
   timestamp: number
   market_stats: Record<string, LighterMarketStats>
 }
 
-type LighterMarketStatsMarketIdMessage = {
+export type LighterMarketStatsMarketIdMessage = {
   type: 'subscribed/market_stats' | 'update/market_stats'
   channel: `market_stats:${number}`
   timestamp: number
   market_stats: LighterMarketStats
 }
 
-type LighterMarketStatsMessage = LighterMarketStatsAllMessage | LighterMarketStatsMarketIdMessage
+export type LighterMarketStatsMessage = LighterMarketStatsAllMessage | LighterMarketStatsMarketIdMessage
 
-type LighterSpotMarketStats = {
+export type LighterSpotMarketStats = {
   symbol: string
   market_id: number
   index_price: string
   mid_price: string
+  best_ask_price: string
+  best_bid_price: string
   last_trade_price: string
   daily_base_token_volume: number
   daily_quote_token_volume: number
@@ -346,18 +380,18 @@ type LighterSpotMarketStats = {
   daily_price_change: number
 }
 
-type LighterSpotMarketStatsAllMessage = {
+export type LighterSpotMarketStatsAllMessage = {
   type: 'subscribed/spot_market_stats' | 'update/spot_market_stats'
   channel: 'spot_market_stats:all'
   timestamp: number
   spot_market_stats: Record<string, LighterSpotMarketStats>
 }
 
-type LighterSpotMarketStatsMarketIdMessage = {
+export type LighterSpotMarketStatsMarketIdMessage = {
   type: 'subscribed/spot_market_stats' | 'update/spot_market_stats'
   channel: `spot_market_stats:${number}`
   timestamp: number
   spot_market_stats: LighterSpotMarketStats
 }
 
-type LighterSpotMarketStatsMessage = LighterSpotMarketStatsAllMessage | LighterSpotMarketStatsMarketIdMessage
+export type LighterSpotMarketStatsMessage = LighterSpotMarketStatsAllMessage | LighterSpotMarketStatsMarketIdMessage