> ## 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 getBlocks
> Découvrez les cas d'utilisation de getBlocks, des exemples de code, les paramètres de requête, la structure des réponses et des conseils.
La méthode RPC [`getBlocks`](https://www.helius.dev/docs/api-reference/rpc/http/getblocks) vous permet de récupérer une liste de numéros de slot de blocs confirmés entre un slot de départ spécifié et un slot de fin optionnel. Cela est utile lorsque vous devez savoir quels blocs ont été confirmés dans une plage particulière sans récupérer le contenu complet de chaque bloc.
**Évitez le Batching pour de Meilleures Performances**
Le regroupement de méthodes d'archivage augmente considérablement la latence. Les lots de plus de 10 requêtes ne sont pas autorisés.
## Cas d'utilisation courants
* **Identifier les blocs confirmés dans une plage :** Obtenez rapidement une liste de tous les slots de blocs qui ont été confirmés avec succès entre deux points du registre.
* **Itération à travers les blocs :** Utilisez la liste des slots retournée pour récupérer ensuite des informations détaillées pour chaque bloc en utilisant `getBlock` si nécessaire.
* **Audit de base des blocs :** Vérifiez la présence des blocs dans une certaine plage.
## Paramètres de requête
La méthode `getBlocks` prend les paramètres suivants :
1. **`start_slot`** (u64, obligatoire) : Le premier slot à considérer pour la plage (inclus).
2. **`end_slot`** (u64, optionnel) : Le dernier slot à considérer pour la plage (inclus).
* S'il n'est pas fourni, la requête renverra les blocs jusqu'au dernier slot confirmé de `start_slot`.
* La plage entre `start_slot` et `end_slot` (ou le dernier slot si `end_slot` est omis) **ne doit pas dépasser 500 000 slots**.
3. **`commitment`** (chaîne, optionnel) : Spécifie le niveau d'engagement pour la requête. S'il est omis, l'engagement par défaut du nœud est utilisé. Cela est passé comme le seul champ dans un objet de configuration en tant que dernier paramètre.
## Structure de la réponse
Le champ `result` de la réponse JSON-RPC sera un tableau d'entiers u64. Chaque entier du tableau représente un numéro de slot de bloc confirmé dans la plage spécifiée.
* Exemple : `[5, 6, 7, 8, 9, 10]`
## Exemples
### 1. Obtenir des blocs dans une plage de slots spécifique
Cet exemple récupère la liste des slots de blocs confirmés entre le slot `250000000` et `250000010`.
```bash cURL theme={"system"}
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getBlocks",
"params": [
250000000,
250000010
]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
const { Connection } = require('@solana/web3.js');
async function getBlocksInRange(startSlot, endSlot) {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
try {
const blocks = await connection.getBlocks(startSlot, endSlot);
console.log(`Confirmed blocks between slot ${startSlot} and ${endSlot}:`, blocks);
} catch (error) {
console.error('Error fetching blocks:', error);
}
}
// Example usage:
const startSlot = 250000000;
const endSlot = 250000010;
getBlocksInRange(startSlot, endSlot);
```
### 2. Obtenir des blocs d'un slot de départ jusqu'au dernier slot confirmé
Cet exemple récupère les slots de blocs confirmés à partir de `260000000` jusqu'au dernier bloc confirmé par le nœud (en respectant la limite de range de 500 000 slots à partir du slot de départ).
```bash cURL theme={"system"}
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getBlocks",
"params": [
260000000
]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
const { Connection } = require('@solana/web3.js');
async function getBlocksFromStart(startSlot) {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
try {
// The endSlot parameter is omitted to fetch up to the latest confirmed block
const blocks = await connection.getBlocks(startSlot);
console.log(`Confirmed blocks from slot ${startSlot} to latest:`, blocks);
if (blocks.length > 0) {
console.log(`Latest block in range: ${blocks[blocks.length - 1]}`);
}
} catch (error) {
console.error('Error fetching blocks:', error);
}
}
// Example usage (ensure this doesn't exceed the 500,000 slot limit from latest block):
const recentStartSlot = 260000000;
getBlocksFromStart(recentStartSlot);
```
### 3. Obtenir des blocs avec un niveau d'engagement spécifique
Cet exemple récupère les blocs en utilisant le niveau d'engagement `confirmed`.
```bash cURL theme={"system"}
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getBlocks",
"params": [
270000000,
270000005,
{ "commitment": "confirmed" }
]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
const { Connection } = require('@solana/web3.js');
async function getBlocksWithCommitment(startSlot, endSlot) {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
try {
const blocks = await connection.getBlocks(startSlot, endSlot, { commitment: 'confirmed' });
console.log(`Confirmed blocks (with 'confirmed' commitment) between slot ${startSlot} and ${endSlot}:`, blocks);
} catch (error) {
console.error('Error fetching blocks with commitment:', error);
}
}
// Example usage:
const commitStartSlot = 270000000;
const commitEndSlot = 270000005;
getBlocksWithCommitment(commitStartSlot, commitEndSlot);
```
## Conseils pour les développeurs
* **Limite de plage :** N'oubliez pas la limite de 500 000 slots. Demander une plage plus grande entraînera une erreur.
* **Disponibilité des données du nœud :** Les nœuds peuvent ne pas conserver les informations pour tous les slots historiques. Les valeurs très anciennes de `start_slot` peuvent renvoyer des tableaux vides ou des erreurs en fonction de la configuration du nœud et de la rétention du registre.
* **Confirmation des blocs :** Cette méthode retourne des blocs *confirmés*. L'ensemble exact de blocs peut varier légèrement en fonction du niveau `commitment` choisi et du nœud que vous interrogez, en particulier pour les slots très récents.
* **Complément à `getBlock` :** `getBlocks` est souvent utilisé comme première étape pour identifier les slots de blocs pertinents avant d'utiliser `getBlock` pour récupérer les détails complets des blocs individuels dans cette liste.
* **Alternative de pagination :** Étant donné que `getBlocks` a une limite de plage, si vous devez analyser une très grande partie de la chaîne, vous devrez effectuer plusieurs appels à `getBlocks`, en découpant votre plage totale désirée en segments de 500 000 slots ou moins.
Ce guide fournit un aperçu clair de la manière d'utiliser la méthode RPC `getBlocks` pour répertorier les slots de blocs confirmés sur le réseau Solana.
## Méthodes associées
Obtenez des informations détaillées pour un bloc spécifique
Obtenez un nombre fixe de blocs à partir d'un slot