@xapy/orderbook 0.1.22 → 0.1.24

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,323 @@ 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]) });
+
+// 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());
+  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: "deribit",
+      symbol: fromDeribitSymbol(instrument),
+      market: opts.market,
+      bids: r.bids,
+      asks: r.asks,
+      timestamp: r.timestamp,
+      sequence: r.sequence
+    };
+    stream.emit("update", book);
+  };
+  const resync = () => {
+    if (recovering) return;
+    recovering = true;
+    merger.reset();
+    rpc("public/unsubscribe", { channels: [channel] });
+    subscribe();
+  };
+  const toLevels2 = (entries) => entries.map(([action, price, amount]) => ({
+    price,
+    size: action === "delete" ? 0 : amount
+  }));
+  const buildEvent2 = (d) => {
+    const bids = toLevels2(d.bids);
+    const asks = toLevels2(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(raw);
+    } catch {
+      return;
+    }
+    if (msg.method === "heartbeat") {
+      if (msg.params?.type === "test_request") rpc("public/test", {});
+      return;
+    }
+    if (msg.method === "subscription") {
+      if (msg.params?.channel !== channel || !msg.params.data) return;
+      handleData(msg.params.data);
+      return;
+    }
+    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_PUBLIC3,
+    onOpen: (handle) => {
+      sock = handle;
+      merger.reset();
+      recovering = false;
+      subscribeIds.clear();
+      rpc("public/set_heartbeat", { interval: HEARTBEAT_SECONDS });
+      subscribe();
+    },
+    onMessage
+  });
+  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/deribit/index.ts
+var DeribitClient = class {
+  exchange = "deribit";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
   }
-  return out;
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchDeribitOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamDeribitOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+// src/exchanges/grvt/symbols.ts
+function toGrvtSymbol(symbol, market) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  if (market !== "perpetual") {
+    throw new Error(
+      `grvt only lists perpetuals; use "${base.toUpperCase()}/${quote.toUpperCase()}:${quote.toUpperCase()}"`
+    );
+  }
+  return `${base.toUpperCase()}_${quote.toUpperCase()}_Perp`;
+}
+function fromGrvtSymbol(instrument) {
+  const parts = instrument.split("_");
+  const [base, quote] = parts;
+  return base && quote ? `${base.toUpperCase()}/${quote.toUpperCase()}` : instrument;
 }
 
