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

# Comment utiliser getTokenLargestAccounts

> Découvrez les cas d'utilisation de getTokenLargestAccounts, des exemples de code, des paramètres de requête, la structure de réponse et des conseils.

La méthode RPC [`getTokenLargestAccounts`](https://www.helius.dev/docs/api-reference/rpc/http/gettokenlargestaccounts) retourne une liste des 20 plus grands comptes de jetons pour une frappe de token SPL donnée. Cela est utile pour analyser la distribution des jetons et identifier les principaux détenteurs d'un token particulier.

## Cas d'utilisation courants

* **Analyse de la distribution de jetons :** Comprendre comment l'offre d'un token est distribuée parmi ses détenteurs.
* **Identification des baleines :** Trouver les comptes qui détiennent des montants significatifs d'un token spécifique.
* **Étude de marché :** Évaluer la concentration de la propriété des jetons.
* **Affichage des principaux détenteurs :** Afficher une liste des plus grands comptes dans un explorateur ou tableau de bord de tokens.

## Paramètres de requête

1. **`mintAddress`** (chaîne, requis) : La clé publique encodée en base-58 de la frappe de token pour laquelle vous souhaitez trouver les plus grands comptes.

2. **`options`** (objet, optionnel) : Un objet de configuration optionnel qui peut inclure :
   * **`commitment`** (chaîne, optionnel) : Spécifie le [niveau d'engagement](https://www.helius.dev/blog/solana-commitment-levels) pour la requête (e.g., `"finalized"`, `"confirmed"`, `"processed"`).

## Structure de réponse

Le champ `result.value` dans la réponse JSON-RPC est un tableau de jusqu'à 20 objets. Chaque objet représente l'un des plus grands comptes de jetons et contient les champs suivants :

* **`address`** (chaîne) : La clé publique encodée en base-58 du compte de token.
* **`amount`** (chaîne) : Le solde brut du compte de token, sous forme de chaîne. Cette valeur n'est pas ajustée pour les décimales.
* **`decimals`** (u8) : Le nombre de décimales définies pour cette frappe de token.
* **`uiAmount`** (nombre | nul) : Le solde du token en tant que nombre à virgule flottante, ajusté pour les décimales. Ce champ pourrait être obsolète ou moins fiable ; `uiAmountString` est préféré.
* **`uiAmountString`** (chaîne) : Le solde du token sous forme de chaîne, ajusté pour les décimales. C'est la représentation la plus conviviale du solde.

**Exemple de réponse :**

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

## Exemples de code

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

## Conseils pour les développeurs

* **Limite fixe :** Cette méthode retourne toujours jusqu'à 20 plus grands comptes. Elle ne supporte pas la pagination ni la demande de plus de 20 comptes.
* **Précision des données :** Les données reflètent l'état du registre au créneau déterminé par le niveau d'engagement spécifié.
* **Spécifique à la frappe de token :** Les résultats sont spécifiques à la frappe de token unique fournie dans la requête.
* **Performance :** C'est une requête ciblée qui fonctionne généralement bien. Toutefois, des interrogations excessives doivent être évitées.

Ce guide vous aide à utiliser la méthode RPC `getTokenLargestAccounts` pour découvrir les principaux détenteurs de tout token SPL sur Solana.