@blackcube/xgate-sdk 0.20.0

package/dist/index.js

@@ -0,0 +1,1147 @@
+import { Injectable, Module, Logger } from '@nestjs/common';
+import { Aster } from '@blackcube/aster-sdk';
+import { Binance } from '@blackcube/binance-sdk';
+import { Blofin } from '@blackcube/blofin-sdk';
+import { Bullet } from '@blackcube/bullet-sdk';
+import { Bybit } from '@blackcube/bybit-sdk';
+import { Extended } from '@blackcube/extended-sdk';
+import { Hyperliquid } from '@blackcube/hyperliquid-sdk';
+import { Lighter } from '@blackcube/lighter-sdk';
+import { Pacifica } from '@blackcube/pacifica-sdk';
+import { Paradex } from '@blackcube/paradex-sdk';
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+
+// src/enums/timeframe.enums.ts
+var Timeframe = /* @__PURE__ */ ((Timeframe2) => {
+  Timeframe2["M1"] = "1m";
+  Timeframe2["M5"] = "5m";
+  Timeframe2["M15"] = "15m";
+  Timeframe2["H1"] = "1h";
+  Timeframe2["H4"] = "4h";
+  Timeframe2["D"] = "1d";
+  Timeframe2["W"] = "1w";
+  return Timeframe2;
+})(Timeframe || {});
+var TIMEFRAME_MINUTES = {
+  ["1m" /* M1 */]: 1,
+  ["5m" /* M5 */]: 5,
+  ["15m" /* M15 */]: 15,
+  ["1h" /* H1 */]: 60,
+  ["4h" /* H4 */]: 240,
+  ["1d" /* D */]: 1440,
+  ["1w" /* W */]: 10080
+};
+function timeframeMs(timeframe) {
+  return TIMEFRAME_MINUTES[timeframe] * 6e4;
+}
+
+// src/helpers/decimal.ts
+function parse(value) {
+  const trimmed = value.trim();
+  if (/^-?\d+(\.\d+)?$/.test(trimmed) === false) {
+    throw new Error(`D\xE9cimal illisible : "${value}".`);
+  }
+  const dot = trimmed.indexOf(".");
+  if (dot < 0) {
+    return { digits: BigInt(trimmed), scale: 0 };
+  }
+  return {
+    digits: BigInt(trimmed.slice(0, dot) + trimmed.slice(dot + 1)),
+    scale: trimmed.length - dot - 1
+  };
+}
+function format(digits, scale) {
+  const negative = digits < 0n;
+  const plain = (negative === true ? -digits : digits).toString().padStart(scale + 1, "0");
+  const sign = negative === true ? "-" : "";
+  if (scale === 0) {
+    return sign + plain;
+  }
+  const whole = plain.slice(0, plain.length - scale);
+  const fraction = plain.slice(plain.length - scale).replace(/0+$/, "");
+  return fraction === "" ? sign + whole : `${sign + whole}.${fraction}`;
+}
+function addDecimals(left, right) {
+  const a = parse(left);
+  const b = parse(right);
+  const scale = Math.max(a.scale, b.scale);
+  const digits = a.digits * 10n ** BigInt(scale - a.scale) + b.digits * 10n ** BigInt(scale - b.scale);
+  return format(digits, scale);
+}
+function compareDecimals(left, right) {
+  const a = parse(left);
+  const b = parse(right);
+  const scale = Math.max(a.scale, b.scale);
+  const x = a.digits * 10n ** BigInt(scale - a.scale);
+  const y = b.digits * 10n ** BigInt(scale - b.scale);
+  if (x === y) {
+    return 0;
+  }
+  return x > y ? 1 : -1;
+}
+
+// src/helpers/candle-aggregator.ts
+var MONDAY_OFFSET_MS = 4 * 24 * 60 * 60 * 1e3;
+function aggregate(source, target, now = Date.now()) {
+  if (source.length === 0) {
+    return [];
+  }
+  const sourceMs = timeframeMs(source[0]?.interval ?? "1m" /* M1 */);
+  const targetMs = timeframeMs(target);
+  if (targetMs <= sourceMs) {
+    return [];
+  }
+  const offsetMs = target === "1w" /* W */ ? MONDAY_OFFSET_MS : 0;
+  const expected = targetMs / sourceMs;
+  const buckets = /* @__PURE__ */ new Map();
+  const sorted = [...source].sort(
+    (left, right) => left.openedAt.getTime() - right.openedAt.getTime()
+  );
+  for (const candle of sorted) {
+    const start = Math.floor((candle.openedAt.getTime() - offsetMs) / targetMs) * targetMs + offsetMs;
+    const bucket = buckets.get(start);
+    if (bucket === void 0) {
+      buckets.set(start, {
+        sources: 1,
+        candle: {
+          ...candle,
+          interval: target,
+          openedAt: new Date(start),
+          // Dernière milliseconde du créneau, comme les bougies servies par les venues.
+          closedAt: new Date(start + targetMs - 1),
+          derived: true
+        }
+      });
+    } else {
+      bucket.sources += 1;
+      const built = bucket.candle;
+      built.high = compareDecimals(candle.high, built.high) > 0 ? candle.high : built.high;
+      built.low = compareDecimals(candle.low, built.low) < 0 ? candle.low : built.low;
+      built.close = candle.close;
+      built.volume = sum(built.volume, candle.volume);
+      built.quoteVolume = sum(built.quoteVolume, candle.quoteVolume);
+      built.takerBuyQuoteVolume = sum(built.takerBuyQuoteVolume, candle.takerBuyQuoteVolume);
+      built.trades = built.trades === null || candle.trades === null ? null : built.trades + candle.trades;
+    }
+  }
+  return [...buckets.keys()].sort((left, right) => left - right).map((start) => buckets.get(start)).filter((bucket) => bucket !== void 0).filter((bucket) => {
+    const stillOpen = bucket.candle.openedAt.getTime() + targetMs > now;
+    return bucket.sources >= expected || stillOpen === true;
+  }).map((bucket) => bucket.candle);
+}
+function sum(left, right) {
+  if (left === null || right === null) {
+    return null;
+  }
+  return addDecimals(left, right);
+}
+
+// src/helpers/symbol-naming.ts
+var CONCAT_QUOTE_XEXS = /* @__PURE__ */ new Set(["aster", "binance", "bybit"]);
+var K_MULTIPLIER = /^k(?=[A-Z])/u;
+var NUMERIC_MULTIPLIER = /^10{3,}(?=[A-Z0-9])/u;
+var STOCK_24_5 = /_24_5$/u;
+var TICKER_ALIASES = {
+  GOOG: "GOOGL",
+  // classe d'action (extended `GOOG` ≡ `GOOGL` ailleurs)
+  // Indices
+  US500: "SP500",
+  SPX500M: "SP500",
+  TECH100M: "US100",
+  // Matières premières
+  BRENTOIL: "BRENT",
+  NATGAS: "NG",
+  // Actions (USD collé sur lighter, non strippé → aliasé explicitement)
+  SAMSUNGUSD: "SAMSUNG",
+  SKHYNIXUSD: "SKHYNIX",
+  HYUNDAIUSD: "HYUNDAI"
+};
+function canonicalFromXex(rawSymbol, xexId) {
+  let s = rawSymbol.replace(K_MULTIPLIER, "").toUpperCase();
+  if (CONCAT_QUOTE_XEXS.has(xexId)) {
+    s = s.replace(/(USDT|USDC)$/u, "");
+  } else {
+    s = s.replace(/-USD-PERP$/u, "").replace(/-PERP$/u, "").replace(/-USDT$/u, "").replace(/-USDC$/u, "").replace(/-USD$/u, "");
+  }
+  s = s.replace(NUMERIC_MULTIPLIER, "");
+  s = s.replace(STOCK_24_5, "");
+  return TICKER_ALIASES[s] ?? s;
+}
+function canonicalFromBase(base) {
+  const s = base.replace(K_MULTIPLIER, "").toUpperCase().replace(NUMERIC_MULTIPLIER, "").replace(STOCK_24_5, "");
+  return TICKER_ALIASES[s] ?? s;
+}
+
+// src/helpers/candle-mapper.ts
+function toCandle(wire, xex, interval, quote) {
+  return {
+    symbol: canonicalFromXex(wire.symbol, xex),
+    quote,
+    symbolXex: wire.symbol,
+    xex,
+    kind: wire.kind,
+    interval,
+    openedAt: wire.openedAt,
+    closedAt: wire.closedAt,
+    open: wire.open,
+    high: wire.high,
+    low: wire.low,
+    close: wire.close,
+    volume: wire.volume,
+    quoteVolume: wire.quoteVolume,
+    takerBuyQuoteVolume: wire.takerBuyQuoteVolume,
+    trades: wire.trades > 0 ? wire.trades : null,
+    // Servie par la venue, pas fabriquée. L'agrégation posera `true`.
+    derived: false
+  };
+}
+
+// src/helpers/candle-query.ts
+function toXexQuery(query) {
+  return {
+    name: query.symbol,
+    interval: query.interval,
+    startTime: query.startTime,
+    endTime: query.endTime,
+    limit: query.limit
+  };
+}
+
+// src/enums/xgate-ex.enums.ts
+var XgateEx = /* @__PURE__ */ ((XgateEx2) => {
+  XgateEx2["Hyperliquid"] = "hyperliquid";
+  XgateEx2["Pacifica"] = "pacifica";
+  XgateEx2["Aster"] = "aster";
+  XgateEx2["Lighter"] = "lighter";
+  XgateEx2["Extended"] = "extended";
+  XgateEx2["Paradex"] = "paradex";
+  XgateEx2["Bullet"] = "bullet";
+  XgateEx2["Blofin"] = "blofin";
+  XgateEx2["Binance"] = "binance";
+  XgateEx2["Bybit"] = "bybit";
+  return XgateEx2;
+})(XgateEx || {});
+var XGATE_EXCHANGES = Object.values(XgateEx);
+
+// src/helpers/xex-registry.ts
+function createAccountXex(xex, access) {
+  const NULL_KEY = `0x${"0".repeat(64)}`;
+  const adresse = () => {
+    if (access.address === void 0 || access.address === "") {
+      throw new Error(`wallet(${xex}) : il faut au moins une adresse (\`access.address\`).`);
+    }
+    return access.address;
+  };
+  switch (xex) {
+    case "hyperliquid" /* Hyperliquid */:
+      return new Hyperliquid(
+        {
+          a: {
+            privateKey: access.privateKey ?? NULL_KEY,
+            publicKey: adresse(),
+            network: access.network ?? "mainnet"
+          }
+        },
+        { default: "a" }
+      );
+    case "pacifica" /* Pacifica */:
+      return new Pacifica(
+        {
+          a: {
+            secretKey: access.privateKey ?? "",
+            publicKey: adresse(),
+            network: access.network ?? "mainnet"
+          }
+        },
+        { default: "a" }
+      );
+    case "aster" /* Aster */:
+      if (access.privateKey === void 0 || access.privateKey === "") {
+        throw new Error(
+          `wallet(${xex}) : Aster signe avec une cl\xE9 d'API \u2014 il faut \`privateKey\` (la cl\xE9) et \`address\` (le compte EVM).`
+        );
+      }
+      return new Aster(
+        {
+          a: {
+            privateKey: access.privateKey,
+            user: adresse(),
+            network: access.network ?? "mainnet"
+          }
+        },
+        { default: "a" }
+      );
+    case "blofin" /* Blofin */:
+      if (access.apiKey === void 0 || access.secret === void 0) {
+        throw new Error(
+          `wallet(${xex}) : BloFin signe m\xEAme en lecture \u2014 il faut \`apiKey\`, \`secret\` et \`passphrase\`.`
+        );
+      }
+      return new Blofin({
+        credentials: {
+          apiKey: access.apiKey,
+          secret: access.secret,
+          passphrase: access.passphrase ?? ""
+        },
+        network: access.network ?? "mainnet"
+      });
+    default:
+      throw new Error(
+        `wallet(${xex}) : venue pas encore c\xE2bl\xE9e c\xF4t\xE9 compte. Disponibles : ${WALLET_XEXES.join(", ")}.`
+      );
+  }
+}
+var WALLET_XEXES = [
+  "hyperliquid" /* Hyperliquid */,
+  "pacifica" /* Pacifica */,
+  "aster" /* Aster */,
+  "blofin" /* Blofin */
+];
+function createPublicXex(xex) {
+  switch (xex) {
+    case "hyperliquid" /* Hyperliquid */:
+      return new Hyperliquid();
+    case "pacifica" /* Pacifica */:
+      return new Pacifica();
+    case "aster" /* Aster */:
+      return new Aster();
+    case "lighter" /* Lighter */:
+      return new Lighter();
+    case "extended" /* Extended */:
+      return new Extended();
+    case "paradex" /* Paradex */:
+      return new Paradex();
+    case "bullet" /* Bullet */:
+      return new Bullet();
+    case "blofin" /* Blofin */:
+      return new Blofin();
+    case "binance" /* Binance */:
+      return new Binance();
+    case "bybit" /* Bybit */:
+      return new Bybit();
+  }
+}
+var SPOT_XEXES = ["binance" /* Binance */, "bybit" /* Bybit */];
+function servesSpot(xex) {
+  return SPOT_XEXES.includes(xex);
+}
+function createPublicSpotXex(xex) {
+  switch (xex) {
+    case "binance" /* Binance */:
+      return new Binance();
+    case "bybit" /* Bybit */:
+      return new Bybit();
+    default:
+      throw new Error(
+        `spot(${xex}) : cette venue ne sert pas de comptant via XGate. Venues avec spot : ${SPOT_XEXES.join(", ")}.`
+      );
+  }
+}
+
+// src/helpers/xex-timeframes.ts
+var NATIVE = {
+  ["hyperliquid" /* Hyperliquid */]: Object.values(Timeframe),
+  ["pacifica" /* Pacifica */]: Object.values(Timeframe),
+  ["aster" /* Aster */]: Object.values(Timeframe),
+  ["blofin" /* Blofin */]: Object.values(Timeframe),
+  ["lighter" /* Lighter */]: [
+    "1m" /* M1 */,
+    "5m" /* M5 */,
+    "15m" /* M15 */,
+    "1h" /* H1 */,
+    "4h" /* H4 */,
+    "1d" /* D */
+  ],
+  ["extended" /* Extended */]: [
+    "1m" /* M1 */,
+    "5m" /* M5 */,
+    "15m" /* M15 */,
+    "1h" /* H1 */,
+    "4h" /* H4 */,
+    "1d" /* D */
+  ],
+  ["paradex" /* Paradex */]: ["1m" /* M1 */, "5m" /* M5 */, "15m" /* M15 */, "1h" /* H1 */],
+  ["bullet" /* Bullet */]: [],
+  // Les deux CEX servent les sept, et sous les mêmes noms côté binance. Bybit compte en minutes
+  // (`60`, `240`) puis en lettres (`D`, `W`) : son SDK traduit, la table reste dans notre grille.
+  ["binance" /* Binance */]: Object.values(Timeframe),
+  ["bybit" /* Bybit */]: Object.values(Timeframe)
+};
+function servesNatively(xex, interval) {
+  return NATIVE[xex].includes(interval);
+}
+function sourceFor(xex, target) {
+  const targetMinutes = TIMEFRAME_MINUTES[target];
+  const candidates = NATIVE[xex].filter((interval) => {
+    const minutes = TIMEFRAME_MINUTES[interval];
+    return minutes < targetMinutes && targetMinutes % minutes === 0;
+  }).sort((left, right) => TIMEFRAME_MINUTES[right] - TIMEFRAME_MINUTES[left]);
+  return candidates[0];
+}
+
+// src/services/candles.service.ts
+var CandlesService = class {
+  logger = new Logger(CandlesService.name);
+  /**
+   * Les bougies d'une venue, sur une plage de **dates**.
+   *
+   * L'appelant donne des `Date` et un {@link Timeframe} ; le service traduit vers ce que la venue
+   * attend — chaîne UTC pour huit d'entre elles, millisecondes pour blofin.
+   *
+   * **Un intervalle que la venue ne sert pas est FABRIQUÉ**, pas refusé : on tire l'intervalle
+   * exploitable le plus grand et on agrège. Paradex s'arrête à l'heure, lighter et extended ne
+   * font pas la semaine — l'appelant n'a pas à le savoir. Les bougies fabriquées portent
+   * `derived: true`.
+   *
+   * **Lève si la venue ne sert rien du tout** (bullet, qui n'a pas de REST). Rendre une liste vide
+   * ferait passer une incapacité pour une absence de données, et un backfill silencieusement troué
+   * est pire qu'un backfill en erreur.
+   */
+  async candles(xex, query) {
+    if (servesNatively(xex, query.interval) === true) {
+      return this.fetch(xex, query, query.interval);
+    }
+    const source = sourceFor(xex, query.interval);
+    if (source === void 0) {
+      throw new Error(
+        `candles(${xex}) : ni ${query.interval} servi, ni intervalle plus fin pour le fabriquer.`
+      );
+    }
+    this.logger.log(
+      `${xex} ne sert pas ${query.interval} : agr\xE9gation depuis ${source} (bougies d\xE9riv\xE9es).`
+    );
+    const fine = await this.fetch(xex, query, source);
+    return aggregate(fine, query.interval);
+  }
+  /** Un appel REST à la venue, dans l'intervalle qu'elle sait servir. */
+  async fetch(xex, query, interval) {
+    const perp = createPublicXex(xex).perp();
+    if (perp.getCandles === void 0) {
+      throw new Error(
+        `candles(${xex}) : cette venue ne sert pas de bougies en REST \u2014 utilise WsCandlesService.`
+      );
+    }
+    const wires = await perp.getCandles(toXexQuery({ ...query, interval }));
+    return wires.map((wire) => toCandle(wire, xex, interval, this.quoteOf(wire.symbol)));
+  }
+  /**
+   * Les bougies d'un même marché chez PLUSIEURS venues, en une liste.
+   *
+   * Comme pour le catalogue : une venue en échec parmi d'autres est journalisée et ignorée ; seule,
+   * son échec est celui de l'appel. Chaque bougie porte son `xex`, donc la liste reste
+   * exploitable telle quelle.
+   */
+  async candlesOf(xexes, query) {
+    if (xexes.length === 0) {
+      throw new Error("candlesOf() : aucune venue demand\xE9e \u2014 pr\xE9cise au moins un XgateEx.");
+    }
+    const solo = xexes.length === 1;
+    const collected = await Promise.all(
+      xexes.map(async (xex) => {
+        try {
+          return await this.candles(xex, query);
+        } catch (error) {
+          if (solo === true) {
+            throw error;
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          this.logger.error(
+            `candles(${xex}, ${query.interval}) a \xE9chou\xE9, venue ignor\xE9e : ${message}`
+          );
+          return [];
+        }
+      })
+    );
+    return collected.flat();
+  }
+  /**
+   * La cotation, déduite du symbole natif. Les bougies ne la portent pas — seul le catalogue la
+   * publie —, et refaire un appel de catalogue pour chaque série coûterait plus cher que ce
+   * qu'elle apporte. `BTC-USDT` → `USDT` ; à défaut de séparateur, on ne prétend rien.
+   */
+  quoteOf(symbolXex) {
+    const parts = symbolXex.split("-");
+    const last = parts[parts.length - 1];
+    return parts.length > 1 && last !== void 0 ? last : "";
+  }
+};
+CandlesService = __decorateClass([
+  Injectable()
+], CandlesService);
+var NAMES_ITS_BASE = /* @__PURE__ */ new Set(["binance" /* Binance */, "bybit" /* Bybit */]);
+var CatalogService = class {
+  logger = new Logger(CatalogService.name);
+  /**
+   * Le catalogue **perp** d'une ou plusieurs venues, en une seule liste.
+   *
+   * Chaque ligne porte sa venue d'origine (`xex`) et les deux symboles — le canonique pour
+   * rapprocher un actif entre venues, le brut pour parler à celle-ci.
+   *
+   * **Le traitement d'une venue en échec dépend de ce qui a été demandé** : sur une seule venue,
+   * un échec est l'échec de l'appel et il est relancé ; sur plusieurs, la liste partielle garde
+   * sa valeur et l'incident est journalisé. Rendre `[]` en silence serait le pire des deux — un
+   * catalogue vide se lit comme « cette venue ne liste rien », pas comme « je n'ai pas pu
+   * demander ».
+   */
+  async catalog(...xexes) {
+    if (xexes.length === 0) {
+      throw new Error("catalog() : aucune venue demand\xE9e \u2014 pr\xE9cise au moins un XgateEx.");
+    }
+    const solo = xexes.length === 1;
+    const collected = await Promise.all(
+      xexes.map(async (xex) => {
+        try {
+          return await this.catalogOf(xex);
+        } catch (error) {
+          if (solo === true) {
+            throw error;
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          this.logger.error(`catalog(${xex}) a \xE9chou\xE9, venue ignor\xE9e : ${message}`);
+          return [];
+        }
+      })
+    );
+    return collected.flat();
+  }
+  /** Le catalogue d'UNE venue, traduit vers {@link IPair}. */
+  async catalogOf(xex) {
+    const pairs = await createPublicXex(xex).perp().getPairs();
+    return pairs.map((pair) => ({
+      symbol: NAMES_ITS_BASE.has(xex) ? canonicalFromBase(pair.base) : canonicalFromXex(pair.name, xex),
+      quote: pair.quote,
+      symbolXex: pair.name,
+      xex,
+      kind: pair.kind,
+      ref: pair.ref ?? null,
+      szDecimals: pair.szDecimals,
+      tickSize: pair.tickSize,
+      stepSize: pair.stepSize,
+      minQty: pair.minQty,
+      minNotional: pair.minNotional,
+      maxLeverage: pair.maxLeverage,
+      status: pair.status,
+      delisted: pair.delisted,
+      listedAt: pair.listedAt,
+      xtras: pair.xtras
+    }));
+  }
+};
+CatalogService = __decorateClass([
+  Injectable()
+], CatalogService);
+var PricesService = class {
+  logger = new Logger(PricesService.name);
+  /**
+   * Les prix **perp** d'une ou plusieurs venues, en une seule liste.
+   *
+   * **Le traitement d'une venue en échec dépend de ce qui a été demandé** : sur une seule venue, un
+   * échec est l'échec de l'appel et il est relancé ; sur plusieurs, la liste partielle garde sa
+   * valeur et l'incident est journalisé. Rendre `[]` en silence serait le pire des deux — un relevé
+   * vide se lit comme « ce marché ne cote rien », pas comme « je n'ai pas pu demander ».
+   */
+  async prices(...xexes) {
+    if (xexes.length === 0) {
+      throw new Error("prices() : aucune venue demand\xE9e \u2014 pr\xE9cise au moins un XgateEx.");
+    }
+    const solo = xexes.length === 1;
+    const collected = await Promise.all(
+      xexes.map(async (xex) => {
+        try {
+          return await this.pricesOf(xex);
+        } catch (error) {
+          if (solo === true) {
+            throw error;
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          this.logger.error(`prices(${xex}) a \xE9chou\xE9, venue ignor\xE9e : ${message}`);
+          return [];
+        }
+      })
+    );
+    return collected.flat();
+  }
+  /** Les prix d'UNE venue, traduits vers {@link IPrice}. */
+  async pricesOf(xex) {
+    const prices = await createPublicXex(xex).perp().getPrices();
+    return prices.map((price) => ({
+      symbol: canonicalFromXex(price.name, xex),
+      symbolXex: price.name,
+      xex,
+      kind: price.kind,
+      mark: price.mark,
+      oracle: price.oracle,
+      mid: price.mid,
+      bid: price.bid,
+      ask: price.ask,
+      last: price.last,
+      funding: price.funding,
+      openInterest: price.openInterest,
+      volume24h: price.volume24h,
+      prevDayPrice: price.prevDayPrice,
+      quotedAt: price.quotedAt,
+      xtras: price.xtras
+    }));
+  }
+};
+PricesService = __decorateClass([
+  Injectable()
+], PricesService);
+var SpotCatalogService = class {
+  logger = new Logger(SpotCatalogService.name);
+  /** Les venues dont XGate sert le comptant. */
+  venues() {
+    return SPOT_XEXES;
+  }
+  /**
+   * Le catalogue **spot** d'une ou plusieurs venues, en une seule liste.
+   *
+   * Même politique d'échec que le catalogue perpétuel : sur une seule venue, l'échec est relancé ;
+   * sur plusieurs, la liste partielle garde sa valeur et l'incident est journalisé.
+   *
+   * **Une venue sans comptant lève**, elle ne rend pas une liste vide : « cette venue n'a pas de
+   * spot » et « cette venue ne cote rien au comptant » ne se corrigent pas de la même façon.
+   */
+  async catalog(...xexes) {
+    if (xexes.length === 0) {
+      throw new Error("spot catalog() : aucune venue demand\xE9e \u2014 pr\xE9cise au moins un XgateEx.");
+    }
+    const solo = xexes.length === 1;
+    const collected = await Promise.all(
+      xexes.map(async (xex) => {
+        try {
+          return await this.catalogOf(xex);
+        } catch (error) {
+          if (solo === true) {
+            throw error;
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          this.logger.error(`spot catalog(${xex}) a \xE9chou\xE9, venue ignor\xE9e : ${message}`);
+          return [];
+        }
+      })
+    );
+    return collected.flat();
+  }
+  /** Le catalogue comptant d'UNE venue, traduit vers {@link IPair}. */
+  async catalogOf(xex) {
+    if (servesSpot(xex) === false) {
+      throw new Error(`spot catalog(${xex}) : cette venue ne sert pas de comptant via XGate.`);
+    }
+    const pairs = await createPublicSpotXex(xex).spot().getPairs();
+    return pairs.map((pair) => ({
+      // Les deux venues à comptant NOMMENT leur actif de base : on prend ce qu'elles disent. Re-parser
+      // `ROSEBTC` donnerait `ROSEBTC`, le strip de cotation ne connaissant que USDT et USDC — et le
+      // spot se cote massivement en BTC, ETH ou BNB.
+      symbol: canonicalFromBase(pair.base),
+      quote: pair.quote,
+      symbolXex: pair.name,
+      xex,
+      kind: pair.kind,
+      ref: pair.ref ?? null,
+      szDecimals: pair.szDecimals,
+      tickSize: pair.tickSize,
+      stepSize: pair.stepSize,
+      minQty: pair.minQty,
+      minNotional: pair.minNotional,
+      maxLeverage: pair.maxLeverage,
+      status: pair.status,
+      delisted: pair.delisted,
+      listedAt: pair.listedAt,
+      xtras: pair.xtras
+    }));
+  }
+};
+SpotCatalogService = __decorateClass([
+  Injectable()
+], SpotCatalogService);
+
+// src/helpers/protection.ts
+var SLIPPAGE_DEFAUT = 5e-3;
+var SEUIL_CLOTURE = 0.8;
+function round8(value) {
+  return Number(value.toFixed(8));
+}
+function roundToStep(value, step, mode) {
+  if (step === null || step === void 0 || step === "") {
+    return Math.round(value * 1e4) / 1e4;
+  }
+  const stepNum = Number(step);
+  if (Number.isFinite(stepNum) === false || stepNum <= 0) {
+    return Math.round(value * 1e4) / 1e4;
+  }
+  const quotient = value / stepNum;
+  const units = mode === "floor" ? Math.floor(Number(quotient.toFixed(9))) : Math.round(quotient);
+  const dot = step.indexOf(".");
+  const decimals = dot === -1 ? 0 : step.length - dot - 1;
+  return Number((units * stepNum).toFixed(decimals));
+}
+function roundPrice(value, tickSize, lotSize) {
+  if (tickSize !== null && tickSize !== void 0 && tickSize !== "") {
+    return roundToStep(value, tickSize, "nearest");
+  }
+  const dot = (lotSize ?? "").indexOf(".");
+  const szDecimals = dot === -1 ? 0 : lotSize.length - dot - 1;
+  const maxDecimals = 6 - szDecimals;
+  const sig = Number(value.toPrecision(5));
+  if (maxDecimals <= 0) {
+    return Math.round(sig);
+  }
+  return Number(sig.toFixed(maxDecimals));
+}
+function buildLevels(entry, direction, slPct, tpPcts) {
+  const dir = direction === "long" ? 1 : -1;
+  return {
+    sl: round8(entry * (1 - dir * slPct)),
+    tps: tpPcts.map((pct) => round8(entry * (1 + dir * pct)))
+  };
+}
+function buildProtection(input) {
+  const slippage = input.slippagePct ?? SLIPPAGE_DEFAUT;
+  const long = input.direction === "long";
+  const { sl, tps: niveaux } = buildLevels(
+    input.entry,
+    input.direction,
+    input.slPct,
+    input.tps.map((tp) => tp.pct)
+  );
+  const borne = (trigger) => long === true ? trigger * (1 - slippage) : trigger * (1 + slippage);
+  const sommeParts = input.tps.reduce((total, tp) => total + tp.part, 0);
+  const clotureIntegrale = sommeParts > SEUIL_CLOTURE;
+  const legs = [];
+  let alloue = 0;
+  niveaux.forEach((trigger, index) => {
+    const dernier = index === niveaux.length - 1;
+    const part = input.tps[index]?.part ?? 0;
+    if (dernier === false && part <= 0) {
+      return;
+    }
+    const size = dernier === true && clotureIntegrale === true ? roundToStep(input.size - alloue, input.lotSize, "floor") : roundToStep(part * input.size, input.lotSize, "floor");
+    if (size <= 0) {
+      return;
+    }
+    alloue += size;
+    legs.push({
+      triggerPrice: String(roundPrice(trigger, input.tickSize, input.lotSize)),
+      size: String(size),
+      price: String(roundPrice(borne(trigger), input.tickSize, input.lotSize))
+    });
+  });
+  return {
+    sl: {
+      triggerPrice: String(roundPrice(sl, input.tickSize, input.lotSize)),
+      // Taille PLEINE, toujours : le stop couvre l'intégralité de la position.
+      size: String(input.size),
+      price: String(roundPrice(borne(sl), input.tickSize, input.lotSize))
+    },
+    tps: legs
+  };
+}
+
+// src/interfaces/trading.interfaces.ts
+var ORDER_STATUSES = [
+  "open",
+  "partiallyFilled",
+  "filled",
+  "canceled",
+  "rejected",
+  "expired",
+  "other"
+];
+
+// src/services/trading.service.ts
+var VENUES_PROUVEES = ["pacifica" /* Pacifica */, "hyperliquid" /* Hyperliquid */];
+var TradingService = class {
+  logger = new Logger(TradingService.name);
+  /**
+   * OUVRE UNE POSITION AVEC SA PROTECTION, en un geste atomique.
+   *
+   * Le premier ordre rendu est **l'entrée** ; les suivants sont le stop et les take-profits, dans
+   * l'ordre où ils ont été posés.
+   *
+   * Chaque venue applique son mécanisme natif — hyperliquid groupe les enfants sous l'entrée et les
+   * annule lui-même si elle rate, pacifica les embarque dans l'ordre, aster envoie un lot de
+   * conditionnels. Le SDK de la venue s'en charge ; xgate fournit des niveaux justes.
+   */
+  async openWithProtection(access, input) {
+    if (VENUES_PROUVEES.includes(access.xex) === false) {
+      throw new Error(
+        `openWithProtection(${access.xex}) : l'ouverture prot\xE9g\xE9e n'a pas \xE9t\xE9 prouv\xE9e en r\xE9el sur cette venue. Seules ${VENUES_PROUVEES.join(", ")} le sont. Ouvrir ici reviendrait \xE0 parier qu'un chemin jamais exerc\xE9 pose bien le stop.`
+      );
+    }
+    const protection = buildProtection({
+      entry: input.entry,
+      direction: input.direction,
+      size: input.size,
+      slPct: input.slPct,
+      tps: input.tps,
+      tickSize: input.tickSize,
+      lotSize: input.lotSize,
+      slippagePct: input.slippagePct
+    });
+    const side = input.direction === "long" ? "buy" : "sell";
+    const perp = this.perpOf(access);
+    if (typeof perp.createEntryWithProtection !== "function") {
+      throw new Error(
+        `openWithProtection(${access.xex}) : cette venue n'expose pas l'ouverture prot\xE9g\xE9e atomique.`
+      );
+    }
+    const orders = await perp.createEntryWithProtection(
+      {
+        name: input.symbolXex,
+        side,
+        type: "limit",
+        size: String(input.size),
+        price: String(input.entry),
+        tif: input.tif ?? "ioc",
+        reduceOnly: false,
+        clientId: input.clientId
+      },
+      {
+        name: input.symbolXex,
+        side,
+        sl: protection.sl,
+        tps: protection.tps,
+        clientId: input.clientId
+      }
+    );
+    return orders.map((order) => this.toOrder(order, access.xex));
+  }
+  /** Les positions ouvertes d'un compte. */
+  async positions(access, symbolXex) {
+    const perp = this.perpOf(access);
+    const positions = await perp.getPositions(
+      symbolXex === void 0 ? void 0 : { name: symbolXex }
+    );
+    return positions.map((position) => ({
+      xex: access.xex,
+      symbolXex: position.name,
+      symbol: canonicalFromXex(position.name, access.xex),
+      side: position.side,
+      size: position.size,
+      entryPrice: position.entryPrice,
+      markPrice: position.markPrice,
+      unrealizedPnl: position.unrealizedPnl,
+      leverage: position.leverage,
+      liquidationPrice: position.liquidationPrice,
+      margin: position.margin,
+      xtras: position.xtras
+    }));
+  }
+  /** Les ordres encore au carnet. */
+  async openOrders(access) {
+    const orders = await this.perpOf(access).getOpens();
+    return orders.map((order) => this.toOrder(order, access.xex));
+  }
+  /**
+   * Les exécutions du compte — ce qui a réellement été rempli.
+   *
+   * À ne pas confondre avec les ordres : un ordre annoncé `filled` peut avoir été rempli en
+   * plusieurs fois, à des prix différents. C'est ici que se lit le prix moyen réel.
+   */
+  async trades(access) {
+    const trades = await this.perpOf(access).getUserTrades();
+    return trades.map((trade) => ({
+      xex: access.xex,
+      symbolXex: trade.name,
+      kind: trade.kind,
+      id: trade.id,
+      orderId: trade.orderId,
+      side: trade.side,
+      price: trade.price,
+      size: trade.size,
+      fee: trade.fee,
+      feeAsset: trade.feeAsset,
+      grossPnl: trade.grossPnl,
+      netPnl: trade.netPnl,
+      maker: trade.maker,
+      filledAt: trade.filledAt,
+      xtras: trade.xtras
+    }));
+  }
+  /**
+   * FERME UNE POSITION ENTIÈREMENT, sur la taille que **la venue** déclare — jamais celle qu'on croit.
+   *
+   * C'est toute la différence : fermer la taille planifiée laisse un reliquat quand le fill a différé du
+   * plan (une entrée partiellement remplie, un take-profit passé entre-temps), et ce reliquat reste
+   * ouvert, sans stop, à la charge du compte. On relit donc la position juste avant de la fermer.
+   *
+   * Rend `null` quand il n'y a rien à fermer — un appel sur une position déjà close n'est pas une erreur.
+   */
+  async closePosition(access, symbolXex) {
+    const perp = this.perpOf(access);
+    const positions = await perp.getPositions({ name: symbolXex });
+    const position = positions.find(
+      (candidate) => candidate.name === symbolXex && Number(candidate.size) !== 0
+    );
+    let closed = null;
+    if (position !== void 0) {
+      const exit = position.side === "long" ? "sell" : "buy";
+      const order = await perp.place({
+        name: symbolXex,
+        side: exit,
+        type: "market",
+        size: position.size,
+        reduceOnly: true
+      });
+      closed = this.toOrder(order, access.xex);
+      this.logger.log(
+        `closePosition(${access.xex}/${symbolXex}) : ${position.size} ferm\xE9 au march\xE9`
+      );
+    }
+    return closed;
+  }
+  /**
+   * LE PRIX DE SORTIE RÉEL d'une position, lu dans l'historique de la venue.
+   *
+   * Le prix planifié ne dit pas à quel prix on est sorti : un stop se déclenche au marché, un
+   * take-profit peut remplir en plusieurs fois. Seul l'historique porte le prix réellement obtenu, et
+   * c'est lui qui doit servir au calcul du résultat — sinon le PnL affiché est une fiction.
+   *
+   * On retient le **dernier** ordre de sortie rempli après `openedAt` : les précédents sont les
+   * take-profits partiels, celui-là est la clôture.
+   */
+  async exitPrice(access, symbolXex, direction, openedAt) {
+    const exit = direction === "long" ? "sell" : "buy";
+    const history = await this.perpOf(access).getHistory({ name: symbolXex });
+    const exits = history.filter((order) => order.name === symbolXex && order.side === exit).filter((order) => order.status === "filled" || order.status === "partiallyFilled").filter((order) => order.placedAt.getTime() > openedAt.getTime()).filter((order) => order.price !== null && Number(order.price) > 0).sort((left, right) => right.placedAt.getTime() - left.placedAt.getTime());
+    const last = exits[0];
+    return last === void 0 ? null : last.price;
+  }
+  /** Annule un ordre par son identifiant de venue. */
+  async cancel(access, symbolXex, orderId) {
+    await this.perpOf(access).cancel({ name: symbolXex, id: orderId });
+  }
+  /** Le scope `perp()` de la venue, typé au plus près de ce que le contrat commun garantit. */
+  perpOf(access) {
+    const source = createAccountXex(access.xex, access);
+    return source.perp();
+  }
+  /**
+   * Le statut de la venue, VALIDÉ — jamais casté. Une venue qui inventerait un statut rendrait sinon
+   * une valeur absente de tous les `switch` en aval, et personne ne la rattraperait.
+   */
+  toStatus(status) {
+    return ORDER_STATUSES.includes(status) === true ? status : "other";
+  }
+  toOrder(order, xex) {
+    return {
+      xex,
+      symbolXex: order.name,
+      kind: order.kind,
+      id: order.id,
+      clientId: order.clientId,
+      side: order.side,
+      type: order.type,
+      price: order.price,
+      size: order.size,
+      filled: order.filled,
+      status: this.toStatus(order.status),
+      tif: order.tif,
+      reduceOnly: order.reduceOnly,
+      placedAt: order.placedAt,
+      xtras: order.xtras
+    };
+  }
+};
+TradingService = __decorateClass([
+  Injectable()
+], TradingService);
+var WalletService = class {
+  logger = new Logger(WalletService.name);
+  /** Les venues dont le portefeuille est lisible aujourd'hui. */
+  venues() {
+    return WALLET_XEXES;
+  }
+  /**
+   * Les soldes d'un ou plusieurs comptes.
+   *
+   * Même politique d'échec que les autres services : sur un seul accès, l'échec est relancé ; sur
+   * plusieurs, la liste partielle garde sa valeur et l'incident est journalisé. Rendre `[]` en
+   * silence ferait passer une venue injoignable pour un compte vide — et un compte vide, ça se
+   * regarde autrement qu'une panne.
+   */
+  async balances(...accesses) {
+    return this.collect(accesses, "balances", async (access) => {
+      const balances = await createAccountXex(access.xex, access).account().getBalances();
+      return balances.map((balance) => ({
+        xex: access.xex,
+        asset: balance.asset,
+        total: balance.total,
+        available: balance.available,
+        usdValue: balance.usdValue,
+        xtras: balance.xtras
+      }));
+    });
+  }
+  /**
+   * Les mouvements d'argent, triés du plus ancien au plus récent, montants **signés**.
+   *
+   * **Lève si la venue ne les sert pas** plutôt que de rendre une liste vide : « cette venue
+   * n'expose pas son historique » et « ce compte n'a jamais bougé » appellent des suites très
+   * différentes.
+   */
+  async movements(...accesses) {
+    const collected = await this.collect(accesses, "movements", async (access) => {
+      const account = createAccountXex(access.xex, access).account();
+      if (account.getMovements === void 0) {
+        throw new Error(`movements(${access.xex}) : cette venue n'expose pas ses mouvements.`);
+      }
+      const movements = await account.getMovements();
+      return movements.map((movement) => ({
+        xex: access.xex,
+        kind: movement.kind,
+        amount: movement.amount,
+        fee: movement.fee,
+        asset: movement.asset,
+        occurredAt: movement.occurredAt,
+        status: movement.status,
+        externalId: movement.externalId,
+        xtras: movement.xtras
+      }));
+    });
+    return collected.sort((left, right) => left.occurredAt.getTime() - right.occurredAt.getTime());
+  }
+  /**
+   * La valeur du compte dans le temps.
+   *
+   * **Seules hyperliquid et pacifica la publient**, et XGate ne la fabrique pas ailleurs :
+   * reconstituer une courbe depuis les mouvements et les prix donnerait une valeur qu'aucune venue
+   * n'a cotée, avec une méthode incomparable à celle des deux qui la publient. Lève sur une venue
+   * qui n'en sert pas.
+   */
+  async equityHistory(...accesses) {
+    const collected = await this.collect(accesses, "equityHistory", async (access) => {
+      const account = createAccountXex(access.xex, access).account();
+      if (account.getEquityHistory === void 0) {
+        throw new Error(
+          `equityHistory(${access.xex}) : cette venue ne publie pas la valeur de compte dans le temps.`
+        );
+      }
+      const points = await account.getEquityHistory();
+      return points.map((point) => ({
+        xex: access.xex,
+        measuredAt: point.measuredAt,
+        equity: point.equity
+      }));
+    });
+    return collected.sort((left, right) => left.measuredAt.getTime() - right.measuredAt.getTime());
+  }
+  /** Le motif commun aux trois lectures : un accès seul relance, plusieurs journalisent. */
+  async collect(accesses, capacite, lire) {
+    if (accesses.length === 0) {
+      throw new Error(`${capacite}() : aucun acc\xE8s fourni \u2014 pr\xE9cise au moins une venue.`);
+    }
+    const solo = accesses.length === 1;
+    const collected = await Promise.all(
+      accesses.map(async (access) => {
+        try {
+          return await lire(access);
+        } catch (error) {
+          if (solo === true) {
+            throw error;
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          this.logger.error(`${capacite}(${access.xex}) a \xE9chou\xE9, venue ignor\xE9e : ${message}`);
+          return [];
+        }
+      })
+    );
+    return collected.flat();
+  }
+};
+WalletService = __decorateClass([
+  Injectable()
+], WalletService);
+var WsCandlesService = class {
+  logger = new Logger(WsCandlesService.name);
+  /**
+   * Souscrit aux bougies d'un marché chez une venue. Rend la fonction de désabonnement.
+   *
+   * Le handler reçoit **une bougie à la fois**, au format unifié — c'est la forme commune aux neuf
+   * SDK. La bougie en cours est repoussée à chaque mise à jour tant qu'elle n'est pas close ;
+   * `closedAt` dit jusqu'où elle porte.
+   *
+   * **Attention à extended** : sur un intervalle qu'elle ne connaît pas, sa façade rend un
+   * désabonnement vide au lieu de lever. L'appelant se croit abonné et n'entend jamais rien — un
+   * silence indiscernable d'un marché sans échange. C'est un défaut du SDK, pas d'XGate, et il est
+   * dans la file des corrections.
+   */
+  subscribe(xex, query, handler) {
+    const quote = this.quoteOf(query.symbol);
+    this.logger.log(`souscription bougies ${query.symbol} ${query.interval} sur ${xex}`);
+    return createPublicXex(xex).ws().subscribeCandles({ name: query.symbol, interval: query.interval }, (wire) => {
+      handler(toCandle(wire, xex, query.interval, quote));
+    });
+  }
+  /**
+   * Souscrit au MÊME marché chez plusieurs venues, avec un seul handler.
+   *
+   * Chaque bougie porte son `xex` : l'appelant sait toujours qui parle. La fonction rendue coupe
+   * tous les flux d'un coup — sinon il faudrait en garder N et n'en oublier aucun.
+   */
+  subscribeAll(xexes, query, handler) {
+    if (xexes.length === 0) {
+      throw new Error("subscribeAll() : aucune venue demand\xE9e \u2014 pr\xE9cise au moins un XgateEx.");
+    }
+    const stops = [];
+    for (const xex of xexes) {
+      try {
+        stops.push(this.subscribe(xex, query, handler));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`souscription ${xex} refus\xE9e, venue ignor\xE9e : ${message}`);
+      }
+    }
+    return () => {
+      for (const stop of stops) {
+        stop();
+      }
+    };
+  }
+  /** Voir `CandlesService.quoteOf` : la cotation se déduit du symbole natif, faute d'être publiée. */
+  quoteOf(symbolXex) {
+    const parts = symbolXex.split("-");
+    const last = parts[parts.length - 1];
+    return parts.length > 1 && last !== void 0 ? last : "";
+  }
+};
+WsCandlesService = __decorateClass([
+  Injectable()
+], WsCandlesService);
+
+// src/xgate.module.ts
+var XgateModule = class {
+};
+XgateModule = __decorateClass([
+  Module({
+    providers: [
+      CatalogService,
+      CandlesService,
+      WsCandlesService,
+      PricesService,
+      SpotCatalogService,
+      WalletService
+    ],
+    exports: [
+      CatalogService,
+      CandlesService,
+      WsCandlesService,
+      PricesService,
+      SpotCatalogService,
+      WalletService
+    ]
+  })
+], XgateModule);
+
+export { CandlesService, CatalogService, ORDER_STATUSES, PricesService, SPOT_XEXES, SpotCatalogService, TIMEFRAME_MINUTES, Timeframe, TradingService, WALLET_XEXES, WalletService, WsCandlesService, XGATE_EXCHANGES, XgateEx, XgateModule, buildLevels, buildProtection, canonicalFromBase, canonicalFromXex, roundPrice, roundToStep, servesNatively, servesSpot, sourceFor, timeframeMs };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map