So verwendest du getProgramAccounts

​

Häufige Anwendungsfälle

• Alle Token-Accounts für eine Mint finden: Ermittle alle Inhaber eines bestimmten SPL-Tokens.
• Benutzerspezifische Daten abrufen: Rufe alle Accounts ab, die ein Programm für einen bestimmten Benutzer erstellt hat, z. B. die Positionen des Benutzers in einem DeFi-Protokoll oder seinen Spielstand in einem Play-to-Earn-Spiel.
• Alle Instanzen eines benutzerdefinierten Account-Typs auflisten: Wenn dein Programm eine bestimmte Account-Struktur definiert, kann getProgramAccounts alle Instanzen dieser Struktur finden.
• Programmstatus überwachen: Beobachte alle Accounts eines Programms, um seinen Gesamtstatus oder seine Aktivität zu verfolgen.
• Explorer und Analysetools entwickeln: Aggregiere Daten zu Programmen und den zugehörigen Accounts.

​

Parameter des request

1. programId (string, erforderlich):
   • Der Base58-codierte öffentliche Schlüssel des Programms, dessen Accounts du abrufen möchtest.
   • Beispiel: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" (für das SPL Token Program).
2. options (object, optional): Ein Konfigurationsobjekt mit den folgenden Feldern:
   • commitment (string): Gibt das commitment-Level an, z. B. "finalized" oder "confirmed".
   • encoding (string): Codierung für das Feld data in jedem zurückgegebenen Account. Der Standardwert ist "base64".
     • "base58": Langsamere Alternative für Binärdaten.
     • "base64": Standardmäßige Base64-Codierung für Binärdaten.
     • "base64+zstd": Base64-codierte, mit zstd komprimierte Binärdaten.
     • "jsonParsed": Wenn der RPC-node einen Parser für den Account-Typ des Programms besitzt, z. B. SPL Token oder Stake, wird das Feld data als strukturiertes JSON-Objekt zurückgegeben. Diese Option wird für bessere Lesbarkeit und einfachere Verwendung dringend empfohlen.
   • filters (array): Ein Array mit Filterobjekten, die auf die Accounts angewendet werden. Das ist für Performance und Relevanz entscheidend. Du kannst bis zu vier Filter verwenden. Häufig verwendete Filter sind:
     • dataSize (object):
       • dataSize (u64): Filtert Accounts nach der Länge ihrer Daten in Byte. Beispiel: { "dataSize": 165 } (für SPL-Token-Accounts).
     • memcmp (object): Speichervergleich. Vergleicht einen Ausschnitt der Account-Daten mit den angegebenen Bytes.
       • offset (usize): Der Byte-Offset in den Account-Daten, an dem der Vergleich beginnt.
       • bytes (string): Eine Base58-codierte Zeichenfolge der abzugleichenden Bytes. Die Bytefolge muss kürzer als 129 Byte sein.
       • Beispiel: Um Token-Accounts für eine bestimmte Mint zu finden, verwendest du memcmp mit offset: 0, wo die Mint-Adresse in einem Token-Account gespeichert ist. Setze bytes auf den öffentlichen Schlüssel der Mint.
   • dataSlice (object): Gibt nur einen bestimmten Ausschnitt der Daten jedes Accounts zurück. Das ist bei großen Accounts nützlich, wenn du nur einen Teil der Daten benötigst.
     • offset (usize): Der Byte-Offset, ab dem der Ausschnitt beginnt.
     • length (usize): Die Anzahl der zurückzugebenden Bytes.
     • Hinweis: dataSlice ist primär für Binärcodierungen vorgesehen, nicht für jsonParsed.
   • withContext (boolean): Wenn der Wert true ist, enthält die response ein RpcResponse-Objekt mit context einschließlich slot sowie value, dem Array der Accounts. Wenn der Wert false ist oder weggelassen wird, enthält die response in der Regel nur das Array der Accounts. Das Verhalten kann je nach RPC-Anbieter leicht variieren.
   • minContextSlot (u64): Der minimale slot, an dem der request ausgewertet werden kann.

​

Struktur der response

