> ## 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.

# Estimativa de Taxa Prioritária Solana: Método de Transação Serializada

> Obtenha as estimativas de taxa prioritária mais precisas para Solana usando transações serializadas com a Helius Priority Fee API. Perfeito para aplicações em produção.

<Info>
  **Método Mais Preciso**: Obtenha as estimativas de taxa prioritária de maior precisão ao analisar sua transação exata. Recomendado para aplicações em produção onde a precisão é mais importante.
</Info>

## Visão Geral

Transações serializadas fornecem as estimativas de taxa mais precisas porque a API pode analisar as contas e operações exatas que serão realizadas em sua transação.

<CardGroup cols={2}>
  <Card title="Por que Usar Transações Serializadas" icon="bullseye">
    * **Maior precisão** - Analisa operações exatas
    * **Análise detalhada** - Padrões de instrução específicos
    * **Estimativas realistas** - Reflete a transação real
    * **Pronto para produção** - Projetado para aplicações críticas
  </Card>

  <Card title="Melhor Para" icon="bullseye-pointer">
    * Aplicações de produção
    * Transações complexas
    * Operações críticas
    * Máxima precisão necessária
  </Card>
</CardGroup>

## Vantagens Sobre Chaves de Conta

<Tabs>
  <Tab title="Benefícios de Precisão">
    <CardGroup cols={1}>
      <Card title="Análise Específica de Instrução" icon="code">
        A API pode analisar operações específicas e seus padrões históricos de taxa, não apenas atividade de conta.
      </Card>

      <Card title="Consciência do Tamanho da Transação" icon="expand">
        Considera o tamanho e complexidade reais da sua transação para estimativas mais precisas.
      </Card>

      <Card title="Manuseio de Conta Somente Leitura" icon="eye">
        Melhor análise de contas graváveis e somente leitura em seu contexto de transação.
      </Card>
    </CardGroup>
  </Tab>

  <Tab title="Benefícios no Mundo Real">
    ### Negociação DeFi

    Estimativas mais precisas para operações de swap complexas

    ### Minting de NFT

    Melhores estimativas para transações de mint com metadados específicos

    ### Transações Multi-Instrução

    Taxas precisas para operações complexas de vários passos

    ### Interações com Programas

    Melhores estimativas para chamadas de programas específicas
  </Tab>
</Tabs>

## Guia de Implementação

<Steps>
  <Step title="Construa Sua Transação">
    Crie sua transação com todas as instruções (exceto taxa prioritária)
  </Step>

  <Step title="Serialize a Transação">
    Converta sua transação para um formato serializado
  </Step>

  <Step title="Obtenha Estimativa de Taxa">
    Chame a Priority Fee API com sua transação serializada
  </Step>

  <Step title="Aplique a Taxa Prioritária">
    Adicione a instrução de taxa prioritária e envie sua transação
  </Step>
</Steps>

### Exemplo de Início Rápido

<CodeGroup>
  ```javascript JavaScript theme={"system"}
  import { 
    Connection, 
    PublicKey, 
    Transaction, 
    SystemProgram, 
    ComputeBudgetProgram 
  } from "@solana/web3.js";
  import bs58 from "bs58";

  const connection = new Connection("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY");

  // 1. Build your transaction (without priority fee)
  const transaction = new Transaction();
  const transferIx = SystemProgram.transfer({
    fromPubkey: senderKeypair.publicKey,
    toPubkey: recipientPublicKey,
    lamports: 1000000, // 0.001 SOL
  });
  transaction.add(transferIx);

  // 2. Set required fields and serialize
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.feePayer = senderKeypair.publicKey;
  const serializedTx = bs58.encode(transaction.serialize());

  // 3. Get priority fee estimate
  const priorityFee = await getPriorityFeeEstimate(connection, serializedTx, "Medium");

  // 4. Add priority fee and send
  transaction.instructions = []; // Reset
  transaction.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }));
  transaction.add(transferIx);
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.sign(senderKeypair);
  ```

  ```python Python theme={"system"}
  import requests
  import json
  from solana.transaction import Transaction
  from solana.system_program import transfer, TransferParams

  # Build and serialize transaction
  def get_serialized_transaction():
      # Build your transaction here
      # Return base58 encoded serialized transaction
      pass

  # Get priority fee estimate
  def get_priority_fee_estimate(serialized_tx, priority_level="Medium"):
      response = requests.post(
          "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY",
          json={
              "jsonrpc": "2.0",
              "id": "1",
              "method": "getPriorityFeeEstimate",
              "params": [{
                  "transaction": serialized_tx,
                  "options": {
                      "priorityLevel": priority_level,
                      "recommended": True
                  }
              }]
          }
      )
      return response.json()["result"]["priorityFeeEstimate"]

  # Usage
  serialized_tx = get_serialized_transaction()
  fee = get_priority_fee_estimate(serialized_tx, "High")
  print(f"Priority fee: {fee} micro-lamports")
  ```
