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

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

Metode RPC [`getBlock`](https://www.helius.dev/docs/api-reference/rpc/http/getblock) memungkinkan Anda mengambil informasi mendetail tentang blok yang telah dikonfirmasi dalam ledger Solana. Ini penting untuk penjelajah blok, analisis riwayat transaksi, dan memahami status rantai pada waktu tertentu.

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

  Melakukan batching pada metode arsip meningkatkan latensi secara signifikan. Batch berisi lebih dari 10 permintaan tidak diizinkan.
</Warning>

## Kasus Penggunaan Umum

* **Memeriksa Isi Blok:** Lihat semua transaksi yang disertakan dalam [blok](https://www.helius.dev/blog/solana-slots-blocks-and-epochs) tertentu.
* **Mengambil Hash Blok:** Dapatkan blockhash untuk slot tertentu, blockhash induknya, dan slot induknya.
* **Memeriksa Tinggi dan Waktu Blok:** Cari tahu tinggi blok (nomor urutnya) dan perkiraan waktu pembuatannya.
* **Menganalisis Detail Transaksi:** Dengan parameter yang sesuai, Anda dapat memperoleh data transaksi lengkap, termasuk metadata seperti biaya, status, saldo sebelum/sesudah, dan instruksi internal.
* **Mengambil Imbalan:** Sertakan informasi imbalan untuk blok secara opsional.

## Parameter

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

2. `config` (objek, opsional): Objek konfigurasi dengan bidang berikut:
   * `commitment` (string, opsional): Menentukan [tingkat komitmen](https://www.helius.dev/blog/solana-commitment-levels) yang akan digunakan. `processed` tidak didukung untuk metode ini. Nilai default-nya adalah `finalized`.
   * `encoding` (string, opsional): Pengodean untuk data transaksi. Nilai default-nya adalah `json` jika `transactionDetails` adalah `full` atau `accounts`; jika tidak, nilai default-nya adalah `base64`.
     * `json`: Mengembalikan data transaksi dan akun dalam format JSON (tidak digunakan lagi dan digantikan oleh `jsonParsed`).
     * `jsonParsed`: Mengembalikan data transaksi dan akun sebagai JSON yang telah diurai. Format ini direkomendasikan karena mencakup semua kunci akun transaksi (termasuk yang berasal dari Address Lookup Tables).
     * `base58` (lambat)
     * `base64`
     * `base64+zstd`
   * `transactionDetails` (string, opsional): Menentukan tingkat detail transaksi yang akan dikembalikan. Nilai default-nya adalah `full`.
     * `full`: Mengembalikan detail transaksi lengkap, termasuk metadata transaksi.
     * `accounts`: Mengembalikan daftar akun yang dirinci dalam setiap transaksi, tetapi bukan data atau metadata transaksi lengkap.
     * `signatures`: Hanya mengembalikan tanda tangan transaksi.
     * `none`: Tidak mengembalikan detail transaksi.
   * `rewards` (boolean, opsional): Menentukan apakah array imbalan disertakan dalam respons. Nilai default-nya adalah `false`.
   * `maxSupportedTransactionVersion` (angka, opsional): Versi transaksi maksimum yang akan dikembalikan. Jika blok berisi transaksi dengan versi yang lebih tinggi, permintaan akan gagal dengan kesalahan JSON-RPC `-32015`. Jika dihilangkan, hanya transaksi lama yang dikembalikan, dan blok dengan transaksi berversi apa pun akan menyebabkan kesalahan. Atur ke `1` untuk menyertakan transaksi lama, v0 (Address Lookup Tables), dan v1. Lihat [Dukungan transaksi v1](/docs/id/rpc/transaction-v1).

## Respons

Jika blok yang ditentukan telah dikonfirmasi dan ditemukan, bidang `result` akan berupa objek yang berisi informasi tentang blok tersebut. Jika blok tidak ditemukan atau belum dikonfirmasi, `result` akan bernilai `null`.

Bidang utama dalam objek blok meliputi:

* `blockhash` (string): Blockhash yang dikodekan dengan base-58 untuk blok ini.
* `previousBlockhash` (string): Blockhash yang dikodekan dengan base-58 dari blok sebelumnya. Jika blok induk tidak tersedia (karena pembersihan ledger), nilainya mungkin berupa ID program sistem.
* `parentSlot` (angka): Nomor slot dari blok induk.
* `transactions` (array): Array objek transaksi yang disertakan dalam blok. Struktur objek ini bergantung pada parameter `encoding` dan `transactionDetails`.
  * Setiap objek transaksi biasanya berisi `meta` (metadata seperti biaya, status, log, serta saldo sebelum/sesudah) dan `transaction` (data transaksi sebenarnya, termasuk pesan dan tanda tangan).
* `rewards` (array, opsional): Array objek imbalan, tersedia jika `rewards: true` ditentukan. Setiap objek merinci `pubkey`, `lamports`, `postBalance`, `rewardType`, dan kemungkinan `commission`.
* `blockTime` (angka | null): Perkiraan waktu pembuatan blok sebagai stempel waktu Unix (detik sejak epoch), atau `null` jika tidak tersedia.
* `blockHeight` (angka | null): Tinggi blok ini (jumlah blok sebelumnya dalam rantai yang berasal dari slot 0), atau `null` jika tidak tersedia.

Lihat dokumentasi RPC resmi Solana untuk mengetahui struktur lengkap dan terperinci dari objek transaksi dan meta di dalam respons.

## Contoh: Mengambil Informasi Blok

Mari coba mengambil informasi 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 diketahui 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": "getBlock",
    "params": [
      250000000, 
      {
        "encoding": "jsonParsed",
        "transactionDetails": "full",
        "rewards": true,
        "maxSupportedTransactionVersion": 1
      }
    ]
  }'
  ```

  ```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: 1 
      });

      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: 1,
        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>

