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

# Wie man getLargestAccounts verwendet

> Lernen Sie die Anwendungsfälle, Codebeispiele, Anforderungsparameter, Antwortstruktur und Tipps für getLargestAccounts.

Die [`getLargestAccounts`](https://www.helius.dev/docs/api-reference/rpc/http/getlargestaccounts) RPC-Methode gibt eine Liste der 20 größten Konten im Solana-Netzwerk zurück, sortiert nach ihrem Lamport-Guthaben. Diese Methode kann nützlich sein für Netzwerkanalysen, das Verständnis der Vermögensverteilung oder die Identifizierung bedeutender SOL-Inhaber.

Beachten Sie, dass die Ergebnisse dieser Methode vom RPC-Knoten bis zu zwei Stunden zwischengespeichert werden können.

## Häufige Anwendungsfälle

* **Netzwerküberwachung:** Überwachen Sie die Konzentration von SOL in den größten Konten.
* **Wirtschaftsanalyse:** Untersuchungen zur Vermögensverteilung im Solana-Netzwerk.
* **Identifizierung von Walen:** Finden Sie Konten, die erhebliche Mengen an SOL halten.

## Anforderungsparameter

Diese Methode kann optional ein Konfigurationsobjekt mit den folgenden Parametern entgegennehmen:

* **`commitment`** (string, optional): Gibt das [Commitment-Level](https://www.helius.dev/blog/solana-commitment-levels) an, das beim Abfragen des Ledgers verwendet wird. Wenn nicht angegeben, wird das Standard-Commitment des Knotens verwendet.
* **`filter`** (string, optional): Filtert die Ergebnisse nach Kontotyp. Akzeptierte Werte sind:
  * `circulating`: Gibt die größten Konten zurück, die Teil des zirkulierenden Angebots sind.
  * `nonCirculating`: Gibt die größten Konten zurück, die nicht Teil des zirkulierenden Angebots sind (z.B. gesperrte Konten, Stiftungskonten).
    Wenn weggelassen, werden alle Konten ohne diesen spezifischen Filter betrachtet.

## Antwortstruktur

Das `result` Feld der JSON-RPC-Antwort wird ein `RpcResponse` Objekt sein. Das `value` Feld innerhalb dieses Objekts ist ein Array von bis zu 20 Kontoobjekten, jedes enthält:

* **`address`** (string): Der base-58 kodierte öffentliche Schlüssel des Kontos.
* **`lamports`** (u64): Das Guthaben des Kontos in Lamports.

Die Antwort enthält auch ein `context` Objekt mit dem `slot`, zu dem die Informationen abgerufen wurden.

## Beispiele

### 1. Die 20 größten Konten abrufen (Kein Filter)

Dieses Beispiel ruft die 20 größten Konten nach Lamport-Guthaben ab, ohne einen Angebotsfilter.

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <api-key> with your Helius API key
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getLargestAccounts"
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection } = require('@solana/web3.js');

  async function logLargestAccounts() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    try {
      const largestAccounts = await connection.getLargestAccounts();
      console.log(`Largest Accounts (Slot: ${largestAccounts.context.slot}):`);
      largestAccounts.value.forEach((account, index) => {
        console.log(
          `  ${index + 1}. Address: ${account.address}, Balance: ${account.lamports / 10**9} SOL`
        );
      });
      // For full raw details:
      // console.log(JSON.stringify(largestAccounts, null, 2));
    } catch (error) {
      console.error('Error fetching largest accounts:', error);
    }
  }

  logLargestAccounts();
  ```
</CodeGroup>

### 2. Die 20 größten zirkulierenden Konten abrufen

Dieses Beispiel ruft die 20 größten Konten ab, die als Teil des zirkulierenden Angebots betrachtet werden.

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

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection } = require('@solana/web3.js');

  async function logLargestCirculatingAccounts() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    try {
      const largestAccounts = await connection.getLargestAccounts({ filter: 'circulating' });
      console.log(`Largest Circulating Accounts (Slot: ${largestAccounts.context.slot}):`);
      largestAccounts.value.forEach((account, index) => {
        console.log(
          `  ${index + 1}. Address: ${account.address}, Balance: ${account.lamports / 10**9} SOL`
        );
      });
      // console.log(JSON.stringify(largestAccounts, null, 2));
    } catch (error) {
      console.error('Error fetching largest circulating accounts:', error);
    }
  }

  logLargestCirculatingAccounts();
  ```
</CodeGroup>

## Entwickler-Tipps

* **Zwischengespeicherte Daten:** Die Ergebnisse können bis zu zwei Stunden vom RPC-Knoten zwischengespeichert werden. Das bedeutet, dass die Daten möglicherweise nicht in Echtzeit mit dem neuesten Block übereinstimmen.
* **Begrenzt auf die Top 20:** Diese Methode gibt nur die 20 größten Konten zurück. Für eine umfassendere Analyse der Vermögensverteilung könnten andere Datenquellen oder Methoden erforderlich sein.
* **Filterverhalten:** Die `circulating` und `nonCirculating` Filter hängen von der Definition und den Datenquellen des RPC-Knotens für diese Klassifikationen ab.

Dieser Leitfaden bietet die notwendigen Informationen zur Nutzung der `getLargestAccounts` RPC-Methode zur Abfrage der größten SOL-Inhaber im Solana-Netzwerk.