Alcançando execução em slot zero com Sender e LaserStream

Introdução

Todos querem que suas transações sejam incluídas o mais rápido possível. No entanto, à medida que a infraestrutura de trading da Solana se torna mais sofisticada e os mercados on-chain amadurecem, simplesmente enviar uma transação e torcer pelo melhor já não é suficiente — congestionamento, concorrência e peculiaridades da rede transformam “rápido” em “frustrantemente imprevisível”.

O objetivo é simples: quando surge um sinal — um preço ultrapassa determinado limite, uma conta é atualizada ou um programa é invocado —, a transação que reage a ele deve ser incluída no mesmo slot. 

Essa é a essência da execução em slot zero, na qual a detecção e o envio acontecem de forma tão integrada que as oportunidades são aproveitadas antes de desaparecerem em milissegundos. 

Na prática, isso está cada vez mais difícil de alcançar, pois exige ingestão de sinais com latência ultrabaixa e entrega confiável e determinística.

A Helius oferece ambos.

Ao combinar o LaserStream para detecção ultrarrápida de eventos com o Sender para o envio otimizado de transações, a Helius oferece um pipeline completo e desenvolvido especificamente para execução em slot zero.

Sem infraestrutura fragmentada, sem suposições e sem ciclos desperdiçados — apenas os sinais mais rápidos e os caminhos mais rápidos até os líderes, projetados para dar uma vantagem competitiva à sua operação de trading.

LaserStream e Sender: um fluxo de trabalho unificado

O Sender complementa o LaserStream para criar um pipeline completo e integrado para fluxos de trading responsivos na Solana. Na prática:

1. Use o LaserStream para detectar sinais: a ingestão no nível de shreds e a filtragem avançada fornecem eventos on-chain em tempo real mais rápido do que qualquer outro pipeline.
2. Use o Helius Sender para reagir aos sinais: as transações são enviadas simultaneamente por SWQoS e Jito, com roteamento global e entrega ciente dos validadores para maximizar a inclusão e minimizar a latência.
3. Lucre: juntos, esses serviços tornam possível aproveitar oportunidades lucrativas na prática, não apenas na teoria.

Com a Helius, os desenvolvedores têm acesso a uma stack verticalmente integrada, criada especificamente para oferecer velocidade e confiabilidade:

• Não é preciso combinar RPCs de terceiros, relays ou infraestrutura própria.
• Roteamento global, novas tentativas automáticas e entrega ciente dos validadores são recursos integrados.
• Transparente e justo — não fazemos sandwich de usuários ativamente nem extraímos qualquer tipo de MEV negativo contra nossos usuários.

A Helius já oferece a melhor detecção de sinais da categoria com o LaserStream. Então, por que não combiná-la com o melhor envio de transações da categoria usando o Sender? 

Juntos, eles formam um pipeline único e unificado para fluxos de trabalho na Solana em que cada milissegundo importa. Deixe a Helius cuidar do ciclo de leitura e gravação para gerar resultados determinísticos e lucrativos.

Então, como isso funciona na prática?

Encontrando o sinal certo

Arbitragens e liquidações podem desaparecer em milissegundos na Solana. Detectar o sinal on-chain certo no momento adequado é de extrema importância. Aqui, “sinal” se refere a qualquer evento em tempo real, como uma transferência de token, atualização de conta ou invocação de programa, que apresente uma oportunidade negociável. Sem ingestão de latência ultrabaixa, as vantagens desaparecem antes que seja possível agir, tornando essencial um streaming de dados rápido e confiável.

O LaserStream é o serviço de streaming de dados de última geração da Helius para a Solana. Ele combina a velocidade da ingestão no nível de shreds com a confiabilidade e o alcance de um serviço distribuído globalmente, sem o custo nem as dificuldades operacionais de manter vários nós dedicados.

