Estimation des frais prioritaires Solana : Méthode des clés de compte

Méthode avancée : Obtenez des estimations de frais prioritaires en utilisant des clés de compte pour des cas d’utilisation spécialisés tels que l’analyse pré-transaction, les opérations par lot et la recherche de modèles de compte.

Aperçu

La méthode des clés de compte offre une alternative plus simple à la sérialisation des transactions lorsque vous avez besoin d’estimations rapides de frais ou que vous souhaitez estimer les frais avant de construire la transaction complète.

Cas d'utilisation avancés

Analyse pré-transaction
Opérations de compte par lot
Recherche et modèles de marché
Architectures spécialisées

Compromis

Moins précis que les transactions sérialisées
Pas d’analyse spécifique aux instructions
Idéal pour les modèles au niveau des comptes

Recommandation : Pour la plupart des applications, utilisez plutôt la méthode des transactions sérialisées. Cette méthode des clés de compte est pour des cas d’utilisation spécialisés où vous avez besoin d’une analyse au niveau des comptes ou d’une planification pré-transaction.

Quand utiliser les clés de compte

Cas d'utilisation idéale
Scénarios spécialisés

Planification pré-transaction

Obtenez des estimations de frais avant de construire des transactions complètes

Intégration simplifiée

Lorsque votre architecture rend la sérialisation des transactions difficile

Analyse rapide du marché

Analysez les modèles de frais pour des comptes spécifiques sans construire de transactions

Analyse multi-comptes

Comprenez les modèles de frais à travers plusieurs comptes indépendamment

Démarrage rapide

Identifier les comptes

Déterminez quels comptes seront impliqués dans votre transaction

Appeler l'API

Faites une requête avec les clés de compte et le niveau de priorité souhaité

Appliquer le frais

Utilisez l’estimation pour définir le frais prioritaire dans votre transaction

Exemple de base

import { ComputeBudgetProgram } from "@solana/web3.js";

// 1. Identify accounts involved in your transaction
const accountKeys = [
  "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token program
  "YOUR_WALLET_ADDRESS",                          // Your wallet
  "RECIPIENT_ADDRESS"                             // Recipient
];

// 2. Get priority fee estimate
const priorityFee = await getPriorityFeeEstimate(connection, accountKeys, "Medium");

// 3. Add to your transaction
const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
  microLamports: priorityFee
});
transaction.add(priorityFeeIx);

import requests

# Get priority fee estimate
def get_priority_fee_estimate(account_keys, priority_level="Medium"):
    response = requests.post(
        "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY",
        json={
            "jsonrpc": "2.0",
            "id": "1",
            "method": "getPriorityFeeEstimate",
            "params": [{
                "accountKeys": account_keys,
                "options": {
                    "priorityLevel": priority_level,
                    "recommended": True
                }
            }]
        }
    )
    return response.json()["result"]["priorityFeeEstimate"]

# Usage
accounts = ["ACCOUNT_1", "ACCOUNT_2", "ACCOUNT_3"]
fee = get_priority_fee_estimate(accounts, "High")
print(f"Priority fee: {fee} micro-lamports")

Guide de mise en œuvre

Fonction principale

Voici une fonction réutilisable pour obtenir des estimations de frais prioritaires :

async function getPriorityFeeEstimate(connection, accountKeys, priorityLevel = "Medium") {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        accountKeys: accountKeys,
        options: { 
          priorityLevel: priorityLevel,
          recommended: true 
        }
      }]
    })
  });
  
  const result = await response.json();
  
  if (result.error) {
    throw new Error(`Fee estimation failed: ${JSON.stringify(result.error)}`);
  }
  
  return result.result.priorityFeeEstimate;
}

Exemple complet avec plusieurs niveaux de priorité

Développez pour voir la mise en œuvre complète

const { 
  Connection, 
  PublicKey, 
  Transaction, 
  ComputeBudgetProgram 
} = require("@solana/web3.js");

// Initialize connection
const connection = new Connection("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY");

