tardis-machine 17.0.0 → 18.0.0

package/node_modules/tardis-dev/src/realtimefeeds/binanceeuropeanoptions.ts

@@ -0,0 +1,132 @@
+import { onlyUnique } from '../handy.ts'
+import { Filter } from '../types.ts'
+import { MultiConnectionRealTimeFeedBase, RealTimeFeedBase } from './realtimefeed.ts'
+
+export class BinanceEuropeanOptionsRealTimeFeed extends MultiConnectionRealTimeFeedBase {
+  protected *_getRealTimeFeeds(exchange: string, filters: Filter<string>[], timeoutIntervalMS?: number, onError?: (error: Error) => void) {
+    // V2 API uses two separate WebSocket endpoints:
+    // 1. Public path: for optionTrade, depth20, bookTicker, optionTicker
+    // 2. Market path: for optionIndexPrice, optionMarkPrice, optionOpenInterest
+
+    const publicChannels = ['optionTrade', 'depth20', 'bookTicker', 'optionTicker']
+    const marketChannels = ['optionIndexPrice', 'optionMarkPrice', 'optionOpenInterest']
+
+    const publicFilters = filters.filter((f) => publicChannels.includes(f.channel))
+    const marketFilters = filters.filter((f) => marketChannels.includes(f.channel))
+
+    if (publicFilters.length > 0) {
+      yield new BinanceEuropeanOptionsSingleFeed(
+        'wss://fstream.binance.com/public/stream',
+        exchange,
+        publicFilters,
+        filters, // Pass all filters so we can look up optionTicker when processing optionOpenInterest
+        timeoutIntervalMS,
+        onError
+      )
+    }
+
+    if (marketFilters.length > 0) {
+      yield new BinanceEuropeanOptionsSingleFeed(
+        'wss://fstream.binance.com/market/stream',
+        exchange,
+        marketFilters,
+        filters, // Pass all filters so we can look up optionTicker when processing optionOpenInterest
+        timeoutIntervalMS,
+        onError
+      )
+    }
+  }
+}
+
+class BinanceEuropeanOptionsSingleFeed extends RealTimeFeedBase {
+  constructor(
+    protected wssURL: string,
+    exchange: string,
+    filters: Filter<string>[],
+    private readonly _allFilters: Filter<string>[],
+    timeoutIntervalMS: number | undefined,
+    onError?: (error: Error) => void
+  ) {
+    super(exchange, filters, timeoutIntervalMS, onError)
+  }
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    const payload = filters.map((filter, index) => {
+      if (!filter.symbols || filter.symbols.length === 0) {
+        throw new Error('BinanceEuropeanOptionsRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+      }
+
+      return {
+        method: 'SUBSCRIBE',
+        params: filter.symbols
+          .map((symbol) => {
+            const lowerSymbol = symbol.toLowerCase()
+
+            // Public path channels - use lowercase symbol directly
+            if (filter.channel === 'optionTrade') {
+              return [`${lowerSymbol}@${filter.channel}`]
+            }
+
+            if (filter.channel === 'depth20') {
+              return [`${lowerSymbol}@${filter.channel}@100ms`]
+            }
+
+            if (filter.channel === 'bookTicker') {
+              return [`${lowerSymbol}@${filter.channel}`]
+            }
+
+            if (filter.channel === 'optionTicker') {
+              return [`${lowerSymbol}@${filter.channel}`]
+            }
+
+            // Market path channels - use lowercase underlying
+            if (filter.channel === 'optionIndexPrice' || filter.channel === 'optionMarkPrice') {
+              // Symbol is the underlying (e.g., 'btcusdt')
+              return [`${lowerSymbol}@${filter.channel}`]
+            }
+
+            if (filter.channel === 'optionOpenInterest') {
+              // Need to extract expirations from option symbols
+              // The symbol here is the underlying (e.g., 'btcusdt')
+              // We need to find all option symbols that match this underlying to extract expirations
+
+              // Look for optionTicker filter in all filters to get actual option symbols
+              const optionTickerFilter = this._allFilters.find((f) => f.channel === 'optionTicker')
+
+              if (optionTickerFilter !== undefined) {
+                // Extract expirations from option symbols that match this underlying
+                const underlyingBase = lowerSymbol.replace('usdt', '').toUpperCase()
+
+                const expirations = optionTickerFilter
+                  .symbols!.filter((s) => s.toUpperCase().startsWith(underlyingBase + '-'))
+                  .map((s) => {
+                    const symbolParts = s.split('-')
+                    return symbolParts[1] // Extract expiration (e.g., '251219')
+                  })
+                  .filter(onlyUnique)
+                  .map((exp) => exp.toLowerCase())
+
+                return expirations.map((expiration) => {
+                  return `${lowerSymbol}@${filter.channel}@${expiration}`
+                })
+              }
+            }
+
+            return [`${lowerSymbol}@${filter.channel}`]
+          })
+          .flatMap((s) => s),
+        id: index + 1
+      }
+    })
+
+    return payload
+  }
+
+  protected messageIsError(message: any): boolean {
+    if (message.data !== undefined && message.data.e === 'error') {
+      return true
+    }
+
+    return false
+  }
+}

package/node_modules/tardis-dev/src/realtimefeeds/bitfinex.ts

@@ -0,0 +1,83 @@
+import { Filter } from '../types.ts'
+import { RealTimeFeedBase } from './realtimefeed.ts'
+const TIMESTAMP = 32768
+const SEQ_ALL = 65536
+
+export class BitfinexRealTimeFeed extends RealTimeFeedBase {
+  protected wssURL = 'wss://api-pub.bitfinex.com/ws/2'
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]) {
+    const configMessage = {
+      event: 'conf',
+      flags: TIMESTAMP | SEQ_ALL
+    }
+
+    const subscribeMessages = filters
+      .map((filter) => {
+        if (filter.channel !== 'liquidations' && (!filter.symbols || filter.symbols.length === 0)) {
+          throw new Error('BitfinexRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+        }
+        if (filter.channel === 'liquidations') {
+          return [
+            {
+              event: 'subscribe',
+              channel: 'status',
+              key: 'liq:global'
+            }
+          ]
+        }
+
+        return filter.symbols!.map((symbol) => {
+          if (filter.channel === 'trades') {
+            return {
+              event: 'subscribe',
+              channel: 'trades',
+              symbol: `t${symbol}`
+            }
+          }
+          if (filter.channel === 'book') {
+            return {
+              event: 'subscribe',
+              channel: 'book',
+              len: 100,
+              prec: 'P0',
+              freq: 'F0',
+              symbol: `t${symbol}`
+            }
+          }
+
+          if (filter.channel === 'status') {
+            return {
+              event: 'subscribe',
+              channel: 'status',
+              key: `deriv:t${symbol}`
+            }
+          }
+
+          if (filter.channel === 'raw_book') {
+            return {
+              event: 'subscribe',
+              channel: 'book',
+              len: 100,
+              prec: 'R0',
+              freq: 'F0',
+              symbol: `t${symbol}`
+            }
+          }
+
+          return
+        })
+      })
+      .flatMap((c) => c)
+
+    return [configMessage, ...subscribeMessages]
+  }
+
+  protected messageIsError(message: any) {
+    return message.event === 'error'
+  }
+
+  protected messageIsHeartbeat(message: any) {
+    return Array.isArray(message) && message.length > 1 && message[1] === 'hb'
+  }
+}

package/node_modules/tardis-dev/src/realtimefeeds/bitflyer.ts

@@ -0,0 +1,41 @@
+import { Filter } from '../types.ts'
+import { RealTimeFeedBase } from './realtimefeed.ts'
+
+export class BitflyerRealTimeFeed extends RealTimeFeedBase {
+  protected wssURL = 'wss://ws.lightstream.bitflyer.com/json-rpc'
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    return filters
+      .map((filter) => {
+        if (!filter.symbols || filter.symbols.length === 0) {
+          throw new Error('BitflyerRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+        }
+
+        return filter.symbols.map((symbol) => {
+          return {
+            method: 'subscribe',
+            params: {
+              channel: `${filter.channel}_${symbol}`
+            }
+          }
+        })
+      })
+      .flatMap((c) => c)
+  }
+
+  protected messageIsError(message: any): boolean {
+    return message.method !== 'channelMessage'
+  }
+
+  protected onMessage = (msg: any) => {
+    // once we've received book snapshot, let's unsubscribe from it
+    if ((msg.params.channel as string).startsWith('lightning_board_snapshot')) {
+      this.send({
+        method: 'unsubscribe',
+        params: {
+          channel: msg.params.channel
+        }
+      })
+    }
+  }
+}

package/node_modules/tardis-dev/src/realtimefeeds/bitget.ts

@@ -0,0 +1,76 @@
+import { batchObjects } from '../handy.ts'
+import { Filter } from '../types.ts'
+import { RealTimeFeedBase } from './realtimefeed.ts'
+
+abstract class BitgetRealTimeFeedBase extends RealTimeFeedBase {
+  protected throttleSubscribeMS = 100
+  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')
+      }
+
+      return filter.symbols.map((symbol) => {
+        return {
+          instType: this.getInstType(symbol),
+          topic: filter.channel,
+          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
+
+  protected getLiquidationInstTypes(): string[] {
+    return []
+  }
+}
+
+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'
+  }
+
+  protected getLiquidationInstTypes() {
+    return ['usdt-futures', 'usdc-futures', 'coin-futures']
+  }
+}

package/node_modules/tardis-dev/src/realtimefeeds/bitmex.ts

@@ -0,0 +1,42 @@
+import { batch } from '../handy.ts'
+import { Filter } from '../types.ts'
+import { RealTimeFeedBase } from './realtimefeed.ts'
+
+export class BitmexRealTimeFeed extends RealTimeFeedBase {
+  protected readonly wssURL = 'wss://ws.bitmex.com/realtime'
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]) {
+    return filters
+      .map((filter) => {
+        if (!filter.symbols || filter.symbols.length === 0) {
+          return [
+            {
+              op: 'subscribe',
+              args: [filter.channel]
+            }
+          ]
+        }
+        const subscribeMessages = []
+        for (const symbolsBatch of batch(filter.symbols, 10)) {
+          subscribeMessages.push({
+            op: 'subscribe',
+            args: symbolsBatch.map((s) => `${filter.channel}:${s}`)
+          })
+        }
+
+        return subscribeMessages
+      })
+      .flatMap((s) => s)
+  }
+
+  protected messageIsError(message: any): boolean {
+    if (message.error !== undefined) {
+      return true
+    }
+
+    if ('subscribe' in message && message.success === false) {
+      return true
+    }
+    return false
+  }
+}