</CodeGroup>

## Função de Implementação Principal

Aqui está uma função reutilizável para obter estimativas de taxa prioritária de transações serializadas:

```javascript theme={"system"}
async function getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel = "Medium") {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        transaction: serializedTransaction,
        options: { 
          priorityLevel: priorityLevel,
          recommended: true 
        }
      }]
    })
  });
  
  const result = await response.json();
  
  if (result.error) {
    throw new Error(`Fee estimation failed: ${JSON.stringify(result.error)}`);
  }
  
  return result.result.priorityFeeEstimate;
}
```

## Exemplos Completos de Implementação

<Tabs>
  <Tab title="Transferência Simples">
    <Accordion title="Expandir para ver exemplo completo">
      ```javascript theme={"system"}
      const { 
        Connection, 
        PublicKey, 
        Transaction, 
        SystemProgram, 
        ComputeBudgetProgram, 
        sendAndConfirmTransaction,
        Keypair
      } = require("@solana/web3.js");
      const bs58 = require("bs58");

      // Initialize connection and accounts
      const connection = new Connection("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY");
      const senderKeypair = Keypair.fromSecretKey(bs58.decode("YOUR_PRIVATE_KEY"));
      const receiverPublicKey = new PublicKey("RECIPIENT_PUBLIC_KEY");

      async function sendTransactionWithPriorityFee(amount, priorityLevel = "Medium") {
        // 1. Create transaction with transfer instruction
        const transaction = new Transaction();
        const transferIx = SystemProgram.transfer({
          fromPubkey: senderKeypair.publicKey,
          toPubkey: receiverPublicKey,
          lamports: amount,
        });
        transaction.add(transferIx);
        
        // 2. Set required fields for serialization
        transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
        transaction.feePayer = senderKeypair.publicKey;
        
        // 3. Serialize the transaction
        const serializedTransaction = bs58.encode(transaction.serialize());
        
        // 4. Get priority fee estimate
        const priorityFee = await getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel);
        console.log(`Estimated ${priorityLevel} priority fee: ${priorityFee} micro-lamports`);
        
        // 5. Reset transaction and add priority fee instruction first
        transaction.instructions = [];
        
        // Add priority fee instruction
        const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
          microLamports: priorityFee
        });
        transaction.add(priorityFeeIx);
        
        // Re-add the original transfer instruction
        transaction.add(transferIx);
        
        // 6. Update blockhash and sign
        transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
        transaction.sign(senderKeypair);
        
        // 7. Send the transaction
        try {
          const signature = await sendAndConfirmTransaction(
            connection,
            transaction,
            [senderKeypair],
            { maxRetries: 0 } // Set to 0 for staked connection usage
          );
          console.log(`Transaction successful with signature: ${signature}`);
          return signature;
        } catch (error) {
          console.error("Error sending transaction:", error);
          throw error;
        }
      }

      // Usage
      sendTransactionWithPriorityFee(1000000, "High"); // Send 0.001 SOL with high priority
      ```
    </Accordion>
  </Tab>

  <Tab title="Transferência de Token">
    <Accordion title="Expandir para ver exemplo completo">
      ```javascript theme={"system"}
      const { 
        Connection, 
        PublicKey, 
        Transaction, 
        ComputeBudgetProgram,
        sendAndConfirmTransaction,
        Keypair
      } = require("@solana/web3.js");
      const { 
        createTransferInstruction,
        getAssociatedTokenAddress,
        TOKEN_PROGRAM_ID,
        ASSOCIATED_TOKEN_PROGRAM_ID
      } = require("@solana/spl-token");
      const bs58 = require("bs58");

      async function sendTokenWithPriorityFee(
        connection,
        senderKeypair,
        recipientPublicKey,
        mintAddress,
        amount,
        priorityLevel = "Medium"
      ) {
        // 1. Get token account addresses
        const senderTokenAccount = await getAssociatedTokenAddress(
          mintAddress,
          senderKeypair.publicKey
        );
        
        const recipientTokenAccount = await getAssociatedTokenAddress(
          mintAddress,
          recipientPublicKey
        );
        
        // 2. Create transaction with token transfer instruction
        const transaction = new Transaction();
        const transferIx = createTransferInstruction(
          senderTokenAccount,
          recipientTokenAccount,
          senderKeypair.publicKey,
          amount,
          [],
          TOKEN_PROGRAM_ID
        );
        transaction.add(transferIx);
        
        // 3. Set required fields and serialize
        transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
        transaction.feePayer = senderKeypair.publicKey;
        const serializedTransaction = bs58.encode(transaction.serialize());
        
        // 4. Get priority fee estimate
        const priorityFee = await getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel);
        console.log(`Token transfer priority fee: ${priorityFee} micro-lamports`);
        
        // 5. Reset and rebuild transaction with priority fee
        transaction.instructions = [];
        
        // Add priority fee instruction first
        const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
          microLamports: priorityFee
        });
        transaction.add(priorityFeeIx);
        
        // Re-add the transfer instruction
        transaction.add(transferIx);
        
        // 6. Update blockhash and send
        transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
        transaction.sign(senderKeypair);
        
        const signature = await sendAndConfirmTransaction(
          connection,
          transaction,
          [senderKeypair],
          { maxRetries: 0 }
        );
        
        return signature;
      }
      ```
    </Accordion>
  </Tab>

  <Tab title="Multi-Instrução Complexa">
    <Accordion title="Expandir para ver exemplo completo">
      ```javascript theme={"system"}
      async function complexTransactionWithPriorityFee(connection, keypair) {
        // 1. Build complex transaction with multiple instructions
        const transaction = new Transaction();
        
        // Add multiple instructions
        const createAccountIx = SystemProgram.createAccount({
          fromPubkey: keypair.publicKey,
          newAccountPubkey: newAccountKeypair.publicKey,
          lamports: await connection.getMinimumBalanceForRentExemption(165),
          space: 165,
          programId: TOKEN_PROGRAM_ID,
        });
        
        const initializeAccountIx = createInitializeAccountInstruction(
          newAccountKeypair.publicKey,
          mintAddress,
          keypair.publicKey,
          TOKEN_PROGRAM_ID
        );
        
        const transferIx = SystemProgram.transfer({
          fromPubkey: keypair.publicKey,
          toPubkey: recipientPublicKey,
          lamports: 1000000,
        });
        
        transaction.add(createAccountIx);
        transaction.add(initializeAccountIx);
        transaction.add(transferIx);
        
        // 2. Set required fields and serialize
        transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
        transaction.feePayer = keypair.publicKey;
        const serializedTransaction = bs58.encode(transaction.serialize());
        
        // 3. Get priority fee estimate for complex transaction
        const priorityFee = await getPriorityFeeEstimate(connection, serializedTransaction, "High");
        console.log(`Complex transaction priority fee: ${priorityFee} micro-lamports`);
        
        // 4. Rebuild transaction with priority fee
        transaction.instructions = [];
        
        // Add priority fee instruction first
        const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
          microLamports: priorityFee
        });
        transaction.add(priorityFeeIx);
        
        // Optional: Set compute unit limit for complex transactions
        const computeLimitIx = ComputeBudgetProgram.setComputeUnitLimit({
          units: 400000 // Adjust based on your transaction complexity
        });
        transaction.add(computeLimitIx);
        
        // Re-add all original instructions
        transaction.add(createAccountIx);
        transaction.add(initializeAccountIx);
        transaction.add(transferIx);
        
        // 5. Update blockhash and send
        transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
        transaction.sign(keypair, newAccountKeypair);
        
        const signature = await sendAndConfirmTransaction(
          connection,
          transaction,
          [keypair, newAccountKeypair],
          { maxRetries: 0 }
        );
        
        return signature;
      }
      ```
    </Accordion>
  </Tab>
