tardis-dev 16.2.0 → 16.2.2

package/src/realtimefeeds/bitget.ts

@@ -4,10 +4,19 @@ import { RealTimeFeedBase } from './realtimefeed.ts'
 
 abstract class BitgetRealTimeFeedBase extends RealTimeFeedBase {
   protected throttleSubscribeMS = 100
-  protected readonly wssURL = 'wss://ws.bitget.com/v2/ws/public'
+  protected readonly wssURL = 'wss://ws.bitget.com/v3/ws/public'
 
   protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
     const argsInputs = filters.flatMap((filter) => {
+      if (filter.channel === 'liquidation') {
+        return this.getLiquidationInstTypes().map((instType) => {
+          return {
+            instType,
+            topic: filter.channel
+          }
+        })
+      }
+
       if (!filter.symbols || filter.symbols.length === 0) {
         throw new Error('BitgetRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
       }
@@ -15,8 +24,8 @@ abstract class BitgetRealTimeFeedBase extends RealTimeFeedBase {
       return filter.symbols.map((symbol) => {
         return {
           instType: this.getInstType(symbol),
-          channel: filter.channel,
-          instId: symbol
+          topic: filter.channel,
+          symbol
         }
       })
     })
@@ -36,24 +45,32 @@ abstract class BitgetRealTimeFeedBase extends RealTimeFeedBase {
   }
 
   abstract getInstType(symbol: string): string
+
+  protected getLiquidationInstTypes(): string[] {
+    return []
+  }
 }
 
 export class BitgetRealTimeFeed extends BitgetRealTimeFeedBase {
   getInstType(_: string) {
-    return 'SPOT'
+    return 'spot'
   }
 }
 
 export class BitgetFuturesRealTimeFeed extends BitgetRealTimeFeedBase {
   getInstType(symbol: string) {
     if (symbol.endsWith('USDT')) {
-      return 'USDT-FUTURES'
+      return 'usdt-futures'
     }
 
     if (symbol.endsWith('PERP')) {
-      return 'USDC-FUTURES'
+      return 'usdc-futures'
     }
 
-    return 'COIN-FUTURES'
+    return 'coin-futures'
+  }
+
+  protected getLiquidationInstTypes() {
+    return ['usdt-futures', 'usdc-futures', 'coin-futures']
   }
 }

package/src/realtimefeeds/bitnomial.ts

@@ -27,20 +27,23 @@ export class BitnomialRealTimeFeed extends RealTimeFeedBase {
           product_codes: filter.symbols
         }
       })
