@blackcube/xgate-sdk 0.56.2 → 0.58.0

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.
@@ -1623,6 +1735,8 @@ exports.TradingService = class TradingService {
    * disent la même chose**. La forme native complète reste dans `xtras`, rien n'est perdu.
    *
    * **blofin ne l'expose pas** et lève ; les sept autres le servent.
+   *
+   * **hyperliquid en compte unifié lit le spot** (`unifiedAccountState`) : son état perp y vaut 0.
    */
   async accountInfo(access) {
     const perp = this.perpOf(access);
@@ -1632,7 +1746,42 @@ exports.TradingService = class TradingService {
       );
     }
     const brut = await perp.getAccountInfo();
-    return this.toAccountState(brut, access.xex);
+    const etat = this.toAccountState(brut, access.xex);
+    return access.xex === "hyperliquid" /* Hyperliquid */ ? this.unifiedAccountState(access, etat) : etat;
+  }
+  /**
+   * HYPERLIQUID EN COMPTE UNIFIÉ — l'argent vit dans le spot, et l'état perp affiche 0.
+   *
+   * La doc HL : « unified account and portfolio margin show all balances and holds in the spot
+   * clearinghouse state. Individual perp dex user states are not meaningful ». Lu côté perp, un
+   * compte unifié de 101 USDC rend une équité de 0 — et tout appelant qui dimensionne une mise sur
+   * l'équité refuse d'ouvrir (Blips, 2026-10-01 : « plafond d'engagement » sur un compte financé).
+   *
+   * Le mode est DEMANDÉ à HL (`getAbstraction`), jamais déduit des soldes : en mode standard
+   * (`disabled`), le spot ne finance pas les perps, et le compter fausserait l'équité dans l'autre
+   * sens. Hors `unifiedAccount`/`portfolioMargin`, l'état perp est rendu tel quel.
+   *
+   * L'équité est le total USDC du spot, le disponible ce total moins ce que HL bloque (`hold`).
+   * **Le PnL latent n'y est pas ajouté** (décision Philippe, 2026-10-01) : la doc ne dit pas si le
+   * total spot le contient déjà, et l'ajouter risquerait de le compter deux fois. En portfolio
+   * margin, les autres actifs éligibles (HYPE, BTC, USDT) ne sont pas comptés non plus : seul l'USDC
+   * finance ici. Le mode et le solde lu restent dans `xtras`.
+   */
+  async unifiedAccountState(access, etat) {
+    const source = createAccountXex(access.xex, access);
+    const abstraction = await source.native.account().getAbstraction();
+    if (abstraction.mode !== "unifiedAccount" && abstraction.mode !== "portfolioMargin") {
+      return etat;
+    }
+    const usdc = (await source.account().getBalances()).find((balance) => balance.asset === "USDC");
+    const total = usdc?.total ?? "0";
+    const hold = Number(usdc?.xtras?.hold ?? 0);
+    return {
+      ...etat,
+      equity: total,
+      available: String(Math.max(0, Number(total) - hold)),
+      xtras: { ...etat.xtras, abstraction: abstraction.mode, spotUsdc: usdc ?? null }
+    };
   }
   /**
    * RÈGLE LE LEVIER d'une paire, avant d'ouvrir.
@@ -1835,6 +1984,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),
@@ -1848,6 +1998,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", " ");
 }
@@ -2226,6 +2384,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",