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

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

Metode RPC [`getBlocks`](https://www.helius.dev/docs/api-reference/rpc/http/getblocks) memungkinkan Anda mengambil daftar nomor slot blok yang telah dikonfirmasi antara slot awal tertentu dan [slot](https://www.helius.dev/blog/solana-slots-blocks-and-epochs) akhir opsional. Metode ini berguna ketika Anda perlu mengetahui blok mana yang telah dikonfirmasi dalam rentang tertentu tanpa mengambil seluruh konten setiap blok.

<Warning>
  **Hindari Pengelompokan untuk Performa yang Lebih Baik**

  Mengelompokkan metode arsip akan meningkatkan latensi secara signifikan. Batch yang berisi lebih dari 10 permintaan tidak diizinkan.
</Warning>

## Kasus Penggunaan Umum

* **Mengidentifikasi Blok yang Dikonfirmasi dalam Suatu Rentang:** Dapatkan dengan cepat daftar semua slot blok yang berhasil dikonfirmasi antara dua titik dalam ledger.
* **Mengiterasi Blok:** Gunakan daftar slot yang dikembalikan untuk kemudian mengambil informasi terperinci setiap blok menggunakan `getBlock` jika diperlukan.
* **Audit Blok Dasar:** Verifikasi keberadaan blok dalam rentang tertentu.

## Parameter Permintaan

Metode `getBlocks` menerima parameter berikut:

1. **`start_slot`** (u64, wajib): Slot pertama yang dipertimbangkan dalam rentang (inklusif).
2. **`end_slot`** (u64, opsional): Slot terakhir yang dipertimbangkan dalam rentang (inklusif).
   * Jika tidak diberikan, kueri akan mengembalikan blok mulai dari `start_slot` hingga slot terbaru yang dikonfirmasi.
   * Rentang antara `start_slot` dan `end_slot` (atau slot terbaru jika `end_slot` tidak disertakan) **tidak boleh melebihi 500.000 slot**.
3. **`commitment`** (string, opsional): Menentukan tingkat komitmen untuk kueri. Jika tidak disertakan, komitmen default node akan digunakan. Nilai ini diteruskan sebagai satu-satunya bidang dalam objek konfigurasi yang menjadi parameter terakhir.

## Struktur Respons

Bidang `result` dalam respons JSON-RPC akan berupa array bilangan bulat u64. Setiap bilangan bulat dalam array mewakili nomor slot blok yang dikonfirmasi dalam rentang yang ditentukan.

* Contoh: `[5, 6, 7, 8, 9, 10]`

## Contoh

### 1. Mendapatkan Blok dalam Rentang Slot Tertentu

Contoh ini mengambil daftar slot blok yang dikonfirmasi antara slot `250000000` dan `250000010`.

<CodeGroup>
  ```bash cURL theme={"system"}
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getBlocks",
      "params": [
        250000000,
        250000010
      ]
    }'
  ```

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

  async function getBlocksInRange(startSlot, endSlot) {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    try {
      const blocks = await connection.getBlocks(startSlot, endSlot);
      console.log(`Confirmed blocks between slot ${startSlot} and ${endSlot}:`, blocks);
    } catch (error) {
      console.error('Error fetching blocks:', error);
    }
  }

  // Example usage:
  const startSlot = 250000000;
  const endSlot = 250000010;
  getBlocksInRange(startSlot, endSlot);
  ```
</CodeGroup>

### 2. Mendapatkan Blok dari Slot Awal hingga Slot Terbaru yang Dikonfirmasi

Contoh ini mengambil slot blok yang dikonfirmasi mulai dari `260000000` hingga blok terbaru yang dikonfirmasi oleh node (dengan mematuhi batas rentang 500.000 slot dari slot awal).

<CodeGroup>
  ```bash cURL theme={"system"}
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getBlocks",
      "params": [
        260000000 
      ]
    }'
  ```

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

  async function getBlocksFromStart(startSlot) {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    try {
      // The endSlot parameter is omitted to fetch up to the latest confirmed block
      const blocks = await connection.getBlocks(startSlot);
      console.log(`Confirmed blocks from slot ${startSlot} to latest:`, blocks);
      if (blocks.length > 0) {
        console.log(`Latest block in range: ${blocks[blocks.length - 1]}`);
      }
    } catch (error) {
      console.error('Error fetching blocks:', error);
    }
  }

  // Example usage (ensure this doesn't exceed the 500,000 slot limit from latest block):
  const recentStartSlot = 260000000; 
  getBlocksFromStart(recentStartSlot);
  ```
</CodeGroup>

### 3. Mendapatkan Blok dengan Tingkat Komitmen Tertentu

Contoh ini mengambil blok menggunakan tingkat komitmen `confirmed`.

<CodeGroup>
  ```bash cURL theme={"system"}
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getBlocks",
      "params": [
        270000000,
        270000005,
        { "commitment": "confirmed" }
      ]
    }'
  ```

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

  async function getBlocksWithCommitment(startSlot, endSlot) {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    try {
      const blocks = await connection.getBlocks(startSlot, endSlot, { commitment: 'confirmed' });
      console.log(`Confirmed blocks (with 'confirmed' commitment) between slot ${startSlot} and ${endSlot}:`, blocks);
    } catch (error) {
      console.error('Error fetching blocks with commitment:', error);
    }
  }

  // Example usage:
  const commitStartSlot = 270000000;
  const commitEndSlot = 270000005;
  getBlocksWithCommitment(commitStartSlot, commitEndSlot);
  ```
</CodeGroup>

## Tips untuk Pengembang

* **Batas Rentang:** Ingat batas rentang 500.000 slot. Meminta rentang yang lebih besar akan menghasilkan kesalahan.
* **Ketersediaan Data Node:** Node mungkin tidak menyimpan informasi untuk semua slot historis. Nilai `start_slot` yang sangat lama dapat mengembalikan array kosong atau kesalahan, tergantung pada konfigurasi node dan kebijakan penyimpanan ledger.
* **Konfirmasi Blok:** Metode ini mengembalikan blok yang *dikonfirmasi*. Kumpulan blok yang tepat dapat sedikit berbeda, tergantung pada tingkat `commitment` yang dipilih dan node yang Anda kueri, khususnya untuk slot yang sangat baru.
* **Pelengkap `getBlock`:** `getBlocks` sering digunakan sebagai langkah pertama untuk mengidentifikasi slot blok yang relevan sebelum menggunakan `getBlock` guna mengambil detail lengkap setiap blok dalam daftar tersebut.
* **Alternatif Paginasi:** Karena `getBlocks` memiliki batas rentang, jika Anda perlu memindai bagian chain yang sangat besar, Anda harus melakukan beberapa panggilan ke `getBlocks` dengan membagi total rentang yang diinginkan menjadi beberapa segmen berukuran 500.000 slot atau kurang.

Panduan ini memberikan gambaran umum yang jelas tentang cara menggunakan metode RPC `getBlocks` untuk menampilkan daftar slot blok yang dikonfirmasi di jaringan Solana.

## Metode Terkait

<CardGroup cols={2}>
  <Card title="getBlock" href="/docs/id/api-reference/rpc/http/getblock">
    Dapatkan informasi terperinci untuk blok tertentu
  </Card>

  <Card title="getBlocksWithLimit" href="/docs/id/api-reference/rpc/http/getblockswithlimit">
    Dapatkan blok dalam jumlah tetap mulai dari suatu slot
  </Card>
</CardGroup>