@blackcube/xgate-sdk 0.22.0 → 0.24.0

package/dist/index.d.cts

@@ -312,6 +312,120 @@ declare class WsCandlesService {
     private quoteOf;
 }
 
+/**
+ * LE FLUX DE BOUGIES D'UNE VENUE — porté de
+ * `Blips/server/src/candles/services/internal/dex-candles-stream.service.ts`, où il tourne en
+ * production. Même surface, mêmes garanties ; seul le type de bougie change (celui d'XGate).
+ *
+ * **UNE INSTANCE PAR VENUE, DONC UNE SOCKET PAR VENUE.** La façade est mémoïsée (`instance()`) et
+ * `ws()` n'est appelé qu'une fois, hors de la boucle : les N souscriptions partagent la même
+ * connexion. Créer la façade à chaque souscription ouvrirait une socket par marché — 200 marchés
+ * suivis, 200 sockets, quand hyperliquid n'en accepte que 10 par IP.
+ *
+ * **UNE SOUSCRIPTION PAR MARCHÉ, et non `subscribeAllCandles`.** Ce dernier ne coûte qu'un
+ * abonnement, mais il est bâti sur un flux de prix agrégé : mesuré le 2026-08-02, il rend un prix
+ * MILIEU (40 % des valeurs sur un demi-tick contre 8 % au REST) et AUCUN volume (`"v":"0"` sur les
+ * six dex). Le canal `candle` par marché rend la vraie bougie de trades, avec son volume.
+ *
+ * **LE SYMBOLE VIENT DU MESSAGE**, jamais de la souscription. Les SDK hyperliquid et pacifica
+ * livraient tout le canal à tous les abonnés jusqu'à la 0.15.0 — trois souscriptions recevaient le
+ * même flux. C'est corrigé, mais la règle reste : on lit ce que le wire déclare, on ne suppose pas.
+ */
+declare class CandlesStreamService {
+    readonly xex: XgateEx;
+    /** Le marché écouté. Le comptant n'est servi que par binance et bybit. */
+    readonly kind: MarketKind;
+    private readonly logger;
+    private source;
+    private readonly unsubscribes;
+    /** Le plafond de souscriptions documenté par la venue, ou `null` si personne ne l'a publié. */
+    readonly maxSubscriptions: number | null;
+    constructor(xex: XgateEx, 
+    /** Le marché écouté. Le comptant n'est servi que par binance et bybit. */
+    kind?: MarketKind);
+    /**
+     * Ouvre le flux sur une LISTE de marchés, sur une seule socket.
+     *
+     * **UNE ERREUR DE FLUX COUPE TOUT, PUIS LÈVE.** Elle n'arrive pas à la souscription : mesuré le
+     * 2026-08-07, la venue accepte un symbole inconnu sans broncher, puis ferme la connexion en le
+     * découvrant. Le SDK reconnecte, elle referme — cinq cycles en douze secondes, et sur une socket
+     * partagée **tous** les marchés valides cessent de recevoir, en silence.
+     *
+     * On refuse cette boucle : à la première erreur, les souscriptions sont coupées, l'incident est
+     * journalisé en `error`, et l'exception part. Un flux à moitié mort qui se tait coûte plus cher
+     * qu'un arrêt franc — on ne découvre le premier qu'en constatant l'absence de données.
+     *
+     * ⚠️ L'exception naît dans un rappel de socket : elle ne remonte pas à l'appelant de `start()`,
+     * elle sort en erreur non capturée. C'est délibéré — elle doit être impossible à ignorer.
+     *
+     * **binance et bybit ne remontent pas encore leurs erreurs** : leur client gère la fermeture en
+     * interne sans l'exposer. Sur ces deux venues, la boucle silencieuse reste possible.
+     */
+    start(symbolsXex: string[], interval: Timeframe, onCandle: (candle: ICandle) => void): void;
+    /** Coupe tout. Un désabonnement qui échoue ne doit pas empêcher les autres de se fermer. */
+    stop(): void;
+    /** Le nombre de souscriptions ouvertes. La liste des désabonnements EST le compteur. */
+    subscriptionCount(): number;
+    /**
+     * Le client temps réel, sur le bon marché.
+     *
+     * Les deux contrats ne signent pas `ws()` pareil, et c'est voulu : côté comptant le marché est
+     * **obligatoire** (`ws('spot')`), parce que les façades ouvrent du perpétuel par défaut — un
+     * `ws()` nu y diffuserait des prix de perpétuel à qui croit écouter le comptant.
+     */
+    private wire;
+    /** La façade de la venue, créée une seule fois : c'est elle qui porte la socket partagée. */
+    private instance;
+    /** Voir `CandlesService.quoteOf` : la cotation se déduit du symbole natif, faute d'être publiée. */
+    private quoteOf;
+}
+/**
+ * LA FAÇADE : un flux par venue, et un seul.
+ *
+ * Blips instancie `DexCandlesStreamService` une fois par venue et garde la référence. XGate offre
+ * la même chose sans que l'appelant ait à tenir cette table : `of(xex)` rend **toujours la même
+ * instance** pour une venue et un marché donnés — donc toujours la même socket.
+ *
+ * Demander deux fois `of(hyperliquid)` et souscrire 100 marchés à chaque fois ouvre **une** socket
+ * avec 200 souscriptions, pas deux sockets. C'est exactement ce qui manquait.
+ */
+declare class CandlesStreamRegistry {
+    private readonly streams;
+    /** Le flux d'une venue, créé au premier appel puis réutilisé. */
+    of(xex: XgateEx, kind?: MarketKind): CandlesStreamService;
+    /** Coupe tous les flux ouverts, toutes venues confondues. */
+    stopAll(): void;
+    /** Ce qui est ouvert, par venue — pour surveiller sans avoir à tenir de compteur soi-même. */
+    counts(): Record<string, number>;
+}
+
+/**
+ * LES PLAFONDS DE SOUSCRIPTION, PAR VENUE — uniquement ceux qu'une documentation officielle donne.
+ *
+ * Repris de `Blips/server/src/candles/services/internal/dex-candles-stream.service.ts`, où ils ont
+ * été établis puis vérifiés en réel.
+ *
+ * **aster**, section « Websocket Market Streams » : « A single connection can listen to a maximum
+ * of 200 streams », et « A connection that goes beyond the limit will be disconnected; IPs that are
+ * repeatedly disconnected may be banned ». Vérifié le 2026-08-03 sur `fstream.asterdex.com` : 200
+ * tiennent, 300 tuent la connexion.
+ * <https://github.com/asterdex/api-docs/blob/master/V3(Recommended)/EN/aster-finance-futures-api-v3.md>
+ *
+ * **hyperliquid** : 1 000 souscriptions et 10 connexions par IP.
+ *
+ * **Une venue ABSENTE de cette table n'a pas de plafond DOCUMENTÉ** — ce qui n'est pas la même
+ * chose que « pas de plafond ». On ne devine aucun chiffre : le jour où l'une d'elles s'en
+ * approche, on lit sa documentation et on l'ajoute.
+ */
+declare const WS_SUBSCRIPTION_LIMITS: Partial<Record<XgateEx, number>>;
+/**
+ * Le plafond documenté d'une venue, ou `undefined` si personne ne l'a publié.
+ *
+ * Rendre `Infinity` par défaut serait un mensonge commode : l'absence de plafond connu n'est pas
+ * une garantie d'illimité.
+ */
+declare function subscriptionLimitOf(xex: XgateEx): number | undefined;
+
 /**
  * UNE COTATION, TELLE QU'XGATE LA REND — quelle que soit la venue d'où elle vient.
  *
@@ -433,10 +547,13 @@ declare class SpotCatalogService {
  * comptant, sans que rien ne le signale. Deux marchés, deux services ; l'appelant choisit
  * explicitement ce qu'il interroge.
  *
- * La différence n'est pas cosmétique : le perpétuel porte un funding et peut s'écarter du comptant,
- * et **les échelles de cotation diffèrent d'un marché à l'autre** — `SATSUSDT` au comptant chez
- * bybit cote ×1 quand son perpétuel cote ×10000. Mélanger les deux séries fabriquerait un graphe
- * qui saute d'un facteur 10 000.
+ * La différence n'est pas cosmétique : **le perpétuel porte un funding et s'écarte du comptant**.
+ * C'est cet écart que certaines stratégies exploitent — le confondre le rendrait invisible.
+ *
+ * En revanche, les échelles de cotation ne posent aucun problème entre les deux marchés :
+ * `SATSUSDT` (×1) et `10000SATSUSDT` (×10000) sont **deux paires distinctes**, chacune portant son
+ * `multiplier` au catalogue. Une bougie appartient à une paire, identifiée par `xex` +
+ * `symbolXex` + `kind` : il n'y a rien à réconcilier.
  *
  * **Aucune agrégation ici**, contrairement au perpétuel : binance et bybit servent nativement tous
  * les intervalles de `1m` à `1w`. Le jour où une venue comptant en manquerait un, ce serait à
@@ -463,6 +580,70 @@ declare class SpotCandlesService {
     candlesOf(xexes: XgateEx[], query: ICandlesQuery): Promise<ICandle[]>;
 }
 
+/**
+ * LES PRIX DU **COMPTANT** — binance et bybit.
+ *
+ * Séparé de `PricesService` comme le catalogue et les bougies le sont : deux marchés, deux
+ * services. Ici la raison est encore plus directe qu'ailleurs — **un prix comptant et un prix
+ * perpétuel ne sont pas le même nombre**. Le perpétuel porte un funding et s'écarte du comptant ;
+ * c'est justement cet écart que certaines stratégies exploitent, et le confondre le rendrait
+ * invisible.
+ *
+ * **La moitié des champs sont `null` au comptant, et c'est correct** : `mark`, `oracle`, `funding`
+ * et `openInterest` n'existent que pour un perpétuel. Le comptant renseigne `bid`, `ask`, `last`,
+ * `volume24h` — ce qui est mesuré, pas ce qui est dérivé d'un contrat.
+ */
+declare class SpotPricesService {
+    private readonly logger;
+    /** Les venues dont XGate sert les prix comptant. */
+    venues(): readonly XgateEx[];
+    /**
+     * Les prix comptant d'une ou plusieurs venues, en une seule liste.
+     *
+     * Même politique d'échec que partout : seule, une venue en échec fait échouer l'appel ; parmi
+     * d'autres, elle est journalisée et ignorée. Chaque prix porte son `xex`.
+     */
+    prices(...xexes: XgateEx[]): Promise<IPrice[]>;
+    /** Les prix comptant d'UNE venue, traduits vers {@link IPrice}. */
+    private pricesOf;
+}
+
+/**
+ * LES BOUGIES DU **COMPTANT** EN TEMPS RÉEL — binance et bybit.
+ *
+ * Le pendant de `WsCandlesService`, sur l'autre marché. La séparation n'est pas une symétrie
+ * décorative : les façades exposent `ws(kind = 'perp')`, donc **un `ws()` nu ouvre un flux de
+ * perpétuels**. Un service unique qui aurait oublié de passer le marché aurait diffusé des prix
+ * de perpétuel à qui croyait écouter le comptant — deux séries voisines, jamais égales, et rien
+ * pour le signaler.
+ *
+ * Le contrat {@link IXexSpotSource} exige donc `ws('spot')` explicitement, sans valeur par défaut.
+ */
+declare class SpotWsCandlesService {
+    private readonly logger;
+    /** Les venues dont XGate diffuse le comptant en temps réel. */
+    venues(): readonly XgateEx[];
+    /**
+     * Souscrit aux bougies **comptant** d'un marché. Rend la fonction de désabonnement.
+     *
+     * Le handler reçoit une bougie à la fois, au format unifié ; la bougie en cours est repoussée à
+     * chaque mise à jour tant qu'elle n'est pas close.
+     */
+    subscribe(xex: XgateEx, query: {
+        symbol: string;
+        interval: Timeframe;
+    }, handler: (candle: ICandle) => void): Unsubscribe;
+    /**
+     * Souscrit au MÊME marché comptant chez plusieurs venues, avec un seul handler.
+     *
+     * Chaque bougie porte son `xex`. La fonction rendue coupe tous les flux d'un coup.
+     */
+    subscribeAll(xexes: XgateEx[], query: {
+        symbol: string;
+        interval: Timeframe;
+    }, handler: (candle: ICandle) => void): Unsubscribe;
+}
+
 /** Une paire, telle qu'un SDK de venue la rend. */
 interface IXexPair {
     name: string;
@@ -555,6 +736,18 @@ interface IXexSpotSource {
         }): Promise<IXexCandle[]>;
         getPrices?(): Promise<IXexPrice[]>;
     };
