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

# Cómo usar getTokenAccountsByDelegate

> Conoce los casos de uso, ejemplos de código, parámetros de solicitud, estructura de respuesta y consejos de getTokenAccountsByDelegate.

El método RPC [`getTokenAccountsByDelegate`](https://www.helius.dev/docs/api-reference/rpc/http/gettokenaccountsbydelegate) recupera todas las cuentas de tokens SPL que han autorizado una clave pública específica como delegada. Un delegado tiene autoridad para realizar determinadas acciones en la cuenta de tokens, como transferir o quemar tokens, hasta el importe delegado.

Este método resulta útil para servicios que administran autoridad delegada o necesitan descubrir sobre qué cuentas de tokens puede actuar una clave específica.

## 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](https://www.helius.dev/blog/solana-commitment-levels).
   * **`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

El campo `result.value` de la respuesta JSON-RPC es un arreglo de objetos. Cada objeto representa una cuenta de tokens que tiene a `delegatePubkey` como delegado y coincide con los criterios de `filter`. Cada objeto del arreglo tiene dos campos:

* **`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.

**Ejemplo de respuesta (con codificación `jsonParsed`):**

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

## Ejemplos de código

<CodeGroup>
  ```bash cURL theme={"system"}
  # 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>
  ```

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

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

Esta guía ofrece una descripción completa de cómo usar `getTokenAccountsByDelegate` para encontrar cuentas de tokens SPL según su delegado autorizado.