@xapy/orderbook 0.1.22 → 0.1.23

package/dist/index.cjs

@@ -325,6 +325,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;
@@ -372,7 +387,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) => {
@@ -380,21 +395,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();
     };
@@ -434,7 +449,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);
   }
 };
@@ -1234,7 +1249,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;
@@ -1277,8 +1292,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) })),
@@ -1320,10 +1335,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);
     }
@@ -2622,98 +2649,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: parseLevels2(res.data.bids),
-    asks: parseLevels2(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 parseLevels2(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: parseLevels3(frame.bids),
-      asks: parseLevels3(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,
@@ -2721,41 +2738,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));
@@ -2764,21 +2841,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 parseLevels3(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 = {}) {
@@ -2787,7 +2853,7 @@ var BitmartClient = class {
   }
   fetchOrderbook(symbol, opts = {}) {
     const { pair, market } = parseSymbol(symbol);
-    return fetchBitmartOrderbook({
+    return fetchDeribitOrderbook({
       symbol: pair,
       market,
       depth: opts.depth,
@@ -2795,11 +2861,12 @@ 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
     });
@@ -2810,10 +2877,10 @@ exports.Backoff = Backoff;
 exports.BinanceClient = BinanceClient;
 exports.BingxClient = BingxClient;
 exports.BitgetClient = BitgetClient;
-exports.BitmartClient = BitmartClient;
 exports.BookMerger = BookMerger;
 exports.BybitClient = BybitClient;
 exports.CoinexClient = CoinexClient;
+exports.DeribitClient = DeribitClient;
 exports.ExchangeError = ExchangeError;
 exports.GateClient = GateClient;
 exports.HuobiClient = HuobiClient;