tardis-dev 16.5.1 → 16.6.0

package/src/mappers/mexcfutures.ts

@@ -0,0 +1,352 @@
+import { debug } from '../debug.ts'
+import { CircularBuffer, upperCaseSymbols } from '../handy.ts'
+import { BookChange, DerivativeTicker, Trade } from '../types.ts'
+import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
+import { exchangeMappers, isRealTime } from './registry.ts'
+
+export const mexcFuturesMappers = exchangeMappers({
+  'mexc-futures': {
+    trades: () => new MexcFuturesTradesMapper(),
+    bookChanges: (localTimestamp) =>
+      new MexcFuturesBookChangeMapper({ ignoreBookSnapshotOverlapError: isRealTime(localTimestamp) === false }),
+    derivativeTickers: () => new MexcFuturesDerivativeTickerMapper()
+  }
+})
+
+export class MexcFuturesTradesMapper implements Mapper<'mexc-futures', Trade> {
+  canHandle(message: MexcFuturesDealMessage) {
+    return message.channel === 'push.deal'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'push.deal', symbols: upperCaseSymbols(symbols) } as const]
+  }
+
+  *map(message: MexcFuturesDealMessage, localTimestamp: Date): IterableIterator<Trade> {
+    for (const trade of message.data) {
+      yield {
+        type: 'trade',
+        symbol: message.symbol,
+        exchange: 'mexc-futures',
+        id: trade.i,
+        price: trade.p,
+        amount: trade.v,
+        side: trade.T === MexcFuturesTradeSide.Buy ? 'buy' : 'sell',
+        timestamp: new Date(trade.t),
+        localTimestamp
+      }
+    }
+  }
+}
+
+export class MexcFuturesBookChangeMapper implements Mapper<'mexc-futures', BookChange> {
+  private readonly symbolDepthInfo: Record<string, MexcFuturesDepthInfo> = {}
+  private readonly ignoreBookSnapshotOverlapError: boolean
+
+  constructor({ ignoreBookSnapshotOverlapError }: { ignoreBookSnapshotOverlapError: boolean }) {
+    this.ignoreBookSnapshotOverlapError = ignoreBookSnapshotOverlapError
+  }
+
+  canHandle(message: MexcFuturesDepthMessage) {
+    return message.channel === 'push.depth' || message.channel === 'push.depth.snapshot'
+  }
+
+  getFilters(symbols?: string[]) {
+    const normalizedSymbols = upperCaseSymbols(symbols)
+
+    return [
+      { channel: 'push.depth', symbols: normalizedSymbols } as const,
+      { channel: 'push.depth.snapshot', symbols: normalizedSymbols } as const
+    ]
+  }
+
+  *map(message: MexcFuturesDepthMessage, localTimestamp: Date): IterableIterator<BookChange> {
+    const depthInfo = this.getSymbolDepthInfo(message.symbol)
+    if (message.generated === true) {
+      if (depthInfo.snapshotEmitted) {
+        return
+      }
+
+      for (const update of depthInfo.updates.items()) {
+        const updateFirstVersion = this.getFirstVersion(update.data)
+        const updateLastVersion = this.getLastVersion(update.data)
+        if (message.data.version >= updateLastVersion) {
+          continue
+        }
+
+        if (!depthInfo.isContinuityValidated) {
+          if (updateFirstVersion > message.data.version + 1 || updateLastVersion < message.data.version + 1) {
+            const errorMessage = `MEXC futures depth snapshot has no overlap with first update, update ${JSON.stringify(update)}, currentBookVersion: ${message.data.version}`
+            if (this.ignoreBookSnapshotOverlapError) {
+              depthInfo.isContinuityValidated = true
+              debug(errorMessage)
+            } else {
+              throw new Error(errorMessage)
+            }
+          } else {
+            depthInfo.isContinuityValidated = true
+          }
+        }
+
+        for (const bid of update.data.bids) {
+          this.applyLevel(message.data.bids, bid)
+        }
+        for (const ask of update.data.asks) {
+          this.applyLevel(message.data.asks, ask)
+        }
+        message.data.version = updateLastVersion
+      }
+      depthInfo.updates.clear()
+      depthInfo.currentBookVersion = message.data.version
+      depthInfo.snapshotEmitted = true
+
+      yield {
+        type: 'book_change',
+        symbol: message.symbol,
+        exchange: 'mexc-futures',
+        isSnapshot: true,
+        bids: message.data.bids.map(this.mapBookLevel),
+        asks: message.data.asks.map(this.mapBookLevel),
+        timestamp: new Date(message.data.timestamp),
+        localTimestamp
+      }
+
+      return
+    }
+
+    if (!depthInfo.snapshotEmitted) {
+      depthInfo.updates.append(message)
+      return
+    }
+
+    const firstVersion = this.getFirstVersion(message.data)
+    const lastVersion = this.getLastVersion(message.data)
+    if (lastVersion <= depthInfo.currentBookVersion!) {
+      return
+    }
+
+    if (!depthInfo.isContinuityValidated) {
+      if (firstVersion > depthInfo.currentBookVersion! + 1 || lastVersion < depthInfo.currentBookVersion! + 1) {
+        const errorMessage = `MEXC futures depth snapshot has no overlap with first update, update ${JSON.stringify(message)}, currentBookVersion: ${depthInfo.currentBookVersion}`
+        if (this.ignoreBookSnapshotOverlapError) {
+          depthInfo.isContinuityValidated = true
+          debug(errorMessage)
+        } else {
+          throw new Error(errorMessage)
+        }
+      } else {
+        depthInfo.isContinuityValidated = true
+      }
+    }
+
+    depthInfo.currentBookVersion = lastVersion
+
+    yield {
+      type: 'book_change',
+      symbol: message.symbol,
+      exchange: 'mexc-futures',
+      isSnapshot: false,
+      bids: message.data.bids.map(this.mapBookLevel),
+      asks: message.data.asks.map(this.mapBookLevel),
+      timestamp: new Date(message.ts),
+      localTimestamp
+    }
+  }
+
+  private getFirstVersion(data: MexcFuturesDepthUpdateData) {
+    return data.begin !== undefined && data.begin !== null && data.begin !== 0 ? data.begin : data.version
+  }
+
+  private getLastVersion(data: MexcFuturesDepthUpdateData) {
+    return data.end !== undefined && data.end !== null && data.end !== 0 ? data.end : data.version
+  }
+
+  private applyLevel(bookSide: MexcFuturesDepthLevel[], levelUpdate: MexcFuturesDepthLevel) {
+    const existingIndex = bookSide.findIndex((level) => level[0] === levelUpdate[0])
+    if (levelUpdate[1] === 0) {
+      if (existingIndex !== -1) {
+        bookSide.splice(existingIndex, 1)
+      }
+      return
+    }
+
+    if (existingIndex === -1) {
+      bookSide.push(levelUpdate)
+    } else {
+      bookSide[existingIndex] = levelUpdate
+    }
+  }
+
+  private mapBookLevel(level: MexcFuturesDepthLevel) {
+    return {
+      price: level[0],
+      amount: level[1]
+    }
+  }
+
+  private getSymbolDepthInfo(symbol: string) {
+    if (this.symbolDepthInfo[symbol] === undefined) {
+      this.symbolDepthInfo[symbol] = { updates: new CircularBuffer<MexcFuturesDepthUpdateMessage>(2000) }
+    }
+
+    return this.symbolDepthInfo[symbol]
+  }
+}
+
+export class MexcFuturesDerivativeTickerMapper implements Mapper<'mexc-futures', DerivativeTicker> {
+  private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
+
+  canHandle(message: MexcFuturesTickerMessage | MexcFuturesFundingRateMessage) {
+    return message.channel === 'push.ticker' || message.channel === 'push.funding.rate'
+  }
+
+  getFilters(symbols?: string[]) {
+    const normalizedSymbols = upperCaseSymbols(symbols)
+
+    return [
+      { channel: 'push.ticker', symbols: normalizedSymbols } as const,
+      { channel: 'push.funding.rate', symbols: normalizedSymbols } as const
+    ]
+  }
+
+  *map(message: MexcFuturesTickerMessage | MexcFuturesFundingRateMessage, localTimestamp: Date): IterableIterator<DerivativeTicker> {
+    const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(message.symbol, 'mexc-futures')
+
+    if (message.channel === 'push.funding.rate') {
+      pendingTickerInfo.updateFundingRate(message.data.rate)
+      pendingTickerInfo.updateFundingTimestamp(
+        message.data.nextSettleTime !== undefined ? new Date(message.data.nextSettleTime) : undefined
+      )
+      return
+    }
+
+    pendingTickerInfo.updateLastPrice(message.data.lastPrice)
+    pendingTickerInfo.updateOpenInterest(message.data.holdVol)
+    pendingTickerInfo.updateIndexPrice(message.data.indexPrice)
+    pendingTickerInfo.updateMarkPrice(message.data.fairPrice)
+    pendingTickerInfo.updateTimestamp(new Date(message.data.timestamp))
+
+    if (pendingTickerInfo.hasChanged()) {
+      yield pendingTickerInfo.getSnapshot(localTimestamp)
+    }
+  }
+}
+
+const MEXC_FUTURES_MAPPED_PUSH_CHANNELS = [
+  'push.deal',
+  'push.depth',
+  'push.depth.snapshot',
+  'push.ticker',
+  'push.index.price',
+  'push.fair.price',
+  'push.funding.rate'
+] as const
+type MexcFuturesMappedPushChannel = (typeof MEXC_FUTURES_MAPPED_PUSH_CHANNELS)[number]
+type MexcFuturesMessage<TChannel extends MexcFuturesMappedPushChannel, TData> = {
+  channel: TChannel
+  symbol: string
+  ts: number
+  data: TData
+}
+
+type MexcFuturesDealMessage = MexcFuturesMessage<
+  'push.deal',
+  {
+    p: number
+    v: number
+    T: MexcFuturesTradeSide
+    O: MexcFuturesOpenCloseFlag
+    M: MexcFuturesSelfTrade
+    t: number
+    i: string
+    cts?: string
+  }[]
+>
+
+enum MexcFuturesTradeSide {
+  Buy = 1,
+  Sell = 2
+}
+enum MexcFuturesOpenCloseFlag {
+  NewPosition = 1,
+  ReducePosition = 2,
+  Unchanged = 3
+}
+enum MexcFuturesSelfTrade {
+  Yes = 1,
+  No = 2
+}
+
+type MexcFuturesDepthInfo = {
+  isContinuityValidated?: boolean
+  currentBookVersion?: number
+  snapshotEmitted?: boolean
+  updates: CircularBuffer<MexcFuturesDepthUpdateMessage>
+}
+
+type MexcFuturesDepthMessage = MexcFuturesDepthSnapshotMessage | MexcFuturesDepthUpdateMessage
+
+export type MexcFuturesDepthSnapshotMessage = {
+  channel: 'push.depth.snapshot'
+  symbol: string
+  generated: true
+  data: MexcFuturesDepthSnapshotData
+}
+
+export type MexcFuturesDepthSnapshotData = {
+  asks: MexcFuturesDepthLevel[]
+  bids: MexcFuturesDepthLevel[]
+  cts?: number | null
+  timestamp: number
+  version: number
+}
+
+type MexcFuturesDepthUpdateMessage = MexcFuturesMessage<'push.depth', MexcFuturesDepthUpdateData> & { generated?: undefined }
+
+export type MexcFuturesDepthUpdateData = {
+  asks: MexcFuturesDepthLevel[]
+  bids: MexcFuturesDepthLevel[]
+  begin?: number | null
+  cts?: number
+  end?: number | null
+  version: number
+}
+
+export type MexcFuturesDepthLevel = [price: number, quantity: number, ordersCount: number]
+
+type MexcFuturesTickerMessage = MexcFuturesMessage<
+  'push.ticker',
+  {
+    ask1: number
+    bid1: number
+    contractId?: number
+    fairPrice: number
+    fundingRate: number
+    high24Price: number
+    indexPrice: number
+    lastPrice: number
+    lower24Price: number
+    maxBidPrice: number
+    minAskPrice: number
+    riseFallRate: number
+    riseFallValue: number
+    symbol: string
+    timestamp: number
+    holdVol: number
+    volume24: number
+    amount24?: number
+    riseFallRates?: number[]
+    riseFallRatesOfTimezone?: number[]
+    zone?: string
+  }
+>
+
+type MexcFuturesIndexPriceMessage = MexcFuturesMessage<'push.index.price', MexcFuturesPriceData>
+type MexcFuturesFairPriceMessage = MexcFuturesMessage<'push.fair.price', MexcFuturesPriceData>
+
+type MexcFuturesPriceData = {
+  price: number
+  symbol: string
+}
+
+type MexcFuturesFundingRateMessage = MexcFuturesMessage<'push.funding.rate', { rate: number; symbol: string; nextSettleTime?: number }>

