tardis-dev 13.4.10 → 13.4.13

package/src/mappers/cryptocom.ts

@@ -0,0 +1,395 @@
+import { upperCaseSymbols } from '../handy'
+import { BookChange, Exchange, BookTicker, Trade, DerivativeTicker } from '../types'
+import { Mapper, PendingTickerInfoHelper } from './mapper'
+
+export class CryptoComTradesMapper implements Mapper<'crypto-com' | 'crypto-com-derivatives', Trade> {
+  constructor(private readonly _exchange: Exchange) {}
+  canHandle(message: CryptoComTradeMessage) {
+    return message.result !== undefined && message.result.channel === 'trade'
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'trade',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: CryptoComTradeMessage, localTimestamp: Date): IterableIterator<Trade> {
+    message.result.data.reverse()
+
+    for (const item of message.result.data) {
+      const trade: Trade = {
+        type: 'trade',
+        symbol: message.result.instrument_name,
+        exchange: this._exchange,
+        id: item.d.toString(),
+        price: Number(item.p),
+        amount: Number(item.q),
+        side: item.s === 'BUY' ? 'buy' : 'sell',
+        timestamp: new Date(item.t),
+        localTimestamp
+      }
+
+      yield trade
+    }
+  }
+}
+
+export class CryptoComBookChangeMapper implements Mapper<'crypto-com' | 'crypto-com-derivatives', BookChange> {
+  constructor(protected readonly _exchange: Exchange) {}
+
+  canHandle(message: CryptoComBookMessage) {
+    return message.result !== undefined && message.result.channel.startsWith('book')
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+    return [
+      {
+        channel: 'book',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: CryptoComBookMessage, localTimestamp: Date) {
+    if (message.result.data === undefined || message.result.data[0] === undefined) {
+      return
+    }
+
+    const bids = (message.result.channel === 'book' ? message.result.data[0].bids : message.result.data[0].update.bids) || []
+    const asks = (message.result.channel === 'book' ? message.result.data[0].asks : message.result.data[0].update.asks) || []
+
+    yield {
+      type: 'book_change',
+      symbol: message.result.instrument_name,
+      exchange: this._exchange,
+      isSnapshot: message.result.channel === 'book',
+      bids: bids.map(this._mapBookLevel),
+      asks: asks.map(this._mapBookLevel),
+      timestamp: new Date(message.result.data[0].t),
+      localTimestamp
+    } as const
+  }
+
+  private _mapBookLevel(level: [number | string, number | string]) {
+    return { price: Number(level[0]), amount: Number(level[1]) }
+  }
+}
+
+export class CryptoComBookTickerMapper implements Mapper<'crypto-com' | 'crypto-com-derivatives', BookTicker> {
+  constructor(protected readonly _exchange: Exchange) {}
+
+  canHandle(message: CryptoComTickerMessage) {
+    return message.result !== undefined && message.result.channel === 'ticker'
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+    return [
+      {
+        channel: 'ticker',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: CryptoComTickerMessage, localTimestamp: Date) {
+    for (const item of message.result.data) {
+      const bookTicker: BookTicker = {
+        type: 'book_ticker',
+        symbol: message.result.instrument_name,
+        exchange: this._exchange,
+
+        askAmount: undefined,
+        askPrice: item.k !== undefined && item.k !== null ? Number(item.k) : undefined,
+        bidPrice: item.b !== undefined && item.b !== null ? Number(item.b) : undefined,
+        bidAmount: undefined,
+        timestamp: new Date(item.t),
+        localTimestamp: localTimestamp
+      }
+
+      yield bookTicker
+    }
+  }
+}
+
+export class CryptoComDerivativeTickerMapper implements Mapper<'crypto-com-derivatives', DerivativeTicker> {
+  private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
+  private readonly _indexPrices = new Map<string, number>()
+
+  constructor(protected readonly exchange: Exchange) {}
+
+  canHandle(message: CryptoComDerivativesTickerMessage | CryptoComIndexMessage | CryptoComMarkPriceMessage | CryptoComFundingMessage) {
+    if (message.result === undefined) {
+      return false
+    }
+
+    return (
+      message.result.channel === 'ticker' ||
+      message.result.channel === 'index' ||
+      message.result.channel === 'mark' ||
+      message.result.channel === 'funding'
+    )
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    let indexes: string[] = []
+    if (symbols !== undefined) {
+      indexes = [...new Set(symbols.map((s) => `${s.split('-')[0]}-INDEX`))]
+    }
+    const filters = [
+      {
+        channel: 'ticker',
+        symbols
+      } as const,
+      {
+        channel: 'index',
+        symbols: indexes
+      } as const,
+      {
+        channel: 'mark',
+        symbols
+      } as const,
+      {
+        channel: 'funding',
+        symbols
+      } as const
+    ]
+
+    return filters
+  }
+
+  *map(
+    message: CryptoComDerivativesTickerMessage | CryptoComIndexMessage | CryptoComMarkPriceMessage | CryptoComFundingMessage,
+    localTimestamp: Date
+  ): IterableIterator<DerivativeTicker> {
+    if (message.result.channel === 'index') {
+      this._indexPrices.set(message.result.instrument_name.split('-')[0], Number(message.result.data[0].v))
+      return
+    }
+
+    const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(message.result.instrument_name, this.exchange)
+
+    const lastIndexPrice = this._indexPrices.get(message.result.instrument_name.split('-')[0])
+    if (lastIndexPrice !== undefined) {
+      pendingTickerInfo.updateIndexPrice(lastIndexPrice)
+    }
+
+    if (message.result.channel === 'ticker') {
+      if (message.result.data[0].a !== null && message.result.data[0].a !== undefined) {
+        pendingTickerInfo.updateLastPrice(Number(message.result.data[0].a))
+      }
+      if (message.result.data[0].oi !== null && message.result.data[0].oi !== undefined) {
+        pendingTickerInfo.updateOpenInterest(Number(message.result.data[0].oi))
+      }
+    }
+
+    if (message.result.channel === 'mark') {
+      if (message.result.data[0].v !== null && message.result.data[0].v !== undefined) {
+        pendingTickerInfo.updateMarkPrice(Number(message.result.data[0].v))
+      }
+    }
+
+    if (message.result.channel === 'funding') {
+      if (message.result.data[0].v !== null && message.result.data[0].v !== undefined) {
+        pendingTickerInfo.updateFundingRate(Number(message.result.data[0].v))
+        const nextFundingTimestamp = new Date(message.result.data[0].t)
+        nextFundingTimestamp.setUTCHours(nextFundingTimestamp.getUTCHours() + 1)
+        nextFundingTimestamp.setUTCMinutes(0, 0, 0)
+        pendingTickerInfo.updateFundingTimestamp(nextFundingTimestamp)
+      }
+    }
+
+    pendingTickerInfo.updateTimestamp(new Date(message.result.data[0].t))
+
+    if (pendingTickerInfo.hasChanged()) {
+      yield pendingTickerInfo.getSnapshot(localTimestamp)
+    }
+  }
+}
+
+type CryptoComTradeMessage =
+  | {
+      method: 'subscribe'
+      result: {
+        instrument_name: 'ETH_CRO' // instrument_name
+        subscription: 'trade.ETH_CRO'
+        channel: 'trade'
+        data: [
+          {
+            p: 162.12 // price
+            q: 11.085 // quantity
+            s: 'BUY' // side
+            d: 1210447366 // trade id
+            t: 1587523078844 // trade time
+            dataTime: 0 // please ignore this field
+          }
+        ]
+      }
+    }
+  | {
+      id: -1
+      code: 0
+      method: 'subscribe'
+      result: {
+        channel: 'trade'
+        subscription: 'trade.BTCUSD-PERP'
+        instrument_name: 'BTCUSD-PERP'
+        data: [{ d: '4611686018439397540'; t: 1653992578435; p: '31603.5'; q: '0.1000'; s: 'BUY'; i: 'BTCUSD-PERP' }]
+      }
+    }
+
+type CryptoComBookMessage =
+  | {
+      code: 0
+      method: 'subscribe'
+      result: {
+        instrument_name: 'ETH_CRO'
+        subscription: 'book.ETH_CRO.150'
+        channel: 'book'
+        depth: 150
+        data: [
+          {
+            bids: [number, number][]
+            asks: [number, number][]
+            t: 1659311999933
+            s: 788293808
+          }
+        ]
+      }
+    }
+  | {
+      code: 0
+      method: 'subscribe'
+      result: {
+        instrument_name: 'DOT_USDT'
+        subscription: 'book.DOT_USDT.150'
+        channel: 'book.update'
+        depth: 150
+        data: [
+          {
+            update: { bids: [number, number][]; asks: [number, number][] }
+            t: 1659312000046
+            s: 763793123
+          }
+        ]
+      }
+    }
+  | {
+      id: -1
+      code: 0
+      method: 'subscribe'
+      result: {
+        channel: 'book.update'
+        subscription: 'book.BTCUSD-PERP.50'
+        instrument_name: 'BTCUSD-PERP'
+        depth: 50
+        data: [
+          {
+            update: { asks: [string, string][]; bids: [string, string][] }
+            t: 1653992578436
+            tt: 1653992578428
+            u: 72560693920
+            pu: 72560688000
+            cs: 380529173
+          }
+        ]
+      }
+    }
+
+type CryptoComTickerMessage =
+  | {
+      code: 0
+      method: 'subscribe'
+      result: {
+        instrument_name: 'GODS_USDT'
+        subscription: 'ticker.GODS_USDT'
+        channel: 'ticker'
+        data: [
+          {
+            i: 'GODS_USDT'
+            b: 0.4262
+            k: 0.4272
+            a: 0.4272
+            t: 1659311999946
+            v: 100623.01
+            vv: 42986.1541
+            h: 0.4624
+            l: 0.4229
+            c: -0.0062
+            pc: -1.4302
+          }
+        ]
+      }
+    }
+  | CryptoComDerivativesTickerMessage
+
+type CryptoComDerivativesTickerMessage = {
+  id: -1
+  code: 0
+  method: 'subscribe'
+  result: {
+    channel: 'ticker'
+    instrument_name: 'BTCUSD-PERP'
+    subscription: 'ticker.BTCUSD-PERP'
+    data: [
+      {
+        h: '32222.5'
+        l: '30240.0'
+        a: '31611.0'
+        c: '0.0320'
+        b: '31613.0'
+        k: '31613.5'
+        i: 'BTCUSD-PERP'
+        v: '13206.4884'
+        vv: '433945264.39'
+        oi: '318.5162'
+        t: 1653992543383
+      }
+    ]
+  }
+}
+
+type CryptoComIndexMessage = {
+  id: -1
+  method: 'subscribe'
+  code: 0
+  result: {
+    instrument_name: 'BTCUSD-INDEX'
+    subscription: 'index.BTCUSD-INDEX'
+    channel: 'index'
+    data: [{ v: '31601.35'; t: 1653992545000 }]
+  }
+}
+
+type CryptoComMarkPriceMessage = {
+  id: 1
+  method: 'subscribe'
+  code: 0
+  result: {
+    instrument_name: 'BTCUSD-PERP'
+    subscription: 'mark.BTCUSD-PERP'
+    channel: 'mark'
+    data: [{ v: '31606.3'; t: 1653992543000 }]
+  }
+}
+
+type CryptoComFundingMessage = {
+  id: -1
+  method: 'subscribe'
+  code: 0
+  result: {
+    instrument_name: 'BTCUSD-PERP'
+    subscription: 'funding.BTCUSD-PERP'
+    channel: 'funding'
+    data: [{ v: '0.00000700'; t: 1653992579000 }]
+  }
+}

package/src/mappers/index.ts

@@ -28,8 +28,10 @@ import {
 } from './bitmex'
 import { BitstampBookChangeMapper, bitstampTradesMapper } from './bitstamp'
 import { BybitBookChangeMapper, BybitDerivativeTickerMapper, BybitLiquidationsMapper, BybitTradesMapper } from './bybit'
+import { BybitSpotBookChangeMapper, BybitSpotBookTickerMapper, BybitSpotTradesMapper } from './bybitspot'
 import { CoinbaseBookChangMapper, coinbaseBookTickerMapper, coinbaseTradesMapper } from './coinbase'
 import { coinflexBookChangeMapper, CoinflexDerivativeTickerMapper, coinflexTradesMapper } from './coinflex'
+import { CryptoComBookChangeMapper, CryptoComBookTickerMapper, CryptoComDerivativeTickerMapper, CryptoComTradesMapper } from './cryptocom'
 import {
   cryptofacilitiesBookChangeMapper,
   CryptofacilitiesDerivativeTickerMapper,
@@ -83,7 +85,7 @@ import {
   OkexV5TradesMapper
 } from './okex'
 import { phemexBookChangeMapper, PhemexDerivativeTickerMapper, phemexTradesMapper } from './phemex'
-import { PoloniexBookChangeMapper, PoloniexTradesMapper } from './poloniex'
+import { PoloniexBookChangeMapper, PoloniexTradesMapper, PoloniexV2BookChangeMapper, PoloniexV2TradesMapper } from './poloniex'
 import { SerumBookChangeMapper, SerumBookTickerMapper, SerumTradesMapper } from './serum'
 import { UpbitBookChangeMapper, UpbitTradesMapper } from './upbit'
 
@@ -108,6 +110,12 @@ const canUseOkexTbtBookTicker = (localTimestamp: Date) => {
   return isRealTime(localTimestamp) || localTimestamp.valueOf() >= OKEX_V5_TBT_BOOK_TICKER_RELEASE_DATE.valueOf()
 }
 
+const POLONIEX_V2_API_SWITCH_DATE = new Date('2022-08-02T00:00:00.000Z')
+
+const shouldUsePoloniexV2Mappers = (localTimestamp: Date) => {
+  return isRealTime(localTimestamp) || localTimestamp.valueOf() >= POLONIEX_V2_API_SWITCH_DATE.valueOf()
+}
+
 const tradesMappers = {
   bitmex: () => bitmexTradesMapper,
   binance: () => new BinanceTradesMapper('binance'),
@@ -151,14 +159,19 @@ const tradesMappers = {
   delta: (localTimestamp: Date) => new DeltaTradesMapper(localTimestamp.valueOf() >= new Date('2020-10-14').valueOf()),
   'gate-io': () => new GateIOTradesMapper('gate-io'),
   'gate-io-futures': () => new GateIOFuturesTradesMapper('gate-io-futures'),
-  poloniex: () => new PoloniexTradesMapper(),
+  poloniex: (localTimestamp: Date) =>
+    shouldUsePoloniexV2Mappers(localTimestamp) ? new PoloniexV2TradesMapper() : new PoloniexTradesMapper(),
   coinflex: () => coinflexTradesMapper,
   'binance-options': () => new BinanceOptionsTradesMapper(),
   upbit: () => new UpbitTradesMapper(),
   ascendex: () => new AscendexTradesMapper(),
   dydx: () => new DydxTradesMapper(),
   serum: () => new SerumTradesMapper('serum'),
-  'star-atlas': () => new SerumTradesMapper('star-atlas')
+  'star-atlas': () => new SerumTradesMapper('star-atlas'),
+  mango: () => new SerumTradesMapper('mango'),
+  'bybit-spot': () => new BybitSpotTradesMapper('bybit-spot'),
+  'crypto-com': () => new CryptoComTradesMapper('crypto-com'),
+  'crypto-com-derivatives': () => new CryptoComTradesMapper('crypto-com-derivatives')
 }
 
 const bookChangeMappers = {
@@ -208,7 +221,7 @@ const bookChangeMappers = {
   'huobi-dm-swap': () => new HuobiBookChangeMapper('huobi-dm-swap'),
   'huobi-dm-linear-swap': () => new HuobiBookChangeMapper('huobi-dm-linear-swap'),
   'huobi-dm-options': () => new HuobiBookChangeMapper('huobi-dm-options'),
-
+  'bybit-spot': () => new BybitSpotBookChangeMapper('bybit-spot'),
   bybit: () => new BybitBookChangeMapper('bybit', false),
   okcoin: (localTimestamp: Date) =>
     new OkexBookChangeMapper('okcoin', 'spot', localTimestamp.valueOf() >= new Date('2020-02-13').valueOf()),
@@ -217,14 +230,18 @@ const bookChangeMappers = {
   delta: () => deltaBookChangeMapper,
   'gate-io': () => new GateIOBookChangeMapper('gate-io'),
   'gate-io-futures': () => new GateIOFuturesBookChangeMapper('gate-io-futures'),
-  poloniex: () => new PoloniexBookChangeMapper(),
+  poloniex: (localTimestamp: Date) =>
+    shouldUsePoloniexV2Mappers(localTimestamp) ? new PoloniexV2BookChangeMapper() : new PoloniexBookChangeMapper(),
   coinflex: () => coinflexBookChangeMapper,
   'binance-options': () => new BinanceOptionsBookChangeMapper(),
   upbit: () => new UpbitBookChangeMapper(),
   ascendex: () => new AscendexBookChangeMapper(),
   dydx: () => new DydxBookChangeMapper(),
   serum: () => new SerumBookChangeMapper('serum'),
-  'star-atlas': () => new SerumBookChangeMapper('star-atlas')
+  'star-atlas': () => new SerumBookChangeMapper('star-atlas'),
+  mango: () => new SerumBookChangeMapper('mango'),
+  'crypto-com': () => new CryptoComBookChangeMapper('crypto-com'),
+  'crypto-com-derivatives': () => new CryptoComBookChangeMapper('crypto-com-derivatives')
 }
 
 const derivativeTickersMappers = {
@@ -252,7 +269,8 @@ const derivativeTickersMappers = {
   'gate-io-futures': () => new GateIOFuturesDerivativeTickerMapper(),
   coinflex: () => new CoinflexDerivativeTickerMapper(),
   ascendex: () => new AscendexDerivativeTickerMapper(),
-  dydx: () => new DydxDerivativeTickerMapper()
+  dydx: () => new DydxDerivativeTickerMapper(),
+  'crypto-com-derivatives': () => new CryptoComDerivativeTickerMapper('crypto-com-derivatives')
 }
 
 const optionsSummaryMappers = {
@@ -327,7 +345,11 @@ const bookTickersMappers = {
   okcoin: () => new OkexBookTickerMapper('okcoin', 'spot'),
   serum: () => new SerumBookTickerMapper('serum'),
   'star-atlas': () => new SerumBookTickerMapper('star-atlas'),
-  'gate-io-futures': () => new GateIOFuturesBookTickerMapper('gate-io-futures')
+  mango: () => new SerumBookTickerMapper('mango'),
+  'gate-io-futures': () => new GateIOFuturesBookTickerMapper('gate-io-futures'),
+  'bybit-spot': () => new BybitSpotBookTickerMapper('bybit-spot'),
+  'crypto-com': () => new CryptoComBookTickerMapper('crypto-com'),
+  'crypto-com-derivatives': () => new CryptoComBookTickerMapper('crypto-com-derivatives')
 }
 
 export const normalizeTrades = <T extends keyof typeof tradesMappers>(exchange: T, localTimestamp: Date): Mapper<T, Trade> => {

package/src/mappers/poloniex.ts

@@ -2,12 +2,87 @@ import { upperCaseSymbols } from '../handy'
 import { BookChange, Trade } from '../types'
 import { Mapper } from './mapper'
 
-// https://docs.poloniex.com/#websocket-api
+export class PoloniexV2TradesMapper implements Mapper<'poloniex', Trade> {
+  canHandle(message: any) {
+    return message.channel === 'trades' && message.data !== undefined && message.data.length > 0
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'trades',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: PoloniexV2TradesMessage, localTimestamp: Date): IterableIterator<Trade> {
+    for (const item of message.data) {
+      yield {
+        type: 'trade',
+        symbol: item.symbol,
+        exchange: 'poloniex',
+        id: item.id,
+        price: Number(item.price),
+        amount: Number(item.quantity),
+        side: item.takerSide === 'sell' ? 'sell' : 'buy',
+        timestamp: new Date(item.createTime),
+        localTimestamp: localTimestamp
+      }
+    }
+  }
+}
+
+const mapBookLevelV2 = (level: [string, string]) => {
+  return {
+    price: Number(level[0]),
+    amount: Number(level[1])
+  }
+}
+export class PoloniexV2BookChangeMapper implements Mapper<'poloniex', BookChange> {
+  canHandle(message: any) {
+    return message.channel === 'book_lv2' && message.data !== undefined && message.data.length > 0
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'book_lv2',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: PoloniexV2BookMessage, localTimestamp: Date): IterableIterator<BookChange> {
+    for (const item of message.data) {
+      const bookSnapshot: BookChange = {
+        type: 'book_change',
+        symbol: item.symbol,
+        exchange: 'poloniex',
+        isSnapshot: message.action === 'snapshot',
+        bids: item.bids.map(mapBookLevelV2),
+        asks: item.asks.map(mapBookLevelV2),
+        timestamp: new Date(item.ts),
+        localTimestamp: localTimestamp
+      }
+
+      yield bookSnapshot
+    }
+  }
+}
 
 export class PoloniexTradesMapper implements Mapper<'poloniex', Trade> {
   private readonly _channelIdToSymbolMap: Map<number, string> = new Map()
 
   canHandle(message: PoloniexPriceAggreatedMessage) {
+    if (Array.isArray(message) === false) {
+      return false
+    }
+
     if (message.length < 3) {
       return false
     }
@@ -80,6 +155,10 @@ export class PoloniexBookChangeMapper implements Mapper<'poloniex', BookChange>
   private readonly _channelIdToSymbolMap: Map<number, string> = new Map()
 
   canHandle(message: PoloniexPriceAggreatedMessage) {
+    if (Array.isArray(message) === false) {
+      return false
+    }
+
     if (message.length < 3) {
       return false
     }
@@ -153,3 +232,57 @@ type PoloniexBookUpdate = ['o', 0 | 1, string, string]
 type PoloniexTrade = ['t', string, 1 | 0, string, string, number]
 
 type PoloniexPriceAggreatedMessage = [number, number, (PoloniexBookSnapshot | PoloniexBookUpdate | PoloniexTrade)[], string?]
+
+type PoloniexV2SubscribeMessage = {
+  event: 'subscribe'
+  channel: 'trades'
+  symbols: string[]
+}
+
+type PoloniexV2TradesMessage = {
+  channel: 'trades'
+  data: [
+    {
+      symbol: 'USDD_USDT'
+      amount: '53.17153856'
+      quantity: '53.0866'
+      takerSide: 'sell'
+      createTime: 1659916859838
+      price: '1.0016'
+      id: '60100203'
+      ts: 1659916859843
+    }
+  ]
+}
+
+type PoloniexV2BookMessage =
+  | {
+      channel: 'book_lv2'
+      data: [
+        {
+          symbol: 'AAVE_BTC'
+          createTime: 1659916859818
+          asks: [string, string][]
+          bids: [string, string][]
+          lastId: 20251
+          id: 20252
+          ts: 1659916859824
+        }
+      ]
+      action: 'update'
+    }
+  | {
+      channel: 'book_lv2'
+      data: [
+        {
+          symbol: 'AAVE_BTC'
+          createTime: 1659900600092
+          asks: [string, string][]
+          bids: [string, string][]
+          lastId: 85
+          id: 86
+          ts: 1659916800614
+        }
+      ]
+      action: 'snapshot'
+    }