package/node_modules/tardis-dev/src/realtimefeeds/bitnomial.ts

@@ -0,0 +1,60 @@
+import { Filter } from '../types.ts'
+import { RealTimeFeedBase } from './realtimefeed.ts'
+
+export class BitnomialRealTimeFeed extends RealTimeFeedBase {
+  protected wssURL = 'wss://bitnomial.com/exchange/ws'
+
+  protected channelMappings = {
+    book: ['book', 'level']
+  }
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    const channelsToSubscribe = filters
+      .map((filter) => {
+        if (!filter.symbols || filter.symbols.length === 0) {
+          throw new Error('BitnomialRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+        }
+        const subscribeToBookChannel = this.channelMappings.book.includes(filter.channel)
+        let channel
+        if (subscribeToBookChannel) {
+          channel = 'book'
+        } else {
+          channel = filter.channel
+        }
+
+        return {
+          name: channel,
+          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)
+              }
+            }
+          } else {
+            prev.push(current)
+          }
+
+          return prev
+        },
+        [] as { name: string; product_codes: string[] }[]
+      )
+
+    return [
+      {
+        type: 'subscribe',
+        product_codes: [],
+        channels: channelsToSubscribe
+      }
+    ]
+  }
+
+  protected messageIsError(message: any): boolean {
+    return message.type === 'error' || message.type === 'disconnect'
+  }
+}