-// 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") {
+// src/exchanges/grvt/rest.ts
+var BASE9 = "https://market-data.grvt.io";
+var ALLOWED_DEPTHS2 = [10, 50, 100, 500];
+function snapDepth(depth) {
+  return ALLOWED_DEPTHS2.find((d) => d >= depth) ?? ALLOWED_DEPTHS2[ALLOWED_DEPTHS2.length - 1];
+}
+function nsToMs(ns) {
+  const n = Number(ns);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n / 1e6) : Date.now();
+}
+var toLevels = (rows) => (rows ?? []).map((l) => ({ price: Number(l.price), size: Number(l.size) }));
+async function fetchGrvtOrderbook(opts) {
+  const instrument = toGrvtSymbol(opts.symbol, opts.market);
+  const depth = snapDepth(opts.depth ?? 50);
+  const res = await httpJson({
+    url: `${BASE9}/full/v1/book`,
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ instrument, depth }),
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (!res.result) {
     throw new ExchangeError(
-      "bitmart",
-      "spot is not supported \u2014 only USDT-M perpetual"
+      "grvt",
+      res.code ? `${res.code}: ${res.message}` : "empty orderbook response"
     );
   }
-  const symbol = toBitmartSymbol(opts.symbol);
-  const level = snapLevel(opts.depth);
-  const interval = opts.interval ?? "200ms";
-  const channelArg = `futures/depthAll${level}:${symbol}@${interval}`;
+  const ts = nsToMs(res.result.event_time);
+  return {
+    exchange: "grvt",
+    symbol: fromGrvtSymbol(res.result.instrument ?? instrument),
+    market: opts.market,
+    bids: toLevels(res.result.bids),
+    asks: toLevels(res.result.asks),
+    timestamp: ts,
+    sequence: ts
+  };
+}
+
+// src/exchanges/grvt/ws.ts
+var WS_FULL = "wss://market-data.grvt.io/ws/full";
+var STREAM = "v1.book.d";
+function streamGrvtOrderbook(opts) {
+  const instrument = toGrvtSymbol(opts.symbol, opts.market);
+  const selector = `${instrument}@${opts.rate ?? 500}`;
   const merger = new BookMerger();
   let ws = null;
+  let sock = null;
+  let recovering = false;
+  let awaitingFirstDelta = false;
+  let snapshotSequence = 0;
+  let ackSequence = null;
   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) => {
+    const id = nextId++;
+    sock?.send(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        method,
+        params: { stream: STREAM, selectors: [selector] },
+        id
+      })
+    );
+    return id;
+  };
+  const subscribe = () => subscribeIds.add(rpc("subscribe"));
+  const emit = (r) => {
     const book = {
-      exchange: "bitmart",
-      symbol: fromBitmartSymbol(symbol),
-      market: "perpetual",
+      exchange: "grvt",
+      symbol: fromGrvtSymbol(instrument),
+      market: opts.market,
       bids: r.bids,
       asks: r.asks,
       timestamp: r.timestamp,
@@ -2721,41 +2973,92 @@ function streamBitmartOrderbook(opts) {
     };
     stream.emit("update", book);
   };
-  const handlePayload = (text) => {
+  const resync = () => {
+    if (recovering) return;
+    recovering = true;
+    merger.reset();
+    rpc("unsubscribe");
+    subscribe();
+  };
+  const buildEvent2 = (feed, seq) => {
+    const bids = toLevels(feed.bids);
+    const asks = toLevels(feed.asks);
+    const timestamp = nsToMs(feed.event_time);
+    if (seq === 0) {
+      snapshotSequence = ackSequence ?? 0;
+      awaitingFirstDelta = true;
+      return {
+        kind: "snapshot",
+        bids,
+        asks,
+        sequence: snapshotSequence,
+        timestamp
+      };
+    }
+    const prevSequence = awaitingFirstDelta ? snapshotSequence : seq - 1;
+    awaitingFirstDelta = false;
+    return { kind: "delta", bids, asks, sequence: seq, prevSequence, timestamp };
+  };
+  const handleFeed = (msg) => {
+    if (!msg.feed) return;
+    const seq = Number(msg.sequence_number ?? 0);
+    if (!Number.isFinite(seq)) return;
+    if (seq === 0) recovering = false;
+    else if (recovering) return;
+    const r = merger.apply(buildEvent2(msg.feed, seq));
+    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) {
+    if (msg.feed) {
+      if (msg.selector && msg.selector !== selector) return;
+      handleFeed(msg);
+      return;
+    }
+    if (msg.id === void 0) return;
+    if (msg.error) {
       stream.emit(
         "error",
-        new Error(`bitmart: ${msg.errorCode} ${msg.errorMessage ?? ""}`)
+        new ExchangeError("grvt", `${msg.error.code}: ${msg.error.message}`)
       );
       return;
     }
-    if (msg.group !== channelArg || !msg.data) return;
-    handleFrame(msg.data);
-  };
-  const onMessage = async (raw) => {
-    if (typeof raw === "string") {
-      handlePayload(raw);
-      return;
+    if (subscribeIds.delete(msg.id)) {
+      const subs = msg.result?.subs ?? [];
+      const latest = Number(msg.result?.latest_sequence_number?.[0]);
+      ackSequence = Number.isFinite(latest) ? latest : null;
+      if (!subs.includes(selector)) {
+        stream.emit(
+          "error",
+          new ExchangeError(
+            "grvt",
+            `subscribe rejected for "${STREAM}" selector "${selector}"`
+          )
+        );
+      }
     }
-    const inflate = await getGzipInflate();
-    handlePayload(inflate(raw));
   };
   ws = new WSClient({
-    url: WS_FUTURES4,
-    onOpen: (sock) => {
+    url: WS_FULL,
+    onOpen: (handle) => {
+      sock = handle;
       merger.reset();
-      sock.send(subscribePayload);
+      recovering = false;
+      awaitingFirstDelta = false;
+      subscribeIds.clear();
+      subscribe();
     },
-    onMessage,
-    pingIntervalMs: 15e3,
-    pingPayload
+    onMessage
   });
   ws.on("open", () => stream.emit("connected"));
   ws.on("close", (r) => stream.emit("disconnected", r));
@@ -2764,21 +3067,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/grvt/index.ts
+var GrvtClient = class {
+  exchange = "grvt";
   transformUrl;
   timeoutMs;
   constructor(opts = {}) {
@@ -2787,7 +3079,7 @@ var BitmartClient = class {
   }
   fetchOrderbook(symbol, opts = {}) {
     const { pair, market } = parseSymbol(symbol);
-    return fetchBitmartOrderbook({
+    return fetchGrvtOrderbook({
       symbol: pair,
       market,
       depth: opts.depth,
@@ -2795,11 +3087,12 @@ var BitmartClient = class {
       transformUrl: this.transformUrl
     });
   }
-  streamOrderbook(symbol, _opts = {}) {
+  streamOrderbook(symbol, opts = {}) {
     const { pair, market } = parseSymbol(symbol);
-    return streamBitmartOrderbook({
+    return streamGrvtOrderbook({
       symbol: pair,
       market,
+      depth: opts.depth,
       transformUrl: this.transformUrl,
       timeoutMs: this.timeoutMs
     });
@@ -2810,12 +3103,13 @@ 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.GrvtClient = GrvtClient;
 exports.HuobiClient = HuobiClient;
 exports.HyperliquidClient = HyperliquidClient;
 exports.KucoinClient = KucoinClient;