@blackcube/xgate-sdk 0.22.0 → 0.24.0

package/dist/index.js

@@ -9,6 +9,7 @@ import { Hyperliquid } from '@blackcube/hyperliquid-sdk';
 import { Lighter } from '@blackcube/lighter-sdk';
 import { Pacifica } from '@blackcube/pacifica-sdk';
 import { Paradex } from '@blackcube/paradex-sdk';
+import { randomUUID } from 'crypto';
 
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -19,131 +20,6 @@ var __decorateClass = (decorators, target, key, kind) => {
   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;
@@ -219,15 +95,13 @@ function toCandle(wire, xex, interval, quote) {
   };
 }
 
-// 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/helpers/ws-limits.ts
+var WS_SUBSCRIPTION_LIMITS = {
+  aster: 200,
+  hyperliquid: 1e3
+};
+function subscriptionLimitOf(xex) {
+  return WS_SUBSCRIPTION_LIMITS[xex];
 }
 
 // src/enums/xgate-ex.enums.ts
@@ -375,6 +249,282 @@ function createPublicSpotXex(xex) {
   }
 }
 
+// src/services/candles-stream.service.ts
+var CandlesStreamService = class {
+  constructor(xex, kind = "perp") {
+    this.xex = xex;
+    this.kind = kind;
+    this.logger = new Logger(`CandlesStream:${xex}${kind === "spot" ? ":spot" : ""}`);
+    this.maxSubscriptions = subscriptionLimitOf(xex) ?? null;
+  }
+  xex;
+  kind;
+  logger;
+  source = null;
+  unsubscribes = [];
+  /** Le plafond de souscriptions documenté par la venue, ou `null` si personne ne l'a publié. */
+  maxSubscriptions;
+  /**
+   * Ouvre le flux sur une LISTE de marchés, sur une seule socket.
+   *
+   * **UNE ERREUR DE FLUX COUPE TOUT, PUIS LÈVE.** Elle n'arrive pas à la souscription : mesuré le
+   * 2026-08-07, la venue accepte un symbole inconnu sans broncher, puis ferme la connexion en le
+   * découvrant. Le SDK reconnecte, elle referme — cinq cycles en douze secondes, et sur une socket
+   * partagée **tous** les marchés valides cessent de recevoir, en silence.
+   *
+   * On refuse cette boucle : à la première erreur, les souscriptions sont coupées, l'incident est
+   * journalisé en `error`, et l'exception part. Un flux à moitié mort qui se tait coûte plus cher
+   * qu'un arrêt franc — on ne découvre le premier qu'en constatant l'absence de données.
+   *
+   * ⚠️ L'exception naît dans un rappel de socket : elle ne remonte pas à l'appelant de `start()`,
+   * elle sort en erreur non capturée. C'est délibéré — elle doit être impossible à ignorer.
+   *
+   * **binance et bybit ne remontent pas encore leurs erreurs** : leur client gère la fermeture en
+   * interne sans l'exposer. Sur ces deux venues, la boucle silencieuse reste possible.
+   */
+  start(symbolsXex, interval, onCandle) {
+    const ws = this.wire();
+    if ("onError" in ws) {
+      ws.onError = (error) => {
+        const raison = lisible(error);
+        this.logger.error(`${this.xex} : erreur de flux \u2014 ${raison}. Souscriptions coup\xE9es.`);
+        this.stop();
+        throw new Error(`stream(${this.xex}) : flux interrompu \u2014 ${raison}`);
+      };
+    }
+    for (const symbolXex of symbolsXex) {
+      this.unsubscribes.push(
+        ws.subscribeCandles({ name: symbolXex, interval }, (wire) => {
+          onCandle(toCandle(wire, this.xex, interval, this.quoteOf(symbolXex)));
+        })
+      );
+    }
+    this.logger.log(`${this.unsubscribes.length}/${symbolsXex.length} souscription(s) ouvertes`);
+  }
+  /** Coupe tout. Un désabonnement qui échoue ne doit pas empêcher les autres de se fermer. */
+  stop() {
+    for (const unsubscribe of this.unsubscribes.splice(0)) {
+      try {
+        unsubscribe();
+      } catch {
+      }
+    }
+  }
+  /** Le nombre de souscriptions ouvertes. La liste des désabonnements EST le compteur. */
+  subscriptionCount() {
+    return this.unsubscribes.length;
+  }
+  /**
+   * Le client temps réel, sur le bon marché.
+   *
+   * Les deux contrats ne signent pas `ws()` pareil, et c'est voulu : côté comptant le marché est
+   * **obligatoire** (`ws('spot')`), parce que les façades ouvrent du perpétuel par défaut — un
+   * `ws()` nu y diffuserait des prix de perpétuel à qui croit écouter le comptant.
+   */
+  wire() {
+    const source = this.instance();
+    return this.kind === "spot" ? source.ws("spot") : source.ws();
+  }
+  /** La façade de la venue, créée une seule fois : c'est elle qui porte la socket partagée. */
+  instance() {
+    if (this.source === null) {
+      if (this.kind === "spot" && servesSpot(this.xex) === false) {
+        throw new Error(`stream(${this.xex}) : cette venue ne sert pas de comptant.`);
+      }
+      this.source = this.kind === "spot" ? createPublicSpotXex(this.xex) : createPublicXex(this.xex);
+    }
+    return this.source;
+  }
+  /** 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 : "";
+  }
+};
+var CandlesStreamRegistry = class {
+  streams = /* @__PURE__ */ new Map();
+  /** Le flux d'une venue, créé au premier appel puis réutilisé. */
+  of(xex, kind = "perp") {
+    const cle = `${xex}:${kind}`;
+    let stream = this.streams.get(cle);
+    if (stream === void 0) {
+      stream = new CandlesStreamService(xex, kind);
+      this.streams.set(cle, stream);
+    }
+    return stream;
+  }
+  /** Coupe tous les flux ouverts, toutes venues confondues. */
+  stopAll() {
+    for (const stream of this.streams.values()) {
+      stream.stop();
+    }
+  }
+  /** Ce qui est ouvert, par venue — pour surveiller sans avoir à tenir de compteur soi-même. */
+  counts() {
+    const total = {};
+    for (const [cle, stream] of this.streams) {
+      total[cle] = stream.subscriptionCount();
+    }
+    return total;
+  }
+};
+CandlesStreamRegistry = __decorateClass([
+  Injectable()
+], CandlesStreamRegistry);
+function lisible(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  const event = error;
+  if (event !== null && typeof event === "object") {
+    const message = event.message ?? event.error?.message;
+    if (typeof message === "string" && message !== "") {
+      return message;
+    }
+    if (typeof event.type === "string" && event.type !== "") {
+      return `\xE9v\xE9nement \xAB ${event.type} \xBB`;
+    }
+  }
+  return String(error);
+}
+
+// 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/candle-query.ts
+function toXexQuery(query) {
+  return {
+    name: query.symbol,
+    interval: query.interval,
+    startTime: query.startTime,
+    endTime: query.endTime,
+    limit: query.limit
+  };
+}
+
 // src/helpers/xex-timeframes.ts
 var HYPERLIQUID_NATIVE = Object.values(Timeframe).filter(
   (interval) => interval !== "1w" /* W */
@@ -793,9 +943,136 @@ var SpotCatalogService = class {
     }));
   }
 };