</Tabs>

## Opções de Configuração Avançadas

<AccordionGroup>
  <Accordion title="Incluir Todos os Níveis de Prioridade">
    Obtenha estimativas para todos os níveis de prioridade de uma vez:

    ```javascript theme={"system"}
    async function getAllPriorityLevels(connection, serializedTransaction) {
      const response = await fetch(connection.rpcEndpoint, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          jsonrpc: "2.0",
          id: "1",
          method: "getPriorityFeeEstimate",
          params: [{
            transaction: serializedTransaction,
            options: { 
              includeAllPriorityFeeLevels: true
            }
          }]
        })
      });
      
      const result = await response.json();
      return result.result.priorityFeeLevels;
    }

    // Usage
    const allLevels = await getAllPriorityLevels(connection, serializedTransaction);
    console.log("All priority levels:", allLevels);
    /*
    Output:
    {
      "min": 0,
      "low": 1000, 
      "medium": 5000,
      "high": 15000,
      "veryHigh": 50000,
      "unsafeMax": 100000
    }
    */
    ```
  </Accordion>

  <Accordion title="Incluir Análise Detalhada">
    Solicitar informações detalhadas sobre o cálculo da taxa:

    ```javascript theme={"system"}
    async function getDetailedFeeAnalysis(connection, serializedTransaction) {
      const response = await fetch(connection.rpcEndpoint, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          jsonrpc: "2.0",
          id: "1",
          method: "getPriorityFeeEstimate",
          params: [{
            transaction: serializedTransaction,
            options: { 
              includeDetails: true,
              priorityLevel: "Medium"
            }
          }]
        })
      });
      
      const result = await response.json();
      console.log("Detailed analysis:", result.result);
      return result.result;
    }
    ```

    Isso fornece insights sobre como a taxa foi calculada, incluindo análise por conta.
  </Accordion>

  <Accordion title="Período de Retrocesso Personalizado">
    Ajustar o número de slots analisados:

    ```javascript theme={"system"}
    async function getCustomLookbackEstimate(connection, serializedTransaction, lookbackSlots = 50) {
      const response = await fetch(connection.rpcEndpoint, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          jsonrpc: "2.0",
          id: "1",
          method: "getPriorityFeeEstimate",
          params: [{
            transaction: serializedTransaction,
            options: { 
              priorityLevel: "Medium",
              lookbackSlots: lookbackSlots  // 1-150, default is 150
            }
          }]
        })
      });
      
      const result = await response.json();
      return result.result.priorityFeeEstimate;
    }

    // Compare different lookback periods
    const recentEstimate = await getCustomLookbackEstimate(connection, serializedTx, 30);
    const longerEstimate = await getCustomLookbackEstimate(connection, serializedTx, 100);

    console.log(`Recent (30 slots): ${recentEstimate} micro-lamports`);
    console.log(`Longer (100 slots): ${longerEstimate} micro-lamports`);
    ```
  </Accordion>