• pubkey (string): Der Base58-codierte öffentliche Schlüssel des Accounts.
• account (object):
  • lamports (u64): Guthaben des Accounts in Lamports.
  • owner (string): Base58-codierter öffentlicher Schlüssel des Programms, dem dieser Account gehört. Dies entspricht dem abgefragten programId.
  • data (string, array oder object): Die Daten des Accounts, formatiert gemäß dem Parameter encoding.
    • Für jsonParsed: Ein JSON-Objekt, das den deserialisierten Account-Status darstellt.
    • Für base64: Ein Array ["encoded_string", "base64"].
  • executable (boolean): Gibt an, ob der Account ausführbar ist, also selbst ein Programm ist.
  • rentEpoch (u64): Die Epoche, in der für diesen Account das nächste Mal Rent fällig wird.
  • space (u64, optional): Die Datenlänge des Accounts in Byte. Wird manchmal als data.length bezeichnet, wenn die Daten ein Puffer sind, oder ist Teil der geparsten Struktur.

​

Beispiele

​

1. Alle Token-Accounts für eine bestimmte Mint (USDC) finden

# Replace <api-key> with your Helius API key
# USDC Mint: EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
# Token Program ID: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getProgramAccounts",
    "params": [
      "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
      {
        "encoding": "jsonParsed",
        "filters": [
          { "dataSize": 165 },
          {
            "memcmp": {
              "offset": 0, 
              "bytes": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
            }
          }
        ]
      }
    ]
  }'

// Replace <api-key> with your Helius API key
const { Connection, PublicKey } = require('@solana/web3.js');
const { TOKEN_PROGRAM_ID } = require('@solana/spl-token');

const USDC_MINT_ADDRESS = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';

async function findUsdcTokenAccounts() {
  const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');

  try {
    const accounts = await connection.getProgramAccounts(TOKEN_PROGRAM_ID, {
      encoding: 'jsonParsed',
      filters: [
        {
          dataSize: 165, // Standard token account size
        },
        {
          memcmp: {
            offset: 0, // Offset for the mint address in a token account
            bytes: USDC_MINT_ADDRESS, // Base-58 encoded mint address
          },
        },
      ],
    });

    console.log(`Found ${accounts.length} USDC token accounts.`);
    accounts.forEach((accountInfo, index) => {
      console.log(`--- Account ${index + 1} ---`);
      console.log(`  Pubkey: ${accountInfo.pubkey.toBase58()}`);
      // Accessing parsed data
      const parsedData = accountInfo.account.data.parsed.info;
      console.log(`  Owner: ${parsedData.owner}`);
      console.log(`  Amount: ${parsedData.tokenAmount.uiAmountString}`);
    });
  } catch (error) {
    console.error('Error fetching USDC token accounts:', error);
  }
}

findUsdcTokenAccounts();

​

2. Alle Token-Accounts einer bestimmten Wallet finden

# Replace <api-key> with your Helius API key
# Example Wallet Address: Helioo21241PANoNdeG55722hgUnp2VawDgsz2g
# Token Program ID: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getProgramAccounts",
    "params": [
      "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
      {
        "encoding": "jsonParsed",
        "filters": [
          { "dataSize": 165 },
          {
            "memcmp": {
              "offset": 32, 
              "bytes": "Helioo21241PANoNdeG55722hgUnp2VawDgsz2g"
            }
          }
        ]
      }
    ]
  }'

// Replace <api-key> with your Helius API key
const { Connection, PublicKey } = require('@solana/web3.js');
const { TOKEN_PROGRAM_ID } = require('@solana/spl-token');

const TARGET_WALLET_ADDRESS = 'Helioo21241PANoNdeG55722hgUnp2VawDgsz2g';

