@xapy/orderbook 0.1.21 → 0.1.23

package/dist/index.js

@@ -323,6 +323,21 @@ async function fetchBybitOrderbook(opts) {
 var hasNativeWebSocket = typeof globalThis.WebSocket !== "undefined";
 
 // src/transport/ws.ts
+function toError(value, fallback = "unknown error") {
+  if (value instanceof Error) {
+    return value.message ? value : new Error(`${value.name}: ${fallback}`);
+  }
+  if (typeof value === "string" && value) return new Error(value);
+  return new Error(fallback);
+}
+function normalizeWsError(ev) {
+  const detail = ev?.message || (ev?.error instanceof Error ? ev.error.message : void 0) || (typeof ev?.error === "string" ? ev.error : void 0);
+  return new Error(detail ? `WebSocket error: ${detail}` : "WebSocket error");
+}
+function describeClose(ev) {
+  if (ev?.reason) return ev.reason;
+  return ev?.code === void 0 ? "closed" : `closed (code ${ev.code})`;
+}
 var cachedCtor = null;
 async function getWebSocketCtor() {
   if (cachedCtor) return cachedCtor;
@@ -370,7 +385,7 @@ var WSClient = class extends TypedEmitter {
           close: () => this.close()
         });
       } catch (err) {
-        this.emit("error", err);
+        this.emit("error", toError(err, "onOpen handler failed"));
       }
     };
     ws.onmessage = (e) => {
@@ -378,21 +393,21 @@ var WSClient = class extends TypedEmitter {
       try {
         result = this.cfg.onMessage(e.data);
       } catch (err) {
-        this.emit("error", err);
+        this.emit("error", toError(err, "onMessage handler failed"));
         return;
       }
       if (result && typeof result.catch === "function") {
         result.catch(
-          (err) => this.emit("error", err)
+          (err) => this.emit("error", toError(err, "onMessage handler failed"))
         );
       }
     };
     ws.onerror = (e) => {
-      this.emit("error", new Error(e?.message ?? "WebSocket error"));
+      this.emit("error", normalizeWsError(e));
     };
     ws.onclose = (e) => {
       this.stopPing();
-      const reason = e?.reason ?? "closed";
+      const reason = describeClose(e);
       this.emit("close", reason);
       if (!this.closed) this.scheduleReconnect();
     };
@@ -432,7 +447,7 @@ var WSClient = class extends TypedEmitter {
     }
     this.emit("reconnecting", next.attempt, next.wait);
     setTimeout(() => {
-      this.connect().catch((e) => this.emit("error", e));
+      this.connect().catch((e) => this.emit("error", toError(e, "reconnect failed")));
     }, next.wait);
   }
 };
@@ -1232,7 +1247,7 @@ function streamBingxOrderbook(opts) {
   const wsSymbol = opts.symbol.toUpperCase().replace("/", "-");
   const level = opts.depth ?? 20;
   const interval = opts.interval ?? "500ms";
-  const depthDataType = `${wsSymbol}@depth${level}@${interval}`;
+  const depthDataType = isSpot ? `${wsSymbol}@depth${level}` : `${wsSymbol}@depth${level}@${interval}`;
   const tickerDataType = `${wsSymbol}@bookTicker`;
   const merger = new BookMerger();
   let ws = null;
@@ -1275,8 +1290,8 @@ function streamBingxOrderbook(opts) {
     };
     stream.emit("update", book);
   };