</AccordionGroup>

## Melhores Práticas

<CardGroup cols={1}>
  <Card title="Serialização de Transação" icon="code">
    **Sempre serialize sua transação real**, não uma versão simplificada

    ```javascript theme={"system"}
    // ✅ Good - serialize actual transaction
    const transaction = new Transaction();
    transaction.add(actualInstruction1);
    transaction.add(actualInstruction2);
    const serialized = bs58.encode(transaction.serialize());
    ```
  </Card>

  <Card title="Ordem de Instrução" icon="list">
    **Inclua todas as instruções exceto a taxa prioritária** em sua transação de estimativa

    ```javascript theme={"system"}
    // ✅ Good - all business logic included
    transaction.add(createAccountIx);
    transaction.add(initializeIx);
    transaction.add(transferIx);

    // ❌ Don't include priority fee in estimation
    ```
  </Card>
</CardGroup>

## Estratégias de Tratamento de Erros

<Tabs>
  <Tab title="Tratamento de Erros Robusto">
    ```javascript theme={"system"}
    class SerializedTransactionFeeEstimator {
      constructor(connection) {
        this.connection = connection;
        this.fallbackFee = 10000; // 10k micro-lamports
      }

      async getEstimate(serializedTransaction, priorityLevel = "Medium") {
        try {
          // Primary attempt with serialized transaction
          return await this.getPrimaryEstimate(serializedTransaction, priorityLevel);
        } catch (error) {
          console.warn("Serialized transaction estimate failed:", error.message);
          
          // Fallback to account-based estimation
          try {
            return await this.getFallbackEstimate(serializedTransaction, priorityLevel);
          } catch (fallbackError) {
            console.warn("Fallback estimate failed:", fallbackError.message);
            return this.getFallbackFee(priorityLevel);
          }
        }
      }

      async getPrimaryEstimate(serializedTransaction, priorityLevel) {
        const response = await fetch(this.connection.rpcEndpoint, {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            jsonrpc: "2.0",
            id: "1",
            method: "getPriorityFeeEstimate",
            params: [{
              transaction: serializedTransaction,
              options: { 
                priorityLevel: priorityLevel,
                recommended: true 
              }
            }]
          })
        });

        const result = await response.json();
        if (result.error) {
          throw new Error(result.error.message);
        }
        
        return result.result.priorityFeeEstimate;
      }

      async getFallbackEstimate(serializedTransaction, priorityLevel) {
        // Extract account keys from transaction and use account-based estimation
        const transaction = Transaction.from(bs58.decode(serializedTransaction));
        const accountKeys = transaction.instructions
          .flatMap(ix => [ix.programId, ...ix.keys.map(k => k.pubkey)])
          .map(key => key.toString());

        const uniqueAccountKeys = [...new Set(accountKeys)];
        
        // Use account-based estimation as fallback
        const response = await fetch(this.connection.rpcEndpoint, {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            jsonrpc: "2.0",
            id: "1",
            method: "getPriorityFeeEstimate",
            params: [{
              accountKeys: uniqueAccountKeys,
              options: { 
                priorityLevel: priorityLevel,
                recommended: true 
              }
            }]
          })
        });

        const result = await response.json();
        if (result.error) {
          throw new Error(result.error.message);
        }
        
        return result.result.priorityFeeEstimate;
      }

      getFallbackFee(priorityLevel) {
        const fallbacks = {
          "Low": 1000,
          "Medium": 5000,
          "High": 15000,
          "VeryHigh": 50000
        };
        
        return fallbacks[priorityLevel] || 5000;
      }
    }

    // Usage
    const estimator = new SerializedTransactionFeeEstimator(connection);
    const fee = await estimator.getEstimate(serializedTransaction, "High");
    ```
  </Tab>

  <Tab title="Tratamento de Erros Simples">
    ```javascript theme={"system"}
    async function safeGetPriorityFeeEstimate(connection, serializedTransaction, priorityLevel = "Medium") {
      try {
        return await getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel);
      } catch (error) {
        console.warn(`Priority fee estimation failed: ${error.message}`);
        
        // Extract account keys and fall back to account-based estimation
        try {
          const transaction = Transaction.from(bs58.decode(serializedTransaction));
          const accountKeys = transaction.instructions
            .flatMap(ix => [ix.programId, ...ix.keys.map(k => k.pubkey)])
            .map(key => key.toString());
          
          const uniqueAccountKeys = [...new Set(accountKeys)];
          return await getAccountBasedEstimate(connection, uniqueAccountKeys, priorityLevel);
        } catch (fallbackError) {
          console.warn(`Fallback estimation failed: ${fallbackError.message}`);
          
          // Return reasonable fallback based on priority level
          const fallbacks = {
            "Low": 1000,
            "Medium": 5000,
            "High": 15000,
            "VeryHigh": 50000
          };
          
          return fallbacks[priorityLevel] || 5000;
        }
      }
    }
    ```
  </Tab>
