tardis-dev 16.6.0 → 16.6.2

package/src/mappers/woox.ts

@@ -1,14 +1,27 @@
-import { upperCaseSymbols } from '../handy.ts'
-import { BookChange, BookTicker, DerivativeTicker, Exchange, FilterForExchange, Liquidation, Trade } from '../types.ts'
+import { asNumberOrUndefined, upperCaseSymbols } from '../handy.ts'
+import { BookChange, BookTicker, DerivativeTicker, Trade } from '../types.ts'
 import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
-import { exchangeMappers } from './registry.ts'
+import { exchangeMappers, mapper } from './registry.ts'
 
+const WOOX_V3_SWITCH_DATE = new Date('2026-06-29T22:02:00.000Z')
+
+// WOO X kept Tardis channel names during the V3 rollout, but changed raw topic layout and payload fields.
+// Keep old and V3 mappers separate so replay uses the schema that was actually recorded at the message time.
 export const wooxMappers = exchangeMappers({
   'woo-x': {
-    trades: () => wooxTradesMapper,
-    bookChanges: () => new WooxBookChangeMapper(),
-    derivativeTickers: () => new WooxDerivativeTickerMapper(),
-    bookTickers: () => new WooxBookTickerMapper()
+    trades: mapper([{ until: WOOX_V3_SWITCH_DATE, use: () => wooxTradesMapper }, { use: () => wooxV3TradesMapper }]),
+    bookChanges: mapper([
+      { until: WOOX_V3_SWITCH_DATE, use: () => new WooxBookChangeMapper() },
+      { use: () => new WooxV3BookChangeMapper() }
+    ]),
+    derivativeTickers: mapper([
+      { until: WOOX_V3_SWITCH_DATE, use: () => new WooxDerivativeTickerMapper() },
+      { use: () => new WooxV3DerivativeTickerMapper() }
+    ]),
+    bookTickers: mapper([
+      { until: WOOX_V3_SWITCH_DATE, use: () => new WooxBookTickerMapper() },
+      { use: () => new WooxV3BookTickerMapper() }
+    ])
   }
 })
 
@@ -49,6 +62,41 @@ const wooxTradesMapper: Mapper<'woo-x', Trade> = {
   }
 }
 
+const wooxV3TradesMapper: Mapper<'woo-x', Trade> = {
+  canHandle(message: WooxV3TradeMessage) {
+    return message.topic !== undefined && message.topic.startsWith('trade@')
+  },
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'trade',
+        symbols
+      }
+    ]
+  },
+
+  *map(message: WooxV3TradeMessage, localTimestamp: Date): IterableIterator<Trade> {
+    if (message.data.src === 0) {
+      return
+    }
+
+    yield {
+      type: 'trade',
+      symbol: message.data.s,
+      exchange: 'woo-x',
+      id: undefined,
+      price: Number(message.data.px),
+      amount: Number(message.data.sx),
+      side: message.data.sd === 'SELL' ? 'sell' : 'buy',
+      timestamp: new Date(message.data.ts),
+      localTimestamp
+    }
+  }
+}
+
 class WooxBookChangeMapper implements Mapper<'woo-x', BookChange> {
   private readonly _symbolToDepthInfoMapping: { [key: string]: LocalDepthInfo } = {}
 
@@ -159,6 +207,129 @@ class WooxBookChangeMapper implements Mapper<'woo-x', BookChange> {
   }
 }
 