-  const handleDepth = (d) => {
-    const ts = d.T ?? d.ts ?? Date.now();
+  const handleDepth = (d, frameTs) => {
+    const ts = d.T ?? d.ts ?? frameTs ?? Date.now();
     const event = {
       kind: "snapshot",
       bids: d.bids.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
@@ -1318,10 +1333,22 @@ function streamBingxOrderbook(opts) {
     } catch {
       return;
     }
-    if (msg.id && !msg.data) return;
+    if (msg.id && !msg.data) {
+      if (msg.code) {
+        stream.emit(
+          "error",
+          new ExchangeError(
+            "bingx",
+            `subscribe failed (${msg.id}): ${msg.code}${msg.msg ? ` ${msg.msg}` : ""}`
+          )
+        );
+      }
+      return;
+    }
     if (!msg.dataType || !msg.data) return;
+    const frameTs = msg.ts ?? msg.timestamp;
     if (msg.dataType === depthDataType) {
-      handleDepth(msg.data);
+      handleDepth(msg.data, frameTs);
     } else if (msg.dataType === tickerDataType) {
       handleTicker(msg.data);
     }
@@ -1616,61 +1643,93 @@ async function fetchCoinexOrderbook(opts) {
 }
 
 // src/exchanges/coinex/ws.ts
-var WS_SPOT5 = "wss://socket.coinex.com/";
-var WS_FUTURES2 = "wss://perpetual.coinex.com/";
+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 seq = 0;
   let ws = null;
   const stream = new OrderbookStream(() => ws?.close());
-  const subscribePayload = JSON.stringify({
+  const subscribeDepth = JSON.stringify({
     method: "depth.subscribe",
-    params: [market, depth, "0", true],
+    params: {
+      // [market, limit, interval, if_full] — `true` = every push is a full
+      // snapshot; the merger revalidates monotonic ordering by updated_at.
+      market_list: [[market, depth, "0", true]]
+    },
     id: 1
   });
-  const pingPayload = () => JSON.stringify({ method: "server.ping", params: [], id: 11 });
-  const emit = (r) => {
+  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);
+      }
+    }
     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 handleDepthPush = (push) => {
-    const [clean, payload, mkt] = push;
-    if (mkt !== market) return;
-    const bids = parseLevels(payload.bids);
-    const asks = parseLevels(payload.asks);
-    const event = clean ? {
-      kind: "snapshot",
-      bids,
-      asks,
-      sequence: ++seq,
-      timestamp: payload.time
-    } : {
-      kind: "delta",
-      bids,
-      asks,
-      sequence: ++seq,
-      timestamp: payload.time
+  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
     };
-    const r = merger.apply(event);
-    if (r.ok) {
-      emit(r);
-      return;
-    }
-    if (r.reason === "no-snapshot") return;
-    if (r.reason === "gap") {
-      merger.reset();
-      seq = 0;
-    }
+    emitOverlayed();
   };
   const handlePayload = (text) => {
     let msg;
@@ -1680,31 +1739,32 @@ function streamCoinexOrderbook(opts) {
       return;
     }
     if (msg.id != null && !msg.method) return;
-    if (msg.error) {
-      stream.emit(
-        "error",
-        new Error(`coinex: ${msg.error.code} ${msg.error.message}`)
-      );
-      return;
-    }
-    if (msg.method === "depth.update" && Array.isArray(msg.params)) {
-      handleDepthPush(msg.params);
+    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 = (raw) => {
-    if (typeof raw !== "string") return;
-    handlePayload(raw);
+  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();
-      seq = 0;
-      sock.send(subscribePayload);
+      lastMerged = null;
+      lastTicker = null;
+      sock.send(subscribeDepth);
+      sock.send(subscribeBbo);
     },
-    onMessage,
-    pingIntervalMs: 25e3,
-    pingPayload
+    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));
@@ -1713,11 +1773,31 @@ function streamCoinexOrderbook(opts) {
   ws.connect().catch((e) => stream.emit("error", e));
   return stream;
 }
-function parseLevels(rows) {
-  if (!rows) return [];
-  const out = [];
-  for (const [p, s] of rows) out.push({ price: Number(p), size: Number(s) });
-  return out;
+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
@@ -2415,8 +2495,8 @@ async function fetchKucoinOrderbook(opts) {
       exchange: "kucoin",
       symbol: fromKucoinSpotSymbol(symbol2),
       market: "spot",
-      bids: parseLevels2(res2.data.bids),
-      asks: parseLevels2(res2.data.asks),
+      bids: parseLevels(res2.data.bids),
+      asks: parseLevels(res2.data.asks),
       timestamp: res2.data.time,
       sequence: Number(res2.data.sequence)
     };
@@ -2435,13 +2515,13 @@ async function fetchKucoinOrderbook(opts) {
     exchange: "kucoin",
     symbol: fromKucoinFuturesSymbol(symbol),
     market: "perpetual",
-    bids: parseLevels2(res.data.bids),
-    asks: parseLevels2(res.data.asks),
+    bids: parseLevels(res.data.bids),
+    asks: parseLevels(res.data.asks),
     timestamp: res.data.ts,
     sequence: res.data.sequence
   };
 }
-function parseLevels2(rows) {
+function parseLevels(rows) {
   return rows.map(([p, s]) => ({ price: Number(p), size: Number(s) }));
 }
 
@@ -2567,98 +2647,88 @@ var KucoinClient = class {
   }
 };
 
-// src/exchanges/bitmart/symbols.ts
-var QUOTES6 = ["USDT", "USDC", "USD"];
-function toBitmartSymbol(symbol) {
+// src/exchanges/deribit/symbols.ts
+function toDeribitSymbol(symbol, market) {
   const [base, quote] = symbol.split("/");
   if (!base || !quote) {
     throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
   }
-  return `${base}${quote}`.toUpperCase();
-}
-function fromBitmartSymbol(s) {
-  const upper = s.toUpperCase();
-  for (const q of QUOTES6) {
-    if (upper.endsWith(q) && upper.length > q.length) {
-      return `${upper.slice(0, -q.length)}/${q}`;
-    }
+  const pair = `${base}_${quote}`.toUpperCase();
+  if (market !== "perpetual") return pair;
+  if (quote.toUpperCase() !== "USDC") {
+    throw new Error(
+      `deribit linear perpetuals are USDC-margined; got "${quote}" (inverse contracts like BTC-PERPETUAL are unsupported)`
+    );
   }
-  return upper;
+  return `${pair}-PERPETUAL`;
+}
+function fromDeribitSymbol(instrument) {
+  let s = instrument.toUpperCase();
+  if (s.endsWith("-PERPETUAL")) s = s.slice(0, -"-PERPETUAL".length);
+  const [base, quote] = s.split("_");
+  return base && quote ? `${base}/${quote}` : s;
 }
 
-// src/exchanges/bitmart/rest.ts
-var BASE8 = "https://api-cloud-v2.bitmart.com";
-async function fetchBitmartOrderbook(opts) {
-  if (opts.market !== "perpetual") {
-    throw new ExchangeError(
-      "bitmart",
-      "spot is not supported \u2014 only USDT-M perpetual"
-    );
-  }
-  const symbol = toBitmartSymbol(opts.symbol);
-  const url = `${BASE8}/contract/public/depth?symbol=${symbol}`;
+// src/exchanges/deribit/rest.ts
+var BASE8 = "https://www.deribit.com";
+var ALLOWED_DEPTHS = [1, 5, 10, 20, 50, 100, 1e3, 1e4];
+function clampDepth(depth) {
+  return ALLOWED_DEPTHS.find((d) => d >= depth) ?? ALLOWED_DEPTHS[ALLOWED_DEPTHS.length - 1];
+}
+async function fetchDeribitOrderbook(opts) {
+  const instrument = toDeribitSymbol(opts.symbol, opts.market);
+  const depth = clampDepth(opts.depth ?? 50);
+  const url = `${BASE8}/api/v2/public/get_order_book?instrument_name=${instrument}&depth=${depth}`;
   const res = await httpJson({
     url,
     timeoutMs: opts.timeoutMs,
     transformUrl: opts.transformUrl
   });
-  if (res.code !== 1e3) {
-    throw new ExchangeError("bitmart", `${res.code}: ${res.message ?? ""}`);
+  if (res.error) {
+    throw new ExchangeError(
+      "deribit",
+      `${res.error.code}: ${res.error.message}`
+    );
   }
+  const r = res.result;
+  if (!r) throw new ExchangeError("deribit", "empty orderbook response");
   return {
-    exchange: "bitmart",
-    symbol: fromBitmartSymbol(res.data.symbol),
-    market: "perpetual",
-    bids: parseLevels3(res.data.bids),
-    asks: parseLevels3(res.data.asks),
-    timestamp: res.data.timestamp,
-    sequence: res.data.timestamp
+    exchange: "deribit",
+    symbol: fromDeribitSymbol(r.instrument_name ?? instrument),
+    market: opts.market,
+    bids: r.bids.map(([price, size]) => ({ price, size })),
+    asks: r.asks.map(([price, size]) => ({ price, size })),
+    timestamp: r.timestamp,
+    sequence: r.change_id
   };
 }
-function parseLevels3(rows) {
-  const out = [];
-  for (const row of rows) {
-    out.push({ price: Number(row[0]), size: Number(row[1]) });
-  }
-  return out;
-}
 
-// src/exchanges/bitmart/ws.ts
-var WS_FUTURES4 = "wss://openapi-ws-v2.bitmart.com/api?protocol=1.1";
-function streamBitmartOrderbook(opts) {
-  if (opts.market !== "perpetual") {
-    throw new ExchangeError(
-      "bitmart",
-      "spot is not supported \u2014 only USDT-M perpetual"
-    );
-  }
-  const symbol = toBitmartSymbol(opts.symbol);
-  const level = snapLevel(opts.depth);
-  const interval = opts.interval ?? "200ms";
-  const channelArg = `futures/depthAll${level}:${symbol}@${interval}`;
+// src/exchanges/deribit/ws.ts
+var WS_PUBLIC3 = "wss://www.deribit.com/ws/api/v2";
+var HEARTBEAT_SECONDS = 30;
+function streamDeribitOrderbook(opts) {
+  const instrument = toDeribitSymbol(opts.symbol, opts.market);
+  const channel = `book.${instrument}.${opts.interval ?? "100ms"}`;
   const merger = new BookMerger();
   let ws = null;
+  let sock = null;
+  let recovering = false;
   const stream = new OrderbookStream(() => ws?.close());
-  const subscribePayload = JSON.stringify({
-    action: "subscribe",
-    args: [channelArg]
-  });
-  const pingPayload = () => JSON.stringify({ action: "ping" });
-  const handleFrame = (frame) => {
-    if (frame.symbol !== symbol) return;
-    const event = {
-      kind: "snapshot",
-      bids: parseLevels4(frame.bids),
-      asks: parseLevels4(frame.asks),
-      sequence: frame.ms_t,
-      timestamp: frame.ms_t
-    };
-    const r = merger.apply(event);
-    if (!r.ok) return;
+  let nextId = 1;
+  const subscribeIds = /* @__PURE__ */ new Set();
+  const rpc = (method, params) => {
+    const id = nextId++;
+    sock?.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+    return id;
+  };
+  const subscribe = () => {
+    subscribeIds.add(rpc("public/subscribe", { channels: [channel] }));
+  };
+  const emit = (r) => {
     const book = {
-      exchange: "bitmart",
-      symbol: fromBitmartSymbol(symbol),
-      market: "perpetual",
+      exchange: "deribit",
+      symbol: fromDeribitSymbol(instrument),
+      market: opts.market,
       bids: r.bids,
       asks: r.asks,
       timestamp: r.timestamp,
@@ -2666,41 +2736,101 @@ function streamBitmartOrderbook(opts) {
     };
     stream.emit("update", book);
   };
-  const handlePayload = (text) => {
+  const resync = () => {
+    if (recovering) return;
+    recovering = true;
+    merger.reset();
+    rpc("public/unsubscribe", { channels: [channel] });
+    subscribe();
+  };
+  const toLevels = (entries) => entries.map(([action, price, amount]) => ({
+    price,
+    size: action === "delete" ? 0 : amount
+  }));
+  const buildEvent2 = (d) => {
+    const bids = toLevels(d.bids);
+    const asks = toLevels(d.asks);
+    if (d.type === "snapshot") {
+      return {
+        kind: "snapshot",
+        bids,
+        asks,
+        sequence: d.change_id,
+        timestamp: d.timestamp
+      };
+    }
+    return {
+      kind: "delta",
+      bids,
+      asks,
+      sequence: d.change_id,
+      prevSequence: d.prev_change_id,
+      timestamp: d.timestamp
+    };
+  };
+  const handleData = (d) => {
+    if (d.type === "snapshot") recovering = false;
+    else if (recovering) return;
+    const r = merger.apply(buildEvent2(d));
+    if (r.ok) {
+      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(text);
+      msg = JSON.parse(raw);
     } catch {
       return;
     }
-    if (msg.action === "subscribe" || msg.action === "pong") return;
-    if (msg.errorCode) {
-      stream.emit(
-        "error",
-        new Error(`bitmart: ${msg.errorCode} ${msg.errorMessage ?? ""}`)
-      );
+    if (msg.method === "heartbeat") {
+      if (msg.params?.type === "test_request") rpc("public/test", {});
       return;
     }
-    if (msg.group !== channelArg || !msg.data) return;
-    handleFrame(msg.data);
-  };
-  const onMessage = async (raw) => {
-    if (typeof raw === "string") {
-      handlePayload(raw);
+    if (msg.method === "subscription") {
+      if (msg.params?.channel !== channel || !msg.params.data) return;
+      handleData(msg.params.data);
       return;
     }
-    const inflate = await getGzipInflate();
-    handlePayload(inflate(raw));
+    if (msg.id !== void 0) {
+      if (msg.error) {
+        stream.emit(
+          "error",
+          new ExchangeError(
+            "deribit",
+            `${msg.error.code}: ${msg.error.message}`
+          )
+        );
+        return;
+      }
+      if (subscribeIds.delete(msg.id)) {
+        const channels = Array.isArray(msg.result) ? msg.result : [];
+        if (!channels.includes(channel)) {
+          stream.emit(
+            "error",
+            new ExchangeError(
+              "deribit",
+              `subscribe rejected for "${channel}" \u2014 unknown instrument or interval`
+            )
+          );
+        }
+      }
+    }
   };
   ws = new WSClient({
-    url: WS_FUTURES4,
-    onOpen: (sock) => {
+    url: WS_PUBLIC3,
+    onOpen: (handle) => {
+      sock = handle;
       merger.reset();
-      sock.send(subscribePayload);
+      recovering = false;
+      subscribeIds.clear();
+      rpc("public/set_heartbeat", { interval: HEARTBEAT_SECONDS });
+      subscribe();
     },
-    onMessage,
-    pingIntervalMs: 15e3,
-    pingPayload
+    onMessage
   });
   ws.on("open", () => stream.emit("connected"));
   ws.on("close", (r) => stream.emit("disconnected", r));
@@ -2709,21 +2839,10 @@ function streamBitmartOrderbook(opts) {
   ws.connect().catch((e) => stream.emit("error", e));
   return stream;
 }
-function snapLevel(depth) {
-  if (depth === 5) return 5;
-  if (depth === 20) return 20;
-  return 50;
-}
-function parseLevels4(rows) {
-  if (!rows) return [];
-  const out = [];
-  for (const r of rows) out.push({ price: Number(r.price), size: Number(r.vol) });
-  return out;
-}
 
-// src/exchanges/bitmart/index.ts
-var BitmartClient = class {
-  exchange = "bitmart";
+// src/exchanges/deribit/index.ts
+var DeribitClient = class {
+  exchange = "deribit";
   transformUrl;
   timeoutMs;
   constructor(opts = {}) {
@@ -2732,7 +2851,7 @@ var BitmartClient = class {
   }
   fetchOrderbook(symbol, opts = {}) {
     const { pair, market } = parseSymbol(symbol);
-    return fetchBitmartOrderbook({
+    return fetchDeribitOrderbook({
       symbol: pair,
       market,
       depth: opts.depth,
@@ -2740,17 +2859,18 @@ var BitmartClient = class {
       transformUrl: this.transformUrl
     });
   }
-  streamOrderbook(symbol, _opts = {}) {
+  streamOrderbook(symbol, opts = {}) {
     const { pair, market } = parseSymbol(symbol);
-    return streamBitmartOrderbook({
+    return streamDeribitOrderbook({
       symbol: pair,
       market,
+      depth: opts.depth,
       transformUrl: this.transformUrl,
       timeoutMs: this.timeoutMs
     });
   }
 };
 
-export { Backoff, BinanceClient, BingxClient, BitgetClient, BitmartClient, BookMerger, BybitClient, CoinexClient, ExchangeError, GateClient, HuobiClient, HyperliquidClient, KucoinClient, OkxClient, OrderbookStream, RateLimitError, SequenceGapError, parseSymbol };
+export { Backoff, BinanceClient, BingxClient, BitgetClient, BookMerger, BybitClient, CoinexClient, DeribitClient, ExchangeError, GateClient, HuobiClient, HyperliquidClient, KucoinClient, OkxClient, OrderbookStream, RateLimitError, SequenceGapError, parseSymbol };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map