package/node_modules/tardis-dev/src/realtimefeeds/bitstamp.ts

@@ -0,0 +1,70 @@
+import { getJSON } from '../handy.ts'
+import { Filter } from '../types.ts'
+import { RealTimeFeedBase } from './realtimefeed.ts'
+
+export class BitstampRealTimeFeed extends RealTimeFeedBase {
+  protected wssURL = 'wss://ws.bitstamp.net'
+  protected httpURL = 'https://www.bitstamp.net/api/v2'
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    return filters
+      .map((filter) => {
+        if (!filter.symbols || filter.symbols.length === 0) {
+          throw new Error('BitstampRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+        }
+
+        return filter.symbols.map((symbol) => {
+          return {
+            event: 'bts:subscribe',
+            data: {
+              channel: `${filter.channel}_${symbol}`
+            }
+          }
+        })
+      })
+      .flatMap((c) => c)
+  }
+
+  protected messageIsError(message: any): boolean {
+    if (message.channel === undefined) {
+      return true
+    }
+
+    if (message.event === 'bts:request_reconnect') {
+      return true
+    }
+
+    return false
+  }
+
+  protected async provideManualSnapshots(filters: Filter<string>[], shouldCancel: () => boolean) {
+    const orderBookFilter = filters.find((f) => f.channel === 'diff_order_book')
+    if (!orderBookFilter) {
+      return
+    }
+
+    this.debug('requesting manual snapshots for: %s', orderBookFilter.symbols!)
+
+    for (let symbol of orderBookFilter.symbols!) {
+      if (shouldCancel()) {
+        return
+      }
+
+      const { data } = await getJSON(`${this.httpURL}/order_book/${symbol}?group=1`)
+      if (shouldCancel()) {
+        return
+      }
+
+      const snapshot = {
+        data,
+        event: 'snapshot',
+        channel: `diff_order_book_${symbol}`,
+        generated: true
+      }
+
+      this.manualSnapshotsBuffer.push(snapshot)
+    }
+
+    this.debug('requested manual snapshots successfully for: %s ', orderBookFilter.symbols!)
+  }
+}

package/node_modules/tardis-dev/src/realtimefeeds/blockchaincom.ts

@@ -0,0 +1,44 @@
+import { wait } from '../handy.ts'
+import { Filter } from '../types.ts'
+import { RealTimeFeedBase } from './realtimefeed.ts'
+
+export class BlockchainComRealTimeFeed extends RealTimeFeedBase {
+  protected readonly wssURL = 'wss://ws.blockchain.info/mercury-gateway/v1/ws'
+  protected readonly originHeader = 'https://exchange.blockchain.com'
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    const subs = filters
+      .map((filter) => {
+        if (!filter.symbols || filter.symbols.length === 0) {
+          throw new Error('BlockchainComRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+        }
+
+        return filter.symbols.map((symbol) => {
+          return {
+            action: 'subscribe',
+            channel: filter.channel,
+            symbol
+          }
+        })
+      })
+      .flatMap((f) => f)
+
+    return subs
+  }
+
+  protected messageIsError(message: any): boolean {
+    return message.event === 'rejected'
+  }
+
+  protected messageIsHeartbeat(msg: any) {
+    return msg.channel === 'heartbeat'
+  }
+  protected async onConnected() {
+    this.send({
+      action: 'subscribe',
+      channel: 'heartbeat'
+    })
+
+    await wait(0)
+  }
+}

package/node_modules/tardis-dev/src/realtimefeeds/bullish.ts

@@ -0,0 +1,140 @@
+import { Filter } from '../types.ts'
+import { MultiConnectionRealTimeFeedBase, RealTimeFeedBase } from './realtimefeed.ts'
+
+type BullishSubscriptionTarget = {
+  readonly topic: string
+  readonly path: string
+  readonly symbolParam?: 'symbol' | 'assetSymbol'
+}
+
+const BULLISH_SUBSCRIPTION_TARGETS: Record<string, BullishSubscriptionTarget> = {
+  V1TALevel2: {
+    topic: 'l2Orderbook',
+    path: '/trading-api/v1/market-data/orderbook',
+    symbolParam: 'symbol'
+  },
+  V1TALevel1: {
+    topic: 'l1Orderbook',
+    path: '/trading-api/v1/market-data/orderbook',
+    symbolParam: 'symbol'
+  },
+  V1TAAnonymousTradeUpdate: {
+    topic: 'anonymousTrades',
+    path: '/trading-api/v1/market-data/trades',
+    symbolParam: 'symbol'
+  },
+  V1TATickerResponse: {
+    topic: 'tick',
+    path: '/trading-api/v1/market-data/tick',
+    symbolParam: 'symbol'
+  },
+  V1TAIndexPrice: {
+    topic: 'indexPrice',
+    path: '/trading-api/v1/index-data',
+    symbolParam: 'assetSymbol'
+  }
+}
+
+function getBullishSubscriptionTarget(channel: string) {
+  const target = BULLISH_SUBSCRIPTION_TARGETS[channel]
+  if (target === undefined) {
+    throw new Error(`BullishRealTimeFeed unsupported channel ${channel}`)
+  }
+
+  return target
+}
+
+export class BullishRealTimeFeed extends MultiConnectionRealTimeFeedBase {
+  protected *_getRealTimeFeeds(exchange: string, filters: Filter<string>[], timeoutIntervalMS?: number, onError?: (error: Error) => void) {
+    for (const [path, pathFilters] of this.groupByPath(filters)) {
+      yield new BullishSingleConnectionRealTimeFeed(exchange, path, pathFilters, timeoutIntervalMS, onError)
+    }
+  }
+
+  private groupByPath(filters: Filter<string>[]) {
+    const filtersByPath = new Map<string, Filter<string>[]>()
+
+    for (const filter of filters) {
+      const target = getBullishSubscriptionTarget(filter.channel)
+      const pathFilters = filtersByPath.get(target.path) ?? []
+      pathFilters.push(filter)
+      filtersByPath.set(target.path, pathFilters)
+    }
+
+    return filtersByPath
+  }
+}
+
+export class BullishSingleConnectionRealTimeFeed extends RealTimeFeedBase {
+  protected wssURL = 'wss://api.exchange.bullish.com'
+  private nextMessageId = 1
+
+  constructor(
+    exchange: string,
+    private readonly path: string,
+    filters: Filter<string>[],
+    timeoutIntervalMS: number | undefined,
+    onError?: (error: Error) => void
+  ) {
+    super(exchange, filters, timeoutIntervalMS, onError)
+  }
+
+  protected async getWebSocketUrl() {
+    const baseURL = await super.getWebSocketUrl()
+    return `${baseURL.replace(/\/$/, '')}${this.path}`
+  }
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    return filters.flatMap((filter) => {
+      const target = getBullishSubscriptionTarget(filter.channel)
+
+      if (target.symbolParam == null) {
+        return [
+          {
+            jsonrpc: '2.0',
+            type: 'command',
+            method: 'subscribe',
+            id: (this.nextMessageId++).toString(),
+            params: {
+              topic: target.topic
+            }
+          }
+        ]
+      }
+
+      if (!filter.symbols || filter.symbols.length === 0) {
+        throw new Error('BullishRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
+      }
+
+      return filter.symbols.map((symbol) => {
+        return {
+          jsonrpc: '2.0',
+          type: 'command',
+          method: 'subscribe',
+          id: (this.nextMessageId++).toString(),
+          params: {
+            topic: target.topic,
+            [target.symbolParam!]: symbol
+          }
+        }
+      })
+    })
+  }
+
+  protected messageIsError(message: any): boolean {
+    return message.error !== undefined && message.error !== null
+  }
+
+  protected sendCustomPing = () => {
+    this.send({
+      jsonrpc: '2.0',
+      type: 'command',
+      method: 'keepalivePing',
+      id: (this.nextMessageId++).toString()
+    })
+  }
+
+  protected messageIsHeartbeat(message: any) {
+    return message.dataType === 'V1TAHeartbeat' || message.result?.message === 'Keep alive pong'
+  }
+}