+class WooxV3BookChangeMapper implements Mapper<'woo-x', BookChange> {
+  private readonly _symbolToDepthInfoMapping: { [key: string]: WooxV3LocalDepthInfo } = {}
+
+  canHandle(message: WooxV3OrderbookMessage | WooxV3OrderbookupdateMessage) {
+    if (message.topic === undefined) {
+      return false
+    }
+
+    if (message.topic.startsWith('orderbook@')) {
+      return 'generated' in message && message.generated === true
+    }
+
+    return message.topic.startsWith('orderbookupdate@')
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'orderbook',
+        symbols
+      },
+      {
+        channel: 'orderbookupdate',
+        symbols
+      }
+    ]
+  }
+
+  *map(message: WooxV3OrderbookMessage | WooxV3OrderbookupdateMessage, localTimestamp: Date): IterableIterator<BookChange> {
+    if ('generated' in message) {
+      const symbol = message.data.s ?? message.topic.split('@')[1]
+      const timestamp = message.data.ts ?? message.ts
+
+      if (this._symbolToDepthInfoMapping[symbol] === undefined) {
+        this._symbolToDepthInfoMapping[symbol] = {
+          bufferedUpdates: []
+        }
+      }
+
+      const symbolDepthInfo = this._symbolToDepthInfoMapping[symbol]
+
+      yield {
+        type: 'book_change',
+        symbol,
+        exchange: 'woo-x',
+        isSnapshot: true,
+        bids: message.data.bids.map(this._mapSnapshotLevel),
+        asks: message.data.asks.map(this._mapSnapshotLevel),
+        timestamp: new Date(timestamp),
+        localTimestamp
+      }
+
+      symbolDepthInfo.lastUpdateTimestamp = timestamp
+      symbolDepthInfo.snapshotProcessed = true
+
+      for (const update of symbolDepthInfo.bufferedUpdates) {
+        const bookChange = this._mapBookDepthUpdate(update, localTimestamp, symbolDepthInfo, symbol)
+        if (bookChange !== undefined) {
+          yield bookChange
+        }
+      }
+      symbolDepthInfo.bufferedUpdates = []
+      return
+    }
+
+    const symbol = message.data.s
+
+    if (this._symbolToDepthInfoMapping[symbol] === undefined) {
+      this._symbolToDepthInfoMapping[symbol] = {
+        bufferedUpdates: []
+      }
+    }
+
+    const symbolDepthInfo = this._symbolToDepthInfoMapping[symbol]
+    const snapshotAlreadyProcessed = symbolDepthInfo.snapshotProcessed
+
+    if (snapshotAlreadyProcessed) {
+      const bookChange = this._mapBookDepthUpdate(message, localTimestamp, symbolDepthInfo, symbol)
+      if (bookChange !== undefined) {
+        yield bookChange
+      }
+    } else {
+      symbolDepthInfo.bufferedUpdates.push(message)
+    }
+  }
+
+  private _mapBookDepthUpdate(
+    wooxBookUpdate: WooxV3OrderbookupdateMessage,
+    localTimestamp: Date,
+    depthInfo: WooxV3LocalDepthInfo,
+    symbol: string
+  ): BookChange | undefined {
+    if (wooxBookUpdate.data.prevTs < depthInfo.lastUpdateTimestamp!) {
+      return
+    }
+
+    return {
+      type: 'book_change',
+      symbol,
+      exchange: 'woo-x',
+      isSnapshot: false,
+      bids: wooxBookUpdate.data.bids.map(this._mapUpdateLevel),
+      asks: wooxBookUpdate.data.asks.map(this._mapUpdateLevel),
+      timestamp: new Date(wooxBookUpdate.data.ts),
+      localTimestamp
+    }
+  }
+
+  private _mapSnapshotLevel(level: WooxV3OrderbookSnapshotLevel): { price: number; amount: number } {
+    if (Array.isArray(level)) {
+      return { price: Number(level[0]), amount: Number(level[1]) }
+    }
+
+    return { price: Number(level.price), amount: Number(level.quantity) }
+  }
+
+  private _mapUpdateLevel(level: WooxV3BookLevel) {
+    return { price: Number(level[0]), amount: Number(level[1]) }
+  }
+}
+
 class WooxDerivativeTickerMapper implements Mapper<'woo-x', DerivativeTicker> {
   private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
   private readonly _indexPrices = new Map<string, number>()
@@ -246,6 +417,99 @@ class WooxDerivativeTickerMapper implements Mapper<'woo-x', DerivativeTicker> {
   }
 }
 
