> ## 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 getMultipleAccounts > Découvrez les cas d'utilisation de getMultipleAccounts, des exemples de code, les paramètres de requête, la structure des réponses et des astuces. La méthode RPC [`getMultipleAccounts`](https://www.helius.dev/docs/api-reference/rpc/http/getmultipleaccounts) est un moyen très efficace d'extraire des informations pour une liste de comptes Solana simultanément. Au lieu de faire des requêtes `getAccountInfo` individuelles pour chaque compte, `getMultipleAccounts` vous permet de regrouper ces requêtes, réduisant ainsi la surcharge réseau et améliorant la réactivité de votre application. ## Cas d'utilisation communs * **Chargement par lot des données de compte :** Lorsque votre application doit afficher ou traiter des données de plusieurs comptes connus (par exemple, les comptes de jetons d'un utilisateur, une liste de configurations de programmes sur la chaîne). * **Suivi de portefeuille :** Extraction des soldes et états de nombreux comptes de jetons détenus par un utilisateur. * **Interfaces de marché :** Affichage des détails de plusieurs NFT ou éléments listés en récupérant leurs données de compte en une seule fois. * **Amélioration des performances des dApps :** Réduction significative du nombre d'appels RPC, conduisant à des temps de chargement plus rapides et une meilleure expérience utilisateur, en particulier lorsque vous gérez de nombreux comptes. ## Paramètres de requête 1. **`pubkeys`** (`array` de `string`, requis) : * Un tableau de chaînes de clés publiques encodées en base-58 pour les comptes que vous souhaitez interroger. * Maximum de 100 clés publiques par demande. * Exemple : `["So11111111111111111111111111111111111111112", "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"]` 2. **`options`** (`object`, optionnel): Un objet de configuration contenant un ou plusieurs des champs suivants : * **`commitment`** (`string`): Spécifie le [niveau d'engagement](https://www.helius.dev/blog/solana-commitment-levels) pour la requête (par exemple, `"finalized"`, `"confirmed"`, `"processed"`). * **`encoding`** (`string`): L'encodage pour les données du compte. Les options incluent : * `"base64"` (par défaut): Encodage standard en base64. * `"base58"`: Plus lent, mais peut être utile dans certains contextes. * `"base64+zstd"`: Données compressées en zstd encodées en base64. * `"jsonParsed"`: Si le compte est détenu par un programme pour lequel le nœud RPC dispose d'un analyseur (par exemple, SPL Token Program, Stake Program), le champ `data` sera un objet JSON. Cela est très utile pour des données structurées. * **`dataSlice`** (`object`): Vous permet d'extraire uniquement une partie spécifique des données du compte. Cela est utile pour les grands comptes où vous n'avez besoin que d'une petite partie des informations. * `offset` (`usize`): Le décalage en octets à partir du début des données du compte. * `length` (`usize`): Le nombre d'octets à retourner à partir du décalage. * *Remarque : `dataSlice` n'est disponible que pour les encodages `base58`, `base64`, ou `base64+zstd`.* * **`minContextSlot`** (`u64`): Le slot minimum auquel la requête peut être évaluée. ## Structure de la réponse L'objet de réponse JSON-RPC aura un champ `result` contenant : * **`context`** (`object`) : * `slot` (`u64`): Le slot auquel l'information a été récupérée. * `apiVersion` (`string`, optionnel): La version de l'API du nœud. * **`value`** (`array`) : * Un tableau où chaque élément correspond à la clé publique au même index dans le tableau `pubkeys` de la requête. * Chaque élément sera soit : * `null` : Si le compte à la clé publique spécifiée n'existe pas ou si une erreur s'est produite pour ce compte spécifique. * Un **objet de compte** avec les champs suivants : * `lamports` (`u64`): Le nombre de lamports détenus par le compte. * `owner` (`string`): La clé publique encodée en base-58 du programme qui détient le compte. * `data` (`array` ou `object`): Les données du compte. Si `encoding` est `jsonParsed` et qu'un analyseur existe, ce sera un objet JSON. Sinon, c'est généralement un tableau `["encoded_string", "encoding_format"]` (par exemple, `["SGVsbG8=", "base64"]`). * `executable` (`boolean`): Indique si le compte contient un programme (est exécutable). * `rentEpoch` (`u64`): La prochaine époque à laquelle ce compte devra payer un loyer. * `space` (`u64`): La longueur des données du compte en octets. ## Exemples ### 1. Extraire les informations de base pour deux comptes Cet exemple récupère des données pour deux comptes : le SOL Llama (un NFT) et le Serum Dex Program v3. ```bash cURL theme={"system"} # Replace with your Helius API key # SOL Llama Mint: Abug4qgG1x23AEdjS2h9CEJ1m6ha2Z22LdK2kL2pys3F # Serum Dex Program v3: 9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \ '{ "jsonrpc": "2.0", "id": 1, "method": "getMultipleAccounts", "params": [ [ "Abug4qgG1x23AEdjS2h9CEJ1m6ha2Z22LdK2kL2pys3F", "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin" ] ] }' ``` ```javascript JavaScript (using @solana/web3.js) theme={"system"} // Replace with your Helius API key const { Connection, PublicKey } = require('@solana/web3.js'); async function fetchMultipleAccountInfo() { const connection = new Connection('https://mainnet.helius-rpc.com/?api-key='); const accountPubkeys = [ new PublicKey('Abug4qgG1x23AEdjS2h9CEJ1m6ha2Z22LdK2kL2pys3F'), // SOL Llama new PublicKey('9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin') // Serum Dex Program v3 ]; try { const accountsInfo = await connection.getMultipleAccountsInfo(accountPubkeys); accountsInfo.forEach((account, index) => { console.log(`--- Account ${index + 1} (${accountPubkeys[index].toBase58()}) ---`); if (account) { console.log(` Owner: ${account.owner.toBase58()}`); console.log(` Lamports: ${account.lamports}`); console.log(` Executable: ${account.executable}`); console.log(` Data length: ${account.data.length}`); // For brevity, not logging full data buffer } else { console.log(" Account not found or error fetching."); } }); } catch (error) { console.error('Error fetching multiple accounts:', error); } } fetchMultipleAccountInfo(); ``` ### 2. Extraire des données de compte de jeton analysées Cet exemple récupère des données pour deux comptes de jetons SPL et demande un encodage `jsonParsed` pour obtenir des données structurées. ```bash cURL theme={"system"} # Replace with your Helius API key # Example USDC Token Account 1: GqoZ2MCrdTtygoX1F2b8X7F2tDXxNxyvMvykR9RzQW8p # Example USDT Token Account 2: HYnLMbkaPMh9W2aPNy2yP4LzLSWWw9zSCYEZdX2g2E7m curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \ '{ "jsonrpc": "2.0", "id": 1, "method": "getMultipleAccounts", "params": [ [ "GqoZ2MCrdTtygoX1F2b8X7F2tDXxNxyvMvykR9RzQW8p", "HYnLMbkaPMh9W2aPNy2yP4LzLSWWw9zSCYEZdX2g2E7m" ], { "encoding": "jsonParsed" } ] }' ``` ```javascript JavaScript (using @solana/web3.js) theme={"system"} // Replace with your Helius API key const { Connection, PublicKey } = require('@solana/web3.js'); async function fetchParsedTokenAccounts() { const connection = new Connection('https://mainnet.helius-rpc.com/?api-key='); const tokenAccountPubkeys = [ new PublicKey('GqoZ2MCrdTtygoX1F2b8X7F2tDXxNxyvMvykR9RzQW8p'), // Example USDC account new PublicKey('HYnLMbkaPMh9W2aPNy2yP4LzLSWWw9zSCYEZdX2g2E7m') // Example USDT account ]; try { const accountsInfo = await connection.getMultipleAccountsInfo(tokenAccountPubkeys, 'confirmed'); // Can also pass commitment here // Note: @solana/web3.js's getMultipleAccountsInfo automatically requests jsonParsed if the node supports it for token accounts. // For explicit control with raw RPC, you use the options object as in the cURL example. accountsInfo.forEach((account, index) => { console.log(`--- Token Account ${index + 1} (${tokenAccountPubkeys[index].toBase58()}) ---`); if (account && account.data && typeof account.data !== 'string') { // Check if data is parsed // The actual structure of account.data depends on the program (e.g., SPL Token) // For SPL Token accounts, you'd typically find parsed data in account.data.parsed.info const parsedInfo = (account.data as any).parsed?.info; if (parsedInfo) { console.log(` Mint: ${parsedInfo.mint}`); console.log(` Owner: ${parsedInfo.owner}`); console.log(` Amount: ${parsedInfo.tokenAmount.uiAmountString} (decimals: ${parsedInfo.tokenAmount.decimals})`); } else { console.log(" Account data is not in the expected parsed format or is not a token account."); // console.log("Raw data:", account.data.toString('base64')); // if buffer } } else if (account) { console.log(" Account found, but data is not parsed or is a string (binary data)."); // console.log(" Raw data:", account.data.toString()); // if string } else { console.log(" Account not found or error fetching."); } }); } catch (error) { console.error('Error fetching parsed token accounts:', error); } } fetchParsedTokenAccounts(); ``` ## Conseils pour les développeurs * **Maximum 100 comptes :** Vous pouvez demander un maximum de 100 comptes par appel. * **Atomicité :** La requête n'est pas atomique dans le sens où si une recherche de compte échoue, d'autres peuvent encore réussir. Vérifiez chaque élément dans le tableau `value` pour `null`. * **Convenance de `jsonParsed` :** L'utilisation de l'encodage `jsonParsed` est fortement recommandée lors de la gestion de types de comptes courants tels que les comptes de jetons SPL, car cela vous évite une désérialisation manuelle. * **`dataSlice` pour les grands comptes :** Pour les très grands comptes (par exemple, certains comptes d'état de programme), utilisez `dataSlice` pour extraire uniquement les octets nécessaires afin d'éviter un transfert excessif de données. * **Gestion des erreurs :** Soyez prêt à gérer les entrées `null` dans le tableau de réponse `value`, indiquant qu'un compte n'a pas été trouvé ou n'a pas pu être récupéré. En tirant parti de `getMultipleAccounts`, vous pouvez créer des applications Solana plus performantes et évolutives. ## Méthodes associées Extraire des informations détaillées pour un seul compte Obtenez tous les comptes détenus par un programme spécifique