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

# Reproducción histórica de LaserStream: recupera datos faltantes

> Recupérate de desconexiones y recupera datos faltantes de la blockchain de Solana con la función de reproducción histórica de LaserStream. No vuelvas a perderte ninguna transacción.

<Info>
  **No te pierdas nada**: la reproducción histórica de LaserStream te permite recuperarte de desconexiones y recuperar datos faltantes de las últimas 24 horas de actividad de la blockchain.
</Info>

## ¿Qué es la reproducción histórica?

La reproducción histórica es una función de LaserStream que te permite volver a reproducir datos recientes de la blockchain estableciendo un punto de inicio `fromSlot`. Resulta útil para gestionar desconexiones y garantizar la continuidad de los datos en aplicaciones en tiempo real.

## Hasta dónde puedes retroceder en la reproducción

Puedes reproducir hasta \~24 horas (\~216,000 slots) de historial, sin importar el nivel de compromiso de tu suscripción. Pasa un valor `fromSlot` dentro de ese intervalo y LaserStream transmitirá desde allí hasta el presente.

**Las reproducciones más antiguas devuelven datos finalizados.** LaserStream conserva aproximadamente los últimos \~20 minutos de slots en memoria; todo lo anterior se obtiene de un almacén histórico que solo contiene bloques finalizados. Por lo tanto, cuando reproduces un valor `fromSlot` con más de \~20 minutos de antigüedad, los datos reflejan la cadena finalizada: no verás slots bifurcados o descartados ni actualizaciones de cuentas dentro de un slot en ese intervalo, incluso con una suscripción `processed` o `confirmed`. Los slots de los últimos \~20 minutos conservan la semántica real del nivel de compromiso, incluidas las bifurcaciones y las actualizaciones de cuentas dentro de un slot.

<Warning>
  **Intervalo de tiempo limitado**: la reproducción histórica solo abarca las últimas \~24 horas. No puedes reproducir datos desde puntos arbitrarios del pasado.
</Warning>

<CardGroup cols={2}>
  <Card title="Handle Disconnections" icon="clock-rotate-left">
    Recupera los datos perdidos durante desconexiones breves (hasta 24 horas)
  </Card>

  <Card title="Bootstrap Applications" icon="rocket">
    Inicia aplicaciones con contexto reciente de las últimas 24 horas
  </Card>

  <Card title="Analyze Recent Events" icon="magnifying-glass">
    Revisa transacciones y cambios de cuentas recientes
  </Card>

  <Card title="Test with Recent Data" icon="flask">
    Usa datos recientes reales para pruebas y desarrollo
  </Card>
</CardGroup>

## Cómo funciona

<Steps>
  <Step title="Specify Starting Point">
    Usa el parámetro `fromSlot` para establecer el punto de inicio de la reproducción (debe estar dentro de los últimos \~216,000 slots)
  </Step>

  <Step title="Stream Historical Data">
    LaserStream entrega todos los eventos a partir del slot especificado
  </Step>

  <Step title="Catch Up to Real-Time">
    Los datos históricos se transmiten hasta que alcanzas el slot actual
  </Step>

  <Step title="Continue Live Streaming">
    Pasa sin interrupciones a la transmisión de datos en tiempo real
  </Step>
</Steps>

<Note>
  **Reconexión automática**: el [SDK de LaserStream](https://github.com/helius-labs/laserstream-sdk) gestiona automáticamente las reconexiones y la reproducción. No se requiere código adicional.
</Note>

La reproducción respeta la marca de filtro de transacciones `matchMints`, por lo que una reproducción [filtrada por mint](/docs/es/laserstream/mint-filtering) devuelve el mismo conjunto de transacciones que habría entregado la transmisión en vivo.

## Inicio rápido

<Tip>
  Comienza a usar LaserStream desde tu [panel de Helius](https://dashboard.helius.dev/laserstream). Mainnet requiere un plan Business o Professional; Devnet está disponible con el plan Developer y superiores. Consulta [Planes y precios](/docs/es/billing/plans) para obtener más información.
</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>

## Opciones de configuración

<ParamField path="fromSlot" type="number" required>
  El número de slot desde el que se iniciará la reproducción, como un `u64`. Debe estar dentro del intervalo de reproducción (los últimos \~216,000 slots o \~24 horas desde el slot actual), en cualquier nivel de compromiso.

  **Ejemplo**: `currentSlot - 1000`

  **Importante**: si pasas un slot anterior al intervalo disponible, LaserStream rechaza la solicitud con `Operation was attempted past the valid range`.
</ParamField>

## Casos de uso

<AccordionGroup>
  <Accordion title="Reconnection After Brief Disconnection">
    Cuando tu aplicación vuelve a conectarse después de una desconexión breve (menos de 24 horas), puedes usar la reproducción histórica para asegurarte de no perder ningún dato. `getCurrentSlot` llama al RPC de Helius; `lastProcessedSlot` se conserva en memoria a continuación. Guárdalo de la forma que mejor se adapte a tu aplicación (Redis, Postgres, un archivo, 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="Bootstrap with Recent Context">
    Inicia tu aplicación con contexto reciente de los ú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="Testing with Recent Data">
    Usa datos históricos recientes para realizar pruebas (limitado a las ú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 pasos

<CardGroup cols={2}>
  <Card title="LaserStream gRPC" icon="bolt" href="/docs/es/laserstream/grpc">
    Obtén más información sobre las capacidades y funciones de transmisión de gRPC
  </Card>

  <Card title="Get Started" icon="rocket" href="https://dashboard.helius.dev/laserstream">
    Habilita LaserStream desde tu panel de Helius y comienza a transmitir.
  </Card>

  <Card title="SDK Documentation" icon="github" href="https://github.com/helius-labs/laserstream-sdk">
    Consulta la documentación completa del SDK
  </Card>

  <Card title="Contact Support" icon="headset" href="/docs/es/support">
    Obtén ayuda con tu implementación
  </Card>
</CardGroup>