tardis-machine 18.3.8 → 18.4.1

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

@@ -1,6 +1,6 @@
 import { lowerCaseSymbols } from '../handy.ts'
-import { BookChange, Trade } from '../types.ts'
-import { Mapper } from './mapper.ts'
+import { BookChange, DerivativeTicker, Trade } from '../types.ts'
+import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
 import { exchangeMappers } from './registry.ts'
 
 // https://www.bitstamp.net/websocket/v2/
@@ -8,12 +8,13 @@ import { exchangeMappers } from './registry.ts'
 export const bitstampMappers = exchangeMappers({
   bitstamp: {
     trades: () => bitstampTradesMapper,
-    bookChanges: () => new BitstampBookChangeMapper()
+    bookChanges: () => new BitstampBookChangeMapper(),
+    derivativeTickers: () => new BitstampDerivativeTickerMapper()
   }
 })
 
 const bitstampTradesMapper: Mapper<'bitstamp', Trade> = {
-  canHandle(message: BitstampTrade | BitstampDiffOrderBook | BitstampDiffOrderBookSnapshot) {
+  canHandle(message: BitstampMessage) {
     if (message.data === undefined) {
       return false
     }
@@ -43,7 +44,7 @@ const bitstampTradesMapper: Mapper<'bitstamp', Trade> = {
       type: 'trade',
       symbol: symbol.toUpperCase(),
       exchange: 'bitstamp',
-      id: String(bitstampTrade.id),
+      id: bitstampTrade.id_str ?? String(bitstampTrade.id),
       price: Number(bitstampTrade.price),
       amount: Number(bitstampTrade.amount),
       side: bitstampTrade.type === 0 ? 'buy' : 'sell',
@@ -53,10 +54,60 @@ const bitstampTradesMapper: Mapper<'bitstamp', Trade> = {
   }
 }
 
+class BitstampDerivativeTickerMapper implements Mapper<'bitstamp', DerivativeTicker> {
+  private readonly _pendingTickerInfoHelper = new PendingTickerInfoHelper()
+
+  canHandle(message: BitstampMessage) {
+    if (message.data === undefined) {
+      return false
+    }
+    if (message.event === 'funding_rate_saved') {
+      return message.channel.startsWith('funding_rate_')
+    }
+    if (message.event === 'ticker') {
+      return message.channel.startsWith('ticker_') && message.channel.endsWith('-perp')
+    }
+    return message.event === 'trade' && message.channel.startsWith('live_trades_') && message.channel.endsWith('-perp')
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = lowerCaseSymbols(symbols)
+    return [
+      { channel: 'funding_rate', symbols } as const,
+      { channel: 'live_trades', symbols } as const,
+      { channel: 'ticker', symbols } as const
+    ]
+  }
+
+  *map(message: BitstampTrade | BitstampFundingRate | BitstampTicker, localTimestamp: Date): IterableIterator<DerivativeTicker> {
+    const symbol = message.channel.slice(message.channel.lastIndexOf('_') + 1).toUpperCase()
+    const ticker = this._pendingTickerInfoHelper.getPendingTickerInfo(symbol, 'bitstamp')
+    if (message.event === 'trade') {
+      // Funding messages own emission and timestamps; trades only update lastPrice.
+      ticker.updateLastPrice(Number(message.data.price))
+      return
+    }
+    if (message.event === 'ticker') {
+      // Recorder-generated REST ticker, polled every 6 seconds; it only adds open interest to the funding-driven ticker.
+      ticker.updateOpenInterest(Number(message.data.open_interest))
+      return
+    }
+
+    ticker.updateFundingRate(Number(message.data.funding_rate))
+    ticker.updateFundingTimestamp(new Date(Number(message.data.next_funding_time) * 1000))
+    ticker.updateMarkPrice(Number(message.data.mark_price))
+    ticker.updateIndexPrice(Number(message.data.index_price))
+    ticker.updateTimestamp(new Date(Number(message.data.timestamp) * 1000))
+    if (ticker.hasChanged()) {
+      yield ticker.getSnapshot(localTimestamp)
+    }
+  }
+}
+
 class BitstampBookChangeMapper implements Mapper<'bitstamp', BookChange> {
   private readonly _symbolToDepthInfoMapping: { [key: string]: LocalDepthInfo } = {}
 
-  canHandle(message: BitstampTrade | BitstampDiffOrderBook | BitstampDiffOrderBookSnapshot) {
+  canHandle(message: BitstampMessage) {
     if (message.data === undefined) {
       return false
     }
@@ -176,44 +227,67 @@ class BitstampBookChangeMapper implements Mapper<'bitstamp', BookChange> {
   }
 }
 
-type BitstampTrade = {
-  event: 'trade'
+type BitstampMessage<Event extends string = string, Data = unknown> = {
+  event: Event
   channel: string
-  data: {
+  data: Data
+}
+
+type BitstampTrade = BitstampMessage<
+  'trade',
+  {
     microtimestamp: string
     amount: number
     price: number
     type: number
     id: number
+    id_str?: string
+  }
+>
+type BitstampTicker = BitstampMessage<
+  'ticker',
+  {
+    market: string
+    open_interest: string
+  }
+>
+type BitstampFundingRate = BitstampMessage<
+  'funding_rate_saved',
+  {
+    market: string
+    funding_rate: string
+    mark_price: string
+    index_price: string
+    timestamp: string
+    next_funding_time: string
   }
+>
+
+type LocalDepthInfo = {
+  bufferedUpdates: BitstampDiffOrderBook[]
+  snapshotProcessed?: boolean
+  lastUpdateTimestamp?: number
+  lastUpdateMicroTimestamp?: number
 }
-type BitstampBookLevel = [string, string]
 
-type BitstampDiffOrderBook = {
-  data: {
-    microtimestamp: string
+type BitstampDiffOrderBook = BitstampMessage<
+  'data',
+  {
     timestamp: string
+    microtimestamp: string
     bids: BitstampBookLevel[]
     asks: BitstampBookLevel[]
   }
-  event: 'data'
-  channel: string
-}
+>
 
-type BitstampDiffOrderBookSnapshot = {
-  event: 'snapshot'
-  channel: string
-  data: {
+type BitstampDiffOrderBookSnapshot = BitstampMessage<
+  'snapshot',
+  {
     timestamp: string
     microtimestamp?: string
     bids: BitstampBookLevel[]
     asks: BitstampBookLevel[]
   }
-}
+>
 
-type LocalDepthInfo = {
-  bufferedUpdates: BitstampDiffOrderBook[]
-  snapshotProcessed?: boolean
-  lastUpdateTimestamp?: number
-  lastUpdateMicroTimestamp?: number
-}
+type BitstampBookLevel = [string, string]

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

@@ -46,12 +46,16 @@ export const bybitMappers = exchangeMappers({
     trades: () => new BybitV5TradesMapper('bybit-options'),
     bookChanges: () => new BybitV5BookChangeMapper('bybit-options', { depth: 25 }),
     optionsSummary: () => new BybitV5OptionSummaryMapper()
+  },
+  'bybit-spread': {
+    trades: () => new BybitV5TradesMapper('bybit-spread'),
+    bookChanges: () => new BybitV5BookChangeMapper('bybit-spread', { depth: 25 })
   }
 })
 
 // v5 https://bybit-exchange.github.io/docs/v5/ws/connect
 
-class BybitV5TradesMapper implements Mapper<'bybit' | 'bybit-spot' | 'bybit-options', Trade> {
+class BybitV5TradesMapper implements Mapper<'bybit' | 'bybit-spot' | 'bybit-options' | 'bybit-spread', Trade> {
   constructor(private readonly _exchange: Exchange) {}
 
   canHandle(message: BybitV5Trade) {
@@ -90,7 +94,7 @@ class BybitV5TradesMapper implements Mapper<'bybit' | 'bybit-spot' | 'bybit-opti
   }
 }
 
-class BybitV5BookChangeMapper implements Mapper<'bybit' | 'bybit-spot' | 'bybit-options', BookChange> {
+class BybitV5BookChangeMapper implements Mapper<'bybit' | 'bybit-spot' | 'bybit-options' | 'bybit-spread', BookChange> {
   private readonly _depth: number
 
   constructor(

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

@@ -0,0 +1,230 @@
+import { asNumberOrUndefined, parseISODateWithMicroseconds, upperCaseSymbols } from '../handy.ts'
+import { BookChange, BookTicker, DerivativeTicker, Trade } from '../types.ts'
+import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
+import { exchangeMappers } from './registry.ts'
+
+export const coinbaseDerivativesMappers = exchangeMappers({
+  'coinbase-derivatives': {
+    trades: () => new CoinbaseDerivativesTradesMapper(),
+    bookChanges: () => new CoinbaseDerivativesBookChangeMapper(),
+    bookTickers: () => new CoinbaseDerivativesBookTickerMapper(),
+    derivativeTickers: () => new CoinbaseDerivativesTickerMapper()
+  }
+})
+
+class CoinbaseDerivativesTradesMapper implements Mapper<'coinbase-derivatives', Trade> {
+  // Besides the subscribe snapshot, Coinbase resends recent-trade snapshots mid-connection, each followed by an update with the preceding older trades.
+  private readonly _snapshotTradeIds = new Map<string, number>()
+
+  canHandle(message: CoinbaseDerivativesTrade) {
+    return message.channel === 'market_trades'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'market_trades', symbols: upperCaseSymbols(symbols) } as const]
+  }
+
+  *map(message: CoinbaseDerivativesTrade, localTimestamp: Date): IterableIterator<Trade> {
+    for (const event of message.events) {
+      if (event.type === 'snapshot') {
+        for (const trade of event.trades) {
+          const tradeId = Number(trade.trade_id)
+          this._snapshotTradeIds.set(trade.product_id, Math.max(tradeId, this._snapshotTradeIds.get(trade.product_id) ?? tradeId))
+        }
+        continue
+      }
+
+      for (const trade of event.trades) {
+        if (Number(trade.trade_id) <= (this._snapshotTradeIds.get(trade.product_id) ?? 0)) {
+          continue
+        }
+
+        yield {
+          type: 'trade',
+          exchange: 'coinbase-derivatives',
+          symbol: trade.product_id,
+          id: trade.trade_id,
+          price: Number(trade.price),
+          amount: Number(trade.size),
+          side: trade.side === 'BUY' ? 'sell' : 'buy',
+          timestamp: parseISODateWithMicroseconds(trade.time),
+          localTimestamp
+        }
+      }
+    }
+  }
+}
+
+class CoinbaseDerivativesBookChangeMapper implements Mapper<'coinbase-derivatives', BookChange> {
+  canHandle(message: CoinbaseDerivativesBook) {
+    return message.channel === 'l2_data'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'l2_data', symbols: upperCaseSymbols(symbols) } as const]
+  }
+
+  *map(message: CoinbaseDerivativesBook, localTimestamp: Date): IterableIterator<BookChange> {
+    for (const event of message.events) {
+      yield {
+        type: 'book_change',
+        exchange: 'coinbase-derivatives',
+        symbol: event.product_id,
+        isSnapshot: event.type === 'snapshot',
+        bids: event.updates.filter((u) => u.side === 'bid').map(this.mapBookLevel),
+        asks: event.updates.filter((u) => u.side === 'offer').map(this.mapBookLevel),
+        timestamp: parseISODateWithMicroseconds(
+          event.updates.length > 0 ? event.updates[event.updates.length - 1].event_time : message.timestamp
+        ),
+        localTimestamp
+      }
+    }
+  }
+
+  private mapBookLevel(update: CoinbaseDerivativesBook['events'][number]['updates'][number]) {
+    return {
+      price: Number(update.price_level),
+      amount: Number(update.new_quantity)
+    }
+  }
+}
+
+class CoinbaseDerivativesBookTickerMapper implements Mapper<'coinbase-derivatives', BookTicker> {
+  canHandle(message: CoinbaseDerivativesTicker) {
+    return message.channel === 'ticker'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'ticker', symbols: upperCaseSymbols(symbols) } as const]
+  }
+
+  *map(message: CoinbaseDerivativesTicker, localTimestamp: Date): IterableIterator<BookTicker> {
+    for (const event of message.events)
+      for (const ticker of event.tickers) {
+        const bidPrice = asNumberOrUndefined(ticker.best_bid)
+        const askPrice = asNumberOrUndefined(ticker.best_ask)
+
+        if (bidPrice === undefined && askPrice === undefined) {
+          continue
+        }
+
+        yield {
+          type: 'book_ticker',
+          exchange: 'coinbase-derivatives',
+          symbol: ticker.product_id,
+          bidPrice,
+          bidAmount: asNumberOrUndefined(ticker.best_bid_quantity),
+          askPrice,
+          askAmount: asNumberOrUndefined(ticker.best_ask_quantity),
+          timestamp: parseISODateWithMicroseconds(message.timestamp),
+          localTimestamp
+        }
+      }
+  }
+}
+
+class CoinbaseDerivativesTickerMapper implements Mapper<'coinbase-derivatives', DerivativeTicker> {
+  private readonly pending = new PendingTickerInfoHelper()
+
+  canHandle(message: CoinbaseDerivativesProducts | CoinbaseDerivativesTicker) {
+    return message.channel === 'products' || message.channel === 'ticker'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [
+      { channel: 'products', symbols: upperCaseSymbols(symbols) } as const,
+      { channel: 'ticker', symbols: upperCaseSymbols(symbols) } as const
+    ]
+  }
+
+  *map(message: CoinbaseDerivativesProducts | CoinbaseDerivativesTicker, localTimestamp: Date) {
+    if (message.channel === 'ticker') {
+      for (const event of message.events)
+        for (const ticker of event.tickers) {
+          const info = this.pending.getPendingTickerInfo(ticker.product_id, 'coinbase-derivatives')
+          info.updateLastPrice(asNumberOrUndefined(ticker.price))
+          info.updateTimestamp(parseISODateWithMicroseconds(message.timestamp))
+          if (info.hasChanged()) {
+            yield info.getSnapshot(localTimestamp)
+          }
+        }
+      return
+    }
+
+    for (const product of message.events) {
+      const info = this.pending.getPendingTickerInfo(product.product_id, 'coinbase-derivatives')
+
+      const details = product.future_product_details
+      info.updateOpenInterest(asNumberOrUndefined(details.open_interest))
+      info.updateFundingRate(asNumberOrUndefined(details.funding_rate))
+      info.updateIndexPrice(asNumberOrUndefined(details.index_price))
+      // funding_time identifies the published rate, not the next funding event. No mark price is supplied.
+      info.updateTimestamp(localTimestamp)
+
+      if (info.hasChanged()) {
+        yield info.getSnapshot(localTimestamp)
+      }
+    }
+  }
+}
+
+type CoinbaseDerivativesMessage<Channel extends string, Event> = {
+  channel: Channel
+  events: Event[]
+}
+
+type CoinbaseDerivativesTrade = CoinbaseDerivativesMessage<
+  'market_trades',
+  {
+    type: CoinbaseDerivativesMessageType
+    trades: {
+      product_id: string
+      trade_id: string
+      price: string
+      size: string
+      side: 'BUY' | 'SELL'
+      time: string
+    }[]
+  }
+>
+type CoinbaseDerivativesBook = CoinbaseDerivativesMessage<
+  'l2_data',
+  {
+    type: CoinbaseDerivativesMessageType
+    product_id: string
+    updates: {
+      side: 'bid' | 'offer'
+      price_level: string
+      new_quantity: string
+      event_time: string
+    }[]
+  }
+> & { timestamp: string }
+
+type CoinbaseDerivativesTicker = CoinbaseDerivativesMessage<
+  'ticker',
+  {
+    tickers: {
+      product_id: string
+      price: string
+      best_bid?: string
+      best_ask?: string
+      best_bid_quantity?: string
+      best_ask_quantity?: string
+    }[]
+  }
+> & { timestamp: string }
+
+type CoinbaseDerivativesProducts = CoinbaseDerivativesMessage<
+  'products',
+  {
+    product_id: string
+    future_product_details: {
+      open_interest: string
+      funding_rate: string
+      index_price: string
+    }
+  }
+> & { generated: true }
+
+type CoinbaseDerivativesMessageType = 'snapshot' | 'update'

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

@@ -111,6 +111,8 @@ class DydxV4BookChangeMapper implements Mapper<'dydx-v4', BookChange> {
 
 class DydxV4DerivativeTickerMapper implements Mapper<'dydx-v4', DerivativeTicker> {
   private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
+  // Oracle prices also cover price-only markets such as USDT-USD, so a price waits here until its market appears in a snapshot, trading update or trade.
+  private readonly _unconfirmedOraclePrices = new Map<string, number>()
 
   canHandle(message: DydxMarketsSnapshot | DyDxMarketsUpdate | DyDxTrade) {
     return message.channel === 'v4_markets' || (message.channel === 'v4_trades' && message.type === 'channel_data')
@@ -133,7 +135,7 @@ class DydxV4DerivativeTickerMapper implements Mapper<'dydx-v4', DerivativeTicker
 
   *map(message: DydxMarketsSnapshot | DyDxMarketsUpdate | DyDxTrade, localTimestamp: Date): IterableIterator<DerivativeTicker> {
     if (message.channel === 'v4_trades') {
-      const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(message.id, 'dydx-v4')
+      const pendingTickerInfo = this._getMarketTickerInfo(message.id)
       pendingTickerInfo.updateLastPrice(Number(message.contents.trades[message.contents.trades.length - 1].price))
 
       return
@@ -143,7 +145,7 @@ class DydxV4DerivativeTickerMapper implements Mapper<'dydx-v4', DerivativeTicker
       for (const key in contents) {
         const marketInfo = (contents as any)[key] as DydxMarketsSnapshotContent | DydxMarketTradeUpdate
 
-        const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(key, 'dydx-v4')
+        const pendingTickerInfo = this._getMarketTickerInfo(key)
 
         if (marketInfo.oraclePrice !== undefined) {
           pendingTickerInfo.updateMarkPrice(Number(marketInfo.oraclePrice))
@@ -167,6 +169,12 @@ class DydxV4DerivativeTickerMapper implements Mapper<'dydx-v4', DerivativeTicker
     if (message.type === 'channel_data' && message.contents.oraclePrices !== undefined) {
       for (const key in message.contents.oraclePrices) {
         const oraclePriceInfo = (message.contents.oraclePrices as any)[key] as OraclePriceInfo
+        if (this.pendingTickerInfoHelper.hasPendingTickerInfo(key) === false) {
+          if (oraclePriceInfo.oraclePrice !== undefined) {
+            this._unconfirmedOraclePrices.set(key, Number(oraclePriceInfo.oraclePrice))
+          }
+          continue
+        }
         const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(key, 'dydx-v4')
         if (oraclePriceInfo.oraclePrice !== undefined) {
           pendingTickerInfo.updateMarkPrice(Number(oraclePriceInfo.oraclePrice))
@@ -179,6 +187,16 @@ class DydxV4DerivativeTickerMapper implements Mapper<'dydx-v4', DerivativeTicker
       }
     }
   }
+
+  private _getMarketTickerInfo(market: string) {
+    const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(market, 'dydx-v4')
+    const oraclePrice = this._unconfirmedOraclePrices.get(market)
+    if (oraclePrice !== undefined) {
+      pendingTickerInfo.updateMarkPrice(oraclePrice)
+      this._unconfirmedOraclePrices.delete(market)
+    }
+    return pendingTickerInfo
+  }
 }
 
 class DydxV4LiquidationsMapper implements Mapper<'dydx-v4', Liquidation> {

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

@@ -132,7 +132,7 @@ class FTXDerivativeTickerMapper implements Mapper<'ftx', DerivativeTicker> {
     return [
       {
         channel: 'instrument',
-        symbols: symbols !== undefined ? symbols.filter((s) => s.includes('/') === false) : undefined
+        symbols
       } as const
     ]
   }

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

@@ -16,6 +16,7 @@ import { blockchainComMappers } from './blockchaincom.ts'
 import { bullishMappers } from './bullish.ts'
 import { bybitMappers } from './bybit.ts'
 import { coinbaseMappers } from './coinbase.ts'
+import { coinbaseDerivativesMappers } from './coinbasederivatives.ts'
 import { coinbaseInternationalMappers } from './coinbaseinternational.ts'
 import { coinflexMappers } from './coinflex.ts'
 import { cryptoComMappers } from './cryptocom.ts'
@@ -74,6 +75,7 @@ const registeredMappers = mergeExchangeMappers(
   bullishMappers,
   bybitMappers,
   coinbaseMappers,
+  coinbaseDerivativesMappers,
   coinbaseInternationalMappers,
   coinflexMappers,
   cryptoComMappers,

package/node_modules/tardis-dev/src/realtimefeeds/bitstamp.ts

@@ -1,10 +1,57 @@
+import { Writable } from 'stream'
 import { getJSON } from '../handy.ts'
 import { Filter } from '../types.ts'
-import { RealTimeFeedBase } from './realtimefeed.ts'
+import { MultiConnectionRealTimeFeedBase, PoolingClientBase, RealTimeFeedBase } from './realtimefeed.ts'
 
-export class BitstampRealTimeFeed extends RealTimeFeedBase {
+const BITSTAMP_HTTP_URL = 'https://www.bitstamp.net/api/v2'
+
+export class BitstampRealTimeFeed extends MultiConnectionRealTimeFeedBase {
+  protected *_getRealTimeFeeds(exchange: string, filters: Filter<string>[], timeoutIntervalMS?: number, onError?: (error: Error) => void) {
+    const wsFilters = filters.filter((f) => f.channel !== 'ticker')
+    if (wsFilters.length > 0) {
+      yield new BitstampWebSocketRealTimeFeed(exchange, wsFilters, timeoutIntervalMS, onError)
+    }
+
+    const tickerFilters = filters.filter((f) => f.channel === 'ticker')
+    if (tickerFilters.length > 0) {
+      yield new BitstampTickerClient(
+        exchange,
+        tickerFilters.flatMap((f) => f.symbols ?? []),
+        onError
+      )
+    }
+  }
+}
+
+// Bitstamp WebSocket has no ticker channel; the recorder polls the REST ticker and stores it in this generated message shape.
+class BitstampTickerClient extends PoolingClientBase {
+  constructor(
+    exchange: string,
+    private readonly _symbols: string[],
+    onError?: (error: Error) => void
+  ) {
+    super(exchange, 6, onError)
+  }
+
+  protected async poolDataToStream(outputStream: Writable) {
+    const { data: tickers } = await getJSON<{ market: string }[]>(`${BITSTAMP_HTTP_URL}/ticker/`, { timeout: 10000 })
+
+    for (const ticker of tickers) {
+      const symbol = ticker.market.replace('/', '').toLowerCase()
+      if (this._symbols.length > 0 && this._symbols.includes(symbol) === false) {
+        continue
+      }
+
+      if (outputStream.writable) {
+        outputStream.write({ data: ticker, channel: `ticker_${symbol}`, event: 'ticker', generated: true })
+      }
+    }
+  }
+}
+
+class BitstampWebSocketRealTimeFeed extends RealTimeFeedBase {
   protected wssURL = 'wss://ws.bitstamp.net'
-  protected httpURL = 'https://www.bitstamp.net/api/v2'
+  protected httpURL = BITSTAMP_HTTP_URL
 
   protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
     return filters

package/node_modules/tardis-dev/src/realtimefeeds/bybit.ts

@@ -90,6 +90,10 @@ export class BybitSpotRealTimeDataFeed extends BybitSingleConnectionRealTimeData
   protected wssURL: string = 'wss://stream.bybit.com/v5/public/spot'
 }
 
+export class BybitSpreadRealTimeDataFeed extends BybitSingleConnectionRealTimeDataFeed {
+  protected wssURL: string = 'wss://stream.bybit.com/v5/public/spread'
+}
+
 export class BybitOptionsRealTimeDataFeed extends BybitSingleConnectionRealTimeDataFeed {
   protected wssURL: string = 'wss://stream.bybit.com/v5/public/option'