A filtragem avançada do LaserStream permite que os desenvolvedores se concentrem em sinais específicos, como tipos de transação e atualizações de conta, além do streaming geral de blocos. Para obter um sinal ainda mais cedo, Preprocessed Transactions transmite transações assinadas e decodificadas de shreds até 8 ms antes do nível de compromisso processed e se integra ao Sender exatamente da mesma forma.

A integração é simples, pois foi projetada como uma substituição direta do Yellowstone gRPC e oferece suporte a vários clientes, incluindo Rust, Go e TypeScript. 

No entanto, ter o melhor serviço de streaming de dados da categoria é apenas metade da batalha, pois as oportunidades apresentadas pelos sinais têm duas partes:

• Detecção de eventos — identificar possíveis sinais.
• Envio reativo de transações — criar, enviar e incluir transações em resposta a um possível sinal.

O LaserStream oferece uma vantagem na detecção de eventos, permitindo um envio reativo de transações mais eficaz. No entanto, o LaserStream não é um serviço de envio de transações e, infelizmente, incluí-las de forma eficaz na Solana não é tão simples quanto disparar uma simples chamada RPC sendTransaction.

Otimizando fluxos de envio de transações

A inclusão de transações é um problema de otimização com múltiplas variáveis que exige conhecimento profundo de várias áreas da arquitetura da Solana. Fatores como tempo de chegada, sucesso da simulação, conflitos de bloqueio de contas, taxas de transação associadas e prioridade interagem para determinar quando uma transação será executada on-chain. 

Deixar de considerar qualquer um desses fatores no fluxo de detecção de sinais e criação de transações pode ter efeitos prejudiciais, transformando uma vantagem competitiva em uma oportunidade perdida. 

Por exemplo, mesmo que um trader detecte um sinal milissegundos antes dos concorrentes, uma chegada atrasada ou taxas insuficientes podem fazer com que a transação falhe on-chain com um slot de atraso, transformando uma oportunidade lucrativa em perda de receita.

Incluir transações de forma eficaz exige um fluxo de trabalho abrangente que maximize a prioridade, minimize a latência e antecipe possíveis falhas em toda a stack. 

Para incluir uma transação na Solana de forma eficaz hoje, um desenvolvedor precisa:

Usar Staked Connections

Staked Connections aproveitam o Stake-Weighted Quality of Service (SWQoS) da Solana, priorizando o tráfego de validadores com stake e RPCs pareados para melhorar o alcance aos líderes e a velocidade de propagação. Os desenvolvedores devem rotear por Staked Connections para minimizar falhas de propagação, melhorar os tempos de chegada e aumentar as taxas de inclusão sem depender apenas de endpoints públicos, que podem sofrer com congestionamentos.

Adicionar taxas de prioridade dinâmicas

As taxas de prioridade ajudam a melhorar a posição de uma transação no agendador do líder durante o Banking Stage, no qual um prio-graph, ou seja, uma fila de prioridade que considera dependências, ordena a execução on-chain com base nas taxas por CU. As taxas de prioridade devem ser calculadas dinamicamente para evitar valores estáticos que resultem em pagamento excessivo ou insuficiente e prejudiquem a inclusão no acesso a estados disputados.

Otimizar o uso de CUs

Compute Units (CUs) quantificam a demanda computacional de uma transação. Exceder o orçamento solicitado causa falhas de execução, enquanto solicitar mais do que o necessário aumenta os custos de prioridade. Salvo indicação em contrário, uma transação solicitará 200.000 CUs por padrão. As CUs de uma transação podem ser otimizadas simulando-a antecipadamente para estimar o consumo e solicitando um valor específico com a instrução SetComputeUnitLimit do Compute Budget Program.

Usar o nível de compromisso adequado para buscar dados

Os níveis de compromisso determinam a profundidade de confirmação dos dados obtidos, como blockhashes, que precisam ser recentes para evitar expiração e garantir a validade de uma transação. Usar o nível confirmed para chamadas getLatestBlockhash será significativamente mais rápido do que usar finalized.

Ignorar verificações de preflight

