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

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

O método RPC [`getBlockHeight`](https://www.helius.dev/docs/api-reference/rpc/http/getblockheight) é uma maneira simples de consultar um nó Solana para obter sua altura de bloco atual. A altura do bloco representa o número de blocos que foram processados desde o bloco gênesis (slot 0).

Este método é útil para entender rapidamente quão longe a cadeia progrediu ou para referenciar a altura do bloco mais recente em um nível de compromisso específico.

## Casos de Uso Comuns

* **Monitoramento da Progressão da Cadeia:** Chame este método periodicamente para ver a cadeia avançando.
* **Obtendo um Snapshot do Comprimento da Cadeia:** Determine o número total de blocos processados até um certo ponto (com base no compromisso).
* **Referenciamento Cruzado com Outros Dados:** Use a altura do bloco como ponto de referência ao analisar outros dados ou eventos on-chain.

## Parâmetros

`getBlockHeight` pode opcionalmente aceitar um objeto de configuração como seu primeiro parâmetro (ou ser chamado sem parâmetros para usar padrões):

1. `config` (objeto, opcional): Um objeto de configuração com os seguintes campos:
   * `commitment` (string, opcional): Especifica o nível de compromisso a ser usado na consulta. O padrão é `finalized`.
     * `finalized`: O nó consultará o bloco mais recente confirmado pela super maioria do cluster como tendo atingido o bloqueio máximo.
     * `confirmed`: O nó consultará o bloco mais recente que foi votado por uma super maioria do cluster.
     * `processed`: O nó consultará seu bloco mais recente. Note que o bloco pode não estar completo.
   * `minContextSlot` (número, opcional): O slot mínimo que a solicitação pode ser avaliada. Isso garante que a altura do bloco retornada seja de um slot igual ou maior que `minContextSlot`.

Se nenhum parâmetro for fornecido, o método geralmente usa o padrão de compromisso `finalized`.

## Dicas para Desenvolvedores

* **Os Níveis de Compromisso Importam**: A altura do bloco retornada pode variar com base no nível `commitment` especificado. `finalized` fornece a altura mais estável, enquanto `processed` pode dar uma altura mais atual, mas potencialmente transitória.
* **`minContextSlot` para Consistência**: Use `minContextSlot` se precisar garantir que a altura do bloco seja consultada a partir de um estado pelo menos tão recente quanto um slot específico que você está acompanhando.
* **Não é um Número de Slot**: Lembre-se de que a altura do bloco é diferente do número do slot. Um slot é um período de tempo, e nem todo slot produz um bloco (esses são chamados de slots ignorados). A altura do bloco é a contagem de blocos reais produzidos.
* **Verificação Básica de Saúde da Cadeia**: Embora simples, `getBlockHeight` pode ser parte de uma verificação básica de saúde ou sincronização da cadeia para seu aplicativo ou sistema de monitoramento.

## Resposta

O campo `result` da resposta JSON-RPC será um único número:

* `blockHeight` (número): A altura atual do bloco (u64) do nó de acordo com o nível de compromisso especificado.

**Exemplo de Resposta JSON:**

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

Este valor representa o número de blocos na cadeia mais longa desde o bloco gênesis (slot 0) até a cabeça atual da cadeia, conforme visto pelo nó consultado.

## Exemplo: Obtendo a Altura Atual do Bloco

Vamos buscar a altura atual do bloco do Helius Devnet RPC.

**Nota:** Substitua `YOUR_API_KEY` pela sua chave de API Helius real nos exemplos abaixo.

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