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

# Cara Menggunakan getBlockHeight

> Pelajari kasus penggunaan getBlockHeight, contoh kode, parameter permintaan, struktur respons, dan kiat.

Metode RPC [`getBlockHeight`](https://www.helius.dev/docs/api-reference/rpc/http/getblockheight) adalah cara sederhana untuk meminta ketinggian blok saat ini dari sebuah node Solana. Ketinggian blok menunjukkan jumlah blok yang telah diproses sejak blok genesis (slot 0).

Metode ini berguna untuk memahami dengan cepat sejauh mana rantai telah berkembang atau untuk merujuk ketinggian blok terbaru pada tingkat komitmen tertentu.

## Kasus Penggunaan Umum

* **Memantau Perkembangan Rantai:** Panggil metode ini secara berkala untuk melihat perkembangan rantai.
* **Mendapatkan Gambaran Panjang Rantai:** Tentukan jumlah total blok yang telah diproses hingga titik tertentu (berdasarkan komitmen).
* **Membandingkan dengan Data Lain:** Gunakan ketinggian blok sebagai titik acuan saat menganalisis data atau peristiwa on-chain lainnya.

## Parameter

`getBlockHeight` dapat menerima objek konfigurasi sebagai parameter pertamanya secara opsional (atau dipanggil tanpa parameter untuk menggunakan nilai default):

1. `config` (objek, opsional): Objek konfigurasi dengan bidang berikut:
   * `commitment` (string, opsional): Menentukan tingkat komitmen yang akan digunakan untuk kueri. Nilai default-nya adalah `finalized`.
     * `finalized`: Node akan meminta blok terbaru yang telah dikonfirmasi oleh mayoritas super klaster sebagai blok yang telah mencapai penguncian maksimum.
     * `confirmed`: Node akan meminta blok terbaru yang telah dipilih oleh mayoritas super klaster.
     * `processed`: Node akan meminta blok terbarunya. Perhatikan bahwa blok tersebut mungkin belum lengkap.
   * `minContextSlot` (angka, opsional): Slot minimum tempat permintaan dapat dievaluasi. Hal ini memastikan bahwa ketinggian blok yang dikembalikan berasal dari slot yang sama dengan atau lebih besar dari `minContextSlot`.

Jika tidak ada parameter yang diberikan, metode ini biasanya menggunakan komitmen `finalized` secara default.

## Kiat untuk Developer

* **Tingkat Komitmen Berpengaruh**: Ketinggian blok yang dikembalikan dapat berbeda berdasarkan tingkat `commitment` yang ditentukan. `finalized` memberikan ketinggian paling stabil, sedangkan `processed` mungkin memberikan ketinggian yang lebih terkini, tetapi berpotensi bersifat sementara.
* **`minContextSlot` untuk Konsistensi**: Gunakan `minContextSlot` jika Anda perlu memastikan ketinggian blok diminta dari status yang setidaknya sama barunya dengan slot tertentu yang sedang Anda lacak.
* **Bukan Nomor Slot**: Ingat bahwa ketinggian blok berbeda dari nomor slot. Slot adalah suatu periode waktu, dan tidak setiap slot menghasilkan blok (slot semacam ini disebut slot yang dilewati). Ketinggian blok adalah jumlah blok aktual yang dihasilkan.
* **Pemeriksaan Dasar Kondisi Rantai**: Meskipun sederhana, `getBlockHeight` dapat menjadi bagian dari pemeriksaan dasar kondisi atau sinkronisasi rantai untuk aplikasi atau sistem pemantauan Anda.

## Respons

Bidang `result` pada respons JSON-RPC akan berupa satu angka:

* `blockHeight` (angka): Ketinggian blok (u64) node saat ini berdasarkan tingkat komitmen yang ditentukan.

**Contoh Respons JSON:**

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

Nilai ini menunjukkan jumlah blok pada rantai terpanjang dari blok genesis (slot 0) hingga kepala rantai saat ini, sebagaimana terlihat oleh node yang diminta.

## Contoh: Mengambil Ketinggian Blok Saat Ini

Mari ambil ketinggian blok saat ini dari RPC Helius Devnet.

**Catatan:** Ganti `YOUR_API_KEY` dengan kunci API Helius Anda yang sebenarnya dalam contoh berikut.

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