tardis-machine 18.6.2 → 18.8.0

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

@@ -0,0 +1,290 @@
+import { asNonZeroNumberOrUndefined, asNumberOrUndefined, fromMicroSecondsToDate, upperCaseSymbols } from '../handy.ts'
+import type { BookChange, BookTicker, DerivativeTicker, OptionSummary, Trade } from '../types.ts'
+import { type Mapper, PendingTickerInfoHelper } from './mapper.ts'
+import { exchangeMappers } from './registry.ts'
+
+export const deltaIndiaMappers = exchangeMappers({
+  'delta-india': {
+    trades: () => new DeltaIndiaTradesMapper(),
+    bookChanges: () => new DeltaIndiaBookChangeMapper(),
+    bookTickers: () => new DeltaIndiaBookTickerMapper(),
+    derivativeTickers: () => new DeltaIndiaDerivativeTickerMapper(),
+    optionsSummary: () => new DeltaIndiaOptionSummaryMapper()
+  }
+})
+
+class DeltaIndiaTradesMapper implements Mapper<'delta-india', Trade> {
+  canHandle(message: DeltaIndiaTrade) {
+    return message.type === 'trades'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'trades', symbols: upperCaseSymbols(symbols) } as const]
+  }
+
+  *map(message: DeltaIndiaTrade, localTimestamp: Date): IterableIterator<Trade> {
+    yield {
+      type: 'trade',
+      exchange: 'delta-india',
+      symbol: message.sy,
+      id: undefined,
+      price: Number(message.p),
+      amount: Number(message.s),
+      side: message.r === 't' ? 'buy' : 'sell',
+      timestamp: fromMicroSecondsToDate(message.t),
+      localTimestamp
+    }
+  }
+}
+
+class DeltaIndiaBookChangeMapper implements Mapper<'delta-india', BookChange> {
+  private readonly initialized = new Set<string>()
+
+  canHandle(message: DeltaIndiaDepth) {
+    return message.type === 'ob_updates' && (message.action === 'snapshot' || message.action === 'update')
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'ob_updates', symbols: upperCaseSymbols(symbols) } as const]
+  }
+
+  *map(message: DeltaIndiaDepth, localTimestamp: Date): IterableIterator<BookChange> {
+    if (message.action === 'snapshot') {
+      this.initialized.add(message.sy)
+    }
+
+    if (!this.initialized.has(message.sy)) {
+      return
+    }
+
+    yield {
+      type: 'book_change',
+      exchange: 'delta-india',
+      symbol: message.sy,
+      isSnapshot: message.action === 'snapshot',
+      bids: message.b.map(this.mapLevel),
+      asks: message.a.map(this.mapLevel),
+      timestamp: fromMicroSecondsToDate(message.ts),
+      localTimestamp
+    }
+  }
+
+  private mapLevel([price, amount]: DeltaIndiaBookLevel) {
+    return { price: Number(price), amount: Number(amount) }
+  }
+}
+
+class DeltaIndiaBookTickerMapper implements Mapper<'delta-india', BookTicker> {
+  canHandle(message: DeltaIndiaBBO) {
+    return message.type === 'ob_l1'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'ob_l1', symbols: upperCaseSymbols(symbols) } as const]
+  }
+
+  *map(message: DeltaIndiaBBO, localTimestamp: Date): IterableIterator<BookTicker> {
+    yield {
+      type: 'book_ticker',
+      exchange: 'delta-india',
+      symbol: message.sy,
+      askPrice: asNonZeroNumberOrUndefined(message.ap),
+      askAmount: asNonZeroNumberOrUndefined(message.as),
+      bidPrice: asNonZeroNumberOrUndefined(message.bp),
+      bidAmount: asNonZeroNumberOrUndefined(message.bs),
+      timestamp: fromMicroSecondsToDate(message.lts),
+      localTimestamp
+    }
+  }
+}
+
+class DeltaIndiaDerivativeTickerMapper implements Mapper<'delta-india', DerivativeTicker> {
+  private readonly pending = new PendingTickerInfoHelper()
+
+  canHandle(message: DeltaIndiaTicker | DeltaIndiaPrice | DeltaIndiaFunding) {
+    return message.type === 'ticker' || message.type === 'mark_price' || message.type === 'funding_rate'
+  }
+
+  getFilters(symbols?: string[]) {
+    const uppercaseSymbols = upperCaseSymbols(symbols)
+    const markPriceSymbols = uppercaseSymbols?.filter(isDerivative).map((symbol) => `MARK:${symbol}`)
+    const perpetualSymbols = uppercaseSymbols?.filter((symbol) => !symbol.includes('-') && !symbol.includes('_'))
+    return [
+      { channel: 'ticker', symbols: uppercaseSymbols } as const,
+      ...(markPriceSymbols?.length === 0 ? [] : [{ channel: 'mark_price', symbols: markPriceSymbols } as const]),
+      ...(perpetualSymbols?.length === 0 ? [] : [{ channel: 'funding_rate', symbols: perpetualSymbols } as const])
+    ]
+  }
+
+  *map(message: DeltaIndiaTicker | DeltaIndiaPrice | DeltaIndiaFunding, localTimestamp: Date): IterableIterator<DerivativeTicker> {
+    const timestamp = fromMicroSecondsToDate(message.ts)
+
+    if (message.type === 'ticker') {
+      for (const ticker of message.d) {
+        if (!isDerivative(ticker.s)) {
+          continue
+        }
+
+        const pending = this.pending.getPendingTickerInfo(ticker.s, 'delta-india')
+        pending.updateLastPrice(asNumberOrUndefined(ticker.ohlc[3]))
+        pending.updateOpenInterest(asNumberOrUndefined(ticker.oi[0]))
+        pending.updateIndexPrice(asNumberOrUndefined(message.sp))
+        pending.updateTimestamp(timestamp)
+
+        if (pending.hasChanged()) {
+          yield pending.getSnapshot(localTimestamp)
+        }
+      }
+      return
+    }
+
+    const symbol = message.sy.replace(/^MARK:/, '')
+    if (!isDerivative(symbol)) {
+      return
+    }
+
+    const pending = this.pending.getPendingTickerInfo(symbol, 'delta-india')
+    if (message.type === 'mark_price') {
+      pending.updateMarkPrice(asNumberOrUndefined(message.p))
+    }
+    if (message.type === 'funding_rate') {
+      // Delta publishes funding rates in percentage points; normalized rates are fractions.
+      pending.updateFundingRate(Number(message.fr) / 100)
+      pending.updateFundingTimestamp(fromMicroSecondsToDate(message.nfr))
+    }
+    pending.updateTimestamp(timestamp)
+
+    if (pending.hasChanged()) {
+      yield pending.getSnapshot(localTimestamp)
+    }
+  }
+}
+
+class DeltaIndiaOptionSummaryMapper implements Mapper<'delta-india', OptionSummary> {
+  canHandle(message: DeltaIndiaTicker) {
+    return message.type === 'ticker'
+  }
+
+  getFilters(symbols?: string[]) {
+    return [{ channel: 'ticker', symbols: upperCaseSymbols(symbols) } as const]
+  }
+
+  *map(message: DeltaIndiaTicker, localTimestamp: Date): IterableIterator<OptionSummary> {
+    for (const ticker of message.d) {
+      if (!isOption(ticker.s)) {
+        continue
+      }
+      const [side, asset, strike, expiry] = ticker.s.split('-')
+
+      yield {
+        type: 'option_summary',
+        exchange: 'delta-india',
+        symbol: ticker.s,
+        optionType: side === 'C' ? 'call' : 'put',
+        strikePrice: Number(strike),
+        expirationDate: this.parseExpirationDate(expiry, asset === 'XAUT' ? 16 : 12),
+        bestAskPrice: asNonZeroNumberOrUndefined(ticker.q[0]),
+        bestAskAmount: asNonZeroNumberOrUndefined(ticker.q[1]),
+        bestBidPrice: asNonZeroNumberOrUndefined(ticker.q[2]),
+        bestBidAmount: asNonZeroNumberOrUndefined(ticker.q[3]),
+        bestAskIV: this.mapIV(ticker.qiv[0]),
+        bestBidIV: this.mapIV(ticker.qiv[1]),
+        markIV: this.mapIV(ticker.qiv[2]),
+        lastPrice: asNumberOrUndefined(ticker.ohlc[3]),
+        openInterest: asNumberOrUndefined(ticker.oi[0]),
+        markPrice: asNumberOrUndefined(ticker.m),
+        delta: asNumberOrUndefined(ticker.g[0]),
+        gamma: asNumberOrUndefined(ticker.g[1]),
+        rho: asNumberOrUndefined(ticker.g[2]),
+        theta: asNumberOrUndefined(ticker.g[3]),
+        vega: asNumberOrUndefined(ticker.g[4]),
+        underlyingPrice: asNumberOrUndefined(message.sp),
+        underlyingIndex: asset === 'BTC' ? '.DEXBTUSD' : `.DE${asset}USD`,
+        timestamp: fromMicroSecondsToDate(message.ts),
+        localTimestamp
+      }
+    }
+  }
+
+  /** DDMMYY encodes no time; the UTC expiry hour depends on the asset. */
+  private parseExpirationDate(expiry: string, expiryHour: number) {
+    const day = Number(expiry.slice(0, 2))
+    const month = Number(expiry.slice(2, 4))
+    const year = 2000 + Number(expiry.slice(4))
+    return new Date(Date.UTC(year, month - 1, day, expiryHour))
+  }
+
+  private mapIV(value: string | null) {
+    const iv = asNumberOrUndefined(value)
+    return iv !== undefined && iv >= 0 ? iv : undefined
+  }
+}
+
+function isDerivative(symbol: string) {
+  return !isOption(symbol) && !symbol.endsWith('_INR')
+}
+function isOption(symbol: string) {
+  return symbol.startsWith('C-') || symbol.startsWith('P-')
+}
+
+type DeltaIndiaChannel =
+  'trades' | 'ob_updates' | 'ob_l1' | 'ticker' | 'mark_price' | 'funding_rate' | 'spot_price' | 'product_updates' | 'system_status'
+
+type DeltaIndiaMessage<Channel extends DeltaIndiaChannel> = {
+  type: Channel
+  sy: string
+  ts: number
+}
+
+type DeltaIndiaTrade = DeltaIndiaMessage<'trades'> & {
+  p: string
+  s: number
+  r: 't' | 'm'
+  t: number
+}
+
+type DeltaIndiaDepth = DeltaIndiaMessage<'ob_updates'> & {
+  action: 'snapshot' | 'update'
+  a: DeltaIndiaBookLevel[]
+  b: DeltaIndiaBookLevel[]
+  seq: number
+  cs: number
+}
+type DeltaIndiaBookLevel = [price: string, size: string]
+
+type DeltaIndiaBBO = DeltaIndiaMessage<'ob_l1'> & {
+  ap: string | null
+  as: string | null
+  bp: string | null
+  bs: string | null
+  lts: number
+}
+
+type DeltaIndiaPrice = DeltaIndiaMessage<'mark_price'> & {
+  p: string
+}
+
+type DeltaIndiaFunding = DeltaIndiaMessage<'funding_rate'> & {
+  fr: number
+  fi: number
+  nfr: number
+}
+
+type DeltaIndiaTicker = DeltaIndiaMessage<'ticker'> & {
+  sp: string | null
+  d: DeltaIndiaTickerContract[]
+}
+
+type DeltaIndiaTickerContract = {
+  i: number
+  s: string
+  m: string | null
+  m24hc: string
+  ohlc: [open: number | null, high: number | null, low: number | null, close: number | null]
+  oi: [contracts: string | null, change: string | null]
+  pb: [lower: string | null, upper: string | null]
+  q: [askPrice: string | null, askSize: string | null, bidPrice: string | null, bidSize: string | null, impactMidPrice: string | null]
+  qiv: [ask: string | null, bid: string | null, mark: string | null]
+  g: [delta: string | null, gamma: string | null, rho: string | null, theta: string | null, vega: string | null]
+  to: [turnover: number | null, turnoverUSD: number | null]
+}

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

