@xapy/orderbook 0.1.6 → 0.1.8

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { B as BookEvent, O as OrderbookLevel, M as Market } from './stream-C73HPYqT.cjs';
-export { C as ClientOptions, E as ExchangeName, a as Orderbook, b as OrderbookOptions, c as OrderbookStream, S as Side, d as StreamEvents } from './stream-C73HPYqT.cjs';
+import { B as BookEvent, O as OrderbookLevel, M as Market } from './stream-L9MJjYbE.cjs';
+export { C as ClientOptions, E as ExchangeName, a as Orderbook, b as OrderbookOptions, c as OrderbookStream, S as Side, d as StreamEvents } from './stream-L9MJjYbE.cjs';
 export { BybitClient } from './exchanges/bybit/index.cjs';
 export { BitgetClient } from './exchanges/bitget/index.cjs';
 export { GateClient } from './exchanges/gate/index.cjs';
@@ -10,6 +10,7 @@ export { OkxClient } from './exchanges/okx/index.cjs';
 export { BinanceClient } from './exchanges/binance/index.cjs';
 export { HyperliquidClient } from './exchanges/hyperliquid/index.cjs';
 export { KucoinClient } from './exchanges/kucoin/index.cjs';
+export { BitmartClient } from './exchanges/bitmart/index.cjs';
 
 declare class ExchangeError extends Error {
     readonly exchange: string;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { B as BookEvent, O as OrderbookLevel, M as Market } from './stream-C73HPYqT.js';
-export { C as ClientOptions, E as ExchangeName, a as Orderbook, b as OrderbookOptions, c as OrderbookStream, S as Side, d as StreamEvents } from './stream-C73HPYqT.js';
+import { B as BookEvent, O as OrderbookLevel, M as Market } from './stream-L9MJjYbE.js';
+export { C as ClientOptions, E as ExchangeName, a as Orderbook, b as OrderbookOptions, c as OrderbookStream, S as Side, d as StreamEvents } from './stream-L9MJjYbE.js';
 export { BybitClient } from './exchanges/bybit/index.js';
 export { BitgetClient } from './exchanges/bitget/index.js';
 export { GateClient } from './exchanges/gate/index.js';
@@ -10,6 +10,7 @@ export { OkxClient } from './exchanges/okx/index.js';
 export { BinanceClient } from './exchanges/binance/index.js';
 export { HyperliquidClient } from './exchanges/hyperliquid/index.js';
 export { KucoinClient } from './exchanges/kucoin/index.js';
+export { BitmartClient } from './exchanges/bitmart/index.js';
 
 declare class ExchangeError extends Error {
     readonly exchange: string;

package/dist/index.js

@@ -1616,94 +1616,61 @@ async function fetchCoinexOrderbook(opts) {
 }
 
 // src/exchanges/coinex/ws.ts
-var WS_SPOT5 = "wss://socket.coinex.com/v2/spot";
-var WS_FUTURES2 = "wss://socket.coinex.com/v2/futures";
+var WS_SPOT5 = "wss://socket.coinex.com/";
+var WS_FUTURES2 = "wss://perpetual.coinex.com/";
 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 subscribeDepth = JSON.stringify({
+  const subscribePayload = JSON.stringify({
     method: "depth.subscribe",
-    params: {
-      // [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]]
-    },
+    params: [market, depth, "0", true],
     id: 1
   });
-  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 pingPayload = () => JSON.stringify({ method: "server.ping", params: [], id: 11 });
+  const emit = (r) => {
     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
     };
-    emitOverlayed();
+    stream.emit("update", book);
   };
-  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 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
     };
-    emitOverlayed();
+    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;
+    }
   };
   const handlePayload = (text) => {
     let msg;
@@ -1713,32 +1680,31 @@ function streamCoinexOrderbook(opts) {
       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") {
-      handlePayload(raw);
+    if (msg.error) {
+      stream.emit(
+        "error",
+        new Error(`coinex: ${msg.error.code} ${msg.error.message}`)
+      );
       return;
     }
-    const inflate = await getGzipInflate();
-    handlePayload(inflate(raw));
+    if (msg.method === "depth.update" && Array.isArray(msg.params)) {
+      handleDepthPush(msg.params);
+    }
+  };
+  const onMessage = (raw) => {
+    if (typeof raw !== "string") return;
+    handlePayload(raw);
   };
   ws = new WSClient({
     url: opts.market === "spot" ? WS_SPOT5 : WS_FUTURES2,
     onOpen: (sock) => {
       merger.reset();
-      lastMerged = null;
-      lastTicker = null;
-      sock.send(subscribeDepth);
-      sock.send(subscribeBbo);
+      seq = 0;
+      sock.send(subscribePayload);
     },
-    onMessage
-    // Native WS ping/pong frames keep the connection alive — no app-level ping.
+    onMessage,
+    pingIntervalMs: 25e3,
+    pingPayload
   });
   ws.on("open", () => stream.emit("connected"));
   ws.on("close", (r) => stream.emit("disconnected", r));
@@ -1747,31 +1713,11 @@ 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)];
+function parseLevels(rows) {
+  if (!rows) return [];
+  const out = [];
+  for (const [p, s] of rows) out.push({ price: Number(p), size: Number(s) });
+  return out;
 }
 
 // src/exchanges/coinex/index.ts
