LaserStream gRPC Quickstart

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 otimizado para desempenho para benefícios adicionais, incluindo maior throughput, reconexões automáticas, gerenciamento de assinaturas, tratamento de erros e mais.

LaserStream SDK é 40x mais rápido em relação a clientes Yellowstone JavaScript

Saiba como usamos Rust Core com bindings NAPI zero-copy para maximizar o desempenho do SDK JavaScript

Aviso de Desempenho: Se você experimentar alguma lentidão ou problemas de desempenho com sua conexão LaserStream, consulte a seção de Solução de Problemas para causas e soluções comuns.

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 obter melhor desempenho:

Endpoints Mainnet

Região	Localização	Endpoint
ewr	Newark, NJ (perto de 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 (perto de Nova York)	`https://laserstream-devnet-ewr.helius-rpc.com`

Seleção de Rede & Região:

Para aplicações de produção, escolha o endpoint mainnet mais próximo de seu servidor para obter melhor desempenho (por exemplo, se implantar na Europa, use Amsterdã (ams) ou Frankfurt (fra))
Para testes, use: https://laserstream-devnet-ewr.helius-rpc.com.

`zstd` Compressão

Todos os endpoints gRPC do LaserStream suportam a compressão zstd. A compressão é opcional: as respostas permanecem descompactadas a menos que seu cliente anuncie suporte zstd. Habilite zstd no Helius LaserStream TypeScript SDK:

import { CompressionAlgorithms } from 'helius-laserstream'
import type { LaserstreamConfig } from 'helius-laserstream'

const config: LaserstreamConfig = {
  apiKey: 'YOUR_API_KEY',
  endpoint: 'https://laserstream-mainnet-ewr.helius-rpc.com',
  channelOptions: {
    'grpc.default_compression_algorithm': CompressionAlgorithms.zstd,
  },
}

zstd reduz a largura de banda da rede, mas adiciona o trabalho de compressão. Avalie com sua carga de trabalho de assinatura antes de ativá-la para streams sensíveis à latência.

Truncamento de Logs

Por padrão, o LaserStream trunca mensagens de log de transações para 10 KB para melhor velocidade e desempenho. Se precisar de logs completos, endpoints dedicados não truncados estão disponíveis — veja Truncamento de Logs.

Início Rápido

Comece com o LaserStream a partir do seu Painel Helius. O mainnet requer um plano Business ou Professional; o Devnet está disponível no Developer e superior. Veja Planos & Preços para detalhes.

Criar um Novo Projeto

mkdir laserstream-grpc-demo
cd laserstream-grpc-demo
npm init -y

Instalar Dependências

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 todos quebram uma execução rápida ts-node index.ts. tsx executa arquivos .ts sem um tsconfig.

Obter Sua Chave API

Gere uma chave no Painel Helius.Esta chave servirá como seu token de autenticação para o LaserStream.

Requisitos de Plano: O LaserStream devnet está disponível em todos os planos. O LaserStream mainnet requer um plano Business ou Professional.

Criar um Script de Assinatura

Crie index.ts com o seguinte:

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

Substituir Sua Chave API e Escolher Sua Região

No index.ts, atualize o objeto config com:

Sua chave API real do Painel Helius
O endpoint LaserStream mais próximo do local do seu servidor

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

Executar e Ver Resultados

npx tsx index.ts

Sempre que uma transação de token confirmed envolver TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA, você verá os dados no seu console.

Fluxos de Trabalho Comuns

Guias passo a passo para os fluxos de trabalho que vemos com mais frequência. Cada guia usa o SDK helius-laserstream com reconexão automática e reprodução histórica integrada.

Assinaturas de Conta

Monitore alterações de saldo, dados e propriedade em contas específicas com filtros.

Monitoramento de Transações

Transmita transações envolvendo contas-alvo, filtre por programa, voto ou status de falha.

Monitoramento de Slots & Blocos

Acompanhe o consenso da rede, produção de blocos e transições de nível de compromisso.

Decodificação de Dados de Transações

Faça o parse dos payloads binários transactionUpdate em transações Solana legíveis.

Stream de Dados Pump AMM

Exemplo do mundo real: monitore negociações Pump AMM com filtros seguros para reconexão.

O cliente @triton-one/yellowstone-grpc funciona nos mesmos endpoints se você preferir o protocolo Yellowstone bruto. Veja a referência do Yellowstone gRPC para detalhes no nível do protocolo.

Pedido de Inscrição

No pedido de inscrição, você precisa incluir os seguintes parâmetros gerais:

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); observe que reproduções mais antigas que ~20 minutos retornam apenas dados finalizados.

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.

