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

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

O método RPC [`getLargestAccounts`](https://www.helius.dev/docs/api-reference/rpc/http/getlargestaccounts) retorna uma lista das 20 principais contas na rede Solana, classificadas pelo saldo em lamports. Este método pode ser útil para análise de rede, compreensão da distribuição de riqueza ou identificação de detentores significativos de SOL.

Note que os resultados deste método podem ser armazenados em cache pelo nó RPC por até duas horas.

## Casos de Uso Comuns

* **Monitoramento de Saúde da Rede:** Observe a concentração de SOL nas maiores contas.
* **Análise Econômica:** Estude a distribuição de riqueza na rede Solana.
* **Identificação de Baleias:** Encontre contas que possuem quantidades significativas de SOL.

## Parâmetros de Requisição

Este método pode, opcionalmente, receber um objeto de configuração com os seguintes parâmetros:

* **`commitment`** (string, opcional): Especifica o [nível de commitment](https://www.helius.dev/blog/solana-commitment-levels) a ser usado ao consultar o ledger. Se não for fornecido, o commitment padrão do nó é usado.
* **`filter`** (string, opcional): Filtra os resultados pelo tipo de conta. Os valores aceitos são:
  * `circulating`: Retorna as maiores contas que fazem parte do suprimento circulante.
  * `nonCirculating`: Retorna as maiores contas que não fazem parte do suprimento circulante (por exemplo, contas bloqueadas, contas da fundação).
    Se omitido, todas as contas são consideradas sem este filtro específico.

## Estrutura da Resposta

O campo `result` da resposta JSON-RPC será um objeto `RpcResponse`. O campo `value` dentro deste objeto é uma matriz de até 20 objetos de conta, cada um contendo:

* **`address`** (string): A chave pública codificada em base-58 da conta.
* **`lamports`** (u64): O saldo da conta em lamports.

A resposta também inclui um objeto `context` com o `slot` no qual a informação foi recuperada.

## Exemplos

### 1. Obter as 20 Maiores Contas (Sem Filtro)

Este exemplo busca as 20 maiores contas por saldo de lamports sem nenhum filtro de suprimento.

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <api-key> with your Helius API key
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getLargestAccounts"
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection } = require('@solana/web3.js');

  async function logLargestAccounts() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    try {
      const largestAccounts = await connection.getLargestAccounts();
      console.log(`Largest Accounts (Slot: ${largestAccounts.context.slot}):`);
      largestAccounts.value.forEach((account, index) => {
        console.log(
          `  ${index + 1}. Address: ${account.address}, Balance: ${account.lamports / 10**9} SOL`
        );
      });
      // For full raw details:
      // console.log(JSON.stringify(largestAccounts, null, 2));
    } catch (error) {
      console.error('Error fetching largest accounts:', error);
    }
  }

  logLargestAccounts();
  ```
</CodeGroup>

### 2. Obter as 20 Maiores Contas Circulantes

Este exemplo busca as 20 maiores contas consideradas parte do suprimento circulante.

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <api-key> with your Helius API key
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getLargestAccounts",
      "params": [{ "filter": "circulating" }]
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection } = require('@solana/web3.js');

  async function logLargestCirculatingAccounts() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    try {
      const largestAccounts = await connection.getLargestAccounts({ filter: 'circulating' });
      console.log(`Largest Circulating Accounts (Slot: ${largestAccounts.context.slot}):`);
      largestAccounts.value.forEach((account, index) => {
        console.log(
          `  ${index + 1}. Address: ${account.address}, Balance: ${account.lamports / 10**9} SOL`
        );
      });
      // console.log(JSON.stringify(largestAccounts, null, 2));
    } catch (error) {
      console.error('Error fetching largest circulating accounts:', error);
    }
  }

  logLargestCirculatingAccounts();
  ```
</CodeGroup>

## Dicas para Desenvolvedores

* **Dados em Cache:** Os resultados podem ser armazenados em cache pelo nó RPC por até duas horas. Isso significa que os dados podem não ser em tempo real até o último bloco.
* **Limitado ao Top 20:** Este método retorna apenas as 20 principais contas. Para uma análise mais abrangente da distribuição de riqueza, outras fontes de dados ou métodos podem ser necessários.
* **Comportamento do Filtro:** Os filtros `circulating` e `nonCirculating` dependem da definição do nó RPC e das fontes de dados para estas classificações.

Este guia fornece as informações necessárias para usar o método RPC `getLargestAccounts` para consultar os maiores detentores de SOL na rede Solana.