tardis-dev 16.5.0 → 16.6.0

package/src/realtimefeeds/mexc.ts

@@ -0,0 +1,327 @@
+import protobuf from 'protobufjs'
+import { CircularBuffer, getJSON, wait } from '../handy.ts'
+import type { MexcDepthSnapshotMessage } from '../mappers/mexc.ts'
+import { Filter } from '../types.ts'
+import { RealTimeFeedBase } from './realtimefeed.ts'
+
+export class MexcRealTimeFeed extends RealTimeFeedBase {
+  private static readonly depthChannel = 'spot@public.aggre.depth.v3.api.pb@10ms'
+  private static readonly depthSnapshotChannel = 'spot@public.aggre.depth.snapshot.v3.api.pb@10ms'
+  private static readonly jsonObjectStart = '{'.charCodeAt(0)
+  private static pushDataV3ApiWrapper: protobuf.Type | undefined
+  /**
+   * MEXC protobuf docs at @see https://www.mexc.com/api-docs/spot-v3/websocket-market-streams/protocol-buffers-integration
+   * and schemas from @see https://github.com/mexcdevelop/websocket-proto, mirrored in tardis-recorder/datafeeds/src/mexc/proto.
+   */
+  private static readonly pushDataV3ApiWrapperSchema = `
+    syntax = "proto3";
+
+    message PushDataV3ApiWrapper {
+      string channel = 1;
+      oneof body {
+        PublicAggreDepthsV3Api publicAggreDepths = 313;
+        PublicAggreDealsV3Api publicAggreDeals = 314;
+        PublicAggreBookTickerV3Api publicAggreBookTicker = 315;
+      }
+
+      optional string symbol = 3;
+      optional string symbolId = 4;
+      optional int64 createTime = 5;
+      optional int64 sendTime = 6;
+    }
+
+    message PublicAggreDealsV3Api {
+      repeated PublicAggreDealsV3ApiItem deals = 1;
+      string eventType = 2;
+    }
+
+    message PublicAggreDealsV3ApiItem {
+      string price = 1;
+      string quantity = 2;
+      int32 tradeType = 3;
+      int64 time = 4;
+      string tradeId = 5;
+    }
+
+    message PublicAggreDepthsV3Api {
+      repeated PublicAggreDepthV3ApiItem asks = 1;
+      repeated PublicAggreDepthV3ApiItem bids = 2;
+      string eventType = 3;
+      string fromVersion = 4;
+      string toVersion = 5;
+      int64 lastOrderCreateTime = 6;
+    }
+
+    message PublicAggreDepthV3ApiItem {
+      string price = 1;
+      string quantity = 2;
+    }
+
+    message PublicAggreBookTickerV3Api {
+      string bidPrice = 1;
+      string bidQuantity = 2;
+      string askPrice = 3;
+      string askQuantity = 4;
+      string version = 5;
+      int64 lastOrderCreateTime = 6;
+    }
+  `
+
+  private readonly pendingDepthSnapshotSymbols = new Set<string>()
+  private readonly bufferedDepthUpdates = new Map<string, CircularBuffer<MexcDepthUpdateData>>()
+  protected readonly wssURL = 'wss://wbs-api.mexc.com/ws'
+  protected readonly httpURL: string = 'https://api.mexc.com'
+  private readonly channels = new Set([
+    'spot@public.aggre.deals.v3.api.pb@10ms',
+    MexcRealTimeFeed.depthChannel,
+    MexcRealTimeFeed.depthSnapshotChannel,
+    'spot@public.aggre.bookTicker.v3.api.pb@10ms'
+  ])
+
+  protected override mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    const filtersWithSymbols = filters.map<Required<Filter<string>>>((filter) => {
+      if (!this.channels.has(filter.channel)) {
+        throw new Error(`MexcRealTimeFeed unsupported channel ${filter.channel}`)
+      }
+
+      if (!filter.symbols || filter.symbols.length === 0) {
+        throw new Error('MexcRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+      }
+
+      return filter as Required<Filter<string>>
+    })
+
+    const depthSnapshotFilters = filtersWithSymbols.filter((filter) => filter.channel === MexcRealTimeFeed.depthSnapshotChannel)
+    this.validateDepthSnapshotFilters(filtersWithSymbols, depthSnapshotFilters)
+    this.resetDepthSnapshotTracking(depthSnapshotFilters)
+
+    return [
+      {
+        method: 'SUBSCRIPTION',
+        params: filtersWithSymbols.flatMap((filter) =>
+          filter.channel === MexcRealTimeFeed.depthSnapshotChannel
+            ? []
+            : filter.symbols.map((symbol) => `${filter.channel}@${symbol.toUpperCase()}`)
+        )
+      }
+    ]
+  }
+
+  protected override parseMessage(message: Buffer<ArrayBufferLike>): any {
+    const buffer = Buffer.isBuffer(message) ? message : Buffer.from(message)
+
+    if (buffer.length > 0 && buffer[0] === MexcRealTimeFeed.jsonObjectStart) {
+      return JSON.parse(buffer.toString())
+    }
+
+    const pushDataV3ApiWrapper = this.getPushDataV3ApiWrapper()
+    return pushDataV3ApiWrapper.toObject(pushDataV3ApiWrapper.decode(buffer), {
+      longs: String,
+      arrays: true
+    })
+  }
+
+  protected override messageIsError(message: any): boolean {
+    return message.code !== undefined && message.code !== 0
+  }
+
+  protected override messageIsHeartbeat(message: any) {
+    return message.msg === 'PONG'
+  }
+
+  protected override onMessage(message: any) {
+    if (
+      message.channel?.startsWith(MexcRealTimeFeed.depthChannel) !== true ||
+      message.symbol === undefined ||
+      this.pendingDepthSnapshotSymbols.has(message.symbol) === false
+    ) {
+      return
+    }
+
+    const firstVersion = Number(message.publicAggreDepths?.fromVersion)
+    const lastVersion = Number(message.publicAggreDepths?.toVersion)
+    if (Number.isFinite(firstVersion) === false || Number.isFinite(lastVersion) === false) {
+      return
+    }
+
+    const bufferedUpdates = this.bufferedDepthUpdates.get(message.symbol) ?? new CircularBuffer<MexcDepthUpdateData>(2000)
+    bufferedUpdates.append({ firstVersion, lastVersion })
+    this.bufferedDepthUpdates.set(message.symbol, bufferedUpdates)
+  }
+
+  protected override async provideManualSnapshots(filters: Filter<string>[], shouldCancel: () => boolean) {
+    const depthFilter = filters.find((filter) => filter.channel === MexcRealTimeFeed.depthSnapshotChannel)
+    if (depthFilter === undefined) {
+      return
+    }
+
+    this.debug('requesting manual snapshots for: %s', depthFilter.symbols!)
+
+    for (const symbol of depthFilter.symbols!) {
+      await this.provideManualSnapshot(symbol.toUpperCase(), shouldCancel)
+    }
+
+    this.debug('requested manual snapshots successfully for: %s ', depthFilter.symbols!)
+  }
+
+  protected sendCustomPing = () => {
+    this.send({ method: 'PING' })
+  }
+
+  private getPushDataV3ApiWrapper() {
+    MexcRealTimeFeed.pushDataV3ApiWrapper ??= protobuf
+      .parse(MexcRealTimeFeed.pushDataV3ApiWrapperSchema)
+      .root.lookupType('PushDataV3ApiWrapper')
+
+    return MexcRealTimeFeed.pushDataV3ApiWrapper
+  }
+
+  private resetDepthSnapshotTracking(filters: Required<Filter<string>>[]) {
+    this.pendingDepthSnapshotSymbols.clear()
+    this.bufferedDepthUpdates.clear()
+
+    for (const filter of filters) {
+      for (const symbol of filter.symbols) {
+        const upperCaseSymbol = symbol.toUpperCase()
+        this.pendingDepthSnapshotSymbols.add(upperCaseSymbol)
+        this.bufferedDepthUpdates.set(upperCaseSymbol, new CircularBuffer<MexcDepthUpdateData>(2000))
+      }
+    }
+  }
+
+  private validateDepthSnapshotFilters(filters: Required<Filter<string>>[], depthSnapshotFilters: Required<Filter<string>>[]) {
+    if (depthSnapshotFilters.length === 0) {
+      return
+    }
+
+    const depthSymbols = new Set(
+      filters
+        .filter((filter) => filter.channel === MexcRealTimeFeed.depthChannel)
+        .flatMap((filter) => filter.symbols.map((symbol) => symbol.toUpperCase()))
+    )
+
+    for (const filter of depthSnapshotFilters) {
+      for (const symbol of filter.symbols) {
+        if (depthSymbols.has(symbol.toUpperCase()) === false) {
+          throw new Error(
+            `MexcRealTimeFeed requires ${MexcRealTimeFeed.depthChannel} for every ${MexcRealTimeFeed.depthSnapshotChannel} symbol`
+          )
+        }
+      }
+    }
+  }
+
+  private async provideManualSnapshot(symbol: string, shouldCancel: () => boolean) {
+    const maxSnapshotRounds = 4
+    const maxSnapshotAttemptsPerRound = 3
+
+    for (let round = 0; round < maxSnapshotRounds; round++) {
+      for (let attempt = 1; attempt <= maxSnapshotAttemptsPerRound; attempt++) {
+        if (shouldCancel()) {
+          return
+        }
+
+        const { data } = await getJSON<MexcDepthSnapshotResponse>(`${this.httpURL}/api/v3/depth?symbol=${symbol}&limit=5000`)
+        if (this.snapshotResponseIsValid(data) === false) {
+          if (attempt < maxSnapshotAttemptsPerRound) {
+            await wait(attempt * 1000)
+          }
+          continue
+        }
+
+        const hasOverlap = await this.waitForSnapshotOverlap(symbol, data.lastUpdateId)
+
+        if (shouldCancel()) {
+          return
+        }
+
+        if (hasOverlap === false) {
+          this.trimBufferedUpdates(symbol)
+          if (attempt < maxSnapshotAttemptsPerRound) {
+            await wait(attempt * 1000)
+          }
+          continue
+        }
+
+        if (hasOverlap === true || attempt === maxSnapshotAttemptsPerRound) {
+          this.manualSnapshotsBuffer.push(this.createManualSnapshot(symbol, data))
+          this.pendingDepthSnapshotSymbols.delete(symbol)
+          this.bufferedDepthUpdates.delete(symbol)
+          return
+        }
+      }
+    }
+
+    throw new Error(`MexcRealTimeFeed could not align depth snapshot for ${symbol}`)
+  }
+
+  private async waitForSnapshotOverlap(symbol: string, lastUpdateId: number) {
+    let hasOverlap = this.validateSnapshotOverlap(symbol, lastUpdateId)
+    for (let attempt = 0; attempt < 60; attempt++) {
+      if (hasOverlap !== undefined) {
+        return hasOverlap
+      }
+
+      await wait(100)
+      hasOverlap = this.validateSnapshotOverlap(symbol, lastUpdateId)
+    }
+
+    return hasOverlap
+  }
+
+  private validateSnapshotOverlap(symbol: string, lastUpdateId: number) {
+    const bufferedUpdates = this.bufferedDepthUpdates.get(symbol)
+    for (const update of bufferedUpdates?.items() ?? []) {
+      if (update.lastVersion <= lastUpdateId) {
+        continue
+      }
+
+      return update.firstVersion <= lastUpdateId + 1 && update.lastVersion >= lastUpdateId + 1
+    }
+
+    return undefined
+  }
+
+  private trimBufferedUpdates(symbol: string) {
+    const bufferedUpdates = this.bufferedDepthUpdates.get(symbol)
+    if (bufferedUpdates === undefined || bufferedUpdates.count <= 100) {
+      return
+    }
+
+    const trimmed = new CircularBuffer<MexcDepthUpdateData>(2000)
+    for (const update of [...bufferedUpdates.items()].slice(-100)) {
+      trimmed.append(update)
+    }
+    this.bufferedDepthUpdates.set(symbol, trimmed)
+  }
+
+  private snapshotResponseIsValid(data: MexcDepthSnapshotResponse) {
+    return Number.isFinite(data.lastUpdateId) && Array.isArray(data.asks) && Array.isArray(data.bids)
+  }
+
+  private createManualSnapshot(symbol: string, data: MexcDepthSnapshotResponse): MexcDepthSnapshotMessage {
+    return {
+      channel: `${MexcRealTimeFeed.depthSnapshotChannel}@${symbol}`,
+      symbol,
+      generated: true,
+      publicAggreDepthsSnapshot: {
+        lastUpdateId: data.lastUpdateId,
+        asks: data.asks,
+        bids: data.bids,
+        timestamp: data.timestamp
+      }
+    }
+  }
+}
+
+type MexcDepthSnapshotResponse = {
+  lastUpdateId: number
+  bids: [string, string][]
+  asks: [string, string][]
+  timestamp: number
+}
+
+type MexcDepthUpdateData = {
+  firstVersion: number
+  lastVersion: number
+}

package/src/realtimefeeds/mexcfutures.ts

@@ -0,0 +1,269 @@
+import { CircularBuffer, getJSON, wait } from '../handy.ts'
+import type { MexcFuturesDepthSnapshotData, MexcFuturesDepthSnapshotMessage } from '../mappers/mexcfutures.ts'
+import { Filter } from '../types.ts'
+import { RealTimeFeedBase } from './realtimefeed.ts'
+
+export class MexcFuturesRealTimeFeed extends RealTimeFeedBase {
+  private readonly pendingDepthSnapshotSymbols = new Set<string>()
+  private readonly bufferedDepthUpdates = new Map<string, CircularBuffer<MexcFuturesDepthUpdateData>>()
+  protected readonly wssURL = 'wss://contract.mexc.com'
+  protected readonly httpURL: string = 'https://contract.mexc.com'
+  protected readonly channelToSubscriptionMethod = new Map([
+    ['push.deal', 'sub.deal'],
+    ['push.depth', 'sub.depth'],
+    ['push.ticker', 'sub.ticker'],
+    ['push.index.price', 'sub.index.price'],
+    ['push.fair.price', 'sub.fair.price'],
+    ['push.funding.rate', 'sub.funding.rate'],
+    ['push.contract', 'sub.contract']
+  ])
+
+  protected override sendCustomPing = () => {
+    this.send({ method: 'ping' })
+  }
+
+  protected override async getWebSocketUrl() {
+    return 'wss://contract.mexc.com/edge'
+  }
+
+  protected override mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    const filtersWithSymbols = filters.map<Required<Filter<string>>>((filter) => {
+      if (filter.channel === 'push.contract') {
+        return { ...filter, symbols: [] }
+      }
+
+      if (filter.channel !== 'push.depth.snapshot' && this.channelToSubscriptionMethod.has(filter.channel) === false) {
+        throw new Error(`Unsupported MEXC futures channel ${filter.channel}`)
+      }
+
+      if (!filter.symbols || filter.symbols.length === 0) {
+        throw new Error('MexcFuturesRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+      }
+
+      return filter as Required<Filter<string>>
+    })
+
+    const depthSnapshotFilters = filtersWithSymbols.filter((filter) => filter.channel === 'push.depth.snapshot')
+    this.validateDepthSnapshotFilters(filtersWithSymbols, depthSnapshotFilters)
+    this.resetDepthSnapshotTracking(depthSnapshotFilters)
+
+    return filtersWithSymbols.flatMap((filter) => {
+      if (filter.channel === 'push.depth.snapshot') {
+        return []
+      }
+
+      if (filter.channel === 'push.contract') {
+        return [{ method: this.channelToSubscriptionMethod.get(filter.channel) }]
+      }
+
+      return filter.symbols.map((symbol) => ({
+        method: this.channelToSubscriptionMethod.get(filter.channel),
+        param: { symbol },
+        gzip: false
+      }))
+    })
+  }
+
+  private resetDepthSnapshotTracking(filters: Required<Filter<string>>[]) {
+    this.pendingDepthSnapshotSymbols.clear()
+    this.bufferedDepthUpdates.clear()
+
+    for (const filter of filters) {
+      for (const symbol of filter.symbols) {
+        const upperCaseSymbol = symbol.toUpperCase()
+        this.pendingDepthSnapshotSymbols.add(upperCaseSymbol)
+        this.bufferedDepthUpdates.set(upperCaseSymbol, new CircularBuffer<MexcFuturesDepthUpdateData>(2000))
+      }
+    }
+  }
+
+  private validateDepthSnapshotFilters(filters: Required<Filter<string>>[], depthSnapshotFilters: Required<Filter<string>>[]) {
+    if (depthSnapshotFilters.length === 0) {
+      return
+    }
+
+    const depthSymbols = new Set(
+      filters.filter((filter) => filter.channel === 'push.depth').flatMap((filter) => filter.symbols.map((symbol) => symbol.toUpperCase()))
+    )
+
+    for (const filter of depthSnapshotFilters) {
+      for (const symbol of filter.symbols) {
+        if (depthSymbols.has(symbol.toUpperCase()) === false) {
+          throw new Error('MexcFuturesRealTimeFeed requires push.depth for every push.depth.snapshot symbol')
+        }
+      }
+    }
+  }
+
+  protected override onMessage(message: any) {
+    if (
+      message.channel !== 'push.depth' ||
+      message.symbol === undefined ||
+      this.pendingDepthSnapshotSymbols.has(message.symbol) === false
+    ) {
+      return
+    }
+
+    const firstVersion = Number(
+      message.data?.begin !== undefined && message.data.begin !== null && message.data.begin !== 0
+        ? message.data.begin
+        : message.data?.version
+    )
+    const lastVersion = Number(
+      message.data?.end !== undefined && message.data.end !== null && message.data.end !== 0 ? message.data.end : message.data?.version
+    )
+    if (Number.isFinite(firstVersion) === false || Number.isFinite(lastVersion) === false) {
+      return
+    }
+
+    const bufferedUpdates = this.bufferedDepthUpdates.get(message.symbol) ?? new CircularBuffer<MexcFuturesDepthUpdateData>(2000)
+    bufferedUpdates.append({ firstVersion, lastVersion })
+    this.bufferedDepthUpdates.set(message.symbol, bufferedUpdates)
+  }
+
+  protected override async provideManualSnapshots(filters: Filter<string>[], shouldCancel: () => boolean) {
+    const depthFilter = filters.find((filter) => filter.channel === 'push.depth.snapshot')
+    if (depthFilter === undefined) {
+      return
+    }
+
+    this.debug('requesting manual snapshots for: %s', depthFilter.symbols!)
+
+    for (const symbol of depthFilter.symbols!) {
+      await this.provideManualSnapshot(symbol.toUpperCase(), shouldCancel)
+    }
+
+    this.debug('requested manual snapshots successfully for: %s ', depthFilter.symbols!)
+  }
+
+  protected override messageIsError(message: any): boolean {
+    return message.channel === 'rs.error' || message.success === false || message.error !== undefined
+  }
+
+  protected override messageIsHeartbeat(message: any) {
+    return message.channel === 'pong'
+  }
+
+  private async provideManualSnapshot(symbol: string, shouldCancel: () => boolean) {
+    const maxSnapshotRounds = 4
+    const maxSnapshotAttemptsPerRound = 3
+
+    for (let round = 0; round < maxSnapshotRounds; round++) {
+      for (let attempt = 1; attempt <= maxSnapshotAttemptsPerRound; attempt++) {
+        if (shouldCancel()) {
+          return
+        }
+
+        const { data } = await getJSON<MexcFuturesDepthSnapshotResponse>(`${this.httpURL}/api/v1/contract/depth/${symbol}?limit=5000`)
+        if (this.snapshotResponseIsValid(data) === false) {
+          if (attempt < maxSnapshotAttemptsPerRound) {
+            await wait(attempt * 1000)
+          }
+          continue
+        }
+
+        const hasOverlap = await this.waitForSnapshotOverlap(symbol, data.data.version)
+
+        if (shouldCancel()) {
+          return
+        }
+
+        if (hasOverlap === false) {
+          this.trimBufferedUpdates(symbol)
+          if (attempt < maxSnapshotAttemptsPerRound) {
+            await wait(attempt * 1000)
+          }
+          continue
+        }
+
+        if (hasOverlap === true || attempt === maxSnapshotAttemptsPerRound) {
+          this.manualSnapshotsBuffer.push(this.createManualSnapshot(symbol, data.data))
+          this.pendingDepthSnapshotSymbols.delete(symbol)
+          this.bufferedDepthUpdates.delete(symbol)
+          return
+        }
+      }
+    }
+
+    throw new Error(`MexcFuturesRealTimeFeed could not align depth snapshot for ${symbol}`)
+  }
+
+  private async waitForSnapshotOverlap(symbol: string, snapshotVersion: number) {
+    let hasOverlap = this.validateSnapshotOverlap(symbol, snapshotVersion)
+    for (let attempt = 0; attempt < 60; attempt++) {
+      if (hasOverlap !== undefined) {
+        return hasOverlap
+      }
+
+      await wait(100)
+      hasOverlap = this.validateSnapshotOverlap(symbol, snapshotVersion)
+    }
+
+    return hasOverlap
+  }
+
+  private validateSnapshotOverlap(symbol: string, snapshotVersion: number) {
+    const bufferedUpdates = this.bufferedDepthUpdates.get(symbol)
+    for (const update of bufferedUpdates?.items() ?? []) {
+      if (update.lastVersion <= snapshotVersion) {
+        continue
+      }
+
+      return update.firstVersion <= snapshotVersion + 1 && update.lastVersion >= snapshotVersion + 1
+    }
+
+    return undefined
+  }
+
+  private trimBufferedUpdates(symbol: string) {
+    const bufferedUpdates = this.bufferedDepthUpdates.get(symbol)
+    if (bufferedUpdates === undefined || bufferedUpdates.count <= 100) {
+      return
+    }
+
+    const trimmed = new CircularBuffer<MexcFuturesDepthUpdateData>(2000)
+    for (const update of [...bufferedUpdates.items()].slice(-100)) {
+      trimmed.append(update)
+    }
+    this.bufferedDepthUpdates.set(symbol, trimmed)
+  }
+
+  private snapshotResponseIsValid(response: MexcFuturesDepthSnapshotResponse) {
+    return (
+      response.success === true &&
+      response.code === 0 &&
+      response.data !== undefined &&
+      Number.isFinite(response.data.version) &&
+      response.data.version >= 0 &&
+      Array.isArray(response.data.asks) &&
+      Array.isArray(response.data.bids)
+    )
+  }
+
+  private createManualSnapshot(symbol: string, data: MexcFuturesDepthSnapshotData): MexcFuturesDepthSnapshotMessage {
+    return {
+      channel: 'push.depth.snapshot',
+      symbol,
+      generated: true,
+      data: {
+        cts: data.cts,
+        asks: data.asks,
+        bids: data.bids,
+        timestamp: data.timestamp,
+        version: data.version
+      }
+    }
+  }
+}
+
+type MexcFuturesDepthSnapshotResponse = {
+  success: boolean
+  code: number
+  message?: string
+  data: MexcFuturesDepthSnapshotData
+}
+
+type MexcFuturesDepthUpdateData = {
+  firstVersion: number
+  lastVersion: number
+}

package/src/realtimefeeds/okex.ts

@@ -1,5 +1,6 @@
 import crypto from 'crypto'
 import { wait } from '../handy.ts'
+import { getOkexOptionsFamilyOrIndex, getOkexOptionsUnderlyingIndex } from '../okexsymbols.ts'
 import { Filter } from '../types.ts'
 import { MultiConnectionRealTimeFeedBase, RealTimeFeedBase } from './realtimefeed.ts'
 
@@ -140,7 +141,8 @@ class OkexOptionsSingleRealTimeFeed extends OkexSingleRealTimeFeed {
     super(wssURL, exchange, filters, timeoutIntervalMS, onError)
   }
 
-  private _defaultIndexes = ['BTC-USD', 'ETH-USD']
+  private _defaultIndexes = ['BTC-USD', 'ETH-USD', 'SOL-USD']
+  private _defaultOptionSummaryInstrumentFamilies = ['BTC-USD', 'BTC-USD_UM', 'ETH-USD', 'ETH-USD_UM', 'SOL-USD_UM']
 
   private _channelRequiresIndexNotSymbol(channel: string) {
     if (channel === 'index-tickers' || channel === 'opt-summary') {
@@ -155,7 +157,7 @@ class OkexOptionsSingleRealTimeFeed extends OkexSingleRealTimeFeed {
         const channelRequiresIndexNotSymbol = this._channelRequiresIndexNotSymbol(filter.channel)
 
         if (symbols.length === 0 && channelRequiresIndexNotSymbol) {
-          symbols = this._defaultIndexes
+          symbols = filter.channel === 'opt-summary' ? this._defaultOptionSummaryInstrumentFamilies : this._defaultIndexes
         }
 
         if (symbols.length === 0) {
@@ -165,8 +167,7 @@ class OkexOptionsSingleRealTimeFeed extends OkexSingleRealTimeFeed {
         return symbols.map((symbol) => {
           let finalSymbol = symbol
           if (channelRequiresIndexNotSymbol) {
-            const symbolParts = symbol.split('-')
-            finalSymbol = `${symbolParts[0]}-${symbolParts[1]}`
+            finalSymbol = filter.channel === 'opt-summary' ? getOkexOptionsFamilyOrIndex(symbol) : getOkexOptionsUnderlyingIndex(symbol)
           }
           return {
             channel: filter.channel,
@@ -176,11 +177,12 @@ class OkexOptionsSingleRealTimeFeed extends OkexSingleRealTimeFeed {
         })
       })
       .flatMap((s) => s)
+    const uniqueArgs = [...new Map(args.map((arg) => [`${arg.channel}:${arg.instId ?? ''}:${arg.instFamily ?? ''}`, arg])).values()]
 
     return [
       {
         op: 'subscribe',
-        args: [...new Set(args)]
+        args: uniqueArgs
       }
     ]
   }

package/src/realtimefeeds/realtimefeed.ts

@@ -117,7 +117,7 @@ export abstract class RealTimeFeedBase implements RealTimeFeedIterable {
             message = message.toString().replace(/"id":([0-9]+),/g, '"id":"$1",') as any
           }
 
-          const messageDeserialized = JSON.parse(message as any)
+          const messageDeserialized = this.parseMessage(message)
 
           if (this.messageIsError(messageDeserialized)) {
             if (this.isIgnoredError(messageDeserialized)) {
@@ -233,6 +233,10 @@ export abstract class RealTimeFeedBase implements RealTimeFeedIterable {
 
   protected abstract messageIsError(message: any): boolean
 
+  protected parseMessage(message: Buffer<ArrayBufferLike>): any {
+    return JSON.parse(message as any)
+  }
+
   protected sendCustomPing: (() => void) | undefined = undefined
 
   protected isIgnoredError(_message: any) {