Priority Fee & Simulation APIs

Use getRecentPrioritizationFees, simulateTransaction, and provider fee APIs to estimate compute units and priority fees before sending transactions.

Recipe

Quick-reference recipe card - copy-paste ready.

import { createSolanaRpc, getBase64EncodedWireTransaction } from "@solana/kit";
 
const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");
 
await rpc.getRecentPrioritizationFees([]).send();
await rpc.simulateTransaction(encodedTx, {
  commitment: "processed",
  sigVerify: false,
}).send();

When to reach for this:

• Setting dynamic priority fees from recent network percentiles.
• Estimating CU consumption to set compute budget instructions.
• Preflight checking custom program errors without landing.
• Debugging transaction failures in staging.

Working Example

import { createSolanaRpc } from "@solana/kit";
 
const rpc = createSolanaRpc(process.env.RPC_URL!);
 
// Recent priority fees for relevant accounts (empty = global sample)
const fees = await rpc.getRecentPrioritizationFees([]).send();
const recent = fees.map((f) => f.prioritizationFee).filter((n) => n > 0);
recent.sort((a, b) => a - b);
const p75 = recent[Math.floor(recent.length * 0.75)] ?? 0;
console.log("suggested microLamports CU price (p75):", p75);
 
// Simulate signed or partially signed tx (base64 wire)
const simulation = await rpc
  .simulateTransaction("BASE64_WIRE_TX", {
    commitment: "processed",
    sigVerify: false,
    replaceRecentBlockhash: true,
  })
  .send();
 
console.log("err:", simulation.value.err);
console.log("units:", simulation.value.unitsConsumed);
console.log("logs:", simulation.value.logs?.slice(0, 5));

What this demonstrates:

• Priority fee RPC samples recent landed transactions for fee guidance.
• Simulation returns unitsConsumed and logs without committing state (except when configured).
• replaceRecentBlockhash helps simulate txs with expiring blockhashes.

Deep Dive

How It Works

• Priority fees are micro-lamports per compute unit paid to validators on top of base fee.
• getRecentPrioritizationFees returns per-slot fee observations for account lock sets.
• simulateTransaction runs SVM against bank snapshot at chosen commitment.
• Providers may expose enhanced priorityFeeEstimate endpoints with percentile stats.

Simulation Options

TypeScript Notes

// After simulation, set compute budget ix with headroom
const units = simulation.value.unitsConsumed ?? 200_000;
const limit = Math.ceil(units * 1.1);
const microLamports = Math.max(p75, 1_000);

Gotchas

• Simulation success ≠ landing - congestion and expired blockhashes still fail on send. Fix: combine with fresh blockhash and priority fee retries.
• Underpriced priority fee - simulation passes but tx drops. Fix: target 75th-90th percentile with cap.
• sigVerify false hiding signer errors - false positives. Fix: final preflight with sigVerify: true before mainnet send.
• Stale prioritization sample - fees spike during NFT mints. Fix: refresh fees per send batch.
• Ignoring unitsConsumed - default 200k CU limit may be too low. Fix: set explicit limit from simulation + 10% headroom.

Alternatives

FAQs

Related

• Estimating Compute Units - CU headroom
• Setting Priority Fees - fee strategy
• Simulating Transactions - conceptual model
• RPC Providers - enhanced APIs

Stack versions: This page was written for Agave 4.1.1, Solana CLI 3.0.10, Anchor 0.32.1, anchor-lang 0.32.1, Rust 1.91.1, @solana/kit 7.0.0, Surfpool 0.12.0, and LiteSVM 0.6.x.