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

# So verwenden Sie isBlockhashValid

> Erfahren Sie mehr über Anwendungsfälle, Codebeispiele, Anforderungsparameter, Antwortstruktur und Tipps zu isBlockhashValid.

Die [`isBlockhashValid`](https://www.helius.dev/docs/api-reference/rpc/http/isblockhashvalid) RPC-Methode überprüft, ob ein zuvor erhaltener Blockhash vom Netzwerk noch als gültig angesehen wird. Blockhashes haben eine begrenzte Lebensdauer (etwa 2 Minuten oder 150 Blöcke), nach deren Ablauf Transaktionen, die auf sie verweisen, abgelehnt werden.

Diese Methode ist entscheidend für Anwendungen, die Blockhashes eine Zeitlang halten, bevor sie eine Transaktion einreichen, um sicherzustellen, dass die Transaktion nicht aufgrund eines abgelaufenen Blockhashes fehlschlägt.

**Versionshinweis:** Diese Methode ist ab `solana-core` v1.9 verfügbar. Für Knoten, die `solana-core` v1.8 oder älter ausführen, sollten Sie `getFeeCalculatorForBlockhash` verwenden, das zusätzlich zu den Gebühreninformationen auch implizit die Gültigkeit von Blockhashes anzeigt (es wird einen Fehler ausgeben, wenn der Blockhash zu alt ist).

## Häufige Anwendungsfälle

* **Transaktionswiederholungsversuch:** Prüfen Sie, bevor Sie eine fehlgeschlagene Transaktion erneut versuchen, ob der ursprüngliche Blockhash noch gültig ist. Wenn nicht, muss ein neuer Blockhash abgerufen werden.
* **Verzögerte Transaktionssignierung:** Wenn eine Transaktion vorbereitet, aber später signiert und eingereicht wird, überprüfen Sie die Gültigkeit des Blockhashes unmittelbar vor der Einreichung.
* **Optimistische Transaktionsverarbeitung:** Bestimmen Sie, ob ein Blockhash wahrscheinlich vom Netzwerk akzeptiert wird, wenn eine Transaktion sofort gesendet wird.

## Anforderungsparameter

1. **`blockhash`** (string, erforderlich): Der zu überprüfende Blockhash, als base-58 kodierter String.
2. **`options`** (object, optional): Ein optionales Konfigurationsobjekt, das Folgendes enthalten kann:
   * **`commitment`** (string, optional): Gibt die [Commitment-Stufe](https://www.helius.dev/blog/solana-commitment-levels) für die Abfrage an (z. B. `"finalized"`, `"confirmed"`, `"processed"`). Wenn nicht angegeben, wird das Standard-Commitment des Knotens verwendet.
   * **`minContextSlot`** (u64, optional): Der minimale Slot, in dem die Anforderung ausgewertet werden kann. Dies stellt sicher, dass der RPC-Knoten nicht mit einem Status aus einem älteren Slot antwortet als dem `minContextSlot`.

## Antwortstruktur

Das `result`-Feld in der JSON-RPC-Antwort ist ein `RpcResponse`-Objekt, das enthält:

* **`context`** (object): Ein Objekt, das enthält:
  * **`slot`** (u64): Der Slot, bei dem der RPC-Knoten die Gültigkeit des Blockhashes überprüft hat.
* **`value`** (boolean): `true`, wenn der Blockhash noch gültig ist, andernfalls `false`.

**Beispielantwort (Gültiger Blockhash):**

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 180000500 },
    "value": true
  },
  "id": 1
}
```

**Beispielantwort (Ungültiger/Abgelaufener Blockhash):**

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 180000800 },
    "value": false
  },
  "id": 1
}
```

## Codebeispiele

