@blackcube/xgate-sdk 0.56.3 → 0.58.1

package/dist/index.d.cts

@@ -1323,6 +1323,8 @@ interface IOrder {
     type: OrderType;
     /** `null` pour un ordre au marché. */
     price: string | null;
+    /** Prix de DÉCLENCHEMENT d'un ordre conditionnel (stop, take-profit) ; `null` pour un ordre ordinaire. */
+    triggerPrice: string | null;
     /** Taille demandée, **en unités de base**. */
     size: string;
     /** Taille déjà exécutée, **en unités de base**. */
@@ -1335,6 +1337,24 @@ interface IOrder {
     placedAt: Date;
     xtras?: Record<string, unknown>;
 }
+/** Le rôle d'un ordre dans un trade : l'entrée, le stop, ou un take-profit. */
+type TradeOrderRole = 'entry' | 'sl' | 'tp';
+/**
+ * UN ORDRE DU TRADE — ce que {@link TradingService.openWithProtection} rend, une ligne par ordre posé.
+ *
+ * La même forme sur toutes les venues : l'appelant garde cette liste avec son trade et la gère sans savoir
+ * comment chaque venue a posé ses protections (hyperliquid en lot, aster une à une, pacifica embarquées dans
+ * l'entrée). C'est XGate qui fait le pont.
+ *
+ * **L'identifiant n'est vide que si l'ordre n'existe pas ou plus** — refusé, ou déjà consommé (un stop touché
+ * dans la seconde) : `status` dit lequel. Une venue qui ne rend pas l'identifiant d'une protection à l'envoi
+ * (hyperliquid `normalTpsl`, pacifica embarqué) le voit retrouvé au carnet par XGate.
+ */
+interface ITradeOrder extends IOrder {
+    role: TradeOrderRole;
+    /** La fraction de la position initiale que l'ordre couvre : 1 pour l'entrée et le stop. */
+    part: number;
+}
 /**
  * UNE POSITION ouverte.
  *
@@ -1562,8 +1582,11 @@ declare class TradingService {
     /**
      * OUVRE UNE POSITION AVEC SA PROTECTION, en un geste atomique.
      *
-     * Le premier ordre rendu est **l'entrée** ; les suivants sont le stop et les take-profits, dans
-     * l'ordre où ils ont été posés.
+     * **Ce qui revient est la liste des ORDRES DU TRADE** ({@link ITradeOrder}), la même sur toutes les
+     * venues : l'entrée, le stop, puis chaque take-profit dans l'ordre du plan — chacun avec son rôle, sa
+     * part et un identifiant réel, retrouvé au carnet quand la venue ne l'a pas rendu à l'envoi (0.58.0,
+     * cf. `ordresDuTrade`). L'appelant la garde avec son trade : annuler une protection, c'est
+     * {@link cancel} sur son identifiant, quel que soit le rôle.
      *
      * 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
@@ -1584,7 +1607,27 @@ declare class TradingService {
      * 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[]>;
+    openWithProtection(access: ITradingAccess, input: IEntryWithProtection): Promise<ITradeOrder[]>;
+    /**
+     * LES ORDRES DU TRADE, rangés par rôle — la même liste sur toutes les venues.
+     *
+     * Chaque venue rend ses ordres à sa façon (mesuré sur testnet le 2026-10-01) : hyperliquid en lot `'na'` rend
+     * tous les identifiants, en `normalTpsl` (un seul take-profit) AUCUN pour le stop et la cible (`waitingForFill`,
+     * `waitingForTrigger`) ; pacifica ne rend que l'entrée, le stop et la première cible embarqués naissant au
+     * carnet sans lien (`parent_id: null`) ; aster pose une à une et rend tout.
+     *
+     * On range donc ce qui est revenu : l'entrée est le premier ordre non reduce-only ; le stop et chaque cible
+     * sont reconnus par leur TYPE et leur PRIX DE DÉCLENCHEMENT — ceux qu'XGate vient de calculer, arrondis à la
+     * grille, donc ceux que la venue a posés. Ce qui manque est cherché au CARNET de la paire, par la même
+     * reconnaissance — le procédé que le SDK pacifica applique déjà à ses take-profits (`placeTakeProfit`).
+     *
+     * Un ordre introuvable garde un identifiant VIDE : refusé, ou déjà consommé (un stop touché dans la seconde,
+     * DOT le 2026-10-01). **Mais une position ouverte dont le stop est introuvable lève** : c'est la position
+     * nue que ce service existe pour empêcher, et l'appelant doit le savoir tout de suite.
+     */
+    private ordresDuTrade;
+    /** Un ordre du trade que la venue n'a pas posé, ou qui n'existe déjà plus — identifiant VIDE. */
+    private ordreAbsent;
     /**
      * POSE LES CIBLES QUE LA VENUE N'A PAS EMBARQUÉES, une fois l'entrée remplie.
      *
@@ -1661,10 +1704,13 @@ declare class TradingService {
      * take-profit peut remplir en plusieurs fois. Seul l'historique porte le prix réellement obtenu, et
      * c'est lui qui doit servir au calcul du résultat — sinon le PnL affiché est une fiction.
      *
-     * On retient le **dernier** ordre de sortie rempli après `openedAt` : les précédents sont les
-     * take-profits partiels, celui-là est la clôture.
+     * On lit les **exécutions** (`trades`), jamais les ordres : le prix d'un ordre est sa LIMITE — chez
+     * hyperliquid, un market est un IOC borné à mark ± glissement, et son « prix » est cette borne, pas le
+     * prix obtenu (BNB, 2026-10-01 : sortie lue à 844,44 pour des fills à 767,69). Le prix de sortie est la
+     * moyenne des exécutions de sortie après `openedAt` — et avant `until` quand il est donné — pondérée par
+     * leur taille : TP partiels et clôture compris, c'est le prix auquel la position est réellement sortie.
      */
-    exitPrice(access: ITradingAccess, symbolXex: string, direction: Direction, openedAt: Date): Promise<string | null>;
+    exitPrice(access: ITradingAccess, symbolXex: string, direction: Direction, openedAt: Date, until?: Date): Promise<string | null>;
     /**
      * L'HISTORIQUE DES ORDRES du compte — ce qui a été soumis, rempli, annulé ou expiré.
      *
@@ -1960,4 +2006,4 @@ declare function expiryOf(xtras?: Record<string, unknown>): Date | undefined;
  */
 declare function isDated(xtras?: Record<string, unknown>): boolean;
 
-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 };
+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 ITradeOrder, 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, type TradeOrderRole, 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