-      .reduce((prev, current) => {
-        const matchingExisting = prev.find((c) => c.name === current.name)
-        if (matchingExisting !== undefined) {
-          for (const symbol of current.product_codes) {
-            if (matchingExisting.product_codes.includes(symbol) === false) {
-              matchingExisting.product_codes.push(symbol)
+      .reduce(
+        (prev, current) => {
+          const matchingExisting = prev.find((c) => c.name === current.name)
+          if (matchingExisting !== undefined) {
+            for (const symbol of current.product_codes) {
+              if (matchingExisting.product_codes.includes(symbol) === false) {
+                matchingExisting.product_codes.push(symbol)
+              }
             }
+          } else {
+            prev.push(current)
           }
-        } else {
-          prev.push(current)
-        }
 
-        return prev
-      }, [] as { name: string; product_codes: string[] }[])
+          return prev
+        },
+        [] as { name: string; product_codes: string[] }[]
+      )
 
     return [
       {

package/src/realtimefeeds/coinbase.ts

@@ -53,20 +53,23 @@ export class CoinbaseRealTimeFeed extends RealTimeFeedBase {
           product_ids: filter.symbols
         }
       })
-      .reduce((prev, current) => {
-        const matchingExisting = prev.find((c) => c.name === current.name)
-        if (matchingExisting !== undefined) {
-          for (const symbol of current.product_ids) {
-            if (matchingExisting.product_ids.includes(symbol) === false) {
-              matchingExisting.product_ids.push(symbol)
+      .reduce(
+        (prev, current) => {
+          const matchingExisting = prev.find((c) => c.name === current.name)
+          if (matchingExisting !== undefined) {
+            for (const symbol of current.product_ids) {
+              if (matchingExisting.product_ids.includes(symbol) === false) {
+                matchingExisting.product_ids.push(symbol)
+              }
             }
+          } else {
+            prev.push(current)
           }
-        } else {
-          prev.push(current)
-        }
 
-        return prev
-      }, [] as { name: string; product_ids: string[] }[])
+          return prev
+        },
+        [] as { name: string; product_ids: string[] }[]
+      )
 
     if (this._hasCredentials) {
       const authParams = this.getAuthParams()

package/src/realtimefeeds/hitbtc.ts

@@ -36,14 +36,17 @@ export class HitBtcRealTimeFeed extends RealTimeFeedBase {
         })
       })
       .flatMap((s) => s)
-      .reduce((prev, current) => {
-        const matchingExisting = prev.find((c) => c.method === current.method && c.symbol === current.symbol)
-        if (matchingExisting === undefined) {
-          prev.push(current)
-        }
+      .reduce(
+        (prev, current) => {
+          const matchingExisting = prev.find((c) => c.method === current.method && c.symbol === current.symbol)
+          if (matchingExisting === undefined) {
+            prev.push(current)
+          }
 
-        return prev
-      }, [] as { method: string; symbol: string }[])
+          return prev
+        },
+        [] as { method: string; symbol: string }[]
+      )
 
     return subscriptions.map((subscription, index) => {
       return {

package/src/realtimefeeds/huobi.ts

@@ -271,7 +271,11 @@ class HuobiOpenInterestClient extends PoolingClientBase {
 }
 
 class HuobiOptionsMarketIndexClient extends PoolingClientBase {
-  constructor(exchange: string, private readonly _httpURL: string, private readonly _instruments: string[]) {
+  constructor(
+    exchange: string,
+    private readonly _httpURL: string,
+    private readonly _instruments: string[]
+  ) {
     super(exchange, 4)
   }
 
@@ -306,7 +310,11 @@ class HuobiOptionsMarketIndexClient extends PoolingClientBase {
 }
 
 class HuobiOptionsIndexClient extends PoolingClientBase {
-  constructor(exchange: string, private readonly _httpURL: string, private readonly _instruments: string[]) {
+  constructor(
+    exchange: string,
+    private readonly _httpURL: string,
+    private readonly _instruments: string[]
+  ) {
     super(exchange, 4)
   }
 

package/src/realtimefeeds/kucoinfutures.ts

@@ -109,7 +109,10 @@ export class KucoinFuturesSingleConnectionRealTimeFeed extends RealTimeFeedBase
 }
 
 class KucoinFuturesContractDetailsClient extends PoolingClientBase {
-  constructor(exchange: string, private readonly _httpURL: string) {
+  constructor(
+    exchange: string,
+    private readonly _httpURL: string
+  ) {
     super(exchange, 6)
   }
 

package/src/realtimefeeds/realtimefeed.ts

@@ -377,7 +377,11 @@ export abstract class PoolingClientBase implements RealTimeFeedIterable {
   protected readonly debug: dbg.Debugger
   private _tid: NodeJS.Timeout | undefined = undefined
 
-  constructor(exchange: string, private readonly _poolingIntervalSeconds: number, protected readonly onError?: (error: Error) => void) {
+  constructor(
+    exchange: string,
+    private readonly _poolingIntervalSeconds: number,
+    protected readonly onError?: (error: Error) => void
+  ) {
     this.debug = dbg(`tardis-dev:pooling-client:${exchange}`)
   }
 

package/src/realtimefeeds/serum.ts

@@ -40,20 +40,23 @@ export class SerumRealTimeFeed extends RealTimeFeedBase {
           markets: filter.symbols
         }
       })
-      .reduce((prev, current) => {
-        const matchingExisting = prev.find((c) => c.channel === current.channel)
-        if (matchingExisting !== undefined) {
-          for (const market of current.markets) {
-            if (matchingExisting.markets.includes(market) === false) {
-              matchingExisting.markets.push(market)
+      .reduce(
+        (prev, current) => {
+          const matchingExisting = prev.find((c) => c.channel === current.channel)
+          if (matchingExisting !== undefined) {
+            for (const market of current.markets) {
+              if (matchingExisting.markets.includes(market) === false) {
+                matchingExisting.markets.push(market)
+              }
             }
+          } else {
+            prev.push(current)
           }
-        } else {
-          prev.push(current)
-        }
 
-        return prev
-      }, [] as { channel: string; markets: string[] }[])
+          return prev
+        },
+        [] as { channel: string; markets: string[] }[]
+      )
 
     return subs
   }

package/src/replay.ts

@@ -35,8 +35,8 @@ export async function* replay<T extends Exchange, U extends boolean = false, Z e
       ? { localTimestamp: Buffer; message: Buffer } | undefined
       : { localTimestamp: Date; message: any } | undefined
     : U extends true
-    ? { localTimestamp: Buffer; message: Buffer }
-    : { localTimestamp: Date; message: any }
+      ? { localTimestamp: Buffer; message: Buffer }
+      : { localTimestamp: Date; message: any }
 > {
   validateReplayOptions(exchange, from, to, filters)
 

package/src/types.ts

@@ -117,7 +117,7 @@ export type Liquidation = {
   readonly id: string | undefined
   readonly price: number
   readonly amount: number
-  readonly side: 'buy' | 'sell' | 'unknown'
+  readonly side: 'buy' | 'sell' | 'unknown' // buy = short position liquidated, sell = long position liquidated
   readonly timestamp: Date
   readonly localTimestamp: Date
 }