So verwendest du getAccountInfo

​

Häufige Anwendungsfälle

• SOL-Guthaben prüfen: Ermittle das native SOL-Guthaben eines beliebigen Kontos.
• Existenz eines Kontos prüfen: Prüfe, ob ein Konto mit einem bestimmten öffentlichen Schlüssel initialisiert wurde, also Lamports oder Daten enthält.
• Programmkonten untersuchen: Rufe die Daten ab, die in einem programmgesteuerten Konto gespeichert sind. Das ist entscheidend, um den Zustand eines Programms zu verstehen.
• Eigentümer eines Kontos identifizieren: Ermittle, welchem Programm ein Konto gehört. So kannst du feststellen, wie die Daten des Kontos interpretiert werden müssen oder ob es sich um ein systemgesteuertes Konto handelt.
• Ausführbarkeit eines Kontos prüfen: Ermittle, ob ein Konto ein bereitgestelltes Programm enthält.

​

Parameter

1. publicKey (string, erforderlich): Der Base58-codierte öffentliche Schlüssel des abzufragenden Kontos.
2. config (object, optional): Ein Konfigurationsobjekt mit den folgenden Feldern:
   • commitment (string, optional): Gibt den commitment-Level für die Abfrage an. Der Standardwert ist finalized.
     • finalized: Der node fragt den neuesten Block ab, den die Supermehrheit des cluster mit maximaler Sperrfrist bestätigt hat.
     • confirmed: Der node fragt den neuesten Block ab, über den eine Supermehrheit des cluster abgestimmt hat.
     • processed: Der node fragt seinen neuesten Block ab. Beachte, dass der Block möglicherweise noch nicht vollständig ist.
   • encoding (string, optional): Die Codierung der Kontodaten. Der Standardwert ist base64.
     • base58 (langsam)
     • base64
     • base64+zstd (wenn die Daten komprimiert sind)
     • jsonParsed: Wenn die Kontodaten einem bekannten Programmzustand entsprechen, etwa bei Token- oder Stake-Konten, versucht der node, sie in eine JSON-Struktur zu parsen. Bei generischen Programmkonten wird in der Regel stattdessen das Binärformat (Base64) verwendet.
   • dataSlice (object, optional): Beschränkt die zurückgegebenen Kontodaten auf einen bestimmten Ausschnitt. Nur für die Codierungen base58, base64 oder base64+zstd verfügbar.
     • offset (number): Die Anzahl der Bytes ab dem Anfang der Kontodaten, bei der der Ausschnitt beginnt.
     • length (number): Die Anzahl der zurückzugebenden Bytes.
   • minContextSlot (number, optional): Der früheste slot, an dem der request ausgewertet werden kann.

​

Response

• context (object): Enthält Metadaten zum request.
  • slot (number): Der slot, an dem die Informationen abgerufen wurden.
  • apiVersion (string, optional): Die Version der RPC API.
• value (object | null): Wenn das Konto nicht existiert, ist der Wert null. Andernfalls enthält das Objekt Folgendes:
  • lamports (number): Die Anzahl der Lamports (1 SOL = 1.000.000.000 Lamports), die dem Konto gehören.
  • owner (string): Der Base58-codierte öffentliche Schlüssel des Programms, dem dieses Konto gehört.
  • data (array | object | string): Die im Konto gespeicherten Daten. Das Format hängt vom Parameter encoding im request ab.
    • Für base64 (Standard), base58 und base64+zstd: In der Regel ist dies ein Array [encoded_string, encoding_format], zum Beispiel ["string_data", "base64"].
    • Für jsonParsed: Dies kann ein JSON-Objekt sein, wenn der RPC-node die Daten parsen kann, etwa bei SPL-Token-Konten. Andernfalls wird möglicherweise standardmäßig ["", "base64"] oder ein ähnlicher Wert verwendet, wenn die Daten keinem Standardlayout entsprechen.
  • executable (boolean): true, wenn das Konto ein Programm enthält, andernfalls false.
  • rentEpoch (number): Die nächste Epoche, in der für dieses Konto Miete fällig wird.
  • space (number, optional): Die Länge der Daten in Bytes. (Hinweis: Die offizielle Solana-Dokumentation führt space auf. Einige RPC-Anbieter schließen diesen Wert möglicherweise ebenfalls ein. Er gibt den gesamten für die Kontodaten reservierten Speicherplatz an.) Weitere Informationen zu Kontodaten und Deserialisierung findest du in unserem ausführlichen Leitfaden.

​

Beispiel: Kontoinformationen abrufen

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": "getAccountInfo",
  "params": [
    "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin",
    {
      "encoding": "jsonParsed"
    }
  ]
}'

const { Connection, PublicKey } = require('@solana/web3.js');

async function getAccountDetails() {
  const rpcUrl = 'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY'; // Replace YOUR_API_KEY
  const connection = new Connection(rpcUrl, 'confirmed');
  const accountPubKey = new PublicKey('9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin');

  try {
    const accountInfo = await connection.getAccountInfo(accountPubKey);

    if (accountInfo === null) {
      console.log('Account not found.');
      return;
    }

    console.log('Account Info:');
    console.log(`   Lamports: ${accountInfo.lamports}`);
    console.log(`   Owner: ${accountInfo.owner.toBase58()}`);
    console.log(`   Executable: ${accountInfo.executable}`);
    console.log(`   Rent Epoch: ${accountInfo.rentEpoch}`);
    // Data is a Buffer, you might need to deserialize it based on the account type
    // console.log(`   Data: ${accountInfo.data.toString()}`); 
  } catch (error) {
    console.error('Error fetching account info:', error);
  }
}

getAccountDetails();

import { address, createSolanaRpc } from "@solana/kit";

const rpc_url = "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY";
const rpc = createSolanaRpc(rpc_url);

const publicKey = address("vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg");
const accountInfo = await rpc.getAccountInfo(publicKey).send();

console.log("Account Info:", accountInfo);

use solana_client::nonblocking::rpc_client::RpcClient;
use solana_sdk::{commitment_config::CommitmentConfig, pubkey::Pubkey};
use anyhow::Result;
use std::str::FromStr;

#[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 pubkey = Pubkey::from_str("vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg")?;
    let account = client.get_account(&pubkey).await?;

    println!("{:#?}", account);

    Ok(())
}

​

Tipps für Entwickler

• Performance: Wenn deine Anwendung mehrere Konten häufig prüfen muss, kannst du requests mit getMultipleAccounts bündeln und so die Anzahl der Hin- und Rückübertragungen reduzieren.
• Datendeserialisierung: Das Feld data muss häufig anhand der Datenstrukturen des besitzenden Programms deserialisiert werden. In der Regel benötigst du dafür programmspezifische Werkzeuge und Bibliotheken, etwa die SPL-Token-Bibliothek für Token-Konten. Unser Blogbeitrag zur Deserialisierung von Kontodaten enthält hilfreiche Techniken und Beispiele.
• Rate limits: Beachte die rate limits des RPC-node, insbesondere wenn du viele Konten abfragst oder häufig requests sendest.
• Kostenmanagement: getAccountInfo ist im Allgemeinen eine kostengünstige Abfrage. Häufiges Polling kann die Kosten jedoch erhöhen. Optimiere deine Abfragemuster.
• Verwende jsonParsed mit Bedacht: jsonParsed ist zwar praktisch, unterstützt aber möglicherweise nicht alle Kontotypen. Die Ausgabe kann sich außerdem ändern, wenn ein Programm seine Datenstrukturen aktualisiert. Bei kritischen Anwendungen bietet das Parsen von Binärdaten mit einem bekannten Layout mehr Stabilität.
• Ziehe dataSlice in Betracht: Wenn du nur einen kleinen Teil der Kontodaten benötigst, kannst du mit dataSlice die übertragene Datenmenge reduzieren und möglicherweise die Abfragekosten senken.

​

Verwandte Methoden