async function analyzeAccountPriorityFees() {
  // Define accounts involved in your transaction
  const accountKeys = [
    "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token program
    "YOUR_WALLET_ADDRESS",                          // Your wallet
    "TOKEN_ACCOUNT_ADDRESS",                        // Token account
    "RECIPIENT_ADDRESS"                             // Recipient
  ];
  
  try {
    // Get estimates for different priority levels
    const [lowFee, mediumFee, highFee, veryHighFee] = await Promise.all([
      getPriorityFeeEstimate(connection, accountKeys, "Low"),
      getPriorityFeeEstimate(connection, accountKeys, "Medium"), 
      getPriorityFeeEstimate(connection, accountKeys, "High"),
      getPriorityFeeEstimate(connection, accountKeys, "VeryHigh")
    ]);
    
    console.log("Priority Fee Estimates:");
    console.log(`Low:      ${lowFee} micro-lamports`);
    console.log(`Medium:   ${mediumFee} micro-lamports`);
    console.log(`High:     ${highFee} micro-lamports`);
    console.log(`VeryHigh: ${veryHighFee} micro-lamports`);
    
    // Get all levels at once for comparison
    const allLevels = await getAllPriorityLevels(connection, accountKeys);
    console.log("\nAll priority levels:", allLevels);
    
    return {
      low: lowFee,
      medium: mediumFee,
      high: highFee,
      veryHigh: veryHighFee,
      allLevels
    };
  } catch (error) {
    console.error("Error getting priority fees:", error);
    throw error;
  }
}

// Helper function to get all priority levels
async function getAllPriorityLevels(connection, accountKeys) {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        accountKeys: accountKeys,
        options: { 
          includeAllPriorityFeeLevels: true
        }
      }]
    })
  });
  
  const result = await response.json();
  
  if (result.error) {
    throw new Error(`Fee estimation failed: ${JSON.stringify(result.error)}`);
  }
  
  return result.result.priorityFeeLevels;
}

// Run the analysis
analyzeAccountPriorityFees();

Types de comptes et stratégies

Comptes de programme
Portefeuilles d'utilisateur
Comptes de jetons

Les comptes de programme à haut volume présentent généralement des frais prioritaires plus élevés en raison de la concurrence.

// Popular program accounts
const programAccounts = [
  "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token program
  "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", // Associated token program
  "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K"  // Metaplex program
];

const programFees = await getPriorityFeeEstimate(connection, programAccounts, "Medium");
console.log(`Program account fees: ${programFees} micro-lamports`);

Comportement attendu : Frais plus élevés en raison du volume élevé de transactions et de la concurrence.

Les portefeuilles d’utilisateur actifs peuvent avoir des modèles de frais différents selon leur activité.

// Active user wallets
const userWallets = [
  "USER_WALLET_1", // Active trader
  "USER_WALLET_2"  // Regular user
];

const walletFees = await getPriorityFeeEstimate(connection, userWallets, "Medium");
console.log(`User wallet fees: ${walletFees} micro-lamports`);

Astuce pro : Incluez à la fois les portefeuilles expéditeur et destinataire pour des estimations plus précises.

Les comptes de jetons spécifiques peuvent montrer des modèles variés selon la popularité du jeton.

// Popular token accounts
const tokenAccounts = [
  "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC mint
  "So11111111111111111111111111111111111111112",  // SOL mint
  "YOUR_TOKEN_ACCOUNT"                            // Your specific token account
];

const tokenFees = await getPriorityFeeEstimate(connection, tokenAccounts, "Medium");

Options de configuration avancées

Évaluation des créneaux vides

L’option evaluateEmptySlotAsZero est particulièrement utile pour les estimations basées sur les comptes :

