@blackcube/xgate-sdk 0.22.0 → 0.24.0

package/README.md

@@ -22,24 +22,37 @@ une capacité n'est comptée que si un test réel l'a exercée.
 |---|:---:|:---:|:---:|:---:|
 | **hyperliquid** | ✔ | ✔ | ✔ | ✔ **prouvée** |
 | **pacifica** | ✔ | ✔ | ✔ | ✔ **prouvée** |
-| **aster** | ✔ | ✔ | ✔ | ⚠ **à valider** |
+| **aster** | ✔ | ✔ | ✔ | ✔ **prouvée** *(voir la fenêtre d'1 s)* |
 | lighter | ✔ | ✔ *(sans clé)* | — | — |
 | extended | ✔ | — | — | — |
 | paradex | ✔ | — | — | — |
 | bullet | ✔ *(bougies en WS seulement)* | — | — | — |
 | blofin | ✔ | ✔ | ✔ | — |
-| binance | ✔ *(+ comptant)* | — | — | — |
-| bybit | ✔ *(+ comptant)* | — | — | — |
+| binance | ✔ **+ comptant complet** | — | — | — |
+| bybit | ✔ **+ comptant complet** | — | — | — |
 
 **hyperliquid et pacifica sont complètes et prouvées.** Le cycle entier — ouvrir avec stop, lire la
 position, refermer sans reliquat — tourne sur leur testnet à chaque exécution de la suite de tests.
 
-**aster est complète mais non validée**, et le refus est délibéré. Son `/fapi/v3/batchOrders` coupe
-à ~3,26 s en répondant « The request has timed out. » *alors que la venue a déjà créé une partie des
-ordres* : deux exécutions identiques ont produit deux sous-ensembles différents. Un statut inconnu
-sur une ouverture protégée, c'est la position nue que ce paquet existe pour rendre impossible — donc
-`openWithProtection` y **lève** tant que la preuve manque. Tout le reste (positions, ordres,
-historique, clôture) fonctionne. Détail complet dans le backlog.
+**aster ouvre en SÉQUENTIEL, avec une fenêtre d'environ une seconde.** Son lot atomique
+(`/fapi/v3/batchOrders`) coupe systématiquement à ~3,26 s — chaque leg s'y écrit on-chain — et
+laissait des orphelins non déterministes : une fois l'entrée seule, une fois le stop seul. XGate y
+pose donc l'entrée, **puis** le stop, **puis** les take-profits.
+
+⚠️ **Entre l'entrée remplie et le stop posé, la position est nue pendant ~1,1 s** (mesuré :
+entrée 1 041 ms, stop 1 078 ms plus tard). Si le marché s'effondre dans cet intervalle, rien ne
+protège. C'est un compromis assumé — l'alternative était une venue inutilisable.
+
+Poser le stop **en premier** supprimerait la fenêtre, mais aster **accepte un `reduceOnly` sans
+position puis l'annule** : vérifié, il a disparu du carnet une seconde plus tard.
+
+**Filet de sécurité** : si le stop échoue alors que l'entrée a rempli, la position est **soldée au
+marché** et l'erreur remonte. Une position sans stop ne survit pas à `openWithProtection`.
+
+> **Un mot sur les timeouts d'aster.** Sa documentation annonce un `HTTP 503` pour un timeout, « à
+> ne **PAS** traiter comme un échec ; le statut d'exécution est **INCONNU** ». Elle renvoie en
+> réalité un **`400`** — « requête malformée » — alors que les ordres sont bel et bien créés. XGate
+> reconnaît donc le message, relit le carnet, et lève sur position nue ou balaie les orphelins.
 
 **lighter se lit sans aucune clé.** Sa documentation classe `/account`, `accountsByL1Address` et
 `positions` parmi les routes **sans authentification**, et `/account` accepte « an account's index,
