Priority fees are an optional fee you can add to your transactions to incentivize block producers (leaders) to include your transaction in the next block. Priority fees are priced in micro-lamports per compute unit. It is recommended to include a priority fee in your transactions, but how much should you pay?
Helius Priority Fee API
The getPriorityFeeEstimate is a new RPC method that provides fee recommendations based on historical data. Most importantly, it considers both global and local fee markets.
For example, say you wanted to submit a swap on Jupiter. You could make the following request:
The method uses a set of predefined priority levels (percentiles) to dictate the returned estimate. Users can optionally specify to receive all the priority levels and adjust the window with which these are calculated via lookbackSlots
fnget_recent_priority_fee_estimate(request:GetPriorityFeeEstimateRequest) ->GetPriorityFeeEstimateResponsestructGetPriorityFeeEstimateRequest { transaction:Option<String>, // estimate fee for a serialized txn account_keys:Option<Vec<String>>, // estimate fee for a list of accounts options:Option<GetPriorityFeeEstimateOptions>}structGetPriorityFeeEstimateOptions { priority_level:Option<PriorityLevel>, // Default to MEDIUM include_all_priority_fee_levels:Option<bool>, // Include all priority level estimates in the response transaction_encoding:Option<UiTransactionEncoding>, // Default Base58 lookback_slots: Option<u8>, // The number of slots to look back to calculate the estimate. Valid numbers are 1-150, default is 150
recommended:Option<bool>, // The Helius recommended fee for landing transactions include_vote:Option<bool>, // Include vote transactions in the priority fee estimate calculation. Default to true }enumPriorityLevel { MIN, // 0th percentile LOW, // 25th percentile MEDIUM, // 50th percentile HIGH, // 75th percentile VERY_HIGH, // 95th percentile// labelled unsafe to prevent people from using and draining their funds by accident UNSAFE_MAX, // 100th percentile DEFAULT, // 50th percentile}structGetPriorityFeeEstimateResponse { priority_fee_estimate:Option<MicroLamportPriorityFee> priority_fee_levels:Option<MicroLamportPriorityFeeLevels>}typeMicroLamportPriorityFee=f64structMicroLamportPriorityFeeLevels { min:f64, low:f64, medium:f64, high:f64, very_high:f64, unsafe_max:f64,}
Sending a transaction with the Priority Fee API (Javascript)
This code snippet showcases how one can transfer SOL from one account to another. In this code, the transaction is passed to the priority fee API which then determines the specified priority fee from all the accounts involved in the transaction.
const {Connection,SystemProgram,Transaction,sendAndConfirmTransaction,Keypair,ComputeBudgetProgram,} =require("@solana/web3.js");constbs58=require("bs58");constHeliusURL="https://mainnet.helius-rpc.com/?api-key=<YOUR_API_KEY>";constconnection=newConnection(HeliusURL);constfromKeypair=Keypair.fromSecretKey(Uint8Array.from("[Your secret key]")); // Replace with your own private keyconst toPubkey = "CckxW6C1CjsxYcXSiDbk7NYfPLhfqAm3kSB5LEZunnSE"; // Replace with the public key that you want to send SOL to
asyncfunctiongetPriorityFeeEstimate(priorityLevel, transaction) {constresponse=awaitfetch(HeliusURL, { method:"POST", headers: { "Content-Type":"application/json" }, body:JSON.stringify({ jsonrpc:"2.0", id:"1", method:"getPriorityFeeEstimate", params: [ { transaction:bs58.encode(transaction.serialize()),// Pass the serialized transaction in Base58 options: { priorityLevel: priorityLevel }, }, ], }), });constdata=awaitresponse.json();console.log("Fee in function for", priorityLevel," :",data.result.priorityFeeEstimate );returndata.result;}asyncfunctionsendTransactionWithPriorityFee(priorityLevel) {consttransaction=newTransaction();consttransferIx=SystemProgram.transfer({ fromPubkey:fromKeypair.publicKey, toPubkey, lamports:100, });transaction.add(transferIx);transaction.recentBlockhash= (awaitconnection.getLatestBlockhash() ).blockhash;transaction.sign(fromKeypair);let feeEstimate = { priorityFeeEstimate:0 };if (priorityLevel !=="NONE") { feeEstimate =awaitgetPriorityFeeEstimate(priorityLevel, transaction);constcomputePriceIx=ComputeBudgetProgram.setComputeUnitPrice({ microLamports:feeEstimate.priorityFeeEstimate, });transaction.add(computePriceIx); }try {consttxid=awaitsendAndConfirmTransaction(connection, transaction, [ fromKeypair, ]);console.log(`Transaction sent successfully with signature ${txid}`); } catch (e) {console.error(`Failed to send transaction: ${e}`); }}sendTransactionWithPriorityFee("High"); // Choose between "Min", "Low", "Medium", "High", "VeryHigh", "UnsafeMax"
(Appendix) Calculating the Percentiles
To calculate the percentiles, we need to consider the global and local fee market over transactions in the last N slots
where txn_fees are the txn_fees from the last 150 blocks, and account_fees(accounts) are the fees for transactions containing these accounts from the last 150 blocks. Here, we are considering the total set of fees seen for accounts and transactions as opposed to the minimum.
Global Fee Market Estimate
The global fee market estimate is a percentile of priority fees paid for transactions in the last N slots.
Local Fee Market Estimate
The local fee market is influenced by the number of people trying to obtain a lock on an account. We can estimate this similarly to the global fee market but instead use the percentile of fees paid for transactions involving a given account(s). If a user requests an estimate for multiple accounts in the same transaction, we will take the max of the percentiles across those accounts.
Priority Fee Estimate
The priority_fee_estimate will be the max of the global and local fee market estimates.
Extensions
This method could also be integrated into simulateTransaction and returned with the response context. This way, developers using simulateTransaction can eliminate an extra RPC call.