tardis-machine 17.0.0 → 18.0.0

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

@@ -0,0 +1,353 @@
+import { debug } from '../debug.ts'
+import { CircularBuffer, upperCaseSymbols } from '../handy.ts'
+import { BookChange, Exchange, BookTicker, Trade, BookPriceLevel } from '../types.ts'
+import { Mapper } from './mapper.ts'
+import { exchangeMappers, isRealTime } from './registry.ts'
+
+export const kucoinMappers = exchangeMappers({
+  kucoin: {
+    trades: () => new KucoinTradesMapper('kucoin'),
+    bookChanges: (localTimestamp) =>
+      new KucoinBookChangeMapper('kucoin', { ignoreBookSnapshotOverlapError: isRealTime(localTimestamp) === false }),
+    bookTickers: () => new KucoinBookTickerMapper('kucoin')
+  }
+})
+
+class KucoinTradesMapper implements Mapper<'kucoin', Trade> {
+  constructor(private readonly _exchange: Exchange) {}
+  canHandle(message: KucoinTradeMessage) {
+    return message.type === 'message' && message.topic.startsWith('/market/match')
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'market/match',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: KucoinTradeMessage, localTimestamp: Date): IterableIterator<Trade> {
+    const kucoinTrade = message.data
+
+    const timestamp = new Date(Number(kucoinTrade.time.slice(0, 13)))
+
+    timestamp.μs = Number(kucoinTrade.time.slice(13, 16))
+
+    yield {
+      type: 'trade',
+      symbol: kucoinTrade.symbol,
+      exchange: this._exchange,
+      id: kucoinTrade.tradeId,
+      price: Number(kucoinTrade.price),
+      amount: Number(kucoinTrade.size),
+      side: kucoinTrade.side === 'sell' ? 'sell' : 'buy',
+      timestamp,
+      localTimestamp
+    }
+  }
+}
+
+class KucoinBookChangeMapper implements Mapper<'kucoin', BookChange> {
+  protected readonly symbolToDepthInfoMapping: {
+    [key: string]: LocalDepthInfo
+  } = {}
+
+  constructor(
+    protected readonly _exchange: Exchange,
+    { ignoreBookSnapshotOverlapError }: { ignoreBookSnapshotOverlapError: boolean }
+  ) {
+    this.ignoreBookSnapshotOverlapError = ignoreBookSnapshotOverlapError
+  }
+
+  private readonly ignoreBookSnapshotOverlapError: boolean
+
+  canHandle(message: KucoinLevel2SnapshotMessage | KucoinLevel2UpdateMessage) {
+    return message.type === 'message' && message.topic.startsWith('/market/level2')
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+    return [
+      {
+        channel: 'market/level2',
+        symbols
+      } as const,
+      {
+        channel: 'market/level2Snapshot',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: KucoinLevel2SnapshotMessage | KucoinLevel2UpdateMessage, localTimestamp: Date) {
+    const symbol = message.topic.split(':')[1]
+
+    if (this.symbolToDepthInfoMapping[symbol] === undefined) {
+      this.symbolToDepthInfoMapping[symbol] = {
+        bufferedUpdates: new CircularBuffer<KucoinLevel2UpdateMessage>(2000)
+      }
+    }
+
+    const symbolDepthInfo = this.symbolToDepthInfoMapping[symbol]
+    const snapshotAlreadyProcessed = symbolDepthInfo.snapshotProcessed
+
+    // first check if received message is snapshot and process it as such if it is
+    if (message.subject === 'trade.l2Snapshot') {
+      // if we've already received 'manual' snapshot, ignore if there is another one
+      if (snapshotAlreadyProcessed) {
+        return
+      }
+      // produce snapshot book_change
+      const kucoinSnapshotData = message.data
+      if (!kucoinSnapshotData.asks) {
+        kucoinSnapshotData.asks = []
+      }
+      if (!kucoinSnapshotData.bids) {
+        kucoinSnapshotData.bids = []
+      }
+
+      //  mark given symbol depth info that has snapshot processed
+      symbolDepthInfo.lastUpdateId = Number(kucoinSnapshotData.sequence)
+      symbolDepthInfo.snapshotProcessed = true
+
+      // if there were any depth updates buffered, let's proccess those by adding to or updating the initial snapshot
+      for (const update of symbolDepthInfo.bufferedUpdates.items()) {
+        const bookChange = this.mapBookDepthUpdate(update, localTimestamp)
+        if (bookChange !== undefined) {
+          for (const bid of update.data.changes.bids) {
+            if (bid[0] == '0') {
+              continue
+            }
+            const matchingBid = kucoinSnapshotData.bids.find((b) => b[0] === bid[0])
+            if (matchingBid !== undefined) {
+              matchingBid[1] = bid[1]
+            } else {
+              kucoinSnapshotData.bids.push([bid[0], bid[1]])
+            }
+          }
+
+          for (const ask of update.data.changes.asks) {
+            if (ask[0] == '0') {
+              continue
+            }
+
+            const matchingAsk = kucoinSnapshotData.asks.find((a) => a[0] === ask[0])
+            if (matchingAsk !== undefined) {
+              matchingAsk[1] = ask[1]
+            } else {
+              kucoinSnapshotData.asks.push([ask[0], ask[1]])
+            }
+          }
+        }
+      }
+
+      // remove all buffered updates
+      symbolDepthInfo.bufferedUpdates.clear()
+
+      const bookChange: BookChange = {
+        type: 'book_change',
+        symbol,
+        exchange: this._exchange,
+        isSnapshot: true,
+        bids: kucoinSnapshotData.bids.map(this.mapBookLevel),
+        asks: kucoinSnapshotData.asks.map(this.mapBookLevel),
+        timestamp: localTimestamp,
+        localTimestamp
+      }
+
+      yield bookChange
+    } else if (snapshotAlreadyProcessed) {
+      // snapshot was already processed let's map the message as normal book_change
+      const bookChange = this.mapBookDepthUpdate(message, localTimestamp)
+      if (bookChange !== undefined) {
+        yield bookChange
+      }
+    } else {
+      symbolDepthInfo.bufferedUpdates.append(message)
+    }
+  }
+
+  protected mapBookDepthUpdate(l2UpdateMessage: KucoinLevel2UpdateMessage, localTimestamp: Date): BookChange | undefined {
+    // we can safely assume here that depthContext and lastUpdateId aren't null here as this is method only works
+    // when we've already processed the snapshot
+    const depthContext = this.symbolToDepthInfoMapping[l2UpdateMessage.data.symbol]!
+    const lastUpdateId = depthContext.lastUpdateId!
+
+    // Drop any event where sequenceEnd is <= lastUpdateId in the snapshot
+    if (l2UpdateMessage.data.sequenceEnd <= lastUpdateId) {
+      return
+    }
+
+    // The first processed event should have sequenceStart <= lastUpdateId+1 AND sequenceEnd >= lastUpdateId+1.
+    if (!depthContext.validatedFirstUpdate) {
+      // if there is new instrument added it can have empty book at first and that's normal
+      const bookSnapshotIsEmpty = lastUpdateId == -1 || lastUpdateId == 0
+
+      if (
+        (l2UpdateMessage.data.sequenceStart <= lastUpdateId + 1 && l2UpdateMessage.data.sequenceEnd >= lastUpdateId + 1) ||
+        bookSnapshotIsEmpty
+      ) {
+        depthContext.validatedFirstUpdate = true
+      } else {
+        const message = `Book depth snapshot has no overlap with first update, update ${JSON.stringify(
+          l2UpdateMessage
+        )}, lastUpdateId: ${lastUpdateId}, exchange ${this._exchange}`
+        if (this.ignoreBookSnapshotOverlapError) {
+          depthContext.validatedFirstUpdate = true
+          debug(message)
+        } else {
+          throw new Error(message)
+        }
+      }
+    }
+    const bids = l2UpdateMessage.data.changes.bids.map(this.mapBookLevel).filter(this.nonZeroLevels)
+    const asks = l2UpdateMessage.data.changes.asks.map(this.mapBookLevel).filter(this.nonZeroLevels)
+
+    if (bids.length === 0 && asks.length === 0) {
+      return
+    }
+
+    const timestamp = l2UpdateMessage.data.time !== undefined ? new Date(l2UpdateMessage.data.time) : localTimestamp
+    return {
+      type: 'book_change',
+      symbol: l2UpdateMessage.data.symbol,
+      exchange: this._exchange,
+      isSnapshot: false,
+      bids,
+      asks,
+      timestamp: timestamp,
+      localTimestamp: localTimestamp
+    }
+  }
+
+  private mapBookLevel(level: [string, string, string?]) {
+    const price = Number(level[0])
+    const amount = Number(level[1])
+    return { price, amount }
+  }
+
+  private nonZeroLevels(level: BookPriceLevel) {
+    return level.price > 0
+  }
+}
+
+class KucoinBookTickerMapper implements Mapper<'kucoin', BookTicker> {
+  constructor(protected readonly _exchange: Exchange) {}
+
+  canHandle(message: KucoinTickerMessage) {
+    return message.type === 'message' && message.topic.startsWith('/market/ticker')
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+    return [
+      {
+        channel: 'market/ticker',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: KucoinTickerMessage, localTimestamp: Date) {
+    const symbol = message.topic.split(':')[1]
+
+    const bookTicker: BookTicker = {
+      type: 'book_ticker',
+      symbol,
+      exchange: this._exchange,
+      askAmount: message.data.bestAskSize !== undefined && message.data.bestAskSize !== null ? Number(message.data.bestAskSize) : undefined,
+      askPrice: message.data.bestAsk !== undefined && message.data.bestAsk !== null ? Number(message.data.bestAsk) : undefined,
+      bidPrice: message.data.bestBid !== undefined && message.data.bestBid !== null ? Number(message.data.bestBid) : undefined,
+      bidAmount: message.data.bestBidSize !== undefined && message.data.bestBidSize !== null ? Number(message.data.bestBidSize) : undefined,
+      timestamp: new Date(message.data.time),
+      localTimestamp: localTimestamp
+    }
+
+    yield bookTicker
+  }
+}
+
+type KucoinTickerMessage = {
+  type: 'message'
+  topic: '/market/ticker:ADA-USDT'
+  subject: 'trade.ticker'
+  data: {
+    bestAsk: '0.549931'
+    bestAskSize: '966.4756'
+    bestBid: '0.549824'
+    bestBidSize: '1050'
+    price: '0.549825'
+    sequence: '1623526404099'
+    size: '1'
+    time: 1660608019871
+  }
+}
+
+type KucoinTradeMessage = {
+  type: 'message'
+  topic: '/market/match:BTC-USDT'
+  subject: 'trade.l3match'
+  data: {
+    symbol: 'BTC-USDT'
+    side: 'sell'
+    type: 'match'
+    makerOrderId: '62fadde41add68000167fb58'
+    sequence: '1636276321894'
+    size: '0.00001255'
+    price: '24093.9'
+    takerOrderId: '62faddfff0476c0001c86c71'
+    time: '1660608000026914990'
+    tradeId: '62fade002e113d292303a18b'
+  }
+}
+
+type LocalDepthInfo = {
+  bufferedUpdates: CircularBuffer<KucoinLevel2UpdateMessage>
+  snapshotProcessed?: boolean
+  lastUpdateId?: number
+  validatedFirstUpdate?: boolean
+}
+
+type KucoinLevel2SnapshotMessage = {
+  type: 'message'
+  generated: true
+  topic: '/market/level2Snapshot:BTC-USDT'
+  subject: 'trade.l2Snapshot'
+  code: '200000'
+  data: {
+    time: 1660608003710
+    sequence: '1636276324355'
+    bids: [string, string][] | null
+    asks: [string, string][] | null
+  }
+}
+
+type KucoinLevel2UpdateMessage =
+  | {
+      type: 'message'
+      topic: '/market/level2:BTC-USDT'
+      subject: 'trade.l2update'
+      data: {
+        sequenceStart: 1636276324710
+        symbol: 'BTC-USDT'
+        changes: { asks: [string, string, string][]; bids: [string, string, string][] }
+        sequenceEnd: 1636276324710
+        time: undefined
+      }
+    }
+  | {
+      type: 'message'
+      topic: '/market/level2:BTC-USDT'
+      subject: 'trade.l2update'
+      data: {
+        changes: { asks: []; bids: [['27309.8', '0.35127929', '8005280396']] }
+        sequenceEnd: 8005280396
+        sequenceStart: 8005280396
+        symbol: 'BTC-USDT'
+        time: 1685578980002
+      }
+    }