## Tips untuk Developer

* **Slot vs. Tinggi Blok:** Ingat bahwa `getBlock` menerima nomor `slot` sebagai input, bukan tinggi blok. Meskipun slot bersifat berurutan, beberapa slot mungkin dilewati oleh leader. Bidang `blockHeight` dalam respons menunjukkan jumlah blok sebenarnya sebelum blok ini.
* **`maxSupportedTransactionVersion` Sangat Penting:** Untuk memeriksa blok dengan transaksi berversi (yang kini menjadi standar dan menggunakan Address Lookup Tables), Anda **harus** menetapkan `maxSupportedTransactionVersion: 1` (atau versi yang lebih tinggi jika muncul standar baru). Jika lupa melakukannya, sebagian besar blok modern akan menghasilkan kesalahan.
* **Memilih `transactionDetails`:**
  * `full` diperlukan untuk sebagian besar analisis mendetail, tetapi mengembalikan data paling banyak.
  * `signatures` berguna jika Anda hanya perlu mencantumkan transaksi dalam sebuah blok.
  * `accounts` dapat menjadi pilihan menengah jika Anda perlu melihat akun mana yang terlibat tanpa mengambil semua data instruksi.
  * `none` jarang digunakan, tetapi dapat digunakan jika Anda hanya memerlukan metadata tingkat blok seperti `blockhash` atau `rewards`.
* **`jsonParsed` Direkomendasikan untuk Pengodean:** Saat meminta detail transaksi, `jsonParsed` memberikan output yang paling ramah bagi developer dan me-resolve akun dari Address Lookup Tables dengan benar, sedangkan `json` (tidak digunakan lagi) tidak melakukannya.
* **Blok Tidak Tersedia:** Hasil `null` berarti blok pada slot tersebut tidak ditemukan. Ini dapat terjadi karena slot dilewati, blok belum dikonfirmasi hingga tingkat yang ditentukan oleh `commitment` Anda, atau node RPC telah menghapus blok historis tersebut dari ledger-nya (umum terjadi pada slot lama).
* **Informasi Imbalan:** Menetapkan `rewards: true` diperlukan untuk melihat distribusi imbalan blok kepada validator (dan mungkin staker, tergantung jenis imbalannya). Hal ini menambah ukuran respons.
* **Memahami Struktur Blok:** Untuk memahami secara lebih mendalam bagaimana blok masuk ke dalam arsitektur Solana, lihat [Memahami Slot, Blok, dan Epoch di Solana](https://www.helius.dev/blog/solana-slots-blocks-and-epochs).