Anleitung zur Verwendung von getTokenAccountsByOwner

​

Häufige Anwendungsfälle

• Benutzerportfolio anzeigen: Abrufen aller Tokenkonten (und damit Salden) für eine bestimmte Wallet-Adresse eines Benutzers, um sein vollständiges Token-Portfolio zu zeigen.
• Anwendungslogik: Identifizieren eines bestimmten Tokenkontos eines Benutzers für ein bestimmtes Mint, bevor ein Transfer oder eine andere Interaktion eingeleitet wird.
• Verifizierung: Überprüfen, welche Tokenkonten ein Besitzer für einen bestimmten Token-Typ besitzt.
• Indexierung von Token-Inhabern: Obwohl weniger effizient für die globale Indexierung als andere Methoden, kann es verwendet werden, um Konten für einen bekannten Satz von Besitzern zu finden.

​

Anfrageparameter

1. ownerPubkey (string, erforderlich): Der Base-58-kodierte öffentliche Schlüssel des Kontobesitzers, dessen Tokenkonten Sie abrufen möchten.
2. filter (Objekt, erforderlich): Ein JSON-Objekt, das muss entweder mint oder programId spezifizieren:
   • mint (string): Der Base-58-kodierte öffentliche Schlüssel eines bestimmten Token-Mints. Wenn angegeben, werden nur Tokenkonten für dieses Mint zurückgegeben, die von ownerPubkey besitzen werden.
   • programId (string): Der Base-58-kodierte öffentliche Schlüssel des Token-Programms, das die Konten verwaltet. Gängige Werte sind:
     • SPL Token-Programm: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
     • Token-2022-Programm: TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
3. options (Objekt, optional): Ein optionales Konfigurationsobjekt, das Folgendes enthalten kann:
   • commitment (string, optional): Gibt das Commitment-Level an.
   • encoding (string, optional): Die Codierung für Kontodaten. "jsonParsed" wird sehr empfohlen. Weitere Optionen: "base64", "base64+zstd". Standardmäßig "base64".
   • dataSlice (Objekt, optional): Um einen bestimmten Ausschnitt der Kontodaten abzurufen (offset: usize, length: usize). Nur für base58, base64 oder base64+zstd Codierungen.
   • minContextSlot (u64, optional): Das Mindest-Slot für die Abfrage.

​

Antwortstruktur

• pubkey (string): Der Base-58-kodierte öffentliche Schlüssel des Tokenkontos selbst.
• account (Objekt): Detaillierte Informationen über das Tokenkonto:
  • lamports (u64): Lamport-Saldo für Freistellung von der Miete.
  • owner (string): Das besitzende Programm (z. B. der Token-Programm-öffentliche Schlüssel).
  • data: Kontodaten. Wenn die "jsonParsed"-Codierung verwendet wird, enthält dies:
    • program (string): z. B. "spl-token".
    • parsed: Ein Objekt mit strukturierten Informationen:
      • info: Details wie:
        • mint (string): Die Mint-Adresse des Tokens.
        • owner (string): Der Besitzer des Tokenkontos (dies sollte mit ownerPubkey aus der Anfrage übereinstimmen).
        • tokenAmount (Objekt): Der Saldo der Tokens (amount, decimals, uiAmount, uiAmountString).
        • state (string): Zustand des Tokenkontos (z. B. "initialized").
        • isNative (boolean): Ob das Konto gewickelte SOL hält.
        • delegate (string, optional): Die Delegiertenadresse, falls eine gesetzt ist.
        • delegatedAmount (Objekt, optional): Der delegierte Betrag, wenn ein Delegat gesetzt ist.
      • type (string): z. B. "account".
  • executable (boolean): Ob das Konto ausführbar ist.
  • rentEpoch (u64): Nächste Epoche, in der die Miete fällig ist.
  • space (u64, wenn nicht jsonParsed): Länge der rohen Kontodaten in Bytes.

{
  "jsonrpc": "2.0",
  "result": {
    "context": {
      "slot": 183459000
    },
    "value": [
      {
        "pubkey": "AssociatedTokenAccountPubkey1...",
        "account": {
          "data": {
            "program": "spl-token",
            "parsed": {
              "info": {
                "isNative": false,
                "mint": "SomeTokenMintPubkey...",
                "owner": "OwnerPubkeyProvidedInRequest...",
                "state": "initialized",
                "tokenAmount": {
                  "amount": "1000000000", // 1 token if decimals is 9
                  "decimals": 9,
                  "uiAmount": 1.0,
                  "uiAmountString": "1.0"
                }
              },
              "type": "account"
            },
            "space": 165
          },
          "executable": false,
          "lamports": 2039280,
          "owner": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
          "rentEpoch": 380
        }
      },
      {
        "pubkey": "AnotherAssociatedTokenAccountPubkey...",
        "account": {
          // ... similar structure for another token owned by the same owner
        }
      }
    ]
  },
  "id": 1
}

​

Code-Beispiele

# Replace <OWNER_PUBKEY> and <TOKEN_MINT_PUBKEY> or <TOKEN_PROGRAM_ID>