@@ -22,6 +22,7 @@ import { coinflexMappers } from './coinflex.ts'
 import { cryptoComMappers } from './cryptocom.ts'
 import { cryptofacilitiesMappers } from './cryptofacilities.ts'
 import { deltaMappers } from './delta.ts'
+import { deltaIndiaMappers } from './delta_india.ts'
 import { deribitMappers } from './deribit.ts'
 import { dydxMappers } from './dydx.ts'
 import { dydxV4Mappers } from './dydxv4.ts'
@@ -81,6 +82,7 @@ const registeredMappers = mergeExchangeMappers(
   cryptoComMappers,
   cryptofacilitiesMappers,
   deltaMappers,
+  deltaIndiaMappers,
   deribitMappers,
   dydxMappers,
   dydxV4Mappers,

package/node_modules/tardis-dev/src/realtimefeeds/delta_india.ts

@@ -0,0 +1,131 @@
+import { optimizeFilters, wait } from '../handy.ts'
+import type { Filter } from '../types.ts'
+import { MultiConnectionRealTimeFeedBase, RealTimeFeedBase } from './realtimefeed.ts'
+
+const productCategories = new Set(['all', 'call_options', 'put_options', 'move_options', 'spot', 'futures', 'perpetual_futures'])
+
+export class DeltaIndiaRealTimeFeed extends MultiConnectionRealTimeFeedBase {
+  protected *_getRealTimeFeeds(exchange: string, filters: Filter<string>[], timeoutIntervalMS?: number, onError?: (error: Error) => void) {
+    const marketFilters: Filter<string>[] = []
+    const depthFilters: Filter<string>[] = []
+
+    for (const filter of optimizeFilters(filters)) {
+      if (filter.channel !== 'product_updates' && filter.channel !== 'system_status' && !filter.symbols?.length) {
+        throw new Error('DeltaIndiaRealTimeFeed requires explicitly specified symbols for market data channels')
+      }
+      if (filter.channel === 'ob_updates') {
+        for (const symbol of filter.symbols!) {
+          if (productCategories.has(symbol.toLowerCase()) || /^[A-Z]+-\d{6}$/i.test(symbol)) {
+            throw new Error('Delta India ob_updates requires individual instrument symbols')
+          }
+        }
+        depthFilters.push(filter)
+      } else {
+        marketFilters.push(filter)
+      }
+    }
+
+    const feeds: DeltaIndiaWebSocketRealTimeFeed[] = [
+      marketFilters.length ? new DeltaIndiaWebSocketRealTimeFeed(exchange, marketFilters, timeoutIntervalMS, onError) : undefined,
+      depthFilters.length ? new DeltaIndiaWebSocketRealTimeFeed(exchange, depthFilters, timeoutIntervalMS, onError) : undefined
+    ].filter((feed) => feed !== undefined)
+
+    yield* feeds
+  }
+}
+
+export class DeltaIndiaWebSocketRealTimeFeed extends RealTimeFeedBase {
+  protected readonly wssURL: string = 'wss://public-socket.india.delta.exchange'
+  private readonly sequences = new Map<string, number>()
+  private readonly pendingSnapshots = new Set<string>()
+  private retrySnapshotsAt = 0
+
+  protected mapToSubscribeMessages(filters: Filter<string>[]) {
+    this.sequences.clear()
+    this.pendingSnapshots.clear()
+    this.retrySnapshotsAt = Date.now() + 5000
+
+    const channels = filters.map((filter) => {
+      if (filter.channel === 'product_updates' || filter.channel === 'system_status') {
+        return { name: filter.channel }
+      }
+      const symbols = [
+        ...new Set(
+          filter.symbols!.map((symbol) => {
+            if (productCategories.has(symbol)) {
+              return symbol
+            }
+            const id = symbol.toUpperCase()
+            if (filter.channel === 'mark_price') {
+              return id.startsWith('MARK:') ? id : `MARK:${id}`
+            }
+            return id
+          })
+        )
+      ]
+      if (filter.channel === 'ob_updates') {
+        for (const symbol of symbols) {
+          this.pendingSnapshots.add(symbol)
+        }
+      }
+      return { name: filter.channel, symbols }
+    })
+    return [{ type: 'subscribe', payload: { channels } }, { type: 'enable_heartbeat' }]
+  }
+
+  protected messageIsError(message: any): boolean {
+    return (
+      message.type === 'error' ||
+      message.error != null ||
+      (message.type === 'subscriptions' && message.channels.some((channel: { error?: unknown }) => channel.error != null)) ||
+      (message.type === 'ob_updates' &&
+        message.action === 'error' &&
+        message.msg !== 'Snapshot load failed. Verify if product is live and resubscribe after a few secs.')
+    )
+  }
+
+  protected override onMessage(message: any) {
+    if (message.type !== 'ob_updates') {
+      return
+    }
+    if (message.action === 'error') {
+      const symbol = message.symbol
+      this.sequences.delete(symbol)
+      this.pendingSnapshots.add(symbol)
+    } else if (message.action === 'snapshot') {
+      this.sequences.set(message.sy, message.seq)
+      this.pendingSnapshots.delete(message.sy)
+    } else if (message.action === 'update') {
+      const previous = this.sequences.get(message.sy)
+      if (previous === undefined) {
+        return
+      }
+      if (message.seq !== previous + 1) {
+        throw new Error(`Delta India order book sequence gap for ${message.sy}: ${previous} -> ${message.seq}`)
+      }
+      this.sequences.set(message.sy, message.seq)
+    }
+  }
+
+  protected override async provideManualSnapshots(filters: Filter<string>[], shouldCancel: () => boolean) {
+    if (!filters.some((filter) => filter.channel === 'ob_updates')) {
+      return
+    }
+    // Native snapshots can be missing without an error; retry only those symbols on the same connection.
+    while (!shouldCancel()) {
+      if (this.pendingSnapshots.size && Date.now() >= this.retrySnapshotsAt) {
+        const channels = [{ name: 'ob_updates', symbols: [...this.pendingSnapshots] }]
+        this.send({ type: 'unsubscribe', payload: { channels } })
+        this.send({ type: 'subscribe', payload: { channels } })
+        this.retrySnapshotsAt = Date.now() + 5000
+      }
+      await wait(1000)
+    }
+  }
+
+  protected override sendCustomPing = () => this.send({ type: 'ping' })
+
+  protected override messageIsHeartbeat(message: any) {
+    return message.type === 'pong' || message.type === 'heartbeat'
+  }
+}

package/node_modules/tardis-dev/src/realtimefeeds/dydx_v4.ts

@@ -3,6 +3,7 @@ import { RealTimeFeedBase } from './realtimefeed.ts'
 
 export class DydxV4RealTimeFeed extends RealTimeFeedBase {
   protected readonly wssURL = 'wss://indexer.dydx.trade/v4/ws'
+  protected readonly perMessageDeflate = true
 
   protected mapToSubscribeMessages(filters: Filter<string>[]): any[] {
     const subs = filters

package/node_modules/tardis-dev/src/realtimefeeds/index.ts

@@ -33,6 +33,7 @@ import { OkexOptionsRealTimeFeed, OkexRealTimeFeed } from './okex.ts'
 import { RealTimeFeed } from './realtimefeed.ts'
 import { PhemexRealTimeFeed } from './phemex.ts'
 import { DeltaRealTimeFeed } from './delta.ts'
+import { DeltaIndiaRealTimeFeed } from './delta_india.ts'
 import { GateIORealTimeFeed } from './gateio.ts'
 import { GateIOFuturesRealTimeFeed } from './gateiofutures.ts'
 import { PoloniexRealTimeFeed } from './poloniex.ts'
@@ -98,6 +99,7 @@ const realTimeFeedsMap: {
   hitbtc: HitBtcRealTimeFeed,
   phemex: PhemexRealTimeFeed,
   delta: DeltaRealTimeFeed,
+  'delta-india': DeltaIndiaRealTimeFeed,
   'gate-io': GateIORealTimeFeed,
   'gate-io-futures': GateIOFuturesRealTimeFeed,
   'mexc-futures': MexcFuturesRealTimeFeed,

package/node_modules/tardis-dev/src/realtimefeeds/realtimefeed.ts

@@ -47,6 +47,7 @@ export abstract class RealTimeFeedBase implements RealTimeFeedIterable {
   private _connection?: RealTimeFeedConnection
   protected readonly originHeader: string | undefined = undefined
   protected readonly extraHeaders: Record<string, string> | undefined = undefined
+  protected readonly perMessageDeflate: boolean = false
 
   constructor(
     protected readonly _exchange: string,
@@ -63,7 +64,6 @@ export abstract class RealTimeFeedBase implements RealTimeFeedIterable {
         'User-Agent':
           'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.75 Safari/537.36'
       },
-      perMessageDeflate: false,
       handshakeTimeout: 10 * ONE_SEC_IN_MS,
       skipUTF8Validation: true
     } as any
@@ -123,6 +123,7 @@ export abstract class RealTimeFeedBase implements RealTimeFeedIterable {
           Object.assign((this._wsClientOptions as any).headers, this.extraHeaders)
         }
 
+        ;(this._wsClientOptions as any).perMessageDeflate = this.perMessageDeflate
         this._wsClientOptions.agent = getProxyAgent(finalWssUrl)
         const ws = new WebSocket(finalWssUrl, this._wsClientOptions)
         const currentConnection: RealTimeFeedConnection = {

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

@@ -163,8 +163,7 @@ async function getDataFeedSlice(
     }
   }
 
-  const requestCompression = dataFeedCompression === 'zstd' ? 'zstd-multiframe' : dataFeedCompression
-  let url = `${endpoint}/data-feeds/${exchange}?from=${fromDate.toISOString()}&offset=${offset}&compression=${requestCompression}`
+  let url = `${endpoint}/data-feeds/${exchange}?from=${fromDate.toISOString()}&offset=${offset}`
   if (requestedSliceSize > DEFAULT_DATA_FEED_SLICE_SIZE) {
     url += `&sliceSize=${requestedSliceSize}`
   }

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

@@ -1,139 +1,8 @@
-import { once } from 'node:events'
-import { open, type FileHandle } from 'node:fs/promises'
-import { Readable } from 'node:stream'
+import { createReadStream } from 'node:fs'
 import { createZstdDecompress } from 'node:zlib'
 
-const ZSTD_FRAME_MAGIC = 0xfd2fb528
-const DICTIONARY_ID_SIZES = [0, 1, 2, 4]
-
 export function createZstdDecompressionStream(path: string, chunkSize: number) {
-  return Readable.from(decompressZstdFrames(path, chunkSize), { objectMode: false })
-}
-
-async function* decompressZstdFrames(path: string, chunkSize: number) {
-  const file = await open(path, 'r')
-  try {
-    const fileSize = (await file.stat()).size
-    const frames = await findZstdFrames(file, path, fileSize)
-
-    for (const frame of frames) {
-      const source = Readable.from(readFileRange(file, frame.offset, frame.length, chunkSize), { objectMode: false })
-      const decompressor = createZstdDecompress({ chunkSize })
-      source.on('error', (error) => decompressor.destroy(error))
-      source.pipe(decompressor)
-
-      try {
-        for await (const chunk of decompressor) {
-          yield chunk
-        }
-
-        if (decompressor.bytesWritten !== frame.length) {
-          throw new Error(
-            `Zstd decoder consumed ${decompressor.bytesWritten} of ${frame.length} bytes at offset ${frame.offset} in ${path}`
-          )
-        }
-      } finally {
-        source.unpipe(decompressor)
-        source.destroy()
-        decompressor.destroy()
-        if (!source.closed) {
-          await once(source, 'close')
-        }
-      }
-    }
-  } finally {
-    await file.close()
-  }
-}
-
-async function findZstdFrames(file: FileHandle, path: string, fileSize: number) {
-  if (fileSize === 0) {
-    throw new Error(`Empty zstd file: ${path}`)
-  }
-
-  const bytes = Buffer.allocUnsafe(4)
-  const frames: { offset: number; length: number }[] = []
-  let offset = 0
-
-  while (offset < fileSize) {
-    const frameStart = offset
-    await readExactly(file, bytes, 4, offset, fileSize, path)
-    if (bytes.readUInt32LE(0) !== ZSTD_FRAME_MAGIC) {
-      throw new Error(`Invalid zstd frame magic at offset ${offset} in ${path}`)
-    }
-    offset += 4
-
-    await readExactly(file, bytes, 1, offset, fileSize, path)
-    const descriptor = bytes[0]
-    if ((descriptor & 0x08) !== 0) {
-      throw new Error(`Unsupported reserved zstd frame descriptor bit at offset ${offset} in ${path}`)
-    }
-    offset++
-
-    const singleSegment = (descriptor & 0x20) !== 0
-    const contentChecksum = (descriptor & 0x04) !== 0
-    const dictionaryIdSize = DICTIONARY_ID_SIZES[descriptor & 0x03]
-    const contentSizeFlag = descriptor >>> 6
-    const contentSizeSize = contentSizeFlag === 0 ? (singleSegment ? 1 : 0) : 1 << contentSizeFlag
-    const windowDescriptorSize = singleSegment ? 0 : 1
-    offset += windowDescriptorSize + dictionaryIdSize + contentSizeSize
-    ensureAvailable(offset, 0, fileSize, path)
-
-    let lastBlock = false
-    while (!lastBlock) {
-      await readExactly(file, bytes, 3, offset, fileSize, path)
-      const blockHeader = bytes.readUIntLE(0, 3)
-      offset += 3
-      lastBlock = (blockHeader & 1) !== 0
-      const blockType = (blockHeader >>> 1) & 3
-      if (blockType === 3) {
-        throw new Error(`Invalid reserved zstd block type at offset ${offset - 3} in ${path}`)
-      }
-
-      const blockSize = blockHeader >>> 3
-      // RLE blocks store one repeated byte; other block types store blockSize bytes.
-      offset += blockType === 1 ? 1 : blockSize
-      ensureAvailable(offset, 0, fileSize, path)
-    }
-
-    if (contentChecksum) {
-      offset += 4
-      ensureAvailable(offset, 0, fileSize, path)
-    }
-    frames.push({ offset: frameStart, length: offset - frameStart })
-  }
-
-  return frames
-}
-
-async function* readFileRange(file: FileHandle, position: number, length: number, chunkSize: number) {
-  let bytesRemaining = length
-  while (bytesRemaining > 0) {
-    const buffer = Buffer.allocUnsafe(Math.min(bytesRemaining, chunkSize))
-    const { bytesRead } = await file.read(buffer, 0, buffer.length, position)
-    if (bytesRead === 0) {
-      throw new Error(`Expected ${length} compressed bytes, read ${length - bytesRemaining}`)
-    }
-    yield bytesRead === buffer.length ? buffer : buffer.subarray(0, bytesRead)
-    position += bytesRead
-    bytesRemaining -= bytesRead
-  }
-}
-
-async function readExactly(file: FileHandle, buffer: Buffer, length: number, position: number, fileSize: number, path: string) {
-  ensureAvailable(position, length, fileSize, path)
-  let bytesRead = 0
-  while (bytesRead < length) {
-    const result = await file.read(buffer, bytesRead, length - bytesRead, position + bytesRead)
-    if (result.bytesRead === 0) {
-      throw new Error(`Truncated zstd frame at offset ${position + bytesRead} in ${path}`)
-    }
-    bytesRead += result.bytesRead
-  }
-}
-
-function ensureAvailable(position: number, length: number, fileSize: number, path: string) {
-  if (position < 0 || length < 0 || position > fileSize - length) {
-    throw new Error(`Truncated zstd frame at offset ${position} in ${path}`)
-  }
+  // Node supports rejectGarbageAfterEnd for Zstd; @types/node does not declare it yet.
+  const decoderOptions = { chunkSize, rejectGarbageAfterEnd: true }
+  return createReadStream(path, { highWaterMark: chunkSize }).compose(createZstdDecompress(decoderOptions))
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tardis-machine",
-  "version": "18.6.2",
+  "version": "18.8.0",
   "engines": {
     "node": "^24.22.1 || >=26.12.1"
   },
@@ -76,7 +76,7 @@
   "license": "MPL-2.0",
   "dependencies": {
     "debug": "^4.4.3",
-    "tardis-dev": "^18.6.2",
+    "tardis-dev": "^18.8.0",
     "ws": "^8.21.3"
   },
   "bundleDependencies": true,

package/src/ws/subscriptionsmappers.ts

@@ -413,6 +413,11 @@ const deltaMapper: SubscriptionMapper = {
   }
 }
 
+const deltaIndiaMapper: SubscriptionMapper = {
+  canHandle: (message: any) => message.type === 'subscribe',
+  map: (message: any) => message.payload.channels.map((channel: any) => ({ channel: channel.name, symbols: channel.symbols }))
+}
+
 const gateIOMapper: SubscriptionMapper = {
   canHandle: (message: any) => {
     return message.method !== undefined && message.method.endsWith('.subscribe')
@@ -865,6 +870,7 @@ export const subscriptionsMappers: Record<Exchange, SubscriptionMapper> = {
   coinflex: coinflexMapper,
   phemex: phemexMapper,
   delta: deltaMapper,
+  'delta-india': deltaIndiaMapper,
   'gate-io': gateIOMapper,
   'gate-io-futures': gateIOFuturesMapper,
   poloniex: poloniexMapper,