As verificações de preflight simulam uma transação no nó RPC antes do envio, verificando assinaturas, instruções e execução para detectar erros antecipadamente. No entanto, isso pode adicionar mais de 100 ms de latência. Em fluxos sensíveis ao tempo e situações nas quais os desenvolvedores têm certeza absoluta de que estão enviando transações bem-formadas, o parâmetro skipPreflight do método RPC sendTransaction deve ser definido como true.

Observe que é altamente recomendável criar protótipos sem ignorar as verificações de preflight para garantir que as transações estejam formatadas corretamente e sejam incluídas on-chain com sucesso. Embora aumente a velocidade, ignorar essas verificações significa operar às cegas — as transações podem falhar por vários motivos, e não haverá informações sobre a causa das falhas quando essas verificações forem ignoradas.

Definir o parâmetro maxRetries como zero

O parâmetro maxRetries do método sendTransaction permite novos envios automáticos pelo RPC em caso de falha. Isso pode ser ineficiente, por exemplo, ao enviar transações duplicadas com blockhashes obsoletos. Os desenvolvedores devem definir maxRetries como 0 para recuperar o controle e implementar suas próprias tentativas no cliente, usando backoff exponencial, atualizando blockhashes e taxas a cada retransmissão e monitorando a altura do bloco para encerrar as tentativas de forma adequada.

Considerar o uso da Jito

As gorjetas da Jito permitem bundles off-chain por meio de leilões de MEV, garantindo a inclusão e a ordenação das transações em blocos parciais. Isso é ideal para traders ou operadores de arbitragem que precisam de execução no início do bloco ou atomicidade entre várias transações. É extremamente vantajoso para transações de alto valor, sensíveis ao tempo ou que disputem acesso a um estado. No entanto, esses leilões adicionam um atraso que pode piorar o tempo de inclusão em comparação ao envio de uma transação bem otimizada por Staked Connections. Os desenvolvedores precisam combinar esses leilões externos ao protocolo com a confiabilidade de Staked Connections para incluir qualquer tipo de transação o mais rápido possível, sempre.

A implementação dessas práticas recomendadas gera um efeito cumulativo, reduzindo drasticamente as taxas de falha e aumentando a confiabilidade da inclusão. No entanto, gerenciar tudo isso manualmente, acompanhar os últimos avanços do protocolo e adaptar os fluxos de trabalho a eles exige um esforço considerável de engenharia, incluindo ajustes constantes, mudanças de infraestrutura e tratamento de erros — um esforço que poderia ser mais bem empregado em outras áreas.

Sender

O Sender é o serviço de envio de transações com latência ultrabaixa da Helius. Ele aproveita o SWQoS e os leilões off-chain de MEV da Jito para otimizar a inclusão, além de incorporar roteamento geográfico para minimizar atrasos de propagação. 

Ao enviar transações simultaneamente por Staked Connections e pela plataforma de leilões da Jito, o Sender oferece dois caminhos para inclusão, aumentando a confiabilidade e reduzindo os tempos de execução sem consumir créditos adicionais.

O Sender está disponível em todos os planos, com um limite de taxa padrão de 6 TPS, que pode ser ampliado mediante solicitação. Ele foi criado para traders, buscadores de MEV e aplicações de alta frequência que precisam de resultados determinísticos. O Sender complementa o LaserStream, permitindo fluxos reativos integrados para execução em slot zero.

Como o Sender funciona

O Sender processa transações da mesma forma que o processamento convencional — por meio de uma simples solicitação JSON-RPC POST, na qual a transação é serializada em base64 e enviada a um dos endpoints. 

O Sender tem um endpoint HTTPS global que faz o roteamento automático para a região geográfica mais próxima. Por isso, ele é recomendado para aplicações frontend que precisam evitar problemas de CORS. 

O Sender também tem vários endpoints HTTP regionais para oferecer latência ideal entre servidores, por exemplo, em Salt Lake City, Tóquio e Frankfurt.