@@ -53,29 +66,129 @@ bougies passent donc par `WsCandlesService` ; `CandlesService` y lève.
 
 **Les autres sont en lecture.** Elles servent le catalogue, les bougies et les prix ; il leur manque
 un accès de compte (clé d'API pour bullet, adresse active pour extended et paradex) ou la partie
-signée n'est pas câblée. Binance et bybit sont volontairement limitées au **public** : leurs
-SDK ne couvrent que catalogue, bougies et prix, et toute route signée y lève.
+signée n'est pas câblée. Binance et bybit sont volontairement limitées au **public**, mais y servent les deux marchés :
+perpétuel ET comptant, chacun avec ses quatre services. Toute route signée y lève.
 
 ## Les services
 
 Chacun est un `@Injectable()` NestJS, utilisable seul ou via `XgateModule`.
 
+**Les marchés se lisent par paires de services** : le nom de la classe dit lequel on interroge.
+
+| Ce qu'on lit | Perpétuel — 10 venues | Comptant — binance, bybit |
+|---|---|---|
+| catalogue | `CatalogService` | `SpotCatalogService` |
+| bougies REST | `CandlesService` | `SpotCandlesService` |
+| prix | `PricesService` | `SpotPricesService` |
+| temps réel — **plusieurs marchés** | `CandlesStreamRegistry` | `CandlesStreamRegistry.of(xex, 'spot')` |
+| temps réel — **un seul marché** | `WsCandlesService` | `SpotWsCandlesService` |
+
+`candlesOf([...venues], query)` interroge le **même marché chez plusieurs venues** en une liste —
+chaque bougie porte son `xex`. Une venue en échec parmi d'autres est journalisée et ignorée ; seule,
+son échec est celui de l'appel.
+
+`CandlesService` agrège quand la venue ne sert pas l'intervalle demandé ; les autres servent ce que
+la venue publie. Un `Spot*` appelé sur une venue sans comptant **lève**.
+
+⚠️ **Les deux lignes de temps réel ne sont pas interchangeables.** `WsCandlesService` ouvre **une
+socket par souscription** : suivre 50 marchés y ouvre 50 connexions, quand hyperliquid n'en accepte
+que 10 par IP. Le registre, lui, les fait toutes passer par **une seule**. En cas de doute, prends
+le registre — `WsCandlesService` ne se justifie que pour un ou deux marchés.
+
+### ⚠️ Les sockets réagissent MAL à un symbole invalide
+
+**À lire avant d'ouvrir un flux.** Aucune des venues ne rejette proprement un marché inconnu : elles
+l'acceptent, puis se comportent mal — chacune à sa façon, et deux d'entre elles **en silence**.
+
+| venue | ce qu'elle fait d'un symbole inconnu | XGate le voit ? |
+|---|---|---|
+| hyperliquid | ferme la connexion et reconnecte **en boucle** | ✔ coupe tout et lève |
+| binance | l'ignore, les autres marchés continuent | sans objet |
+| **bybit** | **fait taire TOUT le flux**, socket ouverte, sans erreur | ✘ **indétectable** |
+
+Le cas bybit est le plus grave : `['BTCUSDT', 'INCONNU']` ne rend **aucune** bougie — pas même pour
+`BTCUSDT` — alors que `['BTCUSDT', 'ETHUSDT']` fonctionne. Pas de fermeture, pas d'erreur, pas de
+reconnexion. C'est un **silence**, pas un incident : aucun canal ne peut le remonter, et rien dans
+XGate ne le détectera jamais.
+
+Le cas hyperliquid était le même silence avant que XGate ne coupe : cinq reconnexions en douze
+secondes pendant lesquelles les marchés **valides** du même socket se taisaient aussi.
+
+**La seule protection : souscrire depuis le catalogue**, jamais depuis une liste écrite à la main.
+
+```typescript
+const paires = await catalog.catalog(XgateEx.Bybit);
+const symboles = paires.filter((p) => /* ta sélection */).map((p) => p.symbolXex);
+registry.of(XgateEx.Bybit).start(symboles, Timeframe.M1, (candle) => { … });
+```
+
+### Suivre plusieurs marchés : `CandlesStreamRegistry`
+
+**Une socket par venue, quel que soit le nombre de marchés.** Porté de Blips, où il tourne en
+production.
+
+```typescript
+const flux = registry.of(XgateEx.Hyperliquid);
+flux.start(['BTC', 'ETH', 'SOL'], Timeframe.M1, (candle) => { … });
+flux.subscriptionCount();   // 3
+flux.maxSubscriptions;      // 1000 — plafond documenté, null si la venue n'en publie pas
+registry.stopAll();
+```
+
+`of(xex, kind?)` rend **toujours la même instance** pour une venue et un marché : deux appels, deux
+`start()`, une seule connexion. C'est ce qui rend tenable de suivre 200 marchés — hyperliquid
+n'accepte que 10 connexions par IP.
+
+**Deux classes, deux rôles.** `CandlesStreamRegistry` tient la table des flux ; `CandlesStreamService`
+est le flux lui-même, celui que `of()` rend. Les deux sont exportés, mais on n'instancie normalement
+que le registre — construire un `CandlesStreamService` à la main revient à tenir soi-même la table,
+donc à risquer plusieurs sockets pour la même venue.
+
+| | `CandlesStreamRegistry` | `CandlesStreamService` |
+|---|---|---|
+| `of(xex, kind?)` | le flux d'une venue, créé une fois | — |
+| `start(symbols, interval, onCandle)` | — | ouvre les souscriptions |
+| `stop()` / `stopAll()` | coupe tous les flux | coupe ce flux |
+| `subscriptionCount()` / `counts()` | par venue | pour ce flux |
+| `maxSubscriptions` | — | plafond documenté, ou `null` |
+
+> **Une erreur de flux coupe tout, puis lève.** Un symbole invalide n'échoue pas à la
+> souscription : la venue l'accepte, puis ferme la connexion en le découvrant — cinq cycles de
+> reconnexion en douze secondes, mesurés le 2026-08-07 sur hyperliquid, pendant lesquels **tous**
+> les marchés valides du même socket cessent de recevoir, en silence.
+>
+> À la première erreur, XGate coupe les souscriptions, journalise en `error`, et lève. L'exception
+> naît dans un rappel de socket : elle ne remonte pas à l'appelant de `start()`, elle sort en
+> erreur non capturée — délibérément, pour être impossible à ignorer.
+>
+> Souscris depuis le catalogue, pas depuis une liste écrite à la main.
+>
+> **Les trois venues ne réagissent pas pareil à un symbole invalide** — mesuré le 2026-08-07 :
+>
+> | venue | ce qu'elle fait | détecté ? |
+> |---|---|---|
+> | hyperliquid | ferme la connexion, reconnecte en boucle | ✔ coupe et lève |
+> | binance | l'ignore, les autres marchés continuent | sans objet |
+> | **bybit** | **tout le flux se tait**, sans fermeture ni erreur | ✘ **rien ne le signale** |
+>
+> ⚠️ **bybit est le cas dangereux** : `['BTCUSDT', 'INCONNU']` ne rend **aucune** bougie, pas même
+> pour `BTCUSDT`, et la socket reste ouverte sans erreur. Aucun canal ne peut le détecter — c'est
+> un silence, pas un incident. La seule protection est de **souscrire depuis le catalogue**.
+
+**Deux services sans équivalent comptant**, parce que binance et bybit sont bornées au public :
+
 | Service | Ce qu'il rend |
 |---|---|
-| `CatalogService` | les paires perpétuelles de toutes les venues, normalisées |
-| `SpotCatalogService` | les paires **comptant** — binance et bybit uniquement |
-| `CandlesService` | les bougies REST **perpétuelles**, avec agrégation quand la venue ne sert pas l'intervalle |
-| `SpotCandlesService` | les bougies REST **comptant** — binance et bybit |
-| `WsCandlesService` | les bougies en temps réel, un handler pour N venues |
-| `PricesService` | mark, oracle, mid, bid/ask, funding, open interest |
 | `WalletService` | soldes, mouvements, historique d'équité |
 | `TradingService` | positions, ordres, exécutions — et le cycle **ouvrir → gérer → fermer** |
+| `WsTradesService` | les flux du compte : **exécutions**, **ordres**, et transactions **publiques** |
 
 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.
 
 | geste | méthode | venues |
 |---|---|---|
+| régler le levier | `setLeverage` | toutes sauf bullet |
 | ouvrir avec sa protection | `openWithProtection` | hyperliquid, pacifica |
 | déplacer le stop | `moveStop` | hyperliquid, pacifica, aster |
 | fermer sans reliquat | `closePosition` | toutes celles qui tradent |
@@ -83,6 +196,16 @@ position n'est jamais sans stop.
 
 ## Le portefeuille
 
+```typescript
+await wallet.balances(access);                    // comptant + collatéral, chaque ligne marquée
+await wallet.movements(access);                   // dépôts, retraits, transferts — montants signés
+await wallet.equityHistory(access);               // la courbe d'équité du compte
+```
+
+`movements` **lève** si la venue ne les sert pas, plutôt que de rendre une liste vide : « cette
+venue n'expose pas son historique » et « ce compte n'a jamais bougé » appellent des suites très
+différentes. `equityHistory` n'est publié que par hyperliquid et pacifica.
+
 `balances()` rend **le comptant et le collatéral**, chaque ligne portant sa nature :
 
 ```typescript
@@ -172,6 +295,89 @@ l'erreur ne se voit qu'une fois l'argent parti. Le prix courant est donc un argu
 > une chaîne nue, sans identifiant — pour un stop groupé sous son entrée. Il se retrouve au carnet,
 > où `reduceOnly === true` le distingue.
 
+### Savoir ce qui s'est rempli : `WsTradesService`
+
+Le flux des exécutions du compte, en temps réel. C'est ce qui permet de connaître son état **exact**
+sans sonder : entre deux interrogations, un take-profit partiel a pu changer la taille de la
+position, et toute décision prise sur l'ancienne valeur est fausse.
+
+```typescript
+const stop = wsTrades.subscribe(access, (trade) => {
+  // trade.price est le prix RÉELLEMENT obtenu, pas celui demandé
+});
+```
+
+**Seules les exécutions survenues après l'abonnement sont transmises.** Les venues rejouent leur
+historique à la souscription — mesuré sur hyperliquid : 30 exécutions dans les six premières
+secondes, toutes antérieures, la plus ancienne de plus de deux jours. XGate les écarte, sans quoi
+chaque reconnexion rejouerait deux jours de trades et ferait compter deux fois les mêmes
+remplissages. Pour l'historique, `TradingService.trades()` est fait pour ça.
+
+`subscribeAll([...accès], handler)` suit plusieurs comptes avec un seul handler. **blofin ne diffuse
+pas ses exécutions** et lève ; les sept autres venues les servent.
+
+**Trois flux, trois usages** :
+
+```typescript
+wsTrades.subscribe(access, (trade) => { … });                    // MES exécutions : à quel prix
+wsTrades.subscribeOrders(access, (order) => { … });              // MES ordres : leur cycle de vie
+wsTrades.subscribePublicTrades(access, 'ETH', (trade) => { … }); // le marché : ce qui se négocie
+```
+
+`subscribeOrders` voit l'ordre **naître et changer d'état** (`open` → `filled`, ou `canceled`) —
+c'est là qu'on apprend qu'un stop vient de se déclencher. `subscribe` dit à quel prix. Les deux
+écartent le rejeu d'historique ; `subscribePublicTrades` n'en a pas à écarter.
+
+### La marge : mode, renfort, allègement
+
+```typescript
+await trading.setMarginMode(access, 'ETH', true);   // true = isolée, false = croisée
+await trading.addMargin(access, 'ETH', '2');        // éloigne la liquidation
+await trading.removeMargin(access, 'ETH', '1');     // libère du capital
+```
+
+**Le mode se règle AVANT d'ouvrir.** En **croisée**, tout le solde 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, la liquidation arrive plus tôt.
+
+`addMargin` renforce une position sous pression **sans la réduire** — vérifié en réel : marge 38,45
+→ 40,46 après `+2`, puis 39,46 après `−1`. N'a de sens qu'en isolée ; en croisée le solde entier
+garantit déjà la position.
+
+⚠️ **pacifica ne retire pas de marge** et `removeMargin` y lève : fermer partiellement la position
+est alors la façon de libérer du capital.
+
+### Le coupe-circuit : `cancelAll`
+
+Annule **tous** les ordres d'une paire d'un geste — pour reprendre la main sans discuter : état
+incohérent, arrêt d'urgence, reprise après incident. Annuler un par un laisse une fenêtre pendant
+laquelle certains vivent encore.
+
+```typescript
+const annules = await trading.cancelAll(access, 'ETH');   // nombre annulé, ou null
+```
+
+⚠️ **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. XGate le journalise en `warn` s'il détecte
+une position, mais ne refuse pas — c'est un coupe-circuit, il doit couper. À n'employer que si la
+position est fermée, ou en reposant une protection dans la foulée.
+
+### Ne jamais annuler pour reposer
+
+**Annuler une protection pour la recréer est une aberration**, et XGate n'expose délibérément ni
+`cancelProtection` ni `createProtection`. Entre l'annulation et la nouvelle pose, la position est
+**nue** — et cette fenêtre s'ouvre précisément quand ça va mal : marché rapide, latence réseau,
+serveur qui redémarre. C'est le scénario que tout ce paquet existe pour rendre impossible.
+
+Le stop se **déplace** : `moveStop` pose le nouveau **avant** d'annuler l'ancien, du côté du SDK de
+la venue. À aucun instant la position n'est sans protection.
+
+```typescript
+await trading.moveStop(access, { …, stopId: stop.id, triggerPrice: 3120, size: 0.02 }, markPrice);
+```
+
+Si tu te surprends à vouloir annuler puis reposer, c'est un déplacement que tu cherches.
+
 ### Fermer
 
 `closePosition` relit la position **sur la venue** avant de la fermer, et sort la taille que la venue
@@ -182,6 +388,39 @@ fill a différé du plan, et ce reliquat reste ouvert, sans stop.
 await trading.closePosition(access, 'ETH');   // null s'il n'y avait rien à fermer
 ```
 
+### Lire l'état et l'historique
+
+```typescript
+await trading.orderHistory(access, 'ETH');          // les ordres : soumis, remplis, annulés
+await trading.accountInfo(access);                  // équité, marge, ratio de maintenance (brut)
+await trading.fundingHistory(access, 'ETH', { limit: 100 });   // le funding RÉELLEMENT payé
+trading.newClientOrderId(XgateEx.Hyperliquid);      // au format que la venue accepte
+```
+
+**`accountInfo` est unifié** — équité, disponible, marge immobilisée, marge de maintenance, PnL
+latent. Les venues rangent ces valeurs sous des noms sans rapport, mais elles disent la même chose :
+
+| | hyperliquid | pacifica | aster |
+|---|---|---|---|
+| équité | `marginSummary.accountValue` | `accountEquity` | `totalMarginBalance` |
+| disponible | `withdrawable` | `availableToSpend` | `availableBalance` |
+| marge utilisée | `marginSummary.totalMarginUsed` | `totalMarginUsed` | `totalInitialMargin` |
+| maintenance | `crossMaintenanceMarginUsed` | `crossMmr` | `totalMaintMargin` |
+
+La forme native complète reste dans `xtras` — rien n'est perdu. `unrealizedPnl` vaut `null` là où la
+venue ne le publie pas au niveau du compte (hyperliquid, pacifica) : il se lit alors sur les
+positions. **blofin ne l'expose pas** et lève.
+
+**`fundingHistory` dit ce qui a été payé**, là où `PricesService` annonce le taux à venir. Un calcul
+de résultat qui l'ignore surestime toute position tenue longtemps.
+
+**`newClientOrderId` n'est pas un `randomUUID()` déguisé** : hyperliquid exige un hexadécimal
+préfixé `0x` (128 bits) quand les autres acceptent un UUID ordinaire. Le mauvais format fait rejeter
+l'ordre.
+
+> ⚠️ **`fundingHistory` sur le testnet aster répond `502`** — page HTML, serveur en panne sur cet
+> endpoint. Le mainnet le sert normalement. Le SDK et l'URL sont corrects.
+
 ### Le prix de sortie réel
 
 Le prix planifié ne dit pas à quel prix on est sorti : un stop se déclenche au marché, un take-profit
@@ -215,19 +454,50 @@ open · partiallyFilled · filled · canceled · rejected · expired · other
 `canceled` prend **un seul L**. Un statut inconnu retombe sur `other` plutôt que de traverser la
 passerelle tel quel : `ORDER_STATUSES` est exporté pour valider plutôt que caster.
 
-## Comptant et perpétuel ne se mélangent pas
+## Le comptant, au même niveau que le perpétuel
+
+**Quatre services de chaque côté**, jamais un drapeau. Le nom de la classe dit quel marché on lit.
 
-Deux services, jamais un drapeau : `CandlesService` sert le perpétuel, `SpotCandlesService` le
-comptant.
+| | perpétuel | comptant |
+|---|---|---|
+| catalogue | `CatalogService` | `SpotCatalogService` |
+| bougies REST | `CandlesService` | `SpotCandlesService` |
+| prix | `PricesService` | `SpotPricesService` |
+| temps réel | `WsCandlesService` | `SpotWsCandlesService` |
 
 ```typescript
+await spotCatalog.catalog(XgateEx.Binance, XgateEx.Bybit);
 await spotCandles.candles(XgateEx.Binance, { symbol: 'BTCUSDT', interval: '1h', limit: 100 });
-await spotCandles.candlesOf([XgateEx.Binance, XgateEx.Bybit], { symbol: 'BTCUSDT', interval: '1h' });
+await spotPrices.prices(XgateEx.Binance, XgateEx.Bybit);
+spotWs.subscribe(XgateEx.Binance, { symbol: 'BTCUSDT', interval: '1m' }, (candle) => { … });
 ```
 
-Ce n'est pas de la coquetterie d'API : **les échelles de cotation diffèrent entre les deux
-marchés**. `SATSUSDT` au comptant chez bybit cote ×1 quand son perpétuel cote ×10000 — mélanger les
-deux séries fabrique un graphe qui saute d'un facteur 10 000. Une venue sans comptant lève.
+Le comptant est servi par **binance et bybit** ; toute autre venue lève.
+
+**Pourquoi deux jeux de services et non un paramètre** : ce sont deux marchés, pas deux vues du
+même. Le perpétuel porte un funding et s'écarte du comptant — c'est cet écart que certaines
+stratégies exploitent, et le confondre le rendrait invisible. Un `candles(xex, { spot: true })`
+laisserait croire qu'on regarde la même chose sous un autre angle.
+
+**Ce qui change concrètement quand on passe au comptant :**
+
+- **La cotation n'est plus toujours un dollar.** En perpétuel, tout est en USDT/USDC. Au comptant,
+  495 paires sont cotées en BTC, 375 en BNB, 370 en TRY, 230 en ETH — le champ `quote` devient
+  indispensable, et le « prix » d'`ETHBTC` est un ratio, pas des dollars.
+- **`mark`, `oracle`, `funding` et `openInterest` valent `null`** : ils n'existent que sur un
+  contrat. Les voir renseignés signalerait qu'on lit en réalité du perpétuel.
+
+> Les échelles de cotation, elles, 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 ou un prix appartient à une paire, identifiée par
+> `xex` + `symbolXex` + `kind` — il n'y a rien à réconcilier.
+
+**419 actifs n'existent qu'au comptant** — le perpétuel en couvre 887, le comptant 962, dont 419
+sans aucun perpétuel nulle part.
+
+> Sur `SpotPricesService`, `symbol` est dérivé du symbole concaténé : `BTCUSDT` → `BTC`. Les paires
+> cotées hors dollar gardent leur nom entier (`ETHBTC`), les prix ne portant pas la base déclarée.
+> Pour un `symbol`/`quote` justes sur ces paires, passer par `SpotCatalogService`.
 
 ## La semaine s'ouvre le lundi, partout
 
@@ -267,6 +537,56 @@ L'échéance est dérivée du **type de contrat**, jamais de la date de livraiso
 `deliveryDate: 4133404800000` — le 1ᵉʳ janvier 2100 — sur **tous** ses perpétuels. S'y fier
 marquerait le catalogue entier comme daté.
 
+## Les actifs non-crypto du catalogue
+
+**Extraction du 2026-08-07, et rien de plus.** Cette liste n'est pas un contrat : elle a été
+relevée un jour donné sur les dix venues, et elle bougera au prochain listing sans que ce fichier
+le sache. Ne l'utilise pas comme référence figée — refais l'extraction quand la question compte.
+
+164 actifs du catalogue perpétuel ne sont pas de la crypto. Ils s'y mélangent sans distinction :
+un balayage qui ramène « les paires BTC-like » y ramasse de l'or, du pétrole et des actions Tesla,
+alors que **ni les horaires de cotation, ni la volatilité, ni la dynamique de funding** ne s'y
+comportent pareil — les actions et indices ne cotent pas 24/7.
+
+**forex (7)**
+`AUDUSD EURUSD GBPUSD NZDUSD USDCAD USDCHF USDJPY`
+
+**matières premières (11)**
+`BZ CL COPPER GOLD NG SILVER WTIOIL XAG XAU XPD XPT`
+
+**indices et ETF (36)** — dont des ETF à effet de levier (`SOXL` ×3, `SQQQ` inverse ×3, `UVXY`)
+`BBX BITO BNC BOT BSP EWJ EWT EWY EWZ FWDI INTW IWM KORU KSTR MUU MVLL QNTX QQQ SHAZ SMH SNXX SOXL
+SOXS SP500 SPY SQQQ STXX TBT TMF TQQQ TZA URNM US100 UVXY XBI XLE`
+
+**hors-US et pré-IPO (29)** — `OPENAI`, `ANTHROPIC`, `SPCX`, `ZHIPU`, `MINIMAX` sont des sociétés
+**non cotées** : des marchés sur valorisation privée
+`AAOI ANTHROPIC ARM ASML AXTI BABA BMNR CBRS CRWV DRAM GIGADEV HK0700 HK1810 HYUNDAI MINIMAX NBIS
+NVO OPENAI PENG POPMART SAMSUNG SKHY SKHYNIX SONY SPCX TENCENT TSM USAR ZHIPU`
+
+**actions US (81)**
+`AAPL ADBE ALAB AMAT AMD AMZN APP ASTS AVGO BE BRKB BX CAT CIEN COHR COIN COST CRCL CRDO CRM CRWD
+CSCO DELL DIS DKNG EBAY FLEX FLNC GEV GLW GME GOOGL GS HD HIMS HOOD HPE IBM INTC IREN JPM KLAC KO
+LITE LLY LRCX META MRVL MSFT MSTR MU NFLX NOK NOW NVDA ONDS ORCL PANW PAYP PLTR PYPL QCOM RDDT
+RIVN RKLB SMCI SNDK SNOW SOFI STRC TER TSLA TTWO TXN UBER V VRT WDC WEN WMT ZM`
+
+### Ce que cette liste vaut, et ce qu'elle ne vaut pas
+
+**Deux venues seulement les déclarent** : extended (`contractType: 'TRADIFI_PERPETUAL'`, 153
+marchés) et bullet (`RwaPerpUsEquity`, `RwaPerpCommodities`, `RwaPerpKrEquity`,
+`RwaPerpUsEquityIndices`, 10 marchés). Les **huit autres n'en disent rien** — bybit en cote 131,
+aster 108, blofin 74, lighter 66, pacifica 20, paradex 19, sans aucun champ pour les distinguer.
+La liste ne tient donc que parce qu'un actif déclaré quelque part se reconnaît ailleurs à son
+symbole canonique.
+
+**Le sous-classement est une interprétation**, pas une donnée de venue. Le forex se reconnaît à sa
+forme (six lettres, deux codes ISO) ; le reste vient d'un rangement fait à la main sur les tickers.
+Ce qui est solide, c'est **l'appartenance à la liste** — pas la catégorie.
+
+**Aucun champ `assetType` n'existe dans `IPair`**, et c'est délibéré tant qu'aucune source
+d'autorité ne couvre les dix venues. La documentation officielle de pacifica le confirme : son
+`/api/v1/info` ne publie que `instrument_type`, qui vaut `perpetual` aussi bien pour `BTC` que pour
+`TSLA`, `XAU` ou `EURUSD`.
+
 ## Les conventions qui traversent tout
 
 - **Une bougie inclut sa dernière milliseconde** : 10:00:00.000 → 10:59:59.999. `closedAt` se