Estimasi Biaya Prioritas Solana: Metode Kunci Akun

Metode Lanjutan: Dapatkan estimasi biaya prioritas menggunakan kunci akun untuk kasus penggunaan khusus seperti analisis pra-transaksi, operasi batch, dan riset pola akun.

Ikhtisar

Metode kunci akun menyediakan alternatif yang lebih sederhana daripada serialisasi transaksi ketika Anda memerlukan estimasi biaya cepat atau ingin memperkirakan biaya sebelum membuat transaksi lengkap.

Advanced Use Cases

Analisis pra-transaksi
Operasi akun secara batch
Riset dan pola pasar
Arsitektur khusus

Trade-offs

Kurang akurat dibandingkan transaksi yang diserialisasi
Tidak ada analisis khusus instruksi
Paling sesuai untuk pola tingkat akun

Rekomendasi: Untuk sebagian besar aplikasi, gunakan metode transaksi yang diserialisasi. Metode kunci akun ini ditujukan untuk kasus penggunaan khusus ketika Anda memerlukan analisis tingkat akun atau perencanaan pra-transaksi.

Kapan Harus Menggunakan Kunci Akun

Ideal Use Cases
Specialized Scenarios

Pre-transaction Planning

Dapatkan estimasi biaya sebelum membuat transaksi lengkap

Simplified Integration

Ketika arsitektur Anda menyulitkan serialisasi transaksi

Quick Market Analysis

Analisis pola biaya untuk akun tertentu tanpa membuat transaksi

Multi-account Analysis

Pahami pola biaya di beberapa akun secara terpisah

Mulai Cepat

Identify Accounts

Tentukan akun yang akan terlibat dalam transaksi Anda

Call the API

Buat permintaan dengan kunci akun dan tingkat prioritas yang diinginkan

Apply the Fee

Gunakan estimasi tersebut untuk menetapkan biaya prioritas dalam transaksi Anda

Contoh Dasar

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

Panduan Implementasi

Fungsi Inti

Berikut adalah fungsi yang dapat digunakan kembali untuk mendapatkan estimasi biaya prioritas:

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

Contoh Lengkap dengan Beberapa Tingkat Prioritas

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

Jenis Akun & Strategi

Program Accounts
User Wallets
Token Accounts

Akun program bervolume tinggi biasanya menunjukkan biaya prioritas yang lebih tinggi akibat persaingan.

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

Perilaku yang diharapkan: Biaya lebih tinggi akibat volume transaksi dan persaingan yang tinggi.

Dompet pengguna aktif mungkin memiliki pola biaya yang berbeda berdasarkan aktivitasnya.

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

Kiat profesional: Sertakan dompet pengirim dan penerima untuk mendapatkan estimasi yang lebih akurat.

Akun token tertentu dapat menunjukkan pola yang berbeda-beda berdasarkan popularitas token.

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

Opsi Konfigurasi Lanjutan

Empty Slot Evaluation

Opsi evaluateEmptySlotAsZero sangat berguna untuk estimasi berbasis akun:

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

Ketika true (bawaan), slot tanpa transaksi diperlakukan sebagai biaya nol, bukan dikecualikan. Hal ini memberikan estimasi yang lebih seimbang untuk akun dengan aktivitas yang jarang.

Include Details

Minta informasi terperinci tentang pola biaya setiap akun:

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

Ini mengembalikan informasi tambahan tentang cara biaya dihitung untuk setiap akun.

Custom Lookback Period

Sesuaikan jumlah slot yang dianalisis untuk estimasi biaya:

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

Periode peninjauan lebih pendek: Data lebih baru yang mungkin lebih fluktuatifPeriode peninjauan lebih panjang: Konteks historis yang lebih stabil

Praktik Terbaik untuk Pemilihan Akun

Include Writable Accounts

Prioritas: Fokus pada akun yang akan diubah

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

Add Key Programs

Konteks: Sertakan akun program yang relevan

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

Penanganan Kesalahan & Fallback

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

Keterbatasan & Pertimbangan

Keterbatasan metode berbasis akun:

Kurang akurat untuk akun hanya-baca - Algoritma berfokus pada akun yang dapat ditulis
Tidak ada analisis khusus instruksi - Tidak dapat mempertimbangkan operasi tertentu
Bergantung pada aktivitas akun - Kurang akurat untuk akun yang tidak aktif
Tidak mempertimbangkan ukuran transaksi - Tidak memperhitungkan kompleksitas transaksi

Kapan harus beralih ke transaksi yang diserialisasi:

Aplikasi produksi yang memerlukan akurasi tertinggi
Transaksi kompleks dengan beberapa instruksi
Ketika pola biaya khusus instruksi penting
Aplikasi yang sangat mementingkan performa

Sumber Daya Terkait

Serialized Transactions

Metode yang lebih akurat menggunakan serialisasi transaksi penuh

API Reference

Dokumentasi dan parameter API lengkap

Memulai

Streaming Data & Pemantauan Peristiwa

API Data & RPC

Perdagangan

Mengirim Transaksi

Dompet sebagai Layanan

Privasi

Sumber Daya

Estimasi Biaya Prioritas Solana: Metode Kunci Akun

Ikhtisar

Advanced Use Cases

Trade-offs

Kapan Harus Menggunakan Kunci Akun

Pre-transaction Planning

Simplified Integration

Quick Market Analysis

Multi-account Analysis

Mulai Cepat

Contoh Dasar

Panduan Implementasi

Fungsi Inti

Contoh Lengkap dengan Beberapa Tingkat Prioritas

Jenis Akun & Strategi

Opsi Konfigurasi Lanjutan

Praktik Terbaik untuk Pemilihan Akun

Include Writable Accounts

Add Key Programs

Penanganan Kesalahan & Fallback

Keterbatasan & Pertimbangan

Sumber Daya Terkait

Serialized Transactions

API Reference

​Ikhtisar

Advanced Use Cases

Trade-offs

​Kapan Harus Menggunakan Kunci Akun

Pre-transaction Planning

Simplified Integration

Quick Market Analysis

Multi-account Analysis

​Mulai Cepat

​Contoh Dasar

​Panduan Implementasi

​Fungsi Inti

​Contoh Lengkap dengan Beberapa Tingkat Prioritas

​Jenis Akun & Strategi

​Opsi Konfigurasi Lanjutan

​Praktik Terbaik untuk Pemilihan Akun

Include Writable Accounts

Add Key Programs

​Penanganan Kesalahan & Fallback

​Keterbatasan & Pertimbangan

​Sumber Daya Terkait

Serialized Transactions

API Reference

Ikhtisar

Kapan Harus Menggunakan Kunci Akun

Mulai Cepat

Contoh Dasar

Panduan Implementasi

Fungsi Inti

Contoh Lengkap dengan Beberapa Tingkat Prioritas

Jenis Akun & Strategi

Opsi Konfigurasi Lanjutan

Praktik Terbaik untuk Pemilihan Akun

Penanganan Kesalahan & Fallback

Keterbatasan & Pertimbangan

Sumber Daya Terkait