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

# Cómo usar isBlockhashValid

> Conoce los casos de uso de isBlockhashValid, ejemplos de código, parámetros de solicitud, estructura de respuesta y consejos.

El método RPC [`isBlockhashValid`](https://www.helius.dev/docs/api-reference/rpc/http/isblockhashvalid) comprueba si la red aún considera válido un hash de bloque obtenido previamente. Los hashes de bloque tienen una vigencia limitada (aproximadamente 2 minutos o 150 bloques). Después de ese plazo, se rechazarán las transacciones que hagan referencia a ellos.

Este método es fundamental para las aplicaciones que conservan hashes de bloque durante un tiempo antes de enviar una transacción, ya que permite garantizar que la transacción no falle debido a un hash de bloque vencido.

**Nota sobre la versión:** Este método está disponible en `solana-core` v1.9 y versiones posteriores. Para los nodos que ejecutan `solana-core` v1.8 o una versión anterior, debes usar `getFeeCalculatorForBlockhash`, que, además de proporcionar información sobre las comisiones, también indica implícitamente la validez del hash de bloque (devolverá un error si el hash de bloque es demasiado antiguo).

## Casos de uso comunes

* **Reenvío de transacciones:** Antes de volver a intentar una transacción fallida, comprueba si su hash de bloque original sigue siendo válido. Si no lo es, debes obtener uno nuevo.
* **Firma diferida de transacciones:** Si preparas una transacción, pero la firmas y envías más tarde, verifica la validez del hash de bloque justo antes de enviarla.
* **Procesamiento optimista de transacciones:** Determina si es probable que la red acepte un hash de bloque cuando se envía una transacción inmediatamente.

## Parámetros de la solicitud

1. **`blockhash`** (cadena, obligatorio): El hash de bloque que se comprobará, como una cadena codificada en base 58.
2. **`options`** (objeto, opcional): Un objeto de configuración opcional que puede incluir:
   * **`commitment`** (cadena, opcional): Especifica el [nivel de compromiso](https://www.helius.dev/blog/solana-commitment-levels) para la consulta (por ejemplo, `"finalized"`, `"confirmed"`, `"processed"`). Si se omite, se usa el nivel de compromiso predeterminado del nodo.
   * **`minContextSlot`** (u64, opcional): El slot mínimo en el que se puede evaluar la solicitud. Esto garantiza que el nodo RPC no responda con el estado de un slot anterior a `minContextSlot`.

## Estructura de la respuesta

El campo `result` de la respuesta JSON-RPC es un objeto `RpcResponse` que contiene:

* **`context`** (objeto): Un objeto que contiene:
  * **`slot`** (u64): El slot en el que el nodo RPC evaluó la validez del hash de bloque.
* **`value`** (booleano): `true` si el hash de bloque sigue siendo válido; de lo contrario, `false`.

**Respuesta de ejemplo (hash de bloque válido):**

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

**Respuesta de ejemplo (hash de bloque no válido o vencido):**

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

## Ejemplos de código

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

## Consejos para desarrolladores

* **Los hashes de bloque vencen:** Los hashes de bloque solo son válidos durante un tiempo limitado (alrededor de 150 slots o aproximadamente 1 o 2 minutos). Obtén siempre un hash de bloque nuevo si tienes dudas o si ha transcurrido bastante tiempo.
* **Uso de `minContextSlot`:** Usa `minContextSlot` para evitar consultar un nodo RPC desactualizado que podría devolver una respuesta "válida" obsoleta para un hash de bloque que, desde la perspectiva del resto del clúster, en realidad es demasiado antiguo.
* **Alternativa para nodos antiguos:** Para los nodos que ejecutan versiones de Solana anteriores a la 1.9, usa `getFeeCalculatorForBlockhash("<YOUR_BLOCKHASH>")`. Si este método devuelve una respuesta correctamente, el hash de bloque es válido. Si devuelve un error (por lo general, porque no se encuentra el hash de bloque o porque es demasiado antiguo), el hash de bloque no es válido.
* **Confirmación de la red:** Aunque `isBlockhashValid` devuelva `true`, una transacción solo se finaliza cuando, después de enviarla, alcanza el nivel de compromiso deseado en la red.

Esta guía proporciona la información necesaria para usar eficazmente el método RPC `isBlockhashValid` al desarrollar aplicaciones de Solana.

## Métodos relacionados

<CardGroup cols={2}>
  <Card title="getLatestBlockhash" href="/docs/es/api-reference/rpc/http/getlatestblockhash">
    Obtén un hash de bloque nuevo para transacciones nuevas
  </Card>
</CardGroup>