async function compareEmptySlotHandling(accountKeys) {
  const withEmptyAsZero = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        accountKeys: accountKeys,
        options: { 
          priorityLevel: "Medium",
          evaluateEmptySlotAsZero: true // Default: true
        }
      }]
    })
  });

  const withoutEmptyAsZero = await fetch(connection.rpcEndpoint, {
    method: "POST", 
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate", 
      params: [{
        accountKeys: accountKeys,
        options: {
          priorityLevel: "Medium",
          evaluateEmptySlotAsZero: false
        }
      }]
    })
  });
  
  const result1 = await withEmptyAsZero.json();
  const result2 = await withoutEmptyAsZero.json();
  
  console.log(`With empty as zero: ${result1.result.priorityFeeEstimate}`);
  console.log(`Without empty as zero: ${result2.result.priorityFeeEstimate}`);
}

Quand true (par défaut), les créneaux sans transactions sont traités comme des frais nuls plutôt que d’être exclus. Cela fournit des estimations plus équilibrées pour les comptes avec une activité sporadique.

Inclure les détails

Demandez des informations détaillées sur les modèles de frais de chaque compte :

async function getDetailedFeeEstimate(connection, accountKeys) {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        accountKeys: accountKeys,
        options: { 
          includeDetails: true,
          priorityLevel: "Medium"
        }
      }]
    })
  });
  
  const result = await response.json();
  console.log("Detailed fee analysis:", result.result);
  return result.result;
}

Cela retourne des informations supplémentaires sur la manière dont les frais ont été calculés pour chaque compte.

Période de rétrospective personnalisée

Ajustez le nombre de créneaux analysés pour l’estimation des frais :

async function getCustomLookbackEstimate(accountKeys, lookbackSlots = 50) {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        accountKeys: accountKeys,
        options: { 
          priorityLevel: "Medium",
          lookbackSlots: lookbackSlots  // 1-150, default is 150
        }
      }]
    })
  });
  
  const result = await response.json();
  return result.result.priorityFeeEstimate;
}

// Compare different lookback periods
const shortTerm = await getCustomLookbackEstimate(accountKeys, 50);   // Recent trends
const longTerm = await getCustomLookbackEstimate(accountKeys, 150);   // Historical average

console.log(`Short-term estimate: ${shortTerm} micro-lamports`);
console.log(`Long-term estimate: ${longTerm} micro-lamports`);

Rétrospective plus petite : Données plus récentes, potentiellement volatilesRétrospective plus large : Contexte historique plus stable

Meilleures pratiques pour la sélection de comptes

Inclure les comptes modifiables

Priorité : Concentrez-vous sur les comptes qui seront modifiés

const writableAccounts = [
  "YOUR_WALLET",        // Paying fees
  "TOKEN_ACCOUNT",      // Being modified  
  "RECIPIENT_ACCOUNT"   // Receiving tokens
];

Ajoutez les programmes clés

Contexte : Incluez les comptes de programme pertinents

const programAccounts = [
  "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token program
  "CUSTOM_PROGRAM_ID"                           // Your program
];

Gestion des erreurs et solutions de secours

class AccountBasedFeeEstimator {
  constructor(connection) {
    this.connection = connection;
    this.fallbackFee = 10000; // 10k micro-lamports fallback
  }

  async getEstimate(accountKeys, priorityLevel = "Medium") {
    try {
      // Primary attempt
      const estimate = await this.getPrimaryEstimate(accountKeys, priorityLevel);
      return estimate;
    } catch (error) {
      console.warn("Primary estimate failed:", error.message);
      
      // Fallback to different configuration
      try {
        return await this.getFallbackEstimate(accountKeys, priorityLevel);
      } catch (fallbackError) {
        console.warn("Fallback estimate failed:", fallbackError.message);
        return this.fallbackFee;
      }
    }
  }

