tardis-dev 13.29.16 → 13.31.0

package/src/mappers/dydxv4.ts

@@ -0,0 +1,339 @@
+import { upperCaseSymbols } from '../handy'
+import { BookChange, DerivativeTicker, Liquidation, Trade } from '../types'
+import { Mapper, PendingTickerInfoHelper } from './mapper'
+
+export class DydxV4TradesMapper implements Mapper<'dydx-v4', Trade> {
+  canHandle(message: DyDxTrade) {
+    return message.channel === 'v4_trades' && message.type === 'channel_data'
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'v4_trades',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: DyDxTrade, localTimestamp: Date): IterableIterator<Trade> {
+    for (let trade of message.contents.trades) {
+      yield {
+        type: 'trade',
+        symbol: message.id,
+        exchange: 'dydx-v4',
+        id: trade.id,
+        price: Number(trade.price),
+        amount: Number(trade.size),
+        side: trade.side === 'SELL' ? 'sell' : 'buy',
+        timestamp: trade.createdAt ? new Date(trade.createdAt) : localTimestamp,
+        localTimestamp: localTimestamp
+      }
+    }
+  }
+}
+
+function mapSnapshotPriceLevel(level: { price: string; size: string }) {
+  return {
+    price: Number(level.price),
+    amount: Number(level.size)
+  }
+}
+
+function mapUpdatePriceLevel(level: [string, string]) {
+  return {
+    price: Number(level[0]),
+    amount: Number(level[1])
+  }
+}
+export class DydxV4BookChangeMapper implements Mapper<'dydx-v4', BookChange> {
+  canHandle(message: DyDxOrderbookSnapshot | DyDxOrderBookUpdate) {
+    return message.channel === 'v4_orderbook'
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'v4_orderbook',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: DyDxOrderbookSnapshot | DyDxOrderBookUpdate, localTimestamp: Date): IterableIterator<BookChange> {
+    if (message.type === 'subscribed') {
+      yield {
+        type: 'book_change',
+        symbol: message.id,
+        exchange: 'dydx-v4',
+        isSnapshot: true,
+        bids: message.contents.bids.map(mapSnapshotPriceLevel),
+        asks: message.contents.asks.map(mapSnapshotPriceLevel),
+        timestamp: localTimestamp,
+        localTimestamp
+      }
+    } else {
+      if (!message.contents) {
+        return
+      }
+
+      const bookChange: BookChange = {
+        type: 'book_change',
+        symbol: message.id,
+        exchange: 'dydx-v4',
+        isSnapshot: false,
+        bids: message.contents.bids !== undefined ? message.contents.bids.map(mapUpdatePriceLevel) : [],
+        asks: message.contents.asks !== undefined ? message.contents.asks.map(mapUpdatePriceLevel) : [],
+        timestamp: localTimestamp,
+        localTimestamp
+      }
+
+      if (bookChange.bids.length > 0 || bookChange.asks.length > 0) {
+        yield bookChange
+      }
+    }
+  }
+}
+
+export class DydxV4DerivativeTickerMapper implements Mapper<'dydx-v4', DerivativeTicker> {
+  private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
+
+  canHandle(message: DydxMarketsSnapshot | DyDxMarketsUpdate | DyDxTrade) {
+    return message.channel === 'v4_markets' || (message.channel === 'v4_trades' && message.type === 'channel_data')
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'v4_markets',
+        symbols: [] as string[]
+      } as const,
+      {
+        channel: 'v4_trades',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: DydxMarketsSnapshot | DyDxMarketsUpdate | DyDxTrade, localTimestamp: Date): IterableIterator<DerivativeTicker> {
+    if (message.channel === 'v4_trades') {
+      const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(message.id, 'dydx-v4')
+      pendingTickerInfo.updateLastPrice(Number(message.contents.trades[message.contents.trades.length - 1].price))
+
+      return
+    }
+    if (message.type === 'subscribed' || (message.type === 'channel_data' && message.contents.trading !== undefined)) {
+      const contents = message.type === 'subscribed' ? message.contents.markets : message.contents.trading
+      for (const key in contents) {
+        const marketInfo = (contents as any)[key] as DydxMarketsSnapshotContent | DydxMarketTradeUpdate
+
+        const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(key, 'dydx-v4')
+
+        if (marketInfo.oraclePrice !== undefined) {
+          pendingTickerInfo.updateMarkPrice(Number(marketInfo.oraclePrice))
+        }
+        if (marketInfo.openInterest !== undefined) {
+          pendingTickerInfo.updateOpenInterest(Number(marketInfo.openInterest))
+        }
+
+        if (marketInfo.nextFundingRate !== undefined) {
+          pendingTickerInfo.updateFundingRate(Number(marketInfo.nextFundingRate))
+        }
+
+        pendingTickerInfo.updateTimestamp(localTimestamp)
+
+        if (pendingTickerInfo.hasChanged()) {
+          yield pendingTickerInfo.getSnapshot(localTimestamp)
+        }
+      }
+    }
+
+    if (message.type === 'channel_data' && message.contents.oraclePrices !== undefined) {
+      for (const key in message.contents.oraclePrices) {
+        const oraclePriceInfo = (message.contents.oraclePrices as any)[key] as OraclePriceInfo
+        const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(key, 'dydx-v4')
+        if (oraclePriceInfo.oraclePrice !== undefined) {
+          pendingTickerInfo.updateMarkPrice(Number(oraclePriceInfo.oraclePrice))
+        }
+        pendingTickerInfo.updateTimestamp(localTimestamp)
+
+        if (pendingTickerInfo.hasChanged()) {
+          yield pendingTickerInfo.getSnapshot(localTimestamp)
+        }
+      }
+    }
+  }
+}
+
+export class DydxV4LiquidationsMapper implements Mapper<'dydx-v4', Liquidation> {
+  canHandle(message: DyDxTrade) {
+    return message.channel === 'v4_trades' && message.type === 'channel_data'
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = upperCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'v4_trades',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: DyDxTrade, localTimestamp: Date): IterableIterator<Liquidation> {
+    for (let trade of message.contents.trades) {
+      if (trade.type === 'LIQUIDATED') {
+        yield {
+          type: 'liquidation',
+          symbol: message.id,
+          exchange: 'dydx-v4',
+          id: trade.id,
+          price: Number(trade.price),
+          amount: Number(trade.size),
+          side: trade.side === 'SELL' ? 'sell' : 'buy',
+          timestamp: trade.createdAt ? new Date(trade.createdAt) : localTimestamp,
+          localTimestamp: localTimestamp
+        }
+      }
+    }
+  }
+}
+
+type DyDxTrade = {
+  type: 'channel_data'
+  connection_id: '3a2e4c0c-7579-4bf6-a570-e0979418bbe9'
+  message_id: 15897
+  id: 'BTC-USD'
+  channel: 'v4_trades'
+  version: '2.1.0'
+  contents: {
+    trades: [
+      {
+        id: '0165e6170000000200000002'
+        size: '0.0001'
+        price: '60392'
+        side: 'BUY' | 'SELL'
+        createdAt: '2024-08-23T00:00:57.627Z'
+        type: 'LIMIT' | 'LIQUIDATED'
+      }
+    ]
+  }
+}
+
+type DyDxOrderbookSnapshot = {
+  type: 'subscribed'
+  connection_id: '67838890-75de-4bf3-a638-d7bcdea5f245'
+  message_id: 7
+  channel: 'v4_orderbook'
+  id: 'GRT-USD'
+  contents: {
+    bids: [{ price: '0.1547'; size: '35520' }]
+    asks: [{ price: '0.155'; size: '3220' }]
+  }
+}
+
+type DyDxOrderBookUpdate = {
+  type: 'channel_data'
+  connection_id: '00908030-4a70-43aa-9263-8ccdf57b5d40'
+  message_id: 10290
+  id: 'EOS-USD'
+  channel: 'v4_orderbook'
+  version: '1.0.0'
+  contents: { bids: [['0.1003', '2017130']]; asks: undefined | [['0.1003', '2017130']] }
+}
+
+type DydxMarketsSnapshot = {
+  type: 'subscribed'
+  connection_id: '3a2e4c0c-7579-4bf6-a570-e0979418bbe9'
+  message_id: 17
+  channel: 'v4_markets'
+  contents: {
+    markets: {
+      [key: string]: DydxMarketsSnapshotContent
+    }
+  }
+}
+type DydxMarketsSnapshotContent = {
+  clobPairId: '0'
+  ticker: 'BTC-USD'
+  status: 'ACTIVE'
+  oraclePrice: '60387.51779'
+  priceChange24H: '-782.58326'
+  volume24H: '247515340.0835'
+  trades24H: 73556
+  nextFundingRate: '0.00001351666666666667'
+  initialMarginFraction: '0.05'
+  maintenanceMarginFraction: '0.03'
+  openInterest: '648.2389'
+  atomicResolution: -10
+  quantumConversionExponent: -9
+  tickSize: '1'
+  stepSize: '0.0001'
+  stepBaseQuantums: 1000000
+  subticksPerTick: 100000
+  marketType: 'CROSS'
+  openInterestLowerCap: '0'
+  openInterestUpperCap: '0'
+  baseOpenInterest: '648.4278'
+}
+
+type DyDxMarketsUpdate =
+  | {
+      type: 'channel_data'
+      connection_id: '3a2e4c0c-7579-4bf6-a570-e0979418bbe9'
+      message_id: 15871
+      channel: 'v4_markets'
+      version: '1.0.0'
+      contents: {
+        oraclePrices: undefined
+        trading: {
+          'ETH-USD': DydxMarketTradeUpdate
+        }
+      }
+    }
+  | {
+      type: 'channel_data'
+      connection_id: '3a2e4c0c-7579-4bf6-a570-e0979418bbe9'
+      message_id: 50
+      channel: 'v4_markets'
+      version: '1.0.0'
+      contents: {
+        trading: undefined
+        oraclePrices: {
+          'ZERO-USD': OraclePriceInfo
+        }
+      }
+    }
+
+type OraclePriceInfo = { oraclePrice: string; effectiveAt: string; effectiveAtHeight: string; marketId: number }
+
+type DydxMarketTradeUpdate = {
+  id?: string
+  clobPairId?: string
+  ticker?: string
+  marketId?: number
+  oraclePrice: undefined
+  baseAsset?: string
+  quoteAsset?: string
+  initialMarginFraction?: string
+  maintenanceMarginFraction?: string
+  basePositionSize?: string
+  incrementalPositionSize?: string
+  maxPositionSize?: string
+  openInterest?: string
+  quantumConversionExponent?: number
+  atomicResolution?: number
+  subticksPerTick?: number
+  stepBaseQuantums?: number
+  priceChange24H?: string
+  volume24H?: string
+  trades24H?: number
+  nextFundingRate?: string
+}

