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

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

Die [`getRecentPrioritizationFees`](https://www.helius.dev/docs/api-reference/rpc/http/getrecentprioritizationfees) RPC-Methode bietet Einblicke in die Priorisierungsgebühren, die in den letzten Blöcken des Solana-Netzwerks gezahlt wurden. Durch die Untersuchung dieser Gebühren können Entwickler fundiertere Entscheidungen darüber treffen, welche zusätzliche Gebühr ([Prioritätsgebühr](https://www.helius.dev/blog/priority-fees-understanding-solanas-transaction-fee-mechanics)) sie ihren Transaktionen hinzufügen sollten, um deren Wahrscheinlichkeit zu erhöhen, insbesondere während Zeiten hoher Netzaktivität, schnell verarbeitet zu werden.

Nodes cachen typischerweise Priorisierungsgebührendaten für bis zu 150 aktuelle Blöcke.

## Häufige Anwendungsfälle

* **Dynamische Gebührenschätzung:** Bestimmen Sie eine wettbewerbsfähige Prioritätsgebühr für eine Transaktion, indem Sie beobachten, welche Gebühren kürzlich erfolgreich waren.
* **Stauanalyse:** Verstehen Sie den aktuellen Stand der Netzwerkkongestion, indem Sie sich die Höhe der gezahlten Prioritätsgebühren ansehen.
* **Wallet-Integration:** Erlauben Sie Wallets, basierend auf den aktuellen Netzwerkkonditionen angemessene Prioritätsgebühren vorzuschlagen.
* **Arbitrage-Bots:** Für zeitkritische Operationen wie Arbitrage ist das Setzen einer optimalen Prioritätsgebühr entscheidend für die rechtzeitige Ausführung.

## Anforderungsparameter

1. **`lockedWritableAccounts`** (`array` von `string`, optional):
   * Ein Array von base-58 kodierten öffentlichen Schlüsseln von Konten, die Ihre Transaktion schreibsperren möchte.
   * Maximal können 128 Adressen angegeben werden.
   * Wenn angegeben, gibt die Methode die von Transaktionen gezahlten Priorisierungsgebühren zurück, die **alle** der angegebenen Konten als schreibbar gesperrt haben.
   * Wenn ausgelassen oder ein leeres Array übergeben wird, gibt die Methode eine allgemeinere Ansicht über die Priorisierungsgebühren zurück, die über die letzten Blöcke hinweg beobachtet wurden, ohne auf eine spezifische Kontengruppe zu achten.

## Antwortstruktur

Das `result` Feld der JSON-RPC-Antwort ist ein Array von Priorisierungsgebühr-Objekten. Jedes Objekt enthält Gebühren aus einem bestimmten aktuellen Slot und hat die folgende Struktur:

* **`slot`** (`u64`): Die Slotnummer, in der die Transaktionen, die zu diesen Gebührendaten beigetragen haben, verarbeitet wurden.
* **`prioritizationFee`** (`u64`): Die minimale Priorisierungsgebühr (in Mikro-Lamports pro Compute Unit), die von mindestens einer Transaktion in diesem Slot gezahlt wurde (und die dem `lockedWritableAccounts`-Filter entspricht, falls vorhanden). Ein Wert von `0` bedeutet oft, dass keine Transaktionen in diesem Slot (die den Kriterien entsprechen) eine zusätzliche Prioritätsgebühr über die Basisgebühr hinaus bezahlt haben oder der Node keine für die gegebenen Konten beobachtet hat.

## Beispiele

### 1. Abrufen der letzten globalen Priorisierungsgebühren

Dieses Beispiel ruft eine allgemeine Liste der letzten Priorisierungsgebühren ab, ohne spezifische gesperrte Konten anzugeben.

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <api-key> with your Helius API key
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getRecentPrioritizationFees",
      "params": [[]] # Empty array for global fees
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection } = require('@solana/web3.js');

  async function fetchGlobalPrioritizationFees() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    try {
      // Pass an empty array or omit the parameter for global fees
      const fees = await connection.getRecentPrioritizationFees([]); 
      if (fees && fees.length > 0) {
        console.log(`Fetched ${fees.length} recent prioritization fee samples (global):`);
        fees.forEach((feeInfo, index) => {
          console.log(`--- Sample ${index + 1} ---`);
          console.log(`  Slot: ${feeInfo.slot}`);
          console.log(`  Prioritization Fee (micro-lamports/CU): ${feeInfo.prioritizationFee}`);
        });
        // Example: Calculate the median of non-zero fees
        const nonZeroFees = fees.filter(f => f.prioritizationFee > 0).map(f => f.prioritizationFee).sort((a,b) => a - b);
        if (nonZeroFees.length > 0) {
          const mid = Math.floor(nonZeroFees.length / 2);
          const medianFee = nonZeroFees.length % 2 !== 0 ? nonZeroFees[mid] : (nonZeroFees[mid - 1] + nonZeroFees[mid]) / 2;
          console.log(`\nMedian non-zero priority fee: ${medianFee} micro-lamports/CU`);
        }
      } else {
        console.log('No recent prioritization fee data returned.');
      }
    } catch (error) {
      console.error('Error fetching global prioritization fees:', error);
    }
  }

  fetchGlobalPrioritizationFees();
  ```
</CodeGroup>

### 2. Abrufen der letzten Priorisierungsgebühren für spezifische schreibbare Konten

Dieses Beispiel ruft Priorisierungsgebühren ab, die für eine Transaktion relevant sind, die zwei spezifische Konten schreibsperren muss.

<CodeGroup>
  ```bash cURL theme={"system"}
  # Replace <api-key> with your Helius API key
  # Replace with actual public keys you are interested in
  curl https://mainnet.helius-rpc.com/?api-key=<api-key> -X POST -H "Content-Type: application/json" -d \
    '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getRecentPrioritizationFees",
      "params": [[
        "Vote111111111111111111111111111111111111111", 
        "Stake11111111111111111111111111111111111111"
      ]]
    }'
  ```

  ```javascript JavaScript (using @solana/web3.js) theme={"system"}
  // Replace <api-key> with your Helius API key
  const { Connection, PublicKey } = require('@solana/web3.js');

  async function fetchPrioritizationFeesForAccounts() {
    const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=<api-key>');
    
    // Replace with actual public keys your transaction will lock
    const accountsToLock = [
      new PublicKey('Vote111111111111111111111111111111111111111'),
      new PublicKey('Stake11111111111111111111111111111111111111')
    ];

    try {
      const fees = await connection.getRecentPrioritizationFees(accountsToLock.map(pk => pk.toBase58()));
      if (fees && fees.length > 0) {
        console.log(`Fetched ${fees.length} recent prioritization fee samples for specified accounts:`);
        fees.forEach((feeInfo, index) => {
          console.log(`--- Sample ${index + 1} ---`);
          console.log(`  Slot: ${feeInfo.slot}`);
          console.log(`  Prioritization Fee (micro-lamports/CU): ${feeInfo.prioritizationFee}`);
        });
      } else {
        console.log('No recent prioritization fee data returned for the specified accounts.');
      }
    } catch (error) {
      console.error('Error fetching prioritization fees for accounts:', error);
    }
  }

  fetchPrioritizationFeesForAccounts();
  ```
</CodeGroup>

## Entwicklertipps

* **Gebühreneinheiten:** Priorisierungsgebühren werden in Mikro-Lamports (0,000001 Lamports) pro Compute Unit (CU) ausgedrückt.
* **Cache-Dauer:** RPC-Nodes cachen diese Gebühren typischerweise für etwa 150 Blöcke. Das bedeutet, dass Sie ein relativ kurzes historisches Fenster betrachten (ungefähr 1-2 Minuten).
* **Null-Gebühren:** Ein `prioritizationFee` von `0` bedeutet nicht unbedingt, dass keine Gebühren bezahlt wurden. Vielmehr, dass für den gegebenen Slot und die Konten, die beobachteten Transaktionen keine Prioritätsgebühr beinhalteten oder unter einem Schwellenwert lagen, den der Node als signifikant erachtet.
* **Strategische Nutzung:** Wählen Sie nicht einfach die höchste kürzlich gezahlte Gebühr. Analysieren Sie die Verteilung (z.B. Median, 75. Perzentil der nicht-Null-Gebühren), um eine kosteneffiziente Wahl zu treffen. Überbezahlungen garantieren keine schnellere Inklusion, wenn der Block bereits voller hochprioritärer Transaktionen ist.
* **Compute Units:** Die Gesamtprioritätsgebühr für Ihre Transaktion wird `prioritizationFee_per_CU * your_transaction_compute_units` sein. Sie müssen auch das Compute Unit-Limit für Ihre Transaktion (`ComputeBudgetProgram.setComputeUnitLimit`) und den Preis (`ComputeBudgetProgram.setComputeUnitPrice`) festlegen.

Die effektive Nutzung von `getRecentPrioritizationFees` kann die Zuverlässigkeit der Transaktionsbestätigung unter dynamischen Netzwerkbedingungen erheblich verbessern.