@@ -2469,8 +2415,8 @@ async function fetchKucoinOrderbook(opts) {
       exchange: "kucoin",
       symbol: fromKucoinSpotSymbol(symbol2),
       market: "spot",
-      bids: parseLevels(res2.data.bids),
-      asks: parseLevels(res2.data.asks),
+      bids: parseLevels2(res2.data.bids),
+      asks: parseLevels2(res2.data.asks),
       timestamp: res2.data.time,
       sequence: Number(res2.data.sequence)
     };
@@ -2489,13 +2435,13 @@ async function fetchKucoinOrderbook(opts) {
     exchange: "kucoin",
     symbol: fromKucoinFuturesSymbol(symbol),
     market: "perpetual",
-    bids: parseLevels(res.data.bids),
-    asks: parseLevels(res.data.asks),
+    bids: parseLevels2(res.data.bids),
+    asks: parseLevels2(res.data.asks),
     timestamp: res.data.ts,
     sequence: res.data.sequence
   };
 }
-function parseLevels(rows) {
+function parseLevels2(rows) {
   return rows.map(([p, s]) => ({ price: Number(p), size: Number(s) }));
 }
 
@@ -2621,6 +2567,185 @@ var KucoinClient = class {
   }
 };
 
-export { Backoff, BinanceClient, BingxClient, BitgetClient, BookMerger, BybitClient, CoinexClient, ExchangeError, GateClient, HuobiClient, HyperliquidClient, KucoinClient, OkxClient, OrderbookStream, RateLimitError, SequenceGapError, parseSymbol };
+// src/exchanges/bitmart/symbols.ts
+var QUOTES6 = ["USDT", "USDC", "USD"];
+function toBitmartSymbol(symbol) {
+  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}`;
+    }
+  }
+  return upper;
+}
+
+// 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}`;
+  const res = await httpJson({
+    url,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (res.code !== 1e3) {
+    throw new ExchangeError("bitmart", `${res.code}: ${res.message ?? ""}`);
+  }
+  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
+  };
+}
+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-wsv2.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 channelArg = opts.interval ? `futures/depth:${symbol}@${opts.interval}` : `futures/depth:${symbol}`;
+  const merger = new BookMerger();
+  let ws = 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: parseLevels4(frame.bids),
+      asks: parseLevels4(frame.asks),
+      sequence: frame.timestamp,
+      timestamp: frame.timestamp
+    };
+    const r = merger.apply(event);
+    if (!r.ok) return;
+    const book = {
+      exchange: "bitmart",
+      symbol: fromBitmartSymbol(symbol),
+      market: "perpetual",
+      bids: r.bids,
+      asks: r.asks,
+      timestamp: r.timestamp,
+      sequence: r.sequence
+    };
+    stream.emit("update", book);
+  };
+  const handlePayload = (text) => {
+    let msg;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (msg.action === "subscribe" || msg.action === "pong") return;
+    if (msg.errorCode) {
+      stream.emit(
+        "error",
+        new Error(`bitmart: ${msg.errorCode} ${msg.errorMessage ?? ""}`)
+      );
+      return;
+    }
+    if (msg.arg !== channelArg || !msg.data) return;
+    handleFrame(msg.data);
+  };
+  const onMessage = async (raw) => {
+    if (typeof raw === "string") {
+      handlePayload(raw);
+      return;
+    }
+    const inflate = await getGzipInflate();
+    handlePayload(inflate(raw));
+  };
+  ws = new WSClient({
+    url: WS_FUTURES4,
+    onOpen: (sock) => {
+      merger.reset();
+      sock.send(subscribePayload);
+    },
+    onMessage,
+    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;
+}
+function parseLevels4(rows) {
+  if (!rows) return [];
+  const out = [];
+  for (const row of rows) {
+    out.push({ price: Number(row[0]), size: Number(row[1]) });
+  }
+  return out;
+}
+
+// src/exchanges/bitmart/index.ts
+var BitmartClient = class {
+  exchange = "bitmart";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchBitmartOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, _opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamBitmartOrderbook({
+      symbol: pair,
+      market,
+      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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map