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

> Erfahren Sie mehr über die Anwendungsfälle von getBlockHeight, Codebeispiele, Anforderungsparameter, die Struktur der Antwort und Tipps.

Die [`getBlockHeight`](https://www.helius.dev/docs/api-reference/rpc/http/getblockheight) RPC-Methode ist eine einfache Möglichkeit, einen Solana-Knoten nach seiner aktuellen Blockhöhe abzufragen. Die Blockhöhe repräsentiert die Anzahl der Blöcke, die seit dem Genesis-Block (Slot 0) verarbeitet wurden.

Diese Methode ist nützlich, um schnell zu verstehen, wie weit die Kette fortgeschritten ist oder um die neueste Blockhöhe auf einem bestimmten Commitment-Level zu referenzieren.

## Häufige Anwendungsfälle

* **Überwachung des Kettenfortschritts:** Rufen Sie diese Methode regelmäßig auf, um zu sehen, wie die Kette voranschreitet.
* **Einen Überblick über die Kettenlänge erhalten:** Bestimmen Sie die Gesamtanzahl der bis zu einem bestimmten Punkt verarbeiteten Blöcke (basierend auf dem Commitment).
* **Abgleich mit anderen Daten:** Verwenden Sie die Blockhöhe als Referenzpunkt, wenn Sie andere On-Chain-Daten oder Ereignisse analysieren.

## Parameter

`getBlockHeight` kann optional ein Konfigurationsobjekt als ersten Parameter entgegennehmen (oder ohne Parameter aufgerufen werden, um Standardwerte zu verwenden):

1. `config` (Objekt, optional): Ein Konfigurationsobjekt mit den folgenden Feldern:
   * `commitment` (String, optional): Gibt das Commitment-Level an, das für die Abfrage verwendet werden soll. Standard ist `finalized`.
     * `finalized`: Der Knoten wird den neuesten Block abfragen, der von der Supermehrheit des Clusters als maximal gesperrt bestätigt wurde.
     * `confirmed`: Der Knoten wird den neuesten Block abfragen, über den von einer Supermehrheit des Clusters abgestimmt wurde.
     * `processed`: Der Knoten wird seinen neuesten Block abfragen. Beachten Sie, dass der Block möglicherweise nicht vollständig ist.
   * `minContextSlot` (Zahl, optional): Der minimale Slot, bei dem die Anfrage ausgewertet werden kann. Dies stellt sicher, dass die zurückgegebene Blockhöhe von einem Slot gleich oder größer als `minContextSlot` stammt.

Wenn keine Parameter angegeben sind, verwendet die Methode in der Regel das STANDARD\_COMMITMENT\_LEVEL.

## Entwicklertipps

* **Commitment-Level ist wichtig**: Die zurückgegebene Blockhöhe kann je nach angegebenem `commitment` Level variieren. `finalized` bietet die stabilste Höhe, während `processed` möglicherweise eine aktuellere, aber potenziell vorübergehende Höhe bietet.
* **`minContextSlot` für Konsistenz**: Verwenden Sie `minContextSlot`, wenn Sie sicherstellen müssen, dass die Blockhöhe aus einem Zustand abgefragt wird, der mindestens so aktuell ist wie ein spezifischer Slot, den Sie verfolgen.
* **Nicht eine Slotnummer**: Denken Sie daran, dass die Blockhöhe sich von der Slotnummer unterscheidet. Ein Slot ist ein Zeitraum, und nicht jeder Slot erzeugt einen Block (dies sind sogenannte übersprungene Slots). Die Blockhöhe ist die Anzahl der tatsächlich erzeugten Blöcke.
* **Grundlegende Kettengesundheitsprüfung**: Obwohl einfach, kann `getBlockHeight` Teil einer grundlegenden Kettengesundheits- oder Synchronisierungsprüfung für Ihre Anwendung oder Ihr Überwachungssystem sein.

## Antwort

Das Feld `result` der JSON-RPC-Antwort wird eine einzelne Zahl sein:

* `blockHeight` (Zahl): Die aktuelle Blockhöhe (u64) des Knotens gemäß dem angegebenen Commitment-Level.

**Beispiel für eine JSON-Antwort:**

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "result": 275123456, // Example block height
  "id": 1
}
```

Dieser Wert repräsentiert die Anzahl der Blöcke auf der längsten Kette vom Genesis-Block (Slot 0) bis zum aktuellen Kopf der Kette, wie vom angefragten Knoten gesehen.

## Beispiel: Abrufen der aktuellen Blockhöhe

Lassen Sie uns die aktuelle Blockhöhe von der Helius Devnet RPC abrufen.

**Hinweis:** Ersetzen Sie `YOUR_API_KEY` durch Ihren tatsächlichen Helius API-Schlüssel in den unten stehenden Beispielen.

<CodeGroup>
  ```bash curl theme={"system"}
  curl https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getBlockHeight",
    "params": [] 
  }'
  ```

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

  async function getCurrentBlockHeight() {
    const rpcUrl = 'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY'; // Replace YOUR_API_KEY
    const connection = new Connection(rpcUrl, 'confirmed');

    try {
      const blockHeight = await connection.getBlockHeight();
      console.log(`Current Block Height: ${blockHeight}`);

    } catch (error) {
      console.error('Error fetching block height:', error);
    }
  }

  getCurrentBlockHeight();
  ```

  ```typescript Kit theme={"system"}
  import { createSolanaRpc } from "@solana/kit";

  const rpc_url = "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY";
  const rpc = createSolanaRpc(rpc_url);

  let blockHeight = await rpc.getBlockHeight().send();

  console.log("block height:", blockHeight);
  ```

  ```rust Rust theme={"system"}
  use anyhow::Result;
  use solana_client::nonblocking::rpc_client::RpcClient;
  use solana_sdk::commitment_config::CommitmentConfig;

  #[tokio::main]
  async fn main() -> Result<()> {
      let client = RpcClient::new_with_commitment(
          String::from("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY"),
          CommitmentConfig::confirmed(),
      );

      let block_height = client.get_block_height().await?;

      println!("Block height: {:#?}", block_height);

      Ok(())
  }
  ```
</CodeGroup>