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

# Clientes LaserStream

> SDKs de alto desempenho para streaming gRPC com reprodução automática e zero perda de dados

## Reprodução Automática na Desconexão

Os clientes LaserStream monitoram continuamente sua posição de streaming por número de slot. Se ocorrer uma desconexão - por problemas de rede, manutenção do servidor ou qualquer outra causa - o cliente se reconecta automaticamente e retoma o streaming a partir do último slot processado. Você nunca perde dados, nunca perde transações e nunca precisa escrever uma lógica de reconexão.

## Cliente JavaScript/TypeScript

<Warning>
  **Recomendamos fortemente a mudança para o SDK LaserStream para aplicativos JavaScript.** Se você está atualmente usando clientes Yellowstone gRPC, experimentará atrasos progressivos no fluxo e gargalos de desempenho que se acumulam ao longo do tempo. O espaço de desempenho do cliente LaserStream garante que seu aplicativo escale com a rede e elimine completamente esses problemas.
</Warning>

O [cliente JavaScript](https://github.com/helius-labs/laserstream-sdk/tree/main/javascript) usa bindings nativos em Rust para alcançar uma taxa de transferência de 1,3GB/s – mais de 40x mais rápido que os clientes Yellowstone gRPC JavaScript que atingem no máximo 30MB/s.

**Detecção de eventos 4x mais rápida**: Graças à sua arquitetura baseada em Rust, o cliente LaserStream JavaScript recebe e processa eventos 4x mais rápido que os clientes Yellowstone, dando ao seu aplicativo uma vantagem competitiva significativa ao ver eventos primeiro.

Em assinaturas de alta largura de banda, os clientes Yellowstone experimentam atrasos progressivos que se acumulam ao longo do tempo. O LaserStream mantém um streaming consistente e de baixa latência, independentemente do volume de dados.

### Instalação

<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>
  Comece com o LaserStream a partir do seu [Painel Helius](https://dashboard.helius.dev/laserstream). A Mainnet requer um plano Empresarial ou Profissional; a Devnet está disponível no nível Desenvolvedor e acima. Veja [Planos e Preços](/docs/pt-BR/billing/plans) para detalhes.
</Tip>

### Início Rápido

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

A partir da versão `helius-laserstream` 0.4.0, o cliente JavaScript suporta [filtragem de contas comprimidas via filtros cuckoo](/docs/pt-BR/laserstream/cuckoo-filters) — rastreie centenas de milhares de contas em uma única assinatura em vez de enviar uma lista extensa de chaves públicas.

### Comparação de Confiabilidade

| Recurso                        | LaserStream    | Yellowstone                       |
| ------------------------------ | -------------- | --------------------------------- |
| Reprodução Automática          | ✅ Integrado    | ❌ Implementação manual necessária |
| Atrasos Progressivos           | ❌ Nenhum       | ✅ Em alta largura de banda        |
| Proteção Contra Perda de Dados | ✅ Automática   | ❌ Responsabilidade da aplicação   |
| Reconexão                      | ✅ Transparente | ❌ Sem suporte integrado           |

## Cliente Rust

O [cliente Rust](https://github.com/helius-labs/laserstream-sdk/tree/main/rust) fornece desserialização de cópia zero e desempenho nativo para aplicativos que requerem controle máximo.

A partir da versão `helius-laserstream` 0.2.0, o cliente Rust suporta [filtragem de contas comprimidas via filtros cuckoo](/docs/pt-BR/laserstream/cuckoo-filters), permitindo que uma única assinatura rastreie centenas de milhares de contas. (Também disponível no SDK JavaScript 0.4.0+.)

### Instalação

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

### Início Rápido

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

## Cliente Go

O [cliente Go](https://github.com/helius-labs/laserstream-sdk/tree/main/go) fornece interfaces Go idiomáticas.

### Instalação

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

### Início Rápido

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

## Por que Migrar do Yellowstone para o LaserStream

Os clientes Yellowstone enfrentam limitações críticas que só piorarão à medida que Solana escalar:

1. **Gargalo de Desempenho**: Clientes Yellowstone JavaScript atingem no máximo 30MB/s – insuficiente para aplicativos de alta taxa de transferência
2. **Atrasos Progressivos**: A latência se acumula ao longo do tempo em assinaturas de alta largura de banda
3. **Reprodução Manual**: Você deve implementar sua própria lógica de reconexão e reprodução
4. **Risco de Perda de Dados**: Sem reprodução integrada, as interrupções na rede significam transações perdidas

**O LaserStream resolve esses problemas hoje**. Com desempenho 40x melhor, reprodução automática e garantias de zero perda de dados, migrar para o LaserStream garante que seu aplicativo permaneça competitivo à medida que Solana evolui.