</Tabs>

## Problemas Comuns & Soluções

<AccordionGroup>
  <Accordion title="Erros de Serialização de Transação">
    **Problema**: Erro ao serializar transações incompletas

    **Solução**: Sempre defina os campos obrigatórios antes da serialização:

    ```javascript theme={"system"}
    // ✅ Always set these fields
    transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
    transaction.feePayer = keypair.publicKey;

    // Then serialize
    const serialized = bs58.encode(transaction.serialize());
    ```
  </Accordion>

  <Accordion title="Problemas de Blockhash Obsoletos">
    **Problema**: Uso de blockhash obsoleto causa falhas na transação

    **Solução**: Sempre obtenha um blockhash novo antes do envio final:

    ```javascript theme={"system"}
    // Get estimate with temporary blockhash
    const tempBlockhash = (await connection.getLatestBlockhash()).blockhash;
    transaction.recentBlockhash = tempBlockhash;
    const serialized = bs58.encode(transaction.serialize());

    const priorityFee = await getPriorityFeeEstimate(connection, serialized, "Medium");

    // Reset and rebuild with fresh blockhash
    transaction.instructions = [];
    transaction.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }));
    transaction.add(originalInstruction);

    // Get FRESH blockhash before sending
    const freshBlockhash = (await connection.getLatestBlockhash()).blockhash;
    transaction.recentBlockhash = freshBlockhash;
    ```
  </Accordion>

  <Accordion title="Erros de Transação Grande">
    **Problema**: Transação muito grande para serialização

    **Solução**: Use transações versionadas ou divida em múltiplas transações:

    ```javascript theme={"system"}
    import { VersionedTransaction, TransactionMessage } from "@solana/web3.js";

    // For large transactions, use versioned transactions
    const messageV0 = new TransactionMessage({
      payerKey: keypair.publicKey,
      recentBlockhash: (await connection.getLatestBlockhash()).blockhash,
      instructions: [instruction1, instruction2, instruction3] // Many instructions
    }).compileToV0Message();

    const versionedTransaction = new VersionedTransaction(messageV0);
    const serialized = bs58.encode(versionedTransaction.serialize());
    ```
  </Accordion>
