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

> Pelajari kasus penggunaan getBlockCommitment, contoh kode, parameter permintaan, struktur respons, dan tips.

Metode RPC [`getBlockCommitment`](https://www.helius.dev/docs/api-reference/rpc/http/getblockcommitment) memberikan informasi tentang status [komitmen](https://www.helius.dev/blog/solana-commitment-levels) dari blok tertentu dalam buku besar Solana. Informasi ini berguna untuk memahami tingkat finalitas blok berdasarkan stake yang telah memberikan suara untuk blok tersebut.

## Kasus Penggunaan Umum

* **Menilai Finalitas Blok:** Tentukan tingkat konsensus yang telah dicapai suatu blok dengan memeriksa suara berbobot stake pada berbagai kedalaman konfirmasi.
* **Memahami Kondisi Klaster:** `totalStake` memberikan informasi tentang total stake aktif dalam klaster pada saat blok diproses.
* **Logika Konfirmasi Tingkat Lanjut:** Untuk aplikasi yang memerlukan jaminan sangat spesifik mengenai finalitas blok di luar tingkat komitmen standar (`confirmed`, `finalized`).

## Parameter

1. `slot` (angka, wajib): Nomor slot (u64) dari blok yang informasi komitmennya ingin dikueri.

## Respons

Kolom `result` dari respons JSON-RPC akan berupa objek yang berisi:

* `commitment` (array bilangan bulat u64 | null):
  * Array bilangan bulat u64, dengan setiap bilangan bulat mewakili jumlah stake klaster (dalam lamport) yang telah memberikan suara untuk blok pada kedalaman konfirmasi tertentu.
  * Array ini biasanya memiliki 32 elemen (mewakili kedalaman 0 hingga `MAX_LOCKOUT_HISTORY`, yaitu 31).
  * Indeks `i` dari array menunjukkan stake yang telah memberikan suara untuk blok, dengan mempertimbangkan suara pada blok itu sendiri dan turunannya hingga kedalaman `i` tingkat.
  * Jika blok tidak ditemukan atau informasi komitmennya tidak tersedia (misalnya, blok terlalu lama dan telah dipangkas dari pelacakan komitmen), kolom ini akan bernilai `null`.
* `totalStake` (angka):
  * Total stake aktif dalam klaster (dalam lamport) pada slot saat blok ini diproses. Nilai ini digunakan untuk menghitung persentase stake yang telah berkomitmen pada blok.

## Tips untuk Developer

* **Menafsirkan Array `commitment`:**
  * Array `commitment` menunjukkan stake (dalam lamport) yang telah memberikan suara untuk blok pada berbagai kedalaman konfirmasi. Nilai yang lebih tinggi pada indeks yang lebih dalam menandakan finalitas yang lebih kuat.
  * Array `commitment` yang bernilai `null` sering kali berarti bahwa simpul tidak memiliki data untuk slot tersebut, mungkin karena slot terlalu lama atau dilewati.
  * Anda dapat mengukur finalitas pada kedalaman `i` jika `commitment[i] / totalStake >= 2/3` (supermayoritas).
* **Kasus Penggunaan Tingkat Lanjut:** `getBlockCommitment` digunakan untuk analisis finalitas yang mendetail. Untuk sebagian besar skenario umum, menggunakan tingkat komitmen standar (`processed`, `confirmed`, atau `finalized`) dengan metode RPC lain (seperti `getTransaction` atau `getBlock`) lebih sederhana dan memadai.
* **Memahami Komitmen:** Untuk memanfaatkan `getBlockCommitment` sepenuhnya, Anda harus memahami tingkat komitmen Solana dengan baik. Lihat [Tingkat Komitmen Solana](https://www.helius.dev/blog/solana-commitment-levels) untuk informasi selengkapnya.
* **Pemangkasan:** Perhatikan bahwa simpul RPC mungkin memangkas informasi komitmen lama sehingga menghasilkan `null` untuk slot yang lebih lama.

## Contoh: Mengambil Informasi Komitmen Blok

Mari kita coba mengambil informasi komitmen untuk contoh nomor slot di Devnet.
**Penting:** Nomor slot diproses dengan cepat. Nomor slot yang digunakan di bawah ini (`250000000`) adalah placeholder. Saat menjalankan contoh, Anda harus menggantinya dengan slot terbaru yang telah dikonfirmasi dan dipastikan tersedia di jaringan target Anda (misalnya, Devnet atau Mainnet). Anda dapat menemukan nomor slot terbaru menggunakan penjelajah blok Solana.

**Catatan:** Ganti `YOUR_API_KEY` dengan API key Helius Anda yang sebenarnya dalam contoh di bawah ini.

<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": "getBlockCommitment",
    "params": [
      250000000 
    ]
  }'
  ```

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

  async function getBlockCommitmentDetails() {
    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 {
      // Note: getBlockCommitment is not directly available in @solana/web3.js Connection object.
      // You typically need to make a direct RPC call for this method.
      // The example below shows how to construct and send such a raw request.
      const response = await fetch(rpcUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          jsonrpc: '2.0',
          id: 1,
          method: 'getBlockCommitment',
          params: [slotToQuery],
        }),
      });
      const result = await response.json();

      if (result.error) {
        console.error(`Error fetching block commitment for slot ${slotToQuery}:`, result.error.message);
        return;
      }

      const blockCommitment = result.result;

      if (blockCommitment) {
        console.log(`Block Commitment for Slot ${slotToQuery}:`);
        console.log(`   Total Stake (Lamports): ${blockCommitment.totalStake}`);
        console.log(`   Commitment Array:`, blockCommitment.commitment ? blockCommitment.commitment : 'Not available/Unknown block');
        // The commitment array shows lamports committed at different depths.
        // A null commitment array usually means the block is not found or too old.
        // A non-null array where later entries are higher indicates increasing finality.
      } else {
        console.log(`Block commitment data for slot ${slotToQuery} not found.`);
      }
    } catch (error) {
      console.error(`Error fetching block commitment for slot ${slotToQuery}:`, error);
    }
  }

  getBlockCommitmentDetails();
  ```

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

  let blockCommitment = await rpc.getBlockCommitment(slot_number).send();

  console.log("block commitment:", blockCommitment);
  ```
</CodeGroup>