tardis-dev 16.5.1 → 16.6.0

package/src/mappers/phemex.ts

@@ -1,5 +1,14 @@
 import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
 import { Trade, BookChange, DerivativeTicker } from '../types.ts'
+import { exchangeMappers } from './registry.ts'
+
+export const phemexMappers = exchangeMappers({
+  phemex: {
+    trades: () => phemexTradesMapper,
+    bookChanges: () => phemexBookChangeMapper,
+    derivativeTickers: () => new PhemexDerivativeTickerMapper()
+  }
+})
 
 // phemex provides timestamps in nanoseconds
 const fromNanoSecondsToDate = (nanos: number) => {
@@ -45,6 +54,7 @@ const COINS_STARTING_WITH_S = [
   'STGUSD',
   'SLPUUSD',
   'SPELLUSD',
+  'SSVUSDT',
   'SSVUSD',
   'STXUSD',
   'SUIUSD',
@@ -101,7 +111,15 @@ const COINS_STARTING_WITH_S = [
   'SPORTFUNUSDT',
   'SKRUSDT',
   'SPACEUSDT',
+  'SPACEXUSDT',
+  'STARUSDT',
+  'SOXLUSDT',
+  'SPCXUSDT',
+  'SAMSUNGUSDT',
+  'SKHYNIXUSDT',
+  'SLXUSDT',
   'SPX500USDT',
+  'STXXUSDT',
   'SPYXUSDT',
   'SP500USDT',
   'SNDKUSDT'
@@ -111,7 +129,10 @@ function getInstrumentType(symbol: string) {
     return 'future'
   }
 
-  if (COINS_STARTING_WITH_S.some((c) => symbol.startsWith(c)) || symbol.startsWith('S') === false) {
+  if (
+    COINS_STARTING_WITH_S.some((coin) => (coin === 'SUSDT' ? symbol === coin : symbol.startsWith(coin))) ||
+    symbol.startsWith('S') === false
+  ) {
     return 'perpetual'
   }
 
@@ -144,7 +165,7 @@ function getSymbols(symbols: string[]) {
   }
 }
 
-export const phemexTradesMapper: Mapper<'phemex', Trade> = {
+const phemexTradesMapper: Mapper<'phemex', Trade> = {
   canHandle(message: PhemexTradeMessage) {
     return message.type === 'incremental' && ('trades' in message || 'trades_p' in message)
   },
@@ -235,7 +256,7 @@ function mapPerpBookLevel([price, amount]: [string, string]) {
   }
 }
 
-export const phemexBookChangeMapper: Mapper<'phemex', BookChange> = {
+const phemexBookChangeMapper: Mapper<'phemex', BookChange> = {
   canHandle(message: PhemexBookMessage) {
     return 'book' in message || 'orderbook_p' in message
   },
@@ -305,7 +326,7 @@ export const phemexBookChangeMapper: Mapper<'phemex', BookChange> = {
   }
 }
 
-export class PhemexDerivativeTickerMapper implements Mapper<'phemex', DerivativeTicker> {
+class PhemexDerivativeTickerMapper implements Mapper<'phemex', DerivativeTicker> {
   private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
 
   canHandle(message: PhemexTicker) {

package/src/mappers/poloniex.ts

@@ -1,8 +1,24 @@
 import { upperCaseSymbols } from '../handy.ts'
 import { BookChange, Trade } from '../types.ts'
 import { Mapper } from './mapper.ts'
+import { exchangeMappers, mapper } from './registry.ts'
+
+const POLONIEX_V2_API_SWITCH_DATE = new Date('2022-08-02T00:00:00.000Z')
+
+export const poloniexMappers = exchangeMappers({
+  poloniex: {
+    trades: mapper([
+      { until: POLONIEX_V2_API_SWITCH_DATE, use: () => new PoloniexTradesMapper() },
+      { use: () => new PoloniexV2TradesMapper() }
+    ]),
+    bookChanges: mapper([
+      { until: POLONIEX_V2_API_SWITCH_DATE, use: () => new PoloniexBookChangeMapper() },
+      { use: () => new PoloniexV2BookChangeMapper() }
+    ])
+  }
+})
 
-export class PoloniexV2TradesMapper implements Mapper<'poloniex', Trade> {
+class PoloniexV2TradesMapper implements Mapper<'poloniex', Trade> {
   canHandle(message: any) {
     return message.channel === 'trades' && message.data !== undefined && message.data.length > 0
   }
@@ -41,7 +57,7 @@ const mapBookLevelV2 = (level: [string, string]) => {
     amount: Number(level[1])
   }
 }
-export class PoloniexV2BookChangeMapper implements Mapper<'poloniex', BookChange> {
+class PoloniexV2BookChangeMapper implements Mapper<'poloniex', BookChange> {
   canHandle(message: any) {
     return message.channel === 'book_lv2' && message.data !== undefined && message.data.length > 0
   }
@@ -75,7 +91,7 @@ export class PoloniexV2BookChangeMapper implements Mapper<'poloniex', BookChange
   }
 }
 
-export class PoloniexTradesMapper implements Mapper<'poloniex', Trade> {
+class PoloniexTradesMapper implements Mapper<'poloniex', Trade> {
   private readonly _channelIdToSymbolMap: Map<number, string> = new Map()
 
   canHandle(message: PoloniexPriceAggreatedMessage) {
@@ -151,7 +167,7 @@ const mapBookLevel = (level: PoloniexBookUpdate) => {
   }
 }
 
-export class PoloniexBookChangeMapper implements Mapper<'poloniex', BookChange> {
+class PoloniexBookChangeMapper implements Mapper<'poloniex', BookChange> {
   private readonly _channelIdToSymbolMap: Map<number, string> = new Map()
 
   canHandle(message: PoloniexPriceAggreatedMessage) {

package/src/mappers/polymarket.ts

@@ -1,9 +1,18 @@
 import { BookChange, BookTicker, Trade } from '../types.ts'
 import { asNonZeroNumberOrUndefined } from '../handy.ts'
 import { Mapper } from './mapper.ts'
+import { exchangeMappers } from './registry.ts'
+
+export const polymarketMappers = exchangeMappers({
+  polymarket: {
+    trades: () => new PolymarketTradesMapper(),
+    bookChanges: () => new PolymarketBookChangeMapper(),
+    bookTickers: () => new PolymarketBookTickerMapper()
+  }
+})
 
 type PolymarketBookChangeMapperMessage = PolymarketClobBookMessage | PolymarketClobBookMessage[] | PolymarketClobPriceChangeMessage
-export class PolymarketBookChangeMapper implements Mapper<'polymarket', BookChange> {
+class PolymarketBookChangeMapper implements Mapper<'polymarket', BookChange> {
   canHandle(message: PolymarketNativeMessage): message is PolymarketBookChangeMapperMessage {
     if (Array.isArray(message)) {
       return message.length > 0 && message.every(isPolymarketClobBookMessage)
@@ -76,7 +85,7 @@ export class PolymarketBookChangeMapper implements Mapper<'polymarket', BookChan
   }
 }
 
-export class PolymarketTradesMapper implements Mapper<'polymarket', Trade> {
+class PolymarketTradesMapper implements Mapper<'polymarket', Trade> {
   canHandle(message: any): message is PolymarketClobLastTradePriceMessage {
     return message.event_type === 'last_trade_price'
   }
@@ -100,7 +109,7 @@ export class PolymarketTradesMapper implements Mapper<'polymarket', Trade> {
   }
 }
 
-export class PolymarketBookTickerMapper implements Mapper<'polymarket', BookTicker> {
+class PolymarketBookTickerMapper implements Mapper<'polymarket', BookTicker> {
   canHandle(message: any): message is PolymarketClobBestBidAskMessage {
     return message.event_type === 'best_bid_ask'
   }

package/src/mappers/registry.ts

@@ -0,0 +1,203 @@
+import { EXCHANGES } from '../consts.ts'
+import { ONE_SEC_IN_MS } from '../handy.ts'
+import { Exchange, NormalizedData } from '../types.ts'
+import { Mapper } from './mapper.ts'
+
+const THREE_MINUTES_IN_MS = 3 * 60 * ONE_SEC_IN_MS
+
+export type MapperCreator<T extends Exchange = any, U extends NormalizedData = NormalizedData> = ((
+  localTimestamp?: Date
+) => Mapper<T, U>) & {
+  switchDates?: readonly Date[]
+}
+export type MapperCollection = Record<string, MapperCreator>
+export type MapperFactory<T extends Exchange = any, U extends NormalizedData = NormalizedData> = (localTimestamp?: Date) => Mapper<T, U>
+export type MapperDefinition<T extends Exchange = any, U extends NormalizedData = NormalizedData> =
+  | MapperCreator<T, U>
+  | MapperFactory<T, U>
+export type ExchangeMapperDefinitions = Partial<Record<MapperKind, MapperDefinition>>
+export type ExchangeMappers = Partial<Record<Exchange, Partial<Record<MapperKind, MapperCreator>>>>
+export type ExchangeMapperDefinitionMap = Partial<Record<Exchange, ExchangeMapperDefinitions>>
+type OnlyExchangeKeys<M> = M & Record<Exclude<keyof M, Exchange>, never>
+type OnlyMapperKindKeys<M> = {
+  [ExchangeName in keyof M]: M[ExchangeName] & Record<Exclude<keyof M[ExchangeName], MapperKind>, never>
+}
+
+export type MapperEntry<T extends Exchange, U extends NormalizedData> = {
+  until?: Date
+  use: (localTimestamp?: Date) => Mapper<T, U>
+}
+
+export type MapperKind = 'trades' | 'bookChanges' | 'derivativeTickers' | 'optionsSummary' | 'liquidations' | 'bookTickers'
+
+export const MAPPER_KINDS: readonly MapperKind[] = [
+  'trades',
+  'bookChanges',
+  'derivativeTickers',
+  'optionsSummary',
+  'liquidations',
+  'bookTickers'
+]
+
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer U) => void ? U : never
+
+type MapperForKind<Mappers, Kind extends MapperKind> = Kind extends keyof Mappers ? Mappers[Kind] : never
+
+type DefinitionMapperCollection<Definition extends ExchangeMappers, Kind extends MapperKind> = {
+  [ExchangeName in keyof Definition as MapperForKind<Definition[ExchangeName], Kind> extends MapperCreator ? ExchangeName : never]: Extract<
+    MapperForKind<Definition[ExchangeName], Kind>,
+    MapperCreator
+  >
+}
+
+type MergedExchangeMappers<Definitions extends readonly ExchangeMappers[]> = {
+  [Kind in MapperKind]: UnionToIntersection<
+    Definitions[number] extends infer Definition
+      ? Definition extends ExchangeMappers
+        ? DefinitionMapperCollection<Definition, Kind>
+        : never
+      : never
+  >
+}
+
+export const isRealTime = (date?: Date) => {
+  if (process.env.__NO_REAL_TIME__) {
+    return false
+  }
+  if (date === undefined) {
+    return false
+  }
+  return date.valueOf() + THREE_MINUTES_IN_MS > new Date().valueOf()
+}
+
+export function mapper<T extends Exchange, U extends NormalizedData>(entry: MapperEntry<T, U>): MapperCreator<T, U>
+export function mapper<T extends Exchange, U extends NormalizedData>(entries: readonly MapperEntry<T, U>[]): MapperCreator<T, U>
+export function mapper<T extends Exchange, U extends NormalizedData>(
+  entryOrEntries: MapperEntry<T, U> | readonly MapperEntry<T, U>[]
+): MapperCreator<T, U> {
+  const entries = Array.isArray(entryOrEntries) ? entryOrEntries : [entryOrEntries]
+  validateMapperEntries(entries)
+
+  const createMapper = ((localTimestamp?: Date) => {
+    if (localTimestamp === undefined || isRealTime(localTimestamp)) {
+      return entries[entries.length - 1].use(localTimestamp)
+    }
+
+    for (const entry of entries) {
+      if (entry.until === undefined || localTimestamp.valueOf() < entry.until.valueOf()) {
+        return entry.use(localTimestamp)
+      }
+    }
+
+    return entries[entries.length - 1].use(localTimestamp)
+  }) as MapperCreator<T, U>
+
+  createMapper.switchDates = entries.flatMap((entry) => (entry.until === undefined ? [] : [entry.until]))
+  return createMapper
+}
+
+export function exchangeMappers<M extends ExchangeMapperDefinitionMap>(
+  definition: OnlyExchangeKeys<M> & OnlyMapperKindKeys<M>
+): NormalizeExchangeMappers<M> {
+  validateExchangeMapperKeys(definition)
+
+  const normalized: ExchangeMappers = {}
+  for (const [exchange, mappers] of Object.entries(definition) as [Exchange, ExchangeMapperDefinitions][]) {
+    normalized[exchange] = {}
+
+    for (const kind of MAPPER_KINDS) {
+      const createMapper = mappers[kind]
+      if (createMapper !== undefined) {
+        normalized[exchange][kind] = createMapper as MapperCreator
+      }
+    }
+  }
+
+  return normalized as NormalizeExchangeMappers<M>
+}
+
+export function mergeExchangeMappers<Definitions extends readonly ExchangeMappers[]>(
+  ...definitions: Definitions
+): MergedExchangeMappers<Definitions> {
+  const merged = MAPPER_KINDS.reduce(
+    (result, kind) => {
+      result[kind] = {}
+      return result
+    },
+    {} as Record<MapperKind, MapperCollection>
+  )
+
+  for (const definition of definitions) {
+    for (const [exchange, mappers] of Object.entries(definition)) {
+      for (const kind of MAPPER_KINDS) {
+        const createMapper = mappers[kind]
+        if (createMapper !== undefined) {
+          merged[kind][exchange] = createMapper
+        }
+      }
+    }
+  }
+
+  return merged as MergedExchangeMappers<Definitions>
+}
+
+function validateMapperEntries<T extends Exchange, U extends NormalizedData>(entries: readonly MapperEntry<T, U>[]) {
+  if (entries.length === 0) {
+    throw new Error('mapper requires at least one entry')
+  }
+
+  let previousUntil: Date | undefined
+  for (let i = 0; i < entries.length; i++) {
+    const { until, use } = entries[i]
+
+    if (typeof use !== 'function') {
+      throw new Error(`mapper entry ${i} requires a use function`)
+    }
+
+    if (i === entries.length - 1) {
+      if (until !== undefined) {
+        throw new Error('last mapper entry must omit until')
+      }
+      continue
+    }
+
+    if (until === undefined) {
+      throw new Error('only last mapper entry can omit until')
+    }
+
+    if (until instanceof Date === false || Number.isFinite(until.valueOf()) === false) {
+      throw new Error(`mapper entry ${i} has an invalid until date`)
+    }
+
+    if (previousUntil !== undefined && previousUntil.valueOf() >= until.valueOf()) {
+      throw new Error('mapper until dates must be strictly increasing')
+    }
+
+    previousUntil = until
+  }
+}
+
+type NormalizeExchangeMappers<M extends ExchangeMapperDefinitionMap> = {
+  [ExchangeName in keyof M]: {
+    [Kind in keyof M[ExchangeName]]: Extract<M[ExchangeName][Kind], MapperDefinition> extends MapperDefinition<infer T, infer U>
+      ? MapperCreator<T, U>
+      : never
+  }
+}
+
+const exchangeIds = new Set<string>(EXCHANGES)
+const mapperKindIds = new Set<string>(MAPPER_KINDS)
+
+function validateExchangeMapperKeys(definition: ExchangeMapperDefinitionMap) {
+  for (const [exchange, mappers] of Object.entries(definition)) {
+    if (exchangeIds.has(exchange) === false) {
+      throw new Error(`Unsupported exchange mapper key: ${exchange}`)
+    }
+
+    for (const kind of Object.keys(mappers ?? {})) {
+      if (mapperKindIds.has(kind) === false) {
+        throw new Error(`Unsupported mapper key for ${exchange}: ${kind}`)
+      }
+    }
+  }
+}

package/src/mappers/serum.ts

@@ -1,8 +1,27 @@
 import { asNonZeroNumberOrUndefined, upperCaseSymbols } from '../handy.ts'
 import { BookChange, BookTicker, Exchange, Trade } from '../types.ts'
 import { Mapper } from './mapper.ts'
+import { exchangeMappers } from './registry.ts'
+
+export const serumMappers = exchangeMappers({
+  serum: {
+    trades: () => new SerumTradesMapper('serum'),
+    bookChanges: () => new SerumBookChangeMapper('serum'),
+    bookTickers: () => new SerumBookTickerMapper('serum')
+  },
+  'star-atlas': {
+    trades: () => new SerumTradesMapper('star-atlas'),
+    bookChanges: () => new SerumBookChangeMapper('star-atlas'),
+    bookTickers: () => new SerumBookTickerMapper('star-atlas')
+  },
+  mango: {
+    trades: () => new SerumTradesMapper('mango'),
+    bookChanges: () => new SerumBookChangeMapper('mango'),
+    bookTickers: () => new SerumBookTickerMapper('mango')
+  }
+})
 
-export class SerumTradesMapper implements Mapper<'serum' | 'star-atlas', Trade> {
+class SerumTradesMapper implements Mapper<'serum' | 'star-atlas', Trade> {
   constructor(private readonly _exchange: Exchange) {}
 
   canHandle(message: SerumVialTrade) {
@@ -37,7 +56,7 @@ export class SerumTradesMapper implements Mapper<'serum' | 'star-atlas', Trade>
   }
 }
 
-export class SerumBookChangeMapper implements Mapper<'serum' | 'star-atlas', BookChange> {
+class SerumBookChangeMapper implements Mapper<'serum' | 'star-atlas', BookChange> {
   constructor(private readonly _exchange: Exchange) {}
 
   canHandle(message: SerumVialL2Snapshot | SerumVialL2Update) {
@@ -81,7 +100,7 @@ export class SerumBookChangeMapper implements Mapper<'serum' | 'star-atlas', Boo
   }
 }
 
-export class SerumBookTickerMapper implements Mapper<'serum' | 'star-atlas', BookTicker> {
+class SerumBookTickerMapper implements Mapper<'serum' | 'star-atlas', BookTicker> {
   constructor(private readonly _exchange: Exchange) {}
 
   canHandle(message: SerumVialQuote) {

package/src/mappers/upbit.ts

@@ -1,8 +1,16 @@
 import { fromMicroSecondsToDate, upperCaseSymbols } from '../handy.ts'
 import { BookChange, BookPriceLevel, Trade } from '../types.ts'
 import { Mapper } from './mapper.ts'
+import { exchangeMappers } from './registry.ts'
 
-export class UpbitTradesMapper implements Mapper<'upbit', Trade> {
+export const upbitMappers = exchangeMappers({
+  upbit: {
+    trades: () => new UpbitTradesMapper(),
+    bookChanges: () => new UpbitBookChangeMapper()
+  }
+})
+
+class UpbitTradesMapper implements Mapper<'upbit', Trade> {
   canHandle(message: UpbitTrade) {
     return message.type === 'trade'
   }
@@ -33,7 +41,7 @@ export class UpbitTradesMapper implements Mapper<'upbit', Trade> {
   }
 }
 
-export class UpbitBookChangeMapper implements Mapper<'upbit', BookChange> {
+class UpbitBookChangeMapper implements Mapper<'upbit', BookChange> {
   canHandle(message: UpbitOrderBook) {
     return message.type === 'orderbook'
   }

package/src/mappers/woox.ts

@@ -1,8 +1,18 @@
 import { upperCaseSymbols } from '../handy.ts'
 import { BookChange, BookTicker, DerivativeTicker, Exchange, FilterForExchange, Liquidation, Trade } from '../types.ts'
 import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
+import { exchangeMappers } from './registry.ts'
+
+export const wooxMappers = exchangeMappers({
+  'woo-x': {
+    trades: () => wooxTradesMapper,
+    bookChanges: () => new WooxBookChangeMapper(),
+    derivativeTickers: () => new WooxDerivativeTickerMapper(),
+    bookTickers: () => new WooxBookTickerMapper()
+  }
+})
 
-export const wooxTradesMapper: Mapper<'woo-x', Trade> = {
+const wooxTradesMapper: Mapper<'woo-x', Trade> = {
   canHandle(message: WooxTradeMessage) {
     return message.topic !== undefined && message.topic.endsWith('@trade')
   },
@@ -39,7 +49,7 @@ export const wooxTradesMapper: Mapper<'woo-x', Trade> = {
   }
 }
 
-export class WooxBookChangeMapper implements Mapper<'woo-x', BookChange> {
+class WooxBookChangeMapper implements Mapper<'woo-x', BookChange> {
   private readonly _symbolToDepthInfoMapping: { [key: string]: LocalDepthInfo } = {}
 
   canHandle(message: WooxOrderbookMessage | WooxOrderbookupdateMessage) {
@@ -149,7 +159,7 @@ export class WooxBookChangeMapper implements Mapper<'woo-x', BookChange> {
   }
 }
 
-export class WooxDerivativeTickerMapper implements Mapper<'woo-x', DerivativeTicker> {
+class WooxDerivativeTickerMapper implements Mapper<'woo-x', DerivativeTicker> {
   private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
   private readonly _indexPrices = new Map<string, number>()
 
@@ -236,7 +246,7 @@ export class WooxDerivativeTickerMapper implements Mapper<'woo-x', DerivativeTic
   }
 }
 
-export class WooxBookTickerMapper implements Mapper<'woo-x', BookTicker> {
+class WooxBookTickerMapper implements Mapper<'woo-x', BookTicker> {
   canHandle(message: WooxTradeMessage) {
     return message.topic !== undefined && message.topic.endsWith('@bbo')
   }

package/src/okexsymbols.ts

@@ -0,0 +1,10 @@
+export function getOkexOptionsFamilyOrIndex(symbol: string) {
+  const symbolParts = symbol.split('-')
+  return `${symbolParts[0]}-${symbolParts[1]}`
+}
+
+export function getOkexOptionsUnderlyingIndex(symbol: string) {
+  const symbolParts = symbol.split('-')
+  const quote = symbolParts[1].split('_')[0]
+  return `${symbolParts[0]}-${quote}`
+}

package/src/realtimefeeds/hyperliquid.ts

@@ -12,11 +12,14 @@ export class HyperliquidRealTimeFeed extends RealTimeFeedBase {
         }
 
         return filter.symbols.map((symbol) => {
+          const isFastBook = filter.channel === 'fastBook'
+
           return {
             method: 'subscribe',
             subscription: {
               coin: symbol,
-              type: filter.channel
+              type: isFastBook ? 'l2Book' : filter.channel,
+              fast: isFastBook ? true : undefined
             }
           }
         })

package/src/realtimefeeds/index.ts

@@ -54,6 +54,8 @@ import { CoinbaseInternationalRealTimeFeed } from './coinbaseinternational.ts'
 import { HyperliquidRealTimeFeed } from './hyperliquid.ts'
 import { LighterRealTimeFeed } from './lighter.ts'
 import { BullishRealTimeFeed } from './bullish.ts'
+import { MexcFuturesRealTimeFeed } from './mexcfutures.ts'
+import { MexcRealTimeFeed } from './mexc.ts'
 import { PolymarketRealTimeFeed } from './polymarket.ts'
 
 export * from './realtimefeed.ts'
@@ -94,6 +96,7 @@ const realTimeFeedsMap: {
   delta: DeltaRealTimeFeed,
   'gate-io': GateIORealTimeFeed,
   'gate-io-futures': GateIOFuturesRealTimeFeed,
+  'mexc-futures': MexcFuturesRealTimeFeed,
   poloniex: PoloniexRealTimeFeed,
   coinflex: CoinflexRealTimeFeed,
   upbit: UpbitRealTimeFeed,
@@ -120,6 +123,7 @@ const realTimeFeedsMap: {
   hyperliquid: HyperliquidRealTimeFeed,
   lighter: LighterRealTimeFeed,
   bullish: BullishRealTimeFeed,
+  mexc: MexcRealTimeFeed,
   polymarket: PolymarketRealTimeFeed
 }