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

# Clients LaserStream

> SDKs haute performance pour le streaming gRPC avec relecture automatique et zéro perte de données

## Relecture automatique en cas de déconnexion

Les clients LaserStream suivent en continu votre position de streaming par numéro de slot. En cas de déconnexion - en raison de problèmes réseau, de maintenance du serveur, ou autre - le client se reconnecte automatiquement et reprend le streaming depuis votre dernier slot traité. Vous ne perdez jamais de données, ne manquez jamais de transactions, et n'avez jamais besoin d'écrire de logique de reconnexion.

## Client JavaScript/TypeScript

<Warning>
  **Nous recommandons fortement de passer au SDK LaserStream pour les applications JavaScript.** Si vous utilisez actuellement les clients gRPC Yellowstone, vous rencontrerez des retards progressifs de flux et des goulots d'étranglement de performance qui s'aggravent avec le temps. La marge de manœuvre de performance du client LaserStream garantit que votre application évolue avec le réseau et élimine entièrement ces problèmes.
</Warning>

Le [client JavaScript](https://github.com/helius-labs/laserstream-sdk/tree/main/javascript) utilise des bindings Rust natifs pour atteindre un débit de 1,3 Go/s – plus de 40 fois plus rapide que les clients JavaScript Yellowstone gRPC qui plafonnent à 30 Mo/s.

**Détection d'événements 4x plus rapide** : Grâce à son architecture basée sur Rust, le client JavaScript LaserStream reçoit et traite les événements 4 fois plus rapidement que les clients Yellowstone, donnant à votre application un avantage concurrentiel significatif pour voir les événements en premier.

Sur les abonnements à large bande passante, les clients Yellowstone subissent des retards progressifs qui s'accumulent avec le temps. LaserStream maintient un streaming constant et à faible latence, quelle que soit la quantité de données.

### Installation

Utilisez `helius-laserstream` 0.8.4 ou ultérieure. Les versions antérieures expédient un proto antérieur à la transaction v1, donc les transactions v1 arrivent sans leurs champs `transactionConfig`. Voir [Support des transactions v1](/docs/fr/rpc/transaction-v1).

<CodeGroup>
  ```bash npm theme={"system"}
  npm install helius-laserstream
  ```

  ```bash yarn theme={"system"}
  yarn add helius-laserstream
  ```

  ```bash pnpm theme={"system"}
  pnpm add helius-laserstream
  ```
</CodeGroup>

<Tip>
  Commencez avec LaserStream depuis votre [Tableau de bord Helius](https://dashboard.helius.dev/laserstream). Le réseau principal nécessite un plan Business ou Professional ; Devnet est disponible pour Developer et plus. Voir [Plans & Tarification](/docs/fr/billing/plans) pour plus de détails.
</Tip>

### Démarrage rapide

```typescript [expandable] theme={"system"}
import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream';

async function streamTransactions() {
  const config: LaserstreamConfig = {
    apiKey: 'YOUR_API_KEY',
    endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com',
  };

  const request: SubscribeRequest = {
    transactions: {
      "jupiter-filter": { // user-defined label for this filter
        accountInclude: ['JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'], // Jupiter Program
        accountExclude: [],
        accountRequired: [],
        vote: false,
        failed: false
      }
    },
    commitment: CommitmentLevel.CONFIRMED,
    accounts: {},
    slots: {},
    transactionsStatus: {},
    blocks: {},
    blocksMeta: {},
    entry: {},
    accountsDataSlice: []
  };

  // The SDK handles reconnection and replay automatically
  await subscribe(config, request, 
    async (data) => {
      console.log('New transaction:', data);
    }, 
    async (error) => {
      console.error('Error:', error);
    }
  );
}

streamTransactions().catch(console.error);
```

À partir de `helius-laserstream` 0.4.0, le client JavaScript prend en charge [le filtrage de comptes compressés via les filtres cuckoo](/docs/fr/laserstream/cuckoo-filters) — suivez des centaines de milliers de comptes dans un seul abonnement au lieu d'envoyer une grande liste explicite de clés publiques.

### Comparaison de fiabilité

| Fonctionnalité                        | LaserStream    | Yellowstone                       |
| ------------------------------------- | -------------- | --------------------------------- |
| Relecture automatique                 | ✅ Intégrée     | ❌ Implémentation manuelle requise |
| Retards progressifs                   | ❌ Aucun        | ✅ Sur large bande passante        |
| Protection contre la perte de données | ✅ Automatique  | ❌ Responsabilité de l'application |
| Reconnexion                           | ✅ Transparente | ❌ Pas de support intégré          |

## Client Rust

Le [client Rust](https://github.com/helius-labs/laserstream-sdk/tree/main/rust) offre une désérialisation sans copie et une performance native pour les applications nécessitant un contrôle maximal.

À partir de `helius-laserstream` 0.2.0, le client Rust prend en charge [le filtrage de comptes compressés via les filtres cuckoo](/docs/fr/laserstream/cuckoo-filters), permettant à un seul abonnement de suivre des centaines de milliers de comptes. (Également disponible dans le SDK JavaScript 0.4.0+.)

### Installation

Utilisez `helius-laserstream` 0.6.3 ou ultérieure. Les versions antérieures expédient un proto antérieur à la transaction v1, donc les transactions v1 arrivent sans leurs champs `transactionConfig`. Voir [Support des transactions v1](/docs/fr/rpc/transaction-v1).

```toml theme={"system"}
[dependencies]
helius-laserstream = "0.2"
tokio = { version = "1", features = ["full"] }
```

### Démarrage rapide

```rust [expandable] theme={"system"}
use futures::StreamExt;
use helius_laserstream::{
    grpc::{CommitmentLevel, SubscribeRequest, SubscribeRequestFilterTransactions},
    subscribe, LaserstreamConfig,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = LaserstreamConfig {
        api_key: "YOUR_API_KEY".to_string(),
        endpoint: "https://laserstream-mainnet-ewr.helius-rpc.com".to_string(),
        ..Default::default()
    };

    let mut request = SubscribeRequest::default();
    request.transactions.insert(
        "jupiter-filter".to_string(),
        SubscribeRequestFilterTransactions {
            vote: Some(false),
            failed: Some(false),
            account_include: vec!["JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4".to_string()],
            ..Default::default()
        },
    );
    request.commitment = Some(CommitmentLevel::Confirmed as i32);

    let (stream, _handle) = subscribe(config, request);
    tokio::pin!(stream);

    while let Some(result) = stream.next().await {
        match result {
            Ok(data) => println!("New transaction: {:?}", data),
            Err(e) => eprintln!("Error: {:?}", e),
        }
    }

    Ok(())
}
```

## Client Go

Le [client Go](https://github.com/helius-labs/laserstream-sdk/tree/main/go) offre des interfaces Go idiomatiques.

### Installation

Utilisez `laserstream-sdk/go` 0.2.0 ou ultérieure. Les versions antérieures expédient un proto antérieur à la transaction v1, donc les transactions v1 arrivent sans leurs champs `transactionConfig`. Voir [Support des transactions v1](/docs/fr/rpc/transaction-v1).

```bash theme={"system"}
go get github.com/helius-labs/laserstream-sdk/go
```

### Démarrage rapide

```go [expandable] theme={"system"}
package main

import (
    "log"
    "os"
    "os/signal"
    "syscall"

    laserstream "github.com/helius-labs/laserstream-sdk/go"
    pb "github.com/helius-labs/laserstream-sdk/go/proto"
)

func main() {
    clientConfig := laserstream.LaserstreamConfig{
        APIKey:   "YOUR_API_KEY",
        Endpoint: "https://laserstream-mainnet-ewr.helius-rpc.com",
    }

    voteFilter := false
    failedFilter := false
    commitment := pb.CommitmentLevel_CONFIRMED

    subscriptionRequest := &pb.SubscribeRequest{
        Transactions: map[string]*pb.SubscribeRequestFilterTransactions{
            "jupiter-filter": {
                Vote:           &voteFilter,
                Failed:         &failedFilter,
                AccountInclude: []string{"JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"},
            },
        },
        Commitment: &commitment,
    }

    client := laserstream.NewClient(clientConfig)

    dataCallback := func(data *pb.SubscribeUpdate) {
        log.Printf("New transaction: %+v\n", data)
    }
    errorCallback := func(err error) {
        log.Printf("Error: %v", err)
    }

    if err := client.Subscribe(subscriptionRequest, dataCallback, errorCallback); err != nil {
        log.Fatalf("Failed to subscribe: %v", err)
    }

    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
    <-sigChan
    client.Close()
}
```

## Pourquoi migrer de Yellowstone vers LaserStream

Les clients Yellowstone font face à des limitations critiques qui s’aggraveront avec l’évolution de Solana :

1. **Goulot d'étranglement de performance** : Les clients JavaScript Yellowstone plafonnent à 30 Mo/s – insuffisant pour les applications à haut débit
2. **Retards progressifs** : La latence s’accumule au fil du temps sur les abonnements à large bande passante
3. **Relecture manuelle** : Vous devez implémenter votre propre logique de reconnexion et de relecture
4. **Risque de perte de données** : Sans relecture intégrée, les perturbations réseau signifient des transactions manquées

**LaserStream résout ces problèmes aujourd'hui**. Avec une performance 40x meilleure, une relecture automatique et des garanties de zéro perte de données, migrer vers LaserStream garantit que votre application reste compétitive à mesure que Solana évolue.