@xapy/orderbook 0.1.23 → 0.1.25

package/dist/index.cjs

@@ -2745,13 +2745,13 @@ function streamDeribitOrderbook(opts) {
     rpc("public/unsubscribe", { channels: [channel] });
     subscribe();
   };
-  const toLevels = (entries) => entries.map(([action, price, amount]) => ({
+  const toLevels4 = (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);
+    const bids = toLevels4(d.bids);
+    const asks = toLevels4(d.asks);
     if (d.type === "snapshot") {
       return {
         kind: "snapshot",
@@ -2873,6 +2873,738 @@ 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;
+var inflight = null;
+var key = (name, market) => `${market}:${name.toUpperCase()}`;
+async function fetchMarkets(opts) {
+  const res = await httpJson({
+    url: `${LIGHTER_REST}/api/v1/orderBooks`,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  const rows = res.order_books ?? [];
+  if (rows.length === 0) {
+    throw new ExchangeError(
+      "lighter",
+      res.message ? `${res.code}: ${res.message}` : "empty orderBooks response"
+    );
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    map.set(key(row.symbol, row.market_type === "spot" ? "spot" : "perpetual"), row);
+  }
+  return map;
+}
+function loadMarkets(opts) {
+  inflight ??= fetchMarkets(opts).then(
+    (m) => {
+      cache = m;
+      inflight = null;
+      return m;
+    },
+    (err) => {
+      inflight = null;
+      throw err;
+    }
+  );
+  return inflight;
+}
+async function resolveLighterMarket(name, market, opts) {
+  const k = key(name, market);
+  const hit = cache?.get(k);
+  const meta = hit ?? (await loadMarkets(opts)).get(k);
+  if (!meta) {
+    throw new ExchangeError(
+      "lighter",
+      `unknown ${market} market "${name}" \u2014 not listed on lighter`
+    );
+  }
+  if (meta.status && meta.status !== "active") {
+    throw new ExchangeError(
+      "lighter",
+      `market "${name}" is ${meta.status} \u2014 no book is published for it`
+    );
+  }
+  return meta;
+}
+
+// src/exchanges/lighter/symbols.ts
+function toLighterSymbol(symbol, market) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  if (quote.toUpperCase() !== "USDC") {
+    throw new Error(`lighter only supports USDC-quoted pairs; got "${quote}"`);
+  }
+  return market === "perpetual" ? base.toUpperCase() : `${base.toUpperCase()}/${quote.toUpperCase()}`;
+}
+function fromLighterSymbol(name) {
+  return name.includes("/") ? name.toUpperCase() : `${name.toUpperCase()}/USDC`;
+}
+
+// src/exchanges/lighter/rest.ts
+var MAX_ORDERS = 250;
+function usToMs(us) {
+  return Number.isFinite(us) && us > 0 ? Math.floor(us / 1e3) : Date.now();
+}
+function aggregate(orders, side, capped) {
+  const byPrice = /* @__PURE__ */ new Map();
+  for (const o of orders ?? []) {
+    const price = Number(o.price);
+    const size = Number(o.remaining_base_amount);
+    if (!Number.isFinite(price) || !Number.isFinite(size)) continue;
+    byPrice.set(price, (byPrice.get(price) ?? 0) + size);
+  }
+  const levels = [];
+  for (const [price, size] of byPrice) levels.push({ price, size });
+  levels.sort((a, b) => side === "bid" ? b.price - a.price : a.price - b.price);
+  if (capped) levels.pop();
+  return levels;
+}
+async function fetchLighterOrderbook(opts) {
+  const name = toLighterSymbol(opts.symbol, opts.market);
+  const meta = await resolveLighterMarket(name, opts.market, opts);
+  const res = await httpJson({
+    url: `${LIGHTER_REST}/api/v1/orderBookOrders?market_id=${meta.market_id}&limit=${MAX_ORDERS}`,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (!res.asks && !res.bids) {
+    throw new ExchangeError(
+      "lighter",
+      res.message ? `${res.code}: ${res.message}` : "empty orderbook response"
+    );
+  }
+  const depth = opts.depth ?? 50;
+  const bids = aggregate(res.bids, "bid", res.total_bids === MAX_ORDERS);
+  const asks = aggregate(res.asks, "ask", res.total_asks === MAX_ORDERS);
+  const timestamp = Date.now();
+  return {
+    exchange: "lighter",
+    symbol: fromLighterSymbol(name),
+    market: opts.market,
+    bids: bids.slice(0, depth),
+    asks: asks.slice(0, depth),
+    timestamp,
+    // The L3 endpoint publishes no sequence of its own — the WS `nonce` chain
+    // is where ordering is enforced.
+    sequence: timestamp
+  };
+}
+
+// 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) }));
+function streamLighterOrderbook(opts) {
+  const name = toLighterSymbol(opts.symbol, opts.market);
+  const symbol = fromLighterSymbol(name);
+  const marketId = resolveLighterMarket(name, opts.market, opts).then(
+    (m) => m.market_id
+  );
+  marketId.catch(() => {
+  });
+  const merger = new BookMerger();
+  let ws = null;
+  let sock = null;
+  let channel = null;
+  let recovering = false;
+  const stream = new OrderbookStream(() => ws?.close());
+  const send = (type) => {
+    if (channel) sock?.send(JSON.stringify({ type, channel }));
+  };
+  const emit = (r) => {
+    const book = {
+      exchange: "lighter",
+      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();
+    send("unsubscribe");
+    send("subscribe");
+  };
+  const buildEvent2 = (msg, snapshot) => {
+    const ob = msg.order_book ?? {};
+    const bids = toLevels2(ob.bids);
+    const asks = toLevels2(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 } : {
+      kind: "delta",
+      bids,
+      asks,
+      sequence,
+      prevSequence: Number(ob.begin_nonce ?? 0),
+      timestamp
+    };
+  };
+  const handleBook = (msg, snapshot) => {
+    if (snapshot) recovering = false;
+    else if (recovering) return;
+    const r = merger.apply(buildEvent2(msg, 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.error) {
+      stream.emit(
+        "error",
+        new ExchangeError("lighter", `${msg.error.code}: ${msg.error.message}`)
+      );
+      return;
+    }
+    if (!msg.order_book) return;
+    if (msg.channel && channel && msg.channel !== channel.replace("/", ":")) {
+      return;
+    }
+    if (msg.type === "subscribed/order_book") handleBook(msg, true);
+    else if (msg.type === "update/order_book") handleBook(msg, false);
+  };
+  ws = new WSClient({
+    url: WS_URL2,
+    onOpen: async (handle) => {
+      sock = handle;
+      merger.reset();
+      recovering = false;
+      channel = `order_book/${await marketId}`;
+      send("subscribe");
+    },
+    onMessage,
+    pingIntervalMs: PING_INTERVAL_MS,
+    pingPayload: () => JSON.stringify({ type: "ping" })
+  });
+  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/lighter/index.ts
+var LighterClient = class {
+  exchange = "lighter";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchLighterOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamLighterOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+// src/exchanges/edgex/markets.ts
+var EDGEX_REST = "https://edgex-prod-v2.edgex.exchange";
+var EDGEX_WS = "wss://edgex-quote-prod-v2.edgex.exchange";
+var cache2 = null;
+var inflight2 = null;
+async function fetchContracts(opts) {
+  const res = await httpJson({
+    url: `${EDGEX_REST}/api/v2/public/meta/getMetaData`,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  const rows = res.data?.contractList ?? [];
+  if (rows.length === 0) {
+    throw new ExchangeError(
+      "edgex",
+      res.msg ? `${res.code}: ${res.msg}` : "empty metadata response"
+    );
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) map.set(row.contractName.toUpperCase(), row);
+  return map;
+}
+function loadContracts(opts) {
+  inflight2 ??= fetchContracts(opts).then(
+    (m) => {
+      cache2 = m;
+      inflight2 = null;
+      return m;
+    },
+    (err) => {
+      inflight2 = null;
+      throw err;
+    }
+  );
+  return inflight2;
+}
+async function resolveEdgexContract(contractName, opts) {
+  const k = contractName.toUpperCase();
+  const hit = cache2?.get(k);
+  const contract = hit ?? (await loadContracts(opts)).get(k);
+  if (!contract) {
+    throw new ExchangeError(
+      "edgex",
+      `unknown contract "${contractName}" \u2014 not listed on edgex`
+    );
+  }
+  return contract;
+}
+
+// src/exchanges/edgex/symbols.ts
+function toEdgexSymbol(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(
+      `edgex only lists perpetuals; use "${base.toUpperCase()}/${quote.toUpperCase()}:${quote.toUpperCase()}"`
+    );
+  }
+  if (quote.toUpperCase() !== "USDC") {
+    throw new Error(`edgex only supports USDC-quoted pairs; got "${quote}"`);
+  }
+  return `${base.toUpperCase()}${quote.toUpperCase()}`;
+}
+function fromEdgexSymbol(contractName) {
+  const name = contractName.toUpperCase();
+  return name.endsWith("USDC") ? `${name.slice(0, -4)}/USDC` : name;
+}
+
+// src/exchanges/edgex/rest.ts
+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) }));
+async function fetchEdgexOrderbook(opts) {
+  const contractName = toEdgexSymbol(opts.symbol, opts.market);
+  const contract = await resolveEdgexContract(contractName, opts);
+  const level = snapLevel(opts.depth ?? 50);
+  const res = await httpJson({
+    url: `${EDGEX_REST}/api/v2/public/quote/getDepth?contractId=${contract.contractId}&level=${level}`,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  const depth = res.data?.[0];
+  if (!depth) {
+    throw new ExchangeError(
+      "edgex",
+      res.msg ? `${res.code}: ${res.msg}` : "empty orderbook response"
+    );
+  }
+  const timestamp = Date.now();
+  return {
+    exchange: "edgex",
+    symbol: fromEdgexSymbol(depth.contractName ?? contractName),
+    market: opts.market,
+    bids: toLevels3(depth.bids),
+    asks: toLevels3(depth.asks),
+    timestamp,
+    sequence: Number(depth.endVersion ?? 0)
+  };
+}
+
+// src/exchanges/edgex/ws.ts
+var WS_URL3 = `${EDGEX_WS}/api/v1/public/ws`;
+function streamEdgexOrderbook(opts) {
+  const contractName = toEdgexSymbol(opts.symbol, opts.market);
+  const symbol = fromEdgexSymbol(contractName);
+  const level = snapLevel(opts.depth ?? 50);
+  const contractId = resolveEdgexContract(contractName, opts).then(
+    (c) => c.contractId
+  );
+  contractId.catch(() => {
+  });
+  const merger = new BookMerger();
+  let ws = null;
+  let sock = null;
+  let channel = null;
+  let recovering = false;
+  const stream = new OrderbookStream(() => ws?.close());
+  const send = (type) => {
+    if (channel) sock?.send(JSON.stringify({ type, channel }));
+  };
+  const emit = (r) => {
+    const book = {
+      exchange: "edgex",
+      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();
+    send("unsubscribe");
+    send("subscribe");
+  };
+  const buildEvent2 = (d, snapshot) => {
+    const bids = toLevels3(d.bids);
+    const asks = toLevels3(d.asks);
+    const timestamp = Date.now();
+    const sequence = Number(d.endVersion ?? 0);
+    return snapshot ? { kind: "snapshot", bids, asks, sequence, timestamp } : {
+      kind: "delta",
+      bids,
+      asks,
+      sequence,
+      prevSequence: Number(d.startVersion ?? 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.type === "ping") {
+      sock?.send(JSON.stringify({ type: "pong", time: msg.time }));
+      return;
+    }
+    if (msg.type === "error") {
+      const { code, msg: detail } = msg.content ?? {};
+      stream.emit(
+        "error",
+        new ExchangeError(
+          "edgex",
+          code ? `${code}: ${detail ?? ""}`.trim() : "subscribe rejected"
+        )
+      );
+      return;
+    }
+    if (msg.type !== "quote-event") return;
+    if (channel && (msg.channel ?? msg.content?.channel) !== channel) return;
+    const snapshot = msg.content?.dataType?.toLowerCase() === "snapshot";
+    for (const d of msg.content?.data ?? []) handleDepth(d, snapshot);
+  };
+  ws = new WSClient({
+    url: WS_URL3,
+    onOpen: async (handle) => {
+      sock = handle;
+      merger.reset();
+      recovering = false;
+      channel = `depth.${await contractId}.${level}`;
+      send("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/edgex/index.ts
+var EdgexClient = class {
+  exchange = "edgex";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchEdgexOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamEdgexOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
 exports.Backoff = Backoff;
 exports.BinanceClient = BinanceClient;
 exports.BingxClient = BingxClient;
@@ -2881,11 +3613,14 @@ exports.BookMerger = BookMerger;
 exports.BybitClient = BybitClient;
 exports.CoinexClient = CoinexClient;
 exports.DeribitClient = DeribitClient;
+exports.EdgexClient = EdgexClient;
 exports.ExchangeError = ExchangeError;
 exports.GateClient = GateClient;
+exports.GrvtClient = GrvtClient;
 exports.HuobiClient = HuobiClient;
 exports.HyperliquidClient = HyperliquidClient;
 exports.KucoinClient = KucoinClient;
+exports.LighterClient = LighterClient;
 exports.OkxClient = OkxClient;
 exports.OrderbookStream = OrderbookStream;
 exports.RateLimitError = RateLimitError;