> ## 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. # Como Usar getRecentPrioritizationFees > Aprenda casos de uso do getRecentPrioritizationFees, exemplos de código, parâmetros de solicitação, estrutura de resposta e dicas. O método RPC [`getRecentPrioritizationFees`](https://www.helius.dev/docs/api-reference/rpc/http/getrecentprioritizationfees) fornece insights sobre as taxas de priorização pagas em blocos recentes na rede Solana. Ao examinar essas taxas, os desenvolvedores podem tomar decisões mais informadas sobre a taxa adicional ([taxa de prioridade](https://www.helius.dev/blog/priority-fees-understanding-solanas-transaction-fee-mechanics)) a serem anexadas às suas transações para aumentar a probabilidade de serem processadas prontamente, especialmente durante períodos de alta atividade na rede. Os nós geralmente armazenam em cache dados de taxas de priorização para até 150 blocos recentes. ## Casos de Uso Comuns * **Estimativa Dinâmica de Taxa:** Determine uma taxa de prioridade competitiva para uma transação observando quais taxas foram bem-sucedidas recentemente. * **Análise de Congestionamento:** Entenda o estado atual do congestionamento da rede observando o nível de taxas de prioridade sendo pagas. * **Integração com Carteira:** Permita que carteiras sugiram taxas de prioridade adequadas aos usuários com base nas condições recentes da rede. * **Bots de Arbitragem:** Para operações sensíveis ao tempo, como arbitragem, definir uma taxa de prioridade ideal é crucial para execução oportuna. ## Parâmetros de Solicitação 1. **`lockedWritableAccounts`** (`array` do `string`, opcional): * Um array de chaves públicas codificadas em base-58 de contas que sua transação pretende bloquear para escrita. * Máximo de 128 endereços podem ser fornecidos. * Se fornecido, o método retorna taxas de priorização pagas por transações que bloquearam **todas** as contas especificadas como graváveis. * Se omitido ou um array vazio for passado, o método retorna uma visão mais geral das taxas de priorização observadas em blocos recentes, não específico para qualquer conjunto particular de contas. ## Estrutura de Resposta O campo `result` da resposta JSON-RPC é um array de objetos de taxas de priorização. Cada objeto detalha as taxas de um slot específico recente e tem a seguinte estrutura: * **`slot`** (`u64`): O número do slot no qual as transações que contribuíram para esses dados de taxa foram processadas. * **`prioritizationFee`** (`u64`): A taxa de priorização mínima (em micro-Lamports por Unidade de Cálculo) paga por pelo menos uma transação neste slot (e correspondendo ao filtro `lockedWritableAccounts`, se houver). Um valor de `0` muitas vezes significa que nenhuma transação nesse slot (que corresponda aos critérios) pagou uma taxa de prioridade adicional além da taxa base, ou o nó não observou nenhuma para as contas dadas. ## Exemplos ### 1. Obter Recentes Taxas de Prioridade Globais Este exemplo busca uma lista geral de taxas de priorização recentes sem especificar nenhuma conta bloqueada. ```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. Obter Recentes Taxas de Prioridade para Contas Específicas Graváveis Este exemplo busca taxas de priorização relevantes para uma transação que precisa bloquear para escrita duas contas específicas. ```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(); ``` ## Dicas para Desenvolvedores * **Unidades de Taxa:** As taxas de priorização são expressas em micro-Lamports (0,000001 Lamports) por Unidade de Cálculo (CU). * **Janela de Cache:** Os nós RPC geralmente armazenam essas taxas em cache por cerca de 150 blocos. Isso significa que você está olhando para uma janela histórica relativamente curta (aproximadamente 1-2 minutos). * **Taxas Zero:** Um `prioritizationFee` de `0` não significa necessariamente que nenhuma taxa foi paga, mas sim que para o slot e conta(s) dados, as transações amostradas não incluíram uma taxa de prioridade, ou estavam abaixo de um limite que o nó considera significativo. * **Uso Estratégico:** Não escolha apenas a taxa recente mais alta. Analise a distribuição (por exemplo, mediana, percentil 75 das taxas não zero) para fazer uma escolha econômica. Pagar a mais não garante uma inclusão mais rápida além de certo ponto se o bloco já estiver cheio de transações de alta prioridade. * **Unidades de Cálculo:** A taxa de prioridade total para sua transação será `prioritizationFee_per_CU * your_transaction_compute_units`. Você também precisa definir o limite de unidades de cálculo para sua transação (`ComputeBudgetProgram.setComputeUnitLimit`) e o preço (`ComputeBudgetProgram.setComputeUnitPrice`). Usar `getRecentPrioritizationFees` efetivamente pode melhorar significativamente a confiabilidade da confirmação da transação em condições dinâmicas da rede.