tardis-dev 14.1.5 → 14.2.1

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/cryptocom.ts

@@ -2,7 +2,7 @@ import { upperCaseSymbols } from '../handy'
 import { BookChange, Exchange, BookTicker, Trade, DerivativeTicker } from '../types'
 import { Mapper, PendingTickerInfoHelper } from './mapper'
 
-export class CryptoComTradesMapper implements Mapper<'crypto-com' | 'crypto-com-derivatives', Trade> {
+export class CryptoComTradesMapper implements Mapper<'crypto-com', Trade> {
   constructor(private readonly _exchange: Exchange) {}
   canHandle(message: CryptoComTradeMessage) {
     return message.result !== undefined && message.result.channel === 'trade'
@@ -40,7 +40,7 @@ export class CryptoComTradesMapper implements Mapper<'crypto-com' | 'crypto-com-
   }
 }
 
-export class CryptoComBookChangeMapper implements Mapper<'crypto-com' | 'crypto-com-derivatives', BookChange> {
+export class CryptoComBookChangeMapper implements Mapper<'crypto-com', BookChange> {
   constructor(protected readonly _exchange: Exchange) {}
 
   canHandle(message: CryptoComBookMessage) {
@@ -82,7 +82,7 @@ export class CryptoComBookChangeMapper implements Mapper<'crypto-com' | 'crypto-
   }
 }
 
-export class CryptoComBookTickerMapper implements Mapper<'crypto-com' | 'crypto-com-derivatives', BookTicker> {
+export class CryptoComBookTickerMapper implements Mapper<'crypto-com', BookTicker> {
   constructor(protected readonly _exchange: Exchange) {}
 
   canHandle(message: CryptoComTickerMessage) {
@@ -119,7 +119,7 @@ export class CryptoComBookTickerMapper implements Mapper<'crypto-com' | 'crypto-
   }
 }
 
-export class CryptoComDerivativeTickerMapper implements Mapper<'crypto-com-derivatives', DerivativeTicker> {
+export class CryptoComDerivativeTickerMapper implements Mapper<'crypto-com', DerivativeTicker> {
   private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
   private readonly _indexPrices = new Map<string, number>()
 

package/src/mappers/index.ts

@@ -12,10 +12,13 @@ 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 {
   BitfinexBookChangeMapper,
   BitfinexDerivativeTickerMapper,
@@ -221,6 +224,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'),
@@ -278,7 +287,6 @@ const tradesMappers = {
   poloniex: (localTimestamp: Date) =>
     shouldUsePoloniexV2Mappers(localTimestamp) ? new PoloniexV2TradesMapper() : new PoloniexTradesMapper(),
   coinflex: () => coinflexTradesMapper,
-  'binance-options': () => new BinanceOptionsTradesMapper(),
   upbit: () => new UpbitTradesMapper(),
   ascendex: () => new AscendexTradesMapper(),
   dydx: () => new DydxTradesMapper(),
@@ -289,14 +297,16 @@ const tradesMappers = {
   'bybit-spot': (localTimestamp: Date) =>
     shouldUseBybitV5Mappers(localTimestamp) ? new BybitV5TradesMapper('bybit-spot') : new BybitSpotTradesMapper('bybit-spot'),
   'crypto-com': () => new CryptoComTradesMapper('crypto-com'),
-  'crypto-com-derivatives': () => new CryptoComTradesMapper('crypto-com-derivatives'),
   kucoin: () => new KucoinTradesMapper('kucoin'),
   'kucoin-futures': () => new KucoinFuturesTradesMapper(),
   bitnomial: () => bitnomialTradesMapper,
   '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'),
@@ -374,7 +384,6 @@ const bookChangeMappers = {
   poloniex: (localTimestamp: Date) =>
     shouldUsePoloniexV2Mappers(localTimestamp) ? new PoloniexV2BookChangeMapper() : new PoloniexBookChangeMapper(),
   coinflex: () => coinflexBookChangeMapper,
-  'binance-options': () => new BinanceOptionsBookChangeMapper(),
   upbit: () => new UpbitBookChangeMapper(),
   ascendex: () => new AscendexBookChangeMapper(),
   dydx: () => new DydxBookChangeMapper(),
@@ -383,14 +392,16 @@ const bookChangeMappers = {
   'star-atlas': () => new SerumBookChangeMapper('star-atlas'),
   mango: () => new SerumBookChangeMapper('mango'),
   'crypto-com': () => new CryptoComBookChangeMapper('crypto-com'),
-  'crypto-com-derivatives': () => new CryptoComBookChangeMapper('crypto-com-derivatives'),
   kucoin: (localTimestamp: Date) => new KucoinBookChangeMapper('kucoin', isRealTime(localTimestamp) === false),
   'kucoin-futures': (localTimestamp: Date) => new KucoinFuturesBookChangeMapper(isRealTime(localTimestamp) === false),
   bitnomial: () => new BitnomialBookChangMapper(),
   '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'),
@@ -426,7 +437,6 @@ const derivativeTickersMappers = {
   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(),
@@ -439,10 +449,12 @@ const optionsSummaryMappers = {
   deribit: () => new DeribitOptionSummaryMapper(),
   'okex-options': (localTimestamp: Date) =>
     shouldUseOkexV5Mappers(localTimestamp) ? new OkexV5OptionSummaryMapper() : new OkexOptionSummaryMapper(),
-  '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 = {
@@ -521,7 +533,6 @@ const bookTickersMappers = {
   'bybit-spot': (localTimestamp: Date) =>
     shouldUseBybitV5Mappers(localTimestamp) ? new BybitV5BookTickerMapper('bybit-spot') : new BybitSpotBookTickerMapper('bybit-spot'),
   'crypto-com': () => new CryptoComBookTickerMapper('crypto-com'),
-  'crypto-com-derivatives': () => new CryptoComBookTickerMapper('crypto-com-derivatives'),
   kucoin: () => new KucoinBookTickerMapper('kucoin'),
   'woo-x': () => new WooxBookTickerMapper(),
   delta: () => new DeltaBookTickerMapper(),
@@ -532,7 +543,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> => {