> ## 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.

# Replay Histórico do LaserStream: Preencher Dados Faltantes

> Recupere-se de desconexões e preencha dados faltantes da blockchain Solana com o recurso de replay histórico do LaserStream. Nunca perca uma transação novamente.

<Info>
  **Nunca perca o ritmo**: O Recurso de Replay Histórico do LaserStream garante que você possa se recuperar de desconexões e preencher dados faltantes das últimas 24 horas de atividade da blockchain.
</Info>

## O que é o Replay Histórico?

Replay Histórico é o recurso do LaserStream que permite reprisar dados recentes da blockchain definindo um ponto de partida `fromSlot`. Isso é útil para lidar com desconexões e garantir continuidade de dados em aplicativos em tempo real.

## Até Onde Você Pode Reprisar

Você pode reprisar até \~24 horas (\~216.000 slots) de histórico, independentemente do nível de compromisso ao qual você se inscreveu. Passe um `fromSlot` dentro desse intervalo e o LaserStream transmite a partir daí até o presente.

**Replays mais antigos retornam dados finalizados.** O LaserStream mantém aproximadamente os últimos \~20 minutos de slots na memória; qualquer coisa mais antiga é servida de um armazenamento histórico que contém apenas blocos finalizados. Portanto, quando você reprisa um `fromSlot` mais antigo que \~20 minutos, os dados refletem a cadeia finalizada — você não verá slots bifurcados ou descartados ou atualizações de conta dentro do slot nessa faixa, mesmo em uma assinatura `processed` ou `confirmed`. Slots nos últimos \~20 minutos carregam semânticas de compromisso verdadeiro, incluindo bifurcações e atualizações de conta dentro do slot.

<Warning>
  **Janela de Tempo Limitada**: O replay histórico só cobre as últimas \~24 horas. Você não pode reprisar dados de pontos arbitrários no passado.
</Warning>

<CardGroup cols={2}>
  <Card title="Lidar com Desconexões" icon="clock-rotate-left">
    Recupere dados perdidos durante desconexões breves (até 24 horas)
  </Card>

  <Card title="Iniciar Aplicações" icon="rocket">
    Inicie aplicações com contexto recente das últimas 24 horas
  </Card>

  <Card title="Analisar Eventos Recentes" icon="magnifying-glass">
    Revise transações e alterações de conta recentes
  </Card>

  <Card title="Testar com Dados Recentes" icon="flask">
    Use dados reais recentes para teste e desenvolvimento
  </Card>
</CardGroup>

## Como Funciona

<Steps>
  <Step title="Especificar Ponto de Partida">
    Use o parâmetro `fromSlot` para definir seu ponto de partida de replay (deve estar dentro dos últimos \~216.000 slots)
  </Step>

  <Step title="Transmitir Dados Históricos">
    O LaserStream entrega todos os eventos do seu slot especificado em diante
  </Step>

  <Step title="Alcançar em Tempo Real">
    Os dados históricos são transmitidos até você atingir o slot atual
  </Step>

  <Step title="Continuar Streaming ao Vivo">
    Transição contínua para streaming de dados em tempo real
  </Step>
</Steps>

