@blackcube/xgate-sdk 0.56.0 → 0.56.2

package/dist/index.d.cts

@@ -1490,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.
@@ -1564,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.
      *

package/dist/index.d.ts

@@ -1490,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.
@@ -1564,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.
      *

package/dist/index.js

@@ -1256,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) {
@@ -1263,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,
@@ -1280,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
     };
@@ -1299,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) {
@@ -1311,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.
    *