@blackcube/xgate-sdk 0.25.5 → 0.56.1

package/dist/index.d.cts

@@ -39,6 +39,37 @@ declare enum XgateEx {
 /** Toutes les venues connues, dans l'ordre de déclaration. */
 declare const XGATE_EXCHANGES: readonly XgateEx[];
 
+/**
+ * CE QUE COTE UNE PAIRE — de la crypto, ou autre chose.
+ *
+ * Les venues perpétuelles ne listent plus seulement des cryptos : bybit publie 164 actions, 43 ETF et
+ * quatre matières premières, binance ouvre des `TRADIFI_PERPETUAL` sur NVDA et l'or, extended range
+ * ses actions en `RWA`. Le catalogue les rendait toutes indistinctes.
+ *
+ * ⚠️ CE N'EST PAS UNE COMMODITÉ DE CLASSEMENT. Le 2026-08-24, `PURR` cotait 11 $ chez bybit et
+ * 0,13 $ chez hyperliquid : le premier est une ACTION, le second le memecoin natif d'Hyperliquid.
+ * Même ticker, deux actifs — et un consommateur qui médiane « le prix de PURR » entre venues
+ * publiait un nombre qui n'était le prix d'aucun des deux. Le rapport n'était même pas constant
+ * (71 à 116 sur douze jours), ce qui excluait une échelle de cotation.
+ *
+ * ⚠️ ET CE N'EST PAS DÉDUCTIBLE DU TICKER. `SPX` est le memecoin SPX6900 chez binance, bybit et
+ * extended — qui le disent tous les trois (`underlyingSubType: ["Meme"]`, `subCategory: "Meme"`) —
+ * alors que l'indice S&P 500 s'appelle `SP500` chez pacifica. Une règle sur le nom aurait classé les
+ * deux à l'envers.
+ */
+type AssetClass = 'crypto' | 'stock' | 'commodity' | 'index' | 'etf' | 'forex';
+/**
+ * LA CLASSE D'ACTIF D'UNE PAIRE, ou `undefined` quand la venue ne se prononce pas.
+ *
+ * ⚠️ `undefined` N'EST PAS « CRYPTO ». hyperliquid et pacifica cotent NVDA, TSLA, XAU et PLTR sans
+ * publier la moindre catégorie : les classer d'office en crypto reproduirait exactement l'erreur
+ * qu'on corrige ici. « On ne sait pas » est une information ; une valeur inventée n'en est pas une.
+ *
+ * Une catégorie inconnue rend `undefined` plutôt que de retomber sur `crypto` — le jour où une venue
+ * en ajoute une, on veut le voir, pas l'absorber.
+ */
+declare function assetClassOf(xex: XgateEx, xtras?: Record<string, unknown>): AssetClass | undefined;
+
 /** Type de marché. */
 type MarketKind = 'perp' | 'spot';
 /**
@@ -77,6 +108,18 @@ interface IPair {
      * ramène toutes les venues à la même unité.
      */
     multiplier: number;
+    /**
+     * CE QUE LA PAIRE COTE — `undefined` quand la venue ne le dit pas.
+     *
+     * Les venues perpétuelles ne listent plus que de la crypto : bybit publie 164 actions, 43 ETF et
+     * quatre matières premières, binance ouvre des `TRADIFI_PERPETUAL` sur NVDA et l'or. Sans ce
+     * champ, un consommateur mélange deux actifs qui partagent un ticker — `PURR` valait 11 $ chez
+     * bybit (une ACTION) et 0,13 $ chez hyperliquid (le memecoin) le 2026-08-24.
+     *
+     * ⚠️ `undefined` NE VEUT PAS DIRE « crypto ». hyperliquid et pacifica cotent NVDA, TSLA et XAU
+     * sans publier de catégorie : les supposer crypto referait l'erreur qu'on corrige.
+     */
+    assetClass?: AssetClass;
     /**
      * ÉCHÉANCE du contrat. `undefined` pour un perpétuel — l'immense majorité.
      *
@@ -1447,7 +1490,11 @@ interface IEntryWithProtection {
     direction: Direction;
     /** Taille à ouvrir, **en unités de base**. */
     size: number;
-    /** Prix d'entrée visé. Sert de référence aux pourcentages, et de prix limite. */
+    /**
+     * Prix d'entrée visé. Sert de référence aux pourcentages, et de prix limite — ARRONDI à la grille
+     * de la paire par XGate (`tickSize`, sinon la règle hyperliquid), comme les protections. Jusqu'en
+     * 0.56.0 il partait tel quel, et pacifica refuse un prix hors tick.
+     */
     entry: number;
     /**
      * LE STOP — en **écart** au prix d'entrée ou en **prix absolu**, jamais les deux.
@@ -1521,8 +1568,43 @@ declare class TradingService {
      * Chaque venue applique son mécanisme natif — hyperliquid groupe les enfants sous l'entrée et les
      * annule lui-même si elle rate, pacifica les embarque dans l'ordre, aster envoie un lot de
      * conditionnels. Le SDK de la venue s'en charge ; xgate fournit des niveaux justes.
+     *
+     * **LE PRIX D'ENTRÉE EST ARRONDI À LA GRILLE DE LA PAIRE, comme les protections.** Jusqu'en 0.56.0 il
+     * partait tel quel (`String(input.entry)`) : les protections étaient justes, l'entrée non — et
+     * pacifica l'envoie au wire sans le reformater (hyperliquid, lui, le reformate). Mesuré le
+     * 2026-09-12 en rejouant 171 ouvertures : 79 entrées hors grille (`13.7421` sur un marché à cinq
+     * chiffres significatifs, `75.885` sur un tick de 0,01). Les niveaux en pourcentage se calculent
+     * depuis l'entrée ARRONDIE — celle qui sera réellement posée.
+     *
+     * **LES CIBLES QUE LA VENUE N'EMBARQUE PAS SONT POSÉES ICI.** Pacifica n'embarque qu'un take-profit
+     * dans l'ordre d'entrée et rend les suivants par `pendingTps()` — « à appeler une fois le fill
+     * constaté ». Avec une entrée immédiate (`ioc`, `fok`), le fill est constaté tout de suite : on
+     * relit la position et on pose ce qui manque, en ordres déclenchés reduce-only. Avec une entrée
+     * qui peut rester au carnet (`gtc`, `alo`), rien ne peut être posé avant le fill : l'appelant
+     * complète par {@link completeProtection} quand il le constate. Jusqu'en 0.56.0 ces cibles n'étaient
+     * posées par personne : une position tide à trois paliers sur pacifica partait sans sa dernière.
      */
     openWithProtection(access: ITradingAccess, input: IEntryWithProtection): Promise<IOrder[]>;
+    /**
+     * POSE LES CIBLES QUE LA VENUE N'A PAS EMBARQUÉES, une fois l'entrée remplie.
+     *
+     * Le pendant de {@link openWithProtection} pour une entrée qui pouvait rester au carnet (`gtc`,
+     * `alo`) : l'appelant constate le fill — une position sur la paire — et complète. Les niveaux se
+     * recalculent depuis la même consigne, donc les mêmes prix ; la venue qui embarque toutes ses
+     * cibles (hyperliquid, aster) n'a rien en attente et rien n'est posé. Sans position, rien non plus :
+     * un ordre reduce-only sans position serait refusé ou annulé par la venue.
+     *
+     * ⚠️ NON IDEMPOTENT : appelé deux fois après le même fill, il pose les cibles deux fois. L'appelant
+     * le fait UNE fois, quand sa relecture montre la position.
+     */
+    completeProtection(access: ITradingAccess, input: IEntryWithProtection): Promise<IOrder[]>;
+    /** Ce que la venue rend comme cibles non embarquées — vide chez celles qui embarquent tout. */
+    private ciblesEnAttente;
+    /**
+     * Les cibles en attente, posées une par une en ordres déclenchés reduce-only — le même geste
+     * qu'aster fait pour toutes les siennes. Rien n'est posé sans position sur la paire.
+     */
+    private poserCiblesEnAttente;
     /**
      * CE QUE LA VENUE A RÉELLEMENT FAIT, après une réponse perdue.
      *
@@ -1857,4 +1939,4 @@ declare function expiryOf(xtras?: Record<string, unknown>): Date | undefined;
  */
 declare function isDated(xtras?: Record<string, unknown>): boolean;
 
-export { CANDLES_MAX_HISTORY, CANDLES_PER_CALL, 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, REST_THROTTLE_MS, 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, candlesMaxHistoryOf, candlesPerCallOf, canonicalFromBase, canonicalFromXex, expiryOf, isDated, multiplierFromXex, restThrottleOf, roundPrice, roundToStep, servesNatively, servesSpot, sourceFor, subscriptionLimitOf, timeframeMs };
+export { type AssetClass, CANDLES_MAX_HISTORY, CANDLES_PER_CALL, 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, REST_THROTTLE_MS, 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, assetClassOf, buildLevels, buildProtection, candlesMaxHistoryOf, candlesPerCallOf, canonicalFromBase, canonicalFromXex, expiryOf, isDated, multiplierFromXex, restThrottleOf, roundPrice, roundToStep, servesNatively, servesSpot, sourceFor, subscriptionLimitOf, timeframeMs };

package/dist/index.d.ts

@@ -39,6 +39,37 @@ declare enum XgateEx {
 /** Toutes les venues connues, dans l'ordre de déclaration. */
 declare const XGATE_EXCHANGES: readonly XgateEx[];
 
+/**
+ * CE QUE COTE UNE PAIRE — de la crypto, ou autre chose.
+ *
+ * Les venues perpétuelles ne listent plus seulement des cryptos : bybit publie 164 actions, 43 ETF et
+ * quatre matières premières, binance ouvre des `TRADIFI_PERPETUAL` sur NVDA et l'or, extended range
+ * ses actions en `RWA`. Le catalogue les rendait toutes indistinctes.
+ *
+ * ⚠️ CE N'EST PAS UNE COMMODITÉ DE CLASSEMENT. Le 2026-08-24, `PURR` cotait 11 $ chez bybit et
+ * 0,13 $ chez hyperliquid : le premier est une ACTION, le second le memecoin natif d'Hyperliquid.
+ * Même ticker, deux actifs — et un consommateur qui médiane « le prix de PURR » entre venues
+ * publiait un nombre qui n'était le prix d'aucun des deux. Le rapport n'était même pas constant
+ * (71 à 116 sur douze jours), ce qui excluait une échelle de cotation.
+ *
+ * ⚠️ ET CE N'EST PAS DÉDUCTIBLE DU TICKER. `SPX` est le memecoin SPX6900 chez binance, bybit et
+ * extended — qui le disent tous les trois (`underlyingSubType: ["Meme"]`, `subCategory: "Meme"`) —
+ * alors que l'indice S&P 500 s'appelle `SP500` chez pacifica. Une règle sur le nom aurait classé les
+ * deux à l'envers.
+ */
+type AssetClass = 'crypto' | 'stock' | 'commodity' | 'index' | 'etf' | 'forex';
+/**
+ * LA CLASSE D'ACTIF D'UNE PAIRE, ou `undefined` quand la venue ne se prononce pas.
+ *
+ * ⚠️ `undefined` N'EST PAS « CRYPTO ». hyperliquid et pacifica cotent NVDA, TSLA, XAU et PLTR sans
+ * publier la moindre catégorie : les classer d'office en crypto reproduirait exactement l'erreur
+ * qu'on corrige ici. « On ne sait pas » est une information ; une valeur inventée n'en est pas une.
+ *
+ * Une catégorie inconnue rend `undefined` plutôt que de retomber sur `crypto` — le jour où une venue
+ * en ajoute une, on veut le voir, pas l'absorber.
+ */
+declare function assetClassOf(xex: XgateEx, xtras?: Record<string, unknown>): AssetClass | undefined;
+
 /** Type de marché. */
 type MarketKind = 'perp' | 'spot';
 /**
@@ -77,6 +108,18 @@ interface IPair {
      * ramène toutes les venues à la même unité.
      */
     multiplier: number;
+    /**
+     * CE QUE LA PAIRE COTE — `undefined` quand la venue ne le dit pas.
+     *
+     * Les venues perpétuelles ne listent plus que de la crypto : bybit publie 164 actions, 43 ETF et
+     * quatre matières premières, binance ouvre des `TRADIFI_PERPETUAL` sur NVDA et l'or. Sans ce
+     * champ, un consommateur mélange deux actifs qui partagent un ticker — `PURR` valait 11 $ chez
+     * bybit (une ACTION) et 0,13 $ chez hyperliquid (le memecoin) le 2026-08-24.
+     *
+     * ⚠️ `undefined` NE VEUT PAS DIRE « crypto ». hyperliquid et pacifica cotent NVDA, TSLA et XAU
+     * sans publier de catégorie : les supposer crypto referait l'erreur qu'on corrige.
+     */
+    assetClass?: AssetClass;
     /**
      * ÉCHÉANCE du contrat. `undefined` pour un perpétuel — l'immense majorité.
      *
@@ -1447,7 +1490,11 @@ interface IEntryWithProtection {
     direction: Direction;
     /** Taille à ouvrir, **en unités de base**. */
     size: number;
-    /** Prix d'entrée visé. Sert de référence aux pourcentages, et de prix limite. */
+    /**
+     * Prix d'entrée visé. Sert de référence aux pourcentages, et de prix limite — ARRONDI à la grille
+     * de la paire par XGate (`tickSize`, sinon la règle hyperliquid), comme les protections. Jusqu'en
+     * 0.56.0 il partait tel quel, et pacifica refuse un prix hors tick.
+     */
     entry: number;
     /**
      * LE STOP — en **écart** au prix d'entrée ou en **prix absolu**, jamais les deux.
@@ -1521,8 +1568,43 @@ declare class TradingService {
      * Chaque venue applique son mécanisme natif — hyperliquid groupe les enfants sous l'entrée et les
      * annule lui-même si elle rate, pacifica les embarque dans l'ordre, aster envoie un lot de
      * conditionnels. Le SDK de la venue s'en charge ; xgate fournit des niveaux justes.
+     *
+     * **LE PRIX D'ENTRÉE EST ARRONDI À LA GRILLE DE LA PAIRE, comme les protections.** Jusqu'en 0.56.0 il
+     * partait tel quel (`String(input.entry)`) : les protections étaient justes, l'entrée non — et
+     * pacifica l'envoie au wire sans le reformater (hyperliquid, lui, le reformate). Mesuré le
+     * 2026-09-12 en rejouant 171 ouvertures : 79 entrées hors grille (`13.7421` sur un marché à cinq
+     * chiffres significatifs, `75.885` sur un tick de 0,01). Les niveaux en pourcentage se calculent
+     * depuis l'entrée ARRONDIE — celle qui sera réellement posée.
+     *
+     * **LES CIBLES QUE LA VENUE N'EMBARQUE PAS SONT POSÉES ICI.** Pacifica n'embarque qu'un take-profit
+     * dans l'ordre d'entrée et rend les suivants par `pendingTps()` — « à appeler une fois le fill
+     * constaté ». Avec une entrée immédiate (`ioc`, `fok`), le fill est constaté tout de suite : on
+     * relit la position et on pose ce qui manque, en ordres déclenchés reduce-only. Avec une entrée
+     * qui peut rester au carnet (`gtc`, `alo`), rien ne peut être posé avant le fill : l'appelant
+     * complète par {@link completeProtection} quand il le constate. Jusqu'en 0.56.0 ces cibles n'étaient
+     * posées par personne : une position tide à trois paliers sur pacifica partait sans sa dernière.
      */
     openWithProtection(access: ITradingAccess, input: IEntryWithProtection): Promise<IOrder[]>;
+    /**
+     * POSE LES CIBLES QUE LA VENUE N'A PAS EMBARQUÉES, une fois l'entrée remplie.
+     *
+     * Le pendant de {@link openWithProtection} pour une entrée qui pouvait rester au carnet (`gtc`,
+     * `alo`) : l'appelant constate le fill — une position sur la paire — et complète. Les niveaux se
+     * recalculent depuis la même consigne, donc les mêmes prix ; la venue qui embarque toutes ses
+     * cibles (hyperliquid, aster) n'a rien en attente et rien n'est posé. Sans position, rien non plus :
+     * un ordre reduce-only sans position serait refusé ou annulé par la venue.
+     *
+     * ⚠️ NON IDEMPOTENT : appelé deux fois après le même fill, il pose les cibles deux fois. L'appelant
+     * le fait UNE fois, quand sa relecture montre la position.
+     */
+    completeProtection(access: ITradingAccess, input: IEntryWithProtection): Promise<IOrder[]>;
+    /** Ce que la venue rend comme cibles non embarquées — vide chez celles qui embarquent tout. */
+    private ciblesEnAttente;
+    /**
+     * Les cibles en attente, posées une par une en ordres déclenchés reduce-only — le même geste
+     * qu'aster fait pour toutes les siennes. Rien n'est posé sans position sur la paire.
+     */
+    private poserCiblesEnAttente;
     /**
      * CE QUE LA VENUE A RÉELLEMENT FAIT, après une réponse perdue.
      *
@@ -1857,4 +1939,4 @@ declare function expiryOf(xtras?: Record<string, unknown>): Date | undefined;
  */
 declare function isDated(xtras?: Record<string, unknown>): boolean;
 
-export { CANDLES_MAX_HISTORY, CANDLES_PER_CALL, 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, REST_THROTTLE_MS, 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, candlesMaxHistoryOf, candlesPerCallOf, canonicalFromBase, canonicalFromXex, expiryOf, isDated, multiplierFromXex, restThrottleOf, roundPrice, roundToStep, servesNatively, servesSpot, sourceFor, subscriptionLimitOf, timeframeMs };
+export { type AssetClass, CANDLES_MAX_HISTORY, CANDLES_PER_CALL, 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, REST_THROTTLE_MS, 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, assetClassOf, buildLevels, buildProtection, candlesMaxHistoryOf, candlesPerCallOf, canonicalFromBase, canonicalFromXex, expiryOf, isDated, multiplierFromXex, restThrottleOf, roundPrice, roundToStep, servesNatively, servesSpot, sourceFor, subscriptionLimitOf, timeframeMs };

package/dist/index.js

@@ -677,6 +677,57 @@ CandlesService = __decorateClass([
   Injectable()
 ], CandlesService);
 
+// src/helpers/asset-class.ts
+var BINANCE = {
+  COIN: "crypto",
+  EQUITY: "stock",
+  CN_EQUITY: "stock",
+  HK_EQUITY: "stock",
+  KR_EQUITY: "stock",
+  PREMARKET: "stock",
+  COMMODITY: "commodity",
+  INDEX: "index"
+};
+var BYBIT = {
+  "": "crypto",
+  innovation: "crypto",
+  stock: "stock",
+  commodity: "commodity",
+  ETF: "etf"
+};
+var EXTENDED = {
+  Equity: "stock",
+  Commodity: "commodity",
+  "ETF/Index": "index",
+  FX: "forex",
+  "Pre-market": "stock"
+};
+function assetClassOf(xex, xtras) {
+  if (xtras === void 0) {
+    return void 0;
+  }
+  if (xex === "binance") {
+    const brut = xtras.underlyingType;
+    return typeof brut === "string" ? BINANCE[brut] : void 0;
+  }
+  if (xex === "bybit") {
+    const brut = xtras.symbolType;
+    return typeof brut === "string" ? BYBIT[brut] : void 0;
+  }
+  if (xex === "extended") {
+    const categorie = xtras.category;
+    if (typeof categorie !== "string") {
+      return void 0;
+    }
+    if (categorie !== "RWA") {
+      return "crypto";
+    }
+    const sous = xtras.subCategory;
+    return typeof sous === "string" ? EXTENDED[sous] : void 0;
+  }
+  return void 0;
+}
+
 // src/helpers/contract-expiry.ts
 var DATED_CONTRACT_TYPES = /* @__PURE__ */ new Set([
   // binance : les trimestriels (`BTCUSDT_260925`, `ETHUSDT_261225`).
@@ -759,6 +810,7 @@ var CatalogService = class {
       xex,
       kind: pair.kind,
       multiplier: multiplierFromXex(pair.name),
+      assetClass: assetClassOf(xex, pair.xtras),
       expiresAt: expiryOf(pair.xtras),
       ref: pair.ref ?? null,
       szDecimals: pair.szDecimals,
@@ -947,6 +999,7 @@ var SpotCatalogService = class {
       // Le comptant porte les mêmes échelles que le perp : `SATSUSDT` (×1) et `1000SATSUSDT`
       // coexistent, et c'est justement entre eux que la comparaison serait fausse.
       multiplier: multiplierFromXex(pair.name),
+      assetClass: assetClassOf(xex, pair.xtras),
       ref: pair.ref ?? null,
       szDecimals: pair.szDecimals,
       tickSize: pair.tickSize,
@@ -1203,6 +1256,21 @@ var TradingService = class {
    * Chaque venue applique son mécanisme natif — hyperliquid groupe les enfants sous l'entrée et les
    * annule lui-même si elle rate, pacifica les embarque dans l'ordre, aster envoie un lot de
    * conditionnels. Le SDK de la venue s'en charge ; xgate fournit des niveaux justes.
+   *
+   * **LE PRIX D'ENTRÉE EST ARRONDI À LA GRILLE DE LA PAIRE, comme les protections.** Jusqu'en 0.56.0 il
+   * partait tel quel (`String(input.entry)`) : les protections étaient justes, l'entrée non — et
+   * pacifica l'envoie au wire sans le reformater (hyperliquid, lui, le reformate). Mesuré le
+   * 2026-09-12 en rejouant 171 ouvertures : 79 entrées hors grille (`13.7421` sur un marché à cinq
+   * chiffres significatifs, `75.885` sur un tick de 0,01). Les niveaux en pourcentage se calculent
+   * depuis l'entrée ARRONDIE — celle qui sera réellement posée.
+   *
+   * **LES CIBLES QUE LA VENUE N'EMBARQUE PAS SONT POSÉES ICI.** Pacifica n'embarque qu'un take-profit
+   * dans l'ordre d'entrée et rend les suivants par `pendingTps()` — « à appeler une fois le fill
+   * constaté ». Avec une entrée immédiate (`ioc`, `fok`), le fill est constaté tout de suite : on
+   * relit la position et on pose ce qui manque, en ordres déclenchés reduce-only. Avec une entrée
+   * qui peut rester au carnet (`gtc`, `alo`), rien ne peut être posé avant le fill : l'appelant
+   * complète par {@link completeProtection} quand il le constate. Jusqu'en 0.56.0 ces cibles n'étaient
+   * posées par personne : une position tide à trois paliers sur pacifica partait sans sa dernière.
    */
   async openWithProtection(access, input) {
     if (VENUES_PROUVEES.includes(access.xex) === false) {
@@ -1210,8 +1278,9 @@ var TradingService = class {
         `openWithProtection(${access.xex}) : l'ouverture prot\xE9g\xE9e n'a pas \xE9t\xE9 prouv\xE9e en r\xE9el sur cette venue. Seules ${VENUES_PROUVEES.join(", ")} le sont. Ouvrir ici reviendrait \xE0 parier qu'un chemin jamais exerc\xE9 pose bien le stop.`
       );
     }
+    const entryPrice = roundPrice(input.entry, input.tickSize, input.lotSize);
     const protection = buildProtection({
-      entry: input.entry,
+      entry: entryPrice,
       direction: input.direction,
       size: input.size,
       sl: input.sl,
@@ -1227,13 +1296,14 @@ var TradingService = class {
         `openWithProtection(${access.xex}) : cette venue n'expose pas l'ouverture prot\xE9g\xE9e atomique.`
       );
     }
+    const tif = input.tif ?? "ioc";
     const entry = {
       name: input.symbolXex,
       side,
       type: "limit",
       size: String(input.size),
-      price: String(input.entry),
-      tif: input.tif ?? "ioc",
+      price: String(entryPrice),
+      tif,
       reduceOnly: false,
       clientId: input.clientId
     };
@@ -1246,7 +1316,25 @@ var TradingService = class {
     };
     try {
       const orders = await perp.createEntryWithProtection(entry, consigne);
-      return orders.map((order) => this.toOrder(order, access.xex));
+      const posees = orders.map((order) => this.toOrder(order, access.xex));
+      const enAttente = this.ciblesEnAttente(perp, consigne);
+      if (enAttente.length === 0) {
+        return posees;
+      }
+      if (tif !== "ioc" && tif !== "fok") {
+        this.logger.warn(
+          `openWithProtection(${access.xex}/${input.symbolXex}) : ${enAttente.length} cible(s) que la venue n'embarque pas \u2014 l'entr\xE9e ${tif} peut rester au carnet, appeler completeProtection une fois remplie.`
+        );
+        return posees;
+      }
+      const complement = await this.poserCiblesEnAttente(
+        access,
+        perp,
+        input.symbolXex,
+        side,
+        enAttente
+      );
+      return [...posees, ...complement];
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (message.includes(ASTER_TIMEOUT) === false) {
@@ -1258,6 +1346,79 @@ var TradingService = class {
       return await this.etatApres(access, input.symbolXex);
     }
   }
+  /**
+   * POSE LES CIBLES QUE LA VENUE N'A PAS EMBARQUÉES, une fois l'entrée remplie.
+   *
+   * Le pendant de {@link openWithProtection} pour une entrée qui pouvait rester au carnet (`gtc`,
+   * `alo`) : l'appelant constate le fill — une position sur la paire — et complète. Les niveaux se
+   * recalculent depuis la même consigne, donc les mêmes prix ; la venue qui embarque toutes ses
+   * cibles (hyperliquid, aster) n'a rien en attente et rien n'est posé. Sans position, rien non plus :
+   * un ordre reduce-only sans position serait refusé ou annulé par la venue.
+   *
+   * ⚠️ NON IDEMPOTENT : appelé deux fois après le même fill, il pose les cibles deux fois. L'appelant
+   * le fait UNE fois, quand sa relecture montre la position.
+   */
+  async completeProtection(access, input) {
+    const entryPrice = roundPrice(input.entry, input.tickSize, input.lotSize);
+    const protection = buildProtection({
+      entry: entryPrice,
+      direction: input.direction,
+      size: input.size,
+      sl: input.sl,
+      tps: input.tps,
+      tickSize: input.tickSize,
+      lotSize: input.lotSize,
+      slippagePct: input.slippagePct
+    });
+    const side = input.direction === "long" ? "buy" : "sell";
+    const perp = this.perpOf(access);
+    const enAttente = this.ciblesEnAttente(perp, {
+      name: input.symbolXex,
+      side,
+      sl: protection.sl,
+      tps: protection.tps,
+      clientId: input.clientId
+    });
+    return enAttente.length === 0 ? [] : this.poserCiblesEnAttente(access, perp, input.symbolXex, side, enAttente);
+  }
+  /** Ce que la venue rend comme cibles non embarquées — vide chez celles qui embarquent tout. */
+  ciblesEnAttente(perp, consigne) {
+    return typeof perp.pendingTps === "function" ? perp.pendingTps(consigne) : [];
+  }
+  /**
+   * Les cibles en attente, posées une par une en ordres déclenchés reduce-only — le même geste
+   * qu'aster fait pour toutes les siennes. Rien n'est posé sans position sur la paire.
+   */
+  async poserCiblesEnAttente(access, perp, symbolXex, side, enAttente) {
+    const positions = await perp.getPositions({ name: symbolXex });
+    const position = positions.find(
+      (candidate) => candidate.name === symbolXex && Number(candidate.size) !== 0
+    );
+    if (position === void 0) {
+      this.logger.log(
+        `openWithProtection(${access.xex}/${symbolXex}) : pas de position, ${enAttente.length} cible(s) en attente non pos\xE9e(s).`
+      );
+      return [];
+    }
+    const exit = side === "buy" ? "sell" : "buy";
+    const posees = [];
+    for (const cible of enAttente) {
+      const order = await perp.place({
+        name: symbolXex,
+        side: exit,
+        type: "takeProfitMarket",
+        size: cible.size,
+        triggerPrice: cible.triggerPrice,
+        price: cible.price,
+        reduceOnly: true
+      });
+      posees.push(this.toOrder(order, access.xex));
+    }
+    this.logger.log(
+      `openWithProtection(${access.xex}/${symbolXex}) : ${posees.length} cible(s) que la venue n'embarquait pas, pos\xE9e(s).`
+    );
+    return posees;
+  }
   /**
    * CE QUE LA VENUE A RÉELLEMENT FAIT, après une réponse perdue.
    *
@@ -2163,6 +2324,6 @@ function candlesMaxHistoryOf(xex) {
   return CANDLES_MAX_HISTORY[xex];
 }
 
-export { CANDLES_MAX_HISTORY, CANDLES_PER_CALL, CandlesService, CandlesStreamRegistry, CandlesStreamService, CatalogService, ORDER_STATUSES, PricesService, REST_THROTTLE_MS, SPOT_XEXES, SpotCandlesService, SpotCatalogService, SpotPricesService, SpotWsCandlesService, TIMEFRAME_MINUTES, Timeframe, TradingService, WALLET_XEXES, WS_SUBSCRIPTION_LIMITS, WalletService, WsCandlesService, WsTradesService, XGATE_EXCHANGES, XgateEx, XgateModule, buildLevels, buildProtection, candlesMaxHistoryOf, candlesPerCallOf, canonicalFromBase, canonicalFromXex, expiryOf, isDated, multiplierFromXex, restThrottleOf, roundPrice, roundToStep, servesNatively, servesSpot, sourceFor, subscriptionLimitOf, timeframeMs };
+export { CANDLES_MAX_HISTORY, CANDLES_PER_CALL, CandlesService, CandlesStreamRegistry, CandlesStreamService, CatalogService, ORDER_STATUSES, PricesService, REST_THROTTLE_MS, SPOT_XEXES, SpotCandlesService, SpotCatalogService, SpotPricesService, SpotWsCandlesService, TIMEFRAME_MINUTES, Timeframe, TradingService, WALLET_XEXES, WS_SUBSCRIPTION_LIMITS, WalletService, WsCandlesService, WsTradesService, XGATE_EXCHANGES, XgateEx, XgateModule, assetClassOf, buildLevels, buildProtection, candlesMaxHistoryOf, candlesPerCallOf, canonicalFromBase, canonicalFromXex, expiryOf, isDated, multiplierFromXex, restThrottleOf, roundPrice, roundToStep, servesNatively, servesSpot, sourceFor, subscriptionLimitOf, timeframeMs };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map