Polymarket integration (#66)

* feat(polymarket-integration): added some types

* feat(polymarket-integration): added more types

* feat(polymarket-integration): added more types

* feat(polymarket-integration): added PolymarketBookChangeMapper mapper

* feat(polymarket-integration): added PolymarketTradesMapper mapper

* feat(polymarket-integration): registered mappers

* feat(polymarket-integration): added next channel

* feat(polymarket-integration): added PolymarketBookTickerMapper mapper

* feat(polymarket-integration): added real feed streaming

* feat(polymarket-integration): improved naming

* feat(polymarket-integration): fixed prettier formatting

* feat(polymarket-integration): migration after back-merge

* feat(polymarket-integration): added  new_market and market_resolved channels

* feat(polymarket-integration): improved condition orders

* feat(polymarket-integration): cleanup

* feat(polymarket-integration): SIMPLIFIED

* feat(polymarket-integration): cleanup

* feat(polymarket-integration): cleanup

* feat(polymarket-integration): optimizations

* feat(polymarket-integration): forget about tests

Author: marcinvalas

src/consts.ts

@@ -57,7 +57,8 @@ export const EXCHANGES = [
   'bitget-futures',
   'hyperliquid',
   'lighter',
-  'bullish'
+  'bullish',
+  'polymarket'
 ] as const
 
 const BINANCE_CHANNELS = ['trade', 'aggTrade', 'ticker', 'depth', 'depthSnapshot', 'bookTicker', 'recentTrades', 'borrowInterest'] as const
@@ -525,6 +526,17 @@ const LIGHTER_CHANNELS = ['order_book', 'trade', 'ticker', 'market_stats', 'spot
 
 const BULLISH_CHANNELS = ['V1TALevel2', 'V1TALevel1', 'V1TAAnonymousTradeUpdate', 'V1TATickerResponse', 'V1TAIndexPrice'] as const
 
+const POLYMARKET_CHANNELS = [
+  'book',
+  'price_change',
+  'last_trade_price',
+  'best_bid_ask',
+  'tick_size_change',
+  'sport_result',
+  'new_market',
+  'market_resolved'
+] as const
+
 export const EXCHANGE_CHANNELS_INFO = {
   bitmex: BITMEX_CHANNELS,
   coinbase: COINBASE_CHANNELS,
@@ -584,5 +596,6 @@ export const EXCHANGE_CHANNELS_INFO = {
   'bitget-futures': BITGET_FUTURES_CHANNELS,
   hyperliquid: HYPERLIQUID_CHANNELS,
   lighter: LIGHTER_CHANNELS,
-  bullish: BULLISH_CHANNELS
+  bullish: BULLISH_CHANNELS,
+  polymarket: POLYMARKET_CHANNELS
 }

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'
 
@@ -352,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 = {
@@ -453,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 = {
@@ -603,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> => {

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
+}

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 {