So verwendest du getBlock

​

Häufige Anwendungsfälle

• Blockinhalte untersuchen: Zeige alle Transaktionen an, die in einem bestimmten Block enthalten sind.
• Blockhashes abrufen: Rufe den Blockhash für einen bestimmten slot, den Blockhash des übergeordneten Blocks und dessen slot ab.
• Blockhöhe und -zeit prüfen: Ermittle die Höhe eines Blocks, also seine Sequenznummer, und seine geschätzte Erstellungszeit.
• Transaktionsdetails analysieren: Mit den passenden Parametern erhältst du vollständige Transaktionsdaten, einschließlich Metadaten wie Gebühren, Status, Kontostände vor und nach der Transaktion sowie innere Anweisungen.
• Belohnungen abrufen: Füge optional Informationen zu den Belohnungen des Blocks hinzu.

​

Parameter

1. slot (number, erforderlich): Die Nummer des abzufragenden Block-slot (u64).
2. config (object, optional): Ein Konfigurationsobjekt mit den folgenden Feldern:
   • commitment (string, optional): Gibt die zu verwendende Stufe des commitment an. processed wird für diese Methode nicht unterstützt. Der Standardwert ist finalized.
   • encoding (string, optional): Die Kodierung der Transaktionsdaten. Der Standardwert ist json, wenn transactionDetails auf full oder accounts gesetzt ist. Andernfalls ist der Standardwert base64.
     • json: Gibt Transaktions- und Kontodaten im JSON-Format zurück. Diese Option ist veraltet. Verwende stattdessen jsonParsed.
     • jsonParsed: Gibt Transaktions- und Kontodaten als geparstes JSON zurück. Diese Option wird empfohlen, da sie alle Kontoschlüssel der Transaktion enthält, einschließlich der Schlüssel aus Address Lookup Tables.
     • base58 (langsam)
     • base64
     • base64+zstd
   • transactionDetails (string, optional): Gibt den Umfang der zurückzugebenden Transaktionsdetails an. Der Standardwert ist full.
     • full: Gibt vollständige Transaktionsdetails einschließlich der Transaktionsmetadaten zurück.
     • accounts: Gibt eine Liste der in jeder Transaktion aufgeführten Konten zurück, jedoch nicht die vollständigen Transaktionsdaten oder Metadaten.
     • signatures: Gibt nur die Transaktionssignaturen zurück.
     • none: Gibt keine Transaktionsdetails zurück.
   • rewards (boolean, optional): Gibt an, ob das Array mit Belohnungen in der response enthalten sein soll. Der Standardwert ist false.
   • maxSupportedTransactionVersion (number, optional): Die höchste zurückzugebende Transaktionsversion. Enthält der Block eine Transaktion mit einer höheren Version, schlägt der request mit dem JSON-RPC-Fehler -32015 fehl. Wenn du diesen Wert weglässt, werden nur Legacy-Transaktionen zurückgegeben. Ein Block mit einer versionierten Transaktion verursacht dann einen Fehler. Setze den Wert auf 1, um Legacy-, v0-Transaktionen mit Address Lookup Tables und v1-Transaktionen einzuschließen. Weitere Informationen findest du unter Unterstützung für Transaction v1.

​

Response

• blockhash (string): Der Base-58-kodierte Blockhash dieses Blocks.
• previousBlockhash (string): Der Base-58-kodierte Blockhash des vorherigen Blocks. Wenn der übergeordnete Block nicht verfügbar ist, etwa wegen einer Bereinigung des Ledgers, kann dies die ID des Systemprogramms sein.
• parentSlot (number): Die Nummer des slot des übergeordneten Blocks.
• transactions (array): Ein Array mit den im Block enthaltenen Transaktionsobjekten. Die Struktur dieser Objekte hängt von den Parametern encoding und transactionDetails ab.
  • Jedes Transaktionsobjekt enthält normalerweise meta (Metadaten wie Gebühren, Status, Protokolle und Kontostände vor und nach der Transaktion) sowie transaction (die eigentlichen Transaktionsdaten einschließlich Nachricht und Signaturen).
• rewards (array, optional): Ein Array mit Belohnungsobjekten, das vorhanden ist, wenn rewards: true angegeben wurde. Jedes Objekt enthält Details zu pubkey, lamports, postBalance, rewardType und möglicherweise commission.
• blockTime (number | null): Die geschätzte Erstellungszeit des Blocks als Unix-Zeitstempel in Sekunden seit der Epoche oder null, wenn sie nicht verfügbar ist.
• blockHeight (number | null): Die Höhe dieses Blocks, also die Anzahl der vorherigen Blöcke in der bei slot 0 beginnenden Chain, oder null, wenn sie nicht verfügbar ist.

​

Beispiel: Blockinformationen abrufen

# 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
    }
  ]
}'

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

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

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(())
}

​

Tipps für Entwickler

• Slot im Vergleich zur Blockhöhe: Beachte, dass getBlock eine slot-Nummer als Eingabe erwartet, nicht unbedingt eine Blockhöhe. slots sind zwar fortlaufend, einige können jedoch von Leadern übersprungen werden. Das Feld blockHeight in der response gibt die tatsächliche Anzahl der Blöcke vor diesem Block an.
• maxSupportedTransactionVersion ist entscheidend: Um Blöcke mit versionierten Transaktionen zu untersuchen, die inzwischen Standard sind und Address Lookup Tables verwenden, musst du maxSupportedTransactionVersion: 1 festlegen. Verwende eine höhere Version, wenn ein neuer Standard eingeführt wird. Wenn du das vergisst, treten bei den meisten modernen Blöcken Fehler auf.
• transactionDetails auswählen:
  • full ist für die meisten detaillierten Analysen erforderlich, gibt aber auch die größte Datenmenge zurück.
  • signatures ist nützlich, wenn du nur die Transaktionen in einem Block auflisten möchtest.
  • accounts ist ein Mittelweg, wenn du sehen möchtest, welche Konten beteiligt waren, ohne alle Anweisungsdaten abzurufen.
  • none wird selten verwendet, kann aber sinnvoll sein, wenn dich nur Metadaten auf Blockebene wie blockhash oder rewards interessieren.
• jsonParsed wird für die Kodierung empfohlen: Wenn du Transaktionsdetails anforderst, liefert jsonParsed die entwicklerfreundlichste Ausgabe und löst Konten aus Address Lookup Tables korrekt auf. json ist veraltet und bietet diese Funktion nicht.
• Block nicht verfügbar: Ein Ergebnis von null bedeutet, dass der Block an diesem slot nicht gefunden wurde. Möglicherweise wurde der slot übersprungen, der Block wurde noch nicht bis zu der durch commitment angegebenen Stufe bestätigt oder der RPC node hat diesen historischen Block aus seinem Ledger entfernt. Letzteres kommt bei älteren slots häufig vor.
• Informationen zu Belohnungen: Du musst rewards: true festlegen, um die Verteilung der Blockbelohnungen an den Validator und je nach Belohnungstyp möglicherweise an Staker anzuzeigen. Dadurch wird die response größer.
• Blockstruktur verstehen: Weitere Informationen dazu, wie sich Blöcke in die Architektur von Solana einfügen, findest du unter Slots, Blocks und Epochs auf Solana verstehen.