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

# Como Usar isBlockhashValid

> Aprenda casos de uso de isBlockhashValid, exemplos de código, parâmetros de solicitação, estrutura de resposta e dicas.

O método RPC [`isBlockhashValid`](https://www.helius.dev/docs/api-reference/rpc/http/isblockhashvalid) verifica se um blockhash obtido anteriormente ainda é considerado válido pela rede. Os blockhashes têm um tempo de vida limitado (aproximadamente 2 minutos, ou 150 blocos), após o qual as transações que os referenciam serão rejeitadas.

Este método é crucial para aplicativos que mantêm blockhashes por algum tempo antes de enviar uma transação, para garantir que a transação não falhe devido a um blockhash expirado.

**Nota de Versão:** Este método está disponível em `solana-core` v1.9 e mais recentes. Para nós executando `solana-core` v1.8 ou mais antigos, você deve usar `getFeeCalculatorForBlockhash` que, além de informações de taxa, também indica implicitamente a validade do blockhash (um erro ocorrerá se o blockhash for muito antigo).

## Casos de Uso Comuns

* **Reenvio de Transação:** Antes de tentar uma transação que falhou, verifique se seu blockhash original ainda é válido. Caso contrário, um novo blockhash deve ser buscado.
* **Assinatura Atrasada de Transação:** Se uma transação for preparada, mas assinada e enviada mais tarde, verifique a validade do blockhash logo antes do envio.
* **Processamento Otimista de Transações:** Determine se um blockhash provavelmente será aceito pela rede se uma transação for enviada imediatamente.

## Parâmetros de Solicitação

1. **`blockhash`** (string, obrigatório): O blockhash a ser verificado, como uma string codificada em base-58.
2. **`options`** (objeto, opcional): Um objeto de configuração opcional que pode incluir:
   * **`commitment`** (string, opcional): Especifica o [nível de compromisso](https://www.helius.dev/blog/solana-commitment-levels) para a consulta (por exemplo, `"finalized"`, `"confirmed"`, `"processed"`). Se omitido, o compromisso padrão do nó é usado.
   * **`minContextSlot`** (u64, opcional): O slot mínimo em que a solicitação pode ser avaliada. Isso garante que o nó RPC não responda com um status de um slot mais antigo do que o `minContextSlot`.

## Estrutura de Resposta

O campo `result` na resposta JSON-RPC é um objeto `RpcResponse` contendo:

* **`context`** (objeto): Um objeto contendo:
  * **`slot`** (u64): O slot no qual o nó RPC avaliou a validade do blockhash.
* **`value`** (boolean): `true` se o blockhash ainda for válido, `false` caso contrário.

**Exemplo de Resposta (Blockhash Válido):**

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

**Exemplo de Resposta (Blockhash Inválido/Expirado):**

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

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

## Dicas para Desenvolvedores

* **Blockhashes Expiram:** Blockhashes são válidos apenas por um tempo limitado (cerca de 150 slots, ou aproximadamente 1-2 minutos). Sempre busque um blockhash novo se não tiver certeza ou se muito tempo se passou.
* **Uso de `minContextSlot`:** Use `minContextSlot` para se proteger contra consultas a um nó RPC obsoleto que possa dar uma resposta "válida" desatualizada para um blockhash que está realmente muito antigo do ponto de vista do resto do cluster.
* **Alternativa para Nós Mais Antigos:** Para nós rodando versões do Solana anteriores a 1.9, use `getFeeCalculatorForBlockhash("<YOUR_BLOCKHASH>")`. Se este método retornar com sucesso, o blockhash é válido. Se ocorrer um erro (tipicamente porque o blockhash não é encontrado ou é muito antigo), então o blockhash é inválido.
* **Confirmação de Rede:** Mesmo que `isBlockhashValid` retorne `true`, uma transação só é finalizada quando atinge o nível de compromisso desejado na rede após o envio.

Este guia fornece os detalhes necessários para usar o método RPC `isBlockhashValid` de forma eficaz ao construir aplicativos Solana.

## Métodos Relacionados

<CardGroup cols={2}>
  <Card title="getLatestBlockhash" href="/docs/pt-BR/api-reference/rpc/http/getlatestblockhash">
    Obtenha um blockhash novo para novas transações
  </Card>
</CardGroup>