</AccordionGroup>

## Quando Usar vs Chaves de Conta

<CardGroup cols={2}>
  <Card title="Use Transações Serializadas" icon="check">
    **Aplicações de produção**

    * Máxima precisão necessária
    * Transações complexas de múltiplas instruções
    * Operações críticas
    * Aplicações sensíveis ao desempenho

    **Cenários de desenvolvimento**

    * Testes de integração final
    * Otimização de desempenho
    * Implantação em produção
  </Card>

  <Card title="Use Chaves de Conta" icon="info">
    **Desenvolvimento & prototipagem**

    * Estimativas rápidas durante o desenvolvimento
    * Transações simples
    * Planejamento pré-transação
    * Restrições de arquitetura impedindo serialização

    **Cenários de análise**

    * Análise de padrões de taxa a nível de conta
    * Análise em lotes de contas
    * Pesquisa rápida de mercado
  </Card>
</CardGroup>

## Recursos Relacionados

<CardGroup cols={2}>
  <Card title="Método de Chaves de Conta" icon="key" href="/docs/pt-BR/priority-fee/estimating-fees-using-account-keys">
    Método avançado usando chaves de conta para casos de uso especializados
  </Card>

  <Card title="Referência da API" icon="book" href="/docs/pt-BR/api-reference/priority-fee/getpriorityfeeestimate">
    Documentação completa da API e parâmetros
  </Card>
</CardGroup>