tardis-dev 13.9.0 → 13.10.1

package/src/mappers/phemex.ts

@@ -27,46 +27,114 @@ function getQtyScale(symbol: string) {
   return 1
 }
 
-function getSymbols(symbols?: string[]) {
-  if (symbols === undefined) {
-    return
+const COINS_STARTING_WITH_S = ['SOL', 'SUSHI', 'SNX', 'SAND', 'SRM', 'SKLU', 'SXP', 'STORJ', 'SFP', 'STG']
+function getInstrumentType(symbol: string) {
+  if (/\d+$/.test(symbol)) {
+    return 'future'
+  }
+
+  if (COINS_STARTING_WITH_S.some((c) => symbol.startsWith(c)) || symbol.startsWith('S') === false) {
+    return 'perpetual'
+  }
+
+  return 'spot'
+}
+
+function getApiSymbolId(symbolId: string) {
+  const type = getInstrumentType(symbolId)
+  if (type === 'spot' && symbolId.startsWith('S')) {
+    return symbolId.charAt(0).toLowerCase() + symbolId.slice(1)
+  }
+  if (symbolId.startsWith('U100')) {
+    return symbolId.charAt(0).toLowerCase() + symbolId.slice(1)
+  }
+
+  if (symbolId === 'CETHUSD') {
+    return symbolId.charAt(0).toLowerCase() + symbolId.slice(1)
+  }
+
+  return symbolId
+}
+
+function getSymbols(symbols: string[]) {
+  const perpV2Symbols = symbols.filter((s) => getInstrumentType(s) === 'perpetual' && s.endsWith('USDT')).map(getApiSymbolId)
+  const otherSymbols = symbols.filter((s) => getInstrumentType(s) !== 'perpetual' || s.endsWith('USDT') == false).map(getApiSymbolId)
+
+  return {
+    perpV2Symbols,
+    otherSymbols
   }
-  return symbols.map((symbol) => {
-    if (symbol.startsWith('S')) {
-      return symbol.charAt(0).toLowerCase() + symbol.slice(1)
-    }
-    return symbol
-  })
 }
 
 export const phemexTradesMapper: Mapper<'phemex', Trade> = {
   canHandle(message: PhemexTradeMessage) {
-    return 'trades' in message && message.type === 'incremental'
+    return message.type === 'incremental' && ('trades' in message || 'trades_p' in message)
   },
 
   getFilters(symbols?: string[]) {
-    return [
-      {
+    if (symbols == undefined || symbols.length === 0) {
+      return [
+        {
+          channel: 'trades'
+        } as const,
+        {
+          channel: 'trades_p'
+        } as const
+      ]
+    }
+
+    const { perpV2Symbols, otherSymbols } = getSymbols(symbols)
+
+    const filters = []
+
+    if (perpV2Symbols.length > 0) {
+      filters.push({
+        channel: 'trades_p',
+        symbols: perpV2Symbols
+      } as const)
+    }
+    if (otherSymbols.length > 0) {
+      filters.push({
         channel: 'trades',
-        symbols: getSymbols(symbols)
-      } as const
-    ]
+        symbols: otherSymbols
+      } as const)
+    }
+
+    return filters
   },
 
   *map(message: PhemexTradeMessage, localTimestamp: Date): IterableIterator<Trade> {
-    for (const [timestamp, side, priceEp, qty] of message.trades) {
-      const symbol = message.symbol
+    if ('trades' in message) {
+      for (const [timestamp, side, priceEp, qty] of message.trades) {
+        const symbol = message.symbol
 
-      yield {
-        type: 'trade',
-        symbol: symbol.toUpperCase(),
-        exchange: 'phemex',
-        id: undefined,
-        price: priceEp / getPriceScale(symbol),
-        amount: qty / getQtyScale(symbol),
-        side: side === 'Buy' ? 'buy' : 'sell',
-        timestamp: fromNanoSecondsToDate(timestamp),
-        localTimestamp: localTimestamp
+        yield {
+          type: 'trade',
+          symbol: symbol.toUpperCase(),
+          exchange: 'phemex',
+          id: undefined,
+          price: priceEp / getPriceScale(symbol),
+          amount: qty / getQtyScale(symbol),
+          side: side === 'Buy' ? 'buy' : 'sell',
+          timestamp: fromNanoSecondsToDate(timestamp),
+          localTimestamp: localTimestamp
+        }
+      }
+    } else if ('trades_p' in message) {
+      for (const [timestamp, side, price, qty] of message.trades_p) {
+        const symbol = message.symbol
+
+        yield {
+          type: 'trade',
+          symbol: symbol.toUpperCase(),
+          exchange: 'phemex',
+          id: undefined,
+          price: Number(price),
+          amount: Number(qty),
+          side: side === 'Buy' ? 'buy' : 'sell',
+          timestamp: fromNanoSecondsToDate(timestamp),
+          localTimestamp: localTimestamp
+        }
       }
     }
   }
@@ -81,33 +149,75 @@ const mapBookLevelForSymbol =
     }
   }
 
+function mapPerpBookLevel([price, amount]: [string, string]) {
+  return {
+    price: Number(price),
+    amount: Number(amount)
+  }
+}
+
 export const phemexBookChangeMapper: Mapper<'phemex', BookChange> = {
   canHandle(message: PhemexBookMessage) {
-    return 'book' in message
+    return 'book' in message || 'orderbook_p' in message
   },
 
   getFilters(symbols?: string[]) {
-    return [
-      {
+    if (symbols == undefined || symbols.length === 0) {
+      return [
+        {
+          channel: 'book'
+        } as const,
+        {
+          channel: 'orderbook_p'
+        } as const
+      ]
+    }
+
+    const { perpV2Symbols, otherSymbols } = getSymbols(symbols)
+    const filters = []
+
+    if (perpV2Symbols.length > 0) {
+      filters.push({
+        channel: 'orderbook_p',
+        symbols: perpV2Symbols
+      } as const)
+    }
+    if (otherSymbols.length > 0) {
+      filters.push({
         channel: 'book',
-        symbols: getSymbols(symbols)
-      } as const
-    ]
+        symbols: otherSymbols
+      } as const)
+    }
+
+    return filters
   },
 
   *map(message: PhemexBookMessage, localTimestamp: Date): IterableIterator<BookChange> {
     const symbol = message.symbol
-    const mapBookLevel = mapBookLevelForSymbol(symbol)
-    yield {
-      type: 'book_change',
-      symbol: symbol.toUpperCase(),
-      exchange: 'phemex',
-      isSnapshot: message.type === 'snapshot',
-      bids: message.book.bids.map(mapBookLevel),
-      asks: message.book.asks.map(mapBookLevel),
-
-      timestamp: fromNanoSecondsToDate(message.timestamp),
-      localTimestamp
+    if ('book' in message) {
+      const mapBookLevel = mapBookLevelForSymbol(symbol)
+      yield {
+        type: 'book_change',
+        symbol: symbol.toUpperCase(),
+        exchange: 'phemex',
+        isSnapshot: message.type === 'snapshot',
+        bids: message.book.bids.map(mapBookLevel),
+        asks: message.book.asks.map(mapBookLevel),
+
+        timestamp: fromNanoSecondsToDate(message.timestamp),
+        localTimestamp
+      }
+    } else if ('orderbook_p' in message) {
+      yield {
+        type: 'book_change',
+        symbol: symbol.toUpperCase(),
+        exchange: 'phemex',
+        isSnapshot: message.type === 'snapshot',
+        bids: message.orderbook_p.bids.map(mapPerpBookLevel),
+        asks: message.orderbook_p.asks.map(mapPerpBookLevel),
+        timestamp: fromNanoSecondsToDate(message.timestamp),
+        localTimestamp
+      }
     }
   }
 }
@@ -116,64 +226,174 @@ export class PhemexDerivativeTickerMapper implements Mapper<'phemex', Derivative
   private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
 
   canHandle(message: PhemexTicker) {
-    return 'market24h' in message
+    return 'market24h' in message || message.method === 'perp_market24h_pack_p.update'
   }
 
   getFilters(symbols?: string[]) {
-    return [
-      {
+    if (symbols == undefined || symbols.length === 0) {
+      return [
+        {
+          channel: 'market24h'
+        } as const,
+        {
+          channel: 'perp_market24h_pack_p'
+        } as const
+      ]
+    }
+
+    const { perpV2Symbols, otherSymbols } = getSymbols(symbols)
+    const filters = []
+
+    if (perpV2Symbols.length > 0) {
+      filters.push({
+        channel: 'perp_market24h_pack_p',
+        symbols: perpV2Symbols
+      } as const)
+    }
+    if (otherSymbols.length > 0) {
+      filters.push({
         channel: 'market24h',
-        symbols
-      } as const
-    ]
+        symbols: otherSymbols
+      } as const)
+    }
+
+    return filters
   }
 
   *map(message: PhemexTicker, localTimestamp: Date): IterableIterator<DerivativeTicker> {
-    const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(message.market24h.symbol, 'phemex')
-    const phemexTicker = message.market24h
-    pendingTickerInfo.updateFundingRate(phemexTicker.fundingRate / 100000000)
-    pendingTickerInfo.updatePredictedFundingRate(phemexTicker.predFundingRate / 100000000)
-    pendingTickerInfo.updateIndexPrice(phemexTicker.indexPrice / 10000)
-    pendingTickerInfo.updateMarkPrice(phemexTicker.markPrice / 10000)
-    pendingTickerInfo.updateOpenInterest(phemexTicker.openInterest)
-    pendingTickerInfo.updateLastPrice(phemexTicker.close / 10000)
-    pendingTickerInfo.updateTimestamp(fromNanoSecondsToDate(message.timestamp))
-
-    if (pendingTickerInfo.hasChanged()) {
-      yield pendingTickerInfo.getSnapshot(localTimestamp)
+    if ('market24h' in message) {
+      const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(message.market24h.symbol, 'phemex')
+      const phemexTicker = message.market24h
+      pendingTickerInfo.updateFundingRate(phemexTicker.fundingRate / 100000000)
+      pendingTickerInfo.updatePredictedFundingRate(phemexTicker.predFundingRate / 100000000)
+      pendingTickerInfo.updateIndexPrice(phemexTicker.indexPrice / 10000)
+      pendingTickerInfo.updateMarkPrice(phemexTicker.markPrice / 10000)
+      pendingTickerInfo.updateOpenInterest(phemexTicker.openInterest)
+      pendingTickerInfo.updateLastPrice(phemexTicker.close / 10000)
+      pendingTickerInfo.updateTimestamp(fromNanoSecondsToDate(message.timestamp))
+
+      if (pendingTickerInfo.hasChanged()) {
+        yield pendingTickerInfo.getSnapshot(localTimestamp)
+      }
+    } else {
+      for (let [
+        symbol,
+        _openRp,
+        _highRp,
+        _lowRp,
+        lastRp,
+        _volumeRq,
+        _turnoverRv,
+        openInterestRv,
+        indexRp,
+        markRp,
+        fundingRateRr,
+        predFundingRateRr
+      ] of message.data) {
+        const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo(symbol, 'phemex')
+
+        pendingTickerInfo.updateFundingRate(Number(fundingRateRr))
+        pendingTickerInfo.updatePredictedFundingRate(Number(predFundingRateRr))
+        pendingTickerInfo.updateIndexPrice(Number(indexRp))
+        pendingTickerInfo.updateMarkPrice(Number(markRp))
+        pendingTickerInfo.updateOpenInterest(Number(openInterestRv))
+        pendingTickerInfo.updateLastPrice(Number(lastRp))
+        pendingTickerInfo.updateTimestamp(fromNanoSecondsToDate(message.timestamp))
+
+        if (pendingTickerInfo.hasChanged()) {
+          yield pendingTickerInfo.getSnapshot(localTimestamp)
+        }
+      }
     }
   }
 }
 
-type PhemexTradeMessage = {
-  symbol: string
-  trades: [[number, 'Buy' | 'Sell', number, number]]
-  type: 'incremental' | 'snapshot'
-}
+type PhemexTradeMessage =
+  | {
+      symbol: string
+      trades: [[number, 'Buy' | 'Sell', number, number]]
+      type: 'incremental' | 'snapshot'
+    }
+  | {
+      sequence: 79157171
+      symbol: 'BTCUSDT'
+      trades_p: [[1669198793402790477, 'Buy' | 'Sell', '16545.6', '0.7']]
+      type: 'snapshot' | 'incremental'
+    }
 
 type PhemexBookLevel = [number, number]
 
-type PhemexBookMessage = {
-  book: {
-    asks: PhemexBookLevel[]
-    bids: PhemexBookLevel[]
-  }
+type PhemexBookMessage =
+  | {
+      book: {
+        asks: PhemexBookLevel[]
+        bids: PhemexBookLevel[]
+      }
 
-  symbol: string
-  timestamp: number
-  type: 'incremental' | 'snapshot'
-}
+      symbol: string
+      timestamp: number
+      type: 'incremental' | 'snapshot'
+    }
+  | {
+      depth: 0
+      orderbook_p: {
+        asks: [string, string][]
+        bids: [string, string][]
+      }
+      sequence: 80321058
+      symbol: 'BTCUSDT'
+      timestamp: 1669198850490348246
+      type: 'snapshot' | 'incremental'
+    }
 
-type PhemexTicker = {
-  market24h: {
-    fundingRate: number
-    indexPrice: number
-    markPrice: number
-    openInterest: number
-    predFundingRate: number
-    symbol: string
-    close: number
-  }
+type PhemexTicker =
+  | {
+      market24h: {
+        fundingRate: number
+        indexPrice: number
+        markPrice: number
+        openInterest: number
+        predFundingRate: number
+        symbol: string
+        close: number
+      }
 
-  timestamp: number
-}
+      timestamp: number
+      method: undefined
+    }
+  | {
+      data: [
+        [
+          'SOLUSDT',
+          '11.246',
+          '13.41',
+          '10.91',
+          '13.029',
+          '10445.82',
+          '127687.14224',
+          '0',
+          '13.03062296',
+          '13.03154351',
+          '0.0001',
+          '0.0001'
+        ],
+
+        [
+          'BTCUSDT',
+          '15713.1',
+          '16626',
+          '15685.7',
+          '16545.6',
+          '1374.476',
+          '22296790.4579',
+          '0',
+          '16553.56998432',
+          '16554.73942506',
+          '0.0001',
+          '0.0001'
+        ]
+      ]
+      method: 'perp_market24h_pack_p.update'
+      timestamp: 1669198855202180601
+      type: 'incremental'
+    }

package/src/realtimefeeds/okex.ts

@@ -61,6 +61,14 @@ export class OkexRealTimeFeed extends RealTimeFeedBase {
   protected messageIsError(message: any): boolean {
     return message.event === 'error'
   }
+
+  protected isIgnoredError(message: any) {
+    if (message.msg.includes('channel') && message.msg.includes(`doesn't exist`)) {
+      return true
+    }
+
+    return false
+  }
 }
 
 export class OKCoinRealTimeFeed extends RealTimeFeedBase {

package/src/realtimefeeds/phemex.ts

@@ -7,16 +7,25 @@ export class PhemexRealTimeFeed extends RealTimeFeedBase {
 
   protected readonly channelsMap = {
     book: 'orderbook.subscribe',
+    orderbook_p: 'orderbook_p.subscribe',
     trades: 'trade.subscribe',
+    trades_p: 'trade_p.subscribe',
     market24h: 'market24h.subscribe',
-    spot_market24h: 'spot_market24h.subscribe'
+    spot_market24h: 'spot_market24h.subscribe',
+    perp_market24h_pack_p: 'perp_market24h_pack_p.subscribe'
   } as any
 
   protected mapToSubscribeMessages(filters: Filter<string>[]) {
     let id = 0
     return filters
+
       .map((filter) => {
-        if (filter.symbols !== undefined && filter.channel !== 'market24h' && filter.channel !== 'spot_market24h') {
+        if (
+          filter.symbols !== undefined &&
+          filter.channel !== 'market24h' &&
+          filter.channel !== 'spot_market24h' &&
+          filter.channel !== 'perp_market24h_pack_p'
+        ) {
           return filter.symbols.map((symbol) => {
             return {
               id: id++,