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

# Como Usar getTokenLargestAccounts

> Conheça os casos de uso do getTokenLargestAccounts, exemplos de código, parâmetros de solicitação, estrutura de resposta e dicas.

O método RPC [`getTokenLargestAccounts`](https://www.helius.dev/docs/api-reference/rpc/http/gettokenlargestaccounts) retorna uma lista das 20 maiores contas de token para um determinado SPL Token mint. Isso é útil para analisar a distribuição de tokens e identificar grandes detentores de um token específico.

## Casos de Uso Comuns

* **Análise de Distribuição de Tokens:** Entender como o suprimento de um token é distribuído entre seus detentores.
* **Identificação de Baleias:** Encontrar contas que possuem quantidades significativas de um token específico.
* **Pesquisa de Mercado:** Avaliar a concentração de propriedade de tokens.
* **Exibição dos Maiores Detentores:** Mostrar uma lista das maiores contas em um explorador de tokens ou painel.

## Parâmetros de Solicitação

1. **`mintAddress`** (string, obrigatório): A chave pública codificada em base-58 do token mint para o qual você deseja encontrar as maiores contas.

2. **`options`** (objeto, opcional): Um objeto de configuração opcional que pode incluir:
   * **`commitment`** (string, opcional): Especifica o [nível de compromisso](https://www.helius.dev/blog/solana-commitment-levels) para a consulta (por exemplo, `"finalized"`, `"confirmed"`, `"processed"`).

## Estrutura da Resposta

O campo `result.value` na resposta JSON-RPC é uma matriz de até 20 objetos. Cada objeto representa uma das maiores contas de token e contém os seguintes campos:

* **`address`** (string): A chave pública codificada em base-58 da conta do token.
* **`amount`** (string): O saldo bruto da conta do token, como uma string. Este valor não é ajustado para decimais.
* **`decimals`** (u8): O número de casas decimais definidas para este token mint.
* **`uiAmount`** (number | null): O saldo do token como um número de ponto flutuante, ajustado para decimais. Este campo pode estar obsoleto ou ser menos confiável; `uiAmountString` é preferido.
* **`uiAmountString`** (string): O saldo do token como uma string, ajustado para decimais. Esta é a representação mais amigável do saldo.

**Exemplo de Resposta:**

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 123456789 },
    "value": [
      {
        "address": "TokenAccountPubkey1...",
        "amount": "1000000000000", // e.g., 1,000,000 tokens with 6 decimals
        "decimals": 6,
        "uiAmount": 1000000.0,
        "uiAmountString": "1000000.0"
      },
      {
        "address": "TokenAccountPubkey2...",
        "amount": "500000000000",  // e.g., 500,000 tokens with 6 decimals
        "decimals": 6,
        "uiAmount": 500000.0,
        "uiAmountString": "500000.0"
      }
      // ... up to 18 more accounts
    ]
  },
  "id": 1
}
```

## Exemplos de Código

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <TOKEN_MINT_PUBKEY> with the actual mint address
  curl -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getTokenLargestAccounts",
      "params": [
        "<TOKEN_MINT_PUBKEY>"
      ]
    }' \
    <YOUR_RPC_URL>

  # Example with commitment level
  curl -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getTokenLargestAccounts",
      "params": [
        "<TOKEN_MINT_PUBKEY>",
        { "commitment": "confirmed" }
      ]
    }' \
    <YOUR_RPC_URL>
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  const { Connection, PublicKey } = require('@solana/web3.js');

  async function getLargestTokenHolders(mintAddress) {
    // Replace with your RPC endpoint
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    const mintPublicKey = new PublicKey(mintAddress);

    try {
      const largestAccounts = await connection.getTokenLargestAccounts(mintPublicKey);
      console.log(`Largest accounts for mint ${mintAddress}:`);
      largestAccounts.value.forEach(account => {
        console.log(`  Address: ${account.address}`);
        console.log(`    UI Amount: ${account.uiAmountString}`);
        console.log(`    Raw Amount: ${account.amount}`);
        console.log(`    Decimals: ${account.decimals}`);
      });
      // For full details:
      // console.log(JSON.stringify(largestAccounts, null, 2));
    } catch (error) {
      console.error(`Error fetching largest token accounts for mint ${mintAddress}:`, error);
    }
  }

  // Replace with the actual token mint public key you want to query
  const exampleTokenMint = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'; // USDC mint
  getLargestTokenHolders(exampleTokenMint);

  // Example with a different mint (e.g., Raydium)
  // const raydiumMint = '4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R';
  // getLargestTokenHolders(raydiumMint);
  ```
</CodeGroup>

## Dicas para Desenvolvedores

* **Limite Fixo:** Este método sempre retorna até as 20 maiores contas. Não suporta paginação ou solicitação de mais de 20 contas.
* **Precisão dos Dados:** Os dados refletem o estado do ledger no slot determinado pelo nível de compromisso especificado.
* **Específico para Mint de Token:** Os resultados são específicos para um único token mint fornecido na solicitação.
* **Desempenho:** Esta é uma consulta direcionada e geralmente tem bom desempenho. No entanto, deve-se evitar polling excessivo.

Este guia ajuda você a usar o método RPC `getTokenLargestAccounts` para descobrir os principais detentores de qualquer token SPL na Solana.