@blackcube/xgate-sdk 0.22.0 → 0.23.0

package/dist/index.js

@@ -19,131 +19,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 +94,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 +248,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 */
@@ -796,6 +945,133 @@ var SpotCatalogService = class {
 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()
+], 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;
@@ -1340,24 +1616,30 @@ XgateModule = __decorateClass([
     providers: [
       CatalogService,
       CandlesService,
+      CandlesStreamRegistry,
       WsCandlesService,
       PricesService,
       SpotCatalogService,
       SpotCandlesService,
+      SpotPricesService,
+      SpotWsCandlesService,
       WalletService
     ],
     exports: [
       CatalogService,
       CandlesService,
+      CandlesStreamRegistry,
       WsCandlesService,
       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, 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