-SpotCatalogService = __decorateClass([
+SpotCatalogService = __decorateClass([
+  Injectable()
+], SpotCatalogService);
+var SpotPricesService = class {
+  logger = new Logger(SpotPricesService.name);
+  /** Les venues dont XGate sert les prix comptant. */
+  venues() {
+    return SPOT_XEXES;
+  }
+  /**
+   * Les prix comptant d'une ou plusieurs venues, en une seule liste.
+   *
+   * Même politique d'échec que partout : seule, une venue en échec fait échouer l'appel ; parmi
+   * d'autres, elle est journalisée et ignorée. Chaque prix porte son `xex`.
+   */
+  async prices(...xexes) {
+    if (xexes.length === 0) {
+      throw new Error("spot 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(`spot prices(${xex}) a \xE9chou\xE9, venue ignor\xE9e : ${message}`);
+          return [];
+        }
+      })
+    );
+    return collected.flat();
+  }
+  /** Les prix comptant d'UNE venue, traduits vers {@link IPrice}. */
+  async pricesOf(xex) {
+    if (servesSpot(xex) === false) {
+      throw new Error(
+        `spot prices(${xex}) : cette venue ne sert pas de comptant. Disponibles : ${SPOT_XEXES.join(", ")}.`
+      );
+    }
+    const spot = createPublicSpotXex(xex).spot();
+    if (spot.getPrices === void 0) {
+      throw new Error(`spot prices(${xex}) : cette venue ne sert pas de prix comptant.`);
+    }
+    const prices = await spot.getPrices();
+    return prices.map((price) => ({
+      // `canonicalFromXex`, et non `canonicalFromBase` : les prix ne portent QUE le symbole
+      // concaténé (`BTCUSDT`), jamais la base — contrairement au catalogue, où la venue déclare
+      // `baseAsset`. Passer le symbole à `canonicalFromBase` rendrait `BTCUSDT` tel quel, puisque
+      // cette fonction ne strippe volontairement aucune cotation.
+      //
+      // ⚠️ La limite est connue et assumée : le strip ne retire que `USDT`/`USDC` finaux, donc une
+      // paire cotée en BTC (`ROSEBTC`, `ETHBTC`) garde son nom entier. Le catalogue comptant, lui,
+      // résout ces cas — c'est là qu'il faut aller chercher `symbol` et `quote` justes.
+      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
+    }));
+  }
+};
+SpotPricesService = __decorateClass([
   Injectable()
-], SpotCatalogService);
+], SpotPricesService);
+var SpotWsCandlesService = class {
+  logger = new Logger(SpotWsCandlesService.name);
+  /** Les venues dont XGate diffuse le comptant en temps réel. */
+  venues() {
+    return SPOT_XEXES;
+  }
+  /**
+   * Souscrit aux bougies **comptant** d'un marché. Rend la fonction de désabonnement.
+   *
+   * Le handler reçoit une bougie à la fois, au format unifié ; la bougie en cours est repoussée à
+   * chaque mise à jour tant qu'elle n'est pas close.
+   */
+  subscribe(xex, query, handler) {
+    if (servesSpot(xex) === false) {
+      throw new Error(
+        `spot subscribe(${xex}) : cette venue ne sert pas de comptant. Disponibles : ${SPOT_XEXES.join(", ")}.`
+      );
+    }
+    this.logger.log(`souscription bougies COMPTANT ${query.symbol} ${query.interval} sur ${xex}`);
+    return createPublicSpotXex(xex).ws("spot").subscribeCandles({ name: query.symbol, interval: query.interval }, (wire) => {
+      handler(toCandle(wire, xex, query.interval, ""));
+    });
+  }
+  /**
+   * Souscrit au MÊME marché comptant chez plusieurs venues, avec un seul handler.
+   *
+   * Chaque bougie porte son `xex`. La fonction rendue coupe tous les flux d'un coup.
+   */
+  subscribeAll(xexes, query, handler) {
+    if (xexes.length === 0) {
+      throw new Error("spot 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 comptant ${xex} refus\xE9e, venue ignor\xE9e : ${message}`);
+      }
+    }
+    return () => {
+      for (const stop of stops) {
+        stop();
+      }
+    };
+  }
+};
+SpotWsCandlesService = __decorateClass([
+  Injectable()
+], SpotWsCandlesService);
 
 // src/helpers/protection.ts
 var SLIPPAGE_DEFAUT = 5e-3;
