@blackcube/xgate-sdk 0.24.0 → 0.25.0

package/README.md

@@ -230,12 +230,28 @@ venues.
 ## Le trading
 
 **Jamais un ordre sans stop.** `openWithProtection` est la seule façon d'ouvrir une position, et
-elle exige un `slPct`. La protection part **avec** l'entrée, en un geste que la venue traite
+elle exige un `sl`. La protection part **avec** l'entrée, en un geste que la venue traite
 atomiquement : si l'entrée ne remplit pas, la protection ne naît jamais.
 
-**L'appelant donne des pourcentages, jamais des prix.** XGate calcule les niveaux depuis le prix
-d'entrée, les arrondit à la grille de la paire, et garantit qu'au-delà de 80 % de parts cumulées la
-position ferme entièrement — sans reliquat de 0,01 qui traîne.
+### Un niveau se dit en écart OU en prix
+
+```typescript
+sl: { pct: 0.02 }        // 2 % sous l'entrée en long, 2 % au-dessus en short
+sl: { price: 62500 }     // exactement 62 500, quel que soit le prix d'entrée
+```
+
+Les deux façons de penser un objectif coexistent réellement : « je sors si ça monte de 10 % »
+raisonne en **risque**, « je sors si ça touche 62 500 » raisonne en **niveau technique**. Obliger à
+convertir l'un dans l'autre reviendrait à faire calculer l'appelant, donc à déplacer l'erreur chez
+lui. Les deux modes se mélangent librement dans le même appel.
+
+**`part` reste toujours une fraction de la POSITION** — les deux modes ne portent que sur le niveau.
+
+Le type rend l'ambiguïté impossible : `ITarget` est une union **exclusive**, donc
+`{ pct: 0.1, price: 62500 }` **ne compile pas**, et `{}` non plus.
+
+**XGate arrondit les niveaux à la grille de la paire** et garantit qu'au-delà de 80 % de parts
+cumulées la position ferme entièrement — sans reliquat de 0,01 qui traîne.
 
 ```typescript
 import { TradingService, XgateEx } from '@blackcube/xgate-sdk';
@@ -254,9 +270,9 @@ const orders = await trading.openWithProtection(access, {
   direction: 'long',
   size: 0.02,
   entry: 3120,
-  slPct: 0.02,                              // stop à 2 % sous l'entrée
+  sl: { pct: 0.02 },                        // stop à 2 % sous l'entrée
   tps: [{ pct: 0.03, part: 0.5 },           // 50 % à +3 %
-        { pct: 0.06, part: 0.5 }],          // 50 % à +6 % → somme 100 %, clôture intégrale
+        { price: 62500, part: 0.5 }],       // 50 % si le prix touche 62 500
   tif: 'ioc',
 });
 ```

package/dist/index.cjs

@@ -1077,6 +1077,13 @@ exports.SpotWsCandlesService = __decorateClass([
 ], exports.SpotWsCandlesService);
 
 // src/helpers/protection.ts
+function priceOf(cible, entry, direction, gagnant) {
+  if (cible.price !== void 0) {
+    return round8(cible.price);
+  }
+  const dir = (direction === "long" ? 1 : -1) * (gagnant === true ? 1 : -1);
+  return round8(entry * (1 + dir * cible.pct));
+}
 var SLIPPAGE_DEFAUT = 5e-3;
 var SEUIL_CLOTURE = 0.8;
 function round8(value) {
@@ -1119,12 +1126,8 @@ function buildLevels(entry, direction, slPct, tpPcts) {
 function buildProtection(input) {
   const slippage = input.slippagePct ?? SLIPPAGE_DEFAUT;
   const long = input.direction === "long";
-  const { sl, tps: niveaux } = buildLevels(
-    input.entry,
-    input.direction,
-    input.slPct,
-    input.tps.map((tp) => tp.pct)
-  );
+  const sl = priceOf(input.sl, input.entry, input.direction, false);
+  const niveaux = input.tps.map((tp) => priceOf(tp, input.entry, input.direction, true));
   const borne = (trigger) => long === true ? trigger * (1 - slippage) : trigger * (1 + slippage);
   const sommeParts = input.tps.reduce((total, tp) => total + tp.part, 0);
   const clotureIntegrale = sommeParts > SEUIL_CLOTURE;
@@ -1195,7 +1198,7 @@ exports.TradingService = class TradingService {
       entry: input.entry,
       direction: input.direction,
       size: input.size,
-      slPct: input.slPct,
+      sl: input.sl,
       tps: input.tps,
       tickSize: input.tickSize,
       lotSize: input.lotSize,