tardis-dev 16.4.1 → 16.5.0

package/src/mappers/deribit.ts

@@ -1,4 +1,4 @@
-import { asNumberIfValid } from '../handy.ts'
+import { asNonZeroNumberOrUndefined } from '../handy.ts'
 import { BookChange, BookTicker, DerivativeTicker, Liquidation, OptionSummary, Trade } from '../types.ts'
 import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
 
@@ -200,15 +200,15 @@ export class DeribitOptionSummaryMapper implements Mapper<'deribit', OptionSumma
       strikePrice,
       expirationDate,
 
-      bestBidPrice: asNumberIfValid(optionInfo.best_bid_price),
-      bestBidAmount: asNumberIfValid(optionInfo.best_bid_amount),
-      bestBidIV: asNumberIfValid(optionInfo.bid_iv),
+      bestBidPrice: asNonZeroNumberOrUndefined(optionInfo.best_bid_price),
+      bestBidAmount: asNonZeroNumberOrUndefined(optionInfo.best_bid_amount),
+      bestBidIV: asNonZeroNumberOrUndefined(optionInfo.bid_iv),
 
-      bestAskPrice: asNumberIfValid(optionInfo.best_ask_price),
-      bestAskAmount: asNumberIfValid(optionInfo.best_ask_amount),
-      bestAskIV: asNumberIfValid(optionInfo.ask_iv),
+      bestAskPrice: asNonZeroNumberOrUndefined(optionInfo.best_ask_price),
+      bestAskAmount: asNonZeroNumberOrUndefined(optionInfo.best_ask_amount),
+      bestAskIV: asNonZeroNumberOrUndefined(optionInfo.ask_iv),
 
-      lastPrice: asNumberIfValid(optionInfo.last_price),
+      lastPrice: asNonZeroNumberOrUndefined(optionInfo.last_price),
       openInterest: optionInfo.open_interest,
 
       markPrice: optionInfo.mark_price,
@@ -308,10 +308,10 @@ export const deribitBookTickerMapper: Mapper<'deribit', BookTicker> = {
       symbol: deribitTicker.instrument_name.toUpperCase(),
       exchange: 'deribit',
 
-      askAmount: asNumberIfValid(deribitTicker.best_ask_amount),
-      askPrice: asNumberIfValid(deribitTicker.best_ask_price),
-      bidPrice: asNumberIfValid(deribitTicker.best_bid_price),
-      bidAmount: asNumberIfValid(deribitTicker.best_bid_amount),
+      askAmount: asNonZeroNumberOrUndefined(deribitTicker.best_ask_amount),
+      askPrice: asNonZeroNumberOrUndefined(deribitTicker.best_ask_price),
+      bidPrice: asNonZeroNumberOrUndefined(deribitTicker.best_bid_price),
+      bidAmount: asNonZeroNumberOrUndefined(deribitTicker.best_bid_amount),
 
       timestamp: new Date(deribitTicker.timestamp),
       localTimestamp: localTimestamp

package/src/mappers/ftx.ts

@@ -1,4 +1,4 @@
-import { asNumberIfValid, parseμs, upperCaseSymbols } from '../handy.ts'
+import { asNonZeroNumberOrUndefined, parseμs, upperCaseSymbols } from '../handy.ts'
 import { BookChange, BookTicker, DerivativeTicker, Exchange, Liquidation, Trade } from '../types.ts'
 import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
 
@@ -229,11 +229,11 @@ export class FTXBookTickerMapper implements Mapper<'ftx' | 'ftx-us', BookTicker>
       symbol: ftxTicker.market,
       exchange: this._exchange,
 
-      askAmount: asNumberIfValid(ftxTicker.data.askSize),
-      askPrice: asNumberIfValid(ftxTicker.data.ask),
+      askAmount: asNonZeroNumberOrUndefined(ftxTicker.data.askSize),
+      askPrice: asNonZeroNumberOrUndefined(ftxTicker.data.ask),
 
-      bidPrice: asNumberIfValid(ftxTicker.data.bid),
-      bidAmount: asNumberIfValid(ftxTicker.data.bidSize),
+      bidPrice: asNonZeroNumberOrUndefined(ftxTicker.data.bid),
+      bidAmount: asNonZeroNumberOrUndefined(ftxTicker.data.bidSize),
       timestamp,
       localTimestamp: localTimestamp
     }