É importante destacar que não há autenticação por chaves de API — o serviço é direto, sem intermediários entre o recebimento e o envio da transação, o que o torna ideal para casos de uso com latência ultrabaixa. 

Para usar o Sender de forma eficaz, uma transação deve ser preparada da seguinte maneira:

• Uma gorjeta mínima de 0,0002 SOL para a Jito ou 0,000005 SOL (5.000 lamports) para envios somente por SWQoS, o que pode ser especificado adicionando ?swqos_only=true ao endpoint
• O parâmetro skipPreflight deve ser definido como true — o Sender é otimizado para priorizar a velocidade em vez da validação da transação
• O parâmetro maxRetries deve ser definido como 0 — novas tentativas adicionam latência
• Taxas de prioridade devem ser adicionadas para aumentar a prioridade da transação no Banking Stage do líder

Todas as transações enviadas pelo Sender devem incluir uma gorjeta e taxas de prioridade. 

Uma gorjeta é necessária para permitir o acesso à infraestrutura e à inclusão de transações por leilão da Jito. As taxas de prioridade sinalizam ao líder, ou seja, ao validador responsável pelo processamento da transação, a disposição de pagar pelo processamento prioritário. Isso oferece um benefício duplo: as gorjetas dão acesso à infraestrutura de leilões da Jito, enquanto as taxas de prioridade aumentam a prioridade da transação. Ambas atuam para maximizar a inclusão.

Recomendamos buscar as gorjetas dinamicamente com a API de valor mínimo de gorjetas da Jito, por exemplo, usando o 75º percentil e adicionando uma pequena margem, e as taxas de prioridade com a API de taxas de prioridade da Helius. 

Após o envio, o Sender distribuirá as transações em paralelo por SWQoS e Jito, maximizando a inclusão sem nenhum custo adicional. 

Também recomendamos manter as conexões aquecidas durante períodos de inatividade, ou seja, superiores a 1 minuto, enviando pings para /ping, isto é, https://sender.helius-rpc.com/ping, a fim de evitar inicializações a frio. Também recomendamos seguir as práticas recomendadas para o envio de transações para garantir ainda mais uma inclusão ideal. 

Como começar

Veja como começar a operar com LaserStream e Sender:

Trabalhando com o LaserStream

O LaserStream oferece a mesma experiência de desenvolvimento do gRPC. Basta alterar o endpoint e a chave de API para apontar para o LaserStream e aproveitar imediatamente todos os benefícios oferecidos pelo serviço.

Para código existente, a migração é tão simples quanto:

// Before: Using standard Yellowstone gRPC
const connection = new GeyserConnection(
  "your-current-endpoint.com",
  { token: "your-current-token" }
);

// After: Using LaserStream (just change the endpoint and token)
const connection = new GeyserConnection(
  "https://laserstream-mainnet-ewr.helius-rpc.com", // Choose the closest region to you
  { token: "your-helius-api-key" }
);

Recomendamos trabalhar com um dos clientes do LaserStream para simplificar o processo de desenvolvimento.

Por exemplo, abrir uma assinatura é tão simples quanto:

// Using the dedicated LaserStream SDK
import { subscribe, CommitmentLevel, LaserstreamConfig } from 'helius-laserstream';

const config = {
  apiKey: "your-helius-api-key",
  endpoint: "https://laserstream-mainnet-ewr.helius-rpc.com" // Choose the closest region to you
};

// The SDK automatically handles:
// - Connection management
// - Reconnection with backoff
// - Historical replay after disconnects
// - Subscription management
await subscribe(config, subscriptionRequest, handleData, handleError);

Experimente o LaserStream gratuitamente

Quer testar o LaserStream antes de migrar? Obtenha uma avaliação gratuita para medir a latência do LaserStream, compará-lo com soluções alternativas de streaming e avaliá-lo para seu caso de uso específico.

Trabalhando com o Sender

O Helius Sender está disponível para todos os usuários e não consome créditos adicionais — nenhum plano pago ou acesso especial é necessário.

