> ## 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 getLatestBlockhash
> Découvrez les cas d'utilisation de getLatestBlockhash, des exemples de code, les paramètres de requête, la structure de réponse et des conseils.
La méthode RPC [`getLatestBlockhash`](https://www.helius.dev/docs/api-reference/rpc/http/getlatestblockhash) est essentielle pour préparer et envoyer des transactions sur le réseau Solana. Elle récupère le blockhash le plus récent traité par le nœud, ainsi que le dernier bloc où ce blockhash restera valide. Pour plus de détails sur l'utilisation efficace des blockhashes et pour vous assurer que vos [transactions aboutissent](https://www.helius.dev/blog/how-to-land-transactions-on-solana), consultez notre guide complet.
Chaque transaction sur Solana doit référencer un blockhash récent. Ce mécanisme aide à prévenir certains types d'attaques, telles que la réplique de transactions sur une chaîne bifurquée.
**Remarque sur la version :** Cette méthode est disponible dans `solana-core` v1.9 ou plus récent. Pour les nœuds exécutant `solana-core` v1.8 ou plus ancien, utilisez la méthode `getRecentBlockhash` à la place.
## Cas d'utilisation courants
* **Construction de transactions :** Obtenez un blockhash récent à inclure dans une nouvelle transaction avant de la signer et de l'envoyer.
* **Gestion de la durée de vie des transactions :** Utilisez `lastValidBlockHeight` pour comprendre combien de temps une transaction référencée par le blockhash récupéré peut être considérée comme valide.
* **Vérifications préalables :** Bien que `simulateTransaction` puisse le faire implicitement, les applications pourraient récupérer un blockhash pour préparer manuellement une transaction pour simulation.
## Paramètres de la requête
Cette méthode peut prendre facultativement un objet de configuration avec les paramètres suivants :
* **`commitment`** (string, optionnel) : Spécifie le [niveau de commitment](https://www.helius.dev/blog/solana-commitment-levels) pour la requête. Si omis, le commitment par défaut du nœud est utilisé. Pour les transactions, il est courant d'utiliser `confirmed` ou `finalized` pour s'assurer que le blockhash provient d'une partie raisonnablement stable de la chaîne.
* **`minContextSlot`** (entier, optionnel) : Le slot minimum auquel la requête peut être évaluée. Cela garantit que la requête est effectuée contre un état du livre qui a traité jusqu'à ce slot au moins.
## Structure de la réponse
Le champ `result` de la réponse JSON-RPC sera un objet `RpcResponse`. Le champ `value` dans cet objet contient :
* **`blockhash`** (string) : Une chaîne encodée en base-58 représentant le blockhash le plus récent.
* **`lastValidBlockHeight`** (u64) : La hauteur du bloc à laquelle le `blockhash` expirera. Une transaction citant ce `blockhash` est valide jusqu'à ce que le réseau atteigne ce `lastValidBlockHeight`.
La réponse inclut également un objet `context` avec le `slot` au moment où l'information a été récupérée.
## Exemples
### 1. Obtenir le blockhash le plus récent avec le commitment par défaut
Cet exemple récupère le blockhash le plus récent en utilisant le commitment par défaut du nœud.
```bash cURL theme={"system"}
# Replace with your Helius API key
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getLatestBlockhash"
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
// Replace with your Helius API key
const { Connection } = require('@solana/web3.js');
async function fetchLatestBlockhash() {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
try {
const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
console.log('Latest Blockhash Info:');
console.log(` Blockhash: ${blockhash}`);
console.log(` Last Valid Block Height: ${lastValidBlockHeight}`);
// This blockhash can now be used in a transaction
} catch (error) {
console.error('Error fetching latest blockhash:', error);
}
}
fetchLatestBlockhash();
```
### 2. Obtenir le blockhash le plus récent avec le commitment 'confirmed'
Cet exemple demande explicitement le dernier blockhash avec le commitment `confirmed`.
```bash cURL theme={"system"}
# Replace with your Helius API key
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getLatestBlockhash",
"params": [{ "commitment": "confirmed" }]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
// Replace with your Helius API key
const { Connection } = require('@solana/web3.js');
async function fetchConfirmedBlockhash() {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
try {
const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
console.log('Confirmed Blockhash Info:');
console.log(` Blockhash: ${blockhash}`);
console.log(` Last Valid Block Height: ${lastValidBlockHeight}`);
} catch (error) {
console.error('Error fetching confirmed blockhash:', error);
}
}
fetchConfirmedBlockhash();
```
## Conseils pour les développeurs
* **Validité du blockhash :** Un blockhash est valide pendant un temps limité, environ 2 minutes (bien que cela puisse varier). Les transactions doivent être confirmées par le réseau avant que leur `lastValidBlockHeight` ne soit passé. Récupérez toujours un nouveau blockhash si un temps considérable s'est écoulé depuis le dernier.
* **Choix du commitment :** Pour les transactions critiques, l'utilisation du commitment `finalized` offre la garantie la plus forte que le blockhash provient de la fourche principale de la chaîne, mais il peut être légèrement plus ancien. `confirmed` offre un bon équilibre. Apprenez-en plus sur les [niveaux de commitment](https://www.helius.dev/blog/solana-commitment-levels) pour des informations détaillées.
* **Frais de transaction :** N'oubliez pas de calculer et d'inclure également les frais de transaction appropriés. Le blockhash lui-même ne détermine pas les frais.
* **Logique de réessai :** Si une transaction expire parce que son `lastValidBlockHeight` est passé, vous devez la re-signer avec un nouveau blockhash plus récent et la renvoyer.
Ce guide fournit les étapes pour utiliser `getLatestBlockhash` efficacement, une pierre angulaire pour interagir avec le réseau Solana via des transactions.
## Méthodes associées
Simuler une transaction avant de l'envoyer
Vérifier si un blockhash est toujours valide