+    /**
+     * Le temps réel du COMPTANT. **`kind` est obligatoire ici**, contrairement aux façades qui le
+     * rendent optionnel : leur défaut est `'perp'`, et un `ws()` nu ouvre donc un flux de perpétuels
+     * en croyant écouter le comptant — deux marchés dont les prix diffèrent, sans que rien ne le
+     * signale.
+     */
+    ws(kind: 'spot'): {
+        subscribeCandles(query: {
+            name: string;
+            interval: string;
+        }, handler: (candle: IXexCandle) => void): () => void;
+    };
 }
 /**
  * De quoi lire UN compte chez une venue.
@@ -935,6 +1128,69 @@ interface IPosition {
     margin: string | null;
     xtras?: Record<string, unknown>;
 }
+/**
+ * UNE TRANSACTION PUBLIQUE — celles de tout le monde sur un marché, pas les siennes.
+ *
+ * À ne pas confondre avec {@link ITrade}, qui est une exécution **du compte**. Celle-ci n'a ni
+ * frais, ni PnL, ni identifiant d'ordre : on ne voit que ce que le marché montre.
+ */
+interface IPublicTrade {
+    xex: XgateEx;
+    symbolXex: string;
+    price: string;
+    size: string;
+    /** Sens de l'AGRESSEUR : `buy` = quelqu'un a pris l'offre. */
+    side: Side;
+    tradedAt: Date;
+    xtras?: Record<string, unknown>;
+}
+/**
+ * L'ÉTAT D'UN COMPTE — ce que toutes les venues disent, sous des noms différents.
+ *
+ * Les formes natives ne se ressemblent pas : hyperliquid range son équité sous
+ * `marginSummary.accountValue`, pacifica sous `accountEquity`, aster sous `totalMarginBalance`.
+ * **Mais les concepts, eux, sont les mêmes** — c'est exactement ce qu'XGate existe pour normaliser.
+ *
+ * `xtras` conserve la forme native complète : ce qui est propre à une venue n'est pas perdu, il
+ * n'est simplement pas promu au rang de contrat.
+ */
+interface IAccountState {
+    xex: XgateEx;
+    /** Valeur totale du compte, PnL latent compris. */
+    equity: string;
+    /** Ce qui reste mobilisable — pour ouvrir ou retirer. `null` si la venue ne le publie pas. */
+    available: string | null;
+    /** Marge immobilisée par les positions et ordres en cours. */
+    marginUsed: string | null;
+    /** Marge de maintenance : sous ce seuil, la liquidation menace. */
+    maintenanceMargin: string | null;
+    /**
+     * PnL non réalisé des positions ouvertes.
+     *
+     * **Seule aster le publie au niveau du compte.** hyperliquid et pacifica ne l'exposent pas là —
+     * il se lit alors sur les positions (`IPosition.unrealizedPnl`), qui le portent toutes. On rend
+     * `null` plutôt que de le reconstituer : une somme calculée ici passerait pour une donnée de la
+     * venue.
+     */
+    unrealizedPnl: string | null;
+    /** L'état natif COMPLET, tel que la venue le publie. */
+    xtras?: Record<string, unknown>;
+}
+/**
+ * UN FUNDING PAYÉ — ce qui a réellement été prélevé ou reçu sur une position.
+ *
+ * À ne pas confondre avec le taux courant d'`IPrice.funding`, qui annonce ce qui *sera* payé. Un
+ * calcul de résultat qui ignore ce qui l'a été surestime toute position tenue longtemps.
+ */
+interface IFundingPaid {
+    xex: XgateEx;
+    symbolXex: string;
+    /** Le taux appliqué, en fraction. */
+    rate: string;
+    /** Moment où il a été prélevé. */
+    appliedAt: Date;
+    xtras?: Record<string, unknown>;
+}
 /** UNE EXÉCUTION du compte — ce qui a réellement été rempli, par opposition à ce qui a été demandé. */
 interface ITrade {
     xex: XgateEx;
@@ -1061,6 +1317,18 @@ declare class TradingService {
      * conditionnels. Le SDK de la venue s'en charge ; xgate fournit des niveaux justes.
      */
     openWithProtection(access: ITradingAccess, input: IEntryWithProtection): Promise<IOrder[]>;
+    /**
+     * CE QUE LA VENUE A RÉELLEMENT FAIT, après une réponse perdue.
+     *
+     * Un timeout ne dit pas « rien n'a été créé » : mesuré sur aster, deux exécutions identiques ont
+     * produit deux sous-ensembles différents — une fois le stop et un take-profit, une fois l'entrée
+     * seule. La seule vérité est au carnet, donc on va l'y chercher.
+     *
+     * **Lève si la position est nue** : une entrée remplie sans stop est exactement ce que ce service
+     * existe pour empêcher, et le silence serait pire que l'erreur. L'appelant doit savoir qu'il a une
+     * position à protéger, tout de suite.
+     */
+    private etatApres;
     /** Les positions ouvertes d'un compte. */
     positions(access: ITradingAccess, symbolXex?: string): Promise<IPosition[]>;
     /** Les ordres encore au carnet. */
@@ -1109,10 +1377,120 @@ declare class TradingService {
      * take-profits partiels, celui-là est la clôture.
      */
     exitPrice(access: ITradingAccess, symbolXex: string, direction: Direction, openedAt: Date): Promise<string | null>;
+    /**
+     * L'HISTORIQUE DES ORDRES du compte — ce qui a été soumis, rempli, annulé ou expiré.
+     *
+     * À distinguer de {@link trades} : un ordre est une **intention**, une exécution est un **fait**.
+     * Un ordre `filled` peut avoir été rempli en plusieurs fois, à des prix différents.
+     *
+     * Servi par les huit venues qui tradent.
+     */
+    orderHistory(access: ITradingAccess, symbolXex?: string): Promise<IOrder[]>;
+    /**
+     * L'ÉTAT DU COMPTE — équité, disponible, marge immobilisée, marge de maintenance, PnL latent.
+     *
+     * Les venues rangent ces valeurs sous des noms qui n'ont rien à voir : `marginSummary.accountValue`
+     * chez hyperliquid, `accountEquity` chez pacifica, `totalMarginBalance` chez aster — **mais elles
+     * 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.
+     */
+    accountInfo(access: ITradingAccess): Promise<IAccountState>;
+    /**
+     * RÈGLE LE LEVIER d'une paire, avant d'ouvrir.
+     *
+     * Le levier détermine la marge immobilisée, donc la taille tenable : le changer après l'ouverture
+     * ne rejoue pas la position déjà prise. C'est un réglage préalable, pas un ajustement.
+     *
+     * **bullet ne l'expose pas** — son levier se fixe au compte, pas à la position — et lève.
+     */
+    setLeverage(access: ITradingAccess, symbolXex: string, leverage: number): Promise<void>;
+    /**
+     * CHOISIT LE MODE DE MARGE d'une paire : **isolée** ou **croisée**.
+     *
+     * En **croisée**, tout le solde du compte garantit la position : elle tient plus longtemps, mais
+     * une liquidation emporte l'ensemble. En **isolée**, seule la marge affectée est en jeu : la perte
+     * est bornée à ce montant, la liquidation arrive plus tôt.
+     *
+     * **À régler AVANT d'ouvrir.** Changer le mode d'une position vivante est refusé par la plupart
+     * des venues, et là où c'est accepté, cela redistribue la garantie sous les pieds de la position.
+     *
+     * Servi par les trois venues de référence.
+     */
+    setMarginMode(access: ITradingAccess, symbolXex: string, isolated: boolean): Promise<void>;
+    /**
+     * AJOUTE DE LA MARGE à une position isolée — pour éloigner le prix de liquidation.
+     *
+     * C'est le geste qui sauve une position sous pression sans la réduire : on renforce la garantie
+     * plutôt que de couper. **N'a de sens qu'en marge isolée** ; en croisée, tout le solde garantit
+     * déjà la position et il n'y a rien à ajouter.
+     *
+     * Servi par les trois venues de référence.
+     */
+    addMargin(access: ITradingAccess, symbolXex: string, amount: string): Promise<void>;
+    /**
+     * RETIRE DE LA MARGE d'une position isolée — pour libérer du capital.
+     *
+     * L'inverse d'{@link addMargin} : la garantie diminue, donc le prix de liquidation **se rapproche**.
+     * La venue refuse ce qui mettrait la position sous son seuil de maintenance.
+     *
+     * ⚠️ **pacifica ne l'expose pas** et lève : chez elle, la marge s'ajoute mais ne se retire pas.
+     * Fermer partiellement la position libère alors le capital.
+     */
+    removeMargin(access: ITradingAccess, symbolXex: string, amount: string): Promise<void>;
+    /**
+     * L'HISTORIQUE DU FUNDING **PAYÉ** sur une paire — ce qui a réellement été prélevé ou reçu.
+     *
+     * À ne pas confondre avec le taux courant, que rend `PricesService` : celui-ci annonce ce qui
+     * *sera* payé, celui-là dit ce qui *l'a été*. Un backtest qui ignore le funding réel surestime le
+     * résultat d'une position tenue longtemps.
+     *
+     * Servi par les huit venues qui tradent.
+     */
+    fundingHistory(access: ITradingAccess, symbolXex: string, range?: {
+        startTime?: Date;
+        endTime?: Date;
+        limit?: number;
+    }): Promise<IFundingPaid[]>;
+    /**
+     * UN IDENTIFIANT APPLICATIF pour un ordre, **au format que la venue accepte**.
+     *
+     * C'est lui qui relie un ordre à la décision qui l'a produit : la venue le rend tel quel dans
+     * `IOrder.clientId`, ce qui permet de retrouver son origine sans tenir de table de correspondance.
+     *
+     * **hyperliquid exige un hexadécimal préfixé `0x`** (128 bits) là où les autres acceptent un UUID
+     * ordinaire. Passer le mauvais format fait rejeter l'ordre — d'où cette méthode plutôt qu'un
+     * `randomUUID()` chez l'appelant.
+     */
+    newClientOrderId(xex: XgateEx): string;
+    /**
+     * LE COUPE-CIRCUIT : annule TOUS les ordres d'une paire, d'un geste.
+     *
+     * À réserver aux situations où l'on veut reprendre la main sans discuter — un état incohérent, un
+     * arrêt d'urgence, une reprise après incident. Annuler un par un laisse une fenêtre pendant
+     * laquelle certains ordres vivent encore.
+     *
+     * ⚠️ **Cela retire aussi les PROTECTIONS.** Stops et take-profits sont des ordres comme les
+     * autres : une position ouverte se retrouve **nue** après ce geste. À n'employer que si la
+     * position est fermée, ou si l'on repose une protection immédiatement — jamais pour « faire le
+     * ménage » sur une position vivante.
+     *
+     * Rend le nombre d'ordres annulés quand la venue le publie, `null` sinon.
+     */
+    cancelAll(access: ITradingAccess, symbolXex: string): Promise<number | null>;
     /** Annule un ordre par son identifiant de venue. */
     cancel(access: ITradingAccess, symbolXex: string, orderId: string): Promise<void>;
     /** Le scope `perp()` de la venue, typé au plus près de ce que le contrat commun garantit. */
     private perpOf;
+    /**
+     * L'état natif d'une venue → {@link IAccountState}.
+     *
+     * Une lecture EXPLICITE par venue plutôt qu'un parcours à l'aveugle : les noms ne se devinent pas,
+     * et prendre le premier champ qui ressemble à une équité produirait un chiffre faux sans que rien
+     * ne le signale. `null` là où la venue ne publie pas la valeur — pas `0`, qui se lirait comme
+     * « rien » alors que personne n'a rien dit.
+     */
+    private toAccountState;
     /**
      * Le statut de la venue, VALIDÉ — jamais casté. Une venue qui inventerait un statut rendrait sinon
      * une valeur absente de tous les `switch` en aval, et personne ne la rattraperait.
@@ -1121,6 +1499,75 @@ declare class TradingService {
     private toOrder;
 }
 
+/**
+ * LE FLUX DES EXÉCUTIONS DU COMPTE — savoir ce qui s'est rempli, à l'instant où ça se remplit.
+ *
+ * **C'est la seule façon de connaître son état exact.** Sans lui, on interroge en boucle et on
+ * apprend un remplissage avec le retard du sondage : entre-temps, un take-profit partiel a pu
+ * modifier la taille de la position, et toute décision prise sur l'ancienne valeur est fausse.
+ *
+ * Le flux ne dit pas ce qu'on a **demandé** mais ce qui a été **obtenu** : un ordre annoncé `filled`
+ * peut l'avoir été en plusieurs fois, à des prix différents. Chaque exécution porte son prix réel.
+ *
+ * **ON NE TRANSMET QUE CE QUI ARRIVE APRÈS L'OUVERTURE DU FLUX.** Les venues rejouent leur
+ * historique à la souscription : mesuré le 2026-08-09 sur hyperliquid, 30 exécutions arrivent dans
+ * les six premières secondes, **toutes antérieures** à l'abonnement, la plus ancienne de plus de
+ * deux jours. Sans filtre, chaque reconnexion rejouerait deux jours de trades — et un consommateur
+ * qui compte les remplissages compterait deux fois les mêmes.
+ *
+ * Le filtre se fait sur `filledAt` contre l'instant d'abonnement. Un flux dit le **présent** ;
+ * l'historique se lit avec `TradingService.trades()`, qui est fait pour ça.
+ *
+ * **blofin est la seule venue qui ne l'expose pas** ; elle lève. Les sept autres le servent.
+ */
+declare class WsTradesService {
+    private readonly logger;
+    /**
+     * S'abonne aux exécutions d'un compte. Rend la fonction de désabonnement.
+     *
+     * Le handler reçoit **une exécution à la fois**, au format unifié, et **uniquement celles
+     * survenues après l'abonnement** — le rejeu d'historique de la venue est écarté.
+     */
+    subscribe(access: ITradingAccess, handler: (trade: ITrade) => void): Unsubscribe;
+    /**
+     * S'abonne aux exécutions de PLUSIEURS comptes, avec un seul handler.
+     *
+     * Chaque exécution porte son `xex` : l'appelant sait toujours de quelle venue elle vient. La
+     * fonction rendue coupe tous les flux d'un coup — sinon il faudrait en garder N et n'en oublier
+     * aucun.
+     *
+     * Une venue qui refuse est journalisée et ignorée : le reste des comptes doit continuer d'être
+     * suivi. Sur un seul accès, l'échec est celui de l'appel.
+     */
+    subscribeAll(accesses: ITradingAccess[], handler: (trade: ITrade) => void): Unsubscribe;
+    /**
+     * S'abonne aux ORDRES du compte — leur naissance, leur remplissage, leur mort.
+     *
+     * À distinguer des exécutions : un ordre est une **intention** dont on suit le cycle de vie
+     * (`open` → `partiallyFilled` → `filled`, ou `canceled`), une exécution est un **fait** ponctuel.
+     * Pour savoir qu'un stop vient de se déclencher, c'est ici qu'il faut écouter ; pour savoir à quel
+     * prix, c'est {@link subscribe}.
+     *
+     * **Même règle que pour les exécutions** : seuls les ordres postérieurs à l'abonnement sont
+     * transmis, le rejeu d'historique est écarté.
+     */
+    subscribeOrders(access: ITradingAccess, handler: (order: IOrder) => void): Unsubscribe;
+    /**
+     * S'abonne aux TRANSACTIONS PUBLIQUES d'un marché — celles de tout le monde, pas les siennes.
+     *
+     * C'est le flux qui dit ce qui se négocie réellement : prix, taille, sens agresseur. Il sert à
+     * mesurer l'activité d'une paire, pas à suivre son compte — pour cela, {@link subscribe}.
+     *
+     * **Aucun filtre temporel ici** : un trade public est daté de son exécution et arrive en direct,
+     * il n'y a pas d'historique rejoué à écarter.
+     */
+    subscribePublicTrades(access: ITradingAccess, symbolXex: string, handler: (trade: IPublicTrade) => void): Unsubscribe;
+    /** Le client temps réel d'un compte, avec ses souscriptions signées. */
+    private wsOf;
+    private toOrder;
+    private toTrade;
+}
+
 /** La venue sert-elle cet intervalle de première main ? */
 declare function servesNatively(xex: XgateEx, interval: Timeframe): boolean;
 /**
@@ -1204,4 +1651,4 @@ declare function expiryOf(xtras?: Record<string, unknown>): Date | undefined;
  */
 declare function isDated(xtras?: Record<string, unknown>): boolean;
 
-export { CandlesService, CatalogService, type Direction, type IBalance, type ICandle, type ICandlesQuery, type IEntryWithProtection, type IEquityPoint, type IMoveStop, type IMovement, type IOrder, type IPair, type IPosition, type IPrice, type IProtection, type IProtectionInput, type IProtectionLeg, type ITrade, type ITradingAccess, type IWalletAccess, type IXexAccess, type IXexSpotSource, type MarketKind, type MovementKind, type MovementStatus, ORDER_STATUSES, type OrderStatus, type OrderType, PricesService, SPOT_XEXES, type Side, SpotCandlesService, SpotCatalogService, TIMEFRAME_MINUTES, type TimeInForce, Timeframe, TradingService, type Unsubscribe, WALLET_XEXES, WalletService, WsCandlesService, XGATE_EXCHANGES, XgateEx, XgateModule, buildLevels, buildProtection, canonicalFromBase, canonicalFromXex, expiryOf, isDated, multiplierFromXex, roundPrice, roundToStep, servesNatively, servesSpot, sourceFor, timeframeMs };
+export { CandlesService, CandlesStreamRegistry, CandlesStreamService, CatalogService, type Direction, type IAccountState, type IBalance, type ICandle, type ICandlesQuery, type IEntryWithProtection, type IEquityPoint, type IFundingPaid, type IMoveStop, type IMovement, type IOrder, type IPair, type IPosition, type IPrice, type IProtection, type IProtectionInput, type IProtectionLeg, type IPublicTrade, type ITrade, type ITradingAccess, type IWalletAccess, type IXexAccess, type IXexSpotSource, type MarketKind, type MovementKind, type MovementStatus, ORDER_STATUSES, type OrderStatus, type OrderType, PricesService, SPOT_XEXES, type Side, SpotCandlesService, SpotCatalogService, SpotPricesService, SpotWsCandlesService, TIMEFRAME_MINUTES, type TimeInForce, Timeframe, TradingService, type Unsubscribe, WALLET_XEXES, WS_SUBSCRIPTION_LIMITS, WalletService, WsCandlesService, WsTradesService, XGATE_EXCHANGES, XgateEx, XgateModule, buildLevels, buildProtection, canonicalFromBase, canonicalFromXex, expiryOf, isDated, multiplierFromXex, roundPrice, roundToStep, servesNatively, servesSpot, sourceFor, subscriptionLimitOf, timeframeMs };