tardis-dev 16.5.1 → 16.6.1

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

@@ -275,27 +275,14 @@ export function replayNormalized<T extends Exchange, U extends MapperFactory<T,
   ...normalizers: U
 ): AsyncIterableIterator<ReplayNormalizedMessage<U, Z>> {
   const fromDate = parseAsUTCDate(from)
+  const toDate = parseAsUTCDate(to)
 
   validateReplayNormalizedOptions(fromDate, normalizers)
 
-  //TODO: zrovi replay dzien po dniu, tak ze kazdego dnia przekazuje swierze filters
-
   const createMappers = (localTimestamp: Date) => normalizers.map((m) => m(exchange, localTimestamp))
   const mappers = createMappers(fromDate)
   const filters = getFilters(mappers, symbols)
 
-  const messages = replay({
-    exchange,
-    from,
-    to,
-    withDisconnects: true,
-    filters,
-    apiKey,
-    withMicroseconds: true,
-    autoCleanup,
-    waitWhenDataNotYetAvailable
-  })
-
   // 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
@@ -303,7 +290,78 @@ export function replayNormalized<T extends Exchange, U extends MapperFactory<T,
     return upperCaseSymbols === undefined || upperCaseSymbols.length === 0 || upperCaseSymbols.includes(symbol)
   }
 
-  return normalizeMessages(exchange, undefined, messages, mappers, createMappers, withDisconnectMessages, filter)
+  const segments = getReplayNormalizedSegments(exchange, normalizers, fromDate, toDate)
+
+  if (segments.length <= 1) {
+    const messages = replay({
+      exchange,
+      from,
+      to,
+      withDisconnects: true,
+      filters,
+      apiKey,
+      withMicroseconds: true,
+      autoCleanup,
+      waitWhenDataNotYetAvailable
+    })
+
+    return normalizeMessages(exchange, undefined, messages, mappers, createMappers, withDisconnectMessages, filter)
+  }
+
+  return replayNormalizedSegments()
+
+  async function* replayNormalizedSegments() {
+    for (let i = 0; i < segments.length; i++) {
+      const { from: segmentFrom, to: segmentTo } = segments[i]
+      const segmentMappers = i === 0 ? mappers : createMappers(segmentFrom)
+      const segmentFilters = getFilters(segmentMappers, symbols)
+
+      const segmentMessages = replay({
+        exchange,
+        from: segmentFrom.toISOString(),
+        to: segmentTo.toISOString(),
+        withDisconnects: true,
+        filters: segmentFilters,
+        apiKey,
+        withMicroseconds: true,
+        autoCleanup,
+        waitWhenDataNotYetAvailable
+      })
+
+      yield* normalizeMessages(exchange, undefined, segmentMessages, segmentMappers, createMappers, withDisconnectMessages, filter)
+    }
+  }
+}
+
+function getReplayNormalizedSegments<T extends Exchange>(exchange: T, normalizers: MapperFactory<T, any>[], fromDate: Date, toDate: Date) {
+  const fromTime = fromDate.valueOf()
+  const toTime = toDate.valueOf()
+  if (Number.isFinite(fromTime) === false || Number.isFinite(toTime) === false || fromTime >= toTime) {
+    return [{ from: fromDate, to: toDate }]
+  }
+
+  const switchTimes = new Set<number>()
+  for (const normalizer of normalizers) {
+    const switchDates = normalizer.getSwitchDates?.(exchange) ?? []
+    for (const switchDate of switchDates) {
+      const switchTime = switchDate.valueOf()
+      if (fromTime < switchTime && switchTime < toTime) {
+        switchTimes.add(switchTime)
+      }
+    }
+  }
+
+  const switchDates = [...switchTimes].sort((a, b) => a - b).map((switchTime) => new Date(switchTime))
+  const segments: { from: Date; to: Date }[] = []
+  let segmentFrom = fromDate
+
+  for (const switchDate of switchDates) {
+    segments.push({ from: segmentFrom, to: switchDate })
+    segmentFrom = switchDate
+  }
+  segments.push({ from: segmentFrom, to: toDate })
+
+  return segments
 }
 
 function validateReplayOptions<T extends Exchange>(exchange: T, from: string, to: string, filters: FilterForExchange[T][]) {