package/src/mappers/huobi.ts

@@ -1,4 +1,4 @@
-import { asNumberIfValid, CircularBuffer, upperCaseSymbols } from '../handy.ts'
+import { asNonZeroNumberOrUndefined, CircularBuffer, upperCaseSymbols } from '../handy.ts'
 import { BookChange, BookTicker, DerivativeTicker, Exchange, FilterForExchange, Liquidation, OptionSummary, Trade } from '../types.ts'
 import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
 
@@ -489,26 +489,26 @@ export class HuobiOptionsSummaryMapper implements Mapper<'huobi-dm-options', Opt
       strikePrice: Number(symbolParts[4]),
       expirationDate,
 
-      bestBidPrice: asNumberIfValid(marketIndexMessage.data.bid_one),
+      bestBidPrice: asNonZeroNumberOrUndefined(marketIndexMessage.data.bid_one),
 
       bestBidAmount: undefined,
-      bestBidIV: asNumberIfValid(marketIndexMessage.data.iv_bid_one),
+      bestBidIV: asNonZeroNumberOrUndefined(marketIndexMessage.data.iv_bid_one),
 
-      bestAskPrice: asNumberIfValid(marketIndexMessage.data.ask_one),
+      bestAskPrice: asNonZeroNumberOrUndefined(marketIndexMessage.data.ask_one),
       bestAskAmount: undefined,
-      bestAskIV: asNumberIfValid(marketIndexMessage.data.iv_ask_one),
+      bestAskIV: asNonZeroNumberOrUndefined(marketIndexMessage.data.iv_ask_one),
 
-      lastPrice: asNumberIfValid(marketIndexMessage.data.last_price),
+      lastPrice: asNonZeroNumberOrUndefined(marketIndexMessage.data.last_price),
 
       openInterest,
 
-      markPrice: marketIndexMessage.data.mark_price > 0 ? asNumberIfValid(marketIndexMessage.data.mark_price) : undefined,
-      markIV: asNumberIfValid(marketIndexMessage.data.iv_mark_price),
+      markPrice: marketIndexMessage.data.mark_price > 0 ? asNonZeroNumberOrUndefined(marketIndexMessage.data.mark_price) : undefined,
+      markIV: asNonZeroNumberOrUndefined(marketIndexMessage.data.iv_mark_price),
 
-      delta: asNumberIfValid(marketIndexMessage.data.delta),
-      gamma: asNumberIfValid(marketIndexMessage.data.gamma),
-      vega: asNumberIfValid(marketIndexMessage.data.vega),
-      theta: asNumberIfValid(marketIndexMessage.data.theta),
+      delta: asNonZeroNumberOrUndefined(marketIndexMessage.data.delta),
+      gamma: asNonZeroNumberOrUndefined(marketIndexMessage.data.gamma),
+      vega: asNonZeroNumberOrUndefined(marketIndexMessage.data.vega),
+      theta: asNonZeroNumberOrUndefined(marketIndexMessage.data.theta),
       rho: undefined,
 
       underlyingPrice: lastUnderlyingPrice,
@@ -555,11 +555,11 @@ export class HuobiBookTickerMapper implements Mapper<'huobi' | 'huobi-dm' | 'huo
         symbol,
         exchange: this._exchange,
 
-        askAmount: asNumberIfValid(message.tick.askSize),
-        askPrice: asNumberIfValid(message.tick.ask),
+        askAmount: asNonZeroNumberOrUndefined(message.tick.askSize),
+        askPrice: asNonZeroNumberOrUndefined(message.tick.ask),
 
-        bidPrice: asNumberIfValid(message.tick.bid),
-        bidAmount: asNumberIfValid(message.tick.bidSize),
+        bidPrice: asNonZeroNumberOrUndefined(message.tick.bid),
+        bidAmount: asNonZeroNumberOrUndefined(message.tick.bidSize),
         timestamp: new Date(message.tick.quoteTime),
         localTimestamp: localTimestamp
       }
@@ -569,11 +569,11 @@ export class HuobiBookTickerMapper implements Mapper<'huobi' | 'huobi-dm' | 'huo
         symbol,
         exchange: this._exchange,
 
