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

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

Metode RPC [`isBlockhashValid`](https://www.helius.dev/docs/api-reference/rpc/http/isblockhashvalid) memeriksa apakah blockhash yang diperoleh sebelumnya masih dianggap valid oleh jaringan. Blockhash memiliki masa berlaku terbatas (sekitar 2 menit atau 150 blok). Setelah itu, transaksi yang merujuknya akan ditolak.

Metode ini sangat penting bagi aplikasi yang menyimpan blockhash selama beberapa waktu sebelum mengirimkan transaksi. Dengan metode ini, Anda dapat memastikan transaksi tidak gagal karena blockhash telah kedaluwarsa.

**Catatan Versi:** Metode ini tersedia di `solana-core` v1.9 dan yang lebih baru. Untuk node yang menjalankan `solana-core` v1.8 atau yang lebih lama, Anda harus menggunakan `getFeeCalculatorForBlockhash`. Selain memberikan informasi biaya, metode tersebut juga secara implisit menunjukkan validitas blockhash (metode akan menghasilkan error jika blockhash terlalu lama).

## Kasus Penggunaan Umum

* **Pengiriman Ulang Transaksi:** Sebelum mencoba kembali transaksi yang gagal, periksa apakah blockhash aslinya masih valid. Jika tidak, blockhash baru harus diambil.
* **Penandatanganan Transaksi yang Ditunda:** Jika transaksi telah disiapkan tetapi baru ditandatangani dan dikirimkan nanti, verifikasi validitas blockhash tepat sebelum pengiriman.
* **Pemrosesan Transaksi Optimistis:** Tentukan apakah blockhash kemungkinan akan diterima oleh jaringan jika transaksi segera dikirim.

## Parameter Permintaan

1. **`blockhash`** (string, wajib): Blockhash yang akan diperiksa, dalam bentuk string yang dienkode dengan base-58.
2. **`options`** (object, opsional): Object konfigurasi opsional yang dapat mencakup:
   * **`commitment`** (string, opsional): Menentukan [tingkat komitmen](https://www.helius.dev/blog/solana-commitment-levels) untuk kueri (misalnya, `"finalized"`, `"confirmed"`, `"processed"`). Jika dihilangkan, komitmen default node akan digunakan.
   * **`minContextSlot`** (u64, opsional): Slot minimum tempat permintaan dapat dievaluasi. Hal ini memastikan node RPC tidak merespons dengan status dari slot yang lebih lama daripada `minContextSlot`.

## Struktur Respons

Kolom `result` dalam respons JSON-RPC adalah object `RpcResponse` yang berisi:

* **`context`** (object): Object yang berisi:
  * **`slot`** (u64): Slot tempat node RPC mengevaluasi validitas blockhash.
* **`value`** (boolean): `true` jika blockhash masih valid, atau `false` jika tidak.

**Contoh Respons (Blockhash Valid):**

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

**Contoh Respons (Blockhash Tidak Valid/Kedaluwarsa):**

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

## Contoh Kode

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

## Tips untuk Developer

* **Blockhash Memiliki Masa Berlaku:** Blockhash hanya valid untuk waktu terbatas (sekitar 150 slot atau kira-kira 1–2 menit). Selalu ambil blockhash baru jika Anda tidak yakin atau jika cukup banyak waktu telah berlalu.
* **Penggunaan `minContextSlot`:** Gunakan `minContextSlot` untuk mencegah kueri ke node RPC usang yang mungkin memberikan respons "valid" yang sudah tidak akurat untuk blockhash yang sebenarnya terlalu lama dari perspektif bagian lain dalam klaster.
* **Alternatif untuk Node Lama:** Untuk node yang menjalankan Solana versi sebelum 1.9, gunakan `getFeeCalculatorForBlockhash("<YOUR_BLOCKHASH>")`. Jika metode ini berhasil memberikan respons, blockhash tersebut valid. Jika menghasilkan error (biasanya karena blockhash tidak ditemukan atau terlalu lama), blockhash tersebut tidak valid.
* **Konfirmasi Jaringan:** Meskipun `isBlockhashValid` mengembalikan `true`, transaksi baru dianggap final setelah mencapai tingkat komitmen yang diinginkan di jaringan setelah dikirimkan.

Panduan ini memberikan detail yang diperlukan untuk menggunakan metode RPC `isBlockhashValid` secara efektif saat membangun aplikasi Solana.

## Metode Terkait

<CardGroup cols={2}>
  <Card title="getLatestBlockhash" href="/docs/id/api-reference/rpc/http/getlatestblockhash">
    Dapatkan blockhash baru untuk transaksi baru
  </Card>
</CardGroup>