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

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.

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.

Por que Usar Transações Serializadas

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

Melhor Para

Aplicações de produção
Transações complexas
Operações críticas
Máxima precisão necessária

Vantagens Sobre Chaves de Conta

Benefícios de Precisão
Benefícios no Mundo Real

Análise Específica de Instrução

A API pode analisar operações específicas e seus padrões históricos de taxa, não apenas atividade de conta.

Consciência do Tamanho da Transação

Considera o tamanho e complexidade reais da sua transação para estimativas mais precisas.

Manuseio de Conta Somente Leitura

Melhor análise de contas graváveis e somente leitura em seu contexto de transação.

Guia de Implementação

Construa Sua Transação

Crie sua transação com todas as instruções (exceto taxa prioritária)

Serialize a Transação

Converta sua transação para um formato serializado

Obtenha Estimativa de Taxa

Chame a Priority Fee API com sua transação serializada

Aplique a Taxa Prioritária

Adicione a instrução de taxa prioritária e envie sua transação

Exemplo de Início Rápido

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

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

Função de Implementação Principal

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

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

Transferência Simples
Transferência de Token
Multi-Instrução Complexa

Expandir para ver exemplo completo

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

Expandir para ver exemplo completo

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

Expandir para ver exemplo completo

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

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

Incluir Todos os Níveis de Prioridade

Obtenha estimativas para todos os níveis de prioridade de uma vez:

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
}
*/

Incluir Análise Detalhada

Solicitar informações detalhadas sobre o cálculo da taxa:

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.

Período de Retrocesso Personalizado

Ajustar o número de slots analisados:

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

Melhores Práticas

Serialização de Transação

Sempre serialize sua transação real, não uma versão simplificada

// ✅ Good - serialize actual transaction
const transaction = new Transaction();
transaction.add(actualInstruction1);
transaction.add(actualInstruction2);
const serialized = bs58.encode(transaction.serialize());

Ordem de Instrução

Inclua todas as instruções exceto a taxa prioritária em sua transação de estimativa

// ✅ Good - all business logic included
transaction.add(createAccountIx);
transaction.add(initializeIx);
transaction.add(transferIx);

// ❌ Don't include priority fee in estimation

Estratégias de Tratamento de Erros

Tratamento de Erros Robusto
Tratamento de Erros Simples

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

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

Problemas Comuns & Soluções

Erros de Serialização de Transação

Problema: Erro ao serializar transações incompletasSolução: Sempre defina os campos obrigatórios antes da serialização:

// ✅ Always set these fields
transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
transaction.feePayer = keypair.publicKey;

// Then serialize
const serialized = bs58.encode(transaction.serialize());

Problemas de Blockhash Obsoletos

Problema: Uso de blockhash obsoleto causa falhas na transaçãoSolução: Sempre obtenha um blockhash novo antes do envio final:

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

Erros de Transação Grande

Problema: Transação muito grande para serializaçãoSolução: Use transações versionadas ou divida em múltiplas transações:

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

Quando Usar vs Chaves de Conta

Use Transações Serializadas

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

Use Chaves de Conta

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

Recursos Relacionados

Método de Chaves de Conta

Método avançado usando chaves de conta para casos de uso especializados

Referência da API

Documentação completa da API e parâmetros

Primeiros Passos

Transmissão de Dados & Escuta de Eventos

APIs de Dados & RPCs

Negociação

Envio de Transações

Carteira como Serviço

Guias

Recursos

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

Visão Geral

Por que Usar Transações Serializadas

Melhor Para

Vantagens Sobre Chaves de Conta

Análise Específica de Instrução

Consciência do Tamanho da Transação

Manuseio de Conta Somente Leitura

Negociação DeFi

Minting de NFT

Transações Multi-Instrução

Interações com Programas

Guia de Implementação

Exemplo de Início Rápido

Função de Implementação Principal

Exemplos Completos de Implementação

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

Melhores Práticas

Serialização de Transação

Ordem de Instrução

Estratégias de Tratamento de Erros

Problemas Comuns & Soluções

Quando Usar vs Chaves de Conta

Use Transações Serializadas

Use Chaves de Conta

Recursos Relacionados

Método de Chaves de Conta

Referência da API

​Visão Geral

Por que Usar Transações Serializadas

Melhor Para

​Vantagens Sobre Chaves de Conta

Análise Específica de Instrução

Consciência do Tamanho da Transação

Manuseio de Conta Somente Leitura

​Negociação DeFi

​Minting de NFT

​Transações Multi-Instrução

​Interações com Programas

​Guia de Implementação

​Exemplo de Início Rápido

​Função de Implementação Principal

​Exemplos Completos de Implementação

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

​Melhores Práticas

Serialização de Transação

Ordem de Instrução

​Estratégias de Tratamento de Erros

​Problemas Comuns & Soluções

​Quando Usar vs Chaves de Conta

Use Transações Serializadas

Use Chaves de Conta

​Recursos Relacionados

Método de Chaves de Conta

Referência da API

Visão Geral

Vantagens Sobre Chaves de Conta

Negociação DeFi

Minting de NFT

Transações Multi-Instrução

Interações com Programas

Guia de Implementação

Exemplo de Início Rápido

Função de Implementação Principal

Exemplos Completos de Implementação

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

Melhores Práticas

Estratégias de Tratamento de Erros

Problemas Comuns & Soluções

Quando Usar vs Chaves de Conta

Recursos Relacionados