> ## 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.

# Comment utiliser preprocessedSubscribe

> Diffusez des transactions Solana pré-exécution sur WebSocket avec la méthode preprocessedSubscribe — souscrivez, filtrez par compte et décodez les charges binaires.

<Note>
  **Bêta publique.** `preprocessedSubscribe` est disponible sur **tous les plans payants**
  et est facturé à **0.1 crédit par message** (un message par transaction livrée).
</Note>

## Qu'est-ce que `preprocessedSubscribe` ?

`preprocessedSubscribe` est une méthode WebSocket de Helius qui diffuse des transactions prétraitées — des transactions Solana pré-exécution livrées **avant d'atteindre le niveau de commitment `processed`**. Helius agrège plusieurs sources pré-exécution — principalement des shreds décodés directement à leur arrivée chez le validateur, complétés par des signaux de [préconfirmation](/docs/fr/pre-confirmations/overview) — et les livre comme un flux unique dédupliqué de messages binaires compacts, sans infrastructure de désassemblage de votre côté.

Les transactions provenant de signaux de préconfirmation arrivent plus tard sur ce flux que sur le produit dédié [Préconfirmations](/docs/fr/pre-confirmations/overview), qui reste l'accès le plus précoce à celles-ci.

C'est le successeur du produit prétraité LaserStream (gRPC) antérieur. Si vous consommez aujourd'hui des transactions prétraitées via gRPC, passez à cette méthode — elle livre la même classe de données sur une connexion WebSocket simple avec une latence plus faible, et la livraison gRPC sera dépréciée.

| Flux                                                                            | Chronométrage relatif                                    | Couverture                                                | Données                                                                                                                  |
| ------------------------------------------------------------------------------- | -------------------------------------------------------- | --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| [Préconfirmations](/docs/fr/pre-confirmations/overview)                              | Le plus tôt possible                                     | Transactions programmées par des validateurs participants | Statut de la transaction et de l'exécution (préconfirmations Helius uniquement; préconfirmations BAM rapportent inconnu) |
| `preprocessedSubscribe`                                                         | En général après les Préconfirmations, avant `processed` | Couverture large des transactions Solana                  | Transaction signée avant exécution                                                                                       |
| [`transactionSubscribe`](/docs/fr/rpc/websocket/transaction-subscribe) à `processed` | Après l'exécution                                        | Transactions traitées                                     | Transaction avec métadonnées d'exécution                                                                                 |

<Warning>
  `preprocessedSubscribe` est un **signal pré-exécution, au mieux des efforts**, pas un
  niveau de commitment. Une transaction en flux peut échouer, être abandonnée ou arriver sur une
  fourche différente. Reconcilez avec un flux traité ou confirmé avant
  de la considérer comme finale.
</Warning>

## Point de terminaison

`preprocessedSubscribe` est servi depuis `wss://beta.helius-rpc.com` — le point de terminaison Helius Gatekeeper — plutôt que `mainnet.helius-rpc.com`. Authentifiez-vous avec votre clé API comme paramètre de requête :

```
wss://beta.helius-rpc.com/?api-key=<API_KEY>
```

Chaque clé API est limitée à **10 connexions/abonnements simultanés**.

## S'abonner