@@ -1323,6 +1323,8 @@ interface IOrder {
     type: OrderType;
     /** `null` pour un ordre au marché. */
     price: string | null;
+    /** Prix de DÉCLENCHEMENT d'un ordre conditionnel (stop, take-profit) ; `null` pour un ordre ordinaire. */
+    triggerPrice: string | null;
     /** Taille demandée, **en unités de base**. */
     size: string;
     /** Taille déjà exécutée, **en unités de base**. */
@@ -1335,6 +1337,24 @@ interface IOrder {
     placedAt: Date;
     xtras?: Record<string, unknown>;
 }
+/** Le rôle d'un ordre dans un trade : l'entrée, le stop, ou un take-profit. */
+type TradeOrderRole = 'entry' | 'sl' | 'tp';
+/**
+ * UN ORDRE DU TRADE — ce que {@link TradingService.openWithProtection} rend, une ligne par ordre posé.
+ *
+ * La même forme sur toutes les venues : l'appelant garde cette liste avec son trade et la gère sans savoir
+ * comment chaque venue a posé ses protections (hyperliquid en lot, aster une à une, pacifica embarquées dans
+ * l'entrée). C'est XGate qui fait le pont.
+ *
+ * **L'identifiant n'est vide que si l'ordre n'existe pas ou plus** — refusé, ou déjà consommé (un stop touché
+ * dans la seconde) : `status` dit lequel. Une venue qui ne rend pas l'identifiant d'une protection à l'envoi
+ * (hyperliquid `normalTpsl`, pacifica embarqué) le voit retrouvé au carnet par XGate.
+ */
+interface ITradeOrder extends IOrder {
+    role: TradeOrderRole;
+    /** La fraction de la position initiale que l'ordre couvre : 1 pour l'entrée et le stop. */
+    part: number;
+}
 /**
  * UNE POSITION ouverte.
  *
@@ -1562,8 +1582,11 @@ declare class TradingService {
     /**
      * OUVRE UNE POSITION AVEC SA PROTECTION, en un geste atomique.
      *
-     * Le premier ordre rendu est **l'entrée** ; les suivants sont le stop et les take-profits, dans
-     * l'ordre où ils ont été posés.
+     * **Ce qui revient est la liste des ORDRES DU TRADE** ({@link ITradeOrder}), la même sur toutes les
+     * venues : l'entrée, le stop, puis chaque take-profit dans l'ordre du plan — chacun avec son rôle, sa
+     * part et un identifiant réel, retrouvé au carnet quand la venue ne l'a pas rendu à l'envoi (0.58.0,
+     * cf. `ordresDuTrade`). L'appelant la garde avec son trade : annuler une protection, c'est
+     * {@link cancel} sur son identifiant, quel que soit le rôle.
      *
      * 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
@@ -1584,7 +1607,27 @@ declare class TradingService {
      * 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[]>;
+    openWithProtection(access: ITradingAccess, input: IEntryWithProtection): Promise<ITradeOrder[]>;
+    /**
+     * LES ORDRES DU TRADE, rangés par rôle — la même liste sur toutes les venues.
+     *
+     * Chaque venue rend ses ordres à sa façon (mesuré sur testnet le 2026-10-01) : hyperliquid en lot `'na'` rend
+     * tous les identifiants, en `normalTpsl` (un seul take-profit) AUCUN pour le stop et la cible (`waitingForFill`,
+     * `waitingForTrigger`) ; pacifica ne rend que l'entrée, le stop et la première cible embarqués naissant au
+     * carnet sans lien (`parent_id: null`) ; aster pose une à une et rend tout.
+     *
+     * On range donc ce qui est revenu : l'entrée est le premier ordre non reduce-only ; le stop et chaque cible
+     * sont reconnus par leur TYPE et leur PRIX DE DÉCLENCHEMENT — ceux qu'XGate vient de calculer, arrondis à la
+     * grille, donc ceux que la venue a posés. Ce qui manque est cherché au CARNET de la paire, par la même
+     * reconnaissance — le procédé que le SDK pacifica applique déjà à ses take-profits (`placeTakeProfit`).
+     *
+     * Un ordre introuvable garde un identifiant VIDE : refusé, ou déjà consommé (un stop touché dans la seconde,
+     * DOT le 2026-10-01). **Mais une position ouverte dont le stop est introuvable lève** : c'est la position
+     * nue que ce service existe pour empêcher, et l'appelant doit le savoir tout de suite.
+     */
+    private ordresDuTrade;
+    /** Un ordre du trade que la venue n'a pas posé, ou qui n'existe déjà plus — identifiant VIDE. */
+    private ordreAbsent;
     /**
      * POSE LES CIBLES QUE LA VENUE N'A PAS EMBARQUÉES, une fois l'entrée remplie.
      *
@@ -1661,10 +1704,13 @@ declare class TradingService {
      * take-profit peut remplir en plusieurs fois. Seul l'historique porte le prix réellement obtenu, et
      * c'est lui qui doit servir au calcul du résultat — sinon le PnL affiché est une fiction.
      *
-     * On retient le **dernier** ordre de sortie rempli après `openedAt` : les précédents sont les
-     * take-profits partiels, celui-là est la clôture.
+     * On lit les **exécutions** (`trades`), jamais les ordres : le prix d'un ordre est sa LIMITE — chez
+     * hyperliquid, un market est un IOC borné à mark ± glissement, et son « prix » est cette borne, pas le
+     * prix obtenu (BNB, 2026-10-01 : sortie lue à 844,44 pour des fills à 767,69). Le prix de sortie est la
+     * moyenne des exécutions de sortie après `openedAt` — et avant `until` quand il est donné — pondérée par
+     * leur taille : TP partiels et clôture compris, c'est le prix auquel la position est réellement sortie.
      */
-    exitPrice(access: ITradingAccess, symbolXex: string, direction: Direction, openedAt: Date): Promise<string | null>;
+    exitPrice(access: ITradingAccess, symbolXex: string, direction: Direction, openedAt: Date, until?: Date): Promise<string | null>;
     /**
      * L'HISTORIQUE DES ORDRES du compte — ce qui a été soumis, rempli, annulé ou expiré.
      *
@@ -1960,4 +2006,4 @@ declare function expiryOf(xtras?: Record<string, unknown>): Date | undefined;
  */
 declare function isDated(xtras?: Record<string, unknown>): boolean;
 
-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 };
+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 ITradeOrder, 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, type TradeOrderRole, 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