# Example filtering by programId (SPL Token Program)
curl -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getTokenAccountsByOwner",
    "params": [
      "<OWNER_PUBKEY>",
      { "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
      { "encoding": "jsonParsed" }
    ]
  }' \
  <YOUR_RPC_URL>

# Example filtering by a specific mint
curl -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getTokenAccountsByOwner",
    "params": [
      "<OWNER_PUBKEY>",
      { "mint": "<SPECIFIC_TOKEN_MINT_PUBKEY>" },
      { "encoding": "jsonParsed", "commitment": "confirmed" }
    ]
  }' \
  <YOUR_RPC_URL>

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

async function findOwnerTokenAccounts(ownerAddress, filter, encoding = 'jsonParsed') {
  // Replace with your RPC endpoint
  const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
  const ownerPubKey = new PublicKey(ownerAddress);

  try {
    let actualFilter;
    if (filter.mint) {
      actualFilter = { mint: new PublicKey(filter.mint) };
    } else if (filter.programId) {
      actualFilter = { programId: new PublicKey(filter.programId) };
    } else {
      console.error("Filter must contain either 'mint' or 'programId'");
      return;
    }

    const accounts = await connection.getTokenAccountsByOwner(
      ownerPubKey,
      actualFilter,
      { encoding }
    );

    console.log(`Found ${accounts.value.length} token accounts for owner ${ownerAddress}:`);
    accounts.value.forEach(accInfo => {
      console.log(`  Token Account: ${accInfo.pubkey.toBase58()}`);
      if (encoding === 'jsonParsed' && accInfo.account.data.parsed) {
        console.log(`    Mint: ${accInfo.account.data.parsed.info.mint}`);
        console.log(`    Balance: ${accInfo.account.data.parsed.info.tokenAmount.uiAmountString}`);
      }
      // console.log(JSON.stringify(accInfo, null, 2)); // For full details
    });

  } catch (error) {
    console.error(`Error fetching token accounts for owner ${ownerAddress}:`, error);
  }
}

// Replace with an actual owner's public key
const exampleOwner = 'HXtBm8XZbxaTt41uqaKhwUAa6Z1aPyvJdsZVENiWsetg'; // Example wallet address

// Example 1: Find all SPL Token Program accounts owned by `exampleOwner`
findOwnerTokenAccounts(exampleOwner, { programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA' });

// Example 2: Find USDC token accounts owned by `exampleOwner`
// const usdcMint = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
// findOwnerTokenAccounts(exampleOwner, { mint: usdcMint });

// Example 3: Find Token-2022 Program accounts owned by `exampleOwner`
// findOwnerTokenAccounts(exampleOwner, { programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb' });

​

Entwickler-Tipps

• Filteranforderung: Sie müssen entweder einen mint oder einen programId im Filter angeben. Es ist nicht möglich, alle Tokenkonten für einen Besitzer über alle Tokentypen hinweg ohne einen dieser primären Filter abzufragen.
• Assoziierte Tokenkonten: Diese Methode gibt alle Tokenkonten zurück, die vom öffentlichen Schlüssel besessen werden, einschließlich standardmäßiger Assoziierter Tokenkonten (ATAs) und aller anderen SPL-Tokenkonten, die sie möglicherweise besitzen (z. B. von älteren Wallet-Implementierungen oder benutzerdefinierten Setups).
• Codierung: Die Verwendung von "jsonParsed" für die encoding-Option wird sehr empfohlen. Es dekodiert die binären Kontodaten in eine besser nutzbare JSON-Struktur.
• Performance: Wenn ein Besitzer eine sehr große Anzahl von Tokenkonten hat (insbesondere wenn nur nach programId gefiltert wird), kann die Antwort groß sein. Verwenden Sie in solchen Fällen getTokenAccountsByOwnerV2, das eingebaute Unterstützung für die Paginierung bietet.
• Token-2022 (Token-Erweiterungen): Wenn Sie mit Tokens arbeiten, die mit dem Token-2022-Programm erstellt wurden (das Erweiterungen wie Transfergebühren, Zinsen usw. unterstützt), stellen Sie sicher, dass Sie den richtigen programId verwenden: TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb.

​

Paginierung für große Token-Portfolios

• Cursor-basierte Paginierung: Setzen Sie limit (1-10.000) und verwenden Sie paginationKey, um durch die Ergebnisse zu navigieren
• Inkrementelle Updates: Verwenden Sie changedSinceSlot, um nur die Tokenkonten abzurufen, die seit einem bestimmten Slot geändert wurden
• Bessere Performance: Verhindert Zeitüberschreitungen und ermöglicht das Echtzeit-Tracking von Portfolios
• Paginierungsverhalten: Das Ende der Paginierung wird nur angezeigt, wenn keine Tokenkonten zurückgegeben werden. Aufgrund von Filterung können weniger Konten als das Limit 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: "getTokenAccountsByOwnerV2",
    params: [
      "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
      { "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
      {
        encoding: "jsonParsed",
        limit: 1000
      }
    ]
  })
});

const data = await response.json();
console.log(`Found ${data.result.value.length} token 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 token accounts available");
}

​

Verwandte Methoden