<Note>
  **Reconexão Automática**: O [LaserStream SDK](https://github.com/helius-labs/laserstream-sdk) lida com reconexões e replay automaticamente. Nenhum código adicional é necessário!
</Note>

## Início Rápido

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

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

    // Pick a slot within the last ~216,000 slots (≈24 h). For a real start
    // value, call `getSlot` first and subtract however far back you want to replay.
    // Note: replays older than ~20 min return finalized data even at processed/confirmed;
    // slots within the last ~20 min carry true commitment semantics.
    const fromSlot = 419_800_000;

    const subscriptionRequest: SubscribeRequest = {
      transactions: {
        "token-filter": { // user-defined label for this filter
          accountInclude: ['TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'],
          vote: false,
          failed: false
        }
      },
      commitment: CommitmentLevel.CONFIRMED,
      accounts: {},
      slots: {},
      blocks: {},
      blocksMeta: {},
      entry: {},
      accountsDataSlice: [],
      fromSlot, // u64 slot number; must fall inside the replay window
    };

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

    await subscribe(config, subscriptionRequest, 
      async (data) => {
        console.log('Received data:', data);
      }, 
      async (error) => {
        console.error('Error:', error);
      }
    );
    ```
  </Tab>
</Tabs>

## Opções de Configuração

<ParamField path="fromSlot" type="number" required>
  O número do slot para começar a reprisar, como um `u64`. Deve estar dentro da janela de replay (últimos \~216.000 slots / \~24 horas a partir do slot atual), em qualquer nível de compromisso.

  **Exemplo**: `currentSlot - 1000`

  **Importante**: Se você passar um slot mais antigo que a janela, o LaserStream rejeita a solicitação com `Operation was attempted past the valid range`.
</ParamField>

## Casos de Uso

<AccordionGroup>
  <Accordion title="Reconexão Após Desconexão Breve">
    Quando seu aplicativo se reconecta após uma breve desconexão (menos de 24 horas), você pode usar o Replay Histórico para garantir que nenhum dado seja perdido. `getCurrentSlot` chama o Helius RPC; `lastProcessedSlot` é mantido na memória abaixo — persista-o como melhor convier ao seu app (Redis, Postgres, um arquivo, etc.).

    ```typescript theme={"system"}
    async function getCurrentSlot(): Promise<number> {
      const r = await fetch(`https://mainnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getSlot', params: [{ commitment: 'confirmed' }] }),
      });
      const { result } = await r.json();
      return result as number;
    }

    // Load the last slot you processed from wherever you store it.
    let lastProcessedSlot = Number(process.env.LAST_PROCESSED_SLOT ?? 0);

    // Check if it's still within the replay window
    const currentSlot = await getCurrentSlot();
    const maxReplaySlot = currentSlot - 216_000;

    if (lastProcessedSlot < maxReplaySlot) {
      console.warn('Disconnection too long, some data may be lost');
      lastProcessedSlot = maxReplaySlot;
    }

    const subscriptionRequest: SubscribeRequest = {
      // ... your subscription config
      fromSlot: lastProcessedSlot, // pass as number, not string
    };

    await subscribe(config, subscriptionRequest,
      async (data) => {
        // your handler here
        if (data.transaction?.slot) {
          lastProcessedSlot = Number(data.transaction.slot);
          // persist `lastProcessedSlot` here so the next reconnect picks up
        }
      }
    );
    ```
  </Accordion>

  <Accordion title="Iniciar com Contexto Recente">
    Inicie seu aplicativo com contexto recente dos últimos minutos:

    ```typescript theme={"system"}
    // Get a slot from 10 minutes ago (within the 24-hour window)
    const currentSlot = await getCurrentSlot();
    const startSlot = currentSlot - 1500; // ~10 minutes ago

    const subscriptionRequest: SubscribeRequest = {
      // ... your subscription config
      fromSlot: startSlot, // u64 number
    };
    ```
  </Accordion>

  <Accordion title="Testar com Dados Recentes">
    Use dados históricos recentes para teste (limitado às últimas 24 horas):

    ```typescript theme={"system"}
    // Test with data from the last 5 minutes
    const currentSlot = await getCurrentSlot();
    const testStartSlot = currentSlot - 750; // ~5 minutes ago
    const testEndSlot = currentSlot - 150;   // ~1 minute ago

    const subscriptionRequest: SubscribeRequest = {
      // ... your subscription config
      fromSlot: testStartSlot, // u64 number
    };

    // Stop processing when reaching the test end slot
    const stream = await subscribe(config, subscriptionRequest,
      async (data) => {
        const slot = Number(data.transaction?.slot ?? data.account?.slot ?? 0);
        if (slot >= testEndSlot) {
          stream.cancel();
          return;
        }
        // your test handler here
      }
    );
    ```
  </Accordion>
</AccordionGroup>

## Próximos Passos

<CardGroup cols={2}>
  <Card title="LaserStream gRPC" icon="bolt" href="/docs/pt-BR/laserstream/grpc">
    Saiba mais sobre recursos e capacidades de streaming gRPC
  </Card>

  <Card title="Comece" icon="rocket" href="https://dashboard.helius.dev/laserstream">
    Habilite o LaserStream no seu Painel Helius e comece a transmitir.
  </Card>

  <Card title="Documentação do SDK" icon="github" href="https://github.com/helius-labs/laserstream-sdk">
    Veja a documentação completa do SDK
  </Card>

  <Card title="Contatar Suporte" icon="headset" href="/docs/pt-BR/support">
    Obtenha ajuda com sua implementação
  </Card>
</CardGroup>