tardis-machine 18.1.0 → 18.2.1

package/node_modules/tardis-dev/dist/realtimefeeds/requestweight.js

@@ -0,0 +1,72 @@
+import { wait } from "../handy.js";
+export function parseRequestWeightHeader(headerValue) {
+    if (headerValue === undefined) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(headerValue, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+export function getExchangeScopedNumberEnv(exchange, suffix, fallback) {
+    const envName = `${exchange.toUpperCase().replace(/-/g, '_')}_${suffix}`;
+    const rawValue = process.env[envName];
+    if (rawValue === undefined) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(rawValue, 10);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+export function getRequestWeightLimit(exchange, exchangeInfo) {
+    const configuredLimit = getExchangeScopedNumberEnv(exchange, 'REQUEST_WEIGHT_LIMIT', 0);
+    if (configuredLimit > 0) {
+        return configuredLimit;
+    }
+    const requestWeightLimit = exchangeInfo.rateLimits.find((d) => d.rateLimitType === 'REQUEST_WEIGHT')?.limit;
+    if (!requestWeightLimit) {
+        throw new Error(`Failed to determine ${exchange} REQUEST_WEIGHT limit`);
+    }
+    return requestWeightLimit;
+}
+export class RequestWeightLimiter {
+    limit;
+    minAvailableWeightBuffer;
+    _usedWeight;
+    constructor(limit, minAvailableWeightBuffer, _usedWeight = 0) {
+        this.limit = limit;
+        this.minAvailableWeightBuffer = minAvailableWeightBuffer;
+        this._usedWeight = _usedWeight;
+    }
+    get usedWeight() {
+        return this._usedWeight;
+    }
+    get availableWeight() {
+        return this.limit > 0 ? this.limit - this._usedWeight - this.minAvailableWeightBuffer : Infinity;
+    }
+    async waitForAvailableWeight(requestWeight, onWait) {
+        const maxAvailableWeight = this.limit - this.minAvailableWeightBuffer;
+        if (this.limit > 0 && requestWeight > maxAvailableWeight) {
+            throw new Error(`Request weight ${requestWeight} exceeds the available per-minute limit ${maxAvailableWeight}`);
+        }
+        if (this.availableWeight >= requestWeight) {
+            return false;
+        }
+        const delayMS = getDelayToNextMinuteMS();
+        onWait?.(delayMS);
+        await wait(delayMS);
+        this._usedWeight = 0;
+        return true;
+    }
+    updateUsedWeight(usedWeight, fallbackIncrement) {
+        if (usedWeight !== undefined) {
+            this._usedWeight = usedWeight;
+            return;
+        }
+        if (this.limit > 0 && fallbackIncrement > 0) {
+            this._usedWeight += fallbackIncrement;
+        }
+    }
+}
+function getDelayToNextMinuteMS() {
+    const now = new Date();
+    return Math.max((61 - now.getUTCSeconds()) * 1000 - now.getUTCMilliseconds(), 1);
+}
+//# sourceMappingURL=requestweight.js.map

package/node_modules/tardis-dev/dist/realtimefeeds/requestweight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestweight.js","sourceRoot":"","sources":["../../src/realtimefeeds/requestweight.ts"],"names":[],"mappings":"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"}

package/node_modules/tardis-dev/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tardis-dev",
-  "version": "18.1.0",
+  "version": "18.2.2",
   "engines": {
     "node": ">=24.19"
   },
@@ -69,12 +69,12 @@
   "license": "MPL-2.0",
   "dependencies": {
     "debug": "^4.4.3",
-    "ws": "^8.21.1"
+    "ws": "^8.21.3"
   },
   "devDependencies": {
-    "@types/node": "^26.1.1",
+    "@types/node": "^26.2.0",
     "@types/ws": "^8.18.1",
-    "prettier": "3.8.3",
+    "prettier": "3.9.6",
     "typescript": "^6.0.3"
   },
   "runkitExampleFilename": "example.js"

package/node_modules/tardis-dev/src/consts.ts

@@ -1,4 +1,6 @@
 export const EXCHANGES = [
+  'aster',
+  'aster-futures',
   'bitmex',
   'deribit',
   'binance-futures',
@@ -64,6 +66,20 @@ export const EXCHANGES = [
 ] as const
 
 const BINANCE_CHANNELS = ['trade', 'aggTrade', 'ticker', 'depth', 'depthSnapshot', 'bookTicker', 'recentTrades', 'borrowInterest'] as const
+
+const ASTER_CHANNELS = ['trade', 'aggTrade', 'ticker', 'depth', 'depthSnapshot', 'bookTicker'] as const
+const ASTER_FUTURES_CHANNELS = [
+  'trade',
+  'aggTrade',
+  'ticker',
+  'depth',
+  'depthSnapshot',
+  'bookTicker',
+  'markPrice',
+  'forceOrder',
+  'assetIndex',
+  'openInterest'
+] as const
 const BINANCE_DEX_CHANNELS = ['trades', 'marketDiff', 'depthSnapshot', 'ticker'] as const
 const BITFINEX_CHANNELS = ['trades', 'book', 'raw_book', 'ticker'] as const
 
@@ -404,6 +420,8 @@ const BYBIT_CHANNELS = [
   'long_short_ratio',
   'orderbook.1',
   'orderbook.50',
+  'orderbook.rpi',
+  'orderbook.full',
   'orderbook.500',
   'publicTrade',
   'tickers',
@@ -558,6 +576,8 @@ const POLYMARKET_CHANNELS = [
 ] as const
 
 export const EXCHANGE_CHANNELS_INFO = {
+  aster: ASTER_CHANNELS,
+  'aster-futures': ASTER_FUTURES_CHANNELS,
   bitmex: BITMEX_CHANNELS,
   coinbase: COINBASE_CHANNELS,
   'coinbase-international': COINBASE_INTERNATIONAL_CHANNELS,

package/node_modules/tardis-dev/src/handy.ts

@@ -76,13 +76,18 @@ export class HttpError extends Error {
   }
 }
 
-class HttpClientError extends Error {
+export class HttpClientError extends Error {
+  public readonly status: number
+  public readonly retryAfterMS: number | undefined
+
   constructor(
     public readonly response: HttpResponse,
     public readonly method: string,
     public readonly url: string
   ) {
     super(`HTTP ${method} ${url} failed with status ${response.statusCode}`)
+    this.status = response.statusCode
+    this.retryAfterMS = getRetryAfterDelayMS(response.headers)
   }
 }
 

package/node_modules/tardis-dev/src/mappers/aster.ts

@@ -0,0 +1,441 @@
+import { debug } from '../debug.ts'
+import { asNumberOrUndefined, CircularBuffer, lowerCaseSymbols } from '../handy.ts'
+import { BookChange, BookTicker, DerivativeTicker, Liquidation, Trade } from '../types.ts'
+import { Mapper, PendingTickerInfoHelper } from './mapper.ts'
+import { exchangeMappers, isRealTime } from './registry.ts'
+
+export const asterMappers = exchangeMappers({
+  aster: {
+    trades: () => new AsterTradesMapper('aster'),
+    bookChanges: (localTimestamp) =>
+      new AsterBookChangeMapper('aster', {
+        ignoreBookSnapshotOverlapError: shouldIgnoreBookSnapshotOverlap(localTimestamp)
+      }),
+    bookTickers: () => new AsterBookTickerMapper('aster')
+  },
+  'aster-futures': {
+    trades: () => new AsterTradesMapper('aster-futures'),
+    bookChanges: (localTimestamp) =>
+      new AsterFuturesBookChangeMapper({
+        ignoreBookSnapshotOverlapError: shouldIgnoreBookSnapshotOverlap(localTimestamp)
+      }),
+    derivativeTickers: () => new AsterFuturesDerivativeTickerMapper(),
+    liquidations: () => new AsterFuturesLiquidationsMapper(),
+    bookTickers: () => new AsterBookTickerMapper('aster-futures')
+  }
+})
+
+function shouldIgnoreBookSnapshotOverlap(date?: Date) {
+  if (process.env.IGNORE_BOOK_SNAPSHOT_OVERLAP_ERROR) {
+    return true
+  }
+
+  return isRealTime(date) === false
+}
+
+class AsterTradesMapper implements Mapper<'aster' | 'aster-futures', Trade> {
+  constructor(private readonly exchange: 'aster' | 'aster-futures') {}
+
+  canHandle(message: AsterMessage<any>) {
+    return message.stream?.endsWith('@trade') === true
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'trade', symbols: lowerCaseSymbols(symbols) } as const]
+  }
+
+  *map({ data }: AsterMessage<AsterTradeData>, localTimestamp: Date) {
+    // Aster's Binance-compatible trade stream uses these X values for off-book
+    // activity, so exclude them from normalized public trades too.
+    const isOffBookTrade = data.X === 'INSURANCE_FUND' || data.X === 'ADL' || data.X === 'NA'
+    if (isOffBookTrade) {
+      return
+    }
+
+    const trade: Trade = {
+      type: 'trade',
+      symbol: data.s,
+      exchange: this.exchange,
+      id: String(data.t),
+      price: Number(data.p),
+      amount: Number(data.q),
+      side: data.m ? 'sell' : 'buy',
+      timestamp: new Date(data.T),
+      localTimestamp
+    }
+
+    yield trade
+  }
+}
+
+class AsterBookChangeMapper implements Mapper<'aster' | 'aster-futures', BookChange> {
+  protected readonly symbolToDepthInfoMapping: { [key: string]: LocalDepthInfo } = {}
+  protected readonly ignoreBookSnapshotOverlapError: boolean
+
+  constructor(
+    protected readonly exchange: 'aster' | 'aster-futures',
+    { ignoreBookSnapshotOverlapError }: { ignoreBookSnapshotOverlapError: boolean }
+  ) {
+    this.ignoreBookSnapshotOverlapError = ignoreBookSnapshotOverlapError
+  }
+
+  canHandle(message: AsterMessage<any>) {
+    return message.stream?.includes('@depth') === true
+  }
+
+  getFilters(symbols?: string[]) {
+    return [
+      { channel: 'depth', symbols: lowerCaseSymbols(symbols) } as const,
+      { channel: 'depthSnapshot', symbols: lowerCaseSymbols(symbols) } as const
+    ]
+  }
+
+  *map({ stream, data }: AsterMessage<AsterDepthData | AsterDepthSnapshotData>, localTimestamp: Date) {
+    const symbol = stream.split('@')[0].toUpperCase()
+
+    if (this.symbolToDepthInfoMapping[symbol] === undefined) {
+      this.symbolToDepthInfoMapping[symbol] = {
+        bufferedUpdates: new CircularBuffer<AsterDepthData>(2000)
+      }
+    }
+
+    const symbolDepthInfo = this.symbolToDepthInfoMapping[symbol]
+
+    if (data.lastUpdateId !== undefined) {
+      if (symbolDepthInfo.snapshotProcessed) {
+        return
+      }
+
+      symbolDepthInfo.lastUpdateId = data.lastUpdateId
+      symbolDepthInfo.snapshotProcessed = true
+      const bidsByPrice = new Map(data.bids.map((level) => [level[0], level]))
+      const asksByPrice = new Map(data.asks.map((level) => [level[0], level]))
+
+      for (const update of symbolDepthInfo.bufferedUpdates.items()) {
+        const bookChange = this.mapBookDepthUpdate(update, localTimestamp)
+        if (bookChange !== undefined) {
+          this.applyLevelUpdates(bidsByPrice, update.b)
+          this.applyLevelUpdates(asksByPrice, update.a)
+        }
+      }
+
+      symbolDepthInfo.bufferedUpdates.clear()
+
+      const bookChange: BookChange = {
+        type: 'book_change',
+        symbol,
+        exchange: this.exchange,
+        isSnapshot: true,
+        bids: [...bidsByPrice.values()].map(this.mapBookLevel),
+        asks: [...asksByPrice.values()].map(this.mapBookLevel),
+        timestamp: data.T !== undefined ? new Date(data.T) : localTimestamp,
+        localTimestamp
+      }
+
+      yield bookChange
+    } else if (symbolDepthInfo.snapshotProcessed) {
+      const bookChange = this.mapBookDepthUpdate(data as AsterDepthData, localTimestamp)
+      if (bookChange !== undefined) {
+        yield bookChange
+      }
+    } else {
+      symbolDepthInfo.bufferedUpdates.append(data as AsterDepthData)
+    }
+  }
+
+  protected mapBookDepthUpdate(depthUpdateData: AsterDepthData, localTimestamp: Date): BookChange | undefined {
+    const depthContext = this.symbolToDepthInfoMapping[depthUpdateData.s]!
+    const lastUpdateId = depthContext.lastUpdateId!
+
+    if (this.isOutdatedDepthUpdate(depthUpdateData, lastUpdateId)) {
+      return
+    }
+
+    if (!depthContext.validatedFirstUpdate) {
+      if (this.hasInitialSnapshotOverlap(depthUpdateData, lastUpdateId) || lastUpdateId === -1) {
+        depthContext.validatedFirstUpdate = true
+      } else if (this.ignoreBookSnapshotOverlapError) {
+        depthContext.validatedFirstUpdate = true
+        debug(this.getSnapshotOverlapError(depthUpdateData, lastUpdateId))
+      } else {
+        throw new Error(this.getSnapshotOverlapError(depthUpdateData, lastUpdateId))
+      }
+    } else if (depthUpdateData.pu !== lastUpdateId) {
+      throw new Error(
+        `Book depth update has a sequence gap, update ${JSON.stringify(
+          depthUpdateData
+        )}, lastUpdateId: ${lastUpdateId}, exchange ${this.exchange}`
+      )
+    }
+
+    depthContext.lastUpdateId = depthUpdateData.u
+
+    return {
+      type: 'book_change',
+      symbol: depthUpdateData.s,
+      exchange: this.exchange,
+      isSnapshot: false,
+      bids: depthUpdateData.b.map(this.mapBookLevel),
+      asks: depthUpdateData.a.map(this.mapBookLevel),
+      timestamp: new Date(depthUpdateData.E),
+      localTimestamp
+    }
+  }
+
+  protected isOutdatedDepthUpdate(depthUpdateData: AsterDepthData, lastUpdateId: number) {
+    return depthUpdateData.u <= lastUpdateId
+  }
+
+  protected hasInitialSnapshotOverlap(depthUpdateData: AsterDepthData, lastUpdateId: number) {
+    // Live and recorded Spot data use pu as the continuous sequence link. The
+    // first non-stale update is safe when its pu..u range contains the snapshot.
+    return depthUpdateData.pu <= lastUpdateId && depthUpdateData.u >= lastUpdateId
+  }
+
+  private applyLevelUpdates(levelsByPrice: Map<string, AsterBookLevel>, updates: AsterBookLevel[]) {
+    for (const level of updates) {
+      if (Number(level[1]) === 0) {
+        levelsByPrice.delete(level[0])
+      } else {
+        levelsByPrice.set(level[0], level)
+      }
+    }
+  }
+
+  private getSnapshotOverlapError(depthUpdateData: AsterDepthData, lastUpdateId: number) {
+    return `Book depth snapshot has no overlap with first update, update ${JSON.stringify(
+      depthUpdateData
+    )}, lastUpdateId: ${lastUpdateId}, exchange ${this.exchange}`
+  }
+
+  private mapBookLevel(level: AsterBookLevel) {
+    return {
+      price: Number(level[0]),
+      amount: Number(level[1])
+    }
+  }
+}
+
+class AsterBookTickerMapper implements Mapper<'aster' | 'aster-futures', BookTicker> {
+  constructor(private readonly exchange: 'aster' | 'aster-futures') {}
+
+  canHandle(message: AsterMessage<any>) {
+    return message.stream?.endsWith('@bookTicker') === true
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'bookTicker', symbols: lowerCaseSymbols(symbols) } as const]
+  }
+
+  *map({ data }: AsterMessage<AsterBookTickerData>, localTimestamp: Date) {
+    const ticker: BookTicker = {
+      type: 'book_ticker',
+      symbol: data.s,
+      exchange: this.exchange,
+      askAmount: asNumberOrUndefined(data.A),
+      askPrice: asNumberOrUndefined(data.a),
+      bidPrice: asNumberOrUndefined(data.b),
+      bidAmount: asNumberOrUndefined(data.B),
+      timestamp: data.E !== undefined ? new Date(data.E) : localTimestamp,
+      localTimestamp
+    }
+
+    yield ticker
+  }
+}
+
+class AsterFuturesBookChangeMapper extends AsterBookChangeMapper {
+  constructor({ ignoreBookSnapshotOverlapError }: { ignoreBookSnapshotOverlapError: boolean }) {
+    super('aster-futures', { ignoreBookSnapshotOverlapError })
+  }
+
+  protected override isOutdatedDepthUpdate(depthUpdateData: AsterDepthData, lastUpdateId: number) {
+    return depthUpdateData.u < lastUpdateId
+  }
+
+  protected override hasInitialSnapshotOverlap(depthUpdateData: AsterDepthData, lastUpdateId: number) {
+    // Futures normally contains the snapshot id in U..u, but live and recorded
+    // data also continues it directly with pu == lastUpdateId. Exact-id partial
+    // depth and bookTicker comparisons confirmed that neither form skips a state.
+    return (depthUpdateData.U <= lastUpdateId && depthUpdateData.u >= lastUpdateId) || depthUpdateData.pu === lastUpdateId
+  }
+}
+
+class AsterFuturesDerivativeTickerMapper implements Mapper<'aster-futures', DerivativeTicker> {
+  private readonly pendingTickerInfoHelper = new PendingTickerInfoHelper()
+
+  canHandle(message: AsterMessage<any>) {
+    return (
+      message.stream?.includes('@markPrice') === true ||
+      message.stream?.endsWith('@ticker') === true ||
+      message.stream?.endsWith('@openInterest') === true
+    )
+  }
+
+  getFilters(symbols?: string[]) {
+    const normalizedSymbols = lowerCaseSymbols(symbols)
+
+    return [
+      { channel: 'markPrice', symbols: normalizedSymbols } as const,
+      { channel: 'ticker', symbols: normalizedSymbols } as const,
+      { channel: 'openInterest', symbols: normalizedSymbols } as const
+    ]
+  }
+
+  *map(
+    { data }: AsterMessage<AsterFuturesMarkPriceData | AsterFuturesTickerData | AsterFuturesOpenInterestData>,
+    localTimestamp: Date
+  ): IterableIterator<DerivativeTicker> {
+    const pendingTickerInfo = this.pendingTickerInfoHelper.getPendingTickerInfo('s' in data ? data.s : data.symbol, 'aster-futures')
+
+    if ('e' in data) {
+      if (data.e === 'markPriceUpdate') {
+        pendingTickerInfo.updateMarkPrice(Number(data.p))
+        if (data.i !== undefined) {
+          pendingTickerInfo.updateIndexPrice(Number(data.i))
+        }
+        if (data.r !== '' && data.T !== 0) {
+          pendingTickerInfo.updateFundingRate(Number(data.r))
+          pendingTickerInfo.updateFundingTimestamp(new Date(data.T))
+        }
+        pendingTickerInfo.updateTimestamp(new Date(data.E))
+      }
+
+      if (data.e === '24hrTicker') {
+        pendingTickerInfo.updateLastPrice(Number(data.c))
+        pendingTickerInfo.updateTimestamp(new Date(data.E))
+      }
+    } else if ('openInterest' in data) {
+      if (data.time === 0) {
+        return
+      }
+      pendingTickerInfo.updateOpenInterest(Number(data.openInterest))
+      pendingTickerInfo.updateTimestamp(new Date(data.time))
+    }
+
+    if (pendingTickerInfo.hasChanged()) {
+      yield pendingTickerInfo.getSnapshot(localTimestamp)
+    }
+  }
+}
+
+class AsterFuturesLiquidationsMapper implements Mapper<'aster-futures', Liquidation> {
+  canHandle(message: AsterMessage<any>) {
+    return message.stream?.endsWith('@forceOrder') === true
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'forceOrder', symbols: lowerCaseSymbols(symbols) } as const]
+  }
+
+  *map({ data }: AsterMessage<AsterFuturesForceOrderData>, localTimestamp: Date) {
+    const order = data.o
+    if (order.X !== 'FILLED') {
+      return
+    }
+
+    const liquidation: Liquidation = {
+      type: 'liquidation',
+      symbol: order.s,
+      exchange: 'aster-futures',
+      id: undefined,
+      price: Number(order.p),
+      amount: Number(order.z),
+      side: order.S === 'SELL' ? 'sell' : 'buy',
+      timestamp: new Date(order.T),
+      localTimestamp
+    }
+
+    yield liquidation
+  }
+}
+
+type AsterMessage<T> = {
+  stream: string
+  data: T
+}
+
+type AsterTradeData = {
+  e: 'trade'
+  s: string
+  t: number
+  p: string
+  q: string
+  T: number
+  m: boolean
+  X?: 'INSURANCE_FUND' | 'MARKET' | 'ADL' | 'NA'
+}
+
+type AsterDepthData = {
+  lastUpdateId: undefined
+  E: number
+  T: number
+  s: string
+  U: number
+  u: number
+  pu: number
+  b: AsterBookLevel[]
+  a: AsterBookLevel[]
+}
+
+type AsterDepthSnapshotData = {
+  lastUpdateId: number
+  bids: AsterBookLevel[]
+  asks: AsterBookLevel[]
+  T?: number
+}
+
+type AsterBookLevel = [string, string]
+
+type LocalDepthInfo = {
+  bufferedUpdates: CircularBuffer<AsterDepthData>
+  snapshotProcessed?: boolean
+  lastUpdateId?: number
+  validatedFirstUpdate?: boolean
+}
+
+type AsterBookTickerData = {
+  u: number
+  s: string
+  b: string
+  B: string
+  a: string
+  A: string
+  E?: number
+}
+
+type AsterFuturesTickerData = {
+  e: '24hrTicker'
+  E: number
+  s: string
+  c: string
+}
+
+type AsterFuturesMarkPriceData = {
+  e: 'markPriceUpdate'
+  E: number
+  s: string
+  p: string
+  i?: string
+  r: string
+  T: number
+}
+
+type AsterFuturesForceOrderData = {
+  e: 'forceOrder'
+  E: number
+  o: {
+    s: string
+    S: 'BUY' | 'SELL'
+    p: string
+    X: string
+    z: string
+    T: number
+  }
+}
+
+type AsterFuturesOpenInterestData = {
+  symbol: string
+  openInterest: string
+  time: number
+}

