@xapy/orderbook 0.1.27 → 0.1.29

package/dist/index.cjs

@@ -2714,232 +2714,6 @@ var DeribitClient = class {
   }
 };
 
-// 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/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(
-      "grvt",
-      res.code ? `${res.code}: ${res.message}` : "empty orderbook response"
-    );
-  }
-  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());
-  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: "grvt",
-      symbol: fromGrvtSymbol(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("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(raw);
-    } catch {
-      return;
-    }
-    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 ExchangeError("grvt", `${msg.error.code}: ${msg.error.message}`)
-      );
-      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}"`
-          )
-        );
-      }
-    }
-  };
-  ws = new WSClient({
-    url: WS_FULL,
-    onOpen: (handle) => {
-      sock = handle;
-      merger.reset();
-      recovering = false;
-      awaitingFirstDelta = false;
-      subscribeIds.clear();
-      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/grvt/index.ts
-var GrvtClient = class {
-  exchange = "grvt";
-  transformUrl;
-  timeoutMs;
-  constructor(opts = {}) {
-    this.transformUrl = opts.transformUrl;
-    this.timeoutMs = opts.timeoutMs;
-  }
-  fetchOrderbook(symbol, opts = {}) {
-    const { pair, market } = parseSymbol(symbol);
-    return fetchGrvtOrderbook({
-      symbol: pair,
-      market,
-      depth: opts.depth,
-      timeoutMs: this.timeoutMs,
-      transformUrl: this.transformUrl
-    });
-  }
-  streamOrderbook(symbol, opts = {}) {
-    const { pair, market } = parseSymbol(symbol);
-    return streamGrvtOrderbook({
-      symbol: pair,
-      market,
-      depth: opts.depth,
-      transformUrl: this.transformUrl,
-      timeoutMs: this.timeoutMs
-    });
-  }
-};
-
 // src/exchanges/lighter/markets.ts
 var LIGHTER_REST = "https://mainnet.zklighter.elliot.ai";
 var cache = null;
@@ -3065,7 +2839,7 @@ async function fetchLighterOrderbook(opts) {
 // src/exchanges/lighter/ws.ts
 var WS_URL2 = "wss://mainnet.zklighter.elliot.ai/stream";
 var PING_INTERVAL_MS = 6e4;
-var toLevels2 = (rows) => (rows ?? []).map((l) => ({ price: Number(l.price), size: Number(l.size) }));
+var toLevels = (rows) => (rows ?? []).map((l) => ({ price: Number(l.price), size: Number(l.size) }));
 function streamLighterOrderbook(opts) {
   const name = toLighterSymbol(opts.symbol, opts.market);
   const symbol = fromLighterSymbol(name);
@@ -3104,8 +2878,8 @@ function streamLighterOrderbook(opts) {
   };
   const buildEvent2 = (msg, snapshot) => {
     const ob = msg.order_book ?? {};
-    const bids = toLevels2(ob.bids);
-    const asks = toLevels2(ob.asks);
+    const bids = toLevels(ob.bids);
+    const asks = toLevels(ob.asks);
     const timestamp = msg.timestamp ?? usToMs(ob.last_updated_at);
     const sequence = Number(ob.nonce ?? 0);
     return snapshot ? { kind: "snapshot", bids, asks, sequence, timestamp } : {
@@ -3284,7 +3058,7 @@ var ALLOWED_LEVELS = [15, 200];
 function snapLevel(depth) {
   return ALLOWED_LEVELS.find((l) => l >= depth) ?? ALLOWED_LEVELS[ALLOWED_LEVELS.length - 1];
 }
-var toLevels3 = (rows) => (rows ?? []).map((l) => ({ price: Number(l.price), size: Number(l.size) }));
+var toLevels2 = (rows) => (rows ?? []).map((l) => ({ price: Number(l.price), size: Number(l.size) }));
 async function fetchEdgexOrderbook(opts) {
   const contractName = toEdgexSymbol(opts.symbol, opts.market);
   const contract = await resolveEdgexContract(contractName, opts);
@@ -3306,8 +3080,8 @@ async function fetchEdgexOrderbook(opts) {
     exchange: "edgex",
     symbol: fromEdgexSymbol(depth.contractName ?? contractName),
     market: opts.market,
-    bids: toLevels3(depth.bids),
-    asks: toLevels3(depth.asks),
+    bids: toLevels2(depth.bids),
+    asks: toLevels2(depth.asks),
     timestamp,
     sequence: Number(depth.endVersion ?? 0)
   };
@@ -3353,8 +3127,8 @@ function streamEdgexOrderbook(opts) {
     send("subscribe");
   };
   const buildEvent2 = (d, snapshot) => {
-    const bids = toLevels3(d.bids);
-    const asks = toLevels3(d.asks);
+    const bids = toLevels2(d.bids);
+    const asks = toLevels2(d.asks);
     const timestamp = Date.now();
     const sequence = Number(d.endVersion ?? 0);
     return snapshot ? { kind: "snapshot", bids, asks, sequence, timestamp } : {
@@ -3458,6 +3232,430 @@ var EdgexClient = class {
   }
 };
 
+// src/exchanges/whitebit/symbols.ts
+function toWhitebitSymbol(symbol, market) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  if (market === "perpetual") {
+    if (quote.toUpperCase() !== "USDT") {
+      throw new Error(
+        `whitebit perpetuals are USDT-margined; got "${quote}"`
+      );
+    }
+    return `${base.toUpperCase()}_PERP`;
+  }
+  return `${base.toUpperCase()}_${quote.toUpperCase()}`;
+}
+function fromWhitebitSymbol(market) {
+  const name = market.toUpperCase();
+  if (name.endsWith("_PERP")) return `${name.slice(0, -5)}/USDT`;
+  const [base, quote] = name.split("_");
+  return base && quote ? `${base}/${quote}` : name;
+}
+
+// src/exchanges/whitebit/rest.ts
+var WHITEBIT_REST = "https://whitebit.com";
+var MAX_REST_LIMIT = 100;
+function secToMs(sec) {
+  return Number.isFinite(sec) && sec > 0 ? Math.round(sec * 1e3) : Date.now();
+}
+var toLevels3 = (rows) => (rows ?? []).map(([price, size]) => ({
+  price: Number(price),
+  size: Number(size)
+}));
+async function fetchWhitebitOrderbook(opts) {
+  const market = toWhitebitSymbol(opts.symbol, opts.market);
+  const limit = Math.min(opts.depth ?? 50, MAX_REST_LIMIT);
+  const res = await httpJson({
+    url: `${WHITEBIT_REST}/api/v4/public/orderbook/${market}?limit=${limit}`,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (!res.asks && !res.bids) {
+    const detail = res.message ?? (res.errors ? JSON.stringify(res.errors) : "empty orderbook response");
+    throw new ExchangeError("whitebit", detail);
+  }
+  const timestamp = secToMs(res.timestamp);
+  return {
+    exchange: "whitebit",
+    symbol: fromWhitebitSymbol(res.ticker_id ?? market),
+    market: opts.market,
+    bids: toLevels3(res.bids),
+    asks: toLevels3(res.asks),
+    timestamp,
+    // REST publishes no `update_id`; the WS chain is where ordering is enforced.
+    sequence: timestamp
+  };
+}
+
+// src/exchanges/whitebit/ws.ts
+var WS_URL4 = "wss://api.whitebit.com/ws";
+var PING_INTERVAL_MS2 = 5e4;
+var ALLOWED_LIMITS = [1, 5, 10, 20, 30, 50, 100];
+function snapLimit(depth) {
+  return ALLOWED_LIMITS.find((l) => l >= depth) ?? ALLOWED_LIMITS[ALLOWED_LIMITS.length - 1];
+}
+function streamWhitebitOrderbook(opts) {
+  const market = toWhitebitSymbol(opts.symbol, opts.market);
+  const symbol = fromWhitebitSymbol(market);
+  const limit = snapLimit(opts.depth ?? 50);
+  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 call = (method, params) => {
+    const id = nextId++;
+    sock?.send(JSON.stringify({ id, method, params }));
+    return id;
+  };
+  const subscribe = () => {
+    subscribeIds.add(call("depth_subscribe", [market, limit, "0", true]));
+  };
+  const emit = (r) => {
+    const book = {
+      exchange: "whitebit",
+      symbol,
+      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();
+    call("depth_unsubscribe", []);
+    subscribe();
+  };
+  const buildEvent2 = (d, snapshot) => {
+    const bids = toLevels3(d.bids);
+    const asks = toLevels3(d.asks);
+    const timestamp = secToMs(d.timestamp ?? d.event_time);
+    const sequence = Number(d.update_id ?? 0);
+    return snapshot ? { kind: "snapshot", bids, asks, sequence, timestamp } : {
+      kind: "delta",
+      bids,
+      asks,
+      sequence,
+      prevSequence: Number(d.past_update_id ?? 0),
+      timestamp
+    };
+  };
+  const handleDepth = (d, snapshot) => {
+    if (snapshot) recovering = false;
+    else if (recovering) return;
+    const r = merger.apply(buildEvent2(d, snapshot));
+    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 === "depth_update") {
+      const [snapshot, data, frameMarket] = msg.params ?? [];
+      if (!data || frameMarket && frameMarket !== market) return;
+      handleDepth(data, snapshot === true);
+      return;
+    }
+    if (msg.error) {
+      stream.emit(
+        "error",
+        new ExchangeError(
+          "whitebit",
+          `${msg.error.code}: ${msg.error.message}`
+        )
+      );
+      return;
+    }
+    if (typeof msg.id === "number") subscribeIds.delete(msg.id);
+  };
+  ws = new WSClient({
+    url: WS_URL4,
+    onOpen: (handle) => {
+      sock = handle;
+      merger.reset();
+      recovering = false;
+      subscribeIds.clear();
+      subscribe();
+    },
+    onMessage,
+    pingIntervalMs: PING_INTERVAL_MS2,
+    pingPayload: () => JSON.stringify({ id: 0, method: "ping", params: [] })
+  });
+  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/whitebit/index.ts
+var WhitebitClient = class {
+  exchange = "whitebit";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchWhitebitOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamWhitebitOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+// src/exchanges/aster/symbols.ts
+var QUOTES5 = ["USDT", "USD1", "FORM", "USDC", "BTC", "ETH", "U"];
+function toAsterSymbol(symbol) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  return `${base}${quote}`.toUpperCase();
+}
+function fromAsterSymbol(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/aster/rest.ts
+var ASTER_SPOT_REST = "https://sapi.asterdex.com";
+var ASTER_FUTURES_REST = "https://fapi.asterdex.com";
+async function fetchAsterOrderbook(opts) {
+  const symbol = toAsterSymbol(opts.symbol);
+  const limit = opts.depth ?? 1e3;
+  const url = opts.market === "spot" ? `${ASTER_SPOT_REST}/api/v3/depth?symbol=${symbol}&limit=${limit}` : `${ASTER_FUTURES_REST}/fapi/v1/depth?symbol=${symbol}&limit=${limit}`;
+  const data = await httpJson({
+    url,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  return {
+    exchange: "aster",
+    symbol: fromAsterSymbol(data.symbol ?? 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/aster/ws.ts
+var WS_SPOT6 = "wss://sstream.asterdex.com/ws";
+var WS_FUTURES4 = "wss://fstream.asterdex.com/ws";
+function streamAsterOrderbook(opts) {
+  const symbol = toAsterSymbol(opts.symbol);
+  const isSpot = opts.market === "spot";
+  const wsBase = isSpot ? WS_SPOT6 : WS_FUTURES4;
+  const wsUrl = `${wsBase}/${symbol.toLowerCase()}@depth@${opts.interval ?? "100ms"}`;
+  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: "aster",
+      symbol: fromAsterSymbol(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;
+    fetchAsterOrderbook({
+      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) 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) {
+      if (ev.U > snapshotId) {
+        resync();
+        return;
+      }
+      prevSequence = snapshotId;
+    } 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
+    // 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/aster/index.ts
+var AsterClient = class {
+  exchange = "aster";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchAsterOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamAsterOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+exports.AsterClient = AsterClient;
 exports.Backoff = Backoff;
 exports.BinanceClient = BinanceClient;
 exports.BingxClient = BingxClient;
@@ -3469,7 +3667,6 @@ exports.DeribitClient = DeribitClient;
 exports.EdgexClient = EdgexClient;
 exports.ExchangeError = ExchangeError;
 exports.GateClient = GateClient;
-exports.GrvtClient = GrvtClient;
 exports.HyperliquidClient = HyperliquidClient;
 exports.KucoinClient = KucoinClient;
 exports.LighterClient = LighterClient;
@@ -3477,6 +3674,7 @@ exports.OkxClient = OkxClient;
 exports.OrderbookStream = OrderbookStream;
 exports.RateLimitError = RateLimitError;
 exports.SequenceGapError = SequenceGapError;
+exports.WhitebitClient = WhitebitClient;
 exports.parseSymbol = parseSymbol;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map