@@ -891,7 +1168,8 @@ var ORDER_STATUSES = [
 ];
 
 // src/services/trading.service.ts
-var VENUES_PROUVEES = ["pacifica" /* Pacifica */, "hyperliquid" /* Hyperliquid */];
+var VENUES_PROUVEES = ["pacifica" /* Pacifica */, "hyperliquid" /* Hyperliquid */, "aster" /* Aster */];
+var ASTER_TIMEOUT = "The request has timed out.";
 var VENUES_MOVE_STOP = ["hyperliquid" /* Hyperliquid */, "pacifica" /* Pacifica */, "aster" /* Aster */];
 var TradingService = class {
   logger = new Logger(TradingService.name);
@@ -928,26 +1206,76 @@ var TradingService = class {
         `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
+    const entry = {
+      name: input.symbolXex,
+      side,
+      type: "limit",
+      size: String(input.size),
+      price: String(input.entry),
+      tif: input.tif ?? "ioc",
+      reduceOnly: false,
+      clientId: input.clientId
+    };
+    const consigne = {
+      name: input.symbolXex,
+      side,
+      sl: protection.sl,
+      tps: protection.tps,
+      clientId: input.clientId
+    };
+    try {
+      const orders = await perp.createEntryWithProtection(entry, consigne);
+      return orders.map((order) => this.toOrder(order, access.xex));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes(ASTER_TIMEOUT) === false) {
+        throw error;
       }
+      this.logger.warn(
+        `openWithProtection(${access.xex}) : la venue a coup\xE9 avant de r\xE9pondre. Statut inconnu \u2014 relecture de l'\xE9tat r\xE9el.`
+      );
+      return await this.etatApres(access, input.symbolXex);
+    }
+  }
+  /**
+   * CE QUE LA VENUE A RÉELLEMENT FAIT, après une réponse perdue.
+   *
+   * Un timeout ne dit pas « rien n'a été créé » : mesuré sur aster, deux exécutions identiques ont
+   * produit deux sous-ensembles différents — une fois le stop et un take-profit, une fois l'entrée
+   * seule. La seule vérité est au carnet, donc on va l'y chercher.
+   *
+   * **Lève si la position est nue** : une entrée remplie sans stop est exactement ce que ce service
+   * existe pour empêcher, et le silence serait pire que l'erreur. L'appelant doit savoir qu'il a une
+   * position à protéger, tout de suite.
+   */
+  async etatApres(access, symbolXex) {
+    const perp = this.perpOf(access);
+    const [ouverts, positions] = await Promise.all([
+      perp.getOpens(),
+      perp.getPositions({ name: symbolXex })
+    ]);
+    const surLaPaire = ouverts.filter((order) => order.name === symbolXex);
+    const position = positions.find(
+      (candidate) => candidate.name === symbolXex && Number(candidate.size) !== 0
     );
-    return orders.map((order) => this.toOrder(order, access.xex));
+    const protege = surLaPaire.some((order) => order.reduceOnly === true);
+    if (position !== void 0 && protege === false) {
+      throw new Error(
+        `openWithProtection(${access.xex}/${symbolXex}) : POSITION NUE \u2014 ${position.size} ouvert sans stop au carnet apr\xE8s une r\xE9ponse perdue. \xC0 prot\xE9ger imm\xE9diatement.`
+      );
+    }
+    if (position === void 0 && surLaPaire.length > 0) {
+      for (const orphelin of surLaPaire) {
+        await perp.cancel({ name: symbolXex, id: orphelin.id }).catch(() => void 0);
+      }
+      throw new Error(
+        `openWithProtection(${access.xex}/${symbolXex}) : r\xE9ponse perdue, lot incomplet \u2014 ${surLaPaire.length} ordre(s) orphelin(s) ANNUL\xC9(S). Rien n'est ouvert, rien ne tra\xEEne.`
+      );
+    }
+    this.logger.log(
+      `openWithProtection(${access.xex}/${symbolXex}) : ${surLaPaire.length} ordre(s) au carnet, position ${position === void 0 ? "absente" : position.size}.`
+    );
+    return surLaPaire.map((order) => this.toOrder(order, access.xex));
   }
   /** Les positions ouvertes d'un compte. */
   async positions(access, symbolXex) {
@@ -1089,6 +1417,193 @@ var TradingService = class {
     const last = exits[0];
     return last === void 0 ? null : last.price;
   }
+  /**
+   * L'HISTORIQUE DES ORDRES du compte — ce qui a été soumis, rempli, annulé ou expiré.
+   *
+   * À distinguer de {@link trades} : un ordre est une **intention**, une exécution est un **fait**.
+   * Un ordre `filled` peut avoir été rempli en plusieurs fois, à des prix différents.
+   *
+   * Servi par les huit venues qui tradent.
+   */
+  async orderHistory(access, symbolXex) {
+    const orders = await this.perpOf(access).getHistory(
+      symbolXex === void 0 ? void 0 : { name: symbolXex }
+    );
+    return orders.map((order) => this.toOrder(order, access.xex));
+  }
+  /**
+   * L'ÉTAT DU COMPTE — équité, disponible, marge immobilisée, marge de maintenance, PnL latent.
+   *
+   * Les venues rangent ces valeurs sous des noms qui n'ont rien à voir : `marginSummary.accountValue`
+   * chez hyperliquid, `accountEquity` chez pacifica, `totalMarginBalance` chez aster — **mais elles
+   * disent la même chose**. La forme native complète reste dans `xtras`, rien n'est perdu.
+   *
+   * **blofin ne l'expose pas** et lève ; les sept autres le servent.
+   */
+  async accountInfo(access) {
+    const perp = this.perpOf(access);
+    if (typeof perp.getAccountInfo !== "function") {
+      throw new Error(
+        `accountInfo(${access.xex}) : cette venue n'expose pas l'\xE9tat de son compte.`
+      );
+    }
+    const brut = await perp.getAccountInfo();
+    return this.toAccountState(brut, access.xex);
+  }
+  /**
+   * RÈGLE LE LEVIER d'une paire, avant d'ouvrir.
+   *
+   * Le levier détermine la marge immobilisée, donc la taille tenable : le changer après l'ouverture
+   * ne rejoue pas la position déjà prise. C'est un réglage préalable, pas un ajustement.
+   *
+   * **bullet ne l'expose pas** — son levier se fixe au compte, pas à la position — et lève.
+   */
+  async setLeverage(access, symbolXex, leverage) {
+    const perp = this.perpOf(access);
+    if (typeof perp.updateLeverage !== "function") {
+      throw new Error(`setLeverage(${access.xex}) : cette venue ne r\xE8gle pas le levier par paire.`);
+    }
+    await perp.updateLeverage({ name: symbolXex, leverage });
+    this.logger.log(`setLeverage(${access.xex}/${symbolXex}) : levier port\xE9 \xE0 ${leverage}`);
+  }
+  /**
+   * CHOISIT LE MODE DE MARGE d'une paire : **isolée** ou **croisée**.
+   *
+   * En **croisée**, tout le solde du compte garantit la position : elle tient plus longtemps, mais
+   * une liquidation emporte l'ensemble. En **isolée**, seule la marge affectée est en jeu : la perte
+   * est bornée à ce montant, la liquidation arrive plus tôt.
+   *
+   * **À régler AVANT d'ouvrir.** Changer le mode d'une position vivante est refusé par la plupart
+   * des venues, et là où c'est accepté, cela redistribue la garantie sous les pieds de la position.
+   *
+   * Servi par les trois venues de référence.
+   */
+  async setMarginMode(access, symbolXex, isolated) {
+    const perp = this.perpOf(access);
+    if (typeof perp.setMarginMode !== "function") {
+      throw new Error(
+        `setMarginMode(${access.xex}) : cette venue ne choisit pas son mode de marge.`
+      );
+    }
+    await perp.setMarginMode({ name: symbolXex, isolated });
+    this.logger.log(
+      `setMarginMode(${access.xex}/${symbolXex}) : marge ${isolated === true ? "ISOL\xC9E" : "CROIS\xC9E"}`
+    );
+  }
+  /**
+   * AJOUTE DE LA MARGE à une position isolée — pour éloigner le prix de liquidation.
+   *
+   * C'est le geste qui sauve une position sous pression sans la réduire : on renforce la garantie
+   * plutôt que de couper. **N'a de sens qu'en marge isolée** ; en croisée, tout le solde garantit
+   * déjà la position et il n'y a rien à ajouter.
+   *
+   * Servi par les trois venues de référence.
+   */
+  async addMargin(access, symbolXex, amount) {
+    const perp = this.perpOf(access);
+    if (typeof perp.addIsolatedMargin !== "function") {
+      throw new Error(`addMargin(${access.xex}) : cette venue n'ajoute pas de marge isol\xE9e.`);
+    }
+    await perp.addIsolatedMargin({ name: symbolXex, amount });
+    this.logger.log(`addMargin(${access.xex}/${symbolXex}) : +${amount} de marge isol\xE9e`);
+  }
+  /**
+   * RETIRE DE LA MARGE d'une position isolée — pour libérer du capital.
+   *
+   * L'inverse d'{@link addMargin} : la garantie diminue, donc le prix de liquidation **se rapproche**.
+   * La venue refuse ce qui mettrait la position sous son seuil de maintenance.
+   *
+   * ⚠️ **pacifica ne l'expose pas** et lève : chez elle, la marge s'ajoute mais ne se retire pas.
+   * Fermer partiellement la position libère alors le capital.
+   */
+  async removeMargin(access, symbolXex, amount) {
+    const perp = this.perpOf(access);
+    if (typeof perp.removeIsolatedMargin !== "function") {
+      throw new Error(
+        `removeMargin(${access.xex}) : cette venue ne retire pas de marge isol\xE9e \u2014 ferme partiellement la position pour lib\xE9rer du capital.`
+      );
+    }
+    await perp.removeIsolatedMargin({ name: symbolXex, amount });
+    this.logger.log(`removeMargin(${access.xex}/${symbolXex}) : \u2212${amount} de marge isol\xE9e`);
+  }
+  /**
+   * L'HISTORIQUE DU FUNDING **PAYÉ** sur une paire — ce qui a réellement été prélevé ou reçu.
+   *
+   * À ne pas confondre avec le taux courant, que rend `PricesService` : celui-ci annonce ce qui
+   * *sera* payé, celui-là dit ce qui *l'a été*. Un backtest qui ignore le funding réel surestime le
+   * résultat d'une position tenue longtemps.
+   *
+   * Servi par les huit venues qui tradent.
+   */
+  async fundingHistory(access, symbolXex, range) {
+    const perp = this.perpOf(access);
+    if (typeof perp.getFundingHistory !== "function") {
+      throw new Error(
+        `fundingHistory(${access.xex}) : cette venue ne publie pas son historique de funding.`
+      );
+    }
+    const rates = await perp.getFundingHistory({
+      name: symbolXex,
+      startTime: range?.startTime === void 0 ? void 0 : toXexDate(range.startTime),
+      endTime: range?.endTime === void 0 ? void 0 : toXexDate(range.endTime),
+      limit: range?.limit
+    });
+    return rates.map((rate) => ({
+      xex: access.xex,
+      symbolXex: rate.name,
+      rate: rate.rate,
+      appliedAt: rate.appliedAt,
+      xtras: rate.xtras
+    }));
+  }
+  /**
+   * UN IDENTIFIANT APPLICATIF pour un ordre, **au format que la venue accepte**.
+   *
+   * C'est lui qui relie un ordre à la décision qui l'a produit : la venue le rend tel quel dans
+   * `IOrder.clientId`, ce qui permet de retrouver son origine sans tenir de table de correspondance.
+   *
+   * **hyperliquid exige un hexadécimal préfixé `0x`** (128 bits) là où les autres acceptent un UUID
+   * ordinaire. Passer le mauvais format fait rejeter l'ordre — d'où cette méthode plutôt qu'un
+   * `randomUUID()` chez l'appelant.
+   */
+  newClientOrderId(xex) {
+    const uuid = randomUUID();
+    return xex === "hyperliquid" /* Hyperliquid */ ? `0x${uuid.replace(/-/gu, "")}` : uuid;
+  }
+  /**
+   * LE COUPE-CIRCUIT : annule TOUS les ordres d'une paire, d'un geste.
+   *
+   * À réserver aux situations où l'on veut reprendre la main sans discuter — un état incohérent, un
+   * arrêt d'urgence, une reprise après incident. Annuler un par un laisse une fenêtre pendant
+   * laquelle certains ordres vivent encore.
+   *
+   * ⚠️ **Cela retire aussi les PROTECTIONS.** Stops et take-profits sont des ordres comme les
+   * autres : une position ouverte se retrouve **nue** après ce geste. À n'employer que si la
+   * position est fermée, ou si l'on repose une protection immédiatement — jamais pour « faire le
+   * ménage » sur une position vivante.
+   *
+   * Rend le nombre d'ordres annulés quand la venue le publie, `null` sinon.
+   */
+  async cancelAll(access, symbolXex) {
+    const perp = this.perpOf(access);
+    if (typeof perp.cancelAll !== "function") {
+      throw new Error(`cancelAll(${access.xex}) : cette venue n'annule pas en masse.`);
+    }
+    const positions = await perp.getPositions({ name: symbolXex });
+    const ouverte = positions.find(
+      (candidate) => candidate.name === symbolXex && Number(candidate.size) !== 0
+    );
+    if (ouverte !== void 0) {
+      this.logger.warn(
+        `cancelAll(${access.xex}/${symbolXex}) : ${ouverte.size} EN POSITION \u2014 ses protections partent avec. La position sera NUE.`
+      );
+    }
+    const { cancelled } = await perp.cancelAll({ name: symbolXex });
+    this.logger.log(
+      `cancelAll(${access.xex}/${symbolXex}) : ${cancelled ?? "?"} ordre(s) annul\xE9(s)`
+    );
+    return cancelled;
+  }
   /** Annule un ordre par son identifiant de venue. */
   async cancel(access, symbolXex, orderId) {
     await this.perpOf(access).cancel({ name: symbolXex, id: orderId });
@@ -1098,6 +1613,27 @@ var TradingService = class {
     const source = createAccountXex(access.xex, access);
     return source.perp();
   }
+  /**
+   * L'état natif d'une venue → {@link IAccountState}.
+   *
+   * Une lecture EXPLICITE par venue plutôt qu'un parcours à l'aveugle : les noms ne se devinent pas,
+   * et prendre le premier champ qui ressemble à une équité produirait un chiffre faux sans que rien
+   * ne le signale. `null` là où la venue ne publie pas la valeur — pas `0`, qui se lirait comme
+   * « rien » alors que personne n'a rien dit.
+   */
+  toAccountState(brut, xex) {
+    const texte = (valeur) => valeur === void 0 || valeur === null ? null : String(valeur);
+    const marge = brut.marginSummary;
+    return {
+      xex,
+      equity: texte(marge?.accountValue) ?? texte(brut.accountEquity) ?? texte(brut.totalMarginBalance) ?? "0",
+      available: texte(brut.withdrawable) ?? texte(brut.availableToSpend) ?? texte(brut.availableBalance),
+      marginUsed: texte(marge?.totalMarginUsed) ?? texte(brut.totalMarginUsed) ?? texte(brut.totalInitialMargin),
+      maintenanceMargin: texte(brut.crossMaintenanceMarginUsed) ?? texte(brut.crossMmr) ?? texte(brut.totalMaintMargin),
+      unrealizedPnl: texte(brut.totalUnrealizedProfit),
+      xtras: brut
+    };
+  }
   /**
    * 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.
@@ -1128,6 +1664,9 @@ var TradingService = class {
 TradingService = __decorateClass([
   Injectable()
 ], TradingService);
+function toXexDate(date) {
+  return date.toISOString().slice(0, 19).replace("T", " ");
+}
 var WalletService = class {
   logger = new Logger(WalletService.name);
   /** Les venues dont le portefeuille est lisible aujourd'hui. */
@@ -1331,6 +1870,176 @@ var WsCandlesService = class {
 WsCandlesService = __decorateClass([
   Injectable()
 ], WsCandlesService);
+var WsTradesService = class {
+  logger = new Logger(WsTradesService.name);
+  /**
+   * S'abonne aux exécutions d'un compte. Rend la fonction de désabonnement.
+   *
+   * Le handler reçoit **une exécution à la fois**, au format unifié, et **uniquement celles
+   * survenues après l'abonnement** — le rejeu d'historique de la venue est écarté.
+   */
+  subscribe(access, handler) {
+    const source = createAccountXex(access.xex, access);
+    if (typeof source.ws !== "function") {
+      throw new Error(`userTrades(${access.xex}) : cette venue n'expose pas de temps r\xE9el.`);
+    }
+    const ws = source.ws();
+    if (typeof ws.subscribeUserTrades !== "function") {
+      throw new Error(
+        `userTrades(${access.xex}) : cette venue ne diffuse pas les ex\xE9cutions du compte.`
+      );
+    }
+    const depuis = Date.now();
+    let ecartees = 0;
+    this.logger.log(`souscription ex\xE9cutions sur ${access.xex}`);
+    return ws.subscribeUserTrades((trade) => {
+      if (trade.filledAt.getTime() < depuis) {
+        ecartees += 1;
+        if (ecartees === 1) {
+          this.logger.log(`${access.xex} : rejeu d'historique \xE9cart\xE9 (ant\xE9rieur \xE0 l'abonnement).`);
+        }
+        return;
+      }
+      handler(this.toTrade(trade, access.xex));
+    });
+  }
+  /**
+   * S'abonne aux exécutions de PLUSIEURS comptes, avec un seul handler.
+   *
+   * Chaque exécution porte son `xex` : l'appelant sait toujours de quelle venue elle vient. La
+   * fonction rendue coupe tous les flux d'un coup — sinon il faudrait en garder N et n'en oublier
+   * aucun.
+   *
+   * Une venue qui refuse est journalisée et ignorée : le reste des comptes doit continuer d'être
+   * suivi. Sur un seul accès, l'échec est celui de l'appel.
+   */
+  subscribeAll(accesses, handler) {
+    if (accesses.length === 0) {
+      throw new Error("userTrades() : aucun compte demand\xE9 \u2014 pr\xE9cise au moins un acc\xE8s.");
+    }
+    const solo = accesses.length === 1;
+    const stops = [];
+    for (const access of accesses) {
+      try {
+        stops.push(this.subscribe(access, handler));
+      } catch (error) {
+        if (solo === true) {
+          throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`souscription ${access.xex} refus\xE9e, venue ignor\xE9e : ${message}`);
+      }
+    }
+    return () => {
+      for (const stop of stops) {
+        try {
+          stop();
+        } catch {
+        }
+      }
+    };
+  }
+  /**
+   * S'abonne aux ORDRES du compte — leur naissance, leur remplissage, leur mort.
+   *
+   * À distinguer des exécutions : un ordre est une **intention** dont on suit le cycle de vie
+   * (`open` → `partiallyFilled` → `filled`, ou `canceled`), une exécution est un **fait** ponctuel.
+   * Pour savoir qu'un stop vient de se déclencher, c'est ici qu'il faut écouter ; pour savoir à quel
+   * prix, c'est {@link subscribe}.
+   *
+   * **Même règle que pour les exécutions** : seuls les ordres postérieurs à l'abonnement sont
+   * transmis, le rejeu d'historique est écarté.
+   */
+  subscribeOrders(access, handler) {
+    const ws = this.wsOf(access);
+    if (typeof ws.subscribeOrders !== "function") {
+      throw new Error(`orders(${access.xex}) : cette venue ne diffuse pas ses ordres.`);
+    }
+    const depuis = Date.now();
+    this.logger.log(`souscription ordres sur ${access.xex}`);
+    return ws.subscribeOrders((order) => {
+      if (order.placedAt.getTime() >= depuis) {
+        handler(this.toOrder(order, access.xex));
+      }
+    });
+  }
+  /**
+   * S'abonne aux TRANSACTIONS PUBLIQUES d'un marché — celles de tout le monde, pas les siennes.
+   *
+   * C'est le flux qui dit ce qui se négocie réellement : prix, taille, sens agresseur. Il sert à
+   * mesurer l'activité d'une paire, pas à suivre son compte — pour cela, {@link subscribe}.
+   *
+   * **Aucun filtre temporel ici** : un trade public est daté de son exécution et arrive en direct,
+   * il n'y a pas d'historique rejoué à écarter.
+   */
+  subscribePublicTrades(access, symbolXex, handler) {
+    const ws = this.wsOf(access);
+    if (typeof ws.subscribeTrades !== "function") {
+      throw new Error(`publicTrades(${access.xex}) : cette venue ne diffuse pas les transactions.`);
+    }
+    this.logger.log(`souscription transactions ${symbolXex} sur ${access.xex}`);
+    return ws.subscribeTrades({ name: symbolXex }, (trade) => {
+      handler({
+        xex: access.xex,
+        symbolXex: trade.name,
+        price: trade.price,
+        size: trade.size,
+        side: trade.side,
+        tradedAt: trade.tradedAt,
+        xtras: trade.xtras
+      });
+    });
+  }
+  /** Le client temps réel d'un compte, avec ses souscriptions signées. */
+  wsOf(access) {
+    const source = createAccountXex(access.xex, access);
+    if (typeof source.ws !== "function") {
+      throw new Error(`${access.xex} : cette venue n'expose pas de temps r\xE9el.`);
+    }
+    return source.ws();
+  }
+  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: ORDER_STATUSES.includes(order.status) ? order.status : "other",
+      tif: order.tif,
+      reduceOnly: order.reduceOnly,
+      placedAt: order.placedAt,
+      xtras: order.xtras
+    };
+  }
+  toTrade(trade, xex) {
+    return {
+      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
+    };
+  }
+};
+WsTradesService = __decorateClass([
+  Injectable()
+], WsTradesService);
 
 // src/xgate.module.ts
 var XgateModule = class {
@@ -1340,24 +2049,32 @@ XgateModule = __decorateClass([
     providers: [
       CatalogService,
       CandlesService,
+      CandlesStreamRegistry,
       WsCandlesService,
+      WsTradesService,
       PricesService,
       SpotCatalogService,
       SpotCandlesService,
+      SpotPricesService,
+      SpotWsCandlesService,
       WalletService
     ],
     exports: [
       CatalogService,
       CandlesService,
+      CandlesStreamRegistry,
       WsCandlesService,
+      WsTradesService,
       PricesService,
       SpotCatalogService,
       SpotCandlesService,
+      SpotPricesService,
+      SpotWsCandlesService,
       WalletService
     ]
   })
 ], XgateModule);
 