package/node_modules/tardis-dev/src/mappers/binance.ts

@@ -164,28 +164,15 @@ class BinanceBookChangeMapper implements Mapper<
       //  mark given symbol depth info that has snapshot processed
       symbolDepthInfo.lastUpdateId = binanceDepthSnapshotData.lastUpdateId
       symbolDepthInfo.snapshotProcessed = true
+      const bidsByPrice = new Map(binanceDepthSnapshotData.bids.map((level) => [level[0], level]))
+      const asksByPrice = new Map(binanceDepthSnapshotData.asks.map((level) => [level[0], level]))
 
       // if there were any depth updates buffered, let's proccess those by adding to or updating the initial snapshot
       for (const update of symbolDepthInfo.bufferedUpdates.items()) {
         const bookChange = this.mapBookDepthUpdate(update, localTimestamp)
         if (bookChange !== undefined) {
-          for (const bid of update.b) {
-            const matchingBid = binanceDepthSnapshotData.bids.find((b) => b[0] === bid[0])
-            if (matchingBid !== undefined) {
-              matchingBid[1] = bid[1]
-            } else {
-              binanceDepthSnapshotData.bids.push(bid)
-            }
-          }
-
-          for (const ask of update.a) {
-            const matchingAsk = binanceDepthSnapshotData.asks.find((a) => a[0] === ask[0])
-            if (matchingAsk !== undefined) {
-              matchingAsk[1] = ask[1]
-            } else {
-              binanceDepthSnapshotData.asks.push(ask)
-            }
-          }
+          this.applyLevelUpdates(bidsByPrice, update.b)
+          this.applyLevelUpdates(asksByPrice, update.a)
         }
       }
 
