> ## 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 客户端

> 高性能 SDK，用于 gRPC 流式传输，具有自动重播和零数据丢失功能

## 断开连接时自动重播

LaserStream 客户端通过槽号持续跟踪您的流媒体位置。如果发生断开连接——无论是由于网络问题、服务器维护还是其他原因——客户端会自动重新连接并从您上次处理的槽位恢复流媒体。您永远不会丢失数据，永远不会错过交易，也不需要编写重新连接逻辑。

## JavaScript/TypeScript 客户端

<Warning>
  **我们强烈建议为 JavaScript 应用切换到 LaserStream SDK。** 如果您当前使用 Yellowstone gRPC 客户端，您将会遇到逐渐增加的流延迟和性能瓶颈，这些问题会随着时间的推移而加剧。LaserStream 客户端的性能余量确保您的应用可以随网络扩展，并完全消除这些问题。
</Warning>

[JavaScript 客户端](https://github.com/helius-labs/laserstream-sdk/tree/main/javascript) 使用原生 Rust 绑定实现 1.3GB/s 的吞吐量——比 Yellowstone gRPC JavaScript 客户端的最大 30MB/s 快 40 倍以上。

**4倍更快的事件检测**：得益于其基于Rust的架构，LaserStream JavaScript客户端接收和处理事件的速度比Yellowstone客户端快4倍，使您的应用程序在事件检测上具有显著的竞争优势。

在高带宽订阅中，Yellowstone客户端会经历随时间累积的渐进延迟。LaserStream则无论数据量如何，始终保持一致的低延迟流传输。

### 安装

<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>
  从您的 [Helius Dashboard](https://dashboard.helius.dev/laserstream) 开始使用 LaserStream。主网需要商务或专业计划；开发网可在开发者及以上中使用。详情见 [计划与定价](/zh/billing/plans)。
</Tip>

### 快速开始

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

在 `helius-laserstream` 0.4.0 版本中，JavaScript 客户端支持[通过 缩库过滤器进行压缩账户过滤](/zh/laserstream/cuckoo-filters)——在单个订阅中跟踪数十万个账户，而不是发送大量明确的公钥列表。

### 可靠性比较

| 功能     | LaserStream | Yellowstone |
| ------ | ----------- | ----------- |
| 自动重播   | ✅ 内置        | ❌ 需要手动实现    |
| 进阶延迟   | ❌ 无         | ✅ 在高带宽下     |
| 数据丢失保护 | ✅ 自动        | ❌ 应用责任      |
| 重新连接   | ✅ 无缝        | ❌ 无内置支持     |

## Rust 客户端

[Rust 客户端](https://github.com/helius-labs/laserstream-sdk/tree/main/rust) 提供零拷贝反序列化和本机性能，适用于需要最大控制的应用程序。

在 `helius-laserstream` 0.2.0 版本中，Rust 客户端支持[通过 缩库过滤器进行压缩账户过滤](/zh/laserstream/cuckoo-filters)，使单个订阅可以跟踪数十万个账户。（在 JavaScript SDK 0.4.0+ 版本中也可用。）

### 安装

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

### 快速开始

```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 客户端

[Go 客户端](https://github.com/helius-labs/laserstream-sdk/tree/main/go) 提供惯用的 Go 接口。

### 安装

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

### 快速开始

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

## 为什么从 Yellowstone 迁移到 LaserStream

Yellowstone 客户端面临关键限制，随着 Solana 的扩展这些限制只会变得更糟：

1. **性能瓶颈**：Yellowstone JavaScript 客户端最大处理速度为 30MB/s —— 对于高吞吐量应用程序来说不够
2. **延迟递增**：在高带宽订阅中，延迟会随着时间累积
3. **手动重播**：您必须实现自己的重新连接和重播逻辑
4. **数据丢失风险**：没有内置重播，网络中断意味着交易丢失

**LaserStream 解决了这些问题**。凭借40倍的性能提升、自动重播和零数据丢失保证，迁移到LaserStream可以确保您的应用程序在Solana发展过程中保持竞争力。