> ## 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 de LaserStream

> SDK de alto rendimiento para streaming mediante gRPC con reproducción automática y cero pérdida de datos

## Reproducción automática tras una desconexión

Los clientes de LaserStream rastrean continuamente tu posición en el stream mediante el número de slot. Si se produce una desconexión, ya sea por problemas de red, mantenimiento del servidor o cualquier otra causa, el cliente vuelve a conectarse automáticamente y reanuda el streaming desde el último slot procesado. Nunca pierdes datos ni transacciones y nunca necesitas escribir lógica de reconexión.

## Cliente de JavaScript/TypeScript

<Warning>
  **Recomendamos encarecidamente cambiar al SDK de LaserStream para aplicaciones JavaScript.** Si actualmente usas clientes gRPC de Yellowstone, experimentarás retrasos progresivos en el stream y cuellos de botella de rendimiento que se acumulan con el tiempo. El margen de rendimiento del cliente de LaserStream garantiza que tu aplicación escale junto con la red y elimina por completo estos problemas.
</Warning>

El [cliente de JavaScript](https://github.com/helius-labs/laserstream-sdk/tree/main/javascript) usa bindings nativos de Rust para alcanzar un rendimiento de 1.3 GB/s, más de 40 veces superior al de los clientes gRPC de JavaScript de Yellowstone, cuyo máximo es de 30 MB/s.

**Detección de eventos 4 veces más rápida**: gracias a su arquitectura basada en Rust, el cliente de JavaScript de LaserStream recibe y procesa eventos 4 veces más rápido que los clientes de Yellowstone. Esto le da a tu aplicación una ventaja competitiva considerable para detectar los eventos antes que otros.

En suscripciones con un gran ancho de banda, los clientes de Yellowstone experimentan retrasos progresivos que se acumulan con el tiempo. LaserStream mantiene un streaming uniforme y de baja latencia, independientemente del volumen de datos.

### Instalación

Usa `helius-laserstream` 0.8.4 o una versión posterior. Las versiones anteriores incluyen un proto previo a transaction v1, por lo que las transacciones v1 llegan sin sus campos `transactionConfig`. Consulta [Compatibilidad con transaction v1](/docs/es/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>
  Comienza a usar LaserStream desde tu [panel de Helius](https://dashboard.helius.dev/laserstream). Mainnet requiere un plan Business o Professional; Devnet está disponible con el plan Developer o uno superior. Consulta [Planes y precios](/docs/es/billing/plans) para obtener más información.
</Tip>

### Inicio 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 de `helius-laserstream` 0.4.0, el cliente de JavaScript admite el [filtrado comprimido de cuentas mediante filtros de cuco](/docs/es/laserstream/cuckoo-filters). Esto permite rastrear cientos de miles de cuentas en una sola suscripción, en lugar de enviar una lista explícita y extensa de pubkeys.

### Comparación de confiabilidad

| Función                               | LaserStream  | Yellowstone                        |
| ------------------------------------- | ------------ | ---------------------------------- |
| Reproducción automática               | ✅ Integrada  | ❌ Requiere implementación manual   |
| Retrasos progresivos                  | ❌ Ninguno    | ✅ Con un gran ancho de banda       |
| Protección contra la pérdida de datos | ✅ Automática | ❌ Responsabilidad de la aplicación |
| Reconexión                            | ✅ Fluida     | ❌ Sin compatibilidad integrada     |

## Cliente de Rust

El [cliente de Rust](https://github.com/helius-labs/laserstream-sdk/tree/main/rust) ofrece deserialización sin copias y rendimiento nativo para las aplicaciones que requieren el máximo control.

A partir de `helius-laserstream` 0.2.0, el cliente de Rust admite el [filtrado comprimido de cuentas mediante filtros de cuco](/docs/es/laserstream/cuckoo-filters), lo que permite que una sola suscripción rastree cientos de miles de cuentas. (También está disponible en el SDK de JavaScript 0.4.0 o posterior).

### Instalación

Usa `helius-laserstream` 0.6.3 o una versión posterior. Las versiones anteriores incluyen un proto previo a transaction v1, por lo que las transacciones v1 llegan sin sus campos `transactionConfig`. Consulta [Compatibilidad con transaction v1](/docs/es/rpc/transaction-v1).

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

### Inicio 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 de Go

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

### Instalación

Usa `laserstream-sdk/go` 0.2.0 o una versión posterior. Las versiones anteriores incluyen un proto previo a transaction v1, por lo que las transacciones v1 llegan sin sus campos `transactionConfig`. Consulta [Compatibilidad con transaction v1](/docs/es/rpc/transaction-v1).

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

### Inicio 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 qué migrar de Yellowstone a LaserStream

Los clientes de Yellowstone presentan limitaciones críticas que solo empeorarán a medida que Solana escale:

1. **Cuello de botella de rendimiento**: los clientes de JavaScript de Yellowstone alcanzan un máximo de 30 MB/s, lo cual es insuficiente para aplicaciones de alto rendimiento
2. **Retrasos progresivos**: la latencia se acumula con el tiempo en las suscripciones con un gran ancho de banda
3. **Reproducción manual**: debes implementar tu propia lógica de reconexión y reproducción
4. **Riesgo de pérdida de datos**: sin una reproducción integrada, las interrupciones de red provocan la pérdida de transacciones

**LaserStream resuelve estos problemas hoy mismo**. Con un rendimiento 40 veces superior, reproducción automática y garantías de cero pérdida de datos, migrar a LaserStream asegura que tu aplicación siga siendo competitiva a medida que Solana evoluciona.