@xapy/orderbook 0.1.28 → 0.1.30

package/dist/index.cjs

@@ -3437,6 +3437,549 @@ var WhitebitClient = class {
   }
 };
 
+// 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
+    });
+  }
+};
+
+// src/exchanges/mexc/contracts.ts
+var MEXC_SPOT_REST = "https://api.mexc.com";
+var MEXC_FUTURES_REST = "https://contract.mexc.com";
+var cache2 = null;
+var inflight2 = null;
+async function fetchContracts2(opts) {
+  const res = await httpJson({
+    url: `${MEXC_FUTURES_REST}/api/v1/contract/detail`,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  const rows = res.data ?? [];
+  if (rows.length === 0) {
+    throw new ExchangeError(
+      "mexc",
+      res.message ? `${res.code}: ${res.message}` : "empty contract/detail response"
+    );
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) map.set(row.symbol.toUpperCase(), row);
+  return map;
+}
+function loadContracts2(opts) {
+  inflight2 ??= fetchContracts2(opts).then(
+    (m) => {
+      cache2 = m;
+      inflight2 = null;
+      return m;
+    },
+    (err) => {
+      inflight2 = null;
+      throw err;
+    }
+  );
+  return inflight2;
+}
+async function resolveContractSize(symbol, opts) {
+  const k = symbol.toUpperCase();
+  const hit = cache2?.get(k);
+  const contract = hit ?? (await loadContracts2(opts)).get(k);
+  if (!contract) {
+    throw new ExchangeError(
+      "mexc",
+      `unknown futures contract "${symbol}" \u2014 not listed on mexc`
+    );
+  }
+  const size = Number(contract.contractSize);
+  if (!Number.isFinite(size) || size <= 0) {
+    throw new ExchangeError(
+      "mexc",
+      `contract "${symbol}" has no usable contractSize (${contract.contractSize})`
+    );
+  }
+  return size;
+}
+
+// src/exchanges/mexc/symbols.ts
+var QUOTES6 = ["USDT", "USDC", "TUSD", "USD", "BTC", "ETH"];
+function toMexcSymbol(symbol, market) {
+  const [base, quote] = symbol.split("/");
+  if (!base || !quote) {
+    throw new Error(`invalid symbol "${symbol}" \u2014 expected "BASE/QUOTE"`);
+  }
+  return market === "perpetual" ? `${base.toUpperCase()}_${quote.toUpperCase()}` : `${base}${quote}`.toUpperCase();
+}
+function fromMexcSymbol(s, market) {
+  const upper = s.toUpperCase();
+  if (market === "perpetual") {
+    const [base, quote] = upper.split("_");
+    return base && quote ? `${base}/${quote}` : upper;
+  }
+  for (const q of QUOTES6) {
+    if (upper.endsWith(q) && upper.length > q.length) {
+      return `${upper.slice(0, -q.length)}/${q}`;
+    }
+  }
+  return upper;
+}
+
+// src/exchanges/mexc/rest.ts
+var toSpotLevels = (rows) => (rows ?? []).map(([p, s]) => ({ price: Number(p), size: Number(s) }));
+var toFuturesLevels = (rows, contractSize) => (rows ?? []).map(([price, vol]) => ({
+  price: Number(price),
+  size: Number(vol) * contractSize
+}));
+async function fetchMexcOrderbook(opts) {
+  const symbol = toMexcSymbol(opts.symbol, opts.market);
+  const depth = opts.depth ?? 50;
+  if (opts.market === "spot") {
+    const data = await httpJson({
+      url: `${MEXC_SPOT_REST}/api/v3/depth?symbol=${symbol}&limit=${depth}`,
+      timeoutMs: opts.timeoutMs,
+      transformUrl: opts.transformUrl
+    });
+    return {
+      exchange: "mexc",
+      symbol: fromMexcSymbol(symbol, opts.market),
+      market: opts.market,
+      bids: toSpotLevels(data.bids),
+      asks: toSpotLevels(data.asks),
+      // The spot depth endpoint returns no timestamp of its own.
+      timestamp: Date.now(),
+      sequence: data.lastUpdateId
+    };
+  }
+  const contractSize = await resolveContractSize(symbol, opts);
+  const res = await httpJson({
+    url: `${MEXC_FUTURES_REST}/api/v1/contract/depth/${symbol}?limit=${depth}`,
+    timeoutMs: opts.timeoutMs,
+    transformUrl: opts.transformUrl
+  });
+  if (!res.data) {
+    throw new ExchangeError(
+      "mexc",
+      res.message ? `${res.code}: ${res.message}` : "empty orderbook response"
+    );
+  }
+  return {
+    exchange: "mexc",
+    symbol: fromMexcSymbol(symbol, opts.market),
+    market: opts.market,
+    bids: toFuturesLevels(res.data.bids, contractSize),
+    asks: toFuturesLevels(res.data.asks, contractSize),
+    timestamp: res.data.timestamp ?? Date.now(),
+    sequence: Number(res.data.version ?? 0)
+  };
+}
+
+// src/exchanges/mexc/ws.ts
+var WS_FUTURES5 = "wss://contract.mexc.com/edge";
+var PING_INTERVAL_MS3 = 2e4;
+function streamMexcOrderbook(opts) {
+  if (opts.market !== "perpetual") {
+    throw new Error(
+      `mexc spot streaming requires the protobuf WS feed, which this adapter does not decode \u2014 use fetchOrderbook("${opts.symbol}") for a REST snapshot, or stream the perpetual ("${opts.symbol}:${opts.symbol.split("/")[1]}")`
+    );
+  }
+  const symbol = toMexcSymbol(opts.symbol, opts.market);
+  const unified = fromMexcSymbol(symbol, opts.market);
+  const contractSize = resolveContractSize(symbol, opts);
+  contractSize.catch(() => {
+  });
+  const merger = new BookMerger();
+  let seedVersion = -1;
+  let lastVersion = -1;
+  let snapshotInFlight = false;
+  let snapshotDone = false;
+  let buffered = [];
+  let recovering = false;
+  let scale = 0;
+  let ws = null;
+  const stream = new OrderbookStream(() => ws?.close());
+  const emit = (r) => {
+    const book = {
+      exchange: "mexc",
+      symbol: unified,
+      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;
+    contractSize.then(async (size) => {
+      scale = size;
+      return fetchMexcOrderbook({
+        symbol: opts.symbol,
+        market: opts.market,
+        depth: opts.depth ?? 200,
+        timeoutMs: opts.timeoutMs,
+        transformUrl: opts.transformUrl
+      });
+    }).then((snap) => {
+      seedVersion = 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;
+      lastVersion = -1;
+      const pending2 = buffered;
+      buffered = [];
+      for (const d of pending2) processDelta(d);
+    }).catch((err) => stream.emit("error", err)).finally(() => {
+      snapshotInFlight = false;
+    });
+  };
+  const resync = () => {
+    if (recovering) return;
+    recovering = true;
+    merger.reset();
+    seedVersion = -1;
+    snapshotDone = false;
+    lastVersion = -1;
+    buffered = [];
+    setTimeout(() => {
+      recovering = false;
+      triggerSnapshot();
+    }, 100);
+  };
+  const processDelta = (d) => {
+    const end = Number(d.end ?? d.version ?? 0);
+    const begin = Number(d.begin ?? end);
+    if (end <= seedVersion) return;
+    let prevSequence;
+    if (lastVersion < 0) {
+      if (begin - 1 > seedVersion) {
+        resync();
+        return;
+      }
+      prevSequence = seedVersion;
+    } else {
+      prevSequence = begin - 1;
+    }
+    const r = merger.apply({
+      kind: "delta",
+      bids: toFuturesLevels(d.bids, scale),
+      asks: toFuturesLevels(d.asks, scale),
+      sequence: end,
+      prevSequence,
+      timestamp: d.timestamp ?? d.cts ?? Date.now()
+    });
+    if (r.ok) {
+      lastVersion = end;
+      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.channel === "push.depth") {
+      if (msg.symbol && msg.symbol !== symbol) return;
+      const d = msg.data;
+      if (!d) return;
+      if (!snapshotDone) {
+        buffered.push(d);
+        if (!snapshotInFlight) triggerSnapshot();
+        return;
+      }
+      processDelta(d);
+      return;
+    }
+    if (msg.channel === "rs.error" || msg.channel?.startsWith("rs.error")) {
+      stream.emit("error", new ExchangeError("mexc", String(msg.data)));
+      return;
+    }
+    if (msg.channel === "rs.sub.depth" && msg.data !== "success") {
+      stream.emit(
+        "error",
+        new ExchangeError("mexc", `subscribe rejected: ${String(msg.data)}`)
+      );
+    }
+  };
+  ws = new WSClient({
+    url: WS_FUTURES5,
+    onOpen: (handle) => {
+      merger.reset();
+      seedVersion = -1;
+      snapshotDone = false;
+      lastVersion = -1;
+      buffered = [];
+      handle.send(
+        JSON.stringify({ method: "sub.depth", param: { symbol } })
+      );
+    },
+    onMessage,
+    pingIntervalMs: PING_INTERVAL_MS3,
+    pingPayload: () => JSON.stringify({ method: "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/mexc/index.ts
+var MexcClient = class {
+  exchange = "mexc";
+  transformUrl;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.transformUrl = opts.transformUrl;
+    this.timeoutMs = opts.timeoutMs;
+  }
+  fetchOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return fetchMexcOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      timeoutMs: this.timeoutMs,
+      transformUrl: this.transformUrl
+    });
+  }
+  /** Perpetuals only — see the class note on spot. */
+  streamOrderbook(symbol, opts = {}) {
+    const { pair, market } = parseSymbol(symbol);
+    return streamMexcOrderbook({
+      symbol: pair,
+      market,
+      depth: opts.depth,
+      transformUrl: this.transformUrl,
+      timeoutMs: this.timeoutMs
+    });
+  }
+};
+
+exports.AsterClient = AsterClient;
 exports.Backoff = Backoff;
 exports.BinanceClient = BinanceClient;
 exports.BingxClient = BingxClient;
@@ -3451,6 +3994,7 @@ exports.GateClient = GateClient;
 exports.HyperliquidClient = HyperliquidClient;
 exports.KucoinClient = KucoinClient;
 exports.LighterClient = LighterClient;
+exports.MexcClient = MexcClient;
 exports.OkxClient = OkxClient;
 exports.OrderbookStream = OrderbookStream;
 exports.RateLimitError = RateLimitError;