Slots

Defina filtros para atualizações de slot. A chave que você usa (por exemplo, mySlotLabel) é um rótulo definido pelo usuário para esta configuração de filtro específica, permitindo que você defina potencialmente várias configurações nomeadas, se necessário (embora geralmente uma seja suficiente).

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
  }
},

Contas

Defina filtros para atualizações de dados de contas. A chave que você usa (por exemplo, tokenAccounts) é um rótulo definido pelo usuário para esta configuração de filtro específica.

array

Corresponde a qualquer chave pública da array fornecida.

array

A chave pública do proprietário da conta. Corresponde a qualquer chave pública da array fornecida.

array

Semelhante aos filtros em getProgramAccounts. Esta é uma array de filtros datasize e/ou memcmp. Para memcmp, o comparando vai em um dos bytes, base58 ou base64 diretamente no objeto memcmp.

enum

obsoleto

Depreciado — sem operação a partir do Agave 4.2. Configurar notifyOn não tem efeito. O campo será removido posteriormente.

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

Os campos operam como um E lógico.
Valores dentro de arrays funcionam como um OU lógico (exceto dentro de filters, que operam como um E lógico).

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"
        }
      }
    ]
  }
},

Rastreando mais de ~10.000 contas? Em vez de uma lista explícita de chaves públicas (32 bytes por conta), use um filtro cuckoo comprimido (~3–4 bytes por conta) para se inscrever em centenas de milhares de contas em um único stream. Disponível nos SDKs Rust e JavaScript.

Transação

Defina filtros para atualizações de transação. A chave que você usa (por exemplo, myTxSubscription) é um rótulo definido pelo usuário para esta configuração de filtro específica.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.
Valores dentro de arrays são tratados como um OU lógico (exceto para accountRequired, onde todos devem corresponder).

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: []
  }
},

Bloco

Defina filtros para atualizações de bloco. A chave que você usa (por exemplo, myBlockLabel) é um rótulo definido pelo usuário para esta configuração de filtro específica.

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
  }
},

Metadados do Bloco

Isto funciona de maneira semelhante aos Blocos, mas exclui transações, contas e entradas. A chave que você usa (por exemplo, blockmetadata) é um rótulo definido pelo usuário para esta inscrição. Atualmente, não há filtros disponíveis para metadados de blocos — todas as mensagens são transmitidas por padrão.

blocksMeta: {
  blockmetadata: {}
},

Entradas

Inscreva-se para entradas de ledger. A chave que você usa (por exemplo, entrySubscribe) é um rótulo definido pelo usuário para esta inscrição. Atualmente, não há filtros disponíveis para entradas; todas as entradas são transmitidas.

entry: {
  entrySubscribe: {}
},

Exemplos de Código (SDK do LaserStream)

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

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

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

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

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

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

Opções de SDK

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

TypeScript: LaserStream TypeScript SDK
Rust: LaserStream Rust SDK
Go: LaserStream Go SDK

Para outras linguagens ou implementações personalizadas, você pode usar diretamente os arquivos proto Yellowstone gRPC para gerar clientes gRPC na sua linguagem preferida.

Solução de Problemas / FAQ

Q: Estou experimentando atrasos ou desempenho lento com minha conexão LaserStream. O que pode estar causando isso?

A: Problemas de desempenho com as conexões LaserStream são tipicamente 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 inscrições mais estreitamente para reduzir o volume de mensagens, mudar para o LaserStream JavaScript SDK ou tentar usar outra linguagem.
Largura de Banda Local Limitada: Inscrições pesadas podem sobrecarregar clientes com largura de banda de rede limitada. Monitore seu uso de 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 do seu servidor. Para conexões de alta latência, aumente os tamanhos dos buffers de leitura da rede (pode melhorar a largura de banda em mais de 5x):
sudo sysctl -w net.core.rmem_max=67108864 net.ipv4.tcp_rmem="4096 87380 67108864"
Para persistir entre reinicializações, adicione a /etc/sysctl.conf:
net.core.rmem_max=67108864 net.ipv4.tcp_rmem=4096 87380 67108864
Aumente os tamanhos de janela do stream e da conexão HTTP/2 para 64MB para evitar gargalos de controle de fluxo. Ambos são necessários — aumentar apenas a janela do stream deixa a janela no nível da conexão como a restrição de ligação:
// 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 está otimizada e não bloqueia o thread principal por períodos prolongados.