+class WooxV3DerivativeTickerMapper implements Mapper<'woo-x', DerivativeTicker> {
+  private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
+  private readonly _indexPrices = new Map<string, number>()
+
+  canHandle(message: WooxV3TradeMessage | WooxV3EstFundingRate | WooxV3MarkPrice | WooxV3IndexPrice | WooxV3OpenInterest) {
+    if (message.topic === undefined) {
+      return false
+    }
+    const symbol = (message.data && message.data.s) || ''
+    const isPerp = symbol.startsWith('PERP_')
+
+    return (
+      (message.topic.startsWith('trade@') && isPerp) ||
+      (message.topic.startsWith('markprice@') && isPerp) ||
+      (message.topic.startsWith('estfundingrate@') && isPerp) ||
+      message.topic.startsWith('indexprice@') ||
+      (message.topic.startsWith('openinterest@') && isPerp)
+    )
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+    const spotSymbols = symbols !== undefined ? symbols.map((s) => s.replace('PERP_', 'SPOT_')) : []
+
+    return [
+      {
+        channel: 'trade',
+        symbols
+      },
+      {
+        channel: 'markprice',
+        symbols
+      },
+      {
+        channel: 'estfundingrate',
+        symbols
+      },
+      {
+        channel: 'openinterest',
+        symbols
+      },
+      {
+        channel: 'indexprice',
+        symbols: spotSymbols
+      }
+    ]
+  }
+
+  *map(message: WooxV3TradeMessage | WooxV3EstFundingRate | WooxV3MarkPrice | WooxV3IndexPrice | WooxV3OpenInterest, localTimestamp: Date) {
+    if (message.topic.startsWith('indexprice@')) {
+      const data = message.data as WooxV3IndexPrice['data']
+      this._indexPrices.set(data.s.replace('SPOT_', 'PERP_'), Number(data.px))
+    } else {
+      const symbol = message.data.s
+      const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(symbol, 'woo-x')
+
+      const lastIndexPrice = this._indexPrices.get(symbol)
+      if (lastIndexPrice !== undefined) {
+        pendingTickerInfo.updateIndexPrice(lastIndexPrice)
+      }
+
+      if (message.topic.startsWith('markprice@')) {
+        const data = message.data as WooxV3MarkPrice['data']
+        pendingTickerInfo.updateMarkPrice(Number(data.px))
+        pendingTickerInfo.updateTimestamp(new Date(message.data.ts))
+      }
+
+      if (message.topic.startsWith('trade@')) {
+        const data = message.data as WooxV3TradeMessage['data']
+        pendingTickerInfo.updateLastPrice(Number(data.px))
+        pendingTickerInfo.updateTimestamp(new Date(message.data.ts))
+      }
+
+      if (message.topic.startsWith('estfundingrate@')) {
+        const data = message.data as WooxV3EstFundingRate['data']
+        pendingTickerInfo.updateFundingRate(Number(data.r))
+        pendingTickerInfo.updateFundingTimestamp(new Date(Number(data.ft)))
+        pendingTickerInfo.updateTimestamp(new Date(message.data.ts))
+      }
+
+      if (message.topic.startsWith('openinterest@')) {
+        const data = message.data as WooxV3OpenInterest['data']
+        pendingTickerInfo.updateOpenInterest(Number(data.oi))
+        pendingTickerInfo.updateTimestamp(new Date(message.data.ts))
+      }
+
+      if (pendingTickerInfo.hasChanged()) {
+        yield pendingTickerInfo.getSnapshot(localTimestamp)
+      }
+    }
+  }
+}
+
 class WooxBookTickerMapper implements Mapper<'woo-x', BookTicker> {
   canHandle(message: WooxTradeMessage) {
     return message.topic !== undefined && message.topic.endsWith('@bbo')
@@ -282,6 +546,42 @@ class WooxBookTickerMapper implements Mapper<'woo-x', BookTicker> {
   }
 }
 
+class WooxV3BookTickerMapper implements Mapper<'woo-x', BookTicker> {
+  canHandle(message: WooxV3BBOMessage) {
+    return message.topic !== undefined && message.topic.startsWith('bbo@')
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'bbo',
+        symbols
+      }
+    ]
+  }
+
+  *map(wooxBBOMessage: WooxV3BBOMessage, localTimestamp: Date) {
+    const wooxBookTicker = wooxBBOMessage.data
+
+    const ticker: BookTicker = {
+      type: 'book_ticker',
+      symbol: wooxBookTicker.s,
+      exchange: 'woo-x',
+      askAmount: asNumberOrUndefined(wooxBookTicker.aq),
+      askPrice: asNumberOrUndefined(wooxBookTicker.ap),
+
+      bidPrice: asNumberOrUndefined(wooxBookTicker.bp),
+      bidAmount: asNumberOrUndefined(wooxBookTicker.bq),
+      timestamp: new Date(wooxBookTicker.ts),
+      localTimestamp: localTimestamp
+    }
+
+    yield ticker
+  }
+}
+
 type LocalDepthInfo = {
   bufferedUpdates: WooxOrderbookupdateMessage[]
   snapshotProcessed?: boolean
@@ -294,6 +594,12 @@ type WooxTradeMessage = {
   data: { symbol: 'PERP_GALA_USDT'; price: 0.048756; size: 4109; side: 'SELL'; source: 0 }
 }
 
+type WooxV3TradeMessage = {
+  topic: string
+  ts: number
+  data: { s: string; px: string; sx: string; sd: 'BUY' | 'SELL'; src: number; ts: number }
+}
+
 type WooxOrderbookupdateMessage = {
   topic: 'PERP_BTC_USDT@orderbookupdate'
   ts: 1674432000020
@@ -318,19 +624,77 @@ type WooxOrderbookMessage = {
   }
 }
 
+type WooxV3LocalDepthInfo = {
+  bufferedUpdates: WooxV3OrderbookupdateMessage[]
+  snapshotProcessed?: boolean
+  lastUpdateTimestamp?: number
+}
+
+type WooxV3BookLevel = [string, string]
+
+type WooxV3OrderbookupdateMessage = {
+  topic: string
+  ts: number
+  data: {
+    s: string
+    prevTs: number
+    ts: number
+    asks: WooxV3BookLevel[]
+    bids: WooxV3BookLevel[]
+  }
+}
+
+type WooxV3OrderbookRestSnapshotLevel = {
+  price: string
+  quantity: string
+}
+
+type WooxV3OrderbookSnapshotLevel = WooxV3BookLevel | WooxV3OrderbookRestSnapshotLevel
+
+type WooxV3OrderbookMessage = {
+  topic: string
+  ts: number
+  generated: true
+  data: {
+    s?: string
+    ts?: number
+    asks: WooxV3OrderbookSnapshotLevel[]
+    bids: WooxV3OrderbookSnapshotLevel[]
+  }
+}
+
 type WooxBBOMessage = {
   topic: 'SPOT_ETH_USDT@bbo'
   ts: 1674431999996
   data: { symbol: 'SPOT_ETH_USDT'; ask: 1627.61; askSize: 38.3755; bid: 1627.26; bidSize: 20.424926 }
 }
 
+type WooxV3BBOMessage = {
+  topic: string
+  ts: number
+  data: { s: string; ts: number; ap?: string; aq?: string; bp?: string; bq?: string }
+}
+
 type WooxMarkPrice = { topic: 'PERP_BTC_USDT@markprice'; ts: 1674432000007; data: { symbol: 'PERP_BTC_USDT'; price: 22711.11 } }
 
+type WooxV3MarkPrice = { topic: string; ts: number; data: { s: string; ts: number; px: string } }
+
 type WooxEstFundingRate = {
   topic: 'PERP_BTC_USDT@estfundingrate'
   ts: 1674432059002
   data: { symbol: 'PERP_BTC_USDT'; fundingRate: 0.00000782; fundingTs: 1674435600005 }
 }
 
+type WooxV3EstFundingRate = {
+  topic: string
+  ts: number
+  data: { s: string; ts: number; r: string; ft: number | string }
+}
+
 type WooxIndexPrice = { topic: 'SPOT_BTC_USDT@indexprice'; ts: 1674432000024; data: { symbol: 'SPOT_BTC_USDT'; price: 22708.44 } }
+
+type WooxV3IndexPrice = { topic: string; ts: number; data: { s: string; ts: number; px: string } }
+
 type WooxOpenInterest = { topic: 'PERP_BTC_USDT@openinterest'; ts: 1674432013624; data: { symbol: 'PERP_BTC_USDT'; openInterest: 83.2241 } }
+
+type WooxV3OpenInterest = { topic: string; ts: number; data: { s: string; ts: number; oi: string } }

package/src/realtimefeeds/index.ts

@@ -35,7 +35,6 @@ import { GateIOFuturesRealTimeFeed } from './gateiofutures.ts'
 import { PoloniexRealTimeFeed } from './poloniex.ts'
 import { CoinflexRealTimeFeed } from './coinflex.ts'
 import { UpbitRealTimeFeed } from './upbit.ts'
-import { AscendexRealTimeFeed } from './ascendex.ts'
 import { DydxRealTimeFeed } from './dydx.ts'
 import { SerumRealTimeFeed } from './serum.ts'
 import { StarAtlasRealTimeFeed } from './staratlas.ts'
@@ -100,7 +99,6 @@ const realTimeFeedsMap: {
   poloniex: PoloniexRealTimeFeed,
   coinflex: CoinflexRealTimeFeed,
   upbit: UpbitRealTimeFeed,
-  ascendex: AscendexRealTimeFeed,
   dydx: DydxRealTimeFeed,
   serum: SerumRealTimeFeed,
   'star-atlas': StarAtlasRealTimeFeed,

package/src/realtimefeeds/kraken.ts

@@ -2,36 +2,47 @@ import { Filter } from '../types.ts'
 import { RealTimeFeedBase } from './realtimefeed.ts'
 
 export class KrakenRealTimeFeed extends RealTimeFeedBase {
-  protected wssURL = 'wss://ws.kraken.com'
+  private readonly channels = new Set(['trade', 'book', 'ticker', 'instrument'])
+  protected wssURL = 'wss://ws.kraken.com/v2'
 
   protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
-    return filters.map((filter) => {
-      if (!filter.symbols || filter.symbols.length === 0) {
+    return filters.flatMap(({ channel, symbols }): any[] => {
+      if (channel !== 'instrument' && (!symbols || symbols.length === 0)) {
         throw new Error('KrakenRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
       }
 
-      let depth = undefined
+      if (!this.channels.has(channel)) {
+        throw new Error(`KrakenRealTimeFeed unsupported channel ${channel}`)
+      }
 
-      if (filter.channel === 'book') {
-        depth = 1000
+      if (channel === 'instrument') {
+        return [
+          {
+            method: 'subscribe',
+            params: { channel, include_tokenized_assets: true }
+          }
+        ]
       }
 
-      return {
-        event: 'subscribe',
-        pair: filter.symbols,
-        subscription: {
-          name: filter.channel,
-          depth
+      return [
+        {
+          method: 'subscribe',
+          params: {
+            channel,
+            symbol: symbols,
+            ...(channel === 'ticker' ? { event_trigger: 'bbo' } : {}),
+            ...(channel === 'book' ? { depth: 1000 } : {})
+          }
         }
-      }
+      ]
     })
   }
 
   protected messageIsError(message: any): boolean {
-    return message.errorMessage !== undefined
+    return message.errorMessage !== undefined || message.success === false
   }
 
   protected messageIsHeartbeat(message: any): boolean {
-    return message.event === 'heartbeat'
+    return message.event === 'heartbeat' || message.channel === 'heartbeat'
   }
 }

package/src/realtimefeeds/woox.ts

@@ -1,63 +1,73 @@
-import { wait } from '../handy.ts'
+import { getJSON } from '../handy.ts'
 import { Filter } from '../types.ts'
 import { RealTimeFeedBase } from './realtimefeed.ts'
 
+const ORDER_BOOK_DEPTH = 50
+
 export class WooxRealTimeFeed extends RealTimeFeedBase {
-  protected wssURL = 'wss://wss.woo.org/ws/stream/OqdphuyCtYWxwzhxyLLjOWNdFP7sQt8RPWzmb5xY'
+  protected wssURL = 'wss://wss.woox.io/v3/public'
+  protected readonly httpURL = 'https://api.woox.io'
 
   protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
-    return filters
+    const symbolToTopics = new Map<string, string[]>()
+
+    filters
       .filter((filter) => filter.channel !== 'orderbook')
-      .map((filter) => {
+      .forEach((filter) => {
         if (!filter.symbols || filter.symbols.length === 0) {
           throw new Error('WooxRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
         }
 
-        return filter.symbols.map((symbol) => {
-          return {
-            id: `${symbol}@${filter.channel}`,
-            topic: `${symbol}@${filter.channel}`,
-            event: 'subscribe'
-          }
+        filter.symbols.forEach((symbol) => {
+          const topics = symbolToTopics.get(symbol) ?? []
+          topics.push(buildTopic(symbol, filter.channel))
+          symbolToTopics.set(symbol, topics)
         })
       })
-      .flatMap((f) => f)
+
+    return Array.from(symbolToTopics.entries()).map(([symbol, topics]) => ({
+      id: symbol,
+      cmd: 'subscribe',
+      params: topics
+    }))
   }
 
   protected async provideManualSnapshots(filters: Filter<string>[], shouldCancel: () => boolean) {
     const orderbookFilter = filters.find((f) => f.channel === 'orderbook')
-    if (!orderbookFilter) {
+    if (!orderbookFilter?.symbols) {
       return
     }
 
-    await wait(200)
-
     for (let symbol of orderbookFilter.symbols!) {
       if (shouldCancel()) {
         return
       }
 
-      this.send({
-        id: `${symbol}@orderbook`,
-        event: 'request',
-        params: {
-          type: 'orderbook',
-          symbol
-        }
-      })
+      const response = await getJSON<WooxOrderBookSnapshotResponse>(
+        `${this.httpURL}/v3/public/orderbook?symbol=${symbol}&maxLevel=${ORDER_BOOK_DEPTH}`
+      )
+
+      if (response.data.success === false) {
+        throw new Error(`Woox orderbook snapshot request failed: ${JSON.stringify(response.data)}`)
+      }
 
-      await wait(1)
+      this.manualSnapshotsBuffer.push({
+        topic: buildTopic(symbol, 'orderbook'),
+        ts: response.data.timestamp,
+        generated: true,
+        data: response.data.data
+      })
     }
 
-    this.debug('sent orderbook requests for: %s', orderbookFilter.symbols)
+    this.debug('fetched orderbook snapshots for: %s', orderbookFilter.symbols)
   }
 
   protected messageIsError(message: any): boolean {
-    return message.success === false || message.errorMsg !== undefined
+    return message.success === false || message.errorMsg !== undefined || message.cmd === 'ERROR'
   }
 
   protected messageIsHeartbeat(message: any): boolean {
-    return message.event === 'ping'
+    return message.event === 'ping' || message.cmd === 'PING'
   }
 
   protected onMessage(msg: any) {
@@ -66,5 +76,32 @@ export class WooxRealTimeFeed extends RealTimeFeedBase {
         event: 'ping'
       })
     }
+    if (msg.cmd === 'PING') {
+      this.send({
+        cmd: 'PONG'
+      })
+    }
+  }
+}
+
+function buildTopic(symbol: string, channel: string) {
+  if (channel === 'orderbook' || channel === 'orderbookupdate') {
+    return `${channel}@${symbol}@${ORDER_BOOK_DEPTH}`
   }
+
+  return `${channel}@${symbol}`
+}
+
+type WooxOrderBookSnapshotResponse = {
+  success: boolean
+  timestamp: number
+  data: {
+    asks: WooxOrderBookSnapshotLevel[]
+    bids: WooxOrderBookSnapshotLevel[]
+  }
+}
+
+type WooxOrderBookSnapshotLevel = {
+  price: string
+  quantity: string
 }

package/src/replay.ts

@@ -7,7 +7,7 @@ import { BinarySplitStream } from './binarysplit.ts'
 import { clearCacheSync } from './clearcache.ts'
 import { EXCHANGES, EXCHANGE_CHANNELS_INFO } from './consts.ts'
 import { debug } from './debug.ts'
-import { addDays, getFilters, normalizeMessages, parseAsUTCDate, wait } from './handy.ts'
+import { addDays, createNormalizedSymbolFilter, getFilters, normalizeMessages, parseAsUTCDate, wait } from './handy.ts'
 import { MapperFactory, normalizeBookChanges } from './mappers/index.ts'
 import { getOptions } from './options.ts'
 import { Disconnect, Exchange, FilterForExchange } from './types.ts'
@@ -285,14 +285,10 @@ export function replayNormalized<T extends Exchange, U extends MapperFactory<T,
 
   // filter normalized messages by symbol as some exchanges do not provide server side filtering so we could end up with messages
   // for symbols we've not requested for
-  const upperCaseSymbols = symbols !== undefined ? symbols.map((s) => s.toUpperCase()) : undefined
-  const filter = (symbol: string) => {
-    return upperCaseSymbols === undefined || upperCaseSymbols.length === 0 || upperCaseSymbols.includes(symbol)
-  }
-
   const segments = getReplayNormalizedSegments(exchange, normalizers, fromDate, toDate)
 
   if (segments.length <= 1) {
+    const filter = createNormalizedSymbolFilter(symbols, filters)
     const messages = replay({
       exchange,
       from,
@@ -315,6 +311,7 @@ export function replayNormalized<T extends Exchange, U extends MapperFactory<T,
       const { from: segmentFrom, to: segmentTo } = segments[i]
       const segmentMappers = i === 0 ? mappers : createMappers(segmentFrom)
       const segmentFilters = getFilters(segmentMappers, symbols)
+      const segmentFilter = createNormalizedSymbolFilter(symbols, segmentFilters)
 
       const segmentMessages = replay({
         exchange,
@@ -328,7 +325,7 @@ export function replayNormalized<T extends Exchange, U extends MapperFactory<T,
         waitWhenDataNotYetAvailable
       })
 
-      yield* normalizeMessages(exchange, undefined, segmentMessages, segmentMappers, createMappers, withDisconnectMessages, filter)
+      yield* normalizeMessages(exchange, undefined, segmentMessages, segmentMappers, createMappers, withDisconnectMessages, segmentFilter)
     }
   }
 }