@@ -197,8 +184,8 @@ class BinanceBookChangeMapper implements Mapper<
         symbol,
         exchange: this.exchange,
         isSnapshot: true,
-        bids: binanceDepthSnapshotData.bids.map(this.mapBookLevel),
-        asks: binanceDepthSnapshotData.asks.map(this.mapBookLevel),
+        bids: [...bidsByPrice.values()].map(this.mapBookLevel),
+        asks: [...asksByPrice.values()].map(this.mapBookLevel),
         timestamp: binanceDepthSnapshotData.T !== undefined ? fromMicroSecondsToDate(binanceDepthSnapshotData.T) : localTimestamp,
         localTimestamp
       }
@@ -266,6 +253,16 @@ class BinanceBookChangeMapper implements Mapper<
     const amount = Number(level[1])
     return { price, amount }
   }
+
+  private applyLevelUpdates(levelsByPrice: Map<string, BinanceBookLevel>, updates: BinanceBookLevel[]) {
+    for (const level of updates) {
+      if (Number(level[1]) === 0) {
+        levelsByPrice.delete(level[0])
+      } else {
+        levelsByPrice.set(level[0], level)
+      }
+    }
+  }
 }
 
 class BinanceFuturesBookChangeMapper extends BinanceBookChangeMapper implements Mapper<'binance-futures' | 'binance-delivery', BookChange> {
@@ -281,9 +278,14 @@ class BinanceFuturesBookChangeMapper extends BinanceBookChangeMapper implements
       return
     }
 
-    // The first processed should have U <= lastUpdateId AND u >= lastUpdateId
+    // Binance documents a first update that contains the snapshot boundary. Live
+    // USD-M and COIN-M streams can instead continue it directly with pu == lastUpdateId.
+    // Both relations join the buffered stream to the snapshot without an update gap.
     if (!depthContext.validatedFirstUpdate) {
-      if (binanceDepthUpdateData.U <= lastUpdateId && binanceDepthUpdateData.u >= lastUpdateId) {
+      const containsSnapshotBoundary = binanceDepthUpdateData.U <= lastUpdateId && binanceDepthUpdateData.u >= lastUpdateId
+      const continuesSnapshotDirectly = binanceDepthUpdateData.pu === lastUpdateId
+
+      if (containsSnapshotBoundary || continuesSnapshotDirectly) {
         depthContext.validatedFirstUpdate = true
       } else {
         const message = `Book depth snaphot has no overlap with first update, update ${JSON.stringify(