Verwendung von getTokenAccountsByDelegate

​

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

• 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.

{
  "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 });

​

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.