How to Use getProgramAccounts

​

Häufige Anwendungsfälle

• Finden aller Token-Konten für eine Prägung: Entdecken Sie alle Inhaber eines bestimmten SPL-Tokens.
• Abrufen benutzerspezifischer Daten: Holen Sie alle Konten ab, die von einem Programm für einen bestimmten Benutzer erstellt wurden (z. B. die Positionen eines Benutzers in einem DeFi-Protokoll, ihren Spielstatus in einem Play-to-Earn-Spiel).
• Auflisten aller Instanzen eines benutzerdefinierten Kontotyps: Wenn Ihr Programm eine bestimmte Kontostruktur definiert, kann getProgramAccounts alle Instanzen dieser Struktur finden.
• Überwachung des Programmstatus: Beobachten aller Konten, die mit einem Programm verbunden sind, um seinen Gesamtstatus oder Aktivität zu verfolgen.
• Erstellen von Explorer- und Analysetools: Aggregieren von Daten über Programme und ihre zugehörigen Konten.

​

Anfrageparameter

1. programId (string, erforderlich):
   • Der base-58 codierte öffentliche Schlüssel des Programms, dessen Konten Sie abrufen möchten.
   • Beispiel: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" (für das SPL Token Programm).
2. options (object, optional): Ein Konfigurationsobjekt mit den folgenden Feldern:
   • commitment (string): Spezifiziert das Commitment-Level (z. B. "finalized", "confirmed").
   • encoding (string): Kodierung für das data-Feld innerhalb jedes zurückgegebenen Kontos. Standardmäßig "base64".
     • "base58": Langsamere Alternative für Binärdaten.
     • "base64": Standard-Base64-Kodierung für Binärdaten.
     • "base64+zstd": Base64-codierte, zstd-komprimierte Binärdaten.
     • "jsonParsed": Wenn der RPC-Knoten einen Parser für den Kontotyp des Programms hat (z. B. SPL Token, Stake), wird das data-Feld ein strukturiertes JSON-Objekt sein. Dies wird dringend für Lesbarkeit und Benutzerfreundlichkeit empfohlen.
   • filters (array): Ein Array von Filterobjekten, das auf die Konten angewendet werden soll. Dies ist entscheidend für Leistung und Relevanz. Sie können bis zu 4 Filter verwenden. Häufige Filter umfassen:
     • dataSize (object):
       • dataSize (u64): Filtert Konten nach ihrer Datenlänge in Bytes. Beispiel: { "dataSize": 165 } (für SPL Token Konten).
     • memcmp (object): Speichervergleich. Vergleicht einen Abschnitt der Kontodaten mit den bereitgestellten Bytes.
       • offset (usize): Der Byte-Offset in die Kontodaten, an dem der Vergleich beginnen soll.
       • bytes (string): Ein base-58 codierter String der Bytes, die übereinstimmen sollen. Der Byte-String darf kleiner als 129 Bytes sein.
       • Beispiel: Um Token-Konten für eine bestimmte Prägung zu finden, würden Sie memcmp mit offset: 0 verwenden (wo die Prägeadresse in einem Token-Konto gespeichert ist) und bytes auf den öffentlichen Schlüssel der Prägung setzen.
   • dataSlice (object): Gibt nur einen bestimmten Abschnitt der Daten jedes Kontos zurück. Nützlich für große Konten, wenn Sie nur Teilinformationen benötigen.
     • offset (usize): Der Byte-Offset, ab dem der Schnitt beginnen soll.
     • length (usize): Die Anzahl der zurückzugebenden Bytes.
     • Hinweis: dataSlice ist hauptsächlich für Binärkodierungen, nicht jsonParsed.
   • withContext (boolean): Wenn true, wird die Antwort ein RpcResponse-Objekt enthalten, das eine context (mit slot) und die value (das Kontenarray) enthält. Wenn false oder weggelassen, wird normalerweise nur das Kontenarray zurückgegeben. Das Verhalten kann je nach RPC-Anbieter leicht variieren.
   • minContextSlot (u64): Der Mindestspeicherbereich, den die Anfrage erreichen kann.

​

Antwortstruktur

• pubkey (string): Der base-58 codierte öffentliche Schlüssel des Kontos.
• account (object):
  • lamports (u64): Saldo des Kontos in Lamport.
  • owner (string): Base-58 codierter öffentlicher Schlüssel des Programms, dem dieses Konto gehört (dies wird der programId sein, nach dem Sie gesucht haben).
  • data (string, array oder object): Die Kontodaten, formatiert gemäß dem encoding-Parameter.
    • Für jsonParsed: Ein JSON-Objekt, das den deserialisierten Kontostatus darstellt.
    • Für base64: Ein Array ["encoded_string", "base64"].
  • executable (boolean): Ob das Konto ausführbar ist (d. h. ein Programm selbst).
  • rentEpoch (u64): Das Epoche, bei der dieses Konto das nächste Mal Miete zahlen muss.
  • space (u64, optional): Die Datenlänge des Kontos in Bytes. Manchmal auch data.length genannt, wenn Daten ein Puffer sind oder Teil der analysierten Struktur.

​

Beispiele

​

1. Finden aller Token-Konten für eine spezifische Prägung (USDC)

# 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. Finden aller Token-Konten, die von einer bestimmten Wallet verwaltet werden

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

​

Filterarten

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

​

Entwicklertipps

• Leistung: getProgramAccounts kann ressourcenintensiv auf RPC-Knoten sein, insbesondere ohne Filter oder für Programme mit vielen Konten. Verwenden Sie immer Filter (dataSize, memcmp) und dataSlice, wo möglich, um den Abfrageumfang und die Antwortgröße zu reduzieren.
• Große Ergebnismengen: Bei Abfragen, die viele Ergebnisse zurückgeben, könnte die Antwort abgeschnitten oder ein Timeout auftreten. Verwenden Sie Filter, um den Umfang zu reduzieren, oder ziehen Sie getProgramAccountsV2 für Unterstützung bei der Paginierung in Betracht.
• Ratenbeschränkungen: Beachten Sie die Ratenbeschränkungen des RPC-Anbieters, da häufige oder schwere getProgramAccounts-Anrufe diese Grenzen erreichen können.
• Wissen über Datenlayout: Effektive Nutzung von memcmp erfordert das Verständnis des Byte-Layouts der Kontodaten, die Sie abfragen.
• Verfügbarkeit von jsonParsed: Die jsonParsed-Kodierung hängt davon ab, ob der RPC-Knoten einen Parser für die spezifischen Kontotypen des Programms hat. Sie wird häufig für gängige Programme wie SPL Token unterstützt.

​

Paginierung für große Datensätze

• Cursor-basierte Paginierung: Setzen Sie limit (1-10.000) und verwenden Sie paginationKey, um durch Ergebnisse zu navigieren
• Inkrementelle Aktualisierungen: Verwenden Sie changedSinceSlot, um nur Konten abzurufen, die seit einem bestimmten Slot geändert wurden
• Bessere Leistung: Verhindert Timeouts und reduziert den Speicherverbrauch
• Paginierungverhalten: Das Ende der Paginierung wird nur angezeigt, wenn keine Konten zurückgegeben werden. Weniger Konten als das Limit können aufgrund von Filtern zurückgegeben werden – setzen Sie 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