package/src/mappers/okex.ts

@@ -1,15 +1,138 @@
 import { asNonZeroNumberOrUndefined, upperCaseSymbols } from '../handy.ts'
+import { getOkexOptionsFamilyOrIndex, getOkexOptionsUnderlyingIndex } from '../okexsymbols.ts'
 import { BookChange, BookTicker, DerivativeTicker, Exchange, Liquidation, OptionSummary, Trade } from '../types.ts'
 import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
+import { OkexSpreadsBookChangeMapper, OkexSpreadsBookTickerMapper, OkexSpreadsTradesMapper } from './okexspreads.ts'
+import { exchangeMappers, mapper } from './registry.ts'
+
+const OKEX_V5_API_SWITCH_DATE = new Date('2021-12-23T00:00:00.000Z')
+const OKEX_V5_TBT_BOOK_TICKER_RELEASE_DATE = new Date('2022-05-06T00:00:00.000Z')
+const OKX_PUBLIC_BOOKS_CHANNEL_START_DATE = new Date('2023-02-25T00:00:00.000Z')
+const OKX_PUBLIC_BOOKS_CHANNEL_END_DATE = new Date('2023-03-09T00:00:00.000Z')
+const OKEX_PUBLIC_BOOKS_SWITCH_DATE = new Date('2026-05-21T00:00:00.000Z')
+const OKEX_SPOT_DEPTH_L2_TBT_SWITCH_DATE = new Date('2020-04-10T00:00:00.000Z')
+const OKEX_FUTURES_DEPTH_L2_TBT_SWITCH_DATE = new Date('2019-12-05T00:00:00.000Z')
+const OKEX_SWAP_DEPTH_L2_TBT_SWITCH_DATE = new Date('2020-02-08T00:00:00.000Z')
+const OKCOIN_DEPTH_L2_TBT_SWITCH_DATE = new Date('2020-02-13T00:00:00.000Z')
+const OKCOIN_V5_API_SWITCH_DATE = new Date('2023-04-27T00:00:00.000Z')
+const OKX_TRADES_ALL_CHANNEL_SWITCH_DATE = new Date('2023-10-19T00:00:00.000Z')
+
+const useOKXTradesAllChannel = () => process.env.OKX_USE_TRADES_CHANNEL === undefined
+
+export const okexMappers = exchangeMappers({
+  okex: {
+    trades: okexTradesMapper('okex', { market: 'spot' }),
+    bookChanges: okexBookChangesMapper('okex', { market: 'spot', depthL2TbtSwitchDate: OKEX_SPOT_DEPTH_L2_TBT_SWITCH_DATE }),
+    bookTickers: okexBookTickersMapper('okex', { market: 'spot' })
+  },
+  'okex-futures': {
+    trades: okexTradesMapper('okex-futures', { market: 'futures' }),
+    bookChanges: okexBookChangesMapper('okex-futures', {
+      market: 'futures',
+      depthL2TbtSwitchDate: OKEX_FUTURES_DEPTH_L2_TBT_SWITCH_DATE
+    }),
+    derivativeTickers: mapper([
+      { until: OKEX_V5_API_SWITCH_DATE, use: () => new OkexDerivativeTickerMapper('okex-futures') },
+      { use: () => new OkexV5DerivativeTickerMapper('okex-futures') }
+    ]),
+    liquidations: mapper([
+      { until: OKEX_V5_API_SWITCH_DATE, use: () => new OkexLiquidationsMapper('okex-futures', { market: 'futures' }) },
+      { use: () => new OkexV5LiquidationsMapper('okex-futures') }
+    ]),
+    bookTickers: okexBookTickersMapper('okex-futures', { market: 'futures' })
+  },
+  'okex-swap': {
+    trades: okexTradesMapper('okex-swap', { market: 'swap' }),
+    bookChanges: okexBookChangesMapper('okex-swap', { market: 'swap', depthL2TbtSwitchDate: OKEX_SWAP_DEPTH_L2_TBT_SWITCH_DATE }),
+    derivativeTickers: mapper([
+      { until: OKEX_V5_API_SWITCH_DATE, use: () => new OkexDerivativeTickerMapper('okex-swap') },
+      { use: () => new OkexV5DerivativeTickerMapper('okex-swap') }
+    ]),
+    liquidations: mapper([
+      { until: OKEX_V5_API_SWITCH_DATE, use: () => new OkexLiquidationsMapper('okex-swap', { market: 'swap' }) },
+      { use: () => new OkexV5LiquidationsMapper('okex-swap') }
+    ]),
+    bookTickers: okexBookTickersMapper('okex-swap', { market: 'swap' })
+  },
+  'okex-options': {
+    trades: okexTradesMapper('okex-options', { market: 'option' }),
+    bookChanges: okexBookChangesMapper('okex-options', { market: 'option', depthL2TbtSwitchDate: OKEX_SWAP_DEPTH_L2_TBT_SWITCH_DATE }),
+    optionsSummary: mapper([
+      { until: OKEX_V5_API_SWITCH_DATE, use: () => new OkexOptionSummaryMapper() },
+      { use: () => new OkexV5OptionSummaryMapper() }
+    ]),
+    bookTickers: okexBookTickersMapper('okex-options', { market: 'option' })
+  },
+  okcoin: {
+    trades: mapper([
+      { until: OKCOIN_V5_API_SWITCH_DATE, use: () => new OkexTradesMapper('okcoin', { market: 'spot' }) },
+      { use: () => new OkexV5TradesMapper('okcoin', { useTradesAllChannel: false }) }
+    ]),
+    bookChanges: mapper([
+      {
+        until: OKCOIN_DEPTH_L2_TBT_SWITCH_DATE,
+        use: () => new OkexBookChangeMapper('okcoin', { market: 'spot', useTickByTickChannel: false })
+      },
+      {
+        until: OKCOIN_V5_API_SWITCH_DATE,
+        use: () => new OkexBookChangeMapper('okcoin', { market: 'spot', useTickByTickChannel: true })
+      },
+      { use: () => new OkexV5BookChangeMapper('okcoin', { allowPublicBooksChannel: true }) }
+    ]),
+    bookTickers: mapper([
+      { until: OKCOIN_V5_API_SWITCH_DATE, use: () => new OkexBookTickerMapper('okcoin', { market: 'spot' }) },
+      { use: () => new OkexV5BookTickerMapper('okcoin', { useTbtTickerChannel: true }) }
+    ])
+  },
+  'okex-spreads': {
+    trades: () => new OkexSpreadsTradesMapper(),
+    bookChanges: () => new OkexSpreadsBookChangeMapper(),
+    bookTickers: () => new OkexSpreadsBookTickerMapper()
+  }
+})
+
+function okexTradesMapper(exchange: OKEX_EXCHANGES, { market }: { market: OKEX_MARKETS }) {
+  return mapper([
+    { until: OKEX_V5_API_SWITCH_DATE, use: () => new OkexTradesMapper(exchange, { market }) },
+    { until: OKX_TRADES_ALL_CHANNEL_SWITCH_DATE, use: () => new OkexV5TradesMapper(exchange, { useTradesAllChannel: false }) },
+    { use: () => new OkexV5TradesMapper(exchange, { useTradesAllChannel: useOKXTradesAllChannel() }) }
+  ])
+}
+
+function okexBookChangesMapper(
+  exchange: OKEX_EXCHANGES,
+  { market, depthL2TbtSwitchDate }: { market: OKEX_MARKETS; depthL2TbtSwitchDate: Date }
+) {
+  return mapper([
+    { until: depthL2TbtSwitchDate, use: () => new OkexBookChangeMapper(exchange, { market, useTickByTickChannel: false }) },
+    { until: OKEX_V5_API_SWITCH_DATE, use: () => new OkexBookChangeMapper(exchange, { market, useTickByTickChannel: true }) },
+    { until: OKX_PUBLIC_BOOKS_CHANNEL_START_DATE, use: () => new OkexV5BookChangeMapper(exchange, { allowPublicBooksChannel: false }) },
+    { until: OKX_PUBLIC_BOOKS_CHANNEL_END_DATE, use: () => new OkexV5BookChangeMapper(exchange, { allowPublicBooksChannel: true }) },
+    { until: OKEX_PUBLIC_BOOKS_SWITCH_DATE, use: () => new OkexV5BookChangeMapper(exchange, { allowPublicBooksChannel: false }) },
+    { use: () => new OkexV5BookChangeMapper(exchange, { allowPublicBooksChannel: true }) }
+  ])
+}
+
+function okexBookTickersMapper(exchange: OKEX_EXCHANGES, { market }: { market: OKEX_MARKETS }) {
+  return mapper([
+    { until: OKEX_V5_API_SWITCH_DATE, use: () => new OkexBookTickerMapper(exchange, { market }) },
+    { until: OKEX_V5_TBT_BOOK_TICKER_RELEASE_DATE, use: () => new OkexV5BookTickerMapper(exchange, { useTbtTickerChannel: false }) },
+    { use: () => new OkexV5BookTickerMapper(exchange, { useTbtTickerChannel: true }) }
+  ])
+}
 
 // V5 Okex API mappers
 // https://www.okex.com/docs-v5/en/#websocket-api-public-channel-trades-channel
 
