> ## 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 getTokenAccountsByDelegate > Lernen Sie Anwendungsfälle, Codebeispiele, Anforderungsparameter, Antwortstruktur und Tipps für getTokenAccountsByDelegate kennen. Die [`getTokenAccountsByDelegate`](https://www.helius.dev/docs/api-reference/rpc/http/gettokenaccountsbydelegate) RPC-Methode ruft alle SPL-Token-Konten ab, die einen bestimmten öffentlichen Schlüssel als Delegierten genehmigt haben. Ein Delegierter hat die Befugnis, bestimmte Aktionen auf dem Token-Konto durchzuführen, wie z. B. das Übertragen oder Verbrennen von Token, bis zur delegierten Menge. Diese Methode ist nützlich für Dienste, die die delegierte Autorität verwalten oder herausfinden müssen, auf welche Token-Konten ein bestimmter Schlüssel im Namen von handeln kann. ## Häufige Anwendungsfälle * **Auflistung delegierter Vermögenswerte:** Anzeige aller Token-Konten, für die eine bestimmte Brieftasche oder ein Programm Delegiertenrechte hat. * **Automatisiertes Token-Management:** Dienste, die im Namen von Benutzern Aktionen ausführen (z. B. automatisierte Marktmacher, Staking-Protokolle, die tokenisierte Belohnungen verwalten), können dies verwenden, um Konten zu finden, mit denen sie interagieren dürfen. * **Überprüfung von Delegationen:** Überprüfung, welche Konten einer bestimmten Adresse delegierte Autorität gegeben haben. * **Widerruf von Delegationen:** Identifizierung von Token-Konten, von denen die Delegiertenrechte widerrufen werden müssen (der Widerruf selbst ist jedoch eine separate Transaktion). ## Anforderungsparameter 1. **`delegatePubkey`** (string, erforderlich): Der base-58-kodierte öffentliche Schlüssel des Delegiertenkontos, dessen zugehörige Token-Konten Sie finden möchten. 2. **`filter`** (object, erforderlich): Ein JSON-Objekt, das **entweder** `mint` oder `programId` angeben **muss**, um die Konten zu filtern: * **`mint`** (string): Der base-58-kodierte öffentliche Schlüssel eines spezifischen Token-Mints. Wenn angegeben, wird die Abfrage nur die Token-Konten dieses bestimmten Token-Typs zurückgeben, die an `delegatePubkey` delegiert sind. * **`programId`** (string): Der base-58-kodierte öffentliche Schlüssel des Token-Programms, das die Konten besitzt. Dies ist typischerweise das Standard-SPL-Token-Programm (`TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`) oder das Token-2022-Programm (`TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb`). 3. **`options`** (object, optional): Ein optionales Konfigurationsobjekt mit den folgenden allgemeinen Feldern: * **`commitment`** (string, optional): Gibt das [Commitment-Level](https://www.helius.dev/blog/solana-commitment-levels) an. * **`encoding`** (string, optional): Die Kodierung für Kontodaten. `"jsonParsed"` wird dringend empfohlen, da es menschenlesbare Kontoinformationen zurückgibt. Weitere Optionen sind `"base64"`, `"base64+zstd"`. Standardmäßig `"base64"`, wenn nicht angegeben. * **`dataSlice`** (object, optional): Ermöglicht das Abrufen nur eines bestimmten Abschnitts der Kontodaten. Enthält die Felder `offset` (usize) und `length` (usize). Nur anwendbar für `base58`, `base64` oder `base64+zstd` Kodierungen. * **`minContextSlot`** (u64, optional): Der minimale Slot, bei dem die Anfrage ausgewertet werden kann. ## Antwortstruktur Das `result.value` Feld in der JSON-RPC-Antwort ist ein Array von Objekten. Jedes Objekt repräsentiert ein Token-Konto, das `delegatePubkey` als Delegierten hat und den Kriterien von `filter` entspricht. Jedes Objekt im Array hat zwei Felder: * **`pubkey`** (string): Der base-58-kodierte öffentliche Schlüssel des Token-Kontos selbst. * **`account`** (object): Ein Objekt mit detaillierten Informationen über das Token-Konto: * **`lamports`** (u64): Der Lamport-Saldo des Token-Kontos (für Mietbefreiung). * **`owner`** (string): Der öffentliche Schlüssel des Programms, das dieses Konto besitzt (z. B. das Token-Programm). * **`data`**: Die Kontodaten. Wenn die `"jsonParsed"`-Kodierung verwendet wird, wird dies ein Objekt mit einem `program`-Feld sein (z. B. `"spl-token"`) und ein `parsed`-Feld mit strukturierten Informationen enthalten: * **`parsed.info`**: Ein Objekt mit Details wie: * **`mint`** (string): Die Mint-Adresse des Tokens. * **`owner`** (string): Der Besitzer des Token-Kontos (nicht der Delegierte). * **`tokenAmount`** (object): Der Gesamtbestand an Token in diesem Konto (`amount`, `decimals`, `uiAmount`, `uiAmountString`). * **`delegate`** (string): Der öffentliche Schlüssel des Delegierten (sollte dem `delegatePubkey` aus der Anfrage entsprechen). * **`delegatedAmount`** (object): Die Anzahl der Token, die der Delegierte verwalten darf (`amount`, `decimals`, `uiAmount`, `uiAmountString`). * **`isNative`** (boolean): Gibt an, ob das Konto SOL umschlossen hält. * **`state`** (string): Der Zustand des Token-Kontos (z. B. `"initialized"`). * **`parsed.type`** (string): Der Typ des Kontos (z. B. `"account"`). * **`executable`** (boolean): Ob das Konto ausführbar ist. * **`rentEpoch`** (u64): Die Epoche, in der dieses Konto das nächste Mal Miete schulden wird. * **`space`** (u64, wenn `jsonParsed` nicht verwendet wird): Die Länge der rohen Kontodaten in Bytes. **Beispielantwort (mit `jsonParsed`-Kodierung):** ```json theme={"system"} { "jsonrpc": "2.0", "result": { "context": { "slot": 183458000 }, "value": [ { "pubkey": "SomeTokenAccountPubkey1...", "account": { "data": { "program": "spl-token", "parsed": { "info": { "delegate": "DelegatePubkeyProvidedInRequest...", "delegatedAmount": { "amount": "1000000000", "decimals": 9, "uiAmount": 1.0, "uiAmountString": "1.0" }, "isNative": false, "mint": "TokenMintPubkey...", "owner": "ActualOwnerOfTheTokenAccount...", "state": "initialized", "tokenAmount": { "amount": "5000000000", "decimals": 9, "uiAmount": 5.0, "uiAmountString": "5.0" } }, "type": "account" }, "space": 165 }, "executable": false, "lamports": 2039280, "owner": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // SPL Token Program "rentEpoch": 382 } } // ... potentially other token accounts delegated to the same delegate ] }, "id": 1 } ``` ## Codebeispiele ```bash cURL theme={"system"} # Replace and or # Example using programId (SPL Token Program) curl -X POST -H "Content-Type: application/json" -d \ '{ "jsonrpc": "2.0", "id": 1, "method": "getTokenAccountsByDelegate", "params": [ "", { "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" }, { "encoding": "jsonParsed" } ] }' \ # Example using a specific mint curl -X POST -H "Content-Type: application/json" -d \ '{ "jsonrpc": "2.0", "id": 1, "method": "getTokenAccountsByDelegate", "params": [ "", { "mint": "" }, { "encoding": "jsonParsed", "commitment": "confirmed" } ] }' \ ``` ```javascript JavaScript (using @solana/web3.js) theme={"system"} const { Connection, PublicKey } = require('@solana/web3.js'); async function findDelegatedAccounts(delegateAddress, filter, encoding = 'jsonParsed') { // Replace with your RPC endpoint const connection = new Connection('https://mainnet.helius-rpc.com/?api-key='); const delegatePubKey = new PublicKey(delegateAddress); 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.getTokenAccountsByDelegate( delegatePubKey, actualFilter, { encoding } ); console.log(`Found ${accounts.value.length} token accounts delegated to ${delegateAddress}:`); 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(` Owner: ${accInfo.account.data.parsed.info.owner}`); console.log(` Delegated Amount: ${accInfo.account.data.parsed.info.delegatedAmount.uiAmountString}`); } // console.log(JSON.stringify(accInfo.account.data, null, 2)); // For full data }); } catch (error) { console.error(`Error fetching token accounts by delegate for ${delegateAddress}:`, error); } } // Replace with an actual delegate public key const exampleDelegate = '4Nd1mBQtrMJVYVfKf2PJy9NZUZdTAsp7D4xWLs4gDB4T'; // Example 1: Find all SPL Token program accounts delegated to `exampleDelegate` findDelegatedAccounts(exampleDelegate, { programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA' }); // Example 2: Find accounts for a specific mint (e.g., USDC) delegated to `exampleDelegate` // const usdcMint = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'; // findDelegatedAccounts(exampleDelegate, { mint: usdcMint }); ``` ## Entwicklertipps * **Filteranforderung:** Sie *müssen* entweder `mint` oder `programId` im Filterparameter angeben. Sie können nicht nach allen delegierten Konten für alle Token-Typen ohne einen dieser Filter abfragen. * **Kodierung:** Die Verwendung von `"jsonParsed"` für die `encoding`-Option wird dringend empfohlen, um die Datenverarbeitung zu erleichtern, da es die binären Kontodaten in ein strukturiertes JSON-Format dekodiert. * **Leistung:** Abfragen mit `programId` können ressourcenintensiver sein als Abfragen mit `mint`, insbesondere wenn der Delegierte die Autorität über viele verschiedene Token-Typen hat. Einige RPC-Anbieter können strengere Ratenlimits für diese Methode haben. * **Delegierte Menge:** Der `delegatedAmount` in der Antwort gibt die maximale Anzahl von Token an, die der Delegierte derzeit verwenden darf. Dies kann weniger sein als der Gesamte `tokenAmount` im Konto. * **Delegation widerrufen:** Diese Methode liefert nur Informationen. Um eine Delegation zu widerrufen, muss der Besitzer des Token-Kontos eine `Revoke`-Anweisung an das SPL-Token-Programm senden. Dieser Leitfaden bietet einen umfassenden Überblick über die Verwendung von `getTokenAccountsByDelegate`, um SPL-Token-Konten basierend auf ihrem genehmigten Delegierten zu finden.