> ## 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 gRPC Quickstart

> Instale o SDK, escolha um endpoint e transmita suas primeiras transações Solana pelo LaserStream gRPC. Inclui endpoints, referência de solicitações de assinatura, exemplos de código e FAQ.

## Visão Geral

LaserStream é um serviço gerenciado de streaming Solana gRPC. É compatível com o protocolo Yellowstone gRPC aberto — então qualquer cliente Yellowstone funciona imediatamente — e adiciona recursos de produção como reprodução histórica, failover multiponto e um ambiente totalmente gerenciado.

LaserStream usa o protocolo gRPC de código aberto, garantindo que não haja bloqueio de fornecedor e a máxima compatibilidade com implementações gRPC existentes.

Você pode se conectar tanto com o cliente padrão `@triton-one/yellowstone-grpc` quanto usar o **[Helius LaserStream SDK](/docs/pt-BR/laserstream/clients)** otimizado para desempenho para benefícios adicionais, incluindo maior throughput, reconexões automáticas, gerenciamento de assinaturas, tratamento de erros e mais.

<Card title="LaserStream SDK é 40x mais rápido em relação a clientes Yellowstone JavaScript" icon="bolt" href="https://www.helius.dev/blog/laserstream-sdks">
  Saiba como usamos Rust Core com bindings NAPI zero-copy para maximizar o desempenho do SDK JavaScript
</Card>

