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

> Découvrez les cas d'utilisation de getRecentPrioritizationFees, des exemples de code, des paramètres de requête, la structure de réponse et des conseils.

La méthode RPC [`getRecentPrioritizationFees`](https://www.helius.dev/docs/api-reference/rpc/http/getrecentprioritizationfees) fournit des informations sur les frais de priorisation payés dans les blocs récents sur le réseau Solana. En examinant ces frais, les développeurs peuvent prendre des décisions plus éclairées sur le montant du frais supplémentaire ([frais de priorité](https://www.helius.dev/blog/priority-fees-understanding-solanas-transaction-fee-mechanics)) à ajouter à leurs transactions pour augmenter leur probabilité d'être traitées rapidement, surtout pendant les périodes de forte activité du réseau.

Les nœuds mettent généralement en cache les données de frais de priorisation pour jusqu'à 150 blocs récents.

## Cas d'Utilisation Communes

* **Estimation Dynamique des Frais :** Déterminer un frais de priorité compétitif pour une transaction en observant quels frais ont récemment réussi.
* **Analyse de la Congestion :** Comprendre l'état actuel de la congestion du réseau en examinant le niveau des frais de priorité payés.
* **Intégration de Portefeuille :** Permettre aux portefeuilles de suggérer des frais de priorité appropriés aux utilisateurs en fonction des conditions récentes du réseau.
* **Bots d'Arbitrage :** Pour des opérations sensibles au temps comme l'arbitrage, définir un frais de priorité optimal est crucial pour une exécution rapide.

## Paramètres de Requête

1. **`lockedWritableAccounts`** (`array` de `string`, optionnel) :
   * Un tableau de clés publiques encodées en base-58 des comptes que votre transaction a l'intention de verrouiller pour l'écriture.
   * Un maximum de 128 adresses peut être fourni.
   * Si fourni, la méthode retourne les frais de priorisation payés par des transactions qui ont verrouillé **tous** les comptes spécifiés comme écriture.
   * Si omis ou si un tableau vide est passé, la méthode retourne une vue plus générale des frais de priorisation observés à travers les blocs récents, non spécifiques à un ensemble particulier de comptes.

## Structure de Réponse

Le champ `result` de la réponse JSON-RPC est un tableau d'objets de frais de priorisation. Chaque objet détaille les frais d'un créneau récent spécifique et a la structure suivante :

* **`slot`** (`u64`) : Le numéro de créneau dans lequel les transactions contribuant à ces données de frais ont été traitées.
* **`prioritizationFee`** (`u64`) : Le frais de priorisation minimum (en micro-Lamports par Unité de Calcul) payé par au moins une transaction dans ce créneau (et correspondant au filtre `lockedWritableAccounts`, le cas échéant). Une valeur de `0` signifie souvent qu'aucune transaction dans ce créneau (correspondant aux critères) n'a payé un frais de priorité supplémentaire au-delà du frais de base, ou que le nœud n'a pas observé de transaction pour les comptes donnés.

## Exemples

### 1. Obtenir les Frais de Priorisation Récents Globaux

Cet exemple récupère une liste générale de frais de priorisation récents sans spécifier de comptes verrouillés.

<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. Obtenir les Frais de Priorisation Récents pour des Comptes Ecriture Spécifiques

Cet exemple récupère les frais de priorisation pertinents pour une transaction qui doit verrouiller pour l'écriture deux comptes spécifiques.

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

## Conseils pour les Développeurs

* **Unités de Frais :** Les frais de priorisation sont exprimés en micro-Lamports (0.000001 Lamports) par Unité de Calcul (CU).
* **Fenêtre de Cache :** Les nœuds RPC mettent généralement en cache ces frais pendant environ 150 blocs. Cela signifie que vous examinez une fenêtre historique relativement courte (environ 1 à 2 minutes).
* **Frais Zéro :** Un `prioritizationFee` de `0` ne signifie pas nécessairement que aucun frais n'a été payé, mais plutôt que pour le créneau et le(s) compte(s) donné(s), les transactions échantillonnées n'incluaient pas de frais de priorité, ou étaient en dessous d'un seuil que le nœud considère comme significatif.
* **Utilisation Stratégique :** Ne choisissez pas simplement le frais le plus élevé récemment. Analysez la distribution (par exemple, médiane, 75e centile des frais non nuls) pour faire un choix rentable. Surpayer ne garantit pas une inclusion plus rapide au-delà d'un certain point si le bloc est déjà rempli de transactions à haute priorité.
* **Unités de Calcul :** Le frais de priorité total pour votre transaction sera `prioritizationFee_per_CU * your_transaction_compute_units`. Vous devez également définir la limite d'unités de calcul pour votre transaction (`ComputeBudgetProgram.setComputeUnitLimit`) et le prix (`ComputeBudgetProgram.setComputeUnitPrice`).

Utiliser efficacement `getRecentPrioritizationFees` peut améliorer considérablement la fiabilité de confirmation des transactions dans des conditions de réseau dynamiques.