Comment utiliser getTokenAccountsByDelegate

​

Cas d’utilisation courants

• Liste des actifs délégués : Affichage de tous les comptes de jetons pour lesquels un portefeuille ou un programme spécifique a reçu l’autorité de délégué.
• Gestion automatisée des jetons : Les services qui effectuent des actions pour le compte des utilisateurs (par exemple, les teneurs de marché automatisés, les protocoles de staking qui gèrent les récompenses tokenisées) peuvent utiliser ceci pour trouver les comptes avec lesquels ils sont autorisés à interagir.
• Audit des délégations : Revue des comptes ayant délégué leur autorité à une adresse particulière.
• Révocation des délégations : Identification des comptes de jetons dont l’autorité délégataire doit être révoquée (bien que la révocation elle-même soit une transaction distincte).

​

Paramètres de requête

1. delegatePubkey (chaîne, requis) : La clé publique encodée en base-58 du compte délégué dont vous souhaitez trouver les comptes de jetons associés.
2. filter (objet, requis) : Un objet JSON qui doit spécifier soit mint soit programId pour filtrer les comptes :
   • mint (chaîne) : La clé publique encodée en base-58 d’une émission de jetons spécifique. Si fourni, la requête ne retournera que les comptes de jetons de ce type particulier délégués à delegatePubkey.
   • programId (chaîne) : La clé publique encodée en base-58 du Programme de Jetons qui possède les comptes. Cela sera généralement le Programme de Jetons SPL standard (TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA) ou le Programme Token-2022 (TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb).
3. options (objet, optionnel) : Un objet de configuration optionnel avec les champs communs suivants :
   • commitment (chaîne, optionnel) : Spécifie le niveau d’engagement.
   • encoding (chaîne, optionnel) : L’encodage pour les données de compte. "jsonParsed" est fortement recommandé car il renvoie des informations de compte lisibles par l’homme. Les autres options incluent "base64", "base64+zstd". Par défaut, "base64" si non spécifié.
   • dataSlice (objet, optionnel) : Vous permet de récupérer seulement une tranche spécifique des données de compte. Contient les champs offset (usize) et length (usize). Applicable uniquement pour les encodages base58, base64, ou base64+zstd.
   • minContextSlot (u64, optionnel) : Le slot minimum auquel la requête peut être évaluée.

​

Structure de la réponse

• pubkey (chaîne) : La clé publique encodée en base-58 du compte de jetons lui-même.
• account (objet) : Un objet contenant des informations détaillées sur le compte de jetons :
  • lamports (u64) : Le solde de lamports du compte de jetons (pour l’exemption de loyer).
  • owner (chaîne) : La clé publique du programme qui possède ce compte (par exemple, le Programme de Jetons).
  • data : Les données du compte. Si l’encodage "jsonParsed" est utilisé, ceci sera un objet avec un champ program (par exemple, "spl-token") et un champ parsed contenant des informations structurées :
    • parsed.info : Un objet avec des détails tels que :
      • mint (chaîne) : L’adresse de l’émission du jeton.
      • owner (chaîne) : Le propriétaire du compte de jetons (pas le délégué).
      • tokenAmount (objet) : Le solde total de jetons dans ce compte (amount, decimals, uiAmount, uiAmountString).
      • delegate (chaîne) : La clé publique du délégué (devrait correspondre à delegatePubkey de la requête).
      • delegatedAmount (objet) : Le montant de jetons que le délégué est autorisé à gérer (amount, decimals, uiAmount, uiAmountString).
      • isNative (boolean) : Indique si le compte détient du SOL encapsulé.
      • state (chaîne) : L’état du compte de jetons (par exemple, "initialized").
    • parsed.type (chaîne) : Le type de compte (par exemple, "account").
  • executable (boolean) : Indique si le compte est exécutable.
  • rentEpoch (u64) : L’époque à laquelle ce compte devra à nouveau un loyer.
  • space (u64, si jsonParsed n’est pas utilisé) : La longueur des données de compte brutes en octets.

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

​

Exemples de code

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

​

Conseils pour les développeurs

• Exigence de filtre : Vous devez fournir soit mint soit programId dans le paramètre de filtre. Vous ne pouvez pas interroger tous les comptes délégués sur tous les types de jetons sans l’un de ces filtres.
• Encodage : Utiliser "jsonParsed" pour l’option encoding est fortement recommandé pour une manipulation plus facile des données, car cela décode les données binaires du compte dans un format JSON structuré.
• Performance : La requête avec programId peut être plus gourmande en ressources que la requête avec mint, surtout si le délégué a autorité sur de nombreux types de jetons différents. Certains fournisseurs de RPC peuvent avoir des limites de taux plus strictes pour cette méthode.
• Montant délégué : Le delegatedAmount dans la réponse indique le nombre maximum de jetons que le délégué est actuellement autorisé à utiliser. Cela peut être inférieur au total tokenAmount dans le compte.
• Révocation de la délégation : Cette méthode ne fait que récupérer des informations. Pour révoquer une délégation, le propriétaire du compte de jetons doit envoyer une instruction Revoke au Programme de Jetons SPL.