Solana-Prioritätsgebührenschätzung: Account Keys Methode

Erweiterte Methode: Holen Sie Prioritätsgebührenschätzungen mithilfe von Account Keys für spezialisierte Anwendungsfälle wie prä-transaktionale Analysen, Batch-Operationen und Account-Pattern-Forschung ein.

Übersicht

Die Account Keys Methode bietet eine einfachere Alternative zur Transaktionsserialisierung, wenn Sie schnelle Gebührenschätzungen benötigen oder Gebühren schätzen möchten, bevor Sie die vollständige Transaktion konstruieren.

Erweiterte Anwendungsfälle

Prä-transaktionale Analyse
Batch-Account-Operationen
Marktforschung und Muster
Spezialisierte Architekturen

Kompromisse

Weniger genau als serialisierte Transaktionen
Keine anweisungsspezifische Analyse
Am besten für Account-Level-Muster

Empfehlung: Für die meisten Anwendungen verwenden Sie stattdessen die serialisierte Transaktionsmethode. Diese Account Keys Methode ist für spezialisierte Anwendungsfälle gedacht, bei denen Sie eine Account-Level-Analyse oder prä-transactionale Planung benötigen.

Wann Account Keys verwenden

Ideale Anwendungsfälle
Spezialisierte Szenarien

Prä-transaktionale Planung

Holen Sie Gebührenschätzungen ein, bevor Sie vollständige Transaktionen konstruieren

Vereinfachte Integration

Wenn Ihre Architektur die Transaktionsserialisierung erschwert

Schnelle Marktanalyse

Analysieren Sie Gebührenmuster für spezifische Konten, ohne Transaktionen zu erstellen

Multi-Account-Analyse

Verstehen Sie Gebührenmuster über mehrere Konten unabhängig

Schnellstart

Konten identifizieren

Bestimmen Sie, welche Konten an Ihrer Transaktion beteiligt sein werden

Die API aufrufen

Machen Sie eine Anfrage mit den Account Keys und dem gewünschten Prioritätslevel

Die Gebühr anwenden

Verwenden Sie die Schätzung, um die Prioritätsgebühr in Ihrer Transaktion festzulegen

Einfaches Beispiel

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

Implementierungsleitfaden

Kernfunktion

Hier ist eine wiederverwendbare Funktion zur Ermittlung von Prioritätsgebührenschätzungen:

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

Vollständiges Beispiel mit mehreren Prioritätslevels

Erweiterung zur vollständigen Implementierung anzeigen

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();

Kontentypen & Strategien

Programmkonten
Benutzer-Wallets
Token-Konten

Hochvolumige Programmkonten zeigen typischerweise höhere Prioritätsgebühren aufgrund von Wettbewerb.

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

Erwartetes Verhalten: Höhere Gebühren aufgrund hoher Transaktionsvolumina und Wettbewerb.

Aktive Benutzer-Wallets können je nach Aktivität unterschiedliche Gebührenmuster aufweisen.

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

Profi-Tipp: Schließen Sie sowohl Absender- als auch Empfänger-Wallets ein, um genauere Schätzungen zu erhalten.

Spezifische Token-Konten können je nach Token-Beliebtheit unterschiedliche Muster zeigen.

// 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");

Erweiterte Konfigurationsoptionen

Bewertung leerer Slots

Die evaluateEmptySlotAsZero-Option ist besonders nützlich für kontobasierte Schätzungen:

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}`);
}

Wenn true (Standard), werden Slots ohne Transaktionen als Nullgebühren behandelt, anstatt ausgeschlossen zu werden. Dies bietet ausgewogenere Schätzungen für Konten mit sporadischer Aktivität.

Details einbeziehen

Fordern Sie detaillierte Informationen über die Gebührenmuster jedes Kontos an:

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

Dies liefert zusätzliche Informationen darüber, wie die Gebühren für jedes Konto berechnet wurden.

Benutzerdefinierte Rückblicksperiode

Passen Sie die Anzahl der zur Gebührenschätzung analysierten Slots an:

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`);

Kleinerer Rückblick: Kürzere, potenziell volatile DatenGrößerer Rückblick: Stabilere, historische Kontexte

Best Practices für die Kontoauswahl

Schreibbare Konten einbeziehen

Priorität: Konzentrieren Sie sich auf Konten, die geändert werden

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

Wichtige Programme hinzufügen

Kontext: Relevante Programmkonten einbeziehen

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

Fehlerbehandlung & Rückfallstrategien

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

Einschränkungen & Überlegungen

Einschränkungen der kontobasierten Methode:

Weniger genau für schreibgeschützte Konten - Der Algorithmus fokussiert sich auf beschreibbare Konten
Keine anweisungsspezifische Analyse - Kann spezifische Operationen nicht berücksichtigen
Abhängigkeit von Kontoaktivität - Weniger genau für inaktive Konten
Keine Berücksichtigung der Transaktionsgröße - Berücksichtigt nicht die Komplexität der Transaktion

Wann zur serialisierten Transaktion aufsteigen:

Anwendungen im Produktionsumfeld, die höchste Genauigkeit erfordern
Komplexe Transaktionen mit mehreren Anweisungen
Wenn anweisungsspezifische Gebührenmuster wichtig sind
Leistungsoptimierte Anwendungen

Serialisierte Transaktionen

Genauerer Methode durch vollständige Transaktionsserialisierung

API-Referenz

Komplett API-Dokumentation und Parameter

Erste Schritte

Daten-Streaming & Ereignisüberwachung

Daten-APIs & RPCs

Handel

Transaktionen senden

Wallet-as-a-Service

Privatsphäre

Ressourcen

Solana-Prioritätsgebührenschätzung: Account Keys Methode

Übersicht

Erweiterte Anwendungsfälle

Kompromisse

Wann Account Keys verwenden

Prä-transaktionale Planung

Vereinfachte Integration

Schnelle Marktanalyse

Multi-Account-Analyse

Schnellstart

Einfaches Beispiel

Implementierungsleitfaden

Kernfunktion

Vollständiges Beispiel mit mehreren Prioritätslevels

Kontentypen & Strategien

Erweiterte Konfigurationsoptionen

Best Practices für die Kontoauswahl

Schreibbare Konten einbeziehen

Wichtige Programme hinzufügen

Fehlerbehandlung & Rückfallstrategien

Einschränkungen & Überlegungen

Verwandte Ressourcen

Serialisierte Transaktionen

API-Referenz

​Übersicht

Erweiterte Anwendungsfälle

Kompromisse

​Wann Account Keys verwenden

Prä-transaktionale Planung

Vereinfachte Integration

Schnelle Marktanalyse

Multi-Account-Analyse

​Schnellstart

​Einfaches Beispiel

​Implementierungsleitfaden

​Kernfunktion

​Vollständiges Beispiel mit mehreren Prioritätslevels

​Kontentypen & Strategien

​Erweiterte Konfigurationsoptionen

​Best Practices für die Kontoauswahl

Schreibbare Konten einbeziehen

Wichtige Programme hinzufügen

​Fehlerbehandlung & Rückfallstrategien

​Einschränkungen & Überlegungen

​Verwandte Ressourcen

Serialisierte Transaktionen

API-Referenz

Übersicht

Wann Account Keys verwenden

Schnellstart

Einfaches Beispiel

Implementierungsleitfaden

Kernfunktion

Vollständiges Beispiel mit mehreren Prioritätslevels

Kontentypen & Strategien

Erweiterte Konfigurationsoptionen

Best Practices für die Kontoauswahl

Fehlerbehandlung & Rückfallstrategien

Einschränkungen & Überlegungen

Verwandte Ressourcen