@blackcube/xgate-sdk 0.24.0 → 0.25.1

package/dist/index.d.cts

@@ -282,6 +282,8 @@ type Unsubscribe = () => void;
  */
 declare class WsCandlesService {
     private readonly logger;
+    /** Un client temps réel par venue — voir {@link wireOf}. La clé EST la venue. */
+    private readonly wires;
     /**
      * Souscrit aux bougies d'un marché chez une venue. Rend la fonction de désabonnement.
      *
@@ -308,6 +310,23 @@ declare class WsCandlesService {
         symbol: string;
         interval: Timeframe;
     }, handler: (candle: ICandle) => void): Unsubscribe;
+    /**
+     * Le client temps réel d'une venue — **créé une seule fois, donc UNE SOCKET PAR VENUE**.
+     *
+     * C'est la règle que `CandlesStreamService` énonce déjà et que ce service violait : chaque
+     * `subscribe()` appelait `createPublicXex(xex)`, qui construit une façade NEUVE. Or la façade
+     * mémoïse son client temps réel (`unifiedWs()`), et c'est lui qui porte la socket : une façade
+     * par souscription, c'est une socket par souscription.
+     *
+     * Mesuré le 2026-08-13 sur Blips : 1 104 souscriptions ont ouvert **1 104 sockets** sur sept
+     * venues, quand hyperliquid n'en accepte que 10 par IP. Les descripteurs s'épuisent, les venues
+     * refusent, et chaque connexion refusée rejetait une promesse que personne n'attendait — le
+     * process entier mourait deux minutes après l'ouverture des flux. Ici : **sept sockets**.
+     *
+     * Rien à fermer explicitement : le ref-count vit dans les SDK (`refs += 1` / `release()`), donc
+     * la socket se ferme d'elle-même au dernier désabonnement de la venue, et se rouvre au suivant.
+     */
+    private wireOf;
     /** Voir `CandlesService.quoteOf` : la cotation se déduit du symbole natif, faute d'être publiée. */
     private quoteOf;
 }
