@blackcube/xgate-sdk 0.56.0 → 0.56.1

package/README.md

@@ -226,10 +226,20 @@ donc à risquer plusieurs sockets pour la même venue.
 Le cycle de vie d'une position tient en trois gestes, et chacun préserve le même invariant : la
 position n'est jamais sans stop.
 
+**Tout ce qui part est à la grille de la paire** — l'entrée comme le stop et les cibles (`tickSize`,
+sinon la règle hyperliquid : cinq chiffres significatifs, `6 − szDecimals` décimales). Jusqu'en
+0.56.0 l'entrée partait telle quelle ; pacifica refuse un prix hors tick.
+
+**Pacifica n'embarque qu'un take-profit dans l'ordre d'entrée.** Les suivants sont posés par XGate en
+déclenchés reduce-only après une entrée immédiate (`ioc`, `fok`), une fois la position relue ; après
+une entrée qui peut rester au carnet (`gtc`, `alo`), c'est l'appelant qui les pose par
+`completeProtection` quand il constate le fill — une fois, jamais deux.
+
 | geste | méthode | venues |
 |---|---|---|
 | régler le levier | `setLeverage` | toutes sauf bullet |
 | ouvrir avec sa protection | `openWithProtection` | hyperliquid, pacifica |
+| poser les cibles qu'une venue n'embarque pas, une fois l'entrée remplie | `completeProtection` | pacifica (rien à poser ailleurs) |
 | déplacer le stop | `moveStop` | hyperliquid, pacifica, aster |
 | fermer sans reliquat | `closePosition` | toutes celles qui tradent |
 | relire le prix de sortie réel | `exitPrice` | toutes celles qui tradent |

package/dist/index.cjs

@@ -1258,6 +1258,21 @@ exports.TradingService = 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.
    */
   async openWithProtection(access, input) {
     if (VENUES_PROUVEES.includes(access.xex) === false) {
@@ -1265,8 +1280,9 @@ exports.TradingService = class TradingService {
         `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,
@@ -1282,13 +1298,14 @@ exports.TradingService = class TradingService {
         `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
     };
@@ -1301,7 +1318,25 @@ exports.TradingService = class TradingService {
     };
     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) {
@@ -1313,6 +1348,79 @@ exports.TradingService = class TradingService {
       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.
    *