@@ -1250,8 +1250,11 @@ var TradingService = class {
   /**
    * OUVRE UNE POSITION AVEC SA PROTECTION, en un geste atomique.
    *
-   * Le premier ordre rendu est **l'entrée** ; les suivants sont le stop et les take-profits, dans
-   * l'ordre où ils ont été posés.
+   * **Ce qui revient est la liste des ORDRES DU TRADE** ({@link ITradeOrder}), la même sur toutes les
+   * venues : l'entrée, le stop, puis chaque take-profit dans l'ordre du plan — chacun avec son rôle, sa
+   * part et un identifiant réel, retrouvé au carnet quand la venue ne l'a pas rendu à l'envoi (0.58.0,
+   * cf. `ordresDuTrade`). L'appelant la garde avec son trade : annuler une protection, c'est
+   * {@link cancel} sur son identifiant, quel que soit le rôle.
    *
    * 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
@@ -1314,27 +1317,25 @@ var TradingService = class {
       tps: protection.tps,
       clientId: input.clientId
     };
+    let posees;
     try {
       const orders = await perp.createEntryWithProtection(entry, consigne);
-      const posees = orders.map((order) => this.toOrder(order, access.xex));
+      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") {
+      if (enAttente.length > 0 && (tif === "ioc" || tif === "fok")) {
+        const complement = await this.poserCiblesEnAttente(
+          access,
+          perp,
+          input.symbolXex,
+          side,
+          enAttente
+        );
+        posees = [...posees, ...complement];
+      } else if (enAttente.length > 0) {
         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) {
@@ -1343,8 +1344,119 @@ var TradingService = class {
       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);
+      posees = await this.etatApres(access, input.symbolXex);
     }
+    return await this.ordresDuTrade(access, perp, input, side, protection, posees);
+  }
+  /**
+   * LES ORDRES DU TRADE, rangés par rôle — la même liste sur toutes les venues.
+   *
+   * Chaque venue rend ses ordres à sa façon (mesuré sur testnet le 2026-10-01) : hyperliquid en lot `'na'` rend
+   * tous les identifiants, en `normalTpsl` (un seul take-profit) AUCUN pour le stop et la cible (`waitingForFill`,
+   * `waitingForTrigger`) ; pacifica ne rend que l'entrée, le stop et la première cible embarqués naissant au
+   * carnet sans lien (`parent_id: null`) ; aster pose une à une et rend tout.
+   *
+   * On range donc ce qui est revenu : l'entrée est le premier ordre non reduce-only ; le stop et chaque cible
+   * sont reconnus par leur TYPE et leur PRIX DE DÉCLENCHEMENT — ceux qu'XGate vient de calculer, arrondis à la
+   * grille, donc ceux que la venue a posés. Ce qui manque est cherché au CARNET de la paire, par la même
+   * reconnaissance — le procédé que le SDK pacifica applique déjà à ses take-profits (`placeTakeProfit`).
+   *
+   * Un ordre introuvable garde un identifiant VIDE : refusé, ou déjà consommé (un stop touché dans la seconde,
+   * DOT le 2026-10-01). **Mais une position ouverte dont le stop est introuvable lève** : c'est la position
+   * nue que ce service existe pour empêcher, et l'appelant doit le savoir tout de suite.
+   */
+  async ordresDuTrade(access, perp, input, side, protection, posees) {
+    const exit = side === "buy" ? "sell" : "buy";
+    const part = (size) => Number(size) / input.size;
+    const entree = posees.find((order) => order.reduceOnly !== true) ?? null;
+    const rejetee = entree !== null && entree.status === "rejected";
+    const pris = /* @__PURE__ */ new Set();
+    const attendus = [
+      { role: "sl", leg: protection.sl },
+      ...protection.tps.map((leg) => ({ role: "tp", leg }))
+    ];
+    const reconnaitre = (pool, role, leg) => pool.find(
+      (order) => order.id !== "" && pris.has(order.id) === false && estDuRole(order.type, role) === true && (order.triggerPrice === null || memePrix(order.triggerPrice, leg.triggerPrice) === true)
+    );
+    let carnet = null;
+    const lireCarnet = async () => {
+      if (carnet === null) {
+        carnet = (await perp.getOpens()).map((order) => this.toOrder(order, access.xex)).filter((order) => order.symbolXex === input.symbolXex && order.reduceOnly === true);
+      }
+      return carnet;
+    };
+    const ordres = [
+      entree === null ? this.ordreAbsent(
+        access,
+        input,
+        "entry",
+        side,
+        "limit",
+        1,
+        null,
+        String(input.size),
+        "other"
+      ) : { ...entree, role: "entry", part: 1 }
+    ];
+    for (const { role, leg } of attendus) {
+      let trouve = reconnaitre(posees, role, leg);
+      if (trouve === void 0 && rejetee === false) {
+        trouve = reconnaitre(await lireCarnet(), role, leg);
+      }
+      if (trouve !== void 0) {
+        pris.add(trouve.id);
+        ordres.push({ ...trouve, role, part: part(leg.size) });
+      } else {
+        ordres.push(
+          this.ordreAbsent(
+            access,
+            input,
+            role,
+            exit,
+            role === "sl" ? "stopMarket" : "takeProfitMarket",
+            part(leg.size),
+            leg.triggerPrice,
+            leg.size,
+            rejetee === true ? "canceled" : "other"
+          )
+        );
+      }
+    }
+    const stop = ordres.find((order) => order.role === "sl");
+    if (rejetee === false && stop !== void 0 && stop.id === "") {
+      const positions = await perp.getPositions({ name: input.symbolXex });
+      const ouverte = positions.find(
+        (candidate) => candidate.name === input.symbolXex && Number(candidate.size) !== 0
+      );
+      if (ouverte !== void 0) {
+        throw new Error(
+          `openWithProtection(${access.xex}/${input.symbolXex}) : POSITION NUE \u2014 ${ouverte.size} ouvert, stop introuvable au carnet. \xC0 prot\xE9ger imm\xE9diatement.`
+        );
+      }
+    }
+    return ordres;
+  }
+  /** Un ordre du trade que la venue n'a pas posé, ou qui n'existe déjà plus — identifiant VIDE. */
+  ordreAbsent(access, input, role, side, type, part, triggerPrice, size, status) {
+    return {
+      xex: access.xex,
+      symbolXex: input.symbolXex,
+      kind: "perp",
+      id: "",
+      clientId: null,
+      side,
+      type,
+      price: null,
+      triggerPrice,
+      size,
+      filled: "0",
+      status,
+      tif: null,
+      reduceOnly: role !== "entry",
+      placedAt: /* @__PURE__ */ new Date(),
+      role,
+      part
+    };
   }
   /**
    * POSE LES CIBLES QUE LA VENUE N'A PAS EMBARQUÉES, une fois l'entrée remplie.
@@ -1589,15 +1701,25 @@ var TradingService = class {
    * take-profit peut remplir en plusieurs fois. Seul l'historique porte le prix réellement obtenu, et
    * c'est lui qui doit servir au calcul du résultat — sinon le PnL affiché est une fiction.
    *
-   * On retient le **dernier** ordre de sortie rempli après `openedAt` : les précédents sont les
-   * take-profits partiels, celui-là est la clôture.
+   * On lit les **exécutions** (`trades`), jamais les ordres : le prix d'un ordre est sa LIMITE — chez
+   * hyperliquid, un market est un IOC borné à mark ± glissement, et son « prix » est cette borne, pas le
+   * prix obtenu (BNB, 2026-10-01 : sortie lue à 844,44 pour des fills à 767,69). Le prix de sortie est la
+   * moyenne des exécutions de sortie après `openedAt` — et avant `until` quand il est donné — pondérée par
+   * leur taille : TP partiels et clôture compris, c'est le prix auquel la position est réellement sortie.
    */
-  async exitPrice(access, symbolXex, direction, openedAt) {
+  async exitPrice(access, symbolXex, direction, openedAt, until) {
     const exit = direction === "long" ? "sell" : "buy";
-    const history = await this.perpOf(access).getHistory({ name: symbolXex });
-    const exits = history.filter((order) => order.name === symbolXex && order.side === exit).filter((order) => order.status === "filled" || order.status === "partiallyFilled").filter((order) => order.placedAt.getTime() > openedAt.getTime()).filter((order) => order.price !== null && Number(order.price) > 0).sort((left, right) => right.placedAt.getTime() - left.placedAt.getTime());
-    const last = exits[0];
-    return last === void 0 ? null : last.price;
+    const fin = until === void 0 ? Number.POSITIVE_INFINITY : until.getTime();
+    const fills = (await this.trades(access)).filter((fill) => fill.symbolXex === symbolXex && fill.side === exit).filter(
+      (fill) => fill.filledAt.getTime() > openedAt.getTime() && fill.filledAt.getTime() <= fin
+    ).filter((fill) => Number(fill.price) > 0 && Number(fill.size) > 0);
+    const taille = fills.reduce((total, fill) => total + Number(fill.size), 0);
+    if (taille === 0) {
+      return null;
+    }
+    const moyenne = fills.reduce((total, fill) => total + Number(fill.price) * Number(fill.size), 0) / taille;
+    const decimales = Math.max(...fills.map((fill) => (fill.price.split(".")[1] ?? "").length));
+    return String(Number(moyenne.toFixed(decimales)));
   }
   /**
    * L'HISTORIQUE DES ORDRES du compte — ce qui a été soumis, rempli, annulé ou expiré.
@@ -1870,6 +1992,7 @@ var TradingService = class {
       side: order.side,
       type: order.type,
       price: order.price,
+      triggerPrice: order.triggerPrice,
       size: order.size,
       filled: order.filled,
       status: this.toStatus(order.status),
@@ -1883,6 +2006,14 @@ var TradingService = class {
 TradingService = __decorateClass([
   Injectable()
 ], TradingService);
+function estDuRole(type, role) {
+  return role === "sl" ? type === "stop" || type === "stopMarket" : type === "takeProfit" || type === "takeProfitMarket";
+}
+function memePrix(lu, pose) {
+  const a = Number(lu);
+  const b = Number(pose);
+  return Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(b));
+}
 function toXexDate(date) {
   return date.toISOString().slice(0, 19).replace("T", " ");
 }
@@ -2261,6 +2392,7 @@ var WsTradesService = class {
       side: order.side,
       type: order.type,
       price: order.price,
+      triggerPrice: order.triggerPrice,
       size: order.size,
       filled: order.filled,
       status: ORDER_STATUSES.includes(order.status) ? order.status : "other",