  async getPrimaryEstimate(accountKeys, priorityLevel) {
    const response = await fetch(this.connection.rpcEndpoint, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: "1",
        method: "getPriorityFeeEstimate",
        params: [{
          accountKeys: accountKeys,
          options: { 
            priorityLevel: priorityLevel,
            recommended: true 
          }
        }]
      })
    });

    const result = await response.json();
    if (result.error) {
      throw new Error(result.error.message);
    }
    
    return result.result.priorityFeeEstimate;
  }

  async getFallbackEstimate(accountKeys, priorityLevel) {
    // Try with fewer accounts or different settings
    const coreAccounts = accountKeys.slice(0, 3); // Take first 3 accounts
    
    const response = await fetch(this.connection.rpcEndpoint, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: "1",
        method: "getPriorityFeeEstimate",
        params: [{
          accountKeys: coreAccounts,
          options: { 
            priorityLevel: "Medium", // Use medium as fallback
            evaluateEmptySlotAsZero: true
          }
        }]
      })
    });

    const result = await response.json();
    if (result.error) {
      throw new Error(result.error.message);
    }
    
    return result.result.priorityFeeEstimate;
  }
}

// Usage
const estimator = new AccountBasedFeeEstimator(connection);
const fee = await estimator.getEstimate(accountKeys, "High");

async function safeGetPriorityFee(accountKeys, priorityLevel = "Medium") {
  try {
    return await getPriorityFeeEstimate(connection, accountKeys, priorityLevel);
  } catch (error) {
    console.warn(`Priority fee estimation failed: ${error.message}`);
    
    // Return reasonable fallback based on priority level
    const fallbacks = {
      "Low": 1000,
      "Medium": 5000,
      "High": 15000,
      "VeryHigh": 50000
    };
    
    return fallbacks[priorityLevel] || 5000;
  }
}

Limitations et considérations

Limitations de la méthode basée sur les comptes :

Moins précis pour les comptes en lecture seule - L’algorithme se concentre sur les comptes modifiables
Pas d’analyse spécifique aux instructions - Ne peut pas considérer les opérations spécifiques
Dépendance à l’activité des comptes - Moins précis pour les comptes inactifs
Pas de considération de la taille des transactions - Ne prend pas en compte la complexité des transactions

Quand passer aux transactions sérialisées :

Applications en production nécessitant une précision maximale
Transactions complexes avec multiples instructions
Lorsque les modèles de frais spécifiques aux instructions sont importants
Applications critiques en termes de performance

Ressources connexes

Transactions sérialisées

Méthode plus précise utilisant la sérialisation complète des transactions

Référence API

Documentation complète de l’API et paramètres

Commencer

Diffusion de données et écoute d'événements

API de données et RPC

Trading

Envoyer des transactions

Wallet en tant que service

Confidentialité

Ressources

Estimation des frais prioritaires Solana : Méthode des clés de compte

Aperçu

Cas d'utilisation avancés

Compromis

Quand utiliser les clés de compte

Planification pré-transaction

Intégration simplifiée

Analyse rapide du marché

Analyse multi-comptes

Démarrage rapide

Exemple de base

Guide de mise en œuvre

Fonction principale

Exemple complet avec plusieurs niveaux de priorité

Types de comptes et stratégies

Options de configuration avancées

Meilleures pratiques pour la sélection de comptes

Inclure les comptes modifiables

Ajoutez les programmes clés

Gestion des erreurs et solutions de secours

Limitations et considérations

Ressources connexes

Transactions sérialisées

Référence API

​Aperçu

Cas d'utilisation avancés

Compromis

​Quand utiliser les clés de compte

Planification pré-transaction

Intégration simplifiée

Analyse rapide du marché

Analyse multi-comptes

​Démarrage rapide

​Exemple de base

​Guide de mise en œuvre

​Fonction principale

​Exemple complet avec plusieurs niveaux de priorité

​Types de comptes et stratégies

​Options de configuration avancées

​Meilleures pratiques pour la sélection de comptes

Inclure les comptes modifiables

Ajoutez les programmes clés

​Gestion des erreurs et solutions de secours

​Limitations et considérations

​Ressources connexes

Transactions sérialisées

Référence API

Aperçu

Quand utiliser les clés de compte

Démarrage rapide

Exemple de base

Guide de mise en œuvre

Fonction principale

Exemple complet avec plusieurs niveaux de priorité

Types de comptes et stratégies

Options de configuration avancées

Meilleures pratiques pour la sélection de comptes

Gestion des erreurs et solutions de secours

Limitations et considérations

Ressources connexes