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

# LaserStream Historisches Replay: Fehlende Daten auffüllen

> Erholen Sie sich von Verbindungsabbrüchen und füllen Sie fehlende Solana Blockchain-Daten mit der Historisches Replay-Funktion von LaserStream auf. Verpassen Sie nie wieder eine Transaktion.

<Info>
  **Verpassen Sie nie einen Schlag**: Die Historisches Replay-Funktion von LaserStream stellt sicher, dass Sie sich von Verbindungsabbrüchen erholen und fehlende Daten aus den letzten 24 Stunden der Blockchain-Aktivität auffüllen können.
</Info>

## Was ist Historisches Replay?

Historisches Replay ist eine Funktion von LaserStream, die es Ihnen ermöglicht, aktuelle Blockchain-Daten zu einem `fromSlot` Startpunkt erneut abzuspielen. Dies ist nützlich, um Verbindungsabbrüche zu handhaben und die Datenkontinuität in Echtzeit-Apps sicherzustellen.

## Wie weit zurück können Sie abspielen

Sie können die Geschichte bis zu \~24 Stunden (\~216.000 Slots) unabhängig vom abonnierten Commitment-Level abspielen. Geben Sie einen `fromSlot` innerhalb dieses Zeitfensters ein und LaserStream streamt von dort bis zur Gegenwart weiter.

**Ältere Replays liefern abgeschlossene Daten.** LaserStream speichert ungefähr die letzten \~20 Minuten der Slots im Speicher; alles Ältere wird aus einem historischen Speicher geliefert, der nur abgeschlossene Blöcke enthält. Wenn Sie also einen `fromSlot` älter als \~20 Minuten erneut abspielen, spiegeln die Daten die abgeschlossene Kette wider — Sie werden keine gegabelten oder verworfenen Slots oder Intra-Slot-Kontoupdates in diesem Bereich sehen, selbst bei einem `processed` oder `confirmed` Abonnement. Slots innerhalb der letzten \~20 Minuten tragen echte Commitment-Semantiken, einschließlich Forks und Intra-Slot-Kontoupdates.

<Warning>
  **Begrenztes Zeitfenster**: Historisches Replay deckt nur die letzten \~24 Stunden ab. Sie können keine Daten von beliebigen Punkten in der Vergangenheit erneut abspielen.
</Warning>

<CardGroup cols={2}>
  <Card title="Verbindungsabbrüche handhaben" icon="clock-rotate-left">
    Daten wiederherstellen, die während kurzer Verbindungsabbrüche verloren gingen (bis zu 24 Stunden)
  </Card>

  <Card title="Anwendungen starten" icon="rocket">
    Starten Sie Anwendungen mit aktuellem Kontext der letzten 24 Stunden
  </Card>

  <Card title="Jüngste Ereignisse analysieren" icon="magnifying-glass">
    Überprüfen Sie aktuelle Transaktionen und Kontoänderungen
  </Card>

  <Card title="Mit aktuellen Daten testen" icon="flask">
    Verwenden Sie echte aktuelle Daten für Tests und Entwicklung
  </Card>
</CardGroup>

## Wie es funktioniert

<Steps>
  <Step title="Startpunkt angeben">
    Verwenden Sie den `fromSlot` Parameter, um Ihren Replay-Startpunkt festzulegen (muss innerhalb der letzten \~216.000 Slots liegen)
  </Step>

  <Step title="Historische Daten streamen">
    LaserStream liefert alle Ereignisse ab dem von Ihnen angegebenen Slot
  </Step>

  <Step title="Auf Echtzeit aufholen">
    Historische Daten werden gestreamt, bis Sie den aktuellen Slot erreichen
  </Step>

  <Step title="Fortfahren mit Live-Streaming">
    Nahtlos zum Echtzeit-Datenstreaming übergehen
  </Step>
</Steps>

<Note>
  **Automatische Wiederverbindung**: Das [LaserStream SDK](https://github.com/helius-labs/laserstream-sdk) handelt Wiederverbindungen und Replays automatisch. Kein zusätzlicher Code erforderlich!
</Note>

## Schnellstart

<Tip>
  Starten Sie mit LaserStream von Ihrem [Helius-Dashboard](https://dashboard.helius.dev/laserstream). Mainnet erfordert einen Business- oder Professional-Plan; Devnet ist bei Developer und höher verfügbar. Siehe [Pläne & Preise](/docs/de/billing/plans) für Details.
</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>

## Konfigurationsoptionen

<ParamField path="fromSlot" type="number" required>
  Die Slotnummer, ab der das Replay starten soll, als `u64`. Muss innerhalb des Replay-Zeitfensters liegen (letzte \~216.000 Slots / \~24 Stunden ab dem aktuellen Slot), auf jedem Commitment-Level.

  **Beispiel**: `currentSlot - 1000`

  **Wichtig**: Wenn Sie einen älteren Slot als das Zeitfenster übergeben, lehnt LaserStream die Anfrage mit `Operation was attempted past the valid range` ab.
</ParamField>

## Anwendungsfälle

<AccordionGroup>
  <Accordion title="Wiederverbindung nach kurzem Verbindungsabbruch">
    Wenn sich Ihre Anwendung nach einem kurzen Verbindungsabbruch (unter 24 Stunden) wieder verbindet, können Sie Historisches Replay verwenden, um sicherzustellen, dass keine Daten fehlen. `getCurrentSlot` ruft das Helius RPC auf; `lastProcessedSlot` wird im Speicher unten gehalten — speichern Sie es, wie es für Ihre App passt (Redis, Postgres, eine Datei usw.).

    ```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="Anwendung mit Kontext aktualisieren">
    Starten Sie Ihre Anwendung mit aktuellem Kontext aus den letzten Minuten:

    ```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="Testen mit aktuellen Daten">
    Verwenden Sie aktuelle historische Daten für Tests (begrenzt auf die letzten 24 Stunden):

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

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="LaserStream gRPC" icon="bolt" href="/docs/de/laserstream/grpc">
    Erfahren Sie mehr über gRPC-Streaming-Funktionen und -Features
  </Card>

  <Card title="Erste Schritte" icon="rocket" href="https://dashboard.helius.dev/laserstream">
    Aktivieren Sie LaserStream von Ihrem Helius-Dashboard und starten Sie das Streaming.
  </Card>

  <Card title="SDK-Dokumentation" icon="github" href="https://github.com/helius-labs/laserstream-sdk">
    Sehen Sie sich die vollständigen SDK-Dokumente an
  </Card>

  <Card title="Support kontaktieren" icon="headset" href="/docs/de/support">
    Holen Sie sich Hilfe bei Ihrer Implementierung
  </Card>
</CardGroup>