Cómo usar getTokenAccountsByDelegate

​

Casos de uso comunes

• Listar activos delegados: Muestra todas las cuentas de tokens para las que una billetera o un programa específicos han recibido autoridad delegada.
• Administración automatizada de tokens: Los servicios que realizan acciones en nombre de los usuarios (p. ej., creadores de mercado automatizados o protocolos de staking que administran recompensas tokenizadas) pueden usar este método para encontrar las cuentas con las que tienen autorización para interactuar.
• Auditar delegaciones: Revisa qué cuentas han delegado autoridad a una dirección específica.
• Revocar delegaciones: Identifica las cuentas de tokens cuya autoridad delegada debe revocarse (aunque la revocación en sí requiere una transacción independiente).

​

Parámetros de solicitud

1. delegatePubkey (string, obligatorio): La clave pública de la cuenta delegada codificada en base 58 cuyas cuentas de tokens asociadas quieres encontrar.
2. filter (object, obligatorio): Un objeto JSON que debe especificar mint o programId para filtrar las cuentas:
   • mint (string): La clave pública codificada en base 58 de una acuñación de token específica. Si se proporciona, la consulta solo devolverá las cuentas de tokens de este tipo específico que estén delegadas a delegatePubkey.
   • programId (string): La clave pública codificada en base 58 del programa de tokens propietario de las cuentas. Normalmente será el programa de tokens SPL estándar (TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA) o el programa Token-2022 (TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb).
3. options (object, opcional): Un objeto de configuración opcional con los siguientes campos comunes:
   • commitment (string, opcional): Especifica el nivel de compromiso.
   • encoding (string, opcional): La codificación de los datos de la cuenta. Se recomienda ampliamente "jsonParsed" porque devuelve información de la cuenta legible para humanos. Otras opciones incluyen "base64" y "base64+zstd". Si no se especifica, el valor predeterminado es "base64".
   • dataSlice (object, opcional): Te permite recuperar solo una sección específica de los datos de la cuenta. Contiene los campos offset (usize) y length (usize). Solo se aplica a las codificaciones base58, base64 o base64+zstd.
   • minContextSlot (u64, opcional): El slot mínimo en el que se puede evaluar la solicitud.

​

Estructura de la respuesta

• pubkey (string): La clave pública de la propia cuenta de tokens codificada en base 58.
• account (object): Un objeto que contiene información detallada sobre la cuenta de tokens:
  • lamports (u64): El saldo en lamports de la cuenta de tokens (para la exención del alquiler).
  • owner (string): La clave pública del programa propietario de esta cuenta (p. ej., el programa de tokens).
  • data: Los datos de la cuenta. Si se usa la codificación "jsonParsed", será un objeto con un campo program (p. ej., "spl-token") y un campo parsed que contiene información estructurada:
    • parsed.info: Un objeto con detalles como:
      • mint (string): La dirección de acuñación del token.
      • owner (string): El propietario de la cuenta de tokens (no el delegado).
      • tokenAmount (object): El saldo total de tokens de esta cuenta (amount, decimals, uiAmount, uiAmountString).
      • delegate (string): La clave pública del delegado (debe coincidir con el valor delegatePubkey de la solicitud).
      • delegatedAmount (object): La cantidad de tokens que el delegado tiene autorización para administrar (amount, decimals, uiAmount, uiAmountString).
      • isNative (boolean): Indica si la cuenta contiene SOL envuelto.
      • state (string): El estado de la cuenta de tokens (p. ej., "initialized").
    • parsed.type (string): El tipo de cuenta (p. ej., "account").
  • executable (boolean): Indica si la cuenta es ejecutable.
  • rentEpoch (u64): La época en la que esta cuenta deberá pagar alquiler nuevamente.
  • space (u64, si no se usa jsonParsed): La longitud de los datos sin procesar de la cuenta en 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
}

​

Ejemplos de código

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

​

Consejos para desarrolladores

• Requisito de filtro: Debes proporcionar mint o programId en el parámetro de filtro. No puedes consultar todas las cuentas delegadas de todos los tipos de tokens sin uno de estos filtros.
• Codificación: Se recomienda ampliamente usar "jsonParsed" en la opción encoding para facilitar el manejo de los datos, ya que decodifica los datos binarios de la cuenta en un formato JSON estructurado.
• Rendimiento: Consultar con programId puede consumir más recursos que consultar con mint, especialmente si el delegado tiene autoridad sobre muchos tipos de tokens diferentes. Algunos proveedores de RPC pueden aplicar límites de frecuencia más estrictos a este método.
• Cantidad delegada: El valor delegatedAmount de la respuesta indica la cantidad máxima de tokens que el delegado tiene autorización para usar actualmente. Puede ser menor que el valor total tokenAmount de la cuenta.
• Revocar la delegación: Este método solo recupera información. Para revocar una delegación, el propietario de la cuenta de tokens debe enviar una instrucción Revoke al programa de tokens SPL.