tardis-dev 14.1.5 → 14.2.0

package/src/mappers/binanceeuropeanoptions.ts

@@ -1,5 +1,5 @@
-import { asNumberIfValid, upperCaseSymbols } from '../handy'
-import { BookChange, OptionSummary, Trade } from '../types'
+import { asNumberIfValid, lowerCaseSymbols, upperCaseSymbols } from '../handy'
+import { BookChange, BookTicker, OptionSummary, Trade } from '../types'
 import { Mapper } from './mapper'
 
 // https://binance-docs.github.io/apidocs/voptions/en/#websocket-market-streams
@@ -41,6 +41,43 @@ export class BinanceEuropeanOptionsTradesMapper implements Mapper<'binance-europ
   }
 }
 
+export class BinanceEuropeanOptionsTradesMapperV2 implements Mapper<'binance-european-options', Trade> {
+  canHandle(message: BinanceResponse<any>) {
+    if (message.stream === undefined) {
+      return false
+    }
+
+    return message.stream.endsWith('@optionTrade')
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = lowerCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'optionTrade',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(binanceTradeResponse: BinanceResponse<BinanceOptionsTradeDataV2>, localTimestamp: Date) {
+    const trade: Trade = {
+      type: 'trade',
+      symbol: binanceTradeResponse.data.s,
+      exchange: 'binance-european-options',
+      id: String(binanceTradeResponse.data.t),
+      price: Number(binanceTradeResponse.data.p),
+      amount: Number(binanceTradeResponse.data.q),
+      side: binanceTradeResponse.data.m ? 'sell' : 'buy',
+      timestamp: new Date(binanceTradeResponse.data.T),
+      localTimestamp: localTimestamp
+    }
+
+    yield trade
+  }
+}
+
 export class BinanceEuropeanOptionsBookChangeMapper implements Mapper<'binance-european-options', BookChange> {
   canHandle(message: BinanceResponse<any>) {
     if (message.stream === undefined) {
@@ -83,6 +120,90 @@ export class BinanceEuropeanOptionsBookChangeMapper implements Mapper<'binance-e
   }
 }
 
+export class BinanceEuropeanOptionsBookChangeMapperV2 implements Mapper<'binance-european-options', BookChange> {
+  canHandle(message: BinanceResponse<any>) {
+    if (message.stream === undefined) {
+      return false
+    }
+
+    return message.stream.includes('@depth20')
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = lowerCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'depth20',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: BinanceResponse<BinanceOptionsDepthDataV2>, localTimestamp: Date) {
+    const bookChange: BookChange = {
+      type: 'book_change',
+      symbol: message.data.s,
+      exchange: 'binance-european-options',
+      isSnapshot: true,
+      bids: message.data.b.map(this.mapBookLevel),
+      asks: message.data.a.map(this.mapBookLevel),
+      timestamp: new Date(message.data.T),
+      localTimestamp
+    }
+
+    yield bookChange
+  }
+
+  protected mapBookLevel(level: BinanceBookLevel) {
+    const price = Number(level[0])
+    const amount = Number(level[1])
+    return { price, amount }
+  }
+}
+
+export class BinanceEuropeanOptionsBookTickerMapper implements Mapper<'binance-european-options', BookTicker> {
+  canHandle(message: BinanceResponse<any>) {
+    if (message.stream === undefined) {
+      return false
+    }
+
+    return message.stream.endsWith('@bookTicker')
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = lowerCaseSymbols(symbols)
+
+    return [
+      {
+        channel: 'bookTicker',
+        symbols
+      } as const
+    ]
+  }
+
+  *map(message: BinanceResponse<BinanceOptionsBookTickerData>, localTimestamp: Date) {
+    const bestBidPrice = Number(message.data.b)
+    const bestBidAmount = Number(message.data.B)
+    const bestAskPrice = Number(message.data.a)
+    const bestAskAmount = Number(message.data.A)
+
+    const bookTicker: BookTicker = {
+      type: 'book_ticker',
+      symbol: message.data.s,
+      exchange: 'binance-european-options',
+      bidPrice: bestBidPrice > 0 ? bestBidPrice : undefined,
+      bidAmount: bestBidAmount > 0 ? bestBidAmount : undefined,
+      askPrice: bestAskPrice > 0 ? bestAskPrice : undefined,
+      askAmount: bestAskAmount > 0 ? bestAskAmount : undefined,
+      timestamp: new Date(message.data.T),
+      localTimestamp
+    }
+
+    yield bookTicker
+  }
+}
+
 export class BinanceEuropeanOptionSummaryMapper implements Mapper<'binance-european-options', OptionSummary> {
   private readonly _indexPrices = new Map<string, number>()
   private readonly _openInterests = new Map<string, number>()
@@ -233,6 +354,165 @@ export class BinanceEuropeanOptionSummaryMapper implements Mapper<'binance-europ
   }
 }
 
+export class BinanceEuropeanOptionSummaryMapperV2 implements Mapper<'binance-european-options', OptionSummary> {
+  private readonly _lastPrices = new Map<string, number>()
+  private readonly _openInterests = new Map<string, number>()
+
+  canHandle(message: BinanceResponse<any>) {
+    if (message.stream === undefined) {
+      return false
+    }
+
+    return (
+      message.stream.endsWith('@optionMarkPrice') ||
+      message.stream.endsWith('@optionTicker') ||
+      message.stream.includes('@optionOpenInterest')
+    )
+  }
+
+  getFilters(symbols?: string[]) {
+    symbols = lowerCaseSymbols(symbols)
+
+    const underlyings =
+      symbols !== undefined
+        ? symbols.map((s) => {
+            const symbolParts = s.split('-')
+            return `${symbolParts[0]}usdt`
+          })
+        : undefined
+
+    return [
+      {
+        channel: 'optionMarkPrice',
+        symbols: underlyings
+      } as const,
+      {
+        channel: 'optionTicker',
+        symbols
+      } as const,
+      {
+        channel: 'optionOpenInterest',
+        symbols: underlyings
+      } as const
+    ]
+  }
+
+  *map(
+    message: BinanceResponse<BinanceOptionsMarkPriceData[] | BinanceOptionsTickerData | BinanceOptionsOpenInterestDataV2[]>,
+    localTimestamp: Date
+  ) {
+    // Handle optionTicker messages to track last prices
+    if (message.stream.endsWith('@optionTicker')) {
+      const tickerData = message.data as BinanceOptionsTickerData
+      const lastPrice = Number(tickerData.c)
+      if (lastPrice > 0) {
+        this._lastPrices.set(tickerData.s, lastPrice)
+      }
+      return
+    }
+
+    // Handle optionOpenInterest messages to track open interest
+    if (message.stream.includes('@optionOpenInterest')) {
+      const openInterestArray = message.data as BinanceOptionsOpenInterestDataV2[]
+      for (let oi of openInterestArray) {
+        const openInterest = Number(oi.o)
+        if (openInterest >= 0) {
+          this._openInterests.set(oi.s, openInterest)
+        }
+      }
+      return
+    }
+
+    // optionMarkPrice contains all data needed: greeks, IV, best bid/ask, mark price, and index price
+    const markPriceArray = message.data as BinanceOptionsMarkPriceData[]
+    for (let markData of markPriceArray) {
+      const [base, expiryPart, strikePrice, optionType] = markData.s.split('-')
+
+      const expirationDate = new Date(`20${expiryPart.slice(0, 2)}-${expiryPart.slice(2, 4)}-${expiryPart.slice(4, 6)}Z`)
+      expirationDate.setUTCHours(8)
+
+      const isPut = optionType === 'P'
+      const underlyingIndex = `${base}USDT`
+
+      let bestBidPrice = asNumberIfValid(markData.bo)
+      if (bestBidPrice === 0) {
+        bestBidPrice = undefined
+      }
+
+      let bestBidAmount = asNumberIfValid(markData.bq)
+      if (bestBidAmount === 0) {
+        bestBidAmount = undefined
+      }
+
+      let bestAskPrice = asNumberIfValid(markData.ao)
+      if (bestAskPrice === 0) {
+        bestAskPrice = undefined
+      }
+
+      let bestAskAmount = asNumberIfValid(markData.aq)
+      if (bestAskAmount === 0) {
+        bestAskAmount = undefined
+      }
+
+      let bestBidIV = bestBidPrice !== undefined ? asNumberIfValid(markData.b) : undefined
+      if (bestBidIV === -1) {
+        bestBidIV = undefined
+      }
+
+      let bestAskIV = bestAskPrice !== undefined ? asNumberIfValid(markData.a) : undefined
+      if (bestAskIV === -1) {
+        bestAskIV = undefined
+      }
+
+      const markPrice = asNumberIfValid(markData.mp)
+      const markIV = asNumberIfValid(markData.vo)
+      const delta = asNumberIfValid(markData.d)
+      const gamma = asNumberIfValid(markData.g)
+      const vega = asNumberIfValid(markData.v)
+      const theta = asNumberIfValid(markData.t)
+      const underlyingPrice = asNumberIfValid(markData.i) // Index price is included in mark price data
+
+      const optionSummary: OptionSummary = {
+        type: 'option_summary',
+        symbol: markData.s,
+        exchange: 'binance-european-options',
+        optionType: isPut ? 'put' : 'call',
+        strikePrice: Number(strikePrice),
+        expirationDate,
+
+        bestBidPrice,
+        bestBidAmount,
+        bestBidIV,
+
+        bestAskPrice,
+        bestAskAmount,
+        bestAskIV,
+
+        lastPrice: this._lastPrices.get(markData.s),
+
+        openInterest: this._openInterests.get(markData.s),
+
+        markPrice,
+        markIV,
+
+        delta,
+        gamma,
+        vega,
+        theta,
+        rho: undefined,
+
+        underlyingPrice,
+        underlyingIndex,
+
+        timestamp: new Date(markData.E),
+        localTimestamp: localTimestamp
+      }
+
+      yield optionSummary
+    }
+  }
+}
+
 type BinanceResponse<T> = {
   stream: string
   data: T
@@ -301,3 +581,72 @@ type BinanceOptionsIndexData = { e: 'index'; E: 1696118400040; s: 'BNBUSDT'; p:
 type BinanceOptionsOpenInterestData = { e: 'openInterest'; E: 1696118400042; s: 'XRP-231006-0.46-P'; o: '39480.0'; h: '20326.64319' }
 
 type BinanceBookLevel = [string, string]
+
+// V2 Types for new format (Dec 17, 2025+)
+type BinanceOptionsTradeDataV2 = {
+  e: 'trade'
+  E: number // event time
+  T: number // trade completed time
+  s: string // option symbol
+  t: number // trade ID
+  p: string // price
+  q: string // quantity
+  X: 'MARKET' | 'BLOCK' // trade type
+  S: 'BUY' | 'SELL' // direction
+  m: boolean // is buyer market maker
+}
+
+type BinanceOptionsDepthDataV2 = {
+  e: 'depthUpdate'
+  E: number // event time
+  T: number // transaction time
+  s: string // symbol
+  U: number // first update ID
+  u: number // final update ID
+  pu: number // previous final update ID
+  b: [string, string][] // bids
+  a: [string, string][] // asks
+}
+
+type BinanceOptionsBookTickerData = {
+  e: 'bookTicker'
+  u: number // order book update ID
+  s: string // symbol
+  b: string // best bid price
+  B: string // best bid qty
+  a: string // best ask price
+  A: string // best ask qty
+  T: number // transaction time
+  E: number // event time
+}
+
+type BinanceOptionsOpenInterestDataV2 = {
+  e: 'openInterest'
+  E: number // event time
+  s: string // symbol
+  o: string // open interest (quantity)
+  h: string // open interest in notional value (USD)
+}
+
+type BinanceOptionsMarkPriceData = {
+  s: string // option symbol
+  mp: string // mark price
+  E: number // event time
+  e: 'markPrice'
+  i: string // index price
+  P: string // premium
+  bo: string // best bid price
+  ao: string // best ask price
+  bq: string // best bid quantity
+  aq: string // best ask quantity
+  b: string // bid IV
+  a: string // ask IV
+  hl: string // high limit price
+  ll: string // low limit price
+  vo: string // mark IV
+  rf: string // risk free rate
+  d: string // delta
+  t: string // theta
+  g: string // gamma
+  v: string // vega
+}

package/src/mappers/index.ts

@@ -12,8 +12,12 @@ import {
 import { binanceDexBookChangeMapper, binanceDexBookTickerMapper, binanceDexTradesMapper } from './binancedex'
 import {
   BinanceEuropeanOptionsBookChangeMapper,
+  BinanceEuropeanOptionsBookChangeMapperV2,
+  BinanceEuropeanOptionsBookTickerMapper,
   BinanceEuropeanOptionsTradesMapper,
-  BinanceEuropeanOptionSummaryMapper
+  BinanceEuropeanOptionsTradesMapperV2,
+  BinanceEuropeanOptionSummaryMapper,
+  BinanceEuropeanOptionSummaryMapperV2
 } from './binanceeuropeanoptions'
 import { BinanceOptionsBookChangeMapper, BinanceOptionsTradesMapper, BinanceOptionSummaryMapper } from './binanceoptions'
 import {
@@ -221,6 +225,12 @@ const shouldUseOKXTradesAllChannel = (localTimestamp: Date) => {
   return isRealTime(localTimestamp) || localTimestamp.valueOf() >= new Date('2023-10-19T00:00:00.000Z').valueOf()
 }
 
+const BINANCE_EUROPEAN_OPTIONS_V2_API_SWITCH_DATE = new Date('2025-12-17T00:00:00.000Z')
+
+const shouldUseBinanceEuropeanOptionsV2Mappers = (localTimestamp: Date) => {
+  return isRealTime(localTimestamp) || localTimestamp.valueOf() >= BINANCE_EUROPEAN_OPTIONS_V2_API_SWITCH_DATE.valueOf()
+}
+
 const tradesMappers = {
   bitmex: () => bitmexTradesMapper,
   binance: () => new BinanceTradesMapper('binance'),
@@ -296,7 +306,10 @@ const tradesMappers = {
   'woo-x': () => wooxTradesMapper,
   'blockchain-com': () => new BlockchainComTradesMapper(),
   'bybit-options': () => new BybitV5TradesMapper('bybit-options'),
-  'binance-european-options': () => new BinanceEuropeanOptionsTradesMapper(),
+  'binance-european-options': (localTimestamp: Date) =>
+    shouldUseBinanceEuropeanOptionsV2Mappers(localTimestamp)
+      ? new BinanceEuropeanOptionsTradesMapperV2()
+      : new BinanceEuropeanOptionsTradesMapper(),
   'okex-spreads': () => new OkexSpreadsTradesMapper(),
   bitget: () => new BitgetTradesMapper('bitget'),
   'bitget-futures': () => new BitgetTradesMapper('bitget-futures'),
@@ -390,7 +403,10 @@ const bookChangeMappers = {
   'woo-x': () => new WooxBookChangeMapper(),
   'blockchain-com': () => new BlockchainComBookChangeMapper(),
   'bybit-options': () => new BybitV5BookChangeMapper('bybit-options', 25),
-  'binance-european-options': () => new BinanceEuropeanOptionsBookChangeMapper(),
+  'binance-european-options': (localTimestamp: Date) =>
+    shouldUseBinanceEuropeanOptionsV2Mappers(localTimestamp)
+      ? new BinanceEuropeanOptionsBookChangeMapperV2()
+      : new BinanceEuropeanOptionsBookChangeMapper(),
   'okex-spreads': () => new OkexSpreadsBookChangeMapper(),
   bitget: () => new BitgetBookChangeMapper('bitget'),
   'bitget-futures': () => new BitgetBookChangeMapper('bitget-futures'),
@@ -442,7 +458,10 @@ const optionsSummaryMappers = {
   'binance-options': () => new BinanceOptionSummaryMapper(),
   'huobi-dm-options': () => new HuobiOptionsSummaryMapper(),
   'bybit-options': () => new BybitV5OptionSummaryMapper(),
-  'binance-european-options': () => new BinanceEuropeanOptionSummaryMapper()
+  'binance-european-options': (localTimestamp: Date) =>
+    shouldUseBinanceEuropeanOptionsV2Mappers(localTimestamp)
+      ? new BinanceEuropeanOptionSummaryMapperV2()
+      : new BinanceEuropeanOptionSummaryMapper()
 }
 
 const liquidationsMappers = {
@@ -532,7 +551,8 @@ const bookTickersMappers = {
   bitget: () => new BitgetBookTickerMapper('bitget'),
   'bitget-futures': () => new BitgetBookTickerMapper('bitget-futures'),
   'coinbase-international': () => coinbaseInternationalBookTickerMapper,
-  hyperliquid: () => new HyperliquidBookTickerMapper()
+  hyperliquid: () => new HyperliquidBookTickerMapper(),
+  'binance-european-options': () => new BinanceEuropeanOptionsBookTickerMapper()
 }
 
 export const normalizeTrades = <T extends keyof typeof tradesMappers>(exchange: T, localTimestamp: Date): Mapper<T, Trade> => {

package/src/realtimefeeds/binanceeuropeanoptions.ts

@@ -1,9 +1,54 @@
 import { onlyUnique } from '../handy'
 import { Filter } from '../types'
-import { RealTimeFeedBase } from './realtimefeed'
+import { MultiConnectionRealTimeFeedBase, RealTimeFeedBase } from './realtimefeed'
 
-export class BinanceEuropeanOptionsRealTimeFeed extends RealTimeFeedBase {
-  protected wssURL = 'wss://nbstream.binance.com/eoptions/stream'
+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) => {
@@ -15,29 +60,59 @@ export class BinanceEuropeanOptionsRealTimeFeed extends RealTimeFeedBase {
         method: 'SUBSCRIBE',
         params: filter.symbols
           .map((symbol) => {
-            if (filter.channel === 'depth100') {
-              return [`${symbol}@${filter.channel}@100ms`]
+            const lowerSymbol = symbol.toLowerCase()
+
+            // Public path channels - use lowercase symbol directly
+            if (filter.channel === 'optionTrade') {
+              return [`${lowerSymbol}@${filter.channel}`]
             }
 
-            if (filter.channel === 'openInterest') {
-              const matchingTickerChannel = filters.find((f) => f.channel === 'ticker')
+            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()
 
-              if (matchingTickerChannel !== undefined) {
-                const expirations = matchingTickerChannel
-                  .symbols!.filter((s) => s.startsWith(symbol))
+                const expirations = optionTickerFilter
+                  .symbols!.filter((s) => s.toUpperCase().startsWith(underlyingBase + '-'))
                   .map((s) => {
                     const symbolParts = s.split('-')
-                    return `${symbolParts[1]}`
+                    return symbolParts[1] // Extract expiration (e.g., '251219')
                   })
                   .filter(onlyUnique)
+                  .map((exp) => exp.toLowerCase())
 
                 return expirations.map((expiration) => {
-                  return `${symbol}@${filter.channel}@${expiration}`
+                  return `${lowerSymbol}@${filter.channel}@${expiration}`
                 })
               }
             }
 
-            return [`${symbol}@${filter.channel}`]
+            return [`${lowerSymbol}@${filter.channel}`]
           })
           .flatMap((s) => s),
         id: index + 1