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

# LaserStream Clients

> Hochleistungs-SDKs für gRPC-Streaming mit automatischer Wiedergabe und ohne Datenverlust

## Automatische Wiedergabe bei Unterbrechung

LaserStream-Clients verfolgen kontinuierlich Ihre Streaming-Position durch Slotnummern. Bei einer Unterbrechung – sei es durch Netzwerkprobleme, Serverwartung oder andere Ursachen – stellt der Client automatisch die Verbindung wieder her und setzt das Streaming von Ihrem letzten verarbeiteten Slot fort. Sie verlieren nie Daten, verpassen keine Transaktionen und müssen keine Wiederherstellungslogik schreiben.

## JavaScript/TypeScript Client

<Warning>
  **Wir empfehlen dringend, auf das LaserStream SDK für JavaScript-Anwendungen umzusteigen.** Wenn Sie derzeit Yellowstone gRPC-Clients verwenden, werden Sie fortschreitende Stream-Verzögerungen und Leistungsengpässe erleben, die sich mit der Zeit verstärken. Die Leistungskapazität des LaserStream-Clients stellt sicher, dass Ihre App mit dem Netzwerk skaliert und diese Probleme vollständig eliminiert.
</Warning>

Der [JavaScript-Client](https://github.com/helius-labs/laserstream-sdk/tree/main/javascript) verwendet native Rust-Bindings, um einen Durchsatz von 1,3 GB/s zu erreichen – über 40x schneller als Yellowstone gRPC JavaScript-Clients, die bei 30 MB/s maximal sind.

**4x schnellere Ereigniserkennung**: Dank seiner Rust-basierten Architektur empfängt und verarbeitet der LaserStream JavaScript-Client Ereignisse 4x schneller als Yellowstone-Clients, was Ihrer Anwendung einen erheblichen Wettbewerbsvorteil verschafft, indem sie Ereignisse zuerst sieht.

Bei hochbandbreitigen Abonnements erleben Yellowstone-Clients fortschreitende Verzögerungen, die sich mit der Zeit aufaddieren. LaserStream hält konsistentes, latenzarmes Streaming unabhängig vom Datenvolumen aufrecht.

### Installation

Verwenden Sie `helius-laserstream` 0.8.4 oder später. Frühere Versionen liefern ein Proto, das älter als Transaktion v1 ist, sodass v1-Transaktionen ohne ihre `transactionConfig` Felder ankommen. Siehe [Transaktion v1 Unterstützung](/docs/de/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>
  Beginnen Sie mit LaserStream über Ihr [Helius Dashboard](https://dashboard.helius.dev/laserstream). Mainnet erfordert einen Geschäfts- oder Professionellen Plan; Devnet ist auf Entwickler und darüber verfügbar. Siehe [Pläne & Preise](/docs/de/billing/plans) für Details.
</Tip>

### Schnellstart

```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);
```

Ab `helius-laserstream` 0.4.0 unterstützt der JavaScript-Client [komprimierte Kontofilterung über Cuckoo-Filter](/docs/de/laserstream/cuckoo-filters) – verfolgen Sie Hunderttausende von Konten in einem einzigen Abonnement anstatt einer großen expliziten Pubkey-Liste.

### Zuverlässigkeitsvergleich

| Merkmal                       | LaserStream   | Yellowstone                             |
| ----------------------------- | ------------- | --------------------------------------- |
| Automatische Wiedergabe       | ✅ Eingebaut   | ❌ Manuelle Implementierung erforderlich |
| Fortschreitende Verzögerungen | ❌ Keine       | ✅ Bei hoher Bandbreite                  |
| Schutz vor Datenverlust       | ✅ Automatisch | ❌ Anwendungsverantwortung               |
| Wiederverbindung              | ✅ Nahtlos     | ❌ Keine eingebaute Unterstützung        |

## Rust Client

Der [Rust-Client](https://github.com/helius-labs/laserstream-sdk/tree/main/rust) bietet Zero-Copy-Deserialisierung und native Leistung für Anwendungen, die maximale Kontrolle erfordern.

Ab `helius-laserstream` 0.2.0 unterstützt der Rust-Client [komprimierte Kontofilterung über Cuckoo-Filter](/docs/de/laserstream/cuckoo-filters), sodass ein einziges Abonnement Hunderttausende von Konten verfolgen kann. (Auch im JavaScript SDK 0.4.0+ verfügbar.)

### Installation

Verwenden Sie `helius-laserstream` 0.6.3 oder später. Frühere Versionen liefern ein Proto, das älter als Transaktion v1 ist, sodass v1-Transaktionen ohne ihre `transactionConfig` Felder ankommen. Siehe [Transaktion v1 Unterstützung](/docs/de/rpc/transaction-v1).

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

### Schnellstart

```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(())
}
```

## Go Client

Der [Go-Client](https://github.com/helius-labs/laserstream-sdk/tree/main/go) bietet idiomatische Go-Schnittstellen.

### Installation

Verwenden Sie `laserstream-sdk/go` 0.2.0 oder später. Frühere Versionen liefern ein Proto, das älter als Transaktion v1 ist, sodass v1-Transaktionen ohne ihre `transactionConfig` Felder ankommen. Siehe [Transaktion v1 Unterstützung](/docs/de/rpc/transaction-v1).

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

### Schnellstart

```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()
}
```

## Warum von Yellowstone zu LaserStream migrieren

Yellowstone-Clients stehen vor kritischen Einschränkungen, die sich nur verschlimmern werden, wenn Solana skaliert:

1. **Leistungsengpass**: Yellowstone JavaScript-Clients erreichen maximal 30 MB/s – unzureichend für Hochdurchsatzanwendungen
2. **Fortschreitende Verzögerungen**: Latenz addiert sich mit der Zeit bei hochbandbreitigen Abonnements
3. **Manuelle Wiedergabe**: Sie müssen Ihre eigene Wiederverbindungs- und Wiedergabelogik implementieren
4. **Risiko des Datenverlusts**: Ohne eingebaute Wiedergabe bedeuten Netzwerkunterbrechungen verpasste Transaktionen

**LaserStream löst diese Probleme heute**. Mit 40x besserer Leistung, automatischer Wiedergabe und Garantien für keinen Datenverlust stellt die Migration zu LaserStream sicher, dass Ihre Anwendung wettbewerbsfähig bleibt, während sich Solana weiterentwickelt.