tardis-dev 13.11.0 → 13.13.0

package/src/mappers/woox.ts

@@ -0,0 +1,322 @@
+import { upperCaseSymbols } from '../handy'
+import { BookChange, BookTicker, DerivativeTicker, Exchange, FilterForExchange, Liquidation, Trade } from '../types'
+import { Mapper, PendingTickerInfoHelper } from './mapper'
+
+export const wooxTradesMapper: Mapper<'woo-x', Trade> = {
+  canHandle(message: WooxTradeMessage) {
+    return message.topic !== undefined && message.topic.endsWith('@trade')
+  },
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'trade',
+        symbols
+      }
+    ]
+  },
+
+  *map(message: WooxTradeMessage, localTimestamp: Date): IterableIterator<Trade> {
+    const timestamp = new Date(message.ts)
+
+    yield {
+      type: 'trade',
+      symbol: message.data.symbol,
+      exchange: 'woo-x',
+      id: undefined,
+      price: message.data.price,
+      amount: message.data.size,
+      side: message.data.side === 'SELL' ? 'sell' : 'buy',
+      timestamp,
+      localTimestamp: localTimestamp
+    }
+  }
+}
+
+export class WooxBookChangeMapper implements Mapper<'woo-x', BookChange> {
+  private readonly _symbolToDepthInfoMapping: { [key: string]: LocalDepthInfo } = {}
+
+  canHandle(message: WooxOrderbookMessage | WooxOrderbookupdateMessage) {
+    if ('id' in message) {
+      return message.id.endsWith('@orderbook')
+    }
+
+    if ('topic' in message) {
+      return message.topic.endsWith('@orderbookupdate')
+    }
+
+    return false
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'orderbook',
+        symbols
+      },
+      {
+        channel: 'orderbookupdate',
+        symbols
+      }
+    ]
+  }
+
+  *map(message: WooxOrderbookMessage | WooxOrderbookupdateMessage, localTimestamp: Date): IterableIterator<BookChange> {
+    const symbol = message.data.symbol
+
+    if (this._symbolToDepthInfoMapping[symbol] === undefined) {
+      this._symbolToDepthInfoMapping[symbol] = {
+        bufferedUpdates: []
+      }
+    }
+
+    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 ('id' in message && message.success) {
+      yield {
+        type: 'book_change',
+        symbol,
+        exchange: 'woo-x',
+        isSnapshot: true,
+        bids: message.data.bids.map(this._mapBookLevel),
+        asks: message.data.asks.map(this._mapBookLevel),
+        timestamp: new Date(message.data.ts),
+        localTimestamp
+      }
+
+      //  mark given symbol depth info that has snapshot processed
+      symbolDepthInfo.lastUpdateTimestamp = message.data.ts
+      symbolDepthInfo.snapshotProcessed = true
+
+      // if there were any depth updates buffered, let's proccess those
+      for (const update of symbolDepthInfo.bufferedUpdates) {
+        const bookChange = this._mapBookDepthUpdate(update, localTimestamp, symbolDepthInfo, symbol)
+        if (bookChange !== undefined) {
+          yield bookChange
+        }
+      }
+      // remove all buffered updates
+      symbolDepthInfo.bufferedUpdates = []
+    } else if (snapshotAlreadyProcessed) {
+      // snapshot was already processed let's map the message as normal book_change
+      const bookChange = this._mapBookDepthUpdate(message as WooxOrderbookupdateMessage, localTimestamp, symbolDepthInfo, symbol)
+      if (bookChange !== undefined) {
+        yield bookChange
+      }
+    } else {
+      // if snapshot hasn't been yet processed and we've got depthUpdate message, let's buffer it for later processing
+      symbolDepthInfo.bufferedUpdates.push(message as WooxOrderbookupdateMessage)
+    }
+  }
+
+  private _mapBookDepthUpdate(
+    wooxBookUpdate: WooxOrderbookupdateMessage,
+    localTimestamp: Date,
+    depthInfo: LocalDepthInfo,
+    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._mapBookLevel),
+      asks: wooxBookUpdate.data.asks.map(this._mapBookLevel),
+      timestamp: new Date(wooxBookUpdate.ts),
+      localTimestamp
+    }
+  }
+
+  private _mapBookLevel(level: [number, number]) {
+    const price = level[0]
+    const amount = level[1]
+
+    return { price, amount }
+  }
+}
+
+export class WooxDerivativeTickerMapper implements Mapper<'woo-x', DerivativeTicker> {
+  private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
+  private readonly _indexPrices = new Map<string, number>()
+
+  canHandle(message: WooxTradeMessage | WooxEstFundingRate | WooxMarkPrice | WooxIndexPrice | WooxOpenInterest) {
+    if (message.topic === undefined) {
+      return false
+    }
+    const symbol = (message.data && message.data.symbol) || ''
+    const isPerp = symbol.startsWith('PERP_')
+
+    return (
+      (message.topic.endsWith('@trade') && isPerp) ||
+      (message.topic.endsWith('@markprice') && isPerp) ||
+      (message.topic.endsWith('@estfundingrate') && isPerp) ||
+      message.topic.endsWith('@indexprice') ||
+      (message.topic.endsWith('@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: any, localTimestamp: Date): IterableIterator<DerivativeTicker> {
+    if (message.topic.endsWith('@indexprice')) {
+      this._indexPrices.set(message.data.symbol.replace('SPOT_', 'PERP_'), message.data.price)
+    } else {
+      const symbol = message.data.symbol
+      const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(symbol, 'woo-x')
+
+      const lastIndexPrice = this._indexPrices.get(symbol)
+      if (lastIndexPrice !== undefined) {
+        pendingTickerInfo.updateIndexPrice(lastIndexPrice)
+      }
+
+      if (message.topic.endsWith('@markprice')) {
+        pendingTickerInfo.updateMarkPrice(message.data.price)
+        pendingTickerInfo.updateTimestamp(new Date(message.ts))
+      }
+
+      if (message.topic.endsWith('@trade')) {
+        pendingTickerInfo.updateLastPrice(message.data.price)
+        pendingTickerInfo.updateTimestamp(new Date(message.ts))
+      }
+
+      if (message.topic.endsWith('@estfundingrate')) {
+        pendingTickerInfo.updateFundingRate(message.data.fundingRate)
+        pendingTickerInfo.updateFundingTimestamp(new Date(message.data.fundingTs))
+        pendingTickerInfo.updateTimestamp(new Date(message.ts))
+      }
+
+      if (message.topic.endsWith('@openinterest')) {
+        pendingTickerInfo.updateOpenInterest(message.data.openInterest)
+        pendingTickerInfo.updateTimestamp(new Date(message.ts))
+      }
+
+      if (pendingTickerInfo.hasChanged()) {
+        yield pendingTickerInfo.getSnapshot(localTimestamp)
+      }
+    }
+  }
+}
+
+export class WooxBookTickerMapper implements Mapper<'woo-x', BookTicker> {
+  canHandle(message: WooxTradeMessage) {
+    return message.topic !== undefined && message.topic.endsWith('@bbo')
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'bbo',
+        symbols
+      }
+    ]
+  }
+
+  *map(wooxBBOMessage: WooxBBOMessage, localTimestamp: Date) {
+    const wooxBookTicker = wooxBBOMessage.data
+
+    const ticker: BookTicker = {
+      type: 'book_ticker',
+      symbol: wooxBookTicker.symbol,
+      exchange: 'woo-x',
+      askAmount: wooxBookTicker.askSize !== undefined ? wooxBookTicker.askSize : undefined,
+      askPrice: wooxBookTicker.ask !== undefined ? wooxBookTicker.ask : undefined,
+
+      bidPrice: wooxBookTicker.bid !== undefined ? wooxBookTicker.bid : undefined,
+      bidAmount: wooxBookTicker.bidSize !== undefined ? wooxBookTicker.bidSize : undefined,
+      timestamp: new Date(wooxBBOMessage.ts),
+      localTimestamp: localTimestamp
+    }
+
+    yield ticker
+  }
+}
+
+type LocalDepthInfo = {
+  bufferedUpdates: WooxOrderbookupdateMessage[]
+  snapshotProcessed?: boolean
+  lastUpdateTimestamp?: number
+}
+
+type WooxTradeMessage = {
+  topic: 'PERP_GALA_USDT@trade'
+  ts: 1674431999995
+  data: { symbol: 'PERP_GALA_USDT'; price: 0.048756; size: 4109; side: 'SELL'; source: 0 }
+}
+
+type WooxOrderbookupdateMessage = {
+  topic: 'PERP_BTC_USDT@orderbookupdate'
+  ts: 1674432000020
+  data: {
+    symbol: 'PERP_BTC_USDT'
+    prevTs: 1674432000030
+    asks: [[22712.7, 15.4675]]
+    bids: [[22708.0, 4.503]]
+  }
+}
+
+type WooxOrderbookMessage = {
+  id: 'PERP_BTC_USDT@orderbook'
+  event: 'request'
+  success: true
+  ts: 1674432000034
+  data: {
+    symbol: 'PERP_BTC_USDT'
+    ts: 1674432000020
+    asks: [[22712.7, 15.4675], [26772.1, 0.248]]
+    bids: [[22708.0, 4.503], [18555.0, 0.002]]
+  }
+}
+
+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 WooxMarkPrice = { topic: 'PERP_BTC_USDT@markprice'; ts: 1674432000007; data: { symbol: 'PERP_BTC_USDT'; price: 22711.11 } }
+
+type WooxEstFundingRate = {
+  topic: 'PERP_BTC_USDT@estfundingrate'
+  ts: 1674432059002
+  data: { symbol: 'PERP_BTC_USDT'; fundingRate: 0.00000782; fundingTs: 1674435600005 }
+}
+
+type WooxIndexPrice = { topic: 'SPOT_BTC_USDT@indexprice'; ts: 1674432000024; data: { symbol: 'SPOT_BTC_USDT'; price: 22708.44 } }
+type WooxOpenInterest = { topic: 'PERP_BTC_USDT@openinterest'; ts: 1674432013624; data: { symbol: 'PERP_BTC_USDT'; openInterest: 83.2241 } }

package/src/realtimefeeds/index.ts

@@ -45,6 +45,7 @@ import { BybitSpotRealTimeFeed } from './bybitspot'
 import { CryptoComRealTimeFeed } from './cryptocom'
 import { KucoinRealTimeFeed } from './kucoin'
 import { BitnomialRealTimeFeed } from './bitnomial'
+import { WooxRealTimeFeed } from './woox'
 
 export * from './realtimefeed'
 
@@ -98,7 +99,8 @@ const realTimeFeedsMap: {
   'crypto-com': CryptoComRealTimeFeed,
   'crypto-com-derivatives': CryptoComRealTimeFeed,
   kucoin: KucoinRealTimeFeed,
-  bitnomial: BitnomialRealTimeFeed
+  bitnomial: BitnomialRealTimeFeed,
+  'woo-x': WooxRealTimeFeed
 }
 
 export function getRealTimeFeedFactory(exchange: Exchange): RealTimeFeed {

package/src/realtimefeeds/woox.ts

@@ -0,0 +1,70 @@
+import { wait } from '../handy'
+import { Filter } from '../types'
+import { RealTimeFeedBase } from './realtimefeed'
+
+export class WooxRealTimeFeed extends RealTimeFeedBase {
+  protected wssURL = 'wss://wss.woo.org/ws/stream/OqdphuyCtYWxwzhxyLLjOWNdFP7sQt8RPWzmb5xY'
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    return filters
+      .filter((filter) => filter.channel !== 'orderbook')
+      .map((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'
+          }
+        })
+      })
+      .flatMap((f) => f)
+  }
+
+  protected async provideManualSnapshots(filters: Filter<string>[], shouldCancel: () => boolean) {
+    const orderbookFilter = filters.find((f) => f.channel === 'orderbook')
+    if (!orderbookFilter) {
+      return
+    }
+
+    await wait(200)
+
+    for (let symbol of orderbookFilter.symbols!) {
+      if (shouldCancel()) {
+        return
+      }
+
+      this.send({
+        id: `${symbol}@orderbook`,
+        event: 'request',
+        params: {
+          type: 'orderbook',
+          symbol
+        }
+      })
+
+      await wait(1)
+    }
+
+    this.debug('sent orderbook requests for: %s', orderbookFilter.symbols)
+  }
+
+  protected messageIsError(message: any): boolean {
+    return message.success === false || message.errorMsg !== undefined
+  }
+
+  protected messageIsHeartbeat(message: any): boolean {
+    return message.event === 'ping'
+  }
+
+  protected onMessage(msg: any) {
+    if (msg.event === 'ping') {
+      this.send({
+        event: 'ping'
+      })
+    }
+  }
+}