package/src/mappers/index.ts

@@ -24,6 +24,7 @@ import {
   BitfinexTradesMapper
 } from './bitfinex'
 import { BitflyerBookChangeMapper, bitflyerBookTickerMapper, bitflyerTradesMapper } from './bitflyer'
+import { BitgetBookChangeMapper, BitgetBookTickerMapper, BitgetDerivativeTickerMapper, BitgetTradesMapper } from './bitget'
 import {
   BitmexBookChangeMapper,
   BitmexDerivativeTickerMapper,
@@ -67,6 +68,7 @@ import {
   deribitTradesMapper
 } from './deribit'
 import { DydxBookChangeMapper, DydxDerivativeTickerMapper, DydxTradesMapper } from './dydx'
+import { DydxV4BookChangeMapper, DydxV4DerivativeTickerMapper, DydxV4LiquidationsMapper, DydxV4TradesMapper } from './dydxv4'
 import { FTXBookChangeMapper, FTXDerivativeTickerMapper, FTXLiquidationsMapper, FTXBookTickerMapper, FTXTradesMapper } from './ftx'
 import {
   GateIOBookChangeMapper,
@@ -255,6 +257,7 @@ const tradesMappers = {
   upbit: () => new UpbitTradesMapper(),
   ascendex: () => new AscendexTradesMapper(),
   dydx: () => new DydxTradesMapper(),
+  'dydx-v4': () => new DydxV4TradesMapper(),
   serum: () => new SerumTradesMapper('serum'),
   'star-atlas': () => new SerumTradesMapper('star-atlas'),
   mango: () => new SerumTradesMapper('mango'),
@@ -269,7 +272,9 @@ const tradesMappers = {
   'blockchain-com': () => new BlockchainComTradesMapper(),
   'bybit-options': () => new BybitV5TradesMapper('bybit-options'),
   'binance-european-options': () => new BinanceEuropeanOptionsTradesMapper(),
-  'okex-spreads': () => new OkexSpreadsTradesMapper()
+  'okex-spreads': () => new OkexSpreadsTradesMapper(),
+  bitget: () => new BitgetTradesMapper('bitget'),
+  'bitget-futures': () => new BitgetTradesMapper('bitget-futures')
 }
 
 const bookChangeMappers = {
@@ -344,6 +349,7 @@ const bookChangeMappers = {
   upbit: () => new UpbitBookChangeMapper(),
   ascendex: () => new AscendexBookChangeMapper(),
   dydx: () => new DydxBookChangeMapper(),
+  'dydx-v4': () => new DydxV4BookChangeMapper(),
   serum: () => new SerumBookChangeMapper('serum'),
   'star-atlas': () => new SerumBookChangeMapper('star-atlas'),
   mango: () => new SerumBookChangeMapper('mango'),
@@ -356,7 +362,9 @@ const bookChangeMappers = {
   'blockchain-com': () => new BlockchainComBookChangeMapper(),
   'bybit-options': () => new BybitV5BookChangeMapper('bybit-options', 25),
   'binance-european-options': () => new BinanceEuropeanOptionsBookChangeMapper(),
-  'okex-spreads': () => new OkexSpreadsBookChangeMapper()
+  'okex-spreads': () => new OkexSpreadsBookChangeMapper(),
+  bitget: () => new BitgetBookChangeMapper('bitget'),
+  'bitget-futures': () => new BitgetBookChangeMapper('bitget-futures')
 }
 
 const derivativeTickersMappers = {
@@ -386,10 +394,12 @@ const derivativeTickersMappers = {
   coinflex: () => new CoinflexDerivativeTickerMapper(),
   ascendex: () => new AscendexDerivativeTickerMapper(),
   dydx: () => new DydxDerivativeTickerMapper(),
+  'dydx-v4': () => new DydxV4DerivativeTickerMapper(),
   'crypto-com-derivatives': () => new CryptoComDerivativeTickerMapper('crypto-com-derivatives'),
   'crypto-com': () => new CryptoComDerivativeTickerMapper('crypto-com'),
   'woo-x': () => new WooxDerivativeTickerMapper(),
-  'kucoin-futures': () => new KucoinFuturesDerivativeTickerMapper()
+  'kucoin-futures': () => new KucoinFuturesDerivativeTickerMapper(),
+  'bitget-futures': () => new BitgetDerivativeTickerMapper()
 }
 
 const optionsSummaryMappers = {
@@ -411,6 +421,7 @@ const liquidationsMappers = {
   'bitfinex-derivatives': () => new BitfinexLiquidationsMapper('bitfinex-derivatives'),
   cryptofacilities: () => cryptofacilitiesLiquidationsMapper,
   'huobi-dm': () => new HuobiLiquidationsMapper('huobi-dm'),
+  'dydx-v4': () => new DydxV4LiquidationsMapper(),
   'huobi-dm-swap': () => new HuobiLiquidationsMapper('huobi-dm-swap'),
   'huobi-dm-linear-swap': () => new HuobiLiquidationsMapper('huobi-dm-linear-swap'),
   bybit: (localTimestamp: Date) =>
@@ -480,7 +491,9 @@ const bookTickersMappers = {
   bybit: () => new BybitV5BookTickerMapper('bybit'),
   'gate-io': () => new GateIOV4BookTickerMapper('gate-io'),
   'okex-spreads': () => new OkexSpreadsBookTickerMapper(),
-  'kucoin-futures': () => new KucoinFuturesBookTickerMapper()
+  'kucoin-futures': () => new KucoinFuturesBookTickerMapper(),
+  bitget: () => new BitgetBookTickerMapper('bitget'),
+  'bitget-futures': () => new BitgetBookTickerMapper('bitget-futures')
 }
 
 export const normalizeTrades = <T extends keyof typeof tradesMappers>(exchange: T, localTimestamp: Date): Mapper<T, Trade> => {

package/src/realtimefeeds/bitget.ts

@@ -0,0 +1,59 @@
+import { batchObjects } from '../handy'
+import { Filter } from '../types'
+import { RealTimeFeedBase } from './realtimefeed'
+
+abstract class BitgetRealTimeFeedBase extends RealTimeFeedBase {
+  protected throttleSubscribeMS = 100
+  protected readonly wssURL = 'wss://ws.bitget.com/v2/ws/public'
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    const argsInputs = filters.flatMap((filter) => {
+      if (!filter.symbols || filter.symbols.length === 0) {
+        throw new Error('BitgetRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+      }
+
+      return filter.symbols.map((symbol) => {
+        return {
+          instType: this.getInstType(symbol),
+          channel: filter.channel,
+          instId: symbol
+        }
+      })
+    })
+
+    const payload = [...batchObjects(argsInputs, 5)].map((args) => {
+      return {
+        op: 'subscribe',
+        args
+      }
+    })
+
+    return payload
+  }
+
+  protected messageIsError(message: any): boolean {
+    return message.event === 'error'
+  }
+
+  abstract getInstType(symbol: string): string
+}
+
+export class BitgetRealTimeFeed extends BitgetRealTimeFeedBase {
+  getInstType(_: string) {
+    return 'SPOT'
+  }
+}
+
+export class BitgetFuturesRealTimeFeed extends BitgetRealTimeFeedBase {
+  getInstType(symbol: string) {
+    if (symbol.endsWith('USDT')) {
+      return 'USDT-FUTURES'
+    }
+
+    if (symbol.endsWith('PERP')) {
+      return 'USDC-FUTURES'
+    }
+
+    return 'COIN-FUTURES'
+  }
+}

package/src/realtimefeeds/dydx_v4.ts

@@ -0,0 +1,39 @@
+import { Filter } from '../types'
+import { RealTimeFeedBase } from './realtimefeed'
+
+export class DydxV4RealTimeFeed extends RealTimeFeedBase {
+  protected readonly wssURL = 'wss://indexer.dydx.trade/v4/ws'
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    const subs = filters
+      .map((filter) => {
+        if (filter.channel === 'v4_markets') {
+          return [
+            {
+              type: 'subscribe',
+              channel: 'v4_markets'
+            }
+          ]
+        }
+
+        if (!filter.symbols || filter.symbols.length === 0) {
+          throw new Error('DydxV4RealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+        }
+
+        return filter.symbols.map((symbol) => {
+          return {
+            type: 'subscribe',
+            channel: filter.channel,
+            id: symbol
+          }
+        })
+      })
+      .flatMap((f) => f)
+
+    return subs
+  }
+
+  protected messageIsError(message: any): boolean {
+    return message.type === 'error'
+  }
+}

package/src/realtimefeeds/index.ts

@@ -49,6 +49,8 @@ import { BlockchainComRealTimeFeed } from './blockchaincom'
 import { BinanceEuropeanOptionsRealTimeFeed } from './binanceeuropeanoptions'
 import { OkexSpreadsRealTimeFeed } from './okexspreads'
 import { KucoinFuturesRealTimeFeed } from './kucoinfutures'
+import { DydxV4RealTimeFeed } from './dydx_v4'
+import { BitgetFuturesRealTimeFeed, BitgetRealTimeFeed } from './bitget'
 
 export * from './realtimefeed'
 
@@ -108,7 +110,10 @@ const realTimeFeedsMap: {
   'blockchain-com': BlockchainComRealTimeFeed,
   'binance-european-options': BinanceEuropeanOptionsRealTimeFeed,
   'okex-spreads': OkexSpreadsRealTimeFeed,
-  'kucoin-futures': KucoinFuturesRealTimeFeed
+  'kucoin-futures': KucoinFuturesRealTimeFeed,
+  'dydx-v4': DydxV4RealTimeFeed,
+  bitget: BitgetRealTimeFeed,
+  'bitget-futures': BitgetFuturesRealTimeFeed
 }
 
 export function getRealTimeFeedFactory(exchange: Exchange): RealTimeFeed {