-        askAmount: message.tick.ask !== undefined && message.tick.ask !== null ? asNumberIfValid(message.tick.ask[1]) : undefined,
-        askPrice: message.tick.ask !== undefined && message.tick.ask !== null ? asNumberIfValid(message.tick.ask[0]) : undefined,
+        askAmount: asNonZeroNumberOrUndefined(message.tick.ask?.[1]),
+        askPrice: asNonZeroNumberOrUndefined(message.tick.ask?.[0]),
 
-        bidPrice: message.tick.bid !== undefined && message.tick.bid !== null ? asNumberIfValid(message.tick.bid[0]) : undefined,
-        bidAmount: message.tick.bid !== undefined && message.tick.bid !== null ? asNumberIfValid(message.tick.bid[1]) : undefined,
+        bidPrice: asNonZeroNumberOrUndefined(message.tick.bid?.[0]),
+        bidAmount: asNonZeroNumberOrUndefined(message.tick.bid?.[1]),
         timestamp: new Date(message.tick.ts),
         localTimestamp: localTimestamp
       }

package/src/mappers/index.ts

@@ -169,6 +169,7 @@ import { PoloniexBookChangeMapper, PoloniexTradesMapper, PoloniexV2BookChangeMap
 import { SerumBookChangeMapper, SerumBookTickerMapper, SerumTradesMapper } from './serum.ts'
 import { UpbitBookChangeMapper, UpbitTradesMapper } from './upbit.ts'
 import { WooxBookChangeMapper, WooxBookTickerMapper, WooxDerivativeTickerMapper, wooxTradesMapper } from './woox.ts'
+import { PolymarketBookChangeMapper, PolymarketBookTickerMapper, PolymarketTradesMapper } from './polymarket.ts'
 
 export * from './mapper.ts'
 
@@ -183,6 +184,7 @@ const isRealTime = (date: Date) => {
 
 const OKEX_V5_API_SWITCH_DATE = new Date('2021-12-23T00:00:00.000Z')
 const OKEX_V5_TBT_BOOK_TICKER_RELEASE_DATE = new Date('2022-05-06T00:00:00.000Z')
+const OKEX_PUBLIC_BOOKS_SWITCH_DATE = new Date('2026-05-21T00:00:00.000Z')
 const shouldUseOkexV5Mappers = (localTimestamp: Date) => {
   return isRealTime(localTimestamp) || localTimestamp.valueOf() >= OKEX_V5_API_SWITCH_DATE.valueOf()
 }
@@ -200,8 +202,9 @@ const shouldUsePoloniexV2Mappers = (localTimestamp: Date) => {
 // see https://status.tardis.dev/incidents/ryjyv8tgdgkj
 const shouldUseOKXPublicBooksChannel = (localTimestamp: Date) => {
   return (
-    localTimestamp.valueOf() >= new Date('2023-02-25T00:00:00.000Z').valueOf() &&
-    localTimestamp.valueOf() < new Date('2023-03-09T00:00:00.000Z').valueOf()
+    (localTimestamp.valueOf() >= new Date('2023-02-25T00:00:00.000Z').valueOf() &&
+      localTimestamp.valueOf() < new Date('2023-03-09T00:00:00.000Z').valueOf()) ||
+    localTimestamp.valueOf() >= OKEX_PUBLIC_BOOKS_SWITCH_DATE.valueOf()
   )
 }
 
@@ -350,7 +353,8 @@ const tradesMappers = {
   'coinbase-international': () => coinbaseInternationalTradesMapper,
   hyperliquid: () => new HyperliquidTradesMapper(),
   lighter: () => new LighterTradesMapper(),
-  bullish: () => new BullishTradesMapper()
+  bullish: () => new BullishTradesMapper(),
+  polymarket: () => new PolymarketTradesMapper()
 }
 
 const bookChangeMappers = {
@@ -451,7 +455,8 @@ const bookChangeMappers = {
   'coinbase-international': () => new CoinbaseInternationalBookChangMapper(),
   hyperliquid: () => new HyperliquidBookChangeMapper(),
   lighter: () => new LighterBookChangeMapper(),
-  bullish: () => new BullishBookChangeMapper()
+  bullish: () => new BullishBookChangeMapper(),
+  polymarket: () => new PolymarketBookChangeMapper()
 }
 
 const derivativeTickersMappers = {
@@ -601,7 +606,8 @@ const bookTickersMappers = {
   hyperliquid: () => new HyperliquidBookTickerMapper(),
   lighter: () => new LighterBookTickerMapper(),
   bullish: () => new BullishBookTickerMapper(),
-  'binance-european-options': () => new BinanceEuropeanOptionsBookTickerMapper()
+  'binance-european-options': () => new BinanceEuropeanOptionsBookTickerMapper(),
+  polymarket: () => new PolymarketBookTickerMapper()
 }
 
 export const normalizeTrades = <T extends keyof typeof tradesMappers>(exchange: T, localTimestamp: Date): Mapper<T, Trade> => {

package/src/mappers/kraken.ts

@@ -1,4 +1,4 @@
-import { asNumberIfValid, upperCaseSymbols } from '../handy.ts'
+import { asNonZeroNumberOrUndefined, upperCaseSymbols } from '../handy.ts'
 import { BookChange, BookTicker, Trade } from '../types.ts'
 import { Mapper } from './mapper.ts'
 
@@ -158,11 +158,11 @@ export const krakenBookTickerMapper: Mapper<'kraken', BookTicker> = {
       symbol: message[3],
       exchange: 'kraken',
 
-      askAmount: asNumberIfValid(askVolume),
-      askPrice: asNumberIfValid(ask),
+      askAmount: asNonZeroNumberOrUndefined(askVolume),
+      askPrice: asNonZeroNumberOrUndefined(ask),
 
-      bidPrice: asNumberIfValid(bid),
-      bidAmount: asNumberIfValid(bidVolume),
+      bidPrice: asNonZeroNumberOrUndefined(bid),
+      bidAmount: asNonZeroNumberOrUndefined(bidVolume),
       timestamp,
       localTimestamp: localTimestamp
     }

package/src/mappers/kucoinfutures.ts

@@ -1,5 +1,5 @@
 import { debug } from '../debug.ts'
-import { asNumberIfValid, CircularBuffer, upperCaseSymbols } from '../handy.ts'
+import { asNonZeroNumberOrUndefined, CircularBuffer, upperCaseSymbols } from '../handy.ts'
 import { BookChange, BookTicker, DerivativeTicker, Trade } from '../types.ts'
 import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
 
@@ -310,7 +310,7 @@ export class KucoinFuturesDerivativeTickerMapper implements Mapper<'kucoin-futur
     }
 
     if (message.subject === 'contractDetails') {
-      const openInterestValue = asNumberIfValid(message.data.openInterest)
+      const openInterestValue = asNonZeroNumberOrUndefined(message.data.openInterest)
       if (openInterestValue === undefined) {
         return
       }

package/src/mappers/lighter.ts

@@ -1,4 +1,4 @@
-import { asNumberIfValid } from '../handy.ts'
+import { asNonZeroNumberOrUndefined } from '../handy.ts'
 import { BookChange, BookTicker, DerivativeTicker, Liquidation, Trade } from '../types.ts'
 import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
 
@@ -144,10 +144,10 @@ export class LighterBookTickerMapper implements Mapper<'lighter', BookTicker> {
       type: 'book_ticker',
       symbol,
       exchange: 'lighter',
-      askAmount: asNumberIfValid(message.ticker?.a?.size),
-      askPrice: asNumberIfValid(message.ticker?.a?.price),
-      bidPrice: asNumberIfValid(message.ticker?.b?.price),
-      bidAmount: asNumberIfValid(message.ticker?.b?.size),
+      askAmount: asNonZeroNumberOrUndefined(message.ticker?.a?.size),
+      askPrice: asNonZeroNumberOrUndefined(message.ticker?.a?.price),
+      bidPrice: asNonZeroNumberOrUndefined(message.ticker?.b?.price),
+      bidAmount: asNonZeroNumberOrUndefined(message.ticker?.b?.size),
       timestamp: new Date(message.timestamp),
       localTimestamp
     }

package/src/mappers/okex.ts

@@ -1,4 +1,4 @@
-import { asNumberIfValid, upperCaseSymbols } from '../handy.ts'
+import { asNonZeroNumberOrUndefined, upperCaseSymbols } from '../handy.ts'
 import { BookChange, BookTicker, DerivativeTicker, Exchange, Liquidation, OptionSummary, Trade } from '../types.ts'
 import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
 
@@ -221,11 +221,11 @@ export class OkexV5BookTickerMapper implements Mapper<OKEX_EXCHANGES, BookTicker
         symbol: okexTicker.instId,
         exchange: this._exchange,
 
-        askAmount: asNumberIfValid(okexTicker.askSz),
-        askPrice: asNumberIfValid(okexTicker.askPx),
+        askAmount: asNonZeroNumberOrUndefined(okexTicker.askSz),
+        askPrice: asNonZeroNumberOrUndefined(okexTicker.askPx),
 
-        bidPrice: asNumberIfValid(okexTicker.bidPx),
-        bidAmount: asNumberIfValid(okexTicker.bidSz),
+        bidPrice: asNonZeroNumberOrUndefined(okexTicker.bidPx),
+        bidAmount: asNonZeroNumberOrUndefined(okexTicker.bidSz),
         timestamp: new Date(Number(okexTicker.ts)),
         localTimestamp: localTimestamp
       }
@@ -501,7 +501,7 @@ export class OkexV5OptionSummaryMapper implements Mapper<'okex-options', OptionS
       for (const dataMessage of message.data) {
         const indexTickerMessage = dataMessage as OkexV5IndexTickerMessage['data'][0]
 
-        const lastIndexPrice = asNumberIfValid(indexTickerMessage.idxPx)
+        const lastIndexPrice = asNonZeroNumberOrUndefined(indexTickerMessage.idxPx)
         if (lastIndexPrice !== undefined) {
           this._indexPrices.set(indexTickerMessage.instId, lastIndexPrice)
         }
@@ -513,7 +513,7 @@ export class OkexV5OptionSummaryMapper implements Mapper<'okex-options', OptionS
       for (const dataMessage of message.data) {
         const openInterestMessage = dataMessage as OkexV5OpenInterestMessage['data'][0]
 
-        const openInterestValue = asNumberIfValid(openInterestMessage.oi)
+        const openInterestValue = asNonZeroNumberOrUndefined(openInterestMessage.oi)
         if (openInterestValue !== undefined) {
           this._openInterests.set(openInterestMessage.instId, openInterestValue)
         }
@@ -525,7 +525,7 @@ export class OkexV5OptionSummaryMapper implements Mapper<'okex-options', OptionS
       for (const dataMessage of message.data) {
         const markPriceMessage = dataMessage as OkexV5MarkPriceMessage['data'][0]
 
-        const markPrice = asNumberIfValid(markPriceMessage.markPx)
+        const markPrice = asNonZeroNumberOrUndefined(markPriceMessage.markPx)
         if (markPrice !== undefined) {
           this._markPrices.set(markPriceMessage.instId, markPrice)
         }
@@ -569,24 +569,24 @@ export class OkexV5OptionSummaryMapper implements Mapper<'okex-options', OptionS
           strikePrice,
           expirationDate,
 
-          bestBidPrice: lastTickerInfo !== undefined ? asNumberIfValid(lastTickerInfo.bidPx) : undefined,
-          bestBidAmount: lastTickerInfo !== undefined ? asNumberIfValid(lastTickerInfo.bidSz) : undefined,
-          bestBidIV: asNumberIfValid(summary.bidVol),
+          bestBidPrice: asNonZeroNumberOrUndefined(lastTickerInfo?.bidPx),
+          bestBidAmount: asNonZeroNumberOrUndefined(lastTickerInfo?.bidSz),
+          bestBidIV: asNonZeroNumberOrUndefined(summary.bidVol),
 
-          bestAskPrice: lastTickerInfo !== undefined ? asNumberIfValid(lastTickerInfo.askPx) : undefined,
-          bestAskAmount: lastTickerInfo !== undefined ? asNumberIfValid(lastTickerInfo.askSz) : undefined,
-          bestAskIV: asNumberIfValid(summary.askVol),
+          bestAskPrice: asNonZeroNumberOrUndefined(lastTickerInfo?.askPx),
+          bestAskAmount: asNonZeroNumberOrUndefined(lastTickerInfo?.askSz),
+          bestAskIV: asNonZeroNumberOrUndefined(summary.askVol),
 
-          lastPrice: lastTickerInfo !== undefined ? asNumberIfValid(lastTickerInfo.last) : undefined,
+          lastPrice: asNonZeroNumberOrUndefined(lastTickerInfo?.last),
           openInterest: lastOpenInterest,
 
           markPrice: lastMarkPrice,
-          markIV: asNumberIfValid(summary.markVol),
+          markIV: asNonZeroNumberOrUndefined(summary.markVol),
 
-          delta: asNumberIfValid(summary.delta),
-          gamma: asNumberIfValid(summary.gamma),
-          vega: asNumberIfValid(summary.vega),
-          theta: asNumberIfValid(summary.theta),
+          delta: asNonZeroNumberOrUndefined(summary.delta),
+          gamma: asNonZeroNumberOrUndefined(summary.gamma),
+          vega: asNonZeroNumberOrUndefined(summary.vega),
+          theta: asNonZeroNumberOrUndefined(summary.theta),
           rho: undefined,
 
           underlyingPrice: lastUnderlyingPrice,
@@ -970,24 +970,24 @@ export class OkexOptionSummaryMapper implements Mapper<'okex-options', OptionSum
         strikePrice,
         expirationDate,
 
-        bestBidPrice: asNumberIfValid(summary.best_bid),
-        bestBidAmount: asNumberIfValid(summary.best_bid_size),
-        bestBidIV: asNumberIfValid(summary.bid_vol),
+        bestBidPrice: asNonZeroNumberOrUndefined(summary.best_bid),
+        bestBidAmount: asNonZeroNumberOrUndefined(summary.best_bid_size),
+        bestBidIV: asNonZeroNumberOrUndefined(summary.bid_vol),
 
-        bestAskPrice: asNumberIfValid(summary.best_ask),
-        bestAskAmount: asNumberIfValid(summary.best_ask_size),
-        bestAskIV: asNumberIfValid(summary.ask_vol),
+        bestAskPrice: asNonZeroNumberOrUndefined(summary.best_ask),
+        bestAskAmount: asNonZeroNumberOrUndefined(summary.best_ask_size),
+        bestAskIV: asNonZeroNumberOrUndefined(summary.ask_vol),
 
-        lastPrice: asNumberIfValid(summary.last),
-        openInterest: asNumberIfValid(summary.open_interest),
+        lastPrice: asNonZeroNumberOrUndefined(summary.last),
+        openInterest: asNonZeroNumberOrUndefined(summary.open_interest),
 
-        markPrice: asNumberIfValid(summary.mark_price),
-        markIV: asNumberIfValid(summary.mark_vol),
+        markPrice: asNonZeroNumberOrUndefined(summary.mark_price),
+        markIV: asNonZeroNumberOrUndefined(summary.mark_vol),
 
-        delta: asNumberIfValid(summary.delta),
-        gamma: asNumberIfValid(summary.gamma),
-        vega: asNumberIfValid(summary.vega),
-        theta: asNumberIfValid(summary.theta),
+        delta: asNonZeroNumberOrUndefined(summary.delta),
+        gamma: asNonZeroNumberOrUndefined(summary.gamma),
+        vega: asNonZeroNumberOrUndefined(summary.vega),
+        theta: asNonZeroNumberOrUndefined(summary.theta),
         rho: undefined,
 
         underlyingPrice: lastUnderlyingPrice,
@@ -1069,11 +1069,11 @@ export class OkexBookTickerMapper implements Mapper<OKEX_EXCHANGES, BookTicker>
         symbol: okexTicker.instrument_id,
         exchange: this._exchange,
 
-        askAmount: asNumberIfValid(okexTicker.best_ask_size),
-        askPrice: asNumberIfValid(okexTicker.best_ask),
+        askAmount: asNonZeroNumberOrUndefined(okexTicker.best_ask_size),
+        askPrice: asNonZeroNumberOrUndefined(okexTicker.best_ask),
 
-        bidPrice: asNumberIfValid(okexTicker.best_bid),
-        bidAmount: asNumberIfValid(okexTicker.best_bid_size),
+        bidPrice: asNonZeroNumberOrUndefined(okexTicker.best_bid),
+        bidAmount: asNonZeroNumberOrUndefined(okexTicker.best_bid_size),
         timestamp: new Date(okexTicker.timestamp),
         localTimestamp: localTimestamp
       }

package/src/mappers/polymarket.ts

@@ -0,0 +1,195 @@
+import { BookChange, BookTicker, Trade } from '../types.ts'
+import { asNonZeroNumberOrUndefined } from '../handy.ts'
+import { Mapper } from './mapper.ts'
+
+type PolymarketBookChangeMapperMessage = PolymarketClobBookMessage | PolymarketClobBookMessage[] | PolymarketClobPriceChangeMessage
+export class PolymarketBookChangeMapper implements Mapper<'polymarket', BookChange> {
+  canHandle(message: PolymarketNativeMessage): message is PolymarketBookChangeMapperMessage {
+    if (Array.isArray(message)) {
+      return message.length > 0 && message.every(isPolymarketClobBookMessage)
+    }
+    return isPolymarketClobPriceChangeMessage(message) || isPolymarketClobBookMessage(message)
+  }
+
+  getFilters(symbols?: string[]) {
+    return [
+      { channel: 'book' as const, symbols },
+      { channel: 'price_change' as const, symbols }
+    ]
+  }
+
+  *map(message: PolymarketNativeMessage, localTimestamp: Date): IterableIterator<BookChange> {
+    if (Array.isArray(message)) {
+      for (const bookMsg of message) {
+        yield this.mapBookSnapshot(bookMsg, localTimestamp)
+      }
+      return
+    }
+
+    if (isPolymarketClobPriceChangeMessage(message)) {
+      const timestamp = new Date(Number(message.timestamp))
+      const changes = message.price_changes
+
+      for (let i = 0; i < changes.length; i++) {
+        const change = changes[i]
+        const level = this.mapLevel(change)
+
+        yield {
+          type: 'book_change',
+          symbol: change.asset_id,
+          exchange: 'polymarket',
+          isSnapshot: false,
+          bids: change.side === 'BUY' ? [level] : [],
+          asks: change.side === 'SELL' ? [level] : [],
+          timestamp,
+          localTimestamp
+        }
+      }
+
+      return
+    }
+
+    if (isPolymarketClobBookMessage(message)) {
+      yield this.mapBookSnapshot(message, localTimestamp)
+      return
+    }
+  }
+
+  private mapBookSnapshot(message: PolymarketClobBookMessage, localTimestamp: Date): BookChange {
+    return {
+      type: 'book_change',
+      symbol: message.asset_id,
+      exchange: 'polymarket',
+      isSnapshot: true,
+      bids: message.bids.map(this.mapLevel.bind(this)),
+      asks: message.asks.map(this.mapLevel.bind(this)),
+      timestamp: new Date(Number(message.timestamp)),
+      localTimestamp
+    }
+  }
+
+  private mapLevel(level: Pick<PolymarketClobBookLevel, 'price' | 'size'>) {
+    return {
+      price: Number(level.price),
+      amount: Number(level.size)
+    }
+  }
+}
+
+export class PolymarketTradesMapper implements Mapper<'polymarket', Trade> {
+  canHandle(message: any): message is PolymarketClobLastTradePriceMessage {
+    return message.event_type === 'last_trade_price'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'last_trade_price' as const, symbols }]
+  }
+
+  *map(message: PolymarketClobLastTradePriceMessage, localTimestamp: Date): IterableIterator<Trade> {
+    yield {
+      type: 'trade',
+      symbol: message.asset_id,
+      exchange: 'polymarket',
+      id: message.transaction_hash,
+      price: Number(message.price),
+      amount: Number(message.size),
+      side: message.side.toLowerCase() as Lowercase<PolymarketClobTradeSide>,
+      timestamp: new Date(Number(message.timestamp)),
+      localTimestamp
+    }
+  }
+}
+
+export class PolymarketBookTickerMapper implements Mapper<'polymarket', BookTicker> {
+  canHandle(message: any): message is PolymarketClobBestBidAskMessage {
+    return message.event_type === 'best_bid_ask'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'best_bid_ask' as const, symbols }]
+  }
+
+  *map(message: PolymarketClobBestBidAskMessage, localTimestamp: Date): IterableIterator<BookTicker> {
+    yield {
+      type: 'book_ticker',
+      symbol: message.asset_id,
+      exchange: 'polymarket',
+      bidPrice: asNonZeroNumberOrUndefined(message.best_bid),
+      bidAmount: undefined,
+      askPrice: asNonZeroNumberOrUndefined(message.best_ask),
+      askAmount: undefined,
+      timestamp: new Date(Number(message.timestamp)),
+      localTimestamp
+    }
+  }
+}
+
+export type PolymarketNativeMessage =
+  | PolymarketClobBookMessage
+  | PolymarketClobBookMessage[]
+  | PolymarketClobPriceChangeMessage
+  | PolymarketClobLastTradePriceMessage
+  | PolymarketClobBestBidAskMessage
+
+type PolymarketClobEventType = 'book' | 'price_change' | 'last_trade_price' | 'best_bid_ask'
+
+type PolymarketClobMessage<T extends PolymarketClobEventType = PolymarketClobEventType> = {
+  event_type: T
+  market: string
+}
+
+function isPolymarketClobBookMessage(message: any): message is PolymarketClobBookMessage {
+  return message?.event_type === 'book'
+}
+type PolymarketClobBookMessage = PolymarketClobMessage<'book'> & {
+  asset_id: string
+  timestamp: string
+  hash: string
+  bids: PolymarketClobBookLevel[]
+  asks: PolymarketClobBookLevel[]
+  tick_size?: string
+  last_trade_price?: string
+}
+
+type PolymarketClobBookLevel = {
+  price: string
+  size: string
+}
+
+function isPolymarketClobPriceChangeMessage(message: any): message is PolymarketClobPriceChangeMessage {
+  return message?.event_type === 'price_change'
+}
+type PolymarketClobPriceChangeMessage = PolymarketClobMessage<'price_change'> & {
+  timestamp: string
+  price_changes: PolymarketClobPriceChange[]
+}
+
+type PolymarketClobPriceChange = {
+  asset_id: string
+  price: string
+  size: string
+  side: PolymarketClobTradeSide
+  hash: string
+  best_bid: string
+  best_ask: string
+}
+
+type PolymarketClobLastTradePriceMessage = PolymarketClobMessage<'last_trade_price'> & {
+  asset_id: string
+  fee_rate_bps: string
+  price: string
+  side: PolymarketClobTradeSide
+  size: string
+  timestamp: string
+  transaction_hash: string
+}
+
+type PolymarketClobTradeSide = 'BUY' | 'SELL'
+
+type PolymarketClobBestBidAskMessage = PolymarketClobMessage<'best_bid_ask'> & {
+  asset_id: string
+  best_bid: string
+  best_ask: string
+  spread: string
+  timestamp: string
+}

package/src/mappers/serum.ts

@@ -1,4 +1,4 @@
-import { asNumberIfValid, upperCaseSymbols } from '../handy.ts'
+import { asNonZeroNumberOrUndefined, upperCaseSymbols } from '../handy.ts'
 import { BookChange, BookTicker, Exchange, Trade } from '../types.ts'
 import { Mapper } from './mapper.ts'
 
@@ -107,11 +107,11 @@ export class SerumBookTickerMapper implements Mapper<'serum' | 'star-atlas', Boo
       symbol: message.market.toUpperCase(),
       exchange: this._exchange,
 
-      askAmount: message.bestAsk !== undefined ? asNumberIfValid(message.bestAsk[1]) : undefined,
-      askPrice: message.bestAsk !== undefined ? asNumberIfValid(message.bestAsk[0]) : undefined,
+      askAmount: asNonZeroNumberOrUndefined(message.bestAsk?.[1]),
+      askPrice: asNonZeroNumberOrUndefined(message.bestAsk?.[0]),
 
-      bidPrice: message.bestBid !== undefined ? asNumberIfValid(message.bestBid[0]) : undefined,
-      bidAmount: message.bestBid !== undefined ? asNumberIfValid(message.bestBid[1]) : undefined,
+      bidPrice: asNonZeroNumberOrUndefined(message.bestBid?.[0]),
+      bidAmount: asNonZeroNumberOrUndefined(message.bestBid?.[1]),
       timestamp: new Date(message.timestamp),
       localTimestamp: localTimestamp
     }

package/src/realtimefeeds/index.ts

@@ -54,6 +54,7 @@ import { CoinbaseInternationalRealTimeFeed } from './coinbaseinternational.ts'
 import { HyperliquidRealTimeFeed } from './hyperliquid.ts'
 import { LighterRealTimeFeed } from './lighter.ts'
 import { BullishRealTimeFeed } from './bullish.ts'
+import { PolymarketRealTimeFeed } from './polymarket.ts'
 
 export * from './realtimefeed.ts'
 
@@ -118,7 +119,8 @@ const realTimeFeedsMap: {
   'coinbase-international': CoinbaseInternationalRealTimeFeed,
   hyperliquid: HyperliquidRealTimeFeed,
   lighter: LighterRealTimeFeed,
-  bullish: BullishRealTimeFeed
+  bullish: BullishRealTimeFeed,
+  polymarket: PolymarketRealTimeFeed
 }
 
 export function getRealTimeFeedFactory(exchange: Exchange): RealTimeFeed {