<Warning>
  **Aviso de Desempenho**: Se você experimentar qualquer atraso ou problema de desempenho com sua conexão LaserStream, consulte a [seção de Solução de Problemas](#troubleshooting-%2F-faq) para causas comuns e soluções.
</Warning>

<Note>
  **Sem Compressão**: Para minimizar a latência, o LaserStream não comprime mensagens de resposta gRPC. Configurar `Accept-Encoding` com gzip ou zstd não terá efeito — as respostas são sempre retornadas sem compressão.
</Note>

<Divider />

## Endpoints & Regiões

LaserStream está disponível em várias regiões ao redor do mundo.

Escolha o endpoint mais próximo de sua aplicação para um desempenho ideal:

### Endpoints Mainnet

| Região   | Localização                      | Endpoint                                          |
| -------- | -------------------------------- | ------------------------------------------------- |
| **ewr**  | Newark, NJ (próximo a Nova York) | `https://laserstream-mainnet-ewr.helius-rpc.com`  |
| **pitt** | Pittsburgh, US (Central)         | `https://laserstream-mainnet-pitt.helius-rpc.com` |
| **slc**  | Salt Lake City, US (Costa Oeste) | `https://laserstream-mainnet-slc.helius-rpc.com`  |
| **lax**  | Los Angeles, US (Costa Oeste)    | `https://laserstream-mainnet-lax.helius-rpc.com`  |
| **lon**  | Londres, Europa                  | `https://laserstream-mainnet-lon.helius-rpc.com`  |
| **ams**  | Amsterdã, Europa                 | `https://laserstream-mainnet-ams.helius-rpc.com`  |
| **fra**  | Frankfurt, Europa                | `https://laserstream-mainnet-fra.helius-rpc.com`  |
| **tyo**  | Tóquio, Ásia                     | `https://laserstream-mainnet-tyo.helius-rpc.com`  |
| **sgp**  | Singapura, Ásia                  | `https://laserstream-mainnet-sgp.helius-rpc.com`  |

### Endpoint Devnet

| Rede       | Localização                      | Endpoint                                        |
| ---------- | -------------------------------- | ----------------------------------------------- |
| **Devnet** | Newark, NJ (próximo a Nova York) | `https://laserstream-devnet-ewr.helius-rpc.com` |

<Note>
  **Seleção de Rede & Região**:

  * Para **apps em produção**, escolha o endpoint mainnet mais próximo de seu servidor para um melhor desempenho (ex.: se implantando na Europa, use Amsterdã (`ams`) ou Frankfurt (`fra`))
  * Para **testes**, use: `https://laserstream-devnet-ewr.helius-rpc.com`.
</Note>

### Truncamento de Logs

Por padrão, o LaserStream trunca mensagens de log de transação para **10 KB** para melhor velocidade e desempenho. Se você precisar de logs completos, endpoints dedicados não truncados estão disponíveis — veja [Truncamento de Logs](/docs/pt-BR/laserstream/log-truncation).

## Início Rápido

<Tip>
  Comece com o LaserStream a partir do seu [Painel Helius](https://dashboard.helius.dev/laserstream). O Mainnet requer um plano Business ou Professional; o Devnet está disponível no Developer e acima. Veja [Planos & Preços](/docs/pt-BR/billing/plans) para detalhes.
</Tip>

<Steps>
  <Step title="Crie um Novo Projeto">
    ```bash theme={"system"}
    mkdir laserstream-grpc-demo
    cd laserstream-grpc-demo
    npm init -y
    ```
  </Step>

  <Step title="Instale Dependências">
    ```bash theme={"system"}
    npm install helius-laserstream
    npm install --save-dev typescript tsx @types/node
    ```

    Usamos `tsx` porque o padrão `npx tsc --init` no TypeScript 5.x define `verbatimModuleSyntax`, `module: "nodenext"`, e `types: []`, que quebram uma execução rápida `ts-node index.ts`. `tsx` executa arquivos `.ts` sem um tsconfig.
  </Step>

  <Step title="Obtenha Sua Chave API">
    Gere uma chave a partir do [Painel Helius](https://dashboard.helius.dev/).

    Esta chave servirá como seu token de autenticação para o LaserStream.

    <Note>
      **Requisitos de Plano**: O LaserStream devnet está disponível em todos os [planos](/docs/pt-BR/billing/plans). O LaserStream mainnet requer um plano Business ou Professional.
    </Note>
  </Step>

  <Step title="Crie um Script de Assinatura">
    Crie **`index.ts`** com o seguinte conteúdo:

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

    async function main() {
      const subscriptionRequest: SubscribeRequest = {
        transactions: {
          "token-filter": { // user-defined label for this filter
            accountInclude: ['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'],
            accountExclude: [],
            accountRequired: [],
            vote: false,
            failed: false
          }
        },
        commitment: CommitmentLevel.CONFIRMED,
        accounts: {},
        slots: {},
        transactionsStatus: {},
        blocks: {},
        blocksMeta: {},
        entry: {},
        accountsDataSlice: [],
        // Optionally, you can replay missed data by specifying a `fromSlot` (u64 number):
        // fromSlot: currentSlot - 1000,
        // Note: replay is currently limited to the last ~216,000 slots (≈24 hours).
      };

    // Replace the values below with your actual LaserStream API key and endpoint
    const config: LaserstreamConfig = {
      apiKey: 'YOUR_API_KEY', // Replace with your key from https://dashboard.helius.dev/
      endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
    }

      await subscribe(config, subscriptionRequest, async (data) => {
        
        console.log(data);

      }, async (error) => {
        console.error(error);
      });
    }

    main().catch(console.error);
    ```
  </Step>

  <Step title="Substitua Sua Chave API e Escolha Sua Região">
    No `index.ts`, atualize o objeto `config` com:

    1. Sua chave API real do [Painel Helius](https://dashboard.helius.dev/)
    2. O endpoint LaserStream mais próximo da localização do seu servidor

    ```typescript theme={"system"}
    const config: LaserstreamConfig = {
      apiKey: 'YOUR_ACTUAL_API_KEY', // Replace with your key from Helius Dashboard
      endpoint: 'https://laserstream-mainnet-fra.helius-rpc.com', // Example: Frankfurt mainnet
      // For devnet: endpoint: 'https://laserstream-devnet-ewr.helius-rpc.com'
    }
    ```

    **Exemplos de Seleção de Rede & Região:**

    * **Para Produção (Mainnet)**:
      * Europa: Use `fra` (Frankfurt), `ams` (Amsterdã), ou `lon` (Londres)
      * US Leste: Use `ewr` (Nova York)
      * US Oeste: Use `slc` (Salt Lake City) ou `lax` (Los Angeles)
      * Ásia: Use `tyo` (Tóquio) ou `sgp` (Singapura)
    * **Para Desenvolvimento (Devnet)**:
      * Use `https://laserstream-devnet-ewr.helius-rpc.com`
  </Step>

  <Step title="Execute e Veja os Resultados">
    ```bash theme={"system"}
    npx tsx index.ts
    ```

    Sempre que uma transação de token `confirmed` envolver `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`, você verá os dados no seu console.
  </Step>
</Steps>

<Divider />

## Fluxos de Trabalho Comuns

Guias passo-a-passo para os fluxos de trabalho que mais vemos. Cada guia usa o [`helius-laserstream`](/docs/pt-BR/laserstream/clients) SDK com reconexão automática e reprodução histórica integrada.

<CardGroup cols={2}>
  <Card title="Assinaturas de Conta" icon="user" href="/docs/pt-BR/laserstream/guides/account-subscription">
    Monitore alterações de saldo, dados e propriedade em contas específicas com filtros.
  </Card>

  <Card title="Monitoramento de Transações" icon="receipt" href="/docs/pt-BR/laserstream/guides/transaction-monitoring">
    Transmita transações envolvendo contas-alvo, filtre por programa, voto ou status de falha.
  </Card>

  <Card title="Monitoramento de Slot & Bloco" icon="cube" href="/docs/pt-BR/laserstream/guides/slot-and-block-monitoring">
    Acompanhe o consenso da rede, produção de blocos e transições de nível de compromisso.
  </Card>

  <Card title="Decodificação de Dados de Transação" icon="binary" href="/docs/pt-BR/laserstream/guides/decoding-transaction-data">
    Parseie cargas úteis `transactionUpdate` binárias em transações Solana legíveis.
  </Card>

  <Card title="Dados de Pump AMM em Stream" icon="chart-line" href="/docs/pt-BR/laserstream/guides/stream-pump-amm-data">
    Exemplo do mundo real: monitore trades de Pump AMM com filtros seguros para reconexão.
  </Card>
</CardGroup>

<Tip>
  O cliente `@triton-one/yellowstone-grpc` funciona contra os mesmos endpoints se você preferir o protocolo Yellowstone bruto. Veja a [referência Yellowstone gRPC](/docs/pt-BR/grpc) para detalhes do protocolo.
</Tip>

<Divider />

## Solicitação de Assinatura

Na solicitação de assinatura, você precisa incluir os seguintes parâmetros gerais:

<Note>
  **Reprodução Histórica:** Você pode incluir opcionalmente um campo `fromSlot` (um número `u64`) no objeto principal `SubscribeRequest` para reproduzir dados a partir de um slot específico. A reprodução atualmente é limitada aos últimos 216.000 slots (≈24 horas); note que [reproduções mais antigas que \~20 minutos retornam apenas dados finalizados](/docs/pt-BR/laserstream/historical-replay#how-far-back-you-can-replay).
</Note>

<ParamField type="enum">
  Especifica o nível de compromisso, que pode ser **processed**, **confirmed** ou **finalized**.
</ParamField>

<ParamField type="array">
  Uma matriz de objetos `{ offset: uint64, length: uint64 }` que permite que você receba apenas as fatias de dados necessárias das contas.
</ParamField>

<ParamField type="boolean">
  Alguns provedores de nuvem (como o Cloudflare) podem fechar streams inativos após um período de inatividade. Para evitar isso e manter a conexão ativa sem a necessidade de reenviar filtros, configure este parâmetro como **true**. O servidor responderá com uma mensagem Pong a cada 15 segundos.
</ParamField>

```typescript theme={"system"}
const subscriptionRequest: SubscribeRequest = {
  commitment: CommitmentLevel.CONFIRMED,
  accountsDataSlice: [],
  transactions: {},
  accounts: {},
  slots: {},
  blocks: {},
  blocksMeta: {},
  entry: {},
}
```

Em seguida, você precisará especificar os filtros para os dados aos quais deseja se inscrever, como contas, blocos, slots ou transações.

<Accordion title="Slots">
  Defina filtros para atualizações de slots. A chave que você usa (ex.: `mySlotLabel`) é uma **etiqueta definida pelo usuário** para esta configuração de filtro específica, permitindo potencialmente definir múltiplas configurações nomeadas, se necessário (embora normalmente uma seja suficiente).

  <ParamField type="boolean">
    Por padrão, os slots são enviados para todos os níveis de compromisso. Com este filtro, você pode optar por receber apenas o nível de compromisso selecionado.
  </ParamField>

  <ParamField type="boolean">
    Habilita a assinatura para receber atualizações para mudanças dentro de um slot, não apenas no início de novos slots. Isto é útil para dados de slot mais granulares e de baixa latência.
  </ParamField>

  ```typescript theme={"system"}
  slots: {
    // mySlotLabel is a user-defined name for this slot update filter configuration
    mySlotLabel: {
      // filterByCommitment: true => Only broadcast slot updates at the specified subscribeRequest commitment
      filterByCommitment: true
      // interslotUpdates: true allows receiving updates for changes occurring within a slot, not just new slots.
      interslotUpdates: true
    }
  },
  ```
</Accordion>

<Accordion title="Accounts">
  Defina filtros para atualizações de dados de contas. A chave que você usa (ex.: `tokenAccounts`) é uma **etiqueta definida pelo usuário** para esta configuração de filtro.

  <ParamField type="array">
    Corresponde a qualquer chave pública da matriz fornecida.
  </ParamField>

  <ParamField type="array">
    A chave pública do proprietário da conta. Corresponde a qualquer chave pública da matriz fornecida.
  </ParamField>

  <ParamField type="array">
    Semelhante aos filtros em [getProgramAccounts](https://solana.com/docs/rpc/http/getprogramaccounts). Isto é uma matriz de filtros `datasize` e/ou `memcmp`. Para `memcmp`, o comparador vai em um dos `bytes`, `base58`, ou `base64` diretamente no objeto `memcmp`.
  </ParamField>

  Se todos os campos estiverem vazios, todas as contas serão transmitidas. Caso contrário:

  * Os campos operam como um **E** lógico.
  * Os valores dentro das matrizes agem como um **OU** lógico (exceto dentro de `filters`, que operam como um **E** lógico).

  ```typescript theme={"system"}
  accounts: {
    // tokenAccounts is a user-defined label for this account filter configuration
    tokenAccounts: {
      // Matches any of these public keys (logical OR)
      account: ["9SHQTA66Ekh7ZgMnKWsjxXk6DwXku8przs45E8bcEe38"],
      // Matches owners that are any of these public keys
      owner: ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"],
      // Filters - all must match (AND logic)
      filters: [
        { datasize: 165 },
        {
          memcmp: {
            offset: 0,
            base58: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
          }
        }
      ]
    }
  },
  ```

  Rastreamento de mais de \~10.000 contas? Em vez de uma lista explícita de chaves públicas (32 bytes por conta), use um filtro [cuckoo](https://en.wikipedia.org/wiki/Cuckoo_filter) comprimido (\~3–4 bytes por conta) para assinar centenas de milhares de contas em uma única transmissão. Disponível nos SDK Rust e JavaScript.
</Accordion>

<Accordion title="Transaction">
  Defina filtros para atualizações de transações. A chave que você usa (ex.: `myTxSubscription`) é uma **etiqueta definida pelo usuário** para esta configuração de filtro.

  <ParamField type="boolean">
    Ative ou desative a transmissão de transações de votação.
  </ParamField>

  <ParamField type="boolean">
    Ative ou desative a transmissão de transações com falha.
  </ParamField>

  <ParamField type="string">
    Transmita apenas transações que correspondam à assinatura especificada.
  </ParamField>

  <ParamField type="array">
    Filtre transações que envolvam qualquer conta da lista fornecida.
  </ParamField>

  <ParamField type="array">
    Exclua transações que envolvam qualquer conta da lista fornecida (o oposto de `accountInclude`).
  </ParamField>

  <ParamField type="array">
    Filtre transações que envolvam todas as contas da lista fornecida (todas as contas devem ser usadas).
  </ParamField>

  <ParamField type="string">
    Expansão opcional `tokenAccounts` (conta de token associada). Quando configurado, uma carteira `accountInclude` também coincide com transações onde ela **possui** um saldo de token SPL — ex. transferências de token de entrada que tocam a conta de token da carteira em vez de sua chave pública. Aceita `"balanceChanged"` (correspondências de delta de saldo), `"all"` (qualquer referência, maior volume), ou `"none"` (nenhuma expansão, o padrão). O SDK converte a string para o enum de nível de fio `TokenAccountExpansionControlFlag` (parte do `yellowstone-grpc-proto` 12.5.0+). Veja [Filtragem de Conta de Token (ATA)](/docs/pt-BR/laserstream/token-account-filtering) para saber o que faz e como funciona.
  </ParamField>

  Se todos os campos forem deixados vazios, todas as transações serão transmitidas. Caso contrário:

  * Os campos operam como um **E** lógico.
  * Os valores dentro das matrizes são tratados como um **OU** lógico (exceto para `accountRequired`, onde todos devem corresponder).

  ```typescript theme={"system"}
  transactions: {
    // myTxSubscription is a user-defined label for this transaction filter configuration
    myTxSubscription: {
      vote: false,
      failed: false,
      signature: "",
      // Transaction must include at least one of these public keys (OR)
      accountInclude: ["86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY"],
      // Exclude if it matches any of these
      accountExclude: [],
      // Require all accounts in this array (AND)
      accountRequired: []
    }
  },
  ```
</Accordion>

<Accordion title="Block">
  Defina filtros para atualizações de blocos. A chave que você usa (ex.: `myBlockLabel`) é uma **etiqueta definida pelo usuário** para esta configuração de filtro específico.

  <ParamField type="array">
    Filtre transações e contas que envolvam qualquer conta da lista fornecida.
  </ParamField>

  <ParamField type="boolean">
    Inclui todas as transações na transmissão.
  </ParamField>

  <ParamField type="boolean">
    Inclui todas as atualizações de conta na transmissão.
  </ParamField>

  <ParamField type="boolean">
    Inclui todas as entradas na transmissão.
  </ParamField>

  ```typescript theme={"system"}
  blocks: {
    // myBlockLabel is a user-defined label for this block filter configuration
    myBlockLabel: {
      // Only broadcast blocks referencing these accounts
      accountInclude: ["86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY"],
      includeTransactions: true,
      includeAccounts: false,
      includeEntries: false
    }
  },
  ```
</Accordion>

<Accordion title="Blocks Meta">
  Isto funciona de maneira semelhante aos Blocos, mas exclui transações, contas e entradas. A chave que você usa (ex.: `blockmetadata`) é uma **etiqueta definida pelo usuário** para esta assinatura. Atualmente, não há filtros disponíveis para metadados de bloco — todas as mensagens são transmitidas por padrão.

  ```typescript theme={"system"}
  blocksMeta: {
    blockmetadata: {}
  },
  ```
</Accordion>

<Accordion title="Entries">
  Assine entradas no livro razão. A chave que você usa (ex.: `entrySubscribe`) é uma **etiqueta definida pelo usuário** para esta assinatura. Atualmente, não há filtros disponíveis para entradas; todas as entradas são transmitidas.

  ```typescript theme={"system"}
  entry: {
    entrySubscribe: {}
  },
  ```
</Accordion>

<Divider />

## Exemplos de Código (LaserStream SDK)

<Tabs>
  <Tab title="Atualizações de Slot">
    ```typescript theme={"system"}
    import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

    async function main() {
        const subscriptionRequest: SubscribeRequest = {
            transactions: {},
            commitment: CommitmentLevel.CONFIRMED,
            accounts: {},
            slots: {
                slot: { filterByCommitment: true },
            },
            transactionsStatus: {},
            blocks: {},
            blocksMeta: {},
            entry: {},
            accountsDataSlice: [],
        };

        const config: LaserstreamConfig = {
            apiKey: 'YOUR_API_KEY', // Replace with your key
            endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
        }

        await subscribe(config, subscriptionRequest, async (data) => {
            console.log(data);
        }, async (error) => {
            console.error(error);
        });
    }

    main().catch(console.error);
    ```
  </Tab>

  <Tab title="Atualizações de Conta">
    ```typescript theme={"system"}
    import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

    async function main() {
        const subscriptionRequest: SubscribeRequest = {
            accounts: {
                "usdc-account": { // user-defined label for this filter
                    account: ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"], // USDC mint account
                    owner: [],
                    filters: []
                }
            },
            accountsDataSlice: [],
            commitment: CommitmentLevel.CONFIRMED,
            slots: {},
            transactions: {},
            transactionsStatus: {},
            blocks: {},
            blocksMeta: {},
            entry: {}
        };

        const config: LaserstreamConfig = {
            apiKey: 'YOUR_API_KEY', // Replace with your key
            endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
        }

        await subscribe(config, subscriptionRequest, async (data) => {
            console.log(data);
        }, async (error) => {
            console.error(error);
        });
    }

    main().catch(console.error);
    ```
  </Tab>

  <Tab title="Atualizações de Transação">
    ```typescript theme={"system"}
    import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

    async function main() {
        const subscriptionRequest: SubscribeRequest = {
            transactions: {
                "token-filter": { // user-defined label for this filter
                    accountInclude: ['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'],
                    accountExclude: [],
                    accountRequired: [],
                    vote: false,
                    failed: false
                }
            },
            commitment: CommitmentLevel.CONFIRMED,
            accounts: {},
            slots: {},
            transactionsStatus: {},
            blocks: {},
            blocksMeta: {},
            entry: {},
            accountsDataSlice: [],
        };

        const config: LaserstreamConfig = {
            apiKey: 'YOUR_API_KEY', // Replace with your key
            endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
        }

        await subscribe(config, subscriptionRequest, async (data) => {
            console.log(data);
        }, async (error) => {
            console.error(error);
        });
    }

    main().catch(console.error);
    ```
  </Tab>

  <Tab title="Blocos">
    ```typescript theme={"system"}
    import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

    async function main() {
        const subscriptionRequest: SubscribeRequest = {
            entry: {},
            accounts: {},
            accountsDataSlice: [],
            slots: {},
            blocks: {
                blocks: {
                    accountInclude: []
                }
            },
            blocksMeta: {},
            transactions: {},
            transactionsStatus: {},
            commitment: CommitmentLevel.CONFIRMED,
        };

        const config: LaserstreamConfig = {
            apiKey: 'YOUR_API_KEY', // Replace with your key
            endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
        }

        await subscribe(config, subscriptionRequest, async (data) => {
            console.log(data);
        }, async (error) => {
            console.error(error);
        });
    }

    main().catch(console.error);
    ```
  </Tab>

  <Tab title="Metadados de Bloco">
    ```typescript theme={"system"}
    import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

    async function main() {
        const subscriptionRequest: SubscribeRequest = {
            entry: {},
            accounts: {},
            accountsDataSlice: [],
            slots: {},
            blocks: {},
            blocksMeta: {
                blockmetadata: {}
            },
            transactions: {},
            transactionsStatus: {},
            commitment: CommitmentLevel.CONFIRMED,
        };

        const config: LaserstreamConfig = {
            apiKey: 'YOUR_API_KEY', // Replace with your key
            endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
        }

        await subscribe(config, subscriptionRequest, async (data) => {
            console.log(data);
        }, async (error) => {
            console.error(error);
        });
    }

    main().catch(console.error);
    ```
  </Tab>

  <Tab title="Entradas">
    ```typescript theme={"system"}
    import { subscribe, CommitmentLevel, LaserstreamConfig, SubscribeRequest } from 'helius-laserstream'

    async function main() {
        const subscriptionRequest: SubscribeRequest = {
            entry: {
                entrySubscribe: {}  // Subscribe to all entries
            },
            accounts: {},
            accountsDataSlice: [],
            slots: {},
            blocks: {},
            blocksMeta: {},
            transactions: {},
            transactionsStatus: {},
            commitment: CommitmentLevel.CONFIRMED,
        };

        const config: LaserstreamConfig = {
            apiKey: 'YOUR_API_KEY', // Replace with your key
            endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com', // Choose your closest region
        }

        await subscribe(config, subscriptionRequest, async (data) => {
            console.log(data);
        }, async (error) => {
            console.error(error);
        });
    }

    main().catch(console.error);
    ```
  </Tab>
</Tabs>

<Divider />

## Opções de SDK

Fornecemos SDKs oficiais para várias linguagens de programação:

* **TypeScript**: [LaserStream TypeScript SDK](https://github.com/helius-labs/laserstream-sdk)
* **Rust**: [LaserStream Rust SDK](https://github.com/helius-labs/laserstream-sdk/tree/main/rust)
* **Go**: [LaserStream Go SDK](https://github.com/helius-labs/laserstream-sdk/tree/main/go)

Para outras linguagens ou implementações personalizadas, você pode usar os [arquivos proto gRPC Yellowstone](https://github.com/rpcpool/yellowstone-grpc/tree/v6.0.0%2Bsolana.2.2.12/yellowstone-grpc-proto/proto) diretamente para gerar clientes gRPC para sua linguagem preferida.

<Divider />

## Solução de Problemas / FAQ

<Accordion title="Q: Estou experenciando atraso ou desempenho lento com minha conexão LaserStream. O que poderia estar causando isso?">
  **A:** Problemas de desempenho com conexões LaserStream normalmente são causados por:

  * **Lentidão do Cliente JavaScript**: O cliente JavaScript pode ficar para trás ao processar muitas mensagens ou consumir muita largura de banda. Considere filtrar suas assinaturas de maneira mais estreita para reduzir o volume de mensagens, mudar para o [LaserStream JavaScript SDK](/docs/pt-BR/laserstream/clients), ou tentar usar outra linguagem.

  * **Largura de banda local limitada**: Assinaturas pesadas podem sobrecarregar clientes com largura de banda de rede limitada. Monitore o uso da rede e considere atualizar sua conexão ou reduzir o escopo da assinatura.

  * **Distância geográfica**: Rotas de rede longas aumentam a latência e a perda de pacotes. Use o [endpoint mais próximo de seu servidor](#mainnet-endpoints). Para conexões de alta latência, aumente os tamanhos dos buffers de leitura de rede (pode melhorar a largura de banda em mais de 5x):

    ```bash theme={"system"}
    sudo sysctl -w net.core.rmem_max=67108864 net.ipv4.tcp_rmem="4096 87380 67108864"
    ```

    Para persistir após reinicializações, adicione ao `/etc/sysctl.conf`:

    ```bash theme={"system"}
    net.core.rmem_max=67108864
    net.ipv4.tcp_rmem=4096 87380 67108864
    ```

    Aumente os tamanhos da janela de stream **e conexão** HTTP/2 para 64MB para evitar gargalos de controle de fluxo. Ambos são necessários — elevar apenas a janela do stream deixa a janela de nível de conexão como a restrição de ligação:

    ```rust theme={"system"}
    // Rust (tonic)
    Channel::from_static("https://laserstream-mainnet-ewr.helius-rpc.com")
        .initial_stream_window_size(1024 * 1024 * 64)      // 64MB stream window
        .initial_connection_window_size(1024 * 1024 * 64)  // 64MB connection window
        .connect()
        .await?;
    ```

  * **Gargalos de processamento do lado do cliente**: Certifique-se de que sua lógica de processamento de mensagens esteja otimizada e não bloqueie a thread principal por longos períodos.

  **Debugging de Atrasos no Cliente**: Para ajudá-lo a depurar o cliente, criamos uma ferramenta para testar a largura de banda máxima do seu nó para um servidor Laserstream gRPC. Para usá-la execute:

  ```
  cargo install helius-laserstream-bandwidth
  helius-laserstream-bandwidth --laserstream-url $LASERSTREAM_URL --api-key $API_KEY
  ```

  A saída retorna a capacidade de rede máxima entre seu servidor e o servidor Laserstream. No mínimo, você precisa de 10MB/s para assinar todos os dados de transação e 80MB/s para assinar todos os dados de conta. Recomendamos ter pelo menos 2x a capacidade necessária para um desempenho ideal.
</Accordion>

<Accordion title="Q: Estou recebendo erros de conexão. O que devo verificar?">
  **A:** Verifique se sua chave API e endpoint estão corretos e se sua rede permite conexões gRPC de saída para o endpoint especificado. Verifique a [página de status do Helius](https://helius.statuspage.io/) para quaisquer incidentes em andamento.
</Accordion>

<Accordion title="Q: Por que meus filtros não estão funcionando como esperado?">
  **A:** Verifique novamente os operadores lógicos (AND/OR) descritos nas seções de filtro. Certifique-se de que as chaves públicas estão corretas. Revise o nível de compromisso especificado na sua solicitação.
</Accordion>

<Accordion title="Q: Posso assinar vários tipos de dados (ex.: contas e transações) em uma única solicitação?">
  **A:** Sim, você pode definir configurações de filtro sob várias chaves (ex.: `accounts`, `transactions`) dentro do mesmo objeto `SubscribeRequest`.
</Accordion>

<Accordion title="Q: O LaserStream suporta grupos de consumo?">
  **A:** Nós não implementamos grupos de consumo. Em vez disso, o LaserStream entrega os mesmos resultados que as equipes desejam: retomar, reproduzir e confiabilidade multiponto sem uma camada de coordenação (e a latência/sobrecarga que acompanha). Acreditamos que grupos de consumo não são necessários para a maioria das cargas de trabalho e adicionam latência e sobrecarga operacional. Por exemplo, uma única conexão LaserStream gRPC pode emitir até 10× os dados de transações + contas do Solana, e a maioria dos clientes assina uma fatia pequena e filtrada. Usar grupos de consumo neste caso consome desempenho e introduz outro ponto de falha.
</Accordion>

<Accordion title="Q: Por que minhas mensagens de log de transação estão sendo cortadas?">
  **A:** O LaserStream trunca mensagens de log de transação para 10 KB por padrão para melhor velocidade e desempenho. Se você precisar de logs completos, conecte-se a um endpoint dedicado não truncado — veja [Truncamento de Logs](/docs/pt-BR/laserstream/log-truncation) para a lista.
</Accordion>

<Accordion title="Q: Por que estou recebendo apenas respostas Pong sem dados de conta ou slot?">
  **A:** Incluir um campo `ping` em sua solicitação inicial `SubscribeRequest` faz com que o LaserStream ignore silenciosamente todos os filtros de assinatura — apenas um Pong é retornado sem dados de conta, transação ou slot. Para corrigir isso, remova `ping` da solicitação inicial de assinatura e em vez disso envie pings separadamente via saída do stream após a assinatura ser estabelecida. Isso mantém a conexão ativa sem interferir nos seus filtros.
</Accordion>