So verwendest du getTokenAccountsByDelegate

​

Häufige Anwendungsfälle

• Delegierte Assets auflisten: Zeige alle Konten für Token an, für die ein bestimmtes Wallet oder Programm als Delegierter autorisiert wurde.
• Automatisierte Verwaltung von Token: Dienste, die Aktionen im Namen von Benutzern ausführen, können damit Konten finden, mit denen sie interagieren dürfen. Dazu gehören beispielsweise automatisierte Market Maker oder Staking-Protokolle, die tokenisierte Belohnungen verwalten.
• Delegierungen prüfen: Prüfe, welche Konten Berechtigungen an eine bestimmte Adresse delegiert haben.
• Delegierungen widerrufen: Ermittle Konten für Token, bei denen die Berechtigung eines Delegierten widerrufen werden muss. Der eigentliche Widerruf erfolgt jedoch in einer separaten Transaktion.

​

Parameter des request

1. delegatePubkey (string, erforderlich): Der Base58-codierte öffentliche Schlüssel des Kontos des Delegierten, dessen zugehörige Konten für Token du finden möchtest.
2. filter (object, erforderlich): Ein JSON-Objekt, das zum Filtern der Konten entweder mint oder programId angeben muss:
   • mint (string): Der Base58-codierte öffentliche Schlüssel eines bestimmten Mint für Token. Wenn du ihn angibst, gibt die Abfrage nur Konten dieses konkreten Typs von Token zurück, die an delegatePubkey delegiert wurden.
   • programId (string): Der Base58-codierte öffentliche Schlüssel des Programms für Token, dem die Konten gehören. Dies ist normalerweise das standardmäßige SPL Token Program (TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA) oder das Token-2022 Program (TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb).
3. options (object, optional): Ein optionales Konfigurationsobjekt mit den folgenden gängigen Feldern:
   • commitment (string, optional): Gibt die Stufe des commitment an.
   • encoding (string, optional): Die Codierung der Kontodaten. "jsonParsed" wird ausdrücklich empfohlen, da es menschenlesbare Kontoinformationen zurückgibt. Weitere Optionen sind "base64" und "base64+zstd". Wenn du keinen Wert angibst, wird standardmäßig "base64" verwendet.
   • dataSlice (object, optional): Damit kannst du nur einen bestimmten Ausschnitt der Kontodaten abrufen. Enthält die Felder offset (usize) und length (usize). Gilt nur für die Codierungen base58, base64 oder base64+zstd.
   • minContextSlot (u64, optional): Der minimale slot, bei dem der request ausgewertet werden kann.

​

Struktur der response

• pubkey (string): Der Base58-codierte öffentliche Schlüssel des Kontos für Token.
• account (object): Ein Objekt mit detaillierten Informationen zum Konto für Token:
  • lamports (u64): Das Lamport-Guthaben des Kontos für Token zur Befreiung von der Miete.
  • owner (string): Der öffentliche Schlüssel des Programms, dem dieses Konto gehört, beispielsweise des Token Program.
  • data: Die Kontodaten. Wenn du die Codierung "jsonParsed" verwendest, ist dies ein Objekt mit einem Feld program (z. B. "spl-token") und einem Feld parsed, das strukturierte Informationen enthält:
    • parsed.info: Ein Objekt mit Details wie:
      • mint (string): Die Mint-Adresse des Token.
      • owner (string): Der Eigentümer des Kontos für Token, nicht der Delegierte.
      • tokenAmount (object): Das gesamte Guthaben an Token in diesem Konto (amount, decimals, uiAmount, uiAmountString).
      • delegate (string): Der öffentliche Schlüssel des Delegierten. Er sollte mit delegatePubkey aus dem request übereinstimmen.
      • delegatedAmount (object): Die Menge an Token, die der Delegierte verwalten darf (amount, decimals, uiAmount, uiAmountString).
      • isNative (boolean): Gibt an, ob das Konto Wrapped SOL enthält.
      • state (string): Der Status des Kontos für Token, beispielsweise "initialized".
    • parsed.type (string): Der Kontotyp, beispielsweise "account".
  • executable (boolean): Gibt an, ob das Konto ausführbar ist.
  • rentEpoch (u64): Die Epoche, in der für dieses Konto das nächste Mal Miete fällig wird.
  • space (u64, wenn jsonParsed nicht verwendet wird): Die Länge der rohen Kontodaten in Byte.

{
  "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

# Replace <DELEGATE_PUBKEY> and <TOKEN_MINT_PUBKEY> or <TOKEN_PROGRAM_ID>
# Example using programId (SPL Token Program)
curl -X POST -H "Content-Type: application/json" -d \
  '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getTokenAccountsByDelegate",
    "params": [
      "<DELEGATE_PUBKEY>",
      { "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
      { "encoding": "jsonParsed" }
    ]
  }' \
  <YOUR_RPC_URL>

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

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=<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 });

​

Tipps für Entwickler

• Erforderlicher Filter: Du musst im Filterparameter entweder mint oder programId angeben. Ohne einen dieser Filter kannst du nicht alle delegierten Konten über sämtliche Typen von Token hinweg abfragen.
• Codierung: Verwende für die Option encoding möglichst "jsonParsed". Das erleichtert die Datenverarbeitung, da die binären Kontodaten in ein strukturiertes JSON-Format decodiert werden.
• Performance: Eine Abfrage mit programId kann mehr Ressourcen beanspruchen als eine Abfrage mit mint. Das gilt besonders, wenn der Delegierte Berechtigungen für viele verschiedene Typen von Token besitzt. Einige RPC-Anbieter wenden bei dieser Methode möglicherweise strengere rate limit an.
• Delegierter Betrag: delegatedAmount in der response gibt die maximale Anzahl an Token an, die der Delegierte derzeit verwenden darf. Dieser Wert kann kleiner als der gesamte Wert von tokenAmount im Konto sein.
• Delegierung widerrufen: Diese Methode ruft nur Informationen ab. Um eine Delegierung zu widerrufen, muss der Eigentümer des Kontos für Token eine Revoke-Anweisung an das SPL Token Program senden.