> ## 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 getBlocksWithLimit
> Découvrez les cas d'utilisation de getBlocksWithLimit, des exemples de code, des paramètres de requête, la structure de réponse et des conseils.
La méthode RPC [`getBlocksWithLimit`](https://www.helius.dev/docs/api-reference/rpc/http/getblockswithlimit) vous permet de récupérer une liste de numéros de slots de blocs confirmés, à partir d'un slot spécifié et jusqu'à une limite donnée. Ceci est utile lorsque vous avez besoin d'un nombre spécifique de [blocs](https://www.helius.dev/blog/solana-slots-blocks-and-epochs) confirmés successifs à partir d'un certain point dans le registre.
**Évitez le Batching pour de Meilleures Performances**
Le batching des méthodes d'archivage augmente significativement la latence. Les lots de plus de 10 requêtes ne sont pas autorisés.
## Cas d'Utilisation Courants
* **Récupération d'un Nombre Fixe de Blocs Successifs :** Obtenez un nombre défini de slots de blocs confirmés après un slot de départ particulier.
* **Exploration Paginée des Blocs :** Récupérez les blocs par segments lors de l'analyse d'une partie de la blockchain.
* **Surveillance des Blocs Récents :** Obtenez les N derniers blocs à partir d'un slot récent connu.
## Paramètres de Requête
La méthode `getBlocksWithLimit` prend les paramètres suivants :
1. **`start_slot`** (u64, requis) : Le premier slot à considérer (inclus).
2. **`limit`** (u64, requis) : Le nombre maximum de slots de blocs à retourner. Le nombre total de slots interrogés (de `start_slot` jusqu'à `limit` blocs après celui-ci) **ne doit pas dépasser 500 000 slots**.
3. **`commitment`** (string, optionnel) : Spécifie le niveau d'engagement de la requête. Si omis, l'engagement par défaut du nœud est utilisé. Ceci est transmis comme le seul champ dans un objet de configuration en tant que dernier paramètre.
## Structure de Réponse
Le champ `result` de la réponse JSON-RPC sera un tableau d'entiers u64. Chaque entier dans le tableau représente un numéro de slot de bloc confirmé, allant de `start_slot` jusqu'à `limit` spécifié.
* Exemple : Si `start_slot` est 5 et `limit` est 3, un résultat possible est `[5, 6, 7]`.
## Exemples
### 1. Obtenir un Nombre Limité de Blocs à partir d'un Slot de Départ
Cet exemple récupère une liste allant jusqu'à 5 slots de blocs confirmés à partir du slot `280000000`.
```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": "getBlocksWithLimit",
"params": [
280000000,
5
]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
const { Connection } = require('@solana/web3.js');
async function getBlocksWithLimitExample(startSlot, limit) {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
try {
const blocks = await connection.getBlocksWithLimit(startSlot, limit);
console.log(`Up to ${limit} confirmed blocks starting from slot ${startSlot}:`, blocks);
} catch (error) {
console.error('Error fetching blocks with limit:', error);
}
}
// Example usage:
const startSlot = 280000000;
const limit = 5;
getBlocksWithLimitExample(startSlot, limit);
```
### 2. Obtenez des Blocs avec Limite et un Niveau d'Engagement Spécifique
Cet exemple récupère jusqu'à 3 blocs à partir du slot `290000000` 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": "getBlocksWithLimit",
"params": [
290000000,
3,
{ "commitment": "confirmed" }
]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
const { Connection } = require('@solana/web3.js');
async function getBlocksWithLimitAndCommitment(startSlot, limit) {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
try {
const blocks = await connection.getBlocksWithLimit(startSlot, limit, { commitment: 'confirmed' });
console.log(`Up to ${limit} confirmed blocks (with 'confirmed' commitment) starting from slot ${startSlot}:`, blocks);
} catch (error) {
console.error('Error fetching blocks with limit and commitment:', error);
}
}
// Example usage:
const commitStartSlot = 290000000;
const commitLimit = 3;
getBlocksWithLimitAndCommitment(commitStartSlot, commitLimit);
```
## Conseils pour les Développeurs
* **Clarification de la Plage :** Le paramètre `limit` dicte le nombre maximum de *slots* de blocs à retourner. La contrainte de 500 000 slots s'applique à la plage conceptuelle scannée (c'est-à-dire, de `start_slot` à `start_slot + limit - 1`). Assurez-vous que cette plage conceptuelle ne dépasse pas 500 000 slots, même si moins de blocs réels sont trouvés et retournés dans cette plage.
* **Disponibilité des Données du Nœud :** Les nœuds peuvent ne pas conserver les informations pour tous les slots historiques. Un très ancien `start_slot` pourrait retourner moins de blocs que le `limit` spécifié, ou un tableau vide, selon la rétention du registre du nœud.
* **Confirmation des Blocs :** Cette méthode retourne des blocs *confirmés*. L'ensemble exact des blocs peut varier légèrement en fonction du niveau `commitment` choisi et du nœud que vous interrogez, surtout pour les slots très récents.
* **Spécificité du Cas d'Utilisation :** `getBlocksWithLimit` est idéal lorsque vous connaissez le point de départ et avez besoin d'un nombre fixe de blocs successifs. Si vous avez besoin de tous les blocs dans une plage de slots connue, `getBlocks` pourrait être plus approprié.
Ce guide fournit une vue d'ensemble claire sur la façon d'utiliser la méthode RPC `getBlocksWithLimit` pour lister un nombre spécifique de slots de blocs confirmés sur le réseau Solana.
## Méthodes Associées
Obtenez tous les blocs dans une plage de slots
Obtenez des informations détaillées pour un bloc spécifique