tardis-dev 13.4.11 → 13.5.0

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,
@@ -166,7 +168,10 @@ const tradesMappers = {
   dydx: () => new DydxTradesMapper(),
   serum: () => new SerumTradesMapper('serum'),
   'star-atlas': () => new SerumTradesMapper('star-atlas'),
-  mango: () => new SerumTradesMapper('mango')
+  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 = {
@@ -216,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()),
@@ -234,7 +239,9 @@ const bookChangeMappers = {
   dydx: () => new DydxBookChangeMapper(),
   serum: () => new SerumBookChangeMapper('serum'),
   'star-atlas': () => new SerumBookChangeMapper('star-atlas'),
-  mango: () => new SerumBookChangeMapper('mango')
+  mango: () => new SerumBookChangeMapper('mango'),
+  'crypto-com': () => new CryptoComBookChangeMapper('crypto-com'),
+  'crypto-com-derivatives': () => new CryptoComBookChangeMapper('crypto-com-derivatives')
 }
 
 const derivativeTickersMappers = {
@@ -262,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 = {
@@ -338,7 +346,10 @@ const bookTickersMappers = {
   serum: () => new SerumBookTickerMapper('serum'),
   'star-atlas': () => new SerumBookTickerMapper('star-atlas'),
   mango: () => new SerumBookTickerMapper('mango'),
-  'gate-io-futures': () => new GateIOFuturesBookTickerMapper('gate-io-futures')
+  '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/realtimefeeds/ascendex.ts

@@ -38,6 +38,14 @@ export class AscendexRealTimeFeed extends RealTimeFeedBase {
     return message.m === 'error'
   }
 
+  protected sendCustomPing = () => {
+    this.send({ op: 'ping' })
+  }
+
+  protected messageIsHeartbeat(msg: any) {
+    return msg.m === 'pong'
+  }
+
   protected async provideManualSnapshots(filters: Filter<string>[], shouldCancel: () => boolean) {
     const depthSnapshotChannel = filters.find((f) => f.channel === 'depth-snapshot-realtime')
     if (!depthSnapshotChannel) {

package/src/realtimefeeds/bybit.ts

@@ -90,4 +90,12 @@ class BybitSingleConnectionRealTimeDataFeed extends RealTimeFeedBase {
   protected messageIsError(message: any): boolean {
     return message.success === false
   }
+
+  protected sendCustomPing = () => {
+    this.send({ op: 'ping' })
+  }
+
+  protected messageIsHeartbeat(msg: any) {
+    return msg.ret_msg === 'pong' || msg.op == 'pong'
+  }
 }

package/src/realtimefeeds/bybitspot.ts

@@ -0,0 +1,39 @@
+import { Filter } from '../types'
+import { RealTimeFeedBase } from './realtimefeed'
+
+export class BybitSpotRealTimeFeed extends RealTimeFeedBase {
+  protected wssURL = 'wss://stream.bybit.com/spot/quote/ws/v2'
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    return filters
+      .map((filter) => {
+        if (!filter.symbols || filter.symbols.length === 0) {
+          throw new Error('BybitSpotRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+        }
+
+        return filter.symbols.map((symbol) => {
+          return {
+            event: 'sub',
+            topic: filter.channel,
+            params: {
+              binary: false,
+              symbol: symbol
+            }
+          }
+        })
+      })
+      .flatMap((c) => c)
+  }
+
+  protected messageIsError(message: any): boolean {
+    return message.code !== undefined && message.code !== '0'
+  }
+
+  protected sendCustomPing = () => {
+    this.send({ ping: new Date().valueOf() })
+  }
+
+  protected messageIsHeartbeat(msg: any) {
+    return msg.pong !== undefined
+  }
+}

package/src/realtimefeeds/cryptocom.ts

@@ -0,0 +1,48 @@
+import { Filter } from '../types'
+import { RealTimeFeedBase } from './realtimefeed'
+
+export class CryptoComRealTimeFeed extends RealTimeFeedBase {
+  protected wssURL = 'wss://stream.crypto.com/v2/market'
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    const channels = filters
+      .map((filter) => {
+        if (!filter.symbols || filter.symbols.length === 0) {
+          throw new Error('CryptoComRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+        }
+
+        return filter.symbols.map((symbol) => {
+          const suffix = filter.channel === 'book' ? '.150' : ''
+          return `${filter.channel}.${symbol}${suffix}`
+        })
+      })
+      .flatMap((s) => s)
+
+    return [
+      {
+        id: 1,
+        method: 'subscribe',
+        nonce: new Date().valueOf(),
+        params: {
+          channels: channels
+        }
+      }
+    ]
+  }
+
+  protected messageIsError(message: any): boolean {
+    return message.code !== undefined && message.code !== 0
+  }
+
+  protected onMessage(msg: any) {
+    if (msg.method === 'public/heartbeat') {
+      this.send({
+        id: msg.id,
+        method: 'public/respond-heartbeat'
+      })
+    }
+  }
+  protected messageIsHeartbeat(msg: any) {
+    return msg.method === 'public/heartbeat'
+  }
+}

package/src/realtimefeeds/cryptocomderivatives.ts

@@ -0,0 +1,50 @@
+import { Filter } from '../types'
+import { RealTimeFeedBase } from './realtimefeed'
+
+export class CryptoComDerivativesRealTimeFeed extends RealTimeFeedBase {
+  protected wssURL = 'wss://deriv-stream.crypto.com/v1/market'
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    const channels = filters
+      .map((filter) => {
+        if (!filter.symbols || filter.symbols.length === 0) {
+          throw new Error('CryptoComDerivativesRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+        }
+
+        return filter.symbols.map((symbol) => {
+          const suffix = filter.channel === 'book' ? '.50' : ''
+          return `${filter.channel}.${symbol}${suffix}`
+        })
+      })
+      .flatMap((s) => s)
+
+    return [
+      {
+        id: 1,
+        method: 'subscribe',
+        nonce: new Date().valueOf(),
+        params: {
+          channels: channels,
+          book_subscription_type: 'SNAPSHOT_AND_UPDATE',
+          book_update_frequency: 5
+        }
+      }
+    ]
+  }
+
+  protected messageIsError(message: any): boolean {
+    return message.code !== undefined && message.code !== 0 && message.code !== 40003
+  }
+
+  protected onMessage(msg: any) {
+    if (msg.method === 'public/heartbeat') {
+      this.send({
+        id: msg.id,
+        method: 'public/respond-heartbeat'
+      })
+    }
+  }
+  protected messageIsHeartbeat(msg: any) {
+    return msg.method === 'public/heartbeat'
+  }
+}

package/src/realtimefeeds/delta.ts

@@ -24,4 +24,12 @@ export class DeltaRealTimeFeed extends RealTimeFeedBase {
   protected messageIsError(message: any): boolean {
     return message.error !== undefined && message.error !== null
   }
+
+  protected sendCustomPing = () => {
+    this.send({ type: 'ping' })
+  }
+
+  protected messageIsHeartbeat(msg: any) {
+    return msg.type === 'pong'
+  }
 }

package/src/realtimefeeds/ftx.ts

@@ -63,6 +63,14 @@ class FtxSingleConnectionRealTimeFeed extends RealTimeFeedBase {
     // ignore market not found errors
     return message.code == 404
   }
+
+  protected sendCustomPing = () => {
+    this.send({ op: 'ping' })
+  }
+
+  protected messageIsHeartbeat(msg: any) {
+    return msg.type === 'pong'
+  }
 }
 
 class FTXInstrumentInfoClient extends PoolingClientBase {

package/src/realtimefeeds/index.ts

@@ -41,6 +41,9 @@ import { DydxRealTimeFeed } from './dydx'
 import { SerumRealTimeFeed } from './serum'
 import { StarAtlasRealTimeFeed } from './staratlas'
 import { MangoRealTimeFeed } from './mango'
+import { BybitSpotRealTimeFeed } from './bybitspot'
+import { CryptoComRealTimeFeed } from './cryptocom'
+import { CryptoComDerivativesRealTimeFeed } from './cryptocomderivatives'
 
 export * from './realtimefeed'
 
@@ -89,7 +92,10 @@ const realTimeFeedsMap: {
   serum: SerumRealTimeFeed,
   'star-atlas': StarAtlasRealTimeFeed,
   'huobi-dm-options': HuobiDMOptionsRealTimeFeed,
-  mango: MangoRealTimeFeed
+  mango: MangoRealTimeFeed,
+  'bybit-spot': BybitSpotRealTimeFeed,
+  'crypto-com': CryptoComRealTimeFeed,
+  'crypto-com-derivatives': CryptoComDerivativesRealTimeFeed
 }
 
 export function getRealTimeFeedFactory(exchange: Exchange): RealTimeFeed {