<CodeGroup>
  ```bash cURL theme={"system"}
  # Check validity of a blockhash (replace <YOUR_BLOCKHASH>):
  curl -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "isBlockhashValid",
      "params": [
        "<YOUR_BLOCKHASH>"
      ]
    }' \
    <YOUR_RPC_URL>

  # Check with commitment and minContextSlot (replace <YOUR_BLOCKHASH>):
  curl -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "isBlockhashValid",
      "params": [
        "<YOUR_BLOCKHASH>",
        {
          "commitment": "confirmed",
          "minContextSlot": 170000000
        }
      ]
    }' \
    <YOUR_RPC_URL>
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  const { Connection } = require('@solana/web3.js');

  async function checkBlockhash(blockhashToCheck) {
    // Replace with your RPC endpoint
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');

    try {
      console.log(`Checking validity of blockhash: ${blockhashToCheck}`);
      const result = await connection.isBlockhashValid(blockhashToCheck);
      
      console.log(`  Blockhash is valid: ${result.value}`);
      console.log(`  Checked at slot: ${result.context.slot}`);

      // Example with options
      // const resultWithOptions = await connection.isBlockhashValid(
      //   blockhashToCheck,
      //   { commitment: 'confirmed', minContextSlot: result.context.slot - 100 }
      // );
      // console.log(`\nWith options - Valid: ${resultWithOptions.value}, Slot: ${resultWithOptions.context.slot}`);

    } catch (error) {
      console.error(`Error checking blockhash ${blockhashToCheck}:`, error);
    }
  }

  // Example usage: First, get a recent blockhash
  async function getRecentBlockhashAndCheck() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    try {
      const { blockhash } = await connection.getLatestBlockhash();
      await checkBlockhash(blockhash); 
      
      // Example with a known old/invalid blockhash (will likely be false)
      // This blockhash is just an example and will be invalid.
      const oldBlockhash = 'J7rBdM6AecPDEZp8aPq5iPSNKVkU5Q76F3oAV4eW5wsW'; 
      // await checkBlockhash(oldBlockhash);

    } catch (error) {
      console.error('Error in example execution:', error);
    }
  }

  getRecentBlockhashAndCheck();
  ```
</CodeGroup>

## Entwicklertipps

* **Blockhashes laufen ab:** Blockhashes sind nur für eine begrenzte Zeit gültig (ca. 150 Slots oder ungefähr 1-2 Minuten). Holen Sie immer einen frischen Blockhash ein, wenn Sie unsicher sind oder wenn viel Zeit vergangen ist.
* **`minContextSlot` Nutzung:** Verwenden Sie `minContextSlot`, um sich vor einer Abfrage eines veralteten RPC-Knotens zu schützen, der möglicherweise eine veraltete "gültige" Antwort für einen Blockhash gibt, der aus der Perspektive des restlichen Clusters tatsächlich zu alt ist.
* **Alternative für ältere Knoten:** Für Knoten, die Solana-Versionen vor 1.9 ausführen, verwenden Sie `getFeeCalculatorForBlockhash("<YOUR_BLOCKHASH>")`. Wenn diese Methode erfolgreich zurückkehrt, ist der Blockhash gültig. Wenn sie einen Fehler ausgibt (typischerweise weil der Blockhash nicht gefunden wird oder zu alt ist), ist der Blockhash ungültig.
* **Netzwerkbestätigung:** Selbst wenn `isBlockhashValid` `true` zurückgibt, wird eine Transaktion erst abgeschlossen, wenn sie nach der Einreichung das gewünschte Commitment-Level im Netzwerk erreicht.

Dieser Leitfaden bietet die notwendigen Details, um die `isBlockhashValid` RPC-Methode effektiv beim Erstellen von Solana-Anwendungen zu nutzen.

## Verwandte Methoden

<CardGroup cols={2}>
  <Card title="getLatestBlockhash" href="/docs/de/api-reference/rpc/http/getlatestblockhash">
    Holen Sie sich einen frischen Blockhash für neue Transaktionen
  </Card>
</CardGroup>