Para começar, crie uma conta no Painel da Helius. Depois, acesse a seção Chaves de API e copie a chave fornecida. Ela é necessária para buscar blockhashes e confirmar a transação, pois o Sender cuida apenas do envio.

Veja abaixo uma transferência simples de SOL usando o Sender. Este exemplo inclui todos os componentes necessários: gorjeta, taxa de prioridade e a opção de ignorar as verificações de preflight.

import { pipe } from "@solana/kit";
import {
  createSolanaRpc,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  signTransactionMessageWithSigners,
  lamports,
  getBase64EncodedWireTransaction,
} from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";
import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from "@solana-program/compute-budget";

(async () => {
  const HELIUS_API_KEY = "your_api_key";
  const PRIV_KEY_B58 = "your_private_key";
  const RECIPIENT = "recipient_address";
  const TIP_ACCOUNTS = [
    "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
    "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
    "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
    "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
    "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
    "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
    "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
    "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
    "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
    "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
  ];

  // Load signer from base58 private key
  const ownerSigner = await createKeyPairSignerFromBytes(bs58.decode(PRIV_KEY_B58));

  // Init RPC and fetch blockhash
  const rpc = createSolanaRpc(`https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`);
  const { value: blockhash } = await rpc.getLatestBlockhash().send();

  // Build and sign transaction
  const tx = pipe(
    createTransactionMessage({ version: 0 }),
    (m) => setTransactionMessageFeePayerSigner(ownerSigner, m),
    (m) => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
    (m) => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 1000 }), m),
    (m) => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: 200_000 }), m),
    (m) =>
      appendTransactionMessageInstruction(
        getTransferSolInstruction({
          source: ownerSigner,
          destination: RECIPIENT,
          amount: lamports(1_000_000n), // 0.001 SOL
        }),
        m
      ),
    (m) =>
      appendTransactionMessageInstruction(
        getTransferSolInstruction({
          source: ownerSigner,
          destination: TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)],
          amount: lamports(200_000n), // 0.0002 SOL
        }),
        m
      )
  );

  const signedTx = await signTransactionMessageWithSigners(tx);
  const base64Tx = getBase64EncodedWireTransaction(signedTx);

  // Send via Sender
  const res = await fetch("https://sender.helius-rpc.com/fast", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: Date.now().toString(),
      method: "sendTransaction",
      params: [
        base64Tx,
        { encoding: "base64", skipPreflight: true, maxRetries: 0 },
      ],
    }),
  });

  const { result: sig, error } = await res.json();
  if (error) throw new Error(error.message);

  console.log("Transaction sent: ", sig);
  console.log(`Explorer: https://orb.helius.dev/tx/${sig}?cluster=mainnet`);
})();

Enviar uma transação pelo Sender é simples com nosso SDK para Node.js. O método `sendTransactionWithSender` processa dinamicamente todos os cálculos de unidades computacionais e taxas, incluindo as gorjetas da Jito: 

import { createHelius } from "helius-sdk";
import { address, createKeyPairSignerFromBytes, lamports } from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";
import bs58 from "bs58";

(async () => {
  const apiKey = ""; // From Helius dashboard
  const helius = createHelius({ apiKey });

  try {
    const feePayerSigner = await createKeyPairSignerFromBytes(
      bs58.decode(process.env.FEEPAYER_SECRET ?? "")
    );

    const toPubkey = address("your_to_address");

    const transferIx = getTransferSolInstruction({
      amount: lamports(1_000_000n), // 0.001 SOL
      destination: toPubkey,
      source: feePayerSigner,
    });

    const sig = await helius.tx.sendTransactionWithSender({
      signers: [feePayerSigner],
      instructions: [transferIx],
      version: 0,
      commitment: "confirmed",
      minUnits: 1_000,
      bufferPct: 0.1,
      region: "US_EAST",
      swqosOnly: true,
      pollTimeoutMs: 60_000,
      pollIntervalMs: 2_000,
    });

    console.log("Confirmed signature:", sig);
    console.log(
      `Explorer link: https://orb.helius.dev/tx/${sig}?cluster=mainnet`
    );
  } catch (error) {
    console.error("Error:", error);
  }
})();

