> ## Documentation Index > Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt > Use this file to discover all available pages before exploring further. # preconfSubscribe > Utilisez preconfSubscribe pour diffuser des transactions Solana avant le partitionnement — les préconfirmations Helius portent le statut d'exécution, les préconfirmations BAM arrivent en pré-exécution. Démarrez une souscription aux [Préconfirmations](/docs/fr/pre-confirmations/overview) — transactions livrées avant qu'elles ne soient collectées en entrées et converties en fragments. Il s'agit du signal de transaction à la latence la plus faible offert par Helius. Un abonnement diffuse à la fois les préconfirmations Helius, émises dès que le leader exécute la transaction et portant son statut d'exécution, et les [préconfirmations BAM](/docs/fr/pre-confirmations/overview#préconfirmations-bam), émises lorsque le validateur s'engage à l'exécuter; réglez `includeBam: false` pour recevoir uniquement les préconfirmations Helius. ## Points de terminaison `preconfSubscribe` est servi depuis le point de terminaison Helius [Gatekeeper](/docs/fr/gatekeeper/overview) : * `wss://beta.helius-rpc.com/?api-key=` Le nom d'hôte `beta` se réfère au déploiement de Gatekeeper, non à la maturité des Préconfirmations — il deviendra le point de terminaison standard à mesure que le trafic migrera vers Gatekeeper. Le flux n'est pas continu. La couverture s'adapte avec la part de participation réseau transmise à Helius ou exécutant BAM, donc attendez-vous à des créneaux sans messages — gérez ces lacunes avec précaution. Voir [Couverture](/docs/fr/pre-confirmations/overview#couverture). ## Autorisations Votre clé API Helius, passée en tant que paramètre de requête `api-key`. Nécessite un plan Professionnel ou supérieur. ## Corps Optionnel. Omettez `params` pour recevoir chaque transaction à la fois de Helius et de BAM. Pour restreindre le flux, passez un objet filtre en premier élément — le filtrage se fait côté serveur, vous ne payez donc que pour les transactions qui vous intéressent et que vous recevez. Chaque champ est optionnel — un champ manquant signifie "aucune contrainte" pour ce prédicat, donc un filtre vide correspond à chaque transaction des deux sources. Les champs définis se combinent avec **ET**, évalués dans l'ordre `includeBam` → `failed` → `regionInclude` → `accountExclude` → `accountRequired` → `accountInclude`. `false` supprime les préconfirmations BAM pour que vous receviez uniquement les préconfirmations Helius. `true`, comme l'omission du champ, conserve les deux sources. Le filtrage de statut est pris en charge uniquement pour les préconfirmations Helius et est ignoré pour les préconfirmations BAM. Pour Helius, `true` retourne uniquement les transactions échouées (révoquées); `false` retourne uniquement les transactions réussies. N'importe quelle valeur exclut les transactions Helius avec un statut inconnu. Omettez le champ pour recevoir tous les statuts. Les préconfirmations BAM sont toujours livrées si elles correspondent aux filtres de source, de région et de compte. Si non vide, la transaction doit provenir d'**une des** ces [régions](#codes-régionaux). Les transactions sans information régionale sont supprimées lorsque cela est défini. Si non vide, la transaction doit référencer **au moins un** de ces comptes (pubkeys base58). Limité à 500 entrées. La transaction est supprimée si elle référence **l'un** de ces comptes. Prend le pas sur `accountInclude`. Limité à 500 entrées. La transaction doit référencer **tous** ces comptes. Limité à 500 entrées. Une valeur de compte invalide ou un code de région non reconnu renvoie une erreur JSON-RPC `-32602` (paramètres invalides). Les filtres de compte correspondent à plus que les clés de compte statiques de la transaction — Helius résout les [tableaux de recherche d'adresse](#glossary#address-lookup-table-alt) v0 côté serveur, donc `accountInclude`, `accountExclude`, et `accountRequired` correspondent également aux comptes qu'une transaction charge par une ALT. ### Codes régionaux | Code | Localisation | Code | Localisation | | ----- | -------------- | ----- | ------------------ | | `slc` | Salt Lake City | `tyo` | Tokyo | | `fra` | Francfort | `ams` | Amsterdam | | `lon` | Londres | `dal` | Dallas | | `pit` | Pittsburgh | `dub` | Dublin | | `sgp` | Singapour | `mia` | Miami | | `ewr` | Newark | `lax` | Los Angeles | | `iad` | Ashburn | `sea` | Seattle | | `hkg` | Hong Kong | `sqq` | Šiauliai, Lituanie | Pour les préconfirmations Helius, la région est celle où Helius a ingéré la transaction. Pour les préconfirmations BAM, c'est le point de terminaison BAM régional qui a émis la préconfirmation, non pas l'endroit où Helius l'a ingéré. Les points de terminaison de BAM à Singapour et Dallas se mappent à `sgp` et `dal`. ## Réponse ID de souscription (nécessaire pour se désabonner) ```json Request theme={"system"} { "jsonrpc": "2.0", "id": 1, "method": "preconfSubscribe", "params": [ { "failed": false, "regionInclude": ["ewr", "fra"], "accountInclude": ["9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM"] } ] } ``` ```json Helius only theme={"system"} { "jsonrpc": "2.0", "id": 1, "method": "preconfSubscribe", "params": [{ "includeBam": false }] } ``` ```javascript JavaScript theme={"system"} const WebSocket = require('ws'); const ws = new WebSocket('wss://beta.helius-rpc.com/?api-key='); ws.on('open', () => { ws.send(JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'preconfSubscribe' // Helius and BAM preconfirmations by default // Optional filter: // params: [{ failed: false, accountInclude: ['9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM'] }] // Helius preconfirmations only: // params: [{ includeBam: false }] })); setInterval(() => ws.ping(), 30_000); }); ws.on('message', (data, isBinary) => { // The subscribe acknowledgement arrives as a JSON text frame if (!isBinary) { const msg = JSON.parse(data.toString()); if (msg.id === 1) console.log('Subscribed, ID:', msg.result); return; } // Notifications arrive as binary frames: // version (u8) | slot (u64 LE) | tx_index (u64 LE) | status (u8) | transaction bytes const buf = Buffer.from(data); const version = buf.readUInt8(0); if (version !== 1) return; // unknown schema version; update your decoder const slot = buf.readBigUInt64LE(1); const txIndex = buf.readBigUInt64LE(9); // always 0 for BAM preconfirmations const status = buf.readUInt8(17); // 0 = failed, 1 = success, 2 = unknown (always 2 for BAM) const txBytes = buf.subarray(18); // transaction in Solana wire format (legacy, v0, or v1) console.log('Preconfirmation:', { slot, txIndex, status, bytes: txBytes.length }); }); ``` ```json Response theme={"system"} { "jsonrpc": "2.0", "id": 1, "result": 24040 } ``` ```text Notification (binary frame) theme={"system"} version u8 payload schema version, currently 1 slot u64 (LE) slot the transaction is scheduled in tx_index u64 (LE) index of the transaction within the slot (always 0 for BAM) status u8 0 = failed, 1 = success, 2 = unknown (always 2 for BAM) tx bytes transaction in Solana wire format (legacy, v0, or v1) ``` ## Notifications Après l'accusé de réception JSON, les notifications sont livrées sous forme de trames WebSocket **binaires** (pas de JSON). Les préconfirmations Helius et BAM partagent la même structure. Chaque trame est un format de byte packé transportant une seule transaction : | Octets | Champ | Type | Description | | ------ | ------------- | --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | 0 | `version` | `u8` | Version du schéma de la charge utile. Actuellement `1`. | | 1–8 | `slot` | `u64` (little-endian) | Le créneau dans lequel la transaction est programmée. | | 9–16 | `tx_index` | `u64` (little-endian) | Index de la transaction dans le créneau. Toujours `0` pour les préconfirmations BAM, qui portent un ID de séquence et une position de paquet plutôt qu'un index de créneau. | | 17 | `status` | `u8` | Statut de la transaction : `0` = échec, `1` = succès, `2` = inconnu. Les préconfirmations Helius rapportent le statut d'exécution sur la base du meilleur effort, `2` lorsqu'il est indisponible. Les préconfirmations BAM rapportent toujours `2`. | | 18+ | `transaction` | `bytes` | La transaction au format filaire Solana. Voir [Décodage de la transaction](#décodage-de-la-transaction). | La charge utile n'a pas de champ source. Ne déduisez pas une origine BAM de `tx_index = 0` et `status = 2`, car les préconfirmations Helius peuvent porter les mêmes valeurs. **Seules les préconfirmations Helius portent un statut d'exécution.** Les préconfirmations Helius rapportent `0` (échec) ou `1` (succès) lorsque le validateur le fournit, et `2` uniquement lorsqu'il est indisponible. Les préconfirmations BAM rapportent toujours `2` (inconnu), donc `status` seul ne peut pas vous dire si une transaction d'origine BAM a réussi. Si votre stratégie dépend sur le statut d'exécution, réglez `includeBam: false` ou confirmez le résultat sur la chaîne. **Lisez et vérifiez toujours d'abord l'octet `version`.** Il est actuellement `1`. Si Helius doit mettre à jour le format de charge utile, la version s'incrémentera — branchez-vous dessus pour que votre décodeur continue de fonctionner quel que soit les changements de schéma. Une préconfirmation est un signal précoce, pas une garantie. La transaction n'a pas encore atterri sur la chaîne et pourrait encore échouer ou être abandonnée. Confirmez l'atterrissage grâce à des vérifications d'engagement standard avant de la considérer comme définitive. ### Décodage de la transaction Les octets de la transaction sont transmis exactement comme le validateur les a sérialisés, dans le codage filaire standard pour la version de la transaction. Les transactions Legacy et v0 utilisent la disposition signatures d'abord que `bincode` produit. La transaction v1 ([SIMD-0385](https://github.com/solana-foundation/solana-improvement-documents/blob/main/proposals/0385-transaction-v1.md)) utilise une disposition messages d'abord avec des signatures à la fin, donc `bincode` échoue sur les charges utiles v1. Utilisez un décodeur qui gère chaque version. En Rust, [`agave-transaction-view`](https://docs.rs/agave-transaction-view) analyse les transactions legacy, v0 et v1 sur place et est l'option recommandée; [`wincode`](https://docs.rs/wincode) avec un SDK Solana actuel `VersionedTransaction` fonctionne également. En JavaScript, assurez-vous que votre version de la bibliothèque prend en charge la transaction v1. Voir le [guide](/docs/fr/pre-confirmations/preconf-subscribe#décoder-la-transaction) pour un exemple Rust. ## Notifications en double Les préconfirmations Helius et BAM sont dédupliquées par source, pas entre les sources. Une petite part des transactions atteignent Helius par les deux, donc vous pouvez recevoir la même signature deux fois, et les deux copies peuvent indiquer différents créneaux. Dédupliquez par signature côté client et rendez les actions déclenchées par les transactions idempotentes. Voir le [guide](/docs/fr/pre-confirmations/preconf-subscribe#notifications-en-double). ## Tarification Les préconfirmations nécessitent un **plan Professionnel ou supérieur** et coûtent **10 crédits par message** — un message par transaction diffusée. Voir [Crédits](/docs/fr/billing/credits) pour plus de détails. La facturation se fait par message, non par signature unique. Une transaction livrée à la fois par Helius et BAM compte double. Réglez `includeBam: false` si vous ne souhaitez recevoir que les préconfirmations Helius. ## Connexe Ce que sont les Préconfirmations et où elles se situent dans le pipeline des validateurs. Arrêtez un abonnement par son ID.