Priority Fee & Simulation APIs

Use getRecentPrioritizationFees, simulateTransaction e APIs de fee de provedor para estimar compute units e priority fees antes de enviar transações.

Receita

Cartão de receita para referência rápida - pronto para copiar e colar.

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

Quando usar:

• Definir priority fees dinâmicas a partir de percentis recentes da rede.
• Estimar consumo de CU para definir instruções de compute budget.
• Preflight checando erros de programa customizado sem aterrissar.
• Depurando falhas de transação em staging.

Exemplo Prático

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

O que isso demonstra:

• RPC de priority fee amostra transações recentes que aterrissaram para orientação de fee.
• Simulação retorna unitsConsumed e logs sem commitar estado (exceto quando configurado).
• replaceRecentBlockhash ajuda a simular txs com blockhashes expirando.

Aprofundamento

Como funciona

• Priority fees são micro-lamports por compute unit pagos a validadores além da base fee.
• getRecentPrioritizationFees retorna observações de fee por slot para conjuntos de account lock.
• simulateTransaction roda SVM contra snapshot de bank no commitment escolhido.
• Provedores podem expor endpoints enhanced priorityFeeEstimate com estatísticas de percentil.

Opções de simulação

Notas TypeScript

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

Erros comuns

• Sucesso na simulação ≠ aterrissagem - congestionamento e blockhashes expirados ainda falham no envio. Correção: combine com blockhash novo e retries de priority fee.
• Priority fee subprecificada - simulação passa mas tx é descartada. Correção: alvo percentil 75-90 com teto.
• sigVerify false escondendo erros de signer - falsos positivos. Correção: preflight final com sigVerify: true antes do envio na mainnet.
• Amostra de prioritization obsoleta - fees disparam durante mints NFT. Correção: atualize fees por lote de envio.
• Ignorar unitsConsumed - limite padrão 200k CU pode ser baixo demais. Correção: defina limite explícito da simulação + 10% de margem.

Alternativas

FAQs

Relacionados

• Estimating Compute Units - margem de CU
• Setting Priority Fees - estratégia de fee
• Simulating Transactions - modelo conceitual
• RPC Providers - APIs enhanced

Versões da stack: Esta página foi escrita para 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 e LiteSVM 0.6.x.