> ## 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.
# Cara Menggunakan getRecentPrioritizationFees
> Pelajari kasus penggunaan getRecentPrioritizationFees, contoh kode, parameter permintaan, struktur respons, dan tips.
Metode RPC [`getRecentPrioritizationFees`](https://www.helius.dev/docs/api-reference/rpc/http/getrecentprioritizationfees) memberikan informasi tentang biaya prioritas yang dibayarkan dalam blok terbaru di jaringan Solana. Dengan memeriksa biaya ini, developer dapat membuat keputusan yang lebih tepat mengenai biaya tambahan ([biaya prioritas](https://www.helius.dev/blog/priority-fees-understanding-solanas-transaction-fee-mechanics)) yang akan ditambahkan ke transaksi mereka untuk meningkatkan kemungkinan transaksi diproses dengan cepat, terutama selama periode aktivitas jaringan yang tinggi.
Node biasanya menyimpan data biaya prioritas dalam cache hingga 150 blok terbaru.
## Kasus Penggunaan Umum
* **Estimasi Biaya Dinamis:** Tentukan biaya prioritas yang kompetitif untuk suatu transaksi dengan mengamati biaya yang baru-baru ini berhasil digunakan.
* **Analisis Kemacetan:** Pahami kondisi kemacetan jaringan saat ini dengan melihat tingkat biaya prioritas yang dibayarkan.
* **Integrasi Dompet:** Memungkinkan dompet menyarankan biaya prioritas yang sesuai kepada pengguna berdasarkan kondisi jaringan terbaru.
* **Bot Arbitrase:** Untuk operasi yang sensitif terhadap waktu seperti arbitrase, menetapkan biaya prioritas yang optimal sangat penting agar eksekusi berlangsung tepat waktu.
## Parameter Permintaan
1. **`lockedWritableAccounts`** (`array` dari `string`, opsional):
* Array berisi kunci publik akun yang dikodekan dalam base-58 dan ingin dikunci untuk penulisan oleh transaksi Anda.
* Maksimal 128 alamat dapat diberikan.
* Jika diberikan, metode ini mengembalikan biaya prioritas yang dibayarkan oleh transaksi yang mengunci **semua** akun yang ditentukan sebagai dapat ditulis.
* Jika tidak diberikan atau array kosong diteruskan, metode ini mengembalikan gambaran yang lebih umum tentang biaya prioritas yang diamati di berbagai blok terbaru, tanpa terbatas pada kumpulan akun tertentu.
## Struktur Respons
Kolom `result` dalam respons JSON-RPC adalah array objek biaya prioritas. Setiap objek merinci biaya dari slot terbaru tertentu dan memiliki struktur berikut:
* **`slot`** (`u64`): Nomor slot tempat transaksi yang berkontribusi pada data biaya ini diproses.
* **`prioritizationFee`** (`u64`): Biaya prioritas minimum (dalam mikro-Lamport per Compute Unit) yang dibayarkan oleh setidaknya satu transaksi dalam slot ini (dan sesuai dengan filter `lockedWritableAccounts`, jika ada). Nilai `0` sering kali berarti tidak ada transaksi dalam slot tersebut (yang sesuai dengan kriteria) yang membayar biaya prioritas tambahan di luar biaya dasar, atau node tidak mengamati transaksi semacam itu untuk akun yang diberikan.
## Contoh
### 1. Mendapatkan Biaya Prioritas Global Terbaru
Contoh ini mengambil daftar umum biaya prioritas terbaru tanpa menentukan akun yang dikunci.
```bash cURL theme={"system"}
# Replace with your Helius API key
curl https://mainnet.helius-rpc.com/?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 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=');
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();
```
### 2. Mendapatkan Biaya Prioritas Terbaru untuk Akun Tertentu yang Dapat Ditulis
Contoh ini mengambil biaya prioritas yang relevan untuk transaksi yang perlu mengunci dua akun tertentu untuk penulisan.
```bash cURL theme={"system"}
# Replace with your Helius API key
# Replace with actual public keys you are interested in
curl https://mainnet.helius-rpc.com/?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 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=');
// 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();
```
## Tips untuk Developer
* **Satuan Biaya:** Biaya prioritas dinyatakan dalam mikro-Lamport (0,000001 Lamport) per Compute Unit (CU).
* **Rentang Cache:** Node RPC biasanya menyimpan biaya ini dalam cache selama sekitar 150 blok. Artinya, Anda melihat rentang historis yang relatif singkat (sekitar 1–2 menit).
* **Biaya Nol:** `prioritizationFee` dengan nilai `0` tidak selalu berarti tidak ada biaya yang dibayarkan, tetapi untuk slot dan akun yang diberikan, transaksi yang dijadikan sampel tidak menyertakan biaya prioritas atau berada di bawah ambang batas yang dianggap signifikan oleh node.
* **Penggunaan Strategis:** Jangan hanya memilih biaya terbaru yang tertinggi. Analisis distribusinya (misalnya, median atau persentil ke-75 dari biaya yang bukan nol) untuk membuat pilihan yang hemat biaya. Membayar terlalu mahal tidak menjamin penyertaan yang lebih cepat setelah titik tertentu jika blok sudah penuh dengan transaksi berprioritas tinggi.
* **Compute Unit:** Total biaya prioritas untuk transaksi Anda adalah `prioritizationFee_per_CU * your_transaction_compute_units`. Anda juga perlu menetapkan batas compute unit untuk transaksi Anda (`ComputeBudgetProgram.setComputeUnitLimit`) dan harganya (`ComputeBudgetProgram.setComputeUnitPrice`).
Menggunakan `getRecentPrioritizationFees` secara efektif dapat meningkatkan keandalan konfirmasi transaksi secara signifikan dalam kondisi jaringan yang dinamis.