@blackcube/xgate-sdk 0.56.3 → 0.58.1

package/dist/index.cjs

@@ -1252,8 +1252,11 @@ exports.TradingService = 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
@@ -1316,27 +1319,25 @@ exports.TradingService = class TradingService {
       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) {
@@ -1345,8 +1346,119 @@ exports.TradingService = class TradingService {
       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.
@@ -1591,15 +1703,25 @@ exports.TradingService = 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.
    */
-  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é.
@@ -1872,6 +1994,7 @@ exports.TradingService = class TradingService {
       side: order.side,
       type: order.type,
       price: order.price,
+      triggerPrice: order.triggerPrice,
       size: order.size,
       filled: order.filled,
       status: this.toStatus(order.status),
@@ -1885,6 +2008,14 @@ exports.TradingService = class TradingService {
 exports.TradingService = __decorateClass([
   common.Injectable()
 ], exports.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", " ");
 }
@@ -2263,6 +2394,7 @@ exports.WsTradesService = class WsTradesService {
       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",