async function findWalletTokenAccounts() {
  const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');

  try {
    const accounts = await connection.getProgramAccounts(TOKEN_PROGRAM_ID, {
      encoding: 'jsonParsed',
      filters: [
        {
          dataSize: 165, // Standard token account size
        },
        {
          memcmp: {
            offset: 32, // Offset for the owner address in a token account
            bytes: TARGET_WALLET_ADDRESS, // Base-58 encoded wallet address
          },
        },
      ],
    });

    console.log(`Found ${accounts.length} token accounts for wallet ${TARGET_WALLET_ADDRESS}.`);
    accounts.forEach((accountInfo, index) => {
      console.log(`--- Account ${index + 1} (${accountInfo.pubkey.toBase58()}) ---`);
      const parsedData = accountInfo.account.data.parsed.info;
      console.log(`  Mint: ${parsedData.mint}`);
      console.log(`  Amount: ${parsedData.tokenAmount.uiAmountString}`);
    });
  } catch (error) {
    console.error('Error fetching token accounts for wallet:', error);
  }
}

findWalletTokenAccounts();

​

Erweiterte Filterung

// Example filtering by memcmp (memory comparison)
const response = await fetch(
  "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getProgramAccounts",
      params: [
        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Solana Token Program
        {
          encoding: "jsonParsed",
          filters: [
            {
              dataSize: 165, // Size of token account data
            },
            {
              memcmp: {
                offset: 32, // Location of owner address in the token account
                bytes: "83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri",
              },
            },
          ],
        },
      ],
    }),
  }
);
const data = await response.json();
console.log("Filtered program accounts data:", data);

​

Filtertypen

• memcmp: Filtert Accounts, die an einem bestimmten Offset einem bestimmten Muster entsprechen
• dataSize: Filtert Accounts nach ihrer exakten Datengröße
• Mehrere Filter: Alle Bedingungen müssen erfüllt sein (logisches UND)

​

Tipps für Entwickler

• Performance: getProgramAccounts kann auf RPC-nodes viele Ressourcen beanspruchen, besonders ohne Filter oder bei Programmen mit vielen Accounts. Verwende nach Möglichkeit immer Filter wie dataSize und memcmp sowie dataSlice, um den Umfang der Abfrage und die Größe der response zu reduzieren.
• Große Ergebnismengen: Bei Abfragen mit vielen Ergebnissen kann die response abgeschnitten werden oder ein timeout auftreten. Verwende Filter, um den Umfang zu reduzieren, oder nutze getProgramAccountsV2 für Paginierung.
• Rate Limits: Beachte die rate limits des RPC-Anbieters. Häufige oder umfangreiche Aufrufe von getProgramAccounts können diese Limits erreichen.
• Kenntnis des Datenlayouts: Um memcmp effektiv zu nutzen, musst du das Byte-Layout der abgefragten Account-Daten verstehen.
• Verfügbarkeit von jsonParsed: Die Codierung jsonParsed setzt voraus, dass der RPC-node einen Parser für die Account-Typen des jeweiligen Programms besitzt. Für häufig verwendete Programme wie SPL Token wird sie umfassend unterstützt.

​

Paginierung für große Datensätze

• Cursorbasierte Paginierung: Setze limit auf einen Wert von 1 bis 10.000 und verwende paginationKey, um durch die Ergebnisse zu navigieren
• Inkrementelle Aktualisierungen: Verwende changedSinceSlot, um nur Accounts abzurufen, die seit einem bestimmten slot geändert wurden
• Bessere Performance: Verhindert timeouts und reduziert den Speicherverbrauch
• Paginierungsverhalten: Das Ende der Paginierung wird erst angezeigt, wenn keine Accounts zurückgegeben werden. Aufgrund der Filterung können weniger Accounts als durch das Limit festgelegt zurückgegeben werden. Setze die Paginierung fort, bis paginationKey null ist

// Example: Paginated query for all token accounts
const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: "1",
    method: "getProgramAccountsV2",
    params: [
      "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
      {
        encoding: "base64",
        filters: [{ dataSize: 165 }],
        limit: 5000
      }
    ]
  })
});

const data = await response.json();
console.log(`Found ${data.result.accounts.length} accounts`);
if (data.result.paginationKey) {
  console.log("More results available, use paginationKey for next page");
  // Continue pagination even if fewer than limit accounts were returned
} else {
  console.log("End of pagination - no more accounts available");
}

​

Verwandte Methoden