Envoyez une requête JSON-RPC avec la méthode `preprocessedSubscribe`. `params` contient les filtres de compte et est requis — `accountInclude` et `accountRequired` doivent spécifier au moins un compte entre eux (voir [Filtrage](#filtrage)):

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "preprocessedSubscribe",
  "params": {
    "accountInclude": ["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"],
    "accountExclude": [],
    "accountRequired": []
  }
}
```

Le serveur accuse réception de l'abonnement avec un cadre texte JSON contenant l'ID de l'abonnement :

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "result": 1,
  "id": 1
}
```

Après cet accusé de réception, les mises à jour des transactions arrivent sous forme de cadres WebSocket **binaires** — voir [Notification payload](#notification-payload).

## Filtrage

Chaque abonnement est défini par les filtres de compte dans `params`. Le filtrage se fait côté serveur, donc vous ne recevez que les transactions qui vous intéressent :

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "preprocessedSubscribe",
  "params": {
    "accountInclude": ["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"],
    "accountExclude": ["Vote111111111111111111111111111111111111111"],
    "accountRequired": []
  }
}
```

| Filtrer           | Comportement de correspondance                                                              |
| ----------------- | ------------------------------------------------------------------------------------------- |
| `accountInclude`  | Correspond lorsqu'une transaction fait référence à **n'importe lequel** des comptes listés. |
| `accountExclude`  | Abandonne la transaction si elle fait référence à **n'importe lequel** des comptes listés.  |
| `accountRequired` | Correspond uniquement lorsque la transaction fait référence à **tous** les comptes listés.  |

Règles de filtrage :

* Les trois filtres sont combinés avec une logique ET.
* `accountInclude` et `accountRequired` doivent spécifier **au moins un compte** entre eux — il n'y a pas de flux complet non filtré.
* Les comptes sont des clés publiques codées en base58. Chaque liste accepte jusqu'à **5,000** adresses.

### Résolution de la table de recherche d'adresses (ALT)

Les filtres de compte correspondent à plus que les clés de compte statiques de la transaction — Helius résout les [tables de recherche d'adresses](/docs/fr/glossary#table-de-recherche-dadresse-alt) côté serveur, donc `accountInclude`, `accountExclude`, et `accountRequired` correspondent également aux comptes qu'une transaction charge via un ALT. Passez simplement la clé publique du compte ; pas besoin de maintenir les mappages ALT ou de résoudre les tables vous-même.

## Notification payload

Les notifications sont livrées sous forme de cadres WebSocket **binaires** (pas JSON). Chaque cadre porte une seule transaction dans une mise en page de byte compact :

| Octets | Champ         | Type                  | Description                                                                                             |
| ------ | ------------- | --------------------- | ------------------------------------------------------------------------------------------------------- |
| 0      | `version`     | `u8`                  | Version du schéma de payload. Actuellement `1`.                                                         |
| 1–8    | `slot`        | `u64` (little-endian) | Le slot où la transaction a été observée.                                                               |
| 9–72   | `signature`   | 64 octets             | La première signature de la transaction, sous forme binaire.                                            |
| 73+    | `transaction` | `bytes`               | La transaction signée au format wire de Solana. Voir [Décoder la transaction](#décoder-la-transaction). |

Lisez le préfixe fixe de 73 octets dans l'ordre, puis décodez les octets restants pour lire les instructions, les comptes et les recherches de table d'adresses. La signature est incluse dans le préfixe pour que vous puissiez identifier et dédupliquer une transaction sans décoder le corps complet de la transaction.

Lisez et vérifiez toujours d'abord l'octet `version`. Si Helius a besoin de mettre à jour le format de payload, la version s'incrémentera — branchez dessus pour que votre décodeur continue de fonctionner malgré les changements de schéma.

### Décoder la transaction

Les octets de transaction sont transmis exactement comme observé sur le réseau, dans le codage wire standard pour la version de la transaction. Les transactions legacy et v0 utilisent la mise en page signatures en premier 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 mise en page message en premier avec signatures à la fin, donc `bincode` échoue sur les payloads v1. Utilisez un décodeur qui gère chaque version :

* **Rust :** [`agave-transaction-view`](https://docs.rs/agave-transaction-view) analyse les transactions legacy, v0 et v1 sur place, sans copie intermédiaire. C'est l'option recommandée. [`wincode`](https://docs.rs/wincode), le sérialiseur compatible bincode utilisé par les SDK Solana actuels, décode également v1 en `VersionedTransaction`.
* **JavaScript / TypeScript :** assurez-vous que votre version de bibliothèque prend en charge la transaction v1. Les anciennes implémentations `VersionedTransaction.deserialize` ne gèrent que legacy et v0. Utilisez `@solana/kit` 8.0+ ou `@solana/web3.js` v3. Voir [Transaction v1 support](/docs/fr/rpc/transaction-v1).

```rust theme={"system"}
use agave_transaction_view::transaction_view::TransactionView;

// `frame` is the full binary WebSocket message
let tx_bytes = &frame[73..];
let tx = TransactionView::try_new_unsanitized(tx_bytes)?;

println!("version: {:?}", tx.version()); // Legacy, V0, or V1
for ix in tx.instructions_iter() {
    println!("program index {}: {} bytes", ix.program_id_index, ix.data.len());
}
```

## Exemple

```javascript theme={"system"}
const WebSocket = require('ws');
const bs58module = require('bs58');
const bs58 = bs58module.default ?? bs58module;

const ws = new WebSocket('wss://beta.helius-rpc.com/?api-key=<API_KEY>');

ws.on('open', () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'preprocessedSubscribe',
    // Only Jupiter v6 transactions — accountInclude/accountRequired must
    // specify at least one account between them.
    params: {
      accountInclude: ['JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'],
      accountExclude: [],
      accountRequired: []
    }
  }));

  // Keep the connection alive
  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) | signature ([u8; 64]) | transaction bytes
  const buf = Buffer.from(data);
  const version = buf.readUInt8(0); // currently 1 — branch on this if it changes
  if (version !== 1) return; // unknown schema version; update your decoder
  const slot = buf.readBigUInt64LE(1);
  const signature = bs58.encode(buf.subarray(9, 73));
  const txBytes = buf.subarray(73); // transaction in Solana wire format (legacy, v0, or v1)

  console.log('Preprocessed transaction:', { slot, signature, bytes: txBytes.length });
  // Decode txBytes with a decoder that supports transaction v1 (see "Decoding the transaction")
});

