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

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

O método RPC [`getBlock`](https://www.helius.dev/docs/api-reference/rpc/http/getblock) permite que você recupere informações detalhadas sobre um bloco confirmado no ledger Solana. Isso é essencial para exploradores de blocos, análise de histórico de transações e entendimento do estado da cadeia em um ponto específico no tempo.

<Warning>
  **Evite Agrupamento para Melhor Desempenho**

  Métodos de arquivamento em lote aumentam significativamente a latência. Lotes com mais de 10 solicitações não são permitidos.
</Warning>

## Casos de Uso Comuns

* **Inspecionando Conteúdos de Bloco:** Veja todas as transações incluídas em um [bloco](https://www.helius.dev/blog/solana-slots-blocks-and-epochs) específico.
* **Recuperando Hashes de Bloco:** Obtenha o blockhash para um determinado slot, o blockhash do seu pai e o slot do pai.
* **Verificando Altura e Tempo do Bloco:** Descubra a altura de um bloco (seu número de sequência) e seu tempo estimado de produção.
* **Analisando Detalhes de Transação:** Com parâmetros apropriados, você pode obter dados completos de transações, incluindo metadados como taxas, status, saldos pré/pós e instruções internas.
* **Buscando Recompensas:** Inclua opcionalmente informações de recompensa para o bloco.

## Parâmetros

1. `slot` (número, obrigatório): O número do slot do bloco para consultar (u64).

2. `config` (objeto, opcional): Um objeto de configuração com os seguintes campos:
   * `commitment` (string, opcional): Especifica o [nível de compromisso](https://www.helius.dev/blog/solana-commitment-levels) a ser usado. `processed` não é suportado para este método. O padrão é `finalized`.
   * `encoding` (string, opcional): A codificação para dados de transação. O padrão é `json` se `transactionDetails` for `full` ou `accounts`, caso contrário, `base64`.
     * `json`: Retorna transações e dados de contas em formato JSON (obsoleto em favor de `jsonParsed`).
     * `jsonParsed`: Retorna transações e dados de contas como JSON analisado. Isso é recomendado, pois inclui todas as chaves de conta de transações (incluindo aquelas de Tabelas de Pesquisa de Endereços).
     * `base58` (lento)
     * `base64`
     * `base64+zstd`
   * `transactionDetails` (string, opcional): Especifica o nível de detalhe da transação a ser retornado. O padrão é `full`.
     * `full`: Retorna detalhes completos da transação, incluindo metadados da transação.
     * `accounts`: Retorna uma lista de contas detalhadas em cada transação, mas não os dados completos da transação ou metadados.
     * `signatures`: Retorna apenas as assinaturas das transações.
     * `none`: Não retorna detalhes das transações.
   * `rewards` (booleano, opcional): Se deve incluir o array de recompensas na resposta. O padrão é `false`.
   * `maxSupportedTransactionVersion` (número, opcional): A versão máxima de transação a ser retornada. Se o bloco contiver uma transação com uma versão maior, é retornado um erro. Se omitido, apenas transações legadas são retornadas, e um bloco com qualquer transação versionada causará um erro. Defina como `0` para incluir transações versionadas que usam Tabelas de Pesquisa de Endereços.

## Resposta

Se o bloco especificado for confirmado e encontrado, o campo `result` será um objeto contendo informações sobre o bloco. Se o bloco não for encontrado ou não for confirmado, `result` será `null`.

Os campos principais no objeto de bloco incluem:

* `blockhash` (string): O blockhash codificado em base-58 para este bloco.
* `previousBlockhash` (string): O blockhash codificado em base-58 do bloco anterior. Se o pai não estiver disponível (devido à limpeza do ledger), isso pode ser o ID do programa do sistema.
* `parentSlot` (número): O número do slot do bloco pai.
* `transactions` (array): Um array de objetos de transação incluídos no bloco. A estrutura desses objetos depende dos parâmetros `encoding` e `transactionDetails`.
  * Cada objeto de transação normalmente contém `meta` (metadados como taxa, status, registros, saldos pré/pós) e `transaction` (os dados reais da transação, incluindo mensagem e assinaturas).
* `rewards` (array, opcional): Um array de objetos de recompensa, presente se `rewards: true` foi especificado. Cada objeto detalha o `pubkey`, `lamports`, `postBalance`, `rewardType` e potencialmente `commission`.
* `blockTime` (número | nulo): O tempo estimado de produção do bloco como um timestamp Unix (segundos desde a época), ou `null` se não estiver disponível.
* `blockHeight` (número | nulo): A altura deste bloco (número de blocos antes dele na cadeia originária do slot 0), ou `null` se não estiver disponível.

Consulte a documentação oficial do RPC Solana para a estrutura completa e detalhada dos objetos de transação e meta dentro da resposta.

## Exemplo: Buscando Informações de Bloco

Vamos tentar buscar informações para um número de slot ilustrativo no Devnet.
**Importante:** Os números de slot são processados rapidamente. O número de slot usado abaixo (`250000000`) é um espaço reservado. Você deve substituí-lo por um slot recente e confirmado que você sabe existir na sua rede de destino (por exemplo, Devnet ou Mainnet) quando executar o exemplo. Você pode encontrar números de slot recentes usando um explorador de blocos Solana.

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

<CodeGroup>
  ```bash curl theme={"system"}
  # Replace 250000000 with a valid, recent slot number on Devnet/Mainnet
  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": "getBlock",
    "params": [
      250000000, 
      {
        "encoding": "jsonParsed",
        "transactionDetails": "full",
        "rewards": true,
        "maxSupportedTransactionVersion": 0
      }
    ]
  }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  const { Connection } = require('@solana/web3.js');

  async function getBlockDetails() {
    const rpcUrl = 'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY'; // Replace YOUR_API_KEY
    const connection = new Connection(rpcUrl, 'confirmed');
    
    // Replace with a valid, recent slot number on your target network
    const slotToQuery = 250000000; 

    try {
      const block = await connection.getBlock(slotToQuery, {
        encoding: "jsonParsed",
        transactionDetails: "full",
        rewards: true,
        maxSupportedTransactionVersion: 0 
      });

      if (block) {
        console.log('Block Details:');
        console.log(`   Slot: ${slotToQuery}`);
        console.log(`   Blockhash: ${block.blockhash}`);
        console.log(`   Previous Blockhash: ${block.previousBlockhash}`);
        console.log(`   Parent Slot: ${block.parentSlot}`);
        console.log(`   Block Height: ${block.blockHeight !== null ? block.blockHeight : 'N/A'}`);
        console.log(`   Block Time: ${block.blockTime ? new Date(block.blockTime * 1000).toISOString() : 'N/A'}`);
        console.log(`   Transactions Count: ${block.transactions.length}`);
        // console.log('   Transactions:', JSON.stringify(block.transactions, null, 2)); // Full transaction details
        // console.log('   Rewards:', JSON.stringify(block.rewards, null, 2)); // Reward details
      } else {
        console.log(`Block at slot ${slotToQuery} not found or not confirmed.`);
      }
    } catch (error) {
      console.error(`Error fetching block ${slotToQuery}:`, error);
    }
  }

  getBlockDetails();
  ```

  ```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);

  const slot_number = BigInt(377261141);

  let block = await rpc
    .getBlock(
      slot_number,
      {
        commitment: "finalized",
        encoding: "json",
        transactionDetails: "full",
        maxSupportedTransactionVersion: 0,
        rewards: false,
      },
    )
    .send();

  console.log("block:", block);
  ```

  ```rust Rust theme={"system"}
  use anyhow::Result;
  use solana_client::nonblocking::rpc_client::RpcClient;
  use solana_sdk::commitment_config::CommitmentConfig;
  use solana_transaction_status_client_types::{TransactionDetails, UiTransactionEncoding};

  #[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 slot_number = 377261141;

      let config = solana_client::rpc_config::RpcBlockConfig {
          encoding: UiTransactionEncoding::Base58.into(),
          transaction_details: TransactionDetails::Full.into(),
          rewards: None,
          commitment: CommitmentConfig::finalized().into(),
          max_supported_transaction_version: Some(0),
      };
      let block = client.get_block_with_config(slot_number, config).await?;

      println!("Block: {:#?}", block);

      Ok(())
  }
  ```
</CodeGroup>

## Dicas para Desenvolvedores

* **Slot vs. Altura de Bloco:** Lembre-se de que `getBlock` aceita um número `slot` como entrada, não necessariamente uma altura de bloco. Embora os slots sejam sequenciais, alguns slots podem ser pulados por líderes. O campo `blockHeight` na resposta indica o número real de blocos antes deste.
* **`maxSupportedTransactionVersion` é Crucial:** Para inspecionar blocos com transações versionadas (que são padrão agora e usam Tabelas de Pesquisa de Endereços), você **deve** definir `maxSupportedTransactionVersion: 0` (ou uma versão superior se um novo padrão surgir). Esquecer isso resultará em erros para a maioria dos blocos modernos.
* **Escolhendo `transactionDetails`:**
  * `full` é necessário para a análise mais detalhada, mas retorna mais dados.
  * `signatures` é útil se você só precisa listar transações em um bloco.
  * `accounts` pode ser um meio-termo se você precisa ver quais contas estavam envolvidas sem buscar todos os dados de instrução.
  * `none` é raro, mas pode ser usado se você só se importa com metadados em nível de bloco, como `blockhash` ou `rewards`.
* **`jsonParsed` é Recomendado para Codificação:** Ao solicitar detalhes de transações, `jsonParsed` fornece a saída mais amigável ao desenvolvedor e resolve corretamente contas de Tabelas de Pesquisa de Endereços, o que `json` (obsoleto) não faz.
* **Indisponibilidade de Bloco:** Um resultado `null` significa que o bloco naquele slot não foi encontrado. Isso pode ser porque o slot foi pulado, o bloco não foi confirmado ao nível especificado pelo seu `commitment`, ou o nó RPC removeu esse bloco histórico do seu ledger (comum para slots mais antigos).
* **Informações de Recompensas:** Definir `rewards: true` é necessário para ver a distribuição de recompensas de bloco para o validador (e potencialmente apostadores, dependendo do tipo de recompensa). Isso aumenta o tamanho da resposta.
* **Entendendo a Estrutura do Bloco:** Para um entendimento mais profundo de como os blocos se encaixam na arquitetura do Solana, veja [Entendendo Slots, Blocos e Épocas no Solana](https://www.helius.dev/blog/solana-slots-blocks-and-epochs).