@xapy/orderbook 0.1.24 → 0.1.26

package/dist/index.js

@@ -1438,167 +1438,8 @@ var BingxClient = class {
   }
 };
 
-// src/exchanges/huobi/symbols.ts
-var QUOTES3 = ["USDT", "USDC", "USD", "BTC", "ETH"];
-function toHuobiSymbol(symbol, market) {
-  const [base, quote] = symbol.split("/");
-  if (!base || !quote) {
-    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
-  }
-  return market === "spot" ? `${base}${quote}`.toLowerCase() : `${base}-${quote}`.toUpperCase();
-}
-function fromHuobiSymbol(s, market) {
-  if (market === "spot") {
-    const upper = s.toUpperCase();
-    for (const q of QUOTES3) {
-      if (upper.endsWith(q)) return `${upper.slice(0, -q.length)}/${q}`;
-    }
-    return upper;
-  }
-  return s.toUpperCase().replace("-", "/");
-}
-
-// src/exchanges/huobi/rest.ts
-var SPOT_BASE = "https://api.huobi.pro";
-var PERP_BASE = "https://api.hbdm.com";
-async function fetchHuobiOrderbook(opts) {
-  const symbol = toHuobiSymbol(opts.symbol, opts.market);
-  const step = opts.step ?? "step0";
-  const url = opts.market === "spot" ? `${SPOT_BASE}/market/depth?symbol=${symbol}&type=${step}` : `${PERP_BASE}/linear-swap-ex/market/depth?contract_code=${symbol}&type=${step}`;
-  const res = await httpJson({
-    url,
-    timeoutMs: opts.timeoutMs,
-    transformUrl: opts.transformUrl
-  });
-  if (res.status !== "ok" || !res.tick) {
-    throw new ExchangeError(
-      "huobi",
-      res["err-msg"] ?? res["err-code"] ?? "missing tick"
-    );
-  }
-  const ts = res.tick.ts;
-  return {
-    exchange: "huobi",
-    symbol: fromHuobiSymbol(symbol, opts.market),
-    market: opts.market,
-    bids: res.tick.bids.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
-    asks: res.tick.asks.map(([p, s]) => ({ price: Number(p), size: Number(s) })),
-    timestamp: ts,
-    sequence: res.tick.version ?? ts
-  };
-}
-
-// src/exchanges/huobi/ws.ts
-var WS_SPOT4 = "wss://api.huobi.pro/ws";
-var WS_PERP = "wss://api.hbdm.com/linear-swap-ws";
-function streamHuobiOrderbook(opts) {
-  const huobiSymbol = toHuobiSymbol(opts.symbol, opts.market);
-  const step = opts.step ?? "step0";
-  const channel = `market.${huobiSymbol}.depth.${step}`;
-  const merger = new BookMerger();
-  let ws = null;
-  const stream = new OrderbookStream(() => ws?.close());
-  const subscribePayload = JSON.stringify({
-    sub: channel,
-    id: `sub-${Date.now()}`
-  });
-  const handlePayload = (text) => {
-    let msg;
-    try {
-      msg = JSON.parse(text);
-    } catch {
-      return;
-    }
-    if (typeof msg.ping === "number") {
-      ws?.send(JSON.stringify({ pong: msg.ping }));
-      return;
-    }
-    if (msg.status === "ok" && msg.subbed) return;
-    if (msg.ch !== channel || !msg.tick) return;
-    const ts = msg.tick.ts;
-    const sequence = msg.tick.version ?? ts;
-    const event = {
-      kind: "snapshot",
-      bids: msg.tick.bids.map(([p, s]) => ({
-        price: Number(p),
-        size: Number(s)
-      })),
-      asks: msg.tick.asks.map(([p, s]) => ({
-        price: Number(p),
-        size: Number(s)
-      })),
-      sequence,
-      timestamp: ts
-    };
-    const r = merger.apply(event);
-    if (!r.ok) return;
-    const book = {
-      exchange: "huobi",
-      symbol: fromHuobiSymbol(huobiSymbol, opts.market),
-      market: opts.market,
-      bids: r.bids,
-      asks: r.asks,
-      timestamp: r.timestamp,
-      sequence: r.sequence
-    };
-    stream.emit("update", book);
-  };
-  const onMessage = async (raw) => {
-    if (typeof raw === "string") {
-      handlePayload(raw);
-      return;
-    }
-    const inflate = await getGzipInflate();
-    handlePayload(inflate(raw));
-  };
-  ws = new WSClient({
-    url: opts.market === "spot" ? WS_SPOT4 : WS_PERP,
-    onOpen: (sock) => {
-      merger.reset();
-      sock.send(subscribePayload);
-    },
-    onMessage
-    // Huobi heartbeat is server-initiated; we reply inline above. No client 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/huobi/index.ts
-var HuobiClient = class {
-  exchange = "huobi";
-  transformUrl;
-  timeoutMs;
-  constructor(opts = {}) {
-    this.transformUrl = opts.transformUrl;
-    this.timeoutMs = opts.timeoutMs;
-  }
-  fetchOrderbook(symbol, _opts = {}) {
-    const { pair, market } = parseSymbol(symbol);
-    return fetchHuobiOrderbook({
-      symbol: pair,
-      market,
-      timeoutMs: this.timeoutMs,
-      transformUrl: this.transformUrl
-    });
-  }
-  streamOrderbook(symbol, _opts = {}) {
-    const { pair, market } = parseSymbol(symbol);
-    return streamHuobiOrderbook({
-      symbol: pair,
-      market,
-      transformUrl: this.transformUrl,
-      timeoutMs: this.timeoutMs
-    });
-  }
-};
-
 // src/exchanges/coinex/symbols.ts
-var QUOTES4 = ["USDT", "USDC", "USD"];
+var QUOTES3 = ["USDT", "USDC", "USD"];
 function toCoinexSymbol(symbol) {
   const [base, quote] = symbol.split("/");
   if (!base || !quote) {
@@ -1608,7 +1449,7 @@ function toCoinexSymbol(symbol) {
 }
 function fromCoinexSymbol(s) {
   const upper = s.toUpperCase();
-  for (const q of QUOTES4) {
+  for (const q of QUOTES3) {
     if (upper.endsWith(q)) {
       return `${upper.slice(0, -q.length)}/${q}`;
     }
@@ -1643,7 +1484,7 @@ async function fetchCoinexOrderbook(opts) {
 }
 
 // src/exchanges/coinex/ws.ts
-var WS_SPOT5 = "wss://socket.coinex.com/v2/spot";
+var WS_SPOT4 = "wss://socket.coinex.com/v2/spot";
 var WS_FUTURES2 = "wss://socket.coinex.com/v2/futures";
 function streamCoinexOrderbook(opts) {
   const market = toCoinexSymbol(opts.symbol);
@@ -1755,7 +1596,7 @@ function streamCoinexOrderbook(opts) {
     handlePayload(inflate(raw));
   };
   ws = new WSClient({
-    url: opts.market === "spot" ? WS_SPOT5 : WS_FUTURES2,
+    url: opts.market === "spot" ? WS_SPOT4 : WS_FUTURES2,
     onOpen: (sock) => {
       merger.reset();
       lastMerged = null;
@@ -2026,7 +1867,7 @@ var OkxClient = class {
 };
 
 // src/exchanges/binance/symbols.ts
-var QUOTES5 = [
+var QUOTES4 = [
   "USDT",
   "USDC",
   "FDUSD",
@@ -2046,7 +1887,7 @@ function toBinanceSymbol(symbol) {
 }
 function fromBinanceSymbol(s) {
   const upper = s.toUpperCase();
-  for (const q of QUOTES5) {
+  for (const q of QUOTES4) {
     if (upper.endsWith(q) && upper.length > q.length) {
       return `${upper.slice(0, -q.length)}/${q}`;
     }
@@ -2078,13 +1919,13 @@ async function fetchBinanceOrderbook(opts) {
 }
 
 // src/exchanges/binance/ws.ts
-var WS_SPOT6 = "wss://stream.binance.com:9443/ws";
+var WS_SPOT5 = "wss://stream.binance.com:9443/ws";
 var WS_FUTURES3 = "wss://fstream.binance.com/ws";
 function streamBinanceOrderbook(opts) {
   const symbol = toBinanceSymbol(opts.symbol);
   const isSpot = opts.market === "spot";
   const interval = opts.interval ?? "100ms";
-  const wsBase = isSpot ? WS_SPOT6 : WS_FUTURES3;
+  const wsBase = isSpot ? WS_SPOT5 : WS_FUTURES3;
   const wsUrl = `${wsBase}/${symbol.toLowerCase()}@depth@${interval}`;
   const merger = new BookMerger();
   let snapshotId = -1;
@@ -2743,13 +2584,13 @@ function streamDeribitOrderbook(opts) {
     rpc("public/unsubscribe", { channels: [channel] });
     subscribe();
   };
-  const toLevels2 = (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 = toLevels2(d.bids);
-    const asks = toLevels2(d.asks);
+    const bids = toLevels4(d.bids);
+    const asks = toLevels4(d.asks);
     if (d.type === "snapshot") {
       return {
         kind: "snapshot",
@@ -3097,6 +2938,512 @@ var GrvtClient = class {
   }
 };
 
-export { Backoff, BinanceClient, BingxClient, BitgetClient, BookMerger, BybitClient, CoinexClient, DeribitClient, ExchangeError, GateClient, GrvtClient, HuobiClient, HyperliquidClient, KucoinClient, OkxClient, OrderbookStream, RateLimitError, SequenceGapError, parseSymbol };
+// 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
+    });
+  }
+};
+
+export { Backoff, BinanceClient, BingxClient, BitgetClient, BookMerger, BybitClient, CoinexClient, DeribitClient, EdgexClient, ExchangeError, GateClient, GrvtClient, HyperliquidClient, KucoinClient, LighterClient, OkxClient, OrderbookStream, RateLimitError, SequenceGapError, parseSymbol };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map