> ## 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.

# So verwenden Sie getFeeForMessage

> Erfahren Sie mehr über Anwendungsfälle, Codebeispiele, Anforderungsparameter, Antwortstruktur und Tipps zu getFeeForMessage.

Die [`getFeeForMessage`](https://www.helius.dev/docs/api-reference/rpc/http/getfeeformessage) RPC-Methode ermöglicht Ihnen die Schätzung der Gebühr, die das Netzwerk für die Verarbeitung einer gegebenen Transaktionsnachricht berechnen wird. Dies ist nützlich, um die [Transaktionskosten](https://www.helius.dev/blog/solana-fees-in-theory-and-practice) zu verstehen, bevor sie an das Netzwerk gesendet werden.

**Versionshinweis:** Diese Methode ist in `solana-core` v1.9 oder neuer verfügbar. Für ältere Versionen sollten Sie `getFees` verwenden.

## Häufige Anwendungsfälle

* **Gebührenschätzung:** Bestimmen Sie die voraussichtliche Transaktionsgebühr (in Lamports) für eine bestimmte Nachricht.
* **Kostenoptimierung:** Analysieren Sie Gebühren für verschiedene Transaktionsstrukturen oder zu unterschiedlichen Zeiten.
* **Benutzeroberflächenanzeige:** Zeigen Sie Benutzern eine geschätzte Transaktionskosten an, bevor sie eine Transaktion unterzeichnen und senden.

## Anforderungsparameter

1. **`message`** (String, erforderlich): Die Transaktionsnachricht, base64-kodiert. Sie können diese erhalten, indem Sie eine Transaktion kompilieren.
2. **`config`** (Objekt, optional): Ein Konfigurationsobjekt mit den folgenden Feldern:
   * **`commitment`** (String, optional): Gibt das zu verwendende [Commitment-Level](https://www.helius.dev/blog/solana-commitment-levels) an. Standardmäßig ist `finalized`.
   * **`minContextSlot`** (Nummer, optional): Der minimale Slot, bei dem die Anfrage ausgewertet werden kann.

## Antwortstruktur

Das `result` Feld der JSON-RPC-Antwort ist ein Objekt mit der folgenden Struktur:

* **`context`** (Objekt):
  * **`slot`** (u64): Der Slot, bei dem die Gebühr bewertet wurde.
* **`value`** (u64 | null): Die geschätzte Gebühr in Lamports. Dies kann `null` sein, wenn die Gebühr nicht bestimmt werden kann (z.B. wenn der in der Nachricht verwendete Blockhash zu alt oder ungültig ist).

## Beispiele

### 1. Gebührenschätzung für eine einfache Transfernachricht

Dieses Beispiel zeigt, wie man einen einfachen Transfer konstruiert, seine Nachricht kompiliert und dann die geschätzte Gebühr abruft.

<CodeGroup>
  ```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=<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=<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();
  ```
</CodeGroup>

## Entwicklertipps

* **Nachrichtenkonstruktion:** Der Schlüssel zur Verwendung von `getFeeForMessage` besteht darin, die Transaktion `Message` korrekt zu konstruieren und zu serialisieren. Dies umfasst das Festlegen des Gebührenzahlers, der Anweisungen und eines aktuellen Blockhashes.
* **Aktueller Blockhash:** Die Nachricht muss mit einem aktuellen Blockhash konstruiert werden. Wenn der Blockhash zu alt ist, könnte der `value` in der Antwort `null` sein.
* **Gebühr vs. Prioritätsgebühr:** Diese Methode gibt die Basisnetzgebühr zurück. Sie beinhaltet keine zusätzlichen Prioritätsgebühren, die Sie gegebenenfalls zu einer Transaktion hinzufügen, um ihre Wahrscheinlichkeit einer schnellen Verarbeitung bei Netzwerkkongestion zu erhöhen. Verwenden Sie `getRecentPrioritizationFees`, um [Prioritätsgebühren](https://www.helius.dev/blog/priority-fees-understanding-solanas-transaction-fee-mechanics) zu schätzen.
* **Lamports:** Die Gebühr wird in Lamports zurückgegeben (1 SOL = 1.000.000.000 Lamports).
* **Nullwert:** Ein `null`-Wert für die Gebühr kann auf Probleme mit der Nachricht hinweisen (z.B. ungültiger Blockhash, fehlerhafte Nachricht) oder darauf, dass der Knoten keine Gebühr dafür bei dem angegebenen Commitment-Level oder Slot berechnen kann.

Diese Anleitung bietet die notwendigen Schritte zur Nutzung der `getFeeForMessage` RPC-Methode zur Schätzung von Transaktionsgebühren im Solana-Netzwerk.

## Verwandte Methoden

<CardGroup cols={2}>
  <Card title="getLatestBlockhash" href="/docs/de/api-reference/rpc/http/getlatestblockhash">
    Erhalten Sie einen aktuellen Blockhash zur Konstruktion von Nachrichten
  </Card>

  <Card title="getRecentPrioritizationFees" href="/docs/de/api-reference/rpc/http/getrecentprioritizationfees">
    Schätzen Sie Prioritätsgebühren für schnellere Verarbeitung
  </Card>
</CardGroup>