@@ -340,23 +359,39 @@ declare class CandlesStreamService {
     private readonly unsubscribes;
     /** Le plafond de souscriptions documenté par la venue, ou `null` si personne ne l'a publié. */
     readonly maxSubscriptions: number | null;
+    /**
+     * Notifié quand le flux meurt — après que les souscriptions ont été coupées.
+     *
+     * **Ce crochet a remplacé un `throw`.** Lever depuis un rappel de socket ne remonte à aucun
+     * appelant : l'exception sort en `unhandledRejection` et **tue le process entier**, ce qui est
+     * arrivé le 2026-08-13 sur Blips par un autre chemin. « Impossible à ignorer » et « fatal pour
+     * tout le monde » ne sont pas la même chose : la première est une garantie, la seconde une panne.
+     *
+     * Le contrat reste franc — le flux est coupé, il ne repartira pas tout seul, et le silence est
+     * journalisé en `.error` de toute façon. Mais c'est à l'appelant de décider ce qu'il en fait :
+     * rouvrir, basculer de venue, ou s'arrêter.
+     */
+    onFailure: ((error: Error) => void) | null;
     constructor(xex: XgateEx, 
     /** Le marché écouté. Le comptant n'est servi que par binance et bybit. */
     kind?: MarketKind);
     /**
      * 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
+     * **UNE ERREUR DE FLUX COUPE TOUT, PUIS NOTIFIE.** 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.
+     * journalisé en `error`, et {@link onFailure} est notifié. 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.
+     * ⚠️ **On ne lève pas depuis le rappel de socket.** Une exception née là ne remonte à aucun
+     * appelant de `start()` : elle sort en `unhandledRejection` et emporte le process entier — pas
+     * seulement le flux fautif, mais les crons et tout ce qui tournait à côté. C'est {@link onFailure}
+     * qui porte l'information, et l'appelant qui décide.
      *
      * **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.
@@ -969,23 +1004,42 @@ interface IProtection {
  * Ce que l'appelant fournit. **Les pourcentages sont des écarts au prix d'entrée**, en fraction
  * (0.01 = 1 %) : `slPct: 0.02` place le stop 2 % sous l'entrée en long, 2 % au-dessus en short.
  */
+/**
+ * UN NIVEAU DE SORTIE — dit en ÉCART ou en PRIX, jamais les deux.
+ *
+ * Les deux façons de penser un objectif coexistent réellement : « je sors si ça monte de 10 % »
+ * raisonne en risque, « je sors si ça touche 62 500 » raisonne en niveau technique. Obliger à
+ * convertir l'un dans l'autre revient à faire calculer l'appelant, donc à déplacer l'erreur chez lui.
+ *
+ * L'union est **exclusive** par construction : donner les deux ne compile pas, et n'en donner aucun
+ * non plus. C'est ce qui rend impossible un objectif à moitié défini.
+ */
+type ITarget = {
+    pct: number;
+    price?: never;
+} | {
+    price: number;
+    pct?: never;
+};
 interface IProtectionInput {
     /** Prix d'entrée de référence. */
     entry: number;
     direction: Direction;
     /** Taille de la position, **en unités de base**. */
     size: number;
-    /** Écart du stop au prix d'entrée, en fraction. Toujours du côté perdant. */
-    slPct: number;
     /**
-     * Les take-profits, dans l'ordre. `pct` est l'écart au prix d'entrée (côté gagnant) et `part` la
-     * fraction de la position à sortir à ce niveau.
+     * Le stop — en **écart** au prix d'entrée (`{ pct: 0.02 }`) ou en **prix absolu**
+     * (`{ price: 62500 }`). Toujours du côté perdant quand il est donné en écart.
+     */
+    sl: ITarget;
+    /**
+     * Les take-profits, dans l'ordre. Chacun porte son niveau — en écart ou en prix — et `part`, la
+     * fraction de la POSITION à sortir là (toujours un pourcentage, jamais un prix).
      *
      * **Une part à 0 ne produit AUCUN leg** — c'est un marqueur (un palier de breakeven, par exemple),
      * pas un ordre. Sauf s'il s'agit du dernier : celui-là clôture toujours.
      */
-    tps: Array<{
-        pct: number;
+    tps: Array<ITarget & {
         part: number;
     }>;
     /** Pas de prix de la paire. */
@@ -1016,6 +1070,12 @@ declare function roundPrice(value: number, tickSize?: string | null, lotSize?: s
  * L'appelant donne un prix d'entrée, un sens et des écarts ; il ne calcule aucun prix lui-même.
  * Le stop part du côté perdant, les take-profits du côté gagnant — le sens s'en occupe.
  */
+/**
+ * Les niveaux depuis des POURCENTAGES seuls — forme courte quand tout est exprimé en écart.
+ *
+ * {@link buildProtection} ne l'utilise plus : il résout chaque niveau séparément, puisqu'un stop
+ * peut être donné en écart et un take-profit en prix absolu dans le même appel.
+ */
 declare function buildLevels(entry: number, direction: Direction, slPct: number, tpPcts: readonly number[]): {
     sl: number;
     tps: number[];
@@ -1261,16 +1321,34 @@ interface IEntryWithProtection {
     size: number;
     /** Prix d'entrée visé. Sert de référence aux pourcentages, et de prix limite. */
     entry: number;
-    /** Écart du stop au prix d'entrée, en fraction (0.02 = 2 %). Obligatoire. */
-    slPct: number;
     /**
-     * Les take-profits, dans l'ordre. `part` est la fraction de la position à sortir.
+     * LE STOP — en **écart** au prix d'entrée ou en **prix absolu**, jamais les deux.
+     *
+     * ```typescript
+     * sl: { pct: 0.02 }      // 2 % sous l'entrée en long, 2 % au-dessus en short
+     * sl: { price: 62500 }   // exactement 62 500, quel que soit le prix d'entrée
+     * ```
+     *
+     * **Obligatoire.** C'est la règle qui a motivé tout ce chemin : jamais un ordre sans stop.
+     */
+    sl: ITarget;
+    /**
+     * LES TAKE-PROFITS, dans l'ordre. Chacun dit son NIVEAU et sa PART.
+     *
+     * ```typescript
+     * tps: [{ pct: 0.03, part: 0.5 },     // sortir 50 % si ça monte de 3 %
+     *        { price: 62500, part: 0.5 }] // sortir 50 % si ça touche 62 500
+     * ```
+     *
+     * **`part` est toujours une fraction de la POSITION**, jamais un prix : les deux modes ne portent
+     * que sur le niveau. Un objectif se pense soit en risque (« +3 % »), soit en niveau technique
+     * (« 62 500 ») — obliger à convertir l'un dans l'autre déplacerait le calcul, donc l'erreur, chez
+     * l'appelant.
      *
      * Au-dessus de 80 % cumulés, le dernier absorbe le reliquat et la position ferme entièrement ;
      * à 80 % ou en dessous, le reste court.
      */
-    tps: Array<{
-        pct: number;
+    tps: Array<ITarget & {
         part: number;
     }>;
     /** `ioc` pour entrer au marché (taker), `alo` pour poster (maker). Défaut : `ioc`. */
@@ -1651,4 +1729,4 @@ declare function expiryOf(xtras?: Record<string, unknown>): Date | undefined;
  */
 declare function isDated(xtras?: Record<string, unknown>): boolean;
 
-export { CandlesService, CandlesStreamRegistry, CandlesStreamService, CatalogService, type Direction, type IAccountState, type IBalance, type ICandle, type ICandlesQuery, type IEntryWithProtection, type IEquityPoint, type IFundingPaid, type IMoveStop, type IMovement, type IOrder, type IPair, type IPosition, type IPrice, type IProtection, type IProtectionInput, type IProtectionLeg, type IPublicTrade, type ITrade, type ITradingAccess, type IWalletAccess, type IXexAccess, type IXexSpotSource, type MarketKind, type MovementKind, type MovementStatus, ORDER_STATUSES, type OrderStatus, type OrderType, PricesService, SPOT_XEXES, type Side, SpotCandlesService, SpotCatalogService, SpotPricesService, SpotWsCandlesService, TIMEFRAME_MINUTES, type TimeInForce, Timeframe, TradingService, type Unsubscribe, 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 };
+export { CandlesService, CandlesStreamRegistry, CandlesStreamService, CatalogService, type Direction, type IAccountState, type IBalance, type ICandle, type ICandlesQuery, type IEntryWithProtection, type IEquityPoint, type IFundingPaid, type IMoveStop, type IMovement, type IOrder, type IPair, type IPosition, type IPrice, type IProtection, type IProtectionInput, type IProtectionLeg, type IPublicTrade, type ITarget, type ITrade, type ITradingAccess, type IWalletAccess, type IXexAccess, type IXexSpotSource, type MarketKind, type MovementKind, type MovementStatus, ORDER_STATUSES, type OrderStatus, type OrderType, PricesService, SPOT_XEXES, type Side, SpotCandlesService, SpotCatalogService, SpotPricesService, SpotWsCandlesService, TIMEFRAME_MINUTES, type TimeInForce, Timeframe, TradingService, type Unsubscribe, 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 };

package/dist/index.d.ts

@@ -282,6 +282,8 @@ type Unsubscribe = () => void;
  */
 declare class WsCandlesService {
     private readonly logger;
+    /** Un client temps réel par venue — voir {@link wireOf}. La clé EST la venue. */
+    private readonly wires;
     /**
      * Souscrit aux bougies d'un marché chez une venue. Rend la fonction de désabonnement.
      *
@@ -308,6 +310,23 @@ declare class WsCandlesService {
         symbol: string;
         interval: Timeframe;
     }, handler: (candle: ICandle) => void): Unsubscribe;
+    /**
+     * Le client temps réel d'une venue — **créé une seule fois, donc UNE SOCKET PAR VENUE**.
+     *
+     * C'est la règle que `CandlesStreamService` énonce déjà et que ce service violait : chaque
+     * `subscribe()` appelait `createPublicXex(xex)`, qui construit une façade NEUVE. Or la façade
+     * mémoïse son client temps réel (`unifiedWs()`), et c'est lui qui porte la socket : une façade
+     * par souscription, c'est une socket par souscription.
+     *
+     * Mesuré le 2026-08-13 sur Blips : 1 104 souscriptions ont ouvert **1 104 sockets** sur sept
+     * venues, quand hyperliquid n'en accepte que 10 par IP. Les descripteurs s'épuisent, les venues
+     * refusent, et chaque connexion refusée rejetait une promesse que personne n'attendait — le
+     * process entier mourait deux minutes après l'ouverture des flux. Ici : **sept sockets**.
+     *
+     * Rien à fermer explicitement : le ref-count vit dans les SDK (`refs += 1` / `release()`), donc
+     * la socket se ferme d'elle-même au dernier désabonnement de la venue, et se rouvre au suivant.
+     */
+    private wireOf;
     /** Voir `CandlesService.quoteOf` : la cotation se déduit du symbole natif, faute d'être publiée. */
     private quoteOf;
 }
@@ -340,23 +359,39 @@ declare class CandlesStreamService {
     private readonly unsubscribes;
     /** Le plafond de souscriptions documenté par la venue, ou `null` si personne ne l'a publié. */
     readonly maxSubscriptions: number | null;
+    /**
+     * Notifié quand le flux meurt — après que les souscriptions ont été coupées.
+     *
+     * **Ce crochet a remplacé un `throw`.** Lever depuis un rappel de socket ne remonte à aucun
+     * appelant : l'exception sort en `unhandledRejection` et **tue le process entier**, ce qui est
+     * arrivé le 2026-08-13 sur Blips par un autre chemin. « Impossible à ignorer » et « fatal pour
+     * tout le monde » ne sont pas la même chose : la première est une garantie, la seconde une panne.
+     *
+     * Le contrat reste franc — le flux est coupé, il ne repartira pas tout seul, et le silence est
+     * journalisé en `.error` de toute façon. Mais c'est à l'appelant de décider ce qu'il en fait :
+     * rouvrir, basculer de venue, ou s'arrêter.
+     */
+    onFailure: ((error: Error) => void) | null;
     constructor(xex: XgateEx, 
     /** Le marché écouté. Le comptant n'est servi que par binance et bybit. */
     kind?: MarketKind);
     /**
      * 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
+     * **UNE ERREUR DE FLUX COUPE TOUT, PUIS NOTIFIE.** 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.
+     * journalisé en `error`, et {@link onFailure} est notifié. 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.
+     * ⚠️ **On ne lève pas depuis le rappel de socket.** Une exception née là ne remonte à aucun
+     * appelant de `start()` : elle sort en `unhandledRejection` et emporte le process entier — pas
+     * seulement le flux fautif, mais les crons et tout ce qui tournait à côté. C'est {@link onFailure}
+     * qui porte l'information, et l'appelant qui décide.
      *
      * **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.
@@ -969,23 +1004,42 @@ interface IProtection {
  * Ce que l'appelant fournit. **Les pourcentages sont des écarts au prix d'entrée**, en fraction
  * (0.01 = 1 %) : `slPct: 0.02` place le stop 2 % sous l'entrée en long, 2 % au-dessus en short.
  */
+/**
+ * UN NIVEAU DE SORTIE — dit en ÉCART ou en PRIX, jamais les deux.
+ *
+ * Les deux façons de penser un objectif coexistent réellement : « je sors si ça monte de 10 % »
+ * raisonne en risque, « je sors si ça touche 62 500 » raisonne en niveau technique. Obliger à
+ * convertir l'un dans l'autre revient à faire calculer l'appelant, donc à déplacer l'erreur chez lui.
+ *
+ * L'union est **exclusive** par construction : donner les deux ne compile pas, et n'en donner aucun
+ * non plus. C'est ce qui rend impossible un objectif à moitié défini.
+ */
+type ITarget = {
+    pct: number;
+    price?: never;
+} | {
+    price: number;
+    pct?: never;
+};
 interface IProtectionInput {
     /** Prix d'entrée de référence. */
     entry: number;
     direction: Direction;
     /** Taille de la position, **en unités de base**. */
     size: number;
-    /** Écart du stop au prix d'entrée, en fraction. Toujours du côté perdant. */
-    slPct: number;
     /**
-     * Les take-profits, dans l'ordre. `pct` est l'écart au prix d'entrée (côté gagnant) et `part` la
-     * fraction de la position à sortir à ce niveau.
+     * Le stop — en **écart** au prix d'entrée (`{ pct: 0.02 }`) ou en **prix absolu**
+     * (`{ price: 62500 }`). Toujours du côté perdant quand il est donné en écart.
+     */
+    sl: ITarget;
+    /**
+     * Les take-profits, dans l'ordre. Chacun porte son niveau — en écart ou en prix — et `part`, la
+     * fraction de la POSITION à sortir là (toujours un pourcentage, jamais un prix).
      *
      * **Une part à 0 ne produit AUCUN leg** — c'est un marqueur (un palier de breakeven, par exemple),
      * pas un ordre. Sauf s'il s'agit du dernier : celui-là clôture toujours.
      */
-    tps: Array<{
-        pct: number;
+    tps: Array<ITarget & {
         part: number;
     }>;
     /** Pas de prix de la paire. */
@@ -1016,6 +1070,12 @@ declare function roundPrice(value: number, tickSize?: string | null, lotSize?: s
  * L'appelant donne un prix d'entrée, un sens et des écarts ; il ne calcule aucun prix lui-même.
  * Le stop part du côté perdant, les take-profits du côté gagnant — le sens s'en occupe.
  */
+/**
+ * Les niveaux depuis des POURCENTAGES seuls — forme courte quand tout est exprimé en écart.
+ *
+ * {@link buildProtection} ne l'utilise plus : il résout chaque niveau séparément, puisqu'un stop
+ * peut être donné en écart et un take-profit en prix absolu dans le même appel.
+ */
 declare function buildLevels(entry: number, direction: Direction, slPct: number, tpPcts: readonly number[]): {
     sl: number;
     tps: number[];
@@ -1261,16 +1321,34 @@ interface IEntryWithProtection {
     size: number;
     /** Prix d'entrée visé. Sert de référence aux pourcentages, et de prix limite. */
     entry: number;
-    /** Écart du stop au prix d'entrée, en fraction (0.02 = 2 %). Obligatoire. */
-    slPct: number;
     /**
-     * Les take-profits, dans l'ordre. `part` est la fraction de la position à sortir.
+     * LE STOP — en **écart** au prix d'entrée ou en **prix absolu**, jamais les deux.
+     *
+     * ```typescript
+     * sl: { pct: 0.02 }      // 2 % sous l'entrée en long, 2 % au-dessus en short
+     * sl: { price: 62500 }   // exactement 62 500, quel que soit le prix d'entrée
+     * ```
+     *
+     * **Obligatoire.** C'est la règle qui a motivé tout ce chemin : jamais un ordre sans stop.
+     */
+    sl: ITarget;
+    /**
+     * LES TAKE-PROFITS, dans l'ordre. Chacun dit son NIVEAU et sa PART.
+     *
+     * ```typescript
+     * tps: [{ pct: 0.03, part: 0.5 },     // sortir 50 % si ça monte de 3 %
+     *        { price: 62500, part: 0.5 }] // sortir 50 % si ça touche 62 500
+     * ```
+     *
+     * **`part` est toujours une fraction de la POSITION**, jamais un prix : les deux modes ne portent
+     * que sur le niveau. Un objectif se pense soit en risque (« +3 % »), soit en niveau technique
+     * (« 62 500 ») — obliger à convertir l'un dans l'autre déplacerait le calcul, donc l'erreur, chez
+     * l'appelant.
      *
      * Au-dessus de 80 % cumulés, le dernier absorbe le reliquat et la position ferme entièrement ;
      * à 80 % ou en dessous, le reste court.
      */
-    tps: Array<{
-        pct: number;
+    tps: Array<ITarget & {
         part: number;
     }>;
     /** `ioc` pour entrer au marché (taker), `alo` pour poster (maker). Défaut : `ioc`. */
@@ -1651,4 +1729,4 @@ declare function expiryOf(xtras?: Record<string, unknown>): Date | undefined;
  */
 declare function isDated(xtras?: Record<string, unknown>): boolean;
 
-export { CandlesService, CandlesStreamRegistry, CandlesStreamService, CatalogService, type Direction, type IAccountState, type IBalance, type ICandle, type ICandlesQuery, type IEntryWithProtection, type IEquityPoint, type IFundingPaid, type IMoveStop, type IMovement, type IOrder, type IPair, type IPosition, type IPrice, type IProtection, type IProtectionInput, type IProtectionLeg, type IPublicTrade, type ITrade, type ITradingAccess, type IWalletAccess, type IXexAccess, type IXexSpotSource, type MarketKind, type MovementKind, type MovementStatus, ORDER_STATUSES, type OrderStatus, type OrderType, PricesService, SPOT_XEXES, type Side, SpotCandlesService, SpotCatalogService, SpotPricesService, SpotWsCandlesService, TIMEFRAME_MINUTES, type TimeInForce, Timeframe, TradingService, type Unsubscribe, 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 };
+export { CandlesService, CandlesStreamRegistry, CandlesStreamService, CatalogService, type Direction, type IAccountState, type IBalance, type ICandle, type ICandlesQuery, type IEntryWithProtection, type IEquityPoint, type IFundingPaid, type IMoveStop, type IMovement, type IOrder, type IPair, type IPosition, type IPrice, type IProtection, type IProtectionInput, type IProtectionLeg, type IPublicTrade, type ITarget, type ITrade, type ITradingAccess, type IWalletAccess, type IXexAccess, type IXexSpotSource, type MarketKind, type MovementKind, type MovementStatus, ORDER_STATUSES, type OrderStatus, type OrderType, PricesService, SPOT_XEXES, type Side, SpotCandlesService, SpotCatalogService, SpotPricesService, SpotWsCandlesService, TIMEFRAME_MINUTES, type TimeInForce, Timeframe, TradingService, type Unsubscribe, 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 };

package/dist/index.js

@@ -95,6 +95,24 @@ function toCandle(wire, xex, interval, quote) {
   };
 }
 
+// src/helpers/socket-error.ts
+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/helpers/ws-limits.ts
 var WS_SUBSCRIPTION_LIMITS = {
   aster: 200,
@@ -264,20 +282,36 @@ var CandlesStreamService = class {
   unsubscribes = [];
   /** Le plafond de souscriptions documenté par la venue, ou `null` si personne ne l'a publié. */
   maxSubscriptions;
+  /**
+   * Notifié quand le flux meurt — après que les souscriptions ont été coupées.
+   *
+   * **Ce crochet a remplacé un `throw`.** Lever depuis un rappel de socket ne remonte à aucun
+   * appelant : l'exception sort en `unhandledRejection` et **tue le process entier**, ce qui est
+   * arrivé le 2026-08-13 sur Blips par un autre chemin. « Impossible à ignorer » et « fatal pour
+   * tout le monde » ne sont pas la même chose : la première est une garantie, la seconde une panne.
+   *
+   * Le contrat reste franc — le flux est coupé, il ne repartira pas tout seul, et le silence est
+   * journalisé en `.error` de toute façon. Mais c'est à l'appelant de décider ce qu'il en fait :
+   * rouvrir, basculer de venue, ou s'arrêter.
+   */
+  onFailure = null;
   /**
    * 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
+   * **UNE ERREUR DE FLUX COUPE TOUT, PUIS NOTIFIE.** 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.
+   * journalisé en `error`, et {@link onFailure} est notifié. 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.
+   * ⚠️ **On ne lève pas depuis le rappel de socket.** Une exception née là ne remonte à aucun
+   * appelant de `start()` : elle sort en `unhandledRejection` et emporte le process entier — pas
+   * seulement le flux fautif, mais les crons et tout ce qui tournait à côté. C'est {@link onFailure}
+   * qui porte l'information, et l'appelant qui décide.
    *
    * **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.
@@ -289,7 +323,7 @@ var CandlesStreamService = class {
         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}`);
+        this.onFailure?.(new Error(`stream(${this.xex}) : flux interrompu \u2014 ${raison}`));
       };
     }
     for (const symbolXex of symbolsXex) {
@@ -372,22 +406,6 @@ var CandlesStreamRegistry = class {
 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) => {
@@ -1075,6 +1093,13 @@ SpotWsCandlesService = __decorateClass([
 ], SpotWsCandlesService);
 
 // src/helpers/protection.ts
+function priceOf(cible, entry, direction, gagnant) {
+  if (cible.price !== void 0) {
+    return round8(cible.price);
+  }
+  const dir = (direction === "long" ? 1 : -1) * (gagnant === true ? 1 : -1);
+  return round8(entry * (1 + dir * cible.pct));
+}
 var SLIPPAGE_DEFAUT = 5e-3;
 var SEUIL_CLOTURE = 0.8;
 function round8(value) {
@@ -1117,12 +1142,8 @@ function buildLevels(entry, direction, slPct, tpPcts) {
 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 sl = priceOf(input.sl, input.entry, input.direction, false);
+  const niveaux = input.tps.map((tp) => priceOf(tp, input.entry, input.direction, true));
   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;
@@ -1193,7 +1214,7 @@ var TradingService = class {
       entry: input.entry,
       direction: input.direction,
       size: input.size,
-      slPct: input.slPct,
+      sl: input.sl,
       tps: input.tps,
       tickSize: input.tickSize,
       lotSize: input.lotSize,
@@ -1816,6 +1837,8 @@ WalletService = __decorateClass([
 ], WalletService);
 var WsCandlesService = class {
   logger = new Logger(WsCandlesService.name);
+  /** Un client temps réel par venue — voir {@link wireOf}. La clé EST la venue. */
+  wires = /* @__PURE__ */ new Map();
   /**
    * Souscrit aux bougies d'un marché chez une venue. Rend la fonction de désabonnement.
    *
@@ -1831,9 +1854,12 @@ var WsCandlesService = class {
   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));
-    });
+    return this.wireOf(xex).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.
@@ -1860,6 +1886,35 @@ var WsCandlesService = class {
       }
     };
   }
+  /**
+   * Le client temps réel d'une venue — **créé une seule fois, donc UNE SOCKET PAR VENUE**.
+   *
+   * C'est la règle que `CandlesStreamService` énonce déjà et que ce service violait : chaque
+   * `subscribe()` appelait `createPublicXex(xex)`, qui construit une façade NEUVE. Or la façade
+   * mémoïse son client temps réel (`unifiedWs()`), et c'est lui qui porte la socket : une façade
+   * par souscription, c'est une socket par souscription.
+   *
+   * Mesuré le 2026-08-13 sur Blips : 1 104 souscriptions ont ouvert **1 104 sockets** sur sept
+   * venues, quand hyperliquid n'en accepte que 10 par IP. Les descripteurs s'épuisent, les venues
+   * refusent, et chaque connexion refusée rejetait une promesse que personne n'attendait — le
+   * process entier mourait deux minutes après l'ouverture des flux. Ici : **sept sockets**.
+   *
+   * Rien à fermer explicitement : le ref-count vit dans les SDK (`refs += 1` / `release()`), donc
+   * la socket se ferme d'elle-même au dernier désabonnement de la venue, et se rouvre au suivant.
+   */
+  wireOf(xex) {
+    let wire = this.wires.get(xex);
+    if (wire === void 0) {
+      wire = createPublicXex(xex).ws();
+      if ("onError" in wire) {
+        wire.onError = (error) => {
+          this.logger.error(`${xex} : erreur de flux \u2014 ${lisible(error)}`);
+        };
+      }
+      this.wires.set(xex, wire);
+    }
+    return wire;
+  }
   /** Voir `CandlesService.quoteOf` : la cotation se déduit du symbole natif, faute d'être publiée. */
   quoteOf(symbolXex) {
     const parts = symbolXex.split("-");