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

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

La méthode RPC [`isBlockhashValid`](https://www.helius.dev/docs/api-reference/rpc/http/isblockhashvalid) vérifie si un blockhash précédemment obtenu est toujours considéré comme valide par le réseau. Les blockhashes ont une durée de vie limitée (environ 2 minutes, ou 150 blocs), après quoi les transactions les référant seront rejetées.

Cette méthode est cruciale pour les applications qui conservent des blockhashes pendant un certain temps avant de soumettre une transaction, afin de s'assurer que la transaction ne échoue pas en raison d'un blockhash expiré.

**Remarque sur la version :** Cette méthode est disponible dans `solana-core` v1.9 et plus récent. Pour les nœuds exécutant `solana-core` v1.8 ou plus ancien, vous devez utiliser `getFeeCalculatorForBlockhash` qui, en plus des informations sur les frais, indique également implicitement la validité du blockhash (il renverra une erreur si le blockhash est trop ancien).

## Cas d'utilisation courants

* **Réenvoi de transaction :** Avant de réessayer une transaction échouée, vérifiez si son blockhash original est toujours valide. Sinon, un nouveau blockhash doit être récupéré.
* **Signature de transaction différée :** Si une transaction est préparée mais signée et soumise plus tard, vérifiez la validité du blockhash juste avant la soumission.
* **Traitement optimiste des transactions :** Déterminez si un blockhash est susceptible d'être accepté par le réseau si une transaction est envoyée immédiatement.

## Paramètres de requête

1. **`blockhash`** (string, requis): Le blockhash à vérifier, en tant que chaîne encodée en base-58.
2. **`options`** (objet, optionnel): Un objet de configuration optionnel pouvant inclure :
   * **`commitment`** (string, optionnel): Spécifie le [niveau d'engagement](https://www.helius.dev/blog/solana-commitment-levels) pour la requête (par exemple, `"finalized"`, `"confirmed"`, `"processed"`). Si omis, l'engagement par défaut du nœud est utilisé.
   * **`minContextSlot`** (u64, optionnel): Le slot minimum auquel la requête peut être évaluée. Cela garantit que le nœud RPC ne répond pas avec un statut provenant d'un slot antérieur au `minContextSlot`.

## Structure de la réponse

Le champ `result` dans la réponse JSON-RPC est un objet `RpcResponse` contenant :

* **`context`** (objet) : Un objet contenant :
  * **`slot`** (u64) : Le slot auquel le nœud RPC a évalué la validité du blockhash.
* **`value`** (booléen) : `true` si le blockhash est toujours valide, `false` sinon.

**Exemple de réponse (Blockhash valide) :**

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

**Exemple de réponse (Blockhash invalide/expiré) :**

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

## Exemples de code

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

## Conseils pour les développeurs

* **Expiration des blockhashes :** Les blockhashes ne sont valides que pendant un temps limité (environ 150 slots, ou environ 1-2 minutes). Récupérez toujours un blockhash frais si vous avez un doute ou si un temps significatif s'est écoulé.
* **Utilisation de `minContextSlot` :** Utilisez `minContextSlot` pour vous protéger contre l'interrogation d'un nœud RPC obsolète qui pourrait donner une réponse "valide" dépassée pour un blockhash qui est en réalité trop ancien du point de vue du reste du cluster.
* **Alternative pour les nœuds plus anciens :** Pour les nœuds exécutant des versions de Solana antérieures à 1.9, utilisez `getFeeCalculatorForBlockhash("<YOUR_BLOCKHASH>")`. Si cette méthode réussit, le blockhash est valide. Si une erreur est renvoyée (généralement parce que le blockhash est introuvable ou trop ancien), alors le blockhash est invalide.
* **Confirmation réseau :** Même si `isBlockhashValid` retourne `true`, une transaction n'est finalisée que lorsqu'elle atteint le niveau d'engagement souhaité sur le réseau après soumission.

Ce guide fournit les détails nécessaires pour utiliser efficacement la méthode RPC `isBlockhashValid` lors de la création d'applications Solana.

## Méthodes associées

<CardGroup cols={2}>
  <Card title="getLatestBlockhash" href="/docs/fr/api-reference/rpc/http/getlatestblockhash">
    Obtenez un nouveau blockhash pour de nouvelles transactions
  </Card>
</CardGroup>