@xapy/orderbook 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1744 @@
+'use strict';
+
+// src/core/errors.ts
+var ExchangeError = class extends Error {
+  constructor(exchange, message, cause) {
+    super(
+      `[${exchange}] ${message}`,
+      cause === void 0 ? void 0 : { cause }
+    );
+    this.exchange = exchange;
+    this.name = "ExchangeError";
+  }
+  exchange;
+};
+var RateLimitError = class extends ExchangeError {
+  constructor(exchange, message = "rate limited") {
+    super(exchange, message);
+    this.name = "RateLimitError";
+  }
+};
+var SequenceGapError = class extends Error {
+  constructor(expected, received) {
+    super(`sequence gap: expected ${expected}, received ${received}`);
+    this.expected = expected;
+    this.received = received;
+    this.name = "SequenceGapError";
+  }
+  expected;
+  received;
+};
+
+// src/core/book-merger.ts
+var BookMerger = class {
+  bids = /* @__PURE__ */ new Map();
+  // price -> size
+  asks = /* @__PURE__ */ new Map();
+  sequence = -1;
+  timestamp = 0;
+  hasSnapshot = false;
+  apply(event) {
+    if (event.kind === "snapshot") {
+      this.bids.clear();
+      this.asks.clear();
+      for (const { price, size } of event.bids) {
+        if (size > 0) this.bids.set(price, size);
+      }
+      for (const { price, size } of event.asks) {
+        if (size > 0) this.asks.set(price, size);
+      }
+      this.sequence = event.sequence;
+      this.timestamp = event.timestamp;
+      this.hasSnapshot = true;
+      return this.emit();
+    }
+    if (!this.hasSnapshot) {
+      return { ok: false, reason: "no-snapshot" };
+    }
+    if (event.sequence <= this.sequence) {
+      return this.emit();
+    }
+    if (event.prevSequence !== void 0) {
+      if (event.prevSequence !== this.sequence) {
+        return {
+          ok: false,
+          reason: "gap",
+          expected: this.sequence,
+          received: event.prevSequence
+        };
+      }
+    } else if (event.sequence !== this.sequence + 1) {
+      return {
+        ok: false,
+        reason: "gap",
+        expected: this.sequence + 1,
+        received: event.sequence
+      };
+    }
+    for (const { price, size } of event.bids) {
+      if (size === 0) this.bids.delete(price);
+      else this.bids.set(price, size);
+    }
+    for (const { price, size } of event.asks) {
+      if (size === 0) this.asks.delete(price);
+      else this.asks.set(price, size);
+    }
+    this.sequence = event.sequence;
+    this.timestamp = event.timestamp;
+    return this.emit();
+  }
+  reset() {
+    this.bids.clear();
+    this.asks.clear();
+    this.sequence = -1;
+    this.timestamp = 0;
+    this.hasSnapshot = false;
+  }
+  /** Returns true once the merger has a usable book. */
+  isReady() {
+    return this.hasSnapshot;
+  }
+  emit() {
+    const bids = [];
+    for (const [price, size] of this.bids) bids.push({ price, size });
+    bids.sort((a, b) => b.price - a.price);
+    const asks = [];
+    for (const [price, size] of this.asks) asks.push({ price, size });
+    asks.sort((a, b) => a.price - b.price);
+    return {
+      ok: true,
+      bids,
+      asks,
+      sequence: this.sequence,
+      timestamp: this.timestamp
+    };
+  }
+};
+
+// src/core/event-emitter.ts
+var TypedEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, fn) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(fn);
+    return this;
+  }
+  off(event, fn) {
+    this.listeners.get(event)?.delete(fn);
+    return this;
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set || set.size === 0) return false;
+    for (const fn of set) fn(...args);
+    return true;
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+
+// src/core/stream.ts
+var OrderbookStream = class extends TypedEmitter {
+  constructor(onClose) {
+    super();
+    this.onClose = onClose;
+  }
+  onClose;
+  closed = false;
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.onClose();
+    this.removeAllListeners();
+  }
+  /** Yields each maintained book as it becomes available. */
+  async *iter() {
+    const queue = [];
+    let resolveNext = null;
+    let pendingError = null;
+    let ended = false;
+    const onUpdate = (b) => {
+      queue.push(b);
+      resolveNext?.();
+    };
+    const onError = (e) => {
+      pendingError = e;
+      resolveNext?.();
+    };
+    const onClose = () => {
+      ended = true;
+      resolveNext?.();
+    };
+    this.on("update", onUpdate);
+    this.on("error", onError);
+    this.on("disconnected", onClose);
+    try {
+      while (true) {
+        if (pendingError) throw pendingError;
+        const next = queue.shift();
+        if (next) {
+          yield next;
+          continue;
+        }
+        if (ended || this.closed) return;
+        await new Promise((r) => {
+          resolveNext = r;
+        });
+        resolveNext = null;
+      }
+    } finally {
+      this.off("update", onUpdate);
+      this.off("error", onError);
+      this.off("disconnected", onClose);
+    }
+  }
+};
+
+// src/core/reconnect.ts
+var Backoff = class _Backoff {
+  attempt = 0;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  static withDefaults(opts = {}) {
+    return new _Backoff({
+      initialMs: opts.initialMs ?? 500,
+      maxMs: opts.maxMs ?? 3e4,
+      factor: opts.factor ?? 2,
+      jitter: opts.jitter ?? 0.3,
+      maxAttempts: opts.maxAttempts ?? 0
+    });
+  }
+  next() {
+    if (this.opts.maxAttempts > 0 && this.attempt >= this.opts.maxAttempts) {
+      return null;
+    }
+    this.attempt += 1;
+    const base = Math.min(
+      this.opts.initialMs * Math.pow(this.opts.factor, this.attempt - 1),
+      this.opts.maxMs
+    );
+    const jitterRange = base * this.opts.jitter;
+    const wait = Math.max(0, base + (Math.random() * 2 - 1) * jitterRange);
+    return { wait, attempt: this.attempt };
+  }
+  reset() {
+    this.attempt = 0;
+  }
+};
+
+// src/core/symbol.ts
+function parseSymbol(symbol) {
+  const [pair, settle] = symbol.split(":");
+  const parts = (pair ?? "").split("/");
+  const base = parts[0]?.toUpperCase();
+  const quote = parts[1]?.toUpperCase();
+  if (!base || !quote) {
+    throw new Error(
+      `invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE" or "BASE/QUOTE:SETTLE"`
+    );
+  }
+  if (settle && settle.toUpperCase() !== quote) {
+    throw new Error(
+      `unsupported settlement currency in "${symbol}" \u2014 only linear (settle === quote) is supported`
+    );
+  }
+  return {
+    base,
+    quote,
+    market: settle ? "perpetual" : "spot",
+    pair: `${base}/${quote}`
+  };
+}
+
+// src/transport/http.ts
+async function httpJson(req) {
+  const url = req.transformUrl ? req.transformUrl(req.url) : req.url;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), req.timeoutMs ?? 1e4);
+  try {
+    const res = await fetch(url, {
+      method: req.method ?? "GET",
+      headers: req.headers,
+      body: req.body,
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`HTTP ${res.status} ${res.statusText}: ${text.slice(0, 200)}`);
+    }
+    return await res.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/exchanges/bybit/symbols.ts
+var QUOTES = ["USDT", "USDC", "USD"];
+function toBybitSymbol(symbol) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  return `${base}${quote}`.toUpperCase();
+}
+function fromBybitSymbol(s) {
+  const upper = s.toUpperCase();
+  for (const q of QUOTES) {
+    if (upper.endsWith(q)) {
+      return `${upper.slice(0, -q.length)}/${q}`;
+    }
+  }
+  return upper;
+}
+
+// src/exchanges/bybit/rest.ts
+var BASE = "https://api.bybit.com";
+async function fetchBybitOrderbook(opts) {
+  const category = opts.market === "spot" ? "spot" : "linear";
+  const limit = opts.depth ?? 50;
+  const url = `${BASE}/v5/market/orderbook?category=${category}&symbol=${toBybitSymbol(opts.symbol)}&limit=${limit}`;
+  const res = await httpJson({
+    url,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (res.retCode !== 0) {
+    throw new ExchangeError("bybit", `${res.retCode}: ${res.retMsg}`);
+  }
+  return {
+    exchange: "bybit",
+    symbol: fromBybitSymbol(res.result.s),
+    market: opts.market,
+    bids: res.result.b.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    asks: res.result.a.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    timestamp: res.result.ts,
+    sequence: res.result.u
+  };
+}
+var hasNativeWebSocket = typeof globalThis.WebSocket !== "undefined";
+
+// src/transport/ws.ts
+var cachedCtor = null;
+async function getWebSocketCtor() {
+  if (cachedCtor) return cachedCtor;
+  if (hasNativeWebSocket) {
+    cachedCtor = globalThis.WebSocket;
+    return cachedCtor;
+  }
+  try {
+    const mod = await import('ws');
+    const ctor = mod.default ?? mod.WebSocket;
+    if (!ctor) throw new Error("missing default export");
+    cachedCtor = ctor;
+    return cachedCtor;
+  } catch (err) {
+    throw new Error(
+      "WebSocket unavailable; install peer dep `ws` for Node <22. " + (err instanceof Error ? err.message : String(err))
+    );
+  }
+}
+var WSClient = class extends TypedEmitter {
+  constructor(cfg) {
+    super();
+    this.cfg = cfg;
+    this.backoff = Backoff.withDefaults(cfg.reconnect);
+  }
+  cfg;
+  ws = null;
+  backoff;
+  closed = false;
+  pingTimer = null;
+  async connect() {
+    if (this.closed) return;
+    const WS = await getWebSocketCtor();
+    const ws = new WS(this.cfg.url);
+    ws.binaryType = "arraybuffer";
+    this.ws = ws;
+    ws.onopen = async () => {
+      this.backoff.reset();
+      this.startPing();
+      this.emit("open");
+      try {
+        await this.cfg.onOpen?.({
+          send: (d) => ws.send(d),
+          close: () => this.close()
+        });
+      } catch (err) {
+        this.emit("error", err);
+      }
+    };
+    ws.onmessage = (e) => {
+      let result;
+      try {
+        result = this.cfg.onMessage(e.data);
+      } catch (err) {
+        this.emit("error", err);
+        return;
+      }
+      if (result && typeof result.catch === "function") {
+        result.catch(
+          (err) => this.emit("error", err)
+        );
+      }
+    };
+    ws.onerror = (e) => {
+      this.emit("error", new Error(e?.message ?? "WebSocket error"));
+    };
+    ws.onclose = (e) => {
+      this.stopPing();
+      const reason = e?.reason ?? "closed";
+      this.emit("close", reason);
+      if (!this.closed) this.scheduleReconnect();
+    };
+  }
+  send(data) {
+    this.ws?.send(data);
+  }
+  close() {
+    this.closed = true;
+    this.stopPing();
+    try {
+      this.ws?.close();
+    } catch {
+    }
+  }
+  startPing() {
+    if (!this.cfg.pingIntervalMs || !this.cfg.pingPayload) return;
+    this.stopPing();
+    this.pingTimer = setInterval(() => {
+      try {
+        this.ws?.send(this.cfg.pingPayload());
+      } catch {
+      }
+    }, this.cfg.pingIntervalMs);
+  }
+  stopPing() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+  scheduleReconnect() {
+    const next = this.backoff.next();
+    if (!next) {
+      this.emit("error", new Error("max reconnect attempts exceeded"));
+      return;
+    }
+    this.emit("reconnecting", next.attempt, next.wait);
+    setTimeout(() => {
+      this.connect().catch((e) => this.emit("error", e));
+    }, next.wait);
+  }
+};
+
+// src/exchanges/bybit/ws.ts
+var WS_SPOT = "wss://stream.bybit.com/v5/public/spot";
+var WS_LINEAR = "wss://stream.bybit.com/v5/public/linear";
+function streamBybitOrderbook(opts) {
+  const wsUrl = opts.market === "spot" ? WS_SPOT : WS_LINEAR;
+  const depth = opts.depth ?? 50;
+  const bybitSymbol = toBybitSymbol(opts.symbol);
+  const topic = `orderbook.${depth}.${bybitSymbol}`;
+  const merger = new BookMerger();
+  let recovering = false;
+  let ws = null;
+  const stream = new OrderbookStream(() => ws?.close());
+  const handleMergeResult = (data, timestamp) => {
+    const r = merger.apply(buildEvent(
+      data,
+      timestamp,
+      /*isSnapshot*/
+      false
+    ));
+    if (r.ok) {
+      stream.emit("update", buildBook(opts, data.s, r));
+      return;
+    }
+    if (r.reason === "no-snapshot" || r.reason === "gap") {
+      triggerResnapshot();
+    }
+  };
+  const triggerResnapshot = () => {
+    if (recovering) return;
+    recovering = true;
+    merger.reset();
+    fetchBybitOrderbook({
+      symbol: opts.symbol,
+      market: opts.market,
+      depth,
+      timeoutMs: opts.timeoutMs,
+      transformUrl: opts.transformUrl
+    }).then((snap) => {
+      const r = merger.apply({
+        kind: "snapshot",
+        bids: snap.bids,
+        asks: snap.asks,
+        sequence: snap.sequence,
+        timestamp: snap.timestamp
+      });
+      if (r.ok) {
+        stream.emit("update", { ...snap, bids: r.bids, asks: r.asks });
+      }
+    }).catch((err) => stream.emit("error", err)).finally(() => {
+      recovering = false;
+    });
+  };
+  const onMessage = (raw) => {
+    if (typeof raw !== "string") return;
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.op === "ping" || msg.op === "pong") return;
+    if (msg.op === "subscribe") return;
+    if (!msg.topic || msg.topic !== topic || !msg.data) return;
+    const ts = msg.ts ?? Date.now();
+    const data = msg.data;
+    if (msg.type === "snapshot") {
+      const r = merger.apply(buildEvent(
+        data,
+        ts,
+        /*isSnapshot*/
+        true
+      ));
+      if (r.ok) stream.emit("update", buildBook(opts, data.s, r));
+      return;
+    }
+    handleMergeResult(data, ts);
+  };
+  ws = new WSClient({
+    url: wsUrl,
+    onOpen: (sock) => {
+      merger.reset();
+      sock.send(JSON.stringify({ op: "subscribe", args: [topic] }));
+    },
+    onMessage,
+    pingIntervalMs: 2e4,
+    pingPayload: () => JSON.stringify({ op: "ping" })
+  });
+  ws.on("open", () => stream.emit("connected"));
+  ws.on("close", (r) => stream.emit("disconnected", r));
+  ws.on("reconnecting", (a, w) => stream.emit("reconnecting", a, w));
+  ws.on("error", (e) => stream.emit("error", e));
+  ws.connect().catch((e) => stream.emit("error", e));
+  return stream;
+}
+function buildEvent(data, timestamp, isSnapshot) {
+  const bids = data.b.map(([p, s]) => ({ price: Number(p), size: Number(s) }));
+  const asks = data.a.map(([p, s]) => ({ price: Number(p), size: Number(s) }));
+  if (isSnapshot) {
+    return { kind: "snapshot", bids, asks, sequence: data.u, timestamp };
+  }
+  return { kind: "delta", bids, asks, sequence: data.u, timestamp };
+}
+function buildBook(opts, rawSymbol, merged) {
+  return {
+    exchange: "bybit",
+    symbol: fromBybitSymbol(rawSymbol),
+    market: opts.market,
+    bids: merged.bids,
+    asks: merged.asks,
+    timestamp: merged.timestamp,
+    sequence: merged.sequence
+  };
+}
+
+// src/exchanges/bybit/index.ts
+var BybitClient = class {
+  exchange = "bybit";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchBybitOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamBybitOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+// src/exchanges/bitget/symbols.ts
+var QUOTES2 = ["USDT", "USDC", "USD"];
+function toBitgetSymbol(symbol) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  return `${base}${quote}`.toUpperCase();
+}
+function fromBitgetSymbol(s) {
+  const upper = s.toUpperCase();
+  for (const q of QUOTES2) {
+    if (upper.endsWith(q)) {
+      return `${upper.slice(0, -q.length)}/${q}`;
+    }
+  }
+  return upper;
+}
+
+// src/exchanges/bitget/rest.ts
+var BASE2 = "https://api.bitget.com";
+async function fetchBitgetOrderbook(opts) {
+  const symbol = toBitgetSymbol(opts.symbol);
+  const limit = opts.depth ?? 50;
+  const url = opts.market === "spot" ? `${BASE2}/api/v2/spot/market/orderbook?symbol=${symbol}&limit=${limit}` : `${BASE2}/api/v2/mix/market/merge-depth?symbol=${symbol}&productType=USDT-FUTURES&limit=${limit}`;
+  const res = await httpJson({
+    url,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (res.code !== "00000") {
+    throw new ExchangeError("bitget", `${res.code}: ${res.msg}`);
+  }
+  const ts = Number(res.data.ts);
+  return {
+    exchange: "bitget",
+    symbol: fromBitgetSymbol(symbol),
+    market: opts.market,
+    bids: res.data.bids.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    asks: res.data.asks.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    timestamp: ts,
+    sequence: ts
+    // REST endpoint doesn't expose a seq; ts is monotonic in practice
+  };
+}
+
+// src/exchanges/bitget/ws.ts
+var WS_PUBLIC = "wss://ws.bitget.com/v2/ws/public";
+function streamBitgetOrderbook(opts) {
+  const bitgetSymbol = toBitgetSymbol(opts.symbol);
+  const instType = opts.market === "spot" ? "SPOT" : "USDT-FUTURES";
+  const channel = "books";
+  const merger = new BookMerger();
+  let lastSeq = -1;
+  let recovering = false;
+  let ws = null;
+  const stream = new OrderbookStream(() => ws?.close());
+  const subscribePayload = JSON.stringify({
+    op: "subscribe",
+    args: [{ instType, channel, instId: bitgetSymbol }]
+  });
+  const handleEntry = (entry, isSnapshot) => {
+    const ts = Number(entry.ts);
+    const sequence = entry.seq ?? ts;
+    const event = isSnapshot ? {
+      kind: "snapshot",
+      bids: entry.bids.map(([p, s]) => ({
+        price: Number(p),
+        size: Number(s)
+      })),
+      asks: entry.asks.map(([p, s]) => ({
+        price: Number(p),
+        size: Number(s)
+      })),
+      sequence,
+      timestamp: ts
+    } : {
+      kind: "delta",
+      bids: entry.bids.map(([p, s]) => ({
+        price: Number(p),
+        size: Number(s)
+      })),
+      asks: entry.asks.map(([p, s]) => ({
+        price: Number(p),
+        size: Number(s)
+      })),
+      // bitget doesn't publish prevSeq; pass it ourselves so merger checks
+      // consecutive ordering without assuming the seq jumps by exactly 1.
+      prevSequence: lastSeq >= 0 ? lastSeq : void 0,
+      sequence,
+      timestamp: ts
+    };
+    const r = merger.apply(event);
+    if (r.ok) {
+      lastSeq = r.sequence;
+      stream.emit("update", {
+        exchange: "bitget",
+        symbol: fromBitgetSymbol(bitgetSymbol),
+        market: opts.market,
+        bids: r.bids,
+        asks: r.asks,
+        timestamp: r.timestamp,
+        sequence: r.sequence
+      });
+      return;
+    }
+    if (r.reason === "no-snapshot" || r.reason === "gap") {
+      triggerResnapshot();
+    }
+  };
+  const triggerResnapshot = () => {
+    if (recovering) return;
+    recovering = true;
+    merger.reset();
+    lastSeq = -1;
+    fetchBitgetOrderbook({
+      symbol: opts.symbol,
+      market: opts.market,
+      depth: opts.depth,
+      timeoutMs: opts.timeoutMs,
+      transformUrl: opts.transformUrl
+    }).then((snap) => {
+      const r = merger.apply({
+        kind: "snapshot",
+        bids: snap.bids,
+        asks: snap.asks,
+        sequence: snap.sequence,
+        timestamp: snap.timestamp
+      });
+      if (r.ok) {
+        lastSeq = r.sequence;
+        stream.emit("update", { ...snap, bids: r.bids, asks: r.asks });
+      }
+    }).catch((err) => stream.emit("error", err)).finally(() => {
+      recovering = false;
+    });
+  };
+  const onMessage = (raw) => {
+    if (typeof raw !== "string") return;
+    if (raw === "pong") return;
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.event === "subscribe" || msg.event === "error") return;
+    if (!msg.action || !msg.data?.length) return;
+    if (msg.arg?.channel !== channel || msg.arg?.instId !== bitgetSymbol) return;
+    const isSnapshot = msg.action === "snapshot";
+    for (const entry of msg.data) {
+      handleEntry(entry, isSnapshot);
+    }
+  };
+  ws = new WSClient({
+    url: WS_PUBLIC,
+    onOpen: (sock) => {
+      merger.reset();
+      lastSeq = -1;
+      sock.send(subscribePayload);
+    },
+    onMessage,
+    pingIntervalMs: 25e3,
+    // bitget idle-closes at 30s
+    pingPayload: () => "ping"
+  });
+  ws.on("open", () => stream.emit("connected"));
+  ws.on("close", (r) => stream.emit("disconnected", r));
+  ws.on("reconnecting", (a, w) => stream.emit("reconnecting", a, w));
+  ws.on("error", (e) => stream.emit("error", e));
+  ws.connect().catch((e) => stream.emit("error", e));
+  return stream;
+}
+
+// src/exchanges/bitget/index.ts
+var BitgetClient = class {
+  exchange = "bitget";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchBitgetOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamBitgetOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+// src/exchanges/gate/symbols.ts
+function toGateSymbol(symbol) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  return `${base}_${quote}`.toUpperCase();
+}
+function fromGateSymbol(s) {
+  return s.toUpperCase().replace("_", "/");
+}
+
+// src/exchanges/gate/rest.ts
+var BASE3 = "https://api.gateio.ws";
+async function fetchGateOrderbook(opts) {
+  const symbol = toGateSymbol(opts.symbol);
+  const limit = opts.depth ?? 50;
+  if (opts.market === "spot") {
+    const url2 = `${BASE3}/api/v4/spot/order_book?currency_pair=${symbol}&limit=${limit}&with_id=true`;
+    const data2 = await httpJson({
+      url: url2,
+      timeoutMs: opts.timeoutMs,
+      transformUrl: opts.transformUrl
+    });
+    return {
+      exchange: "gate",
+      symbol: fromGateSymbol(symbol),
+      market: "spot",
+      bids: parseArrayLevels(data2.bids),
+      asks: parseArrayLevels(data2.asks),
+      timestamp: data2.update,
+      sequence: data2.id
+    };
+  }
+  const url = `${BASE3}/api/v4/futures/usdt/order_book?contract=${symbol}&limit=${limit}&with_id=true`;
+  const data = await httpJson({
+    url,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  return {
+    exchange: "gate",
+    symbol: fromGateSymbol(symbol),
+    market: "perpetual",
+    bids: parseObjectLevels(data.bids),
+    asks: parseObjectLevels(data.asks),
+    timestamp: data.update,
+    sequence: data.id ?? data.update
+  };
+}
+function parseArrayLevels(rows) {
+  return rows.map(([p, s]) => ({ price: Number(p), size: Number(s) }));
+}
+function parseObjectLevels(rows) {
+  return rows.map((r) => ({ price: Number(r.p), size: Number(r.s) }));
+}
+
+// src/exchanges/gate/ws.ts
+var WS_SPOT2 = "wss://api.gateio.ws/ws/v4/";
+var WS_FUTURES = "wss://fx-ws.gateio.ws/v4/ws/usdt";
+function streamGateOrderbook(opts) {
+  const isFutures = opts.market === "perpetual";
+  const gateSymbol = toGateSymbol(opts.symbol);
+  const channel = isFutures ? "futures.order_book_update" : "spot.order_book_update";
+  const interval = `${opts.intervalMs ?? 100}ms`;
+  const depth = String(opts.depth ?? 100);
+  const merger = new BookMerger();
+  let snapshotSequence = -1;
+  let lastU = -1;
+  let snapshotInFlight = false;
+  let snapshotDone = false;
+  let buffered = [];
+  let recovering = false;
+  let ws = null;
+  const stream = new OrderbookStream(() => ws?.close());
+  const payload = isFutures ? [gateSymbol, interval, depth] : [gateSymbol, depth, interval];
+  const subscribeMsg = () => JSON.stringify({
+    time: Math.floor(Date.now() / 1e3),
+    channel,
+    event: "subscribe",
+    payload
+  });
+  const pingMsg = () => JSON.stringify({
+    time: Math.floor(Date.now() / 1e3),
+    channel: isFutures ? "futures.ping" : "spot.ping"
+  });
+  const emitBook = (bids, asks, sequence, timestamp) => {
+    const book = {
+      exchange: "gate",
+      symbol: fromGateSymbol(gateSymbol),
+      market: opts.market,
+      bids,
+      asks,
+      timestamp,
+      sequence
+    };
+    stream.emit("update", book);
+  };
+  const triggerSnapshot = () => {
+    if (snapshotInFlight || recovering) return;
+    snapshotInFlight = true;
+    fetchGateOrderbook({
+      symbol: opts.symbol,
+      market: opts.market,
+      depth: opts.depth ?? 100,
+      timeoutMs: opts.timeoutMs,
+      transformUrl: opts.transformUrl
+    }).then((snap) => {
+      snapshotSequence = snap.sequence;
+      const r = merger.apply({
+        kind: "snapshot",
+        bids: snap.bids,
+        asks: snap.asks,
+        sequence: snap.sequence,
+        timestamp: snap.timestamp
+      });
+      if (r.ok) emitBook(r.bids, r.asks, r.sequence, r.timestamp);
+      snapshotDone = true;
+      lastU = -1;
+      const pending2 = buffered;
+      buffered = [];
+      for (const ev of pending2) processDelta(ev);
+    }).catch((err) => stream.emit("error", err)).finally(() => {
+      snapshotInFlight = false;
+    });
+  };
+  const resync = () => {
+    if (recovering) return;
+    recovering = true;
+    merger.reset();
+    snapshotSequence = -1;
+    snapshotDone = false;
+    lastU = -1;
+    buffered = [];
+    setTimeout(() => {
+      recovering = false;
+      triggerSnapshot();
+    }, 100);
+  };
+  const processDelta = (ev) => {
+    if (ev.u <= snapshotSequence) return;
+    let prevSequence;
+    if (lastU < 0) {
+      if (ev.U > snapshotSequence + 1) {
+        resync();
+        return;
+      }
+      prevSequence = snapshotSequence;
+    } else {
+      prevSequence = lastU;
+    }
+    const r = merger.apply({
+      kind: "delta",
+      bids: ev.bids,
+      asks: ev.asks,
+      sequence: ev.u,
+      prevSequence,
+      timestamp: ev.t
+    });
+    if (r.ok) {
+      lastU = ev.u;
+      emitBook(r.bids, r.asks, r.sequence, r.timestamp);
+    } else if (r.reason === "gap") {
+      resync();
+    }
+  };
+  const onMessage = (raw) => {
+    if (typeof raw !== "string") return;
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.event === "subscribe" || msg.event === "pong") return;
+    if (msg.error) {
+      stream.emit("error", new Error(`gate: ${msg.error.message}`));
+      return;
+    }
+    if (msg.channel !== channel || !msg.result) return;
+    if (msg.event !== "update") return;
+    const ev = normalize(msg.result, isFutures);
+    if (!snapshotDone) {
+      buffered.push(ev);
+      if (!snapshotInFlight) triggerSnapshot();
+      return;
+    }
+    processDelta(ev);
+  };
+  ws = new WSClient({
+    url: isFutures ? WS_FUTURES : WS_SPOT2,
+    onOpen: (sock) => {
+      merger.reset();
+      snapshotSequence = -1;
+      snapshotDone = false;
+      lastU = -1;
+      buffered = [];
+      sock.send(subscribeMsg());
+    },
+    onMessage,
+    pingIntervalMs: 15e3,
+    pingPayload: pingMsg
+  });
+  ws.on("open", () => stream.emit("connected"));
+  ws.on("close", (r) => stream.emit("disconnected", r));
+  ws.on("reconnecting", (a, w) => stream.emit("reconnecting", a, w));
+  ws.on("error", (e) => stream.emit("error", e));
+  ws.connect().catch((e) => stream.emit("error", e));
+  return stream;
+}
+function normalize(ev, isFutures) {
+  if (isFutures) {
+    const f = ev;
+    return {
+      U: f.U,
+      u: f.u,
+      t: f.t,
+      bids: f.b.map((row) => ({ price: Number(row.p), size: Number(row.s) })),
+      asks: f.a.map((row) => ({ price: Number(row.p), size: Number(row.s) }))
+    };
+  }
+  const s = ev;
+  return {
+    U: s.U,
+    u: s.u,
+    t: s.t,
+    bids: s.b.map(([p, sz]) => ({ price: Number(p), size: Number(sz) })),
+    asks: s.a.map(([p, sz]) => ({ price: Number(p), size: Number(sz) }))
+  };
+}
+
+// src/exchanges/gate/index.ts
+var GateClient = class {
+  exchange = "gate";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchGateOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamGateOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+// src/exchanges/bingx/symbols.ts
+function toBingxSymbol(symbol) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  return `${base}-${quote}`.toUpperCase();
+}
+function fromBingxSymbol(s) {
+  return s.toUpperCase().replace("-", "/");
+}
+
+// src/exchanges/bingx/rest.ts
+var BASE4 = "https://open-api.bingx.com";
+async function fetchBingxOrderbook(opts) {
+  const symbol = toBingxSymbol(opts.symbol);
+  const limit = opts.depth ?? 50;
+  const url = opts.market === "spot" ? `${BASE4}/openApi/spot/v1/market/depth?symbol=${symbol}&limit=${limit}` : `${BASE4}/openApi/swap/v2/quote/depth?symbol=${symbol}&limit=${limit}`;
+  const res = await httpJson({
+    url,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (res.code !== 0) {
+    throw new ExchangeError("bingx", `${res.code}: ${res.msg}`);
+  }
+  const ts = res.data.T ?? res.data.ts ?? Date.now();
+  return {
+    exchange: "bingx",
+    symbol: fromBingxSymbol(symbol),
+    market: opts.market,
+    bids: res.data.bids.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    asks: res.data.asks.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    timestamp: ts,
+    sequence: ts
+  };
+}
+
+// src/utils/gzip.ts
+var cached = null;
+var pending = null;
+function getGzipInflate() {
+  if (cached) return Promise.resolve(cached);
+  if (pending) return pending;
+  pending = (async () => {
+    let pako;
+    try {
+      pako = await import('pako');
+    } catch (err) {
+      throw new Error(
+        "gzip decompression requires the `pako` peer dependency. " + (err instanceof Error ? err.message : String(err))
+      );
+    }
+    const inflate = (data) => {
+      const buf = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+      try {
+        return pako.ungzip(buf, { to: "string" });
+      } catch {
+        return pako.inflate(buf, { to: "string" });
+      }
+    };
+    cached = inflate;
+    return inflate;
+  })();
+  return pending;
+}
+
+// src/exchanges/bingx/ws.ts
+var WS_SPOT3 = "wss://open-api-ws.bingx.com/market";
+var WS_SWAP = "wss://open-api-swap.bingx.com/swap-market";
+function streamBingxOrderbook(opts) {
+  const isSpot = opts.market === "spot";
+  const bingxSymbol = toBingxSymbol(opts.symbol);
+  const depth = opts.depth ?? 20;
+  const dataType = `${bingxSymbol}@depth${depth}`;
+  const merger = new BookMerger();
+  let ws = null;
+  const stream = new OrderbookStream(() => ws?.close());
+  const subscribePayload = JSON.stringify({
+    id: `sub-${Date.now()}`,
+    reqType: "sub",
+    dataType
+  });
+  const handlePayload = (text) => {
+    if (text === "Ping" || text === "ping") {
+      ws?.send(text === "Ping" ? "Pong" : "pong");
+      return;
+    }
+    let msg;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (msg.id && !msg.data) return;
+    if (msg.dataType !== dataType || !msg.data) return;
+    const d = msg.data;
+    const ts = d.T ?? d.ts ?? Date.now();
+    const event = {
+      kind: "snapshot",
+      bids: d.bids.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+      asks: d.asks.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+      sequence: ts,
+      timestamp: ts
+    };
+    const r = merger.apply(event);
+    if (!r.ok) return;
+    const book = {
+      exchange: "bingx",
+      symbol: fromBingxSymbol(bingxSymbol),
+      market: opts.market,
+      bids: r.bids,
+      asks: r.asks,
+      timestamp: r.timestamp,
+      sequence: r.sequence
+    };
+    stream.emit("update", book);
+  };
+  const onMessage = async (raw) => {
+    if (typeof raw === "string") {
+      handlePayload(raw);
+      return;
+    }
+    const inflate = await getGzipInflate();
+    handlePayload(inflate(raw));
+  };
+  ws = new WSClient({
+    url: isSpot ? WS_SPOT3 : WS_SWAP,
+    onOpen: (sock) => {
+      merger.reset();
+      sock.send(subscribePayload);
+    },
+    onMessage
+    // bingx server is the one that sends Ping frames; we don't need client pings.
+  });
+  ws.on("open", () => stream.emit("connected"));
+  ws.on("close", (r) => stream.emit("disconnected", r));
+  ws.on("reconnecting", (a, w) => stream.emit("reconnecting", a, w));
+  ws.on("error", (e) => stream.emit("error", e));
+  ws.connect().catch((e) => stream.emit("error", e));
+  return stream;
+}
+
+// src/exchanges/bingx/index.ts
+var BingxClient = class {
+  exchange = "bingx";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchBingxOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamBingxOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+// src/exchanges/huobi/symbols.ts
+var QUOTES3 = ["USDT", "USDC", "USD", "BTC", "ETH"];
+function toHuobiSymbol(symbol, market) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  return market === "spot" ? `${base}${quote}`.toLowerCase() : `${base}-${quote}`.toUpperCase();
+}
+function fromHuobiSymbol(s, market) {
+  if (market === "spot") {
+    const upper = s.toUpperCase();
+    for (const q of QUOTES3) {
+      if (upper.endsWith(q)) return `${upper.slice(0, -q.length)}/${q}`;
+    }
+    return upper;
+  }
+  return s.toUpperCase().replace("-", "/");
+}
+
+// src/exchanges/huobi/rest.ts
+var SPOT_BASE = "https://api.huobi.pro";
+var PERP_BASE = "https://api.hbdm.com";
+async function fetchHuobiOrderbook(opts) {
+  const symbol = toHuobiSymbol(opts.symbol, opts.market);
+  const step = opts.step ?? "step0";
+  const url = opts.market === "spot" ? `${SPOT_BASE}/market/depth?symbol=${symbol}&type=${step}` : `${PERP_BASE}/linear-swap-ex/market/depth?contract_code=${symbol}&type=${step}`;
+  const res = await httpJson({
+    url,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (res.status !== "ok" || !res.tick) {
+    throw new ExchangeError(
+      "huobi",
+      res["err-msg"] ?? res["err-code"] ?? "missing tick"
+    );
+  }
+  const ts = res.tick.ts;
+  return {
+    exchange: "huobi",
+    symbol: fromHuobiSymbol(symbol, opts.market),
+    market: opts.market,
+    bids: res.tick.bids.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    asks: res.tick.asks.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    timestamp: ts,
+    sequence: res.tick.version ?? ts
+  };
+}
+
+// src/exchanges/huobi/ws.ts
+var WS_SPOT4 = "wss://api.huobi.pro/ws";
+var WS_PERP = "wss://api.hbdm.com/linear-swap-ws";
+function streamHuobiOrderbook(opts) {
+  const huobiSymbol = toHuobiSymbol(opts.symbol, opts.market);
+  const step = opts.step ?? "step0";
+  const channel = `market.${huobiSymbol}.depth.${step}`;
+  const merger = new BookMerger();
+  let ws = null;
+  const stream = new OrderbookStream(() => ws?.close());
+  const subscribePayload = JSON.stringify({
+    sub: channel,
+    id: `sub-${Date.now()}`
+  });
+  const handlePayload = (text) => {
+    let msg;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (typeof msg.ping === "number") {
+      ws?.send(JSON.stringify({ pong: msg.ping }));
+      return;
+    }
+    if (msg.status === "ok" && msg.subbed) return;
+    if (msg.ch !== channel || !msg.tick) return;
+    const ts = msg.tick.ts;
+    const sequence = msg.tick.version ?? ts;
+    const event = {
+      kind: "snapshot",
+      bids: msg.tick.bids.map(([p, s]) => ({
+        price: Number(p),
+        size: Number(s)
+      })),
+      asks: msg.tick.asks.map(([p, s]) => ({
+        price: Number(p),
+        size: Number(s)
+      })),
+      sequence,
+      timestamp: ts
+    };
+    const r = merger.apply(event);
+    if (!r.ok) return;
+    const book = {
+      exchange: "huobi",
+      symbol: fromHuobiSymbol(huobiSymbol, opts.market),
+      market: opts.market,
+      bids: r.bids,
+      asks: r.asks,
+      timestamp: r.timestamp,
+      sequence: r.sequence
+    };
+    stream.emit("update", book);
+  };
+  const onMessage = async (raw) => {
+    if (typeof raw === "string") {
+      handlePayload(raw);
+      return;
+    }
+    const inflate = await getGzipInflate();
+    handlePayload(inflate(raw));
+  };
+  ws = new WSClient({
+    url: opts.market === "spot" ? WS_SPOT4 : WS_PERP,
+    onOpen: (sock) => {
+      merger.reset();
+      sock.send(subscribePayload);
+    },
+    onMessage
+    // Huobi heartbeat is server-initiated; we reply inline above. No client ping.
+  });
+  ws.on("open", () => stream.emit("connected"));
+  ws.on("close", (r) => stream.emit("disconnected", r));
+  ws.on("reconnecting", (a, w) => stream.emit("reconnecting", a, w));
+  ws.on("error", (e) => stream.emit("error", e));
+  ws.connect().catch((e) => stream.emit("error", e));
+  return stream;
+}
+
+// src/exchanges/huobi/index.ts
+var HuobiClient = class {
+  exchange = "huobi";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, _opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchHuobiOrderbook({
+      symbol: pair,
+      market,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, _opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamHuobiOrderbook({
+      symbol: pair,
+      market,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+// src/exchanges/coinex/symbols.ts
+var QUOTES4 = ["USDT", "USDC", "USD"];
+function toCoinexSymbol(symbol) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  return `${base}${quote}`.toUpperCase();
+}
+function fromCoinexSymbol(s) {
+  const upper = s.toUpperCase();
+  for (const q of QUOTES4) {
+    if (upper.endsWith(q)) {
+      return `${upper.slice(0, -q.length)}/${q}`;
+    }
+  }
+  return upper;
+}
+
+// src/exchanges/coinex/rest.ts
+var BASE5 = "https://api.coinex.com";
+async function fetchCoinexOrderbook(opts) {
+  const market = toCoinexSymbol(opts.symbol);
+  const limit = opts.depth ?? 50;
+  const url = opts.market === "spot" ? `${BASE5}/v2/spot/depth?market=${market}&limit=${limit}&interval=0` : `${BASE5}/v2/futures/depth?market=${market}&limit=${limit}&interval=0`;
+  const res = await httpJson({
+    url,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (res.code !== 0) {
+    throw new ExchangeError("coinex", `${res.code}: ${res.message}`);
+  }
+  const d = res.data.depth;
+  return {
+    exchange: "coinex",
+    symbol: fromCoinexSymbol(market),
+    market: opts.market,
+    bids: d.bids.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    asks: d.asks.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    timestamp: d.updated_at,
+    sequence: d.updated_at
+  };
+}
+
+// src/exchanges/coinex/ws.ts
+var WS_SPOT5 = "wss://socket.coinex.com/v2/spot";
+var WS_FUTURES2 = "wss://socket.coinex.com/v2/futures";
+function streamCoinexOrderbook(opts) {
+  const market = toCoinexSymbol(opts.symbol);
+  const depth = opts.depth ?? 50;
+  const merger = new BookMerger();
+  let ws = null;
+  const stream = new OrderbookStream(() => ws?.close());
+  const subscribePayload = JSON.stringify({
+    method: "depth.subscribe",
+    params: {
+      // [market, limit, interval, diff_flag] — diff_flag=false → full snapshots
+      market_list: [[market, depth, "0", true]]
+    },
+    id: 1
+  });
+  const handlePayload = (text) => {
+    let msg;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (msg.id != null && !msg.method) return;
+    if (msg.method !== "depth.update" || !msg.data) return;
+    if (msg.data.market !== market) return;
+    const d = msg.data.depth;
+    const event = {
+      kind: "snapshot",
+      bids: d.bids.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+      asks: d.asks.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+      sequence: d.updated_at,
+      timestamp: d.updated_at
+    };
+    const r = merger.apply(event);
+    if (!r.ok) return;
+    const book = {
+      exchange: "coinex",
+      symbol: fromCoinexSymbol(market),
+      market: opts.market,
+      bids: r.bids,
+      asks: r.asks,
+      timestamp: r.timestamp,
+      sequence: r.sequence
+    };
+    stream.emit("update", book);
+  };
+  const onMessage = async (raw) => {
+    if (typeof raw === "string") {
+      handlePayload(raw);
+      return;
+    }
+    const inflate = await getGzipInflate();
+    handlePayload(inflate(raw));
+  };
+  ws = new WSClient({
+    url: opts.market === "spot" ? WS_SPOT5 : WS_FUTURES2,
+    onOpen: (sock) => {
+      merger.reset();
+      sock.send(subscribePayload);
+    },
+    onMessage
+    // Native WS ping/pong frames keep the connection alive — no app-level ping.
+  });
+  ws.on("open", () => stream.emit("connected"));
+  ws.on("close", (r) => stream.emit("disconnected", r));
+  ws.on("reconnecting", (a, w) => stream.emit("reconnecting", a, w));
+  ws.on("error", (e) => stream.emit("error", e));
+  ws.connect().catch((e) => stream.emit("error", e));
+  return stream;
+}
+
+// src/exchanges/coinex/index.ts
+var CoinexClient = class {
+  exchange = "coinex";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchCoinexOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamCoinexOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+// src/exchanges/okx/symbols.ts
+function toOkxSymbol(symbol, market) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  const upper = `${base}-${quote}`.toUpperCase();
+  return market === "perpetual" ? `${upper}-SWAP` : upper;
+}
+function fromOkxSymbol(instId, market) {
+  let s = instId.toUpperCase();
+  if (market === "perpetual" && s.endsWith("-SWAP")) {
+    s = s.slice(0, -"-SWAP".length);
+  }
+  const [base, quote] = s.split("-");
+  if (base && quote) return `${base}/${quote}`;
+  return s;
+}
+
+// src/exchanges/okx/rest.ts
+var BASE6 = "https://www.okx.com";
+async function fetchOkxOrderbook(opts) {
+  const instId = toOkxSymbol(opts.symbol, opts.market);
+  const sz = opts.depth ?? 50;
+  const url = `${BASE6}/api/v5/market/books?instId=${instId}&sz=${sz}`;
+  const res = await httpJson({
+    url,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (res.code !== "0") {
+    throw new ExchangeError("okx", `${res.code}: ${res.msg}`);
+  }
+  const d = res.data[0];
+  if (!d) throw new ExchangeError("okx", "empty orderbook response");
+  const ts = Number(d.ts);
+  return {
+    exchange: "okx",
+    symbol: fromOkxSymbol(instId, opts.market),
+    market: opts.market,
+    bids: d.bids.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    asks: d.asks.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    timestamp: ts,
+    sequence: ts
+  };
+}
+
+// src/exchanges/okx/ws.ts
+var WS_PUBLIC2 = "wss://ws.okx.com:8443/ws/v5/public";
+function streamOkxOrderbook(opts) {
+  const instId = toOkxSymbol(opts.symbol, opts.market);
+  const channel = "books";
+  const merger = new BookMerger();
+  let recovering = false;
+  let ws = null;
+  const stream = new OrderbookStream(() => ws?.close());
+  const subscribePayload = JSON.stringify({
+    op: "subscribe",
+    args: [{ channel, instId }]
+  });
+  const emit = (r) => {
+    const book = {
+      exchange: "okx",
+      symbol: fromOkxSymbol(instId, opts.market),
+      market: opts.market,
+      bids: r.bids,
+      asks: r.asks,
+      timestamp: r.timestamp,
+      sequence: r.sequence
+    };
+    stream.emit("update", book);
+  };
+  const triggerResnapshot = () => {
+    if (recovering) return;
+    recovering = true;
+    merger.reset();
+    fetchOkxOrderbook({
+      symbol: opts.symbol,
+      market: opts.market,
+      depth: opts.depth ?? 50,
+      timeoutMs: opts.timeoutMs,
+      transformUrl: opts.transformUrl
+    }).then((snap) => {
+      const r = merger.apply({
+        kind: "snapshot",
+        bids: snap.bids,
+        asks: snap.asks,
+        sequence: snap.sequence,
+        timestamp: snap.timestamp
+      });
+      if (r.ok) emit(r);
+    }).catch((err) => stream.emit("error", err)).finally(() => {
+      recovering = false;
+    });
+  };
+  const buildEvent2 = (d, isSnapshot) => {
+    const bids = d.bids.map(([p, s]) => ({
+      price: Number(p),
+      size: Number(s)
+    }));
+    const asks = d.asks.map(([p, s]) => ({
+      price: Number(p),
+      size: Number(s)
+    }));
+    const timestamp = Number(d.ts);
+    if (isSnapshot) {
+      return { kind: "snapshot", bids, asks, sequence: d.seqId, timestamp };
+    }
+    return {
+      kind: "delta",
+      bids,
+      asks,
+      sequence: d.seqId,
+      prevSequence: d.prevSeqId,
+      timestamp
+    };
+  };
+  const onMessage = (raw) => {
+    if (typeof raw !== "string") return;
+    if (raw === "pong") return;
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.event === "subscribe") return;
+    if (msg.event === "error") {
+      stream.emit("error", new Error(`okx: ${msg.msg ?? msg.code}`));
+      return;
+    }
+    if (msg.arg?.channel !== channel || msg.arg?.instId !== instId || !msg.data?.length) {
+      return;
+    }
+    const isSnapshot = msg.action === "snapshot";
+    for (const d of msg.data) {
+      const r = merger.apply(buildEvent2(d, isSnapshot));
+      if (r.ok) {
+        emit(r);
+      } else if (r.reason === "gap" || r.reason === "no-snapshot") {
+        triggerResnapshot();
+        return;
+      }
+    }
+  };
+  ws = new WSClient({
+    url: WS_PUBLIC2,
+    onOpen: (sock) => {
+      merger.reset();
+      sock.send(subscribePayload);
+    },
+    onMessage,
+    pingIntervalMs: 25e3,
+    pingPayload: () => "ping"
+  });
+  ws.on("open", () => stream.emit("connected"));
+  ws.on("close", (r) => stream.emit("disconnected", r));
+  ws.on("reconnecting", (a, w) => stream.emit("reconnecting", a, w));
+  ws.on("error", (e) => stream.emit("error", e));
+  ws.connect().catch((e) => stream.emit("error", e));
+  return stream;
+}
+
+// src/exchanges/okx/index.ts
+var OkxClient = class {
+  exchange = "okx";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchOkxOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamOkxOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+exports.Backoff = Backoff;
+exports.BingxClient = BingxClient;
+exports.BitgetClient = BitgetClient;
+exports.BookMerger = BookMerger;
+exports.BybitClient = BybitClient;
+exports.CoinexClient = CoinexClient;
+exports.ExchangeError = ExchangeError;
+exports.GateClient = GateClient;
+exports.HuobiClient = HuobiClient;
+exports.OkxClient = OkxClient;
+exports.OrderbookStream = OrderbookStream;
+exports.RateLimitError = RateLimitError;
+exports.SequenceGapError = SequenceGapError;
+exports.parseSymbol = parseSymbol;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map