-export class OkexV5TradesMapper implements Mapper<OKEX_EXCHANGES, Trade> {
+class OkexV5TradesMapper implements Mapper<OKEX_EXCHANGES, Trade> {
+  private readonly _useTradesAll: boolean
+
   constructor(
     private readonly _exchange: Exchange,
-    private readonly _useTradesAll: boolean
-  ) {}
+    { useTradesAllChannel }: { useTradesAllChannel: boolean }
+  ) {
+    this._useTradesAll = useTradesAllChannel
+  }
 
   canHandle(message: any) {
     if (message.event !== undefined || message.arg === undefined) {
@@ -62,14 +185,14 @@ const mapV5BookLevel = (level: OkexV5BookLevel) => {
   return { price, amount }
 }
 
-export class OkexV5BookChangeMapper implements Mapper<OKEX_EXCHANGES, BookChange> {
+class OkexV5BookChangeMapper implements Mapper<OKEX_EXCHANGES, BookChange> {
   private _channelName: string
 
   constructor(
     private readonly _exchange: Exchange,
-    usePublicBooksChannel: boolean
+    { allowPublicBooksChannel }: { allowPublicBooksChannel: boolean }
   ) {
-    this._channelName = this._getBooksChannelName(usePublicBooksChannel)
+    this._channelName = this._getBooksChannelName(allowPublicBooksChannel)
   }
 
   canHandle(message: any) {
@@ -84,8 +207,8 @@ export class OkexV5BookChangeMapper implements Mapper<OKEX_EXCHANGES, BookChange
   private _hasVip5Access = process.env.OKX_API_VIP_5 !== undefined
   private _hasColoAccess = process.env.OKX_API_COLO !== undefined
 
-  private _getBooksChannelName(usePublicBooksChannel: boolean) {
-    if (usePublicBooksChannel === false) {
+  private _getBooksChannelName(allowPublicBooksChannel: boolean) {
+    if (allowPublicBooksChannel === false) {
       // historical data always uses books-l2-tbt
       return 'books-l2-tbt'
     }
@@ -142,11 +265,15 @@ export class OkexV5BookChangeMapper implements Mapper<OKEX_EXCHANGES, BookChange
   }
 }
 
-export class OkexV5BookTickerMapper implements Mapper<OKEX_EXCHANGES, BookTicker> {
+class OkexV5BookTickerMapper implements Mapper<OKEX_EXCHANGES, BookTicker> {
+  private readonly _useTbtTickerChannel: boolean
+
   constructor(
     private readonly _exchange: Exchange,
-    private readonly _useTbtTickerChannel: boolean
-  ) {}
+    { useTbtTickerChannel }: { useTbtTickerChannel: boolean }
+  ) {
+    this._useTbtTickerChannel = useTbtTickerChannel
+  }
 
   canHandle(message: any) {
     if (message.event !== undefined || message.arg === undefined) {
@@ -235,7 +362,7 @@ export class OkexV5BookTickerMapper implements Mapper<OKEX_EXCHANGES, BookTicker
   }
 }
 
-export class OkexV5DerivativeTickerMapper implements Mapper<'okex-futures' | 'okex-swap', DerivativeTicker> {
+class OkexV5DerivativeTickerMapper implements Mapper<'okex-futures' | 'okex-swap', DerivativeTicker> {
   private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
   private readonly _indexPrices = new Map<string, number>()
 
@@ -366,7 +493,7 @@ export class OkexV5DerivativeTickerMapper implements Mapper<'okex-futures' | 'ok
   }
 }
 
-export class OkexV5LiquidationsMapper implements Mapper<OKEX_EXCHANGES, Liquidation> {
+class OkexV5LiquidationsMapper implements Mapper<OKEX_EXCHANGES, Liquidation> {
   private _isFirstMessage = true
   constructor(private readonly _exchange: Exchange) {}
 
@@ -437,7 +564,7 @@ export class OkexV5LiquidationsMapper implements Mapper<OKEX_EXCHANGES, Liquidat
   }
 }
 
-export class OkexV5OptionSummaryMapper implements Mapper<'okex-options', OptionSummary> {
+class OkexV5OptionSummaryMapper implements Mapper<'okex-options', OptionSummary> {
   private readonly _indexPrices = new Map<string, number>()
   private readonly _openInterests = new Map<string, number>()
   private readonly _markPrices = new Map<string, number>()
@@ -461,18 +588,15 @@ export class OkexV5OptionSummaryMapper implements Mapper<'okex-options', OptionS
   getFilters(symbols?: string[]) {
     symbols = upperCaseSymbols(symbols)
 
-    const indexes =
-      symbols !== undefined
-        ? symbols.map((s) => {
-            const symbolParts = s.split('-')
-            return `${symbolParts[0]}-${symbolParts[1]}`
-          })
-        : undefined
+    const indexes = symbols !== undefined ? [...new Set(symbols.map((s) => getOkexOptionsUnderlyingIndex(s)))] : undefined
+
+    const optionSummaryInstrumentFamilies =
+      symbols !== undefined ? [...new Set(symbols.map((s) => getOkexOptionsFamilyOrIndex(s)))] : undefined
 
     return [
       {
         channel: `opt-summary`,
-        symbols: [] as string[]
+        symbols: optionSummaryInstrumentFamilies
       } as const,
       {
         channel: `index-tickers`,
@@ -734,11 +858,15 @@ type OkexV5SummaryMessage = {
 //V3 Okex API mappers
 // https://www.okex.com/docs/en/#ws_swap-README
 
-export class OkexTradesMapper implements Mapper<OKEX_EXCHANGES, Trade> {
+class OkexTradesMapper implements Mapper<OKEX_EXCHANGES, Trade> {
+  private readonly _market: OKEX_MARKETS
+
   constructor(
     private readonly _exchange: Exchange,
-    private readonly _market: OKEX_MARKETS
-  ) {}
+    { market }: { market: OKEX_MARKETS }
+  ) {
+    this._market = market
+  }
 
   canHandle(message: OkexDataMessage) {
     return message.table === `${this._market}/trade`
@@ -781,12 +909,17 @@ const mapBookLevel = (level: OkexBookLevel) => {
   return { price, amount }
 }
 
-export class OkexBookChangeMapper implements Mapper<OKEX_EXCHANGES, BookChange> {
+class OkexBookChangeMapper implements Mapper<OKEX_EXCHANGES, BookChange> {
+  private readonly _canUseTickByTickChannel: boolean
+  private readonly _market: OKEX_MARKETS
+
   constructor(
     private readonly _exchange: Exchange,
-    private readonly _market: OKEX_MARKETS,
-    private readonly _canUseTickByTickChannel: boolean
-  ) {}
+    { market, useTickByTickChannel }: { market: OKEX_MARKETS; useTickByTickChannel: boolean }
+  ) {
+    this._market = market
+    this._canUseTickByTickChannel = useTickByTickChannel
+  }
 
   canHandle(message: OkexDataMessage) {
     const channelSuffix = this._canUseTickByTickChannel ? 'depth_l2_tbt' : 'depth'
@@ -847,7 +980,7 @@ export class OkexBookChangeMapper implements Mapper<OKEX_EXCHANGES, BookChange>
   }
 }
 
-export class OkexDerivativeTickerMapper implements Mapper<'okex-futures' | 'okex-swap', DerivativeTicker> {
+class OkexDerivativeTickerMapper implements Mapper<'okex-futures' | 'okex-swap', DerivativeTicker> {
   private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
   private _futuresChannels = ['futures/ticker', 'futures/mark_price']
   private _swapChannels = ['swap/ticker', 'swap/mark_price', 'swap/funding_rate']
@@ -910,7 +1043,7 @@ export class OkexDerivativeTickerMapper implements Mapper<'okex-futures' | 'okex
   }
 }
 
-export class OkexOptionSummaryMapper implements Mapper<'okex-options', OptionSummary> {
+class OkexOptionSummaryMapper implements Mapper<'okex-options', OptionSummary> {
   private readonly _indexPrices = new Map<string, number>()
   private readonly expiration_regex = /(\d{2})(\d{2})(\d{2})/
 
@@ -1002,11 +1135,15 @@ export class OkexOptionSummaryMapper implements Mapper<'okex-options', OptionSum
   }
 }
 
-export class OkexLiquidationsMapper implements Mapper<OKEX_EXCHANGES, Liquidation> {
+class OkexLiquidationsMapper implements Mapper<OKEX_EXCHANGES, Liquidation> {
+  private readonly _market: OKEX_MARKETS
+
   constructor(
     private readonly _exchange: Exchange,
-    private readonly _market: OKEX_MARKETS
-  ) {}
+    { market }: { market: OKEX_MARKETS }
+  ) {
+    this._market = market
+  }
 
   canHandle(message: OkexDataMessage) {
     return message.table === `${this._market}/liquidation`
@@ -1041,11 +1178,15 @@ export class OkexLiquidationsMapper implements Mapper<OKEX_EXCHANGES, Liquidatio
   }
 }
 
-export class OkexBookTickerMapper implements Mapper<OKEX_EXCHANGES, BookTicker> {
+class OkexBookTickerMapper implements Mapper<OKEX_EXCHANGES, BookTicker> {
+  private readonly _market: OKEX_MARKETS
+
   constructor(
     private readonly _exchange: Exchange,
-    private readonly _market: OKEX_MARKETS
-  ) {}
+    { market }: { market: OKEX_MARKETS }
+  ) {
+    this._market = market
+  }
 
   canHandle(message: OkexDataMessage) {
     return message.table === `${this._market}/ticker`