Schätzung der Solana-Prioritätsgebühr: Methode mit Kontoschlüsseln

Fortgeschrittene Methode: Ermittle Schätzungen der Prioritätsgebühr anhand von Kontoschlüsseln für spezielle Anwendungsfälle wie Analysen vor einer Transaktion, Batch-Vorgänge und die Untersuchung von Kontomustern.

Übersicht

Die Methode mit Kontoschlüsseln ist eine einfachere Alternative zur Transaktionsserialisierung, wenn du schnell Gebühren schätzen oder Gebühren vor dem Erstellen der vollständigen Transaktion ermitteln möchtest.

Advanced Use Cases

Analysen vor einer Transaktion
Batch-Vorgänge für Konten
Marktforschung und Muster
Spezialisierte Architekturen

Trade-offs

Weniger genau als serialisierte Transaktionen
Keine anweisungsspezifische Analyse
Am besten für Muster auf Kontoebene geeignet

Empfehlung: Verwende für die meisten Anwendungen stattdessen die Methode mit serialisierter Transaktion. Diese Methode mit Kontoschlüsseln eignet sich für spezielle Anwendungsfälle, bei denen du Analysen auf Kontoebene oder eine Planung vor der Transaktion benötigst.

Wann du Kontoschlüssel verwenden solltest

Ideal Use Cases
Specialized Scenarios

Pre-transaction Planning

Erhalte Gebührenschätzungen, bevor du vollständige Transaktionen erstellst

Simplified Integration

Wenn deine Architektur die Transaktionsserialisierung erschwert

Quick Market Analysis

Analysiere Gebührenmuster für bestimmte Konten, ohne Transaktionen zu erstellen

Multi-account Analysis

Untersuche die Gebührenmuster mehrerer Konten unabhängig voneinander

Schnellstart

Identify Accounts

Ermittle, welche Konten an deiner Transaktion beteiligt sind

Call the API

Sende einen request mit den Kontoschlüsseln und der gewünschten Prioritätsstufe

Apply the Fee

Verwende die Schätzung, um die Prioritätsgebühr in deiner 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

Mit dieser wiederverwendbaren Funktion kannst du Schätzungen der Prioritätsgebühr abrufen:

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

Expand to see full implementation

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

Kontotypen und Strategien

Program Accounts
User Wallets
Token Accounts

Stark frequentierte Programmkonten weisen aufgrund des Wettbewerbs in der Regel höhere Prioritätsgebühren auf.

// 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 des hohen Transaktionsvolumens und Wettbewerbs.

Aktive Benutzer-Wallets können abhängig von ihrer 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: Beziehe sowohl die Wallet des Absenders als auch die des Empfängers ein, um genauere Schätzungen zu erhalten.

Bestimmte Token-Konten können je nach Beliebtheit des Tokens unterschiedliche Muster aufweisen.

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

Empty Slot Evaluation

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

Bei true (Standard) werden slots ohne Transaktionen als Gebühren von null behandelt und nicht ausgeschlossen. Dadurch erhältst du ausgewogenere Schätzungen für Konten mit geringer Aktivität.

Include Details

Fordere detaillierte Informationen zu den Gebührenmustern der einzelnen Konten 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;
}

Dadurch erhältst du zusätzliche Informationen dazu, wie die Gebühren für jedes Konto berechnet wurden.

Custom Lookback Period

Passe die Anzahl der für die 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`);

Kürzerer Rückblick: Aktuellere, möglicherweise volatile DatenLängerer Rückblick: Stabilerer historischer Kontext

Best Practices für die Kontoauswahl

Include Writable Accounts

Priorität: Konzentriere dich auf Konten, die geändert werden

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

Add Key Programs

Kontext: Beziehe relevante Programmkonten ein

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

Fehlerbehandlung und Fallbacks

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 und wichtige Hinweise

Einschränkungen der kontobasierten Methode:

Weniger genau bei schreibgeschützten Konten – Der Algorithmus konzentriert sich auf beschreibbare Konten
Keine anweisungsspezifische Analyse – Bestimmte Vorgänge können nicht berücksichtigt werden
Abhängigkeit von der Kontoaktivität – Weniger genau bei inaktiven Konten
Keine Berücksichtigung der Transaktionsgröße – Die Komplexität der Transaktion wird nicht berücksichtigt

Wann du zu serialisierten Transaktionen wechseln solltest:

Produktivsysteme, die höchste Genauigkeit erfordern
Komplexe Transaktionen mit mehreren Anweisungen
Wenn anweisungsspezifische Gebührenmuster relevant sind
Leistungskritische Anwendungen

Zugehörige Ressourcen

Serialized Transactions

Genauere Methode mit vollständiger Transaktionsserialisierung

API Reference

Vollständige API-Dokumentation und Parameter

Erste Schritte

Streaming von Daten und Event-Überwachung

Daten-APIs und RPCs

Trading

Transaktionen senden

Wallet-as-a-Service

Datenschutz

Ressourcen

Schätzung der Solana-Prioritätsgebühr: Methode mit Kontoschlüsseln

Übersicht

Advanced Use Cases

Trade-offs

Wann du Kontoschlüssel verwenden solltest

Pre-transaction Planning

Simplified Integration

Quick Market Analysis

Multi-account Analysis

Schnellstart

Einfaches Beispiel

Implementierungsleitfaden

Kernfunktion

Vollständiges Beispiel mit mehreren Prioritätsstufen

Kontotypen und Strategien

Erweiterte Konfigurationsoptionen

Best Practices für die Kontoauswahl

Include Writable Accounts

Add Key Programs

Fehlerbehandlung und Fallbacks

Einschränkungen und wichtige Hinweise

Zugehörige Ressourcen

Serialized Transactions

API Reference

​Übersicht

Advanced Use Cases

Trade-offs

​Wann du Kontoschlüssel verwenden solltest

Pre-transaction Planning

Simplified Integration

Quick Market Analysis

Multi-account Analysis

​Schnellstart

​Einfaches Beispiel

​Implementierungsleitfaden

​Kernfunktion

​Vollständiges Beispiel mit mehreren Prioritätsstufen

​Kontotypen und Strategien

​Erweiterte Konfigurationsoptionen

​Best Practices für die Kontoauswahl

Include Writable Accounts

Add Key Programs

​Fehlerbehandlung und Fallbacks

​Einschränkungen und wichtige Hinweise

​Zugehörige Ressourcen

Serialized Transactions

API Reference

Übersicht

Wann du Kontoschlüssel verwenden solltest

Schnellstart

Einfaches Beispiel

Implementierungsleitfaden

Kernfunktion

Vollständiges Beispiel mit mehreren Prioritätsstufen

Kontotypen und Strategien

Erweiterte Konfigurationsoptionen

Best Practices für die Kontoauswahl

Fehlerbehandlung und Fallbacks

Einschränkungen und wichtige Hinweise

Zugehörige Ressourcen