-export { CandlesService, CatalogService, ORDER_STATUSES, PricesService, SPOT_XEXES, SpotCandlesService, SpotCatalogService, TIMEFRAME_MINUTES, Timeframe, TradingService, WALLET_XEXES, WalletService, WsCandlesService, XGATE_EXCHANGES, XgateEx, XgateModule, buildLevels, buildProtection, canonicalFromBase, canonicalFromXex, expiryOf, isDated, multiplierFromXex, roundPrice, roundToStep, servesNatively, servesSpot, sourceFor, timeframeMs };
+export { CandlesService, CandlesStreamRegistry, CandlesStreamService, CatalogService, ORDER_STATUSES, PricesService, SPOT_XEXES, SpotCandlesService, SpotCatalogService, SpotPricesService, SpotWsCandlesService, TIMEFRAME_MINUTES, Timeframe, TradingService, WALLET_XEXES, WS_SUBSCRIPTION_LIMITS, WalletService, WsCandlesService, WsTradesService, XGATE_EXCHANGES, XgateEx, XgateModule, buildLevels, buildProtection, canonicalFromBase, canonicalFromXex, expiryOf, isDated, multiplierFromXex, roundPrice, roundToStep, servesNatively, servesSpot, sourceFor, subscriptionLimitOf, timeframeMs };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map