@xapy/orderbook 0.1.4 → 0.1.6

package/dist/index.cjs

@@ -358,7 +358,8 @@ var WSClient = class extends TypedEmitter {
   async connect() {
     if (this.closed) return;
     const WS = await getWebSocketCtor();
-    const ws = new WS(this.cfg.url);
+    const url = typeof this.cfg.url === "function" ? await this.cfg.url() : this.cfg.url;
+    const ws = new WS(url);
     ws.binaryType = "arraybuffer";
     this.ws = ws;
     ws.onopen = async () => {
@@ -1625,44 +1626,101 @@ function streamCoinexOrderbook(opts) {
   const merger = new BookMerger();
   let ws = null;
   const stream = new OrderbookStream(() => ws?.close());
-  const subscribePayload = JSON.stringify({
+  const subscribeDepth = JSON.stringify({
     method: "depth.subscribe",
     params: {
-      // [market, limit, interval, diff_flag] — diff_flag=false → full snapshots
+      // [market, limit, interval, diff_flag] — diff_flag=true → snapshots only
+      // (CoinEx flips the sense of the flag in V2; our handler treats every
+      // frame as a snapshot to stay correct under either reading).
       market_list: [[market, depth, "0", true]]
     },
     id: 1
   });
-  const handlePayload = (text) => {
-    let msg;
-    try {
-      msg = JSON.parse(text);
-    } catch {
-      return;
+  const subscribeBbo = JSON.stringify({
+    method: "bbo.subscribe",
+    params: { market_list: [market] },
+    id: 2
+  });
+  let lastMerged = null;
+  let lastTicker = null;
+  const emitOverlayed = () => {
+    if (!lastMerged) return;
+    let bids = lastMerged.bids;
+    let asks = lastMerged.asks;
+    let timestamp = lastMerged.timestamp;
+    let sequence = lastMerged.sequence;
+    if (lastTicker) {
+      bids = overlayBid2(bids, lastTicker.bid);
+      asks = overlayAsk2(asks, lastTicker.ask);
+      if (lastTicker.ts > timestamp) {
+        timestamp = lastTicker.ts;
+        sequence = Math.max(sequence, lastTicker.ts);
+      }
     }
-    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,
+      asks,
+      timestamp,
+      sequence
+    };
+    stream.emit("update", book);
+  };
+  const handleDepth = (d) => {
+    if (d.market !== market) return;
+    const inner = d.depth;
+    const r = merger.apply({
+      kind: "snapshot",
+      bids: inner.bids.map(([p, s]) => ({
+        price: Number(p),
+        size: Number(s)
+      })),
+      asks: inner.asks.map(([p, s]) => ({
+        price: Number(p),
+        size: Number(s)
+      })),
+      sequence: inner.updated_at,
+      timestamp: inner.updated_at
+    });
+    if (!r.ok) return;
+    lastMerged = {
       bids: r.bids,
       asks: r.asks,
       timestamp: r.timestamp,
       sequence: r.sequence
     };
-    stream.emit("update", book);
+    emitOverlayed();
+  };
+  const handleBbo = (b) => {
+    if (b.market !== market) return;
+    const bidPrice = Number(b.best_bid_price);
+    const askPrice = Number(b.best_ask_price);
+    const bidSize = Number(b.best_bid_size);
+    const askSize = Number(b.best_ask_size);
+    if (!Number.isFinite(bidPrice) || !Number.isFinite(askPrice)) return;
+    lastTicker = {
+      bid: { price: bidPrice, size: bidSize },
+      ask: { price: askPrice, size: askSize },
+      ts: b.updated_at
+    };
+    emitOverlayed();
+  };
+  const handlePayload = (text) => {
+    let msg;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (msg.id != null && !msg.method) return;
+    if (!msg.data || !msg.method) return;
+    if (msg.method === "depth.update") {
+      handleDepth(msg.data);
+    } else if (msg.method === "bbo.update") {
+      handleBbo(msg.data);
+    }
   };
   const onMessage = async (raw) => {
     if (typeof raw === "string") {
@@ -1676,7 +1734,10 @@ function streamCoinexOrderbook(opts) {
     url: opts.market === "spot" ? WS_SPOT5 : WS_FUTURES2,
     onOpen: (sock) => {
       merger.reset();
-      sock.send(subscribePayload);
+      lastMerged = null;
+      lastTicker = null;
+      sock.send(subscribeDepth);
+      sock.send(subscribeBbo);
     },
     onMessage
     // Native WS ping/pong frames keep the connection alive — no app-level ping.
@@ -1688,6 +1749,32 @@ function streamCoinexOrderbook(opts) {
   ws.connect().catch((e) => stream.emit("error", e));
   return stream;
 }
+function overlayAsk2(asks, top) {
+  if (!(top.size > 0)) return asks;
+  let i = 0;
+  for (; i < asks.length; i++) {
+    const level = asks[i];
+    if (!level || level.price >= top.price) break;
+  }
+  const at = asks[i];
+  if (at && at.price === top.price) {
+    return [{ price: top.price, size: top.size }, ...asks.slice(i + 1)];
+  }
+  return [{ price: top.price, size: top.size }, ...asks.slice(i)];
+}
+function overlayBid2(bids, top) {
+  if (!(top.size > 0)) return bids;
+  let i = 0;
+  for (; i < bids.length; i++) {
+    const level = bids[i];
+    if (!level || level.price <= top.price) break;
+  }
+  const at = bids[i];
+  if (at && at.price === top.price) {
+    return [{ price: top.price, size: top.size }, ...bids.slice(i + 1)];
+  }
+  return [{ price: top.price, size: top.size }, ...bids.slice(i)];
+}
 
 // src/exchanges/coinex/index.ts
 var CoinexClient = class {
@@ -1914,7 +2001,630 @@ var OkxClient = class {
   }
 };
 
+// src/exchanges/binance/symbols.ts
+var QUOTES5 = [
+  "USDT",
+  "USDC",
+  "FDUSD",
+  "BUSD",
+  "TUSD",
+  "USD",
+  "BTC",
+  "ETH",
+  "BNB"
+];
+function toBinanceSymbol(symbol) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  return `${base}${quote}`.toUpperCase();
+}
+function fromBinanceSymbol(s) {
+  const upper = s.toUpperCase();
+  for (const q of QUOTES5) {
+    if (upper.endsWith(q) && upper.length > q.length) {
+      return `${upper.slice(0, -q.length)}/${q}`;
+    }
+  }
+  return upper;
+}
+
+// src/exchanges/binance/rest.ts
+var BASE_SPOT = "https://api.binance.com";
+var BASE_FAPI = "https://fapi.binance.com";
+async function fetchBinanceOrderbook(opts) {
+  const symbol = toBinanceSymbol(opts.symbol);
+  const limit = opts.depth ?? 1e3;
+  const url = opts.market === "spot" ? `${BASE_SPOT}/api/v3/depth?symbol=${symbol}&limit=${limit}` : `${BASE_FAPI}/fapi/v1/depth?symbol=${symbol}&limit=${limit}`;
+  const data = await httpJson({
+    url,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  return {
+    exchange: "binance",
+    symbol: fromBinanceSymbol(symbol),
+    market: opts.market,
+    bids: data.bids.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    asks: data.asks.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
+    timestamp: data.E ?? data.T ?? Date.now(),
+    sequence: data.lastUpdateId
+  };
+}
+
+// src/exchanges/binance/ws.ts
+var WS_SPOT6 = "wss://stream.binance.com:9443/ws";
+var WS_FUTURES3 = "wss://fstream.binance.com/ws";
+function streamBinanceOrderbook(opts) {
+  const symbol = toBinanceSymbol(opts.symbol);
+  const isSpot = opts.market === "spot";
+  const interval = opts.interval ?? "100ms";
+  const wsBase = isSpot ? WS_SPOT6 : WS_FUTURES3;
+  const wsUrl = `${wsBase}/${symbol.toLowerCase()}@depth@${interval}`;
+  const merger = new BookMerger();
+  let snapshotId = -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 emit = (r) => {
+    const book = {
+      exchange: "binance",
+      symbol: fromBinanceSymbol(symbol),
+      market: opts.market,
+      bids: r.bids,
+      asks: r.asks,
+      timestamp: r.timestamp,
+      sequence: r.sequence
+    };
+    stream.emit("update", book);
+  };
+  const triggerSnapshot = () => {
+    if (snapshotInFlight) return;
+    snapshotInFlight = true;
+    fetchBinanceOrderbook({
+      symbol: opts.symbol,
+      market: opts.market,
+      depth: opts.depth ?? 1e3,
+      timeoutMs: opts.timeoutMs,
+      transformUrl: opts.transformUrl
+    }).then((snap) => {
+      snapshotId = snap.sequence;
+      const r = merger.apply({
+        kind: "snapshot",
+        bids: snap.bids,
+        asks: snap.asks,
+        sequence: snap.sequence,
+        timestamp: snap.timestamp
+      });
+      if (r.ok) emit(r);
+      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();
+    snapshotId = -1;
+    snapshotDone = false;
+    lastU = -1;
+    buffered = [];
+    setTimeout(() => {
+      recovering = false;
+      triggerSnapshot();
+    }, 100);
+  };
+  const processDelta = (ev) => {
+    if (ev.u < snapshotId + 1) return;
+    const bids = ev.b.map(([p, s]) => ({
+      price: Number(p),
+      size: Number(s)
+    }));
+    const asks = ev.a.map(([p, s]) => ({
+      price: Number(p),
+      size: Number(s)
+    }));
+    let prevSequence;
+    if (lastU < 0) {
+      const overlap = isSpot ? ev.U <= snapshotId + 1 : ev.U <= snapshotId;
+      if (!overlap) {
+        resync();
+        return;
+      }
+      prevSequence = snapshotId;
+    } else if (isSpot) {
+      prevSequence = ev.U - 1;
+    } else {
+      if (ev.pu === void 0) {
+        resync();
+        return;
+      }
+      prevSequence = ev.pu;
+    }
+    const r = merger.apply({
+      kind: "delta",
+      bids,
+      asks,
+      sequence: ev.u,
+      prevSequence,
+      timestamp: ev.E
+    });
+    if (r.ok) {
+      lastU = ev.u;
+      emit(r);
+    } else if (r.reason === "gap" || r.reason === "no-snapshot") {
+      resync();
+    }
+  };
+  const onMessage = (raw) => {
+    if (typeof raw !== "string") return;
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.e !== "depthUpdate") return;
+    if (!snapshotDone) {
+      buffered.push(msg);
+      if (!snapshotInFlight) triggerSnapshot();
+      return;
+    }
+    processDelta(msg);
+  };
+  ws = new WSClient({
+    url: wsUrl,
+    onOpen: () => {
+      merger.reset();
+      snapshotId = -1;
+      snapshotDone = false;
+      lastU = -1;
+      buffered = [];
+    },
+    onMessage
+    // Binance server-initiated WS-level ping; auto-handled by the WS impl.
+  });
+  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/binance/index.ts
+var BinanceClient = class {
+  exchange = "binance";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchBinanceOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamBinanceOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+// src/exchanges/hyperliquid/symbols.ts
+function toHyperliquidSymbol(symbol) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  if (quote.toUpperCase() !== "USDC") {
+    throw new Error(
+      `hyperliquid only supports USDC-quoted pairs; got "${quote}"`
+    );
+  }
+  return base.toUpperCase();
+}
+function fromHyperliquidSymbol(coin) {
+  return `${coin.toUpperCase()}/USDC`;
+}
+
+// src/exchanges/hyperliquid/rest.ts
+var BASE7 = "https://api.hyperliquid.xyz";
+async function fetchHyperliquidOrderbook(opts) {
+  if (opts.market !== "perpetual") {
+    throw new Error(
+      "hyperliquid: only perpetual markets are supported (spot uses @N-indexed coins)"
+    );
+  }
+  const coin = toHyperliquidSymbol(opts.symbol);
+  const data = await httpJson({
+    url: `${BASE7}/info`,
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ type: "l2Book", coin }),
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  return {
+    exchange: "hyperliquid",
+    symbol: fromHyperliquidSymbol(data.coin),
+    market: "perpetual",
+    bids: data.levels[0].map((l) => ({
+      price: Number(l.px),
+      size: Number(l.sz)
+    })),
+    asks: data.levels[1].map((l) => ({
+      price: Number(l.px),
+      size: Number(l.sz)
+    })),
+    timestamp: data.time,
+    sequence: data.time
+  };
+}
+
+// src/exchanges/hyperliquid/ws.ts
+var WS_URL = "wss://api.hyperliquid.xyz/ws";
+function streamHyperliquidOrderbook(opts) {
+  if (opts.market !== "perpetual") {
+    const s = new OrderbookStream(() => void 0);
+    queueMicrotask(
+      () => s.emit(
+        "error",
+        new Error(
+          "hyperliquid: only perpetual markets are supported (spot uses @N-indexed coins)"
+        )
+      )
+    );
+    return s;
+  }
+  const coin = toHyperliquidSymbol(opts.symbol);
+  const merger = new BookMerger();
+  let ws = null;
+  const stream = new OrderbookStream(() => ws?.close());
+  const subscribePayload = JSON.stringify({
+    method: "subscribe",
+    subscription: { type: "l2Book", coin }
+  });
+  const onMessage = (raw) => {
+    if (typeof raw !== "string") return;
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.channel === "pong" || msg.channel === "subscriptionResponse") {
+      return;
+    }
+    if (msg.channel !== "l2Book" || !msg.data) return;
+    const book = msg.data;
+    if (book.coin !== coin) return;
+    const event = {
+      kind: "snapshot",
+      bids: book.levels[0].map((l) => ({
+        price: Number(l.px),
+        size: Number(l.sz)
+      })),
+      asks: book.levels[1].map((l) => ({
+        price: Number(l.px),
+        size: Number(l.sz)
+      })),
+      sequence: book.time,
+      timestamp: book.time
+    };
+    const r = merger.apply(event);
+    if (!r.ok) return;
+    const out = {
+      exchange: "hyperliquid",
+      symbol: fromHyperliquidSymbol(coin),
+      market: "perpetual",
+      bids: r.bids,
+      asks: r.asks,
+      timestamp: r.timestamp,
+      sequence: r.sequence
+    };
+    stream.emit("update", out);
+  };
+  ws = new WSClient({
+    url: WS_URL,
+    onOpen: (sock) => {
+      merger.reset();
+      sock.send(subscribePayload);
+    },
+    onMessage,
+    pingIntervalMs: 5e4,
+    pingPayload: () => JSON.stringify({ method: "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/hyperliquid/index.ts
+var HyperliquidClient = class {
+  exchange = "hyperliquid";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchHyperliquidOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamHyperliquidOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+// src/exchanges/kucoin/symbols.ts
+var FUTURES_QUOTES = ["USDT", "USDC", "USD"];
+function toKucoinSpotSymbol(symbol) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  return `${base.toUpperCase()}-${quote.toUpperCase()}`;
+}
+function fromKucoinSpotSymbol(s) {
+  return s.toUpperCase().replace("-", "/");
+}
+function toKucoinFuturesSymbol(symbol) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  const b = base.toUpperCase() === "BTC" ? "XBT" : base.toUpperCase();
+  return `${b}${quote.toUpperCase()}M`;
+}
+function fromKucoinFuturesSymbol(s) {
+  const upper = s.toUpperCase();
+  const stripped = upper.endsWith("M") ? upper.slice(0, -1) : upper;
+  for (const q of FUTURES_QUOTES) {
+    if (stripped.endsWith(q) && stripped.length > q.length) {
+      let base = stripped.slice(0, -q.length);
+      if (base === "XBT") base = "BTC";
+      return `${base}/${q}`;
+    }
+  }
+  return upper;
+}
+
+// src/exchanges/kucoin/rest.ts
+var BASE_SPOT2 = "https://api.kucoin.com";
+var BASE_FUTURES = "https://api-futures.kucoin.com";
+async function fetchKucoinBullet(opts) {
+  const base = opts.market === "spot" ? BASE_SPOT2 : BASE_FUTURES;
+  const res = await httpJson({
+    url: `${base}/api/v1/bullet-public`,
+    method: "POST",
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (res.code !== "200000") {
+    throw new ExchangeError("kucoin", `bullet failed: ${res.code}`);
+  }
+  const server = res.data.instanceServers[0];
+  if (!server) {
+    throw new ExchangeError("kucoin", "bullet returned no instance servers");
+  }
+  return {
+    endpoint: server.endpoint,
+    token: res.data.token,
+    pingInterval: server.pingInterval,
+    pingTimeout: server.pingTimeout
+  };
+}
+async function fetchKucoinOrderbook(opts) {
+  const tier = (opts.depth ?? 100) <= 20 ? 20 : 100;
+  if (opts.market === "spot") {
+    const symbol2 = toKucoinSpotSymbol(opts.symbol);
+    const url2 = `${BASE_SPOT2}/api/v1/market/orderbook/level2_${tier}?symbol=${symbol2}`;
+    const res2 = await httpJson({
+      url: url2,
+      timeoutMs: opts.timeoutMs,
+      transformUrl: opts.transformUrl
+    });
+    if (res2.code !== "200000") {
+      throw new ExchangeError("kucoin", `orderbook failed: ${res2.code}`);
+    }
+    return {
+      exchange: "kucoin",
+      symbol: fromKucoinSpotSymbol(symbol2),
+      market: "spot",
+      bids: parseLevels(res2.data.bids),
+      asks: parseLevels(res2.data.asks),
+      timestamp: res2.data.time,
+      sequence: Number(res2.data.sequence)
+    };
+  }
+  const symbol = toKucoinFuturesSymbol(opts.symbol);
+  const url = `${BASE_FUTURES}/api/v1/level2/depth${tier}?symbol=${symbol}`;
+  const res = await httpJson({
+    url,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (res.code !== "200000") {
+    throw new ExchangeError("kucoin", `orderbook failed: ${res.code}`);
+  }
+  return {
+    exchange: "kucoin",
+    symbol: fromKucoinFuturesSymbol(symbol),
+    market: "perpetual",
+    bids: parseLevels(res.data.bids),
+    asks: parseLevels(res.data.asks),
+    timestamp: res.data.ts,
+    sequence: res.data.sequence
+  };
+}
+function parseLevels(rows) {
+  return rows.map(([p, s]) => ({ price: Number(p), size: Number(s) }));
+}
+
+// src/exchanges/kucoin/ws.ts
+function streamKucoinOrderbook(opts) {
+  const isSpot = opts.market === "spot";
+  const symbol = isSpot ? toKucoinSpotSymbol(opts.symbol) : toKucoinFuturesSymbol(opts.symbol);
+  const level = (opts.depth ?? 50) <= 5 ? 5 : 50;
+  const topic = isSpot ? `/spotMarket/level2Depth${level}:${symbol}` : `/contractMarket/level2Depth${level}:${symbol}`;
+  const merger = new BookMerger();
+  let ws = null;
+  const stream = new OrderbookStream(() => ws?.close());
+  const urlProvider = async () => {
+    const bullet = await fetchKucoinBullet({
+      market: opts.market,
+      timeoutMs: opts.timeoutMs,
+      transformUrl: opts.transformUrl
+    });
+    const connectId = `xapy-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
+    return `${bullet.endpoint}?token=${encodeURIComponent(bullet.token)}&connectId=${connectId}`;
+  };
+  const subscribePayload = () => JSON.stringify({
+    id: `sub-${Date.now()}`,
+    type: "subscribe",
+    topic,
+    privateChannel: false,
+    response: true
+  });
+  const pingPayload = () => JSON.stringify({ id: `${Date.now()}`, type: "ping" });
+  const handleDepth = (d) => {
+    const ts = d.timestamp ?? 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: "kucoin",
+      symbol: isSpot ? fromKucoinSpotSymbol(symbol) : fromKucoinFuturesSymbol(symbol),
+      market: opts.market,
+      bids: r.bids,
+      asks: r.asks,
+      timestamp: r.timestamp,
+      sequence: r.sequence
+    };
+    stream.emit("update", book);
+  };
+  const onMessage = (raw) => {
+    if (typeof raw !== "string") return;
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.type === "welcome" || msg.type === "ack" || msg.type === "pong") {
+      return;
+    }
+    if (msg.type === "error") {
+      stream.emit("error", new Error(`kucoin: ${JSON.stringify(msg)}`));
+      return;
+    }
+    if (msg.type !== "message" || msg.topic !== topic || !msg.data) return;
+    handleDepth(msg.data);
+  };
+  ws = new WSClient({
+    url: urlProvider,
+    onOpen: (sock) => {
+      merger.reset();
+      sock.send(subscribePayload());
+    },
+    onMessage,
+    // KuCoin's documented bullet `pingInterval` is 18000ms — stay under it.
+    pingIntervalMs: 15e3,
+    pingPayload
+  });
+  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/kucoin/index.ts
+var KucoinClient = class {
+  exchange = "kucoin";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchKucoinOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamKucoinOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
 exports.Backoff = Backoff;
+exports.BinanceClient = BinanceClient;
 exports.BingxClient = BingxClient;
 exports.BitgetClient = BitgetClient;
 exports.BookMerger = BookMerger;
@@ -1923,6 +2633,8 @@ exports.CoinexClient = CoinexClient;
 exports.ExchangeError = ExchangeError;
 exports.GateClient = GateClient;
 exports.HuobiClient = HuobiClient;
+exports.HyperliquidClient = HyperliquidClient;
+exports.KucoinClient = KucoinClient;
 exports.OkxClient = OkxClient;
 exports.OrderbookStream = OrderbookStream;
 exports.RateLimitError = RateLimitError;