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

# Comment Utiliser getBlockHeight

> Découvrez les cas d'utilisation de getBlockHeight, des exemples de code, les paramètres de requête, la structure de réponse et des conseils.

La méthode RPC [`getBlockHeight`](https://www.helius.dev/docs/api-reference/rpc/http/getblockheight) est un moyen simple de demander à un nœud Solana sa hauteur de bloc actuelle. La hauteur de bloc représente le nombre de blocs traités depuis le bloc de genèse (slot 0).

Cette méthode est utile pour comprendre rapidement l'avancement de la chaîne ou pour référencer la dernière hauteur de bloc à un niveau d'engagement spécifique.

## Cas d'Utilisation Courants

* **Surveillance de la Progression de la Chaîne :** Appelez périodiquement cette méthode pour voir la chaîne avancer.
* **Obtenir un Instantané de la Longueur de la Chaîne :** Déterminez le nombre total de blocs traités jusqu'à un certain point (basé sur l'engagement).
* **Référencement Croisé avec d'Autres Données :** Utilisez la hauteur de bloc comme point de référence lors de l'analyse d'autres données ou événements sur la chaîne.

## Paramètres

`getBlockHeight` peut éventuellement prendre un objet de configuration comme premier paramètre (ou être appelé sans paramètres pour utiliser les valeurs par défaut) :

1. `config` (objet, optionnel) : Un objet de configuration avec les champs suivants :
   * `commitment` (chaîne, optionnel) : Spécifie le niveau d'engagement à utiliser pour la requête. Par défaut, c'est `finalized`.
     * `finalized` : Le nœud interrogera le bloc le plus récent confirmé par la supermajorité du cluster comme ayant atteint le verrouillage maximal.
     * `confirmed` : Le nœud interrogera le bloc le plus récent voté par une supermajorité du cluster.
     * `processed` : Le nœud interrogera son bloc le plus récent. Notez que le bloc peut ne pas être complet.
   * `minContextSlot` (nombre, optionnel) : Le slot minimum auquel la requête peut être évaluée. Cela garantit que la hauteur de bloc retournée provient d'un slot égal ou supérieur à `minContextSlot`.

Si aucun paramètre n'est fourni, la méthode utilise généralement l'engagement par défaut `finalized`.

## Conseils pour les Développeurs

* **Les Niveaux d'Engagement Comptent :** La hauteur de bloc retournée peut varier selon le niveau `commitment` spécifié. `finalized` donne la hauteur la plus stable, tandis qu'`processed` pourrait donner une hauteur plus actuelle mais potentiellement transitoire.
* **`minContextSlot` pour la Cohérence :** Utilisez `minContextSlot` si vous devez vous assurer que la hauteur de bloc est interrogée à partir d'un état au moins aussi récent qu'un slot spécifique que vous suivez.
* **Pas un Numéro de Slot :** Rappelez-vous que la hauteur de bloc est différente du numéro de slot. Un slot est une période de temps, et chaque slot ne produit pas un bloc (ce sont des slots sautés). La hauteur de bloc est le compte des blocs effectivement produits.
* **Vérification Basique de la Santé de la Chaîne :** Bien que simple, `getBlockHeight` peut faire partie d'une vérification basique de la santé de la chaîne ou de synchronisation pour votre application ou système de surveillance.

## Réponse

Le champ `result` de la réponse JSON-RPC sera un seul nombre :

* `blockHeight` (nombre) : La hauteur de bloc actuelle (u64) du nœud selon le niveau d'engagement spécifié.

**Exemple de Réponse JSON :**

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

Cette valeur représente le nombre de blocs sur la chaîne la plus longue, du bloc de genèse (slot 0) jusqu'à la tête actuelle de la chaîne, telle que vue par le nœud interrogé.

## Exemple : Récupération de la Hauteur de Bloc Actuelle

Récupérons la hauteur de bloc actuelle depuis le Helius Devnet RPC.

**Remarque :** Remplacez `YOUR_API_KEY` par votre clé API Helius réelle dans les exemples ci-dessous.

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