ws.on('error', console.error);
ws.on('close', () => process.exit(1));
```

## Quelles données sont disponibles ?

Chaque notification transporte la transaction signée, sa première signature et son slot. Comme la livraison se fait avant l'exécution, le flux n'inclut **pas** :

* Statut d'exécution ou erreurs
* Soldes pré/post ou changements de solde de jetons
* Messages de journal ou instructions internes
* Unités de calcul consommées

Considérez-le comme recevoir la "proposition" sans le "résultat" — vous voyez ce que l'expéditeur a essayé de faire, mais pas ce qui s'est réellement passé. Les mises à jour d'état de compte et de programme n'existent pas encore à ce stade non plus; si vous avez besoin de l'état du compte en temps réel, utilisez [LaserStream gRPC](/docs/fr/laserstream) au niveau de commitment `processed`.

## Contre-pression

Le flux ne tamponne pas indéfiniment pour les consommateurs lents. Si votre client lit trop lentement et que plus de **4,000 messages** s'accumulent côté serveur, Helius ferme la connexion — vous recevez un cadre de fermeture WebSocket propre. Drainez les cadres plus rapidement qu'ils n'arrivent : gardez les travaux lourds tels que le décodage de transaction et la logique de stratégie hors de la boucle de réception, et reconnectez-vous et réabonnez-vous après une déconnexion.

## Garanties de livraison

La livraison est au mieux des efforts, non garantie, et il n'y a pas de lecture historique. Les clients doivent :

1. Se reconnecter et se réabonner après une fermeture de connexion.
2. Dédupliquer par signature de transaction.
3. Considérer le slot comme une observation, pas une finalité.
4. Reconcilez avec un flux traité ou confirmé lorsque les résultats d'exécution sont importants.

## Tarification

`preprocessedSubscribe` est disponible sur **tous les plans payants** et facturé à **0.1 crédit par message** — un message par transaction livrée, facturé à partir de votre plan. Voir [Crédits](/docs/fr/billing/credits) pour plus de détails.

## Connexes

<CardGroup cols={2}>
  <Card title="Préconfirmations" icon="bolt" href="/docs/fr/pre-confirmations/overview">
    Transactions diffusées avant de devenir des shreds — le signal de transaction le plus précoce.
  </Card>

  <Card title="Shreds bruts (UDP)" icon="network-wired" href="/docs/fr/shred-delivery/raw-shreds">
    Paquets shred non traités via UDP. Vous implémentez le désassemblage.
  </Card>

  <Card title="transactionSubscribe" icon="tower-broadcast" href="/docs/fr/rpc/websocket/transaction-subscribe">
    Transactions post-exécution avec filtrage riche et métadonnées d'exécution.
  </Card>
</CardGroup>