tardis-dev 16.4.2 → 16.5.0

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

package/src/realtimefeeds/polymarket.ts

@@ -0,0 +1,112 @@
+import { Filter } from '../types.ts'
+import { MultiConnectionRealTimeFeedBase, RealTimeFeedBase, RealTimeFeedIterable } from './realtimefeed.ts'
+
+export class PolymarketRealTimeFeed extends MultiConnectionRealTimeFeedBase {
+  private readonly clobChannels = new Set([
+    'book',
+    'price_change',
+    'last_trade_price',
+    'best_bid_ask',
+    'tick_size_change',
+    'new_market',
+    'market_resolved'
+  ])
+  private readonly sportsChannel = 'sport_result'
+
+  protected *_getRealTimeFeeds(
+    exchange: string,
+    filters: Filter<string>[],
+    timeoutIntervalMS?: number,
+    onError?: (error: Error) => void
+  ): IterableIterator<RealTimeFeedIterable> {
+    const clobFilters: Filter<string>[] = []
+    const sportsFilters: Filter<string>[] = []
+
+    for (const filter of filters) {
+      if (this.clobChannels.has(filter.channel)) {
+        clobFilters.push(filter)
+      } else if (filter.channel === this.sportsChannel) {
+        sportsFilters.push(filter)
+      } else {
+        throw new Error(`PolymarketRealTimeFeed unsupported channel ${filter.channel}`)
+      }
+    }
+
+    if (clobFilters.length > 0) {
+      if (clobFilters.every((filter) => filter.symbols === undefined || filter.symbols.length === 0)) {
+        throw new Error('PolymarketRealTimeFeed requires explicitly specified symbols when subscribing to CLOB live feed')
+      }
+
+      yield new PolymarketClobRealTimeFeed(exchange, clobFilters, timeoutIntervalMS, onError)
+    }
+    if (sportsFilters.length > 0) {
+      yield new PolymarketSportsRealTimeFeed(exchange, sportsFilters, timeoutIntervalMS, onError)
+    }
+  }
+}
+
+export class PolymarketClobRealTimeFeed extends RealTimeFeedBase {
+  protected wssURL = 'wss://ws-subscriptions-clob.polymarket.com/ws/market'
+  private readonly pongMessage = Buffer.from('{"__pong__":true}')
+
+  protected decompress = (msg: Buffer): Buffer => {
+    if (msg.toString() === 'PONG') {
+      return this.pongMessage
+    }
+    return msg
+  }
+
+  protected messageIsHeartbeat(msg: any) {
+    return msg.__pong__ === true
+  }
+
+  protected sendCustomPing = () => {
+    this.sendRaw('PING')
+  }
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
+    return [
+      {
+        type: 'market',
+        assets_ids: [...new Set(filters.flatMap((f) => f.symbols ?? []))],
+        initial_dump: true,
+        level: 2,
+        custom_feature_enabled: true
+      }
+    ]
+  }
+
+  protected messageIsError(message: any): boolean {
+    return typeof message.error === 'string'
+  }
+}
+
+export class PolymarketSportsRealTimeFeed extends RealTimeFeedBase {
+  protected wssURL = 'wss://sports-api.polymarket.com/ws'
+  private readonly serverPingMessage = Buffer.from('{"__server_ping__":true}')
+
+  protected decompress = (msg: Buffer): Buffer => {
+    if (msg.toString() === 'ping') {
+      return this.serverPingMessage
+    }
+    return msg
+  }
+
+  protected messageIsHeartbeat(msg: any) {
+    return msg.__server_ping__ === true
+  }
+
+  protected onMessage(msg: any) {
+    if (msg.__server_ping__ === true) {
+      this.sendRaw('pong')
+    }
+  }
+
+  protected mapToSubscribeMessages(_filters: Filter<string>[]): any[] {
+    return []
+  }
+
+  protected messageIsError(message: any): boolean {
+    return typeof message.error === 'string'
+  }
+}

package/src/realtimefeeds/realtimefeed.ts

@@ -219,6 +219,16 @@ export abstract class RealTimeFeedBase implements RealTimeFeedIterable {
     this._ws.send(JSON.stringify(msg))
   }
 
+  protected sendRaw(msg: string | Buffer) {
+    if (this._ws === undefined) {
+      return
+    }
+    if (this._ws.readyState !== WebSocket.OPEN) {
+      return
+    }
+    this._ws.send(msg)
+  }
+
   protected abstract mapToSubscribeMessages(filters: Filter<string>[]): any[]
 
   protected abstract messageIsError(message: any): boolean