Depuração de Atraso do Cliente: Para ajudá-lo a depurar o cliente, construímos uma ferramenta para testar a largura de banda máxima do seu nó para um servidor gRPC Laserstream. 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 máxima de rede entre seu servidor e o servidor Laserstream. No mínimo, você precisa de 10MB/s para se inscrever em todos os dados de transação e 80MB/s para se inscrever em todos os dados de conta. Recomendamos ter pelo menos 2x a capacidade necessária para um desempenho ideal.

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 para qualquer incidente em andamento.

Q: Por que meus filtros não estão funcionando como esperado?

A: Verifique novamente os operadores lógicos (E/OU) descritos nas seções de filtro. Certifique-se de que as chaves públicas estão corretas. Revise o nível de compromisso especificado em sua solicitação.

Q: Posso me inscrever para vários tipos de dados (por exemplo, contas e transações) em uma única solicitação?

A: Sim, você pode definir configurações de filtro sob várias chaves (por exemplo, accounts, transactions) dentro do mesmo objeto SubscribeRequest.

Q: O LaserStream suporta grupos de consumidores?

A: Não implementamos grupos de consumidores. Em vez disso, o LaserStream entrega os mesmos resultados que as equipes desejam: retomar, reproduzir e confiabilidade em vários nós sem uma camada de coordenação (e a latência/sobrecarga que vem com isso). Acreditamos que grupos de consumidores não são necessários para a maioria das cargas de trabalho e que eles adicionam latência e sobrecarga operacional. Como exemplo, uma única conexão gRPC LaserStream pode emitir até 10× dados de transação + conta do Solana, e a maioria dos clientes assina uma fatia pequena e filtrada. Usar grupos de consumidores nesse caso queima capacidade de desempenho e introduz outro ponto de falha.

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 precisar de logs completos, conecte-se a um endpoint dedicado não truncado — veja Truncamento de Logs para a lista.

Q: Por que estou recebendo apenas respostas Pong sem dados de conta ou slot?

A: Incluir um campo ping em sua inicialização SubscribeRequest faz com que o LaserStream ignore silenciosamente todos os filtros de inscrição — apenas um Pong é retornado com zero de dados de conta, transação ou slot. Para corrigir isso, remova ping do pedido de inscrição inicial e, em vez disso, envie pings separadamente pelo sink do stream após a assinatura ser estabelecida. Isso mantém a conexão ativa sem interferir em seus filtros.

Primeiros Passos

Transmissão de Dados e Audição de Eventos

APIs de Dados & RPCs

Negociação

Enviando Transações

Carteira como Serviço

Privacidade

Recursos

LaserStream gRPC Quickstart

Visão Geral

LaserStream SDK é 40x mais rápido em relação a clientes Yellowstone JavaScript

Endpoints & Regiões

Endpoints Mainnet

Endpoint Devnet

`zstd` Compressão

Truncamento de Logs

Início Rápido

Fluxos de Trabalho Comuns

Assinaturas de Conta

Monitoramento de Transações

Monitoramento de Slots & Blocos

Decodificação de Dados de Transações

Stream de Dados Pump AMM

Pedido de Inscrição

Exemplos de Código (SDK do LaserStream)

Opções de SDK

Solução de Problemas / FAQ

​Visão Geral

LaserStream SDK é 40x mais rápido em relação a clientes Yellowstone JavaScript

​Endpoints & Regiões

​Endpoints Mainnet

​Endpoint Devnet

​zstd Compressão

​Truncamento de Logs

​Início Rápido

​Fluxos de Trabalho Comuns

Assinaturas de Conta

Monitoramento de Transações

Monitoramento de Slots & Blocos

Decodificação de Dados de Transações

Stream de Dados Pump AMM

​Pedido de Inscrição

​Exemplos de Código (SDK do LaserStream)

​Opções de SDK

​Solução de Problemas / FAQ

Visão Geral

Endpoints & Regiões

Endpoints Mainnet

Endpoint Devnet

`zstd` Compressão

Truncamento de Logs

Início Rápido

Fluxos de Trabalho Comuns

Pedido de Inscrição

Exemplos de Código (SDK do LaserStream)

Opções de SDK

Solução de Problemas / FAQ