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

# Lecture Historique de LaserStream : Compléter les Données Manquantes

> Récupérez les données manquantes de la blockchain Solana à l'aide de la fonctionnalité de lecture historique de LaserStream. Ne manquez plus jamais une transaction.

<Info>
  **Ne ratez jamais un moment** : La Lecture Historique de LaserStream vous assure de pouvoir récupérer des déconnexions et remplir les données manquantes des dernières 24 heures d'activité blockchain.
</Info>

## Qu'est-ce que la Lecture Historique ?

La Lecture Historique est une fonctionnalité de LaserStream qui vous permet de rejouer des données récentes de la blockchain en définissant un `fromSlot` point de départ. Ceci est utile pour gérer les déconnexions et assurer la continuité des données dans les applications en temps réel.

## Jusqu'où pouvez-vous rejouer ?

Vous pouvez rejouer jusqu'à \~24 heures (\~216 000 slots) d'historique, quel que soit le niveau de commitment auquel vous souscrivez. Passez un `fromSlot` dans cette fenêtre et LaserStream diffuse à partir de là jusqu'au présent.

**Les replays plus anciens renvoient des données finalisées.** LaserStream conserve environ les 20 dernières minutes de slots en mémoire; tout ce qui est plus ancien est servi à partir d'un stockage historique qui ne contient que des blocs finalisés. Donc, lorsque vous rejouez un `fromSlot` datant de plus de \~20 minutes, les données reflètent la chaîne finalisée — vous ne verrez pas de slots forkés ou supprimés ou de mises à jour de comptes intra-slot dans cette période, même avec un `processed` ou un `confirmed` abonnement. Les slots des \~20 dernières minutes comportent de véritables sémantiques de commitment, y compris les forks et les mises à jour de comptes intra-slot.

<Warning>
  **Fenêtre Temporelle Limitée** : La lecture historique ne couvre que les dernières \~24 heures. Vous ne pouvez pas rejouer des données à partir de points arbitraires dans le passé.
</Warning>

<CardGroup cols={2}>
  <Card title="Gérer les Déconnexions" icon="clock-rotate-left">
    Récupérez les données perdues lors de courtes déconnexions (jusqu'à 24 heures)
  </Card>

  <Card title="Bootstrap des Applications" icon="rocket">
    Démarrez les applications avec un contexte récent des dernières 24 heures
  </Card>

  <Card title="Analyser les Événements Récents" icon="magnifying-glass">
    Passez en revue les transactions récentes et les changements de compte
  </Card>

  <Card title="Tester avec des Données Récentes" icon="flask">
    Utilisez des données récentes réelles pour les tests et le développement
  </Card>
</CardGroup>

## Comment ça marche

<Steps>
  <Step title="Spécifier le Point de Départ">
    Utilisez le paramètre `fromSlot` pour définir votre point de départ de replay (doit être dans les \~216 000 derniers slots)
  </Step>

  <Step title="Diffuser les Données Historiques">
    LaserStream livre tous les événements à partir de votre slot spécifié
  </Step>

  <Step title="Rattraper le Temps Réel">
    Les données historiques sont diffusées jusqu'à atteindre le slot actuel
  </Step>

  <Step title="Continuons la Diffusion en Direct">
    Transition en douceur vers la diffusion de données en temps réel
  </Step>
</Steps>

<Note>
  **Reconnexion Automatique** : Le [LaserStream SDK](https://github.com/helius-labs/laserstream-sdk) gère les reconnexions et le replay automatiquement. Aucun code supplémentaire requis !
</Note>

## Démarrage Rapide

<Tip>
  Commencez avec LaserStream depuis votre [Tableau de Bord Helius](https://dashboard.helius.dev/laserstream). Le Mainnet nécessite un plan Business ou Professionnel; Devnet est disponible pour Developer et supérieur. Voir [Plans & Tarifs](/docs/fr/billing/plans) pour plus de détails.
</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>

## Options de Configuration

<ParamField path="fromSlot" type="number" required>
  Le numéro de slot pour commencer le replay, en tant que `u64`. Doit être dans la fenêtre de replay (les \~216 000 derniers slots / \~24 heures à partir du slot actuel), à n'importe quel niveau de commitment.

  **Exemple** : `currentSlot - 1000`

  **Important** : Si vous passez un slot plus ancien que la fenêtre, LaserStream rejette la requête avec `Operation was attempted past the valid range`.
</ParamField>

## Cas d'Utilisation

<AccordionGroup>
  <Accordion title="Reconnexion après une Courte Déconnexion">
    Lorsque votre application se reconnecte après une courte déconnexion (moins de 24 heures), vous pouvez utiliser la Lecture Historique pour vous assurer qu'aucune donnée n'est manquée. `getCurrentSlot` appelle le Helius RPC; `lastProcessedSlot` est conservé en mémoire ci-dessous — conservez-le comme bon vous semble pour votre application (Redis, Postgres, un fichier, 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 avec un Contexte Récent">
    Démarrez votre application avec un contexte récent des dernières minutes :

    ```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="Tester avec des Données Récentes">
    Utilisez des données historiques récentes pour les tests (limitées aux dernières 24 heures) :

    ```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>

## Prochaines Étapes

<CardGroup cols={2}>
  <Card title="LaserStream gRPC" icon="bolt" href="/docs/fr/laserstream/grpc">
    En savoir plus sur les capacités et les fonctionnalités de streaming gRPC
  </Card>

  <Card title="Commencer" icon="rocket" href="https://dashboard.helius.dev/laserstream">
    Activez LaserStream à partir de votre Tableau de Bord Helius et commencez à diffuser.
  </Card>

  <Card title="Documentation SDK" icon="github" href="https://github.com/helius-labs/laserstream-sdk">
    Consultez la documentation complète du SDK
  </Card>

  <Card title="Contacter le Support" icon="headset" href="/docs/fr/support">
    Obtenez de l'aide pour votre implémentation
  </Card>
</CardGroup>