tardis-dev 14.1.4 → 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/cryptocom.ts

@@ -106,10 +106,10 @@ export class CryptoComBookTickerMapper implements Mapper<'crypto-com' | 'crypto-
         symbol: message.result.instrument_name,
         exchange: this._exchange,
 
-        askAmount: undefined,
+        askAmount: item.ks !== undefined && item.ks !== null ? Number(item.ks) : undefined,
         askPrice: item.k !== undefined && item.k !== null ? Number(item.k) : undefined,
         bidPrice: item.b !== undefined && item.b !== null ? Number(item.b) : undefined,
-        bidAmount: undefined,
+        bidAmount: item.bs !== undefined && item.bs !== null ? Number(item.bs) : undefined,
         timestamp: new Date(item.t),
         localTimestamp: localTimestamp
       }
@@ -344,7 +344,9 @@ type CryptoComTickerMessage =
           {
             i: 'GODS_USDT'
             b: 0.4262
+            bs?: 0.1
             k: 0.4272
+            ks?: 0.2
             a: 0.4272
             t: 1659311999946
             v: 100623.01
@@ -359,31 +361,89 @@ type CryptoComTickerMessage =
     }
   | CryptoComDerivativesTickerMessage
 
-type CryptoComDerivativesTickerMessage = {
-  id: -1
-  code: 0
-  method: 'subscribe'
-  result: {
-    channel: 'ticker'
-    instrument_name: 'BTCUSD-PERP'
-    subscription: 'ticker.BTCUSD-PERP'
-    data: [
-      {
-        h: '32222.5'
-        l: '30240.0'
-        a: '31611.0'
-        c: '0.0320'
-        b: '31613.0'
-        k: '31613.5'
-        i: 'BTCUSD-PERP'
-        v: '13206.4884'
-        vv: '433945264.39'
-        oi: '318.5162'
-        t: 1653992543383
+type CryptoComDerivativesTickerMessage =
+  | {
+      id: -1
+      code: 0
+      method: 'subscribe'
+      result: {
+        channel: 'ticker'
+        instrument_name: 'BTCUSD-PERP'
+        subscription: 'ticker.BTCUSD-PERP'
+        data: [
+          {
+            h: '32222.5'
+            l: '30240.0'
+            a: '31611.0'
+            c: '0.0320'
+            b: '31613.0'
+            bs?: '0.1000'
+            k: '31613.5'
+            ks?: '0.2000'
+            i: 'BTCUSD-PERP'
+            v: '13206.4884'
+            vv: '433945264.39'
+            oi: '318.5162'
+            t: 1653992543383
+          }
+        ]
       }
-    ]
-  }
-}
+    }
+  | {
+      id: 2
+      method: 'subscribe'
+      code: 0
+      result: {
+        instrument_name: 'ESUSD-PERP'
+        subscription: 'ticker.ESUSD-PERP'
+        channel: 'ticker'
+        data: [
+          {
+            h: '0.09625'
+            l: '0.09230'
+            a: '0.09481'
+            c: '-0.0038'
+            b: '0.09451'
+            bs: '1'
+            k: '0.09452'
+            ks: '8461'
+            i: 'ESUSD-PERP'
+            v: '115'
+            vv: '10.84'
+            oi: '78522'
+            t: 1765238404604
+          }
+        ]
+      }
+    }
+  | {
+      id: -1
+      code: 0
+      method: 'subscribe'
+      result: {
+        channel: 'ticker'
+        instrument_name: 'MATIC_USD'
+        subscription: 'ticker.MATIC_USD'
+        id: 1
+        data: [
+          {
+            h: '1.24383'
+            l: '1.18086'
+            a: '1.19604'
+            c: '-0.0315'
+            b: '1.19591'
+            bs: '0.1'
+            k: '1.19643'
+            ks: '0.7'
+            i: 'MATIC_USD'
+            v: '854908.9'
+            vv: '1043976.96'
+            oi: '0'
+            t: 1677628802241
+          }
+        ]
+      }
+    }
 
 type CryptoComIndexMessage = {
   id: -1

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> => {