Esse processo também pode ser simplificado com nosso SDK para Rust por meio do método send_smart_transaction_with_sender().

Trabalhando com LaserStream e Sender

O verdadeiro poder da Helius vem da combinação do LaserStream e do Sender em um único fluxo de trabalho. O LaserStream apresenta sinais acionáveis no momento em que surgem, enquanto o Sender garante que as transações que reagem a esses sinais sejam incluídas o mais rápido possível.

O padrão é simples:

• Faça uma assinatura com o LaserStream para monitorar alterações em contas, invocações de programas ou transferências.
• Crie uma transação em resposta a determinado sinal.
• Envie a transação pelo Sender, garantindo o caminho mais rápido e confiável até a inclusão.

Veja um exemplo mínimo que demonstra esse fluxo completo na prática: 

import bs58 from "bs58";
import { subscribe, CommitmentLevel } from "helius-laserstream";
import {
  pipe,
  createSolanaRpc,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  signTransactionMessageWithSigners,
  getBase64EncodedWireTransaction,
  createKeyPairSignerFromBytes,
  lamports,
  address,
} from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";
import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from "@solana-program/compute-budget";

const HELIUS_API_KEY = "your_api_key";
const LASERSTREAM_ENDPOINT = "https://laserstream-mainnet-ewr.helius-rpc.com"; // Pick the nearest region
const PRIV_KEY_B58 = "your_private_key";
const RECIPIENT = "recipient_address";
const TIP_ACCOUNTS = [
    "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
    "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
    "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
    "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
    "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
    "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
    "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
    "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
    "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
    "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
  ];

// Example: scope the stream to a program you care about
const PROGRAM_OWNER_TO_WATCH = "11111111111111111111111111111111";

(async () => {
  // Setup signer and fetch blockhash
  const ownerSigner = await createKeyPairSignerFromBytes(bs58.decode(PRIV_KEY_B58));
  const rpc = createSolanaRpc(`https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`);

  // Setup LaserStream config and request
  const config = {
    apiKey: HELIUS_API_KEY,
    endpoint: LASERSTREAM_ENDPOINT,
  };

  // We keep it scoped to a given program for less noise
  const request = {
    accounts: {
      watch: {
        account: [],
        owner: [PROGRAM_OWNER_TO_WATCH],
        filters: [],
      },
    },
    commitment: CommitmentLevel.PROCESSED, // Can also change to CONFIRMED for more reliability
    slots: {},
    transactions: {},
    transactionsStatus: {},
    blocks: {},
    blocksMeta: {},
    entry: {},
    accountsDataSlice: [],
  };

  // On signal, build and send a reactive transaction via Sender
  const handleData = async () => {
    // Fresh blockhash for lifetime
    const { value: blockhash } = await rpc.getLatestBlockhash().send();

    // Build the transaction with compute-budget ixs first, then user ixs
    const tx = pipe(
      createTransactionMessage({ version: 0 }),
      (m) => setTransactionMessageFeePayerSigner(ownerSigner, m),
      (m) => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
      (m) => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 100_000 }), m),
      (m) => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: 200_000 }), m),
      (m) =>
        // In prod, this could be a buy / sell instruction
        appendTransactionMessageInstruction(
          getTransferSolInstruction({
            source: ownerSigner,
            destination: address(RECIPIENT),
            amount: lamports(1_000_000n), // 0.001 SOL
          }),
          m
        ),
      (m) =>
        appendTransactionMessageInstruction(
          getTransferSolInstruction({
            source: ownerSigner,
            destination: address(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
            amount: lamports(200_000n), // 0.0002 SOL tip
          }),
          m
        )
    );

    const signedTx = await signTransactionMessageWithSigners(tx);
    const base64Tx = getBase64EncodedWireTransaction(signedTx);

    // Send via Sender (i.e., skip preflight and no RPC-side retries)
    const res = await fetch("https://sender.helius-rpc.com/fast", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: Date.now().toString(),
        method: "sendTransaction",
        params: [base64Tx, { encoding: "base64", skipPreflight: true, maxRetries: 0 }],
      }),
    });

    const { result: sig, error } = await res.json();
    if (error) throw new Error(error.message);

    console.log("Reactive transaction sent: ", sig);
    console.log(`Explorer:  https://orb.helius.dev/tx/${sig}?cluster=mainnet`);
  };

  const handleError = console.error;

  // Start the stream (signals → reactive sends)
  const stream = await subscribe(config, request, handleData, handleError);
  console.log(`LaserStream subscription started (id: ${stream.id})`);
})();

