> ## 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 getFeeForMessage
> Découvrez les cas d'utilisation de getFeeForMessage, des exemples de code, des paramètres de requête, la structure de réponse et des conseils.
La méthode RPC [`getFeeForMessage`](https://www.helius.dev/docs/api-reference/rpc/http/getfeeformessage) vous permet d'estimer les frais que le réseau facturera pour traiter un message de transaction donné. Cela est utile pour comprendre les [coûts de transaction](https://www.helius.dev/blog/solana-fees-in-theory-and-practice) avant qu'ils ne soient soumis au réseau.
**Remarque sur la version :** Cette méthode est disponible à partir de `solana-core` v1.9 ou plus récent. Pour les versions antérieures, envisagez d'utiliser `getFees`.
## Cas d'utilisation courants
* **Estimation des frais :** Déterminer les frais de transaction probables (en lamports) pour un message spécifique.
* **Optimisation des coûts :** Analyser les frais pour différentes structures de transaction ou à différents moments.
* **Affichage de l'interface utilisateur :** Afficher aux utilisateurs un coût de transaction estimé avant qu'ils ne signent et envoient une transaction.
## Paramètres de requête
1. **`message`** (string, requis) : Le message de transaction, encodé en base64. Vous pouvez l'obtenir en compilant une transaction.
2. **`config`** (objet, optionnel) : Un objet de configuration avec les champs suivants :
* **`commitment`** (string, optionnel) : Spécifie le [niveau de commitment](https://www.helius.dev/blog/solana-commitment-levels) à utiliser. Par défaut `finalized`.
* **`minContextSlot`** (nombre, optionnel) : Le slot minimum auquel la requête peut être évaluée.
## Structure de la réponse
Le champ `result` de la réponse JSON-RPC est un objet avec la structure suivante :
* **`context`** (objet) :
* **`slot`** (u64) : Le slot auquel les frais ont été évalués.
* **`value`** (u64 | null) : Les frais estimés en lamports. Cela peut être `null` si les frais ne peuvent pas être déterminés (par exemple, si le blockhash utilisé dans le message est trop ancien ou invalide).
## Exemples
### 1. Estimer les frais pour un message de transfert simple
Cet exemple démontre comment construire un transfert simple, compiler son message, puis récupérer les frais estimés.
```bash cURL theme={"system"}
# First, you need a base64 encoded message.
# This typically involves creating a transaction, compiling its message,
# and then base64 encoding the serialized message.
# The example message below is illustrative.
# Replace "MESSAGE_BASE64_ENCODED" with your actual encoded message.
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getFeeForMessage",
"params": [
"MESSAGE_BASE64_ENCODED", // Replace with your actual base64 encoded message
{ "commitment": "processed" }
]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
const { Connection, Keypair, SystemProgram, Transaction, LAMPORTS_PER_SOL } = require('@solana/web3.js');
async function estimateTransactionFee() {
const connection = new Connection('https://devnet.helius-rpc.com/?api-key=');
try {
const fromPublicKey = Keypair.generate().publicKey;
const toPublicKey = Keypair.generate().publicKey;
let transaction = new Transaction().add(
SystemProgram.transfer({
fromPubkey: fromPublicKey,
toPubkey: toPublicKey,
lamports: 1000,
})
);
transaction.feePayer = fromPublicKey;
const { blockhash } = await connection.getLatestBlockhash('confirmed');
transaction.recentBlockhash = blockhash;
const message = transaction.compileMessage();
const messageBase64 = message.serialize().toString('base64');
console.log(`Compiled Message (Base64): ${messageBase64}`);
const feeResult = await connection.getFeeForMessage(message, 'confirmed');
if (feeResult && feeResult.value !== null) {
console.log(`Estimated Fee: ${feeResult.value} lamports`);
} else {
console.log('Could not estimate fee. The value was null.');
console.log('This might happen if the blockhash is too old or the message is invalid.');
}
} catch (error) {
console.error('Error estimating transaction fee:', error);
if (error.message.includes('failed to get recent blockhash')) {
console.error('Ensure your RPC endpoint is responsive or try a different commitment level for getLatestBlockhash.');
}
}
}
estimateTransactionFee();
```
## Conseils pour les développeurs
* **Construction de message :** La clé pour utiliser `getFeeForMessage` est de correctement construire et sérialiser la transaction `Message`. Cela implique de définir le payeur des frais, les instructions, et un blockhash récent.
* **Blockhash récent :** Le message doit être construit avec un blockhash récent. Si le blockhash est trop ancien, le `value` dans la réponse pourrait être `null`.
* **Frais vs frais de priorité :** Cette méthode retourne les frais de base du réseau. Elle n'inclut pas les frais de priorité supplémentaires que vous pourriez ajouter à une transaction pour augmenter ses chances d'être traitée rapidement durant les périodes de congestion du réseau. Utilisez `getRecentPrioritizationFees` pour estimer les [frais de priorité](https://www.helius.dev/blog/priority-fees-understanding-solanas-transaction-fee-mechanics).
* **Lamports :** Les frais sont retournés en lamports (1 SOL = 1 000 000 000 lamports).
* **Valeur nulle :** Une valeur `null` pour les frais peut indiquer des problèmes avec le message (par exemple, blockhash invalide, message mal formé) ou que le nœud ne peut pas calculer de frais pour cela au niveau de commitment ou slot donné.
Ce guide fournit les étapes nécessaires pour utiliser la méthode RPC `getFeeForMessage` pour estimer les frais de transaction sur le réseau Solana.
## Méthodes connexes
Obtenez un blockhash récent pour construire des messages
Estimer les frais de priorité pour un traitement plus rapide