tardis-dev 12.5.22 → 12.6.7

package/src/mappers/gateio.ts

@@ -1,117 +1,117 @@
-import { BookChange, Exchange, Trade } from '../types'
-import { Mapper } from './mapper'
-
-// https://www.gate.io/docs/websocket/index.html
-
-export class GateIOTradesMapper implements Mapper<'gate-io', Trade> {
-  private readonly _seenSymbols = new Set<string>()
-
-  constructor(private readonly _exchange: Exchange) {}
-
-  canHandle(message: any) {
-    return message.method === 'trades.update'
-  }
-
-  getFilters(symbols?: string[]) {
-    return [
-      {
-        channel: 'trades',
-        symbols
-      } as const
-    ]
-  }
-
-  *map(tradesMessage: GateIOTrades, localTimestamp: Date): IterableIterator<Trade> {
-    const symbol = tradesMessage.params[0]
-
-    // gate io sends trades from newest to oldest for some reason
-    for (const gateIOTrade of tradesMessage.params[1].reverse()) {
-      // always ignore first returned trade as it's a 'stale' trade, which has already been published before disconnect
-      if (this._seenSymbols.has(symbol) === false) {
-        this._seenSymbols.add(symbol)
-        break
-      }
-
-      const timestamp = new Date(gateIOTrade.time * 1000)
-      timestamp.μs = Math.floor(gateIOTrade.time * 1000000) % 1000
-      yield {
-        type: 'trade',
-        symbol,
-        exchange: this._exchange,
-        id: gateIOTrade.id.toString(),
-        price: Number(gateIOTrade.price),
-        amount: Number(gateIOTrade.amount),
-        side: gateIOTrade.type == 'sell' ? 'sell' : 'buy',
-        timestamp,
-        localTimestamp: localTimestamp
-      }
-    }
-  }
-}
-
-const mapBookLevel = (level: GateIODepthLevel) => {
-  const price = Number(level[0])
-  const amount = Number(level[1])
-
-  return { price, amount }
-}
-
-export class GateIOBookChangeMapper implements Mapper<'gate-io', BookChange> {
-  constructor(private readonly _exchange: Exchange) {}
-
-  canHandle(message: any) {
-    return message.method === 'depth.update'
-  }
-
-  getFilters(symbols?: string[]) {
-    return [
-      {
-        channel: 'depth',
-        symbols
-      } as const
-    ]
-  }
-
-  *map(depthMessage: GateIODepth, localTimestamp: Date): IterableIterator<BookChange> {
-    const symbol = depthMessage.params[2]
-    const isSnapshot = depthMessage.params[0]
-    const bids = Array.isArray(depthMessage.params[1].bids) ? depthMessage.params[1].bids : []
-    const asks = Array.isArray(depthMessage.params[1].asks) ? depthMessage.params[1].asks : []
-    yield {
-      type: 'book_change',
-      symbol,
-      exchange: this._exchange,
-      isSnapshot,
-      bids: bids.map(mapBookLevel),
-      asks: asks.map(mapBookLevel),
-      timestamp: localTimestamp,
-      localTimestamp: localTimestamp
-    }
-  }
-}
-
-type GateIOTrade = {
-  id: number
-  time: number
-  price: string
-  amount: string
-  type: 'sell' | 'buy'
-}
-
-type GateIOTrades = {
-  method: 'trades.update'
-  params: [string, GateIOTrade[]]
-}
-type GateIODepthLevel = [string, string]
-
-type GateIODepth = {
-  method: 'depth.update'
-  params: [
-    boolean,
-    {
-      bids?: GateIODepthLevel[]
-      asks?: GateIODepthLevel[]
-    },
-    string
-  ]
-}
+import { BookChange, Exchange, Trade } from '../types'
+import { Mapper } from './mapper'
+
+// https://www.gate.io/docs/websocket/index.html
+
+export class GateIOTradesMapper implements Mapper<'gate-io', Trade> {
+  private readonly _seenSymbols = new Set<string>()
+
+  constructor(private readonly _exchange: Exchange) {}
+
+  canHandle(message: any) {
+    return message.method === 'trades.update'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [
+      {
+        channel: 'trades',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(tradesMessage: GateIOTrades, localTimestamp: Date): IterableIterator<Trade> {
+    const symbol = tradesMessage.params[0]
+
+    // gate io sends trades from newest to oldest for some reason
+    for (const gateIOTrade of tradesMessage.params[1].reverse()) {
+      // always ignore first returned trade as it's a 'stale' trade, which has already been published before disconnect
+      if (this._seenSymbols.has(symbol) === false) {
+        this._seenSymbols.add(symbol)
+        break
+      }
+
+      const timestamp = new Date(gateIOTrade.time * 1000)
+      timestamp.μs = Math.floor(gateIOTrade.time * 1000000) % 1000
+      yield {
+        type: 'trade',
+        symbol,
+        exchange: this._exchange,
+        id: gateIOTrade.id.toString(),
+        price: Number(gateIOTrade.price),
+        amount: Number(gateIOTrade.amount),
+        side: gateIOTrade.type == 'sell' ? 'sell' : 'buy',
+        timestamp,
+        localTimestamp: localTimestamp
+      }
+    }
+  }
+}
+
+const mapBookLevel = (level: GateIODepthLevel) => {
+  const price = Number(level[0])
+  const amount = Number(level[1])
+
+  return { price, amount }
+}
+
+export class GateIOBookChangeMapper implements Mapper<'gate-io', BookChange> {
+  constructor(private readonly _exchange: Exchange) {}
+
+  canHandle(message: any) {
+    return message.method === 'depth.update'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [
+      {
+        channel: 'depth',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(depthMessage: GateIODepth, localTimestamp: Date): IterableIterator<BookChange> {
+    const symbol = depthMessage.params[2]
+    const isSnapshot = depthMessage.params[0]
+    const bids = Array.isArray(depthMessage.params[1].bids) ? depthMessage.params[1].bids : []
+    const asks = Array.isArray(depthMessage.params[1].asks) ? depthMessage.params[1].asks : []
+    yield {
+      type: 'book_change',
+      symbol,
+      exchange: this._exchange,
+      isSnapshot,
+      bids: bids.map(mapBookLevel),
+      asks: asks.map(mapBookLevel),
+      timestamp: localTimestamp,
+      localTimestamp: localTimestamp
+    }
+  }
+}
+
+type GateIOTrade = {
+  id: number
+  time: number
+  price: string
+  amount: string
+  type: 'sell' | 'buy'
+}
+
+type GateIOTrades = {
+  method: 'trades.update'
+  params: [string, GateIOTrade[]]
+}
+type GateIODepthLevel = [string, string]
+
+type GateIODepth = {
+  method: 'depth.update'
+  params: [
+    boolean,
+    {
+      bids?: GateIODepthLevel[]
+      asks?: GateIODepthLevel[]
+    },
+    string
+  ]
+}

package/src/mappers/gateiofutures.ts

@@ -1,185 +1,185 @@
-import { BookChange, Exchange, Trade, DerivativeTicker } from '../types'
-import { Mapper, PendingTickerInfoHelper } from './mapper'
-
-// https://www.gate.io/docs/futures/ws/index.html
-
-export class GateIOFuturesTradesMapper implements Mapper<'gate-io-futures', Trade> {
-  constructor(private readonly _exchange: Exchange) {}
-
-  canHandle(message: any) {
-    return message.channel === 'futures.trades' && message.event === 'update'
-  }
-
-  getFilters(symbols?: string[]) {
-    return [
-      {
-        channel: 'trades',
-        symbols
-      } as const
-    ]
-  }
-
-  *map(tradesMessage: GateIOFuturesTrades, localTimestamp: Date): IterableIterator<Trade> {
-    for (const trade of tradesMessage.result) {
-      const timestamp = new Date(trade.create_time * 1000)
-
-      yield {
-        type: 'trade',
-        symbol: trade.contract,
-        exchange: this._exchange,
-        id: trade.id.toString(),
-        price: Number(trade.price),
-        amount: Math.abs(trade.size),
-        side: trade.size < 0 ? 'sell' : 'buy',
-        timestamp,
-        localTimestamp: localTimestamp
-      }
-    }
-  }
-}
-
-const mapBookLevel = (level: GateIOFuturesSnapshotLevel) => {
-  const price = Number(level.p)
-
-  return { price, amount: Math.abs(level.s) }
-}
-
-export class GateIOFuturesBookChangeMapper implements Mapper<'gate-io-futures', BookChange> {
-  constructor(private readonly _exchange: Exchange) {}
-
-  canHandle(message: GateIOFuturesOrderBookSnapshot | GateIOFuturesOrderBookUpdate) {
-    return message.channel === 'futures.order_book' && (message.event === 'all' || message.event === 'update')
-  }
-
-  getFilters(symbols?: string[]) {
-    return [
-      {
-        channel: 'order_book',
-        symbols
-      } as const
-    ]
-  }
-
-  *map(depthMessage: GateIOFuturesOrderBookSnapshot | GateIOFuturesOrderBookUpdate, localTimestamp: Date): IterableIterator<BookChange> {
-    if (depthMessage.event === 'all') {
-      // snapshot
-      yield {
-        type: 'book_change',
-        symbol: depthMessage.result.contract,
-        exchange: this._exchange,
-        isSnapshot: true,
-        bids: depthMessage.result.bids.map(mapBookLevel),
-        asks: depthMessage.result.asks.map(mapBookLevel),
-        timestamp: new Date(depthMessage.time * 1000),
-        localTimestamp: localTimestamp
-      }
-    } else if (depthMessage.result.length > 0) {
-      // update
-      yield {
-        type: 'book_change',
-        symbol: depthMessage.result[0].c,
-        exchange: this._exchange,
-        isSnapshot: false,
-        bids: depthMessage.result.filter((l) => l.s >= 0).map(mapBookLevel),
-        asks: depthMessage.result.filter((l) => l.s <= 0).map(mapBookLevel),
-        timestamp: new Date(depthMessage.time * 1000),
-        localTimestamp: localTimestamp
-      }
-    }
-  }
-}
-
-export class GateIOFuturesDerivativeTickerMapper implements Mapper<'gate-io-futures', DerivativeTicker> {
-  private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
-
-  canHandle(message: GateIOFuturesTicker) {
-    return message.channel === 'futures.tickers' && message.event === 'update'
-  }
-
-  getFilters(symbols?: string[]) {
-    return [
-      {
-        channel: 'tickers',
-        symbols
-      } as const
-    ]
-  }
-
-  *map(message: GateIOFuturesTicker, localTimestamp: Date): IterableIterator<DerivativeTicker> {
-    for (const futuresTicker of message.result) {
-      if (futuresTicker.contract === undefined) {
-        return
-      }
-      const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(futuresTicker.contract, 'gate-io-futures')
-
-      pendingTickerInfo.updateFundingRate(Number(futuresTicker.funding_rate))
-      pendingTickerInfo.updatePredictedFundingRate(Number(futuresTicker.funding_rate_indicative))
-      pendingTickerInfo.updateIndexPrice(Number(futuresTicker.index_price))
-      pendingTickerInfo.updateMarkPrice(Number(futuresTicker.mark_price))
-      pendingTickerInfo.updateLastPrice(Number(futuresTicker.last))
-      pendingTickerInfo.updateTimestamp(new Date(message.time * 1000))
-
-      if (pendingTickerInfo.hasChanged()) {
-        yield pendingTickerInfo.getSnapshot(localTimestamp)
-      }
-    }
-  }
-}
-
-type GateIOFuturesTrade = {
-  size: number
-  id: number
-  create_time: number
-  price: string
-  contract: string
-}
-
-type GateIOFuturesTrades = {
-  time: number
-  channel: 'futures.trades'
-  event: 'update'
-
-  result: GateIOFuturesTrade[]
-}
-
-type GateIOFuturesSnapshotLevel = { p: string; s: number }
-
-type GateIOFuturesOrderBookSnapshot = {
-  time: number
-  channel: 'futures.order_book'
-  event: 'all'
-
-  result: {
-    contract: string
-    asks: GateIOFuturesSnapshotLevel[]
-    bids: GateIOFuturesSnapshotLevel[]
-  }
-}
-
-type GateIOFuturesOrderBookUpdate = {
-  time: number
-  channel: 'futures.order_book'
-  event: 'update'
-  result: {
-    p: string
-    s: number
-    c: string
-  }[]
-}
-
-type GateIOFuturesTicker = {
-  time: number
-  channel: 'futures.tickers'
-  event: 'update'
-
-  result: [
-    {
-      contract: string
-      last: string
-      funding_rate: string
-      mark_price: string
-      index_price: string
-      funding_rate_indicative: string
-    }
-  ]
-}
+import { BookChange, Exchange, Trade, DerivativeTicker } from '../types'
+import { Mapper, PendingTickerInfoHelper } from './mapper'
+
+// https://www.gate.io/docs/futures/ws/index.html
+
+export class GateIOFuturesTradesMapper implements Mapper<'gate-io-futures', Trade> {
+  constructor(private readonly _exchange: Exchange) {}
+
+  canHandle(message: any) {
+    return message.channel === 'futures.trades' && message.event === 'update'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [
+      {
+        channel: 'trades',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(tradesMessage: GateIOFuturesTrades, localTimestamp: Date): IterableIterator<Trade> {
+    for (const trade of tradesMessage.result) {
+      const timestamp = new Date(trade.create_time * 1000)
+
+      yield {
+        type: 'trade',
+        symbol: trade.contract,
+        exchange: this._exchange,
+        id: trade.id.toString(),
+        price: Number(trade.price),
+        amount: Math.abs(trade.size),
+        side: trade.size < 0 ? 'sell' : 'buy',
+        timestamp,
+        localTimestamp: localTimestamp
+      }
+    }
+  }
+}
+
+const mapBookLevel = (level: GateIOFuturesSnapshotLevel) => {
+  const price = Number(level.p)
+
+  return { price, amount: Math.abs(level.s) }
+}
+
+export class GateIOFuturesBookChangeMapper implements Mapper<'gate-io-futures', BookChange> {
+  constructor(private readonly _exchange: Exchange) {}
+
+  canHandle(message: GateIOFuturesOrderBookSnapshot | GateIOFuturesOrderBookUpdate) {
+    return message.channel === 'futures.order_book' && (message.event === 'all' || message.event === 'update')
+  }
+
+  getFilters(symbols?: string[]) {
+    return [
+      {
+        channel: 'order_book',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(depthMessage: GateIOFuturesOrderBookSnapshot | GateIOFuturesOrderBookUpdate, localTimestamp: Date): IterableIterator<BookChange> {
+    if (depthMessage.event === 'all') {
+      // snapshot
+      yield {
+        type: 'book_change',
+        symbol: depthMessage.result.contract,
+        exchange: this._exchange,
+        isSnapshot: true,
+        bids: depthMessage.result.bids.map(mapBookLevel),
+        asks: depthMessage.result.asks.map(mapBookLevel),
+        timestamp: new Date(depthMessage.time * 1000),
+        localTimestamp: localTimestamp
+      }
+    } else if (depthMessage.result.length > 0) {
+      // update
+      yield {
+        type: 'book_change',
+        symbol: depthMessage.result[0].c,
+        exchange: this._exchange,
+        isSnapshot: false,
+        bids: depthMessage.result.filter((l) => l.s >= 0).map(mapBookLevel),
+        asks: depthMessage.result.filter((l) => l.s <= 0).map(mapBookLevel),
+        timestamp: new Date(depthMessage.time * 1000),
+        localTimestamp: localTimestamp
+      }
+    }
+  }
+}
+
+export class GateIOFuturesDerivativeTickerMapper implements Mapper<'gate-io-futures', DerivativeTicker> {
+  private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
+
+  canHandle(message: GateIOFuturesTicker) {
+    return message.channel === 'futures.tickers' && message.event === 'update'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [
+      {
+        channel: 'tickers',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: GateIOFuturesTicker, localTimestamp: Date): IterableIterator<DerivativeTicker> {
+    for (const futuresTicker of message.result) {
+      if (futuresTicker.contract === undefined) {
+        return
+      }
+      const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(futuresTicker.contract, 'gate-io-futures')
+
+      pendingTickerInfo.updateFundingRate(Number(futuresTicker.funding_rate))
+      pendingTickerInfo.updatePredictedFundingRate(Number(futuresTicker.funding_rate_indicative))
+      pendingTickerInfo.updateIndexPrice(Number(futuresTicker.index_price))
+      pendingTickerInfo.updateMarkPrice(Number(futuresTicker.mark_price))
+      pendingTickerInfo.updateLastPrice(Number(futuresTicker.last))
+      pendingTickerInfo.updateTimestamp(new Date(message.time * 1000))
+
+      if (pendingTickerInfo.hasChanged()) {
+        yield pendingTickerInfo.getSnapshot(localTimestamp)
+      }
+    }
+  }
+}
+
+type GateIOFuturesTrade = {
+  size: number
+  id: number
+  create_time: number
+  price: string
+  contract: string
+}
+
+type GateIOFuturesTrades = {
+  time: number
+  channel: 'futures.trades'
+  event: 'update'
+
+  result: GateIOFuturesTrade[]
+}
+
+type GateIOFuturesSnapshotLevel = { p: string; s: number }
+
+type GateIOFuturesOrderBookSnapshot = {
+  time: number
+  channel: 'futures.order_book'
+  event: 'all'
+
+  result: {
+    contract: string
+    asks: GateIOFuturesSnapshotLevel[]
+    bids: GateIOFuturesSnapshotLevel[]
+  }
+}
+
+type GateIOFuturesOrderBookUpdate = {
+  time: number
+  channel: 'futures.order_book'
+  event: 'update'
+  result: {
+    p: string
+    s: number
+    c: string
+  }[]
+}
+
+type GateIOFuturesTicker = {
+  time: number
+  channel: 'futures.tickers'
+  event: 'update'
+
+  result: [
+    {
+      contract: string
+      last: string
+      funding_rate: string
+      mark_price: string
+      index_price: string
+      funding_rate_indicative: string
+    }
+  ]
+}

package/src/mappers/huobi.ts

@@ -6,7 +6,8 @@ import { asNumberIfValid, CircularBuffer } from '../handy'
 // https://github.com/huobiapi/API_Docs_en/wiki/WS_api_reference_en
 
 export class HuobiTradesMapper
-  implements Mapper<'huobi' | 'huobi-dm' | 'huobi-dm-swap' | 'huobi-dm-linear-swap' | 'huobi-dm-options', Trade> {
+  implements Mapper<'huobi' | 'huobi-dm' | 'huobi-dm-swap' | 'huobi-dm-linear-swap' | 'huobi-dm-options', Trade>
+{
   constructor(private readonly _exchange: Exchange) {}
   canHandle(message: HuobiDataMessage) {
     if (message.ch === undefined) {
@@ -46,7 +47,8 @@ export class HuobiTradesMapper
 }
 
 export class HuobiBookChangeMapper
-  implements Mapper<'huobi' | 'huobi-dm' | 'huobi-dm-swap' | 'huobi-dm-linear-swap' | 'huobi-dm-options', BookChange> {
+  implements Mapper<'huobi' | 'huobi-dm' | 'huobi-dm-swap' | 'huobi-dm-linear-swap' | 'huobi-dm-options', BookChange>
+{
   constructor(protected readonly _exchange: Exchange) {}
 
   canHandle(message: HuobiDataMessage) {