Por que escolher a Helius

A Helius se destaca como a principal escolha para otimizar fluxos de transações na Solana graças à nossa posição como o maior validador da rede por stake. Portanto, largura de banda com stake não é um problema para nós. Isso elimina efetivamente gargalos ou casos de falha relacionados à perda de prioridade de transações ou ao descarte de pacotes durante congestionamentos, oferecendo às suas transações um caminho direto e prioritário até os líderes, sem limitações. 

Ao integrar profundamente várias otimizações de hardware e software à nossa largura de banda com stake, a Helius continua dominando como principal provedora e apresenta a menor latência média de slots — uma prova da nossa especialização vertical na Solana. 

Nosso compromisso com a Solana nos coloca na vanguarda das pesquisas e contribuições mais recentes. Por exemplo, as descobertas da Chorus One sobre latência de transações mostram que o SWQoS muitas vezes pode superar a Jito na redução do tempo até a inclusão, especialmente para usuários cuja latência p95 seja superior a 40 segundos. O Sender faz o roteamento inteligente por SWQoS e Jito simultaneamente, garantindo máxima confiabilidade em todos os tipos de transação. 

Em última análise, ter um stake significativo e rotear transações por Staked Connections é o fator mais importante para reduzir o tempo até a inclusão.

Mais rápido

O LaserStream reduz a latência e a incerteza. Quanto antes um sinal chega, mais previsíveis se tornam os resultados. Combinadas ao Sender, as transações enviadas em resposta a um sinal proporcionam maior confiança operacional, decisões mais inteligentes e melhor confiabilidade. Esse pipeline unificado não otimiza apenas a velocidade isoladamente — ele otimiza a confiança.

Com o LaserStream, os desenvolvedores sabem que estão trabalhando com o melhor serviço de streaming de dados do mercado. Com o Sender, podem ter certeza de que suas transações serão roteadas pelos caminhos mais rápidos e confiáveis até os líderes de bloco. 

Juntos, eles criam um efeito cumulativo:

• Menor latência E2E: da detecção do evento à inclusão da transação, cada etapa é reduzida a milissegundos
• Maiores taxas de sucesso: as transações são incluídas onde e quando deveriam, permitindo aproveitar as oportunidades em vez de perdê-las
• Menor sobrecarga de engenharia: é possível dedicar mais atenção ao produto, à estratégia e ao ajuste fino dos algoritmos de trading, em vez de gerenciar e configurar nós dedicados para otimizar o envio de transações
• Execução em slot zero: o LaserStream apresenta notificações enquanto as transações estão sendo executadas em determinado slot, não depois que o slot termina. Isso significa que uma transação enviada em resposta a uma notificação pode ser incluída no mesmo slot 

Na prática, isso significa que traders aproveitam mais arbitragens, liquidantes vencem mais leilões e aplicações de alta frequência oferecem experiências mais fluidas aos usuários. A execução em slot zero não é apenas um ideal teórico predestinado, mas um fluxo de trabalho repetível que só pode ser alcançado com a Helius.

Acesse o Painel da Helius e comece hoje mesmo.