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

# Verwendung von getVoteAccounts

> Erfahren Sie mehr über die Anwendungsfälle, Codebeispiele, Anfrageparameter, Antwortstruktur und Tipps zu getVoteAccounts.

Die [`getVoteAccounts`](https://www.helius.dev/docs/api-reference/rpc/http/getvoteaccounts) RPC-Methode liefert Informationen über alle Abstimmungskonten (Validatoren) in der aktuellen Bank. Sie unterscheidet zwischen `current` (aktive) und `delinquent` Validatoren und liefert Details zu ihrem Einsatz, ihrer Abstimmungsaktivität und Identität.

## Allgemeine Anwendungsfälle

* **Validator-Überwachung:** Verfolgen des Status, des Einsatzes und der Leistung von Validatoren im Netzwerk.
* **Staking-Dashboards:** Anzeigen von Informationen über verfügbare Validatoren für Benutzer, die ihr SOL delegieren möchten.
* **Netzwerkanalyse zur Gesundheitsbewertung:** Beurteilung der allgemeinen Gesundheit und Dezentralisierung des Netzwerks durch Untersuchung der Verteilung von Einsatz und Validatoraktivität.
* **Erkennung nachlässiger Validatoren:** Finden von Validatoren, die nicht aktiv an Konsensentscheidungen teilnehmen.

## Anfrageparameter

Diese Methode akzeptiert ein optionales Konfigurationsobjekt mit den folgenden Feldern:

1. **`commitment`** (string, optional): Gibt das [Commitment-Level](https://www.helius.dev/blog/solana-commitment-levels) für die Abfrage an (z. B. `"finalized"`, `"confirmed"`, `"processed"`). Wenn es weggelassen wird, wird das Standard-Commitment des Knotens verwendet.
2. **`votePubkey`** (string, optional): Wenn angegeben, werden die Ergebnisse gefiltert, um nur die angegebene Validator-Abstimmungskontoadresse (base-58-kodiert) einzubeziehen.
3. **`keepUnstakedDelinquents`** (boolean, optional): Standardmäßig `false`. Wenn auf `true` gesetzt, wird die `delinquent`-Liste Validatoren ohne aktivierten Einsatz einbeziehen. Andernfalls werden sie herausgefiltert.
4. **`delinquentSlotDistance`** (u64, optional): Gibt an, wie viele Slots ein Validator hinter der Spitze des Ledgers zurückliegen muss, um als nachlässig zu gelten. Wenn nicht angegeben, verwendet der Knoten einen Standardwert.

## Antwortstruktur

Das `result`-Feld in der JSON-RPC-Antwort ist ein Objekt, das zwei Arrays enthält:

* **`current`**: Ein Array von Objekten, wobei jedes Objekt ein aktives Abstimmungskonto mit folgenden Feldern darstellt:
  * **`votePubkey`** (string): Die Abstimmungskonto-Adresse (base-58-kodiert).
  * **`nodePubkey`** (string): Der öffentliche Identitätsschlüssel des Validator-Knotens (base-58-kodiert).
  * **`activatedStake`** (u64): Die Menge des Einsatzes, in Lamports, die diesem Abstimmungskonto zugewiesen und im aktuellen Zyklus aktiv ist.
  * **`epochVoteAccount`** (boolean): `true`, wenn das Abstimmungskonto mindestens einmal während des aktuellen Zyklus aktiv war.
  * **`commission`** (number): Der Prozentsatz der Kommission (0-100), die vom Validator erhoben wird.
  * **`lastVote`** (u64): Die jüngste Slot-Nummer, für die dieser Validator abgestimmt hat.
  * **`rootSlot`** (u64): Der letzte Slot, den der Knoten als Wurzel betrachtet hat (ein Block, der vollständig bestätigt ist und nicht zurückgerollt wird).
  * **`epochCredits`** (array): Ein Array von Arrays, wobei jedes innere Array `[epoch, credits_earned_in_epoch, previous_total_credits]` enthält.
* **`delinquent`**: Ein Array von Objekten mit derselben Struktur wie `current`, das Validatoren darstellt, die vom Knoten als nachlässig erachtet werden.

**Beispiel-Antwort-Snippet:**

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "result": {
    "current": [
      {
        "commission": 10,
        "epochCredits": [[300, 12345, 567890]],
        "epochVoteAccount": true,
        "lastVote": 180000500,
        "nodePubkey": "NodePubkeyExample123...",
        "rootSlot": 180000450,
        "activatedStake": "50000000000000", // lamports
        "votePubkey": "VoteAccountPubkeyExample123..."
      }
      // ... more current validators
    ],
    "delinquent": [
      // ... delinquent validators, if any
    ]
  },
  "id": 1
}
```

## Codebeispiele

<CodeGroup>
  ```bash cURL theme={"system"}
  # Get all current and delinquent vote accounts:
  curl -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getVoteAccounts"
    }' \
    <YOUR_RPC_URL>

  # Get a specific vote account:
  curl -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getVoteAccounts",
      "params": [
        {
          "votePubkey": "<SPECIFIC_VOTE_ACCOUNT_PUBKEY>"
        }
      ]
    }' \
    <YOUR_RPC_URL>

  # Get vote accounts with "confirmed" commitment and keep unstaked delinquents:
  curl -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getVoteAccounts",
      "params": [
        {
          "commitment": "confirmed",
          "keepUnstakedDelinquents": true
        }
      ]
    }' \
    <YOUR_RPC_URL>
  ```

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

  async function fetchVoteAccounts() {
    // Replace with your RPC endpoint
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');

    try {
      // Get all vote accounts
      const voteAccounts = await connection.getVoteAccounts();
      console.log(`Found ${voteAccounts.current.length} current validators.`);
      console.log(`Found ${voteAccounts.delinquent.length} delinquent validators.`);

      if (voteAccounts.current.length > 0) {
        console.log("\nFirst current validator details:");
        console.log(`  Vote Pubkey: ${voteAccounts.current[0].votePubkey}`);
        console.log(`  Node Pubkey: ${voteAccounts.current[0].nodePubkey}`);
        console.log(`  Activated Stake: ${voteAccounts.current[0].activatedStake} lamports`);
        console.log(`  Commission: ${voteAccounts.current[0].commission}%`);
        console.log(`  Last Vote: ${voteAccounts.current[0].lastVote}`);
        // console.log(JSON.stringify(voteAccounts.current[0], null, 2)); // For full details
      }

      // Get a specific vote account (replace with an actual vote account public key)
      // const specificVotePubkey = 'SPECIFIC_VOTE_ACCOUNT_PUBKEY';
      // const specificValidator = await connection.getVoteAccounts('confirmed', specificVotePubkey);
      // console.log(`\nDetails for ${specificVotePubkey}:`, JSON.stringify(specificValidator, null, 2));

    } catch (error) {
      console.error('Error fetching vote accounts:', error);
    }
  }

  fetchVoteAccounts();
  ```
</CodeGroup>

## Entwicklertipps

* **Große Antwort:** Diese Methode kann eine große Menge an Daten zurückgeben, insbesondere in Netzwerken mit vielen Validatoren wie Mainnet Beta. Achten Sie auf die Antwortgröße und die Verarbeitungszeit.
* **Definition von Nachlässigkeit:** Die Definition von "nachlässig" kann von `delinquentSlotDistance` und der Perspektive des Knotens abhängen. Ein Validator könnte auf einem Knoten als nachlässig erscheinen, auf einem anderen jedoch nicht, wenn ihre Sicht auf die Ledger-Spitze unterschiedlich ist.
* **Einsatzaktivierung:** `activatedStake` spiegelt den Einsatz wider, der im aktuellen Zyklus aktiv ist. Der Einsatz benötigt Zeit, um aktiviert und deaktiviert zu werden.
* **Zyklusgutschriften:** `epochCredits` bietet eine Historie der Leistung eines Validators beim Verdienen von Gutschriften durch Abstimmungen.

Dieser Leitfaden deckt die `getVoteAccounts` RPC-Methode ab und ermöglicht Ihnen, Informationen über Validatoren im Solana-Netzwerk abzufragen und zu verstehen.