Krakenv2 migration (#72)

* feat(krakenv2-migration): added mappers

* feat(krakenv2-migration): mapping only updates, ignore snapshots

* feat(krakenv2-migration): added streaming

* feat(krakenv2-migration): added switch tests

* feat(krakenv2-migration): so we will habdle only bbo events

* feat(krakenv2-migration): added instrument channel

* feat(krakenv2-migration): updates switch date

Author: marcinvalas

src/consts.ts

@@ -124,7 +124,7 @@ const DERIBIT_CHANNELS = [
   'instrument.state.any'
 ] as const
 
-const KRAKEN_CHANNELS = ['trade', 'ticker', 'book', 'spread'] as const
+const KRAKEN_CHANNELS = ['trade', 'ticker', 'book', 'spread', 'instrument'] as const
 
 const OKEX_CHANNELS = [
   'spot/trade',

src/mappers/kraken.ts

@@ -1,15 +1,22 @@
-import { asNonZeroNumberOrUndefined, upperCaseSymbols } from '../handy.ts'
+import { asNonZeroNumberOrUndefined, parseμs, upperCaseSymbols } from '../handy.ts'
 import { BookChange, BookTicker, Trade } from '../types.ts'
 import { Mapper } from './mapper.ts'
-import { exchangeMappers } from './registry.ts'
+import { exchangeMappers, mapper } from './registry.ts'
 
 // https://www.kraken.com/features/websocket-api
+const KRAKEN_V2_API_SWITCH_DATE = new Date('2026-07-10T00:00:00.000Z')
 
 export const krakenMappers = exchangeMappers({
   kraken: {
-    trades: () => krakenTradesMapper,
-    bookChanges: () => krakenBookChangeMapper,
-    bookTickers: () => krakenBookTickerMapper
+    trades: mapper([{ until: KRAKEN_V2_API_SWITCH_DATE, use: () => krakenTradesMapper }, { use: () => new KrakenV2TradesMapper() }]),
+    bookChanges: mapper([
+      { until: KRAKEN_V2_API_SWITCH_DATE, use: () => krakenBookChangeMapper },
+      { use: () => new KrakenV2BookChangeMapper() }
+    ]),
+    bookTickers: mapper([
+      { until: KRAKEN_V2_API_SWITCH_DATE, use: () => krakenBookTickerMapper },
+      { use: () => new KrakenV2BookTickerMapper() }
+    ])
   }
 })
 
@@ -226,3 +233,153 @@ type KrakenSpread = [
   'spread',
   'XBT/USD'
 ]
+
+/** @see https://docs.kraken.com/api/docs/websocket-v2/trade */
+class KrakenV2TradesMapper implements Mapper<'kraken', Trade> {
+  canHandle(message: KrakenV2Trades) {
+    return message.channel === 'trade' && message.type === 'update'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'trade', symbols } as const]
+  }
+
+  *map(message: KrakenV2Trades, localTimestamp: Date): IterableIterator<Trade> {
+    for (const trade of message.data) {
+      const timestamp = new Date(trade.timestamp)
+      timestamp.μs = parseμs(trade.timestamp)
+
+      yield {
+        type: 'trade',
+        symbol: trade.symbol,
+        exchange: 'kraken',
+        id: trade.trade_id.toString(),
+        price: trade.price,
+        amount: trade.qty,
+        side: trade.side,
+        timestamp,
+        localTimestamp
+      }
+    }
+  }
+}
+
+/** @see https://docs.kraken.com/api/docs/websocket-v2/book */
+class KrakenV2BookChangeMapper implements Mapper<'kraken', BookChange> {
+  canHandle(message: KrakenV2Book) {
+    return message.channel === 'book'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'book', symbols } as const]
+  }
+
+  *map(message: KrakenV2Book, localTimestamp: Date): IterableIterator<BookChange> {
+    for (const book of message.data) {
+      const timestamp = new Date(book.timestamp)
+      timestamp.μs = parseμs(book.timestamp)
+
+      yield {
+        type: 'book_change',
+        symbol: book.symbol,
+        exchange: 'kraken',
+        isSnapshot: message.type === 'snapshot',
+        bids: book.bids?.map(this.mapBookLevel) ?? [],
+        asks: book.asks?.map(this.mapBookLevel) ?? [],
+        timestamp,
+        localTimestamp
+      }
+    }
+  }
+
+  private mapBookLevel(level: KrakenV2BookLevel) {
+    return {
+      price: level.price,
+      amount: level.qty
+    }
+  }
+}
+
+/** @see https://docs.kraken.com/api/docs/websocket-v2/ticker  */
+class KrakenV2BookTickerMapper implements Mapper<'kraken', BookTicker> {
+  canHandle(message: KrakenV2Ticker) {
+    return message.channel === 'ticker'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'ticker', symbols } as const]
+  }
+
+  *map(message: KrakenV2Ticker, localTimestamp: Date): IterableIterator<BookTicker> {
+    for (const tickerMessage of message.data) {
+      const timestamp = new Date(tickerMessage.timestamp)
+      timestamp.μs = parseμs(tickerMessage.timestamp)
+
+      yield {
+        type: 'book_ticker',
+        symbol: tickerMessage.symbol,
+        exchange: 'kraken',
+        askAmount: tickerMessage.ask_qty === 0 ? undefined : tickerMessage.ask_qty,
+        askPrice: tickerMessage.ask === 0 ? undefined : tickerMessage.ask,
+        bidPrice: tickerMessage.bid === 0 ? undefined : tickerMessage.bid,
+        bidAmount: tickerMessage.bid_qty === 0 ? undefined : tickerMessage.bid_qty,
+        timestamp,
+        localTimestamp
+      }
+    }
+  }
+}
+
+type KrakenV2Message<Channel extends string, Data> = {
+  channel: Channel
+  type: 'snapshot' | 'update'
+  data: Data[]
+}
+
+type KrakenV2Trades = KrakenV2Message<
+  'trade',
+  {
+    symbol: string
+    side: 'buy' | 'sell'
+    price: number
+    qty: number
+    ord_type?: string
+    trade_id: number
+    timestamp: string
+  }
+>
+
+type KrakenV2Book = KrakenV2Message<
+  'book',
+  {
+    symbol: string
+    bids?: KrakenV2BookLevel[]
+    asks?: KrakenV2BookLevel[]
+    checksum?: number
+    timestamp: string
+  }
+>
+
+type KrakenV2BookLevel = {
+  price: number
+  qty: number
+}
+
+type KrakenV2Ticker = KrakenV2Message<
+  'ticker',
+  {
+    symbol: string
+    bid: number
+    bid_qty: number
+    ask: number
+    ask_qty: number
+    last: number
+    volume: number
+    vwap: number
+    low: number
+    high: number
+    change: number
+    change_pct: number
+    timestamp: string
+  }
+>

src/realtimefeeds/kraken.ts

@@ -2,36 +2,47 @@ import { Filter } from '../types.ts'
 import { RealTimeFeedBase } from './realtimefeed.ts'
 
 export class KrakenRealTimeFeed extends RealTimeFeedBase {
-  protected wssURL = 'wss://ws.kraken.com'
+  private readonly channels = new Set(['trade', 'book', 'ticker', 'instrument'])
+  protected wssURL = 'wss://ws.kraken.com/v2'
 
   protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
-    return filters.map((filter) => {
-      if (!filter.symbols || filter.symbols.length === 0) {
+    return filters.flatMap(({ channel, symbols }): any[] => {
+      if (channel !== 'instrument' && (!symbols || symbols.length === 0)) {
         throw new Error('KrakenRealTimeFeed requires explicitly specified symbols when subscribing to live feed')
       }
 
-      let depth = undefined
+      if (!this.channels.has(channel)) {
+        throw new Error(`KrakenRealTimeFeed unsupported channel ${channel}`)
+      }
 
-      if (filter.channel === 'book') {
-        depth = 1000
+      if (channel === 'instrument') {
+        return [
+          {
+            method: 'subscribe',
+            params: { channel, include_tokenized_assets: true }
+          }
+        ]
       }
 
-      return {
-        event: 'subscribe',
-        pair: filter.symbols,
-        subscription: {
-          name: filter.channel,
-          depth
+      return [
+        {
+          method: 'subscribe',
+          params: {
+            channel,
+            symbol: symbols,
+            ...(channel === 'ticker' ? { event_trigger: 'bbo' } : {}),
+            ...(channel === 'book' ? { depth: 1000 } : {})
+          }
         }
-      }
+      ]
     })
   }
 
   protected messageIsError(message: any): boolean {
-    return message.errorMessage !== undefined
+    return message.errorMessage !== undefined || message.success === false
   }
 
   protected messageIsHeartbeat(message: any): boolean {
-    return message.event === 'heartbeat'
+    return message.event === 'heartbeat' || message.channel === 'heartbeat'
   }
 }

test/__snapshots__/mappers.test.ts.snap

@@ -10761,6 +10761,85 @@ exports[`mappers map kraken messages 7`] = `
 
 exports[`mappers map kraken messages 8`] = `[]`;
 
+exports[`mappers map kraken v2 messages 1`] = `[]`;
+
+exports[`mappers map kraken v2 messages 2`] = `
+[
+  {
+    "amount": 0.25,
+    "exchange": "kraken",
+    "id": "123",
+    "localTimestamp": 2026-07-10T00:00:03.275Z,
+    "price": 100.1,
+    "side": "buy",
+    "symbol": "BTC/USD",
+    "timestamp": 2026-07-10T00:00:00.123456Z,
+    "type": "trade",
+  },
+]
+`;
+
+exports[`mappers map kraken v2 messages 3`] = `
+[
+  {
+    "asks": [
+      {
+        "amount": 0.8,
+        "price": 200.1,
+      },
+    ],
+    "bids": [
+      {
+        "amount": 1.2,
+        "price": 199.9,
+      },
+    ],
+    "exchange": "kraken",
+    "isSnapshot": true,
+    "localTimestamp": 2026-07-10T00:00:03.275Z,
+    "symbol": "AAPLx/USD",
+    "timestamp": 2026-07-10T00:00:01.123457Z,
+    "type": "book_change",
+  },
+]
+`;
+
+exports[`mappers map kraken v2 messages 4`] = `
+[
+  {
+    "asks": [],
+    "bids": [
+      {
+        "amount": 0.5,
+        "price": 99.9,
+      },
+    ],
+    "exchange": "kraken",
+    "isSnapshot": false,
+    "localTimestamp": 2026-07-10T00:00:03.275Z,
+    "symbol": "BTC/USD",
+    "timestamp": 2026-07-10T00:00:01.223456Z,
+    "type": "book_change",
+  },
+]
+`;
+
+exports[`mappers map kraken v2 messages 5`] = `
+[
+  {
+    "askAmount": 2.3,
+    "askPrice": 100.1,
+    "bidAmount": 1.2,
+    "bidPrice": 99.9,
+    "exchange": "kraken",
+    "localTimestamp": 2026-07-10T00:00:03.275Z,
+    "symbol": "BTC/USD",
+    "timestamp": 2026-07-10T00:00:02.123456Z,
+    "type": "book_ticker",
+  },
+]
+`;
+
 exports[`mappers map okcoin messages 1`] = `
 [
   {