Estimativa de Taxa Prioritária Solana: Método de Chaves de Conta

Método Avançado: Obtenha estimativas de taxa prioritária usando chaves de conta para casos de uso especializado, como análise pré-transação, operações em lote e pesquisa de padrões de conta.

Visão Geral

O método de chaves de conta fornece uma alternativa mais simples à serialização de transações quando você precisa de estimativas rápidas de taxas ou deseja estimar taxas antes de construir a transação completa.

Casos de Uso Avançados

Análise pré-transação
Operações de conta em lote
Pesquisa de mercado e padrões
Arquiteturas especializadas

Compromissos

Menos preciso que transações serializadas
Sem análise específica de instruções
Melhor para padrões a nível de conta

Recomendação: Para a maioria das aplicações, use o método de transação serializada em vez disso. Este método de chaves de conta é para casos de uso especializado onde você precisa de análise a nível de conta ou planejamento pré-transação.

Quando Usar Chaves de Conta

Casos de Uso Ideais
Cenários Especializados

Planejamento Pré-transação

Obtenha estimativas de taxa antes de construir transações completas

Integração Simplificada

Quando sua arquitetura torna a serialização de transações difícil

Análise Rápida de Mercado

Analise padrões de taxa para contas específicas sem construir transações

Análise Multi-conta

Entenda padrões de taxa em várias contas de forma independente

Início Rápido

Identificar Contas

Determine quais contas estarão envolvidas na sua transação

Chamar a API

Faça uma solicitação com as chaves de conta e o nível de prioridade desejado

Aplicar a Taxa

Use a estimativa para definir a taxa prioritária na sua transação

Exemplo Básico

import { ComputeBudgetProgram } from "@solana/web3.js";

// 1. Identify accounts involved in your transaction
const accountKeys = [
  "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token program
  "YOUR_WALLET_ADDRESS",                          // Your wallet
  "RECIPIENT_ADDRESS"                             // Recipient
];

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

// 3. Add to your transaction
const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
  microLamports: priorityFee
});
transaction.add(priorityFeeIx);

import requests

# Get priority fee estimate
def get_priority_fee_estimate(account_keys, 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": [{
                "accountKeys": account_keys,
                "options": {
                    "priorityLevel": priority_level,
                    "recommended": True
                }
            }]
        }
    )
    return response.json()["result"]["priorityFeeEstimate"]

# Usage
accounts = ["ACCOUNT_1", "ACCOUNT_2", "ACCOUNT_3"]
fee = get_priority_fee_estimate(accounts, "High")
print(f"Priority fee: {fee} micro-lamports")

Guia de Implementação

Função Principal

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

async function getPriorityFeeEstimate(connection, accountKeys, 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: [{
        accountKeys: accountKeys,
        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;
}

Exemplo Completo com Múltiplos Níveis de Prioridade

Expandir para ver a implementação completa

const { 
  Connection, 
  PublicKey, 
  Transaction, 
  ComputeBudgetProgram 
} = require("@solana/web3.js");

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

async function analyzeAccountPriorityFees() {
  // Define accounts involved in your transaction
  const accountKeys = [
    "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token program
    "YOUR_WALLET_ADDRESS",                          // Your wallet
    "TOKEN_ACCOUNT_ADDRESS",                        // Token account
    "RECIPIENT_ADDRESS"                             // Recipient
  ];
  
  try {
    // Get estimates for different priority levels
    const [lowFee, mediumFee, highFee, veryHighFee] = await Promise.all([
      getPriorityFeeEstimate(connection, accountKeys, "Low"),
      getPriorityFeeEstimate(connection, accountKeys, "Medium"), 
      getPriorityFeeEstimate(connection, accountKeys, "High"),
      getPriorityFeeEstimate(connection, accountKeys, "VeryHigh")
    ]);
    
    console.log("Priority Fee Estimates:");
    console.log(`Low:      ${lowFee} micro-lamports`);
    console.log(`Medium:   ${mediumFee} micro-lamports`);
    console.log(`High:     ${highFee} micro-lamports`);
    console.log(`VeryHigh: ${veryHighFee} micro-lamports`);
    
    // Get all levels at once for comparison
    const allLevels = await getAllPriorityLevels(connection, accountKeys);
    console.log("\nAll priority levels:", allLevels);
    
    return {
      low: lowFee,
      medium: mediumFee,
      high: highFee,
      veryHigh: veryHighFee,
      allLevels
    };
  } catch (error) {
    console.error("Error getting priority fees:", error);
    throw error;
  }
}

// Helper function to get all priority levels
async function getAllPriorityLevels(connection, accountKeys) {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        accountKeys: accountKeys,
        options: { 
          includeAllPriorityFeeLevels: true
        }
      }]
    })
  });
  
  const result = await response.json();
  
  if (result.error) {
    throw new Error(`Fee estimation failed: ${JSON.stringify(result.error)}`);
  }
  
  return result.result.priorityFeeLevels;
}

// Run the analysis
analyzeAccountPriorityFees();

Tipos de Conta & Estratégias

Contas de Programa
Carteiras de Usuário
Contas de Token

Contas de programa de alto volume normalmente mostram taxas prioritárias mais altas devido à concorrência.

// Popular program accounts
const programAccounts = [
  "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token program
  "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", // Associated token program
  "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K"  // Metaplex program
];

const programFees = await getPriorityFeeEstimate(connection, programAccounts, "Medium");
console.log(`Program account fees: ${programFees} micro-lamports`);

Comportamento esperado: Taxas mais altas devido ao alto volume de transações e concorrência.

Carteiras de usuário ativas podem ter diferentes padrões de taxa com base em sua atividade.

// Active user wallets
const userWallets = [
  "USER_WALLET_1", // Active trader
  "USER_WALLET_2"  // Regular user
];

const walletFees = await getPriorityFeeEstimate(connection, userWallets, "Medium");
console.log(`User wallet fees: ${walletFees} micro-lamports`);

Dica pro: Inclua tanto as carteiras de remetente quanto de destinatário para estimativas mais precisas.

Contas de tokens específicos podem mostrar padrões variados com base na popularidade do token.

// Popular token accounts
const tokenAccounts = [
  "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC mint
  "So11111111111111111111111111111111111111112",  // SOL mint
  "YOUR_TOKEN_ACCOUNT"                            // Your specific token account
];

const tokenFees = await getPriorityFeeEstimate(connection, tokenAccounts, "Medium");

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

Avaliação de Slot Vazio

A opção evaluateEmptySlotAsZero é particularmente útil para estimativas baseadas em conta:

async function compareEmptySlotHandling(accountKeys) {
  const withEmptyAsZero = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        accountKeys: accountKeys,
        options: { 
          priorityLevel: "Medium",
          evaluateEmptySlotAsZero: true // Default: true
        }
      }]
    })
  });

  const withoutEmptyAsZero = await fetch(connection.rpcEndpoint, {
    method: "POST", 
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate", 
      params: [{
        accountKeys: accountKeys,
        options: {
          priorityLevel: "Medium",
          evaluateEmptySlotAsZero: false
        }
      }]
    })
  });
  
  const result1 = await withEmptyAsZero.json();
  const result2 = await withoutEmptyAsZero.json();
  
  console.log(`With empty as zero: ${result1.result.priorityFeeEstimate}`);
  console.log(`Without empty as zero: ${result2.result.priorityFeeEstimate}`);
}

Quando true (padrão), slots sem transações são tratados como taxas zero em vez de excluídos. Isso proporciona estimativas mais equilibradas para contas com atividade esparsa.

Incluir Detalhes

Solicite informações detalhadas sobre os padrões de taxa de cada conta:

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

Isso retorna informações adicionais sobre como as taxas foram calculadas para cada conta.

Período de Revisão Personalizado

Ajuste o número de slots analisados para estimativa de taxa:

async function getCustomLookbackEstimate(accountKeys, 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: [{
        accountKeys: accountKeys,
        options: { 
          priorityLevel: "Medium",
          lookbackSlots: lookbackSlots  // 1-150, default is 150
        }
      }]
    })
  });
  
  const result = await response.json();
  return result.result.priorityFeeEstimate;
}

// Compare different lookback periods
const shortTerm = await getCustomLookbackEstimate(accountKeys, 50);   // Recent trends
const longTerm = await getCustomLookbackEstimate(accountKeys, 150);   // Historical average

console.log(`Short-term estimate: ${shortTerm} micro-lamports`);
console.log(`Long-term estimate: ${longTerm} micro-lamports`);

Revisão menor: Dados mais recentes, potencialmente voláteisRevisão maior: Contexto mais estável e histórico

Melhores Práticas para Seleção de Contas

Incluir Contas Graváveis

Prioridade: Foque em contas que serão modificadas

const writableAccounts = [
  "YOUR_WALLET",        // Paying fees
  "TOKEN_ACCOUNT",      // Being modified  
  "RECIPIENT_ACCOUNT"   // Receiving tokens
];

Adicionar Programas Chave

Contexto: Inclua contas de programas relevantes

const programAccounts = [
  "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token program
  "CUSTOM_PROGRAM_ID"                           // Your program
];

Tratamento de Erros & Alternativas

class AccountBasedFeeEstimator {
  constructor(connection) {
    this.connection = connection;
    this.fallbackFee = 10000; // 10k micro-lamports fallback
  }

  async getEstimate(accountKeys, priorityLevel = "Medium") {
    try {
      // Primary attempt
      const estimate = await this.getPrimaryEstimate(accountKeys, priorityLevel);
      return estimate;
    } catch (error) {
      console.warn("Primary estimate failed:", error.message);
      
      // Fallback to different configuration
      try {
        return await this.getFallbackEstimate(accountKeys, priorityLevel);
      } catch (fallbackError) {
        console.warn("Fallback estimate failed:", fallbackError.message);
        return this.fallbackFee;
      }
    }
  }

  async getPrimaryEstimate(accountKeys, 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: [{
          accountKeys: accountKeys,
          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(accountKeys, priorityLevel) {
    // Try with fewer accounts or different settings
    const coreAccounts = accountKeys.slice(0, 3); // Take first 3 accounts
    
    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: coreAccounts,
          options: { 
            priorityLevel: "Medium", // Use medium as fallback
            evaluateEmptySlotAsZero: true
          }
        }]
      })
    });

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

// Usage
const estimator = new AccountBasedFeeEstimator(connection);
const fee = await estimator.getEstimate(accountKeys, "High");

async function safeGetPriorityFee(accountKeys, priorityLevel = "Medium") {
  try {
    return await getPriorityFeeEstimate(connection, accountKeys, priorityLevel);
  } catch (error) {
    console.warn(`Priority fee estimation failed: ${error.message}`);
    
    // Return reasonable fallback based on priority level
    const fallbacks = {
      "Low": 1000,
      "Medium": 5000,
      "High": 15000,
      "VeryHigh": 50000
    };
    
    return fallbacks[priorityLevel] || 5000;
  }
}

Limitações & Considerações

Limitações do método baseado em contas:

Menos preciso para contas somente leitura - O algoritmo foca em contas graváveis
Sem análise específica de instrução - Não pode considerar operações específicas
Dependência da atividade da conta - Menos preciso para contas inativas
Sem consideração do tamanho da transação - Não leva em conta a complexidade da transação

Quando atualizar para transações serializadas:

Aplicações em produção que exigem maior precisão
Transações complexas com múltiplas instruções
Quando padrões de taxa específicos de instruções são importantes
Aplicações críticas em termos de desempenho

Recursos Relacionados

Transações Serializadas

Método mais preciso usando a serialização completa de transações

Referência de API

Documentação completa da API e parâmetros

Primeiros Passos

Transmissão de Dados e Audição de Eventos

APIs de Dados & RPCs

Negociação

Enviando Transações

Carteira como Serviço

Privacidade

Recursos

Estimativa de Taxa Prioritária Solana: Método de Chaves de Conta

Visão Geral

Casos de Uso Avançados

Compromissos

Quando Usar Chaves de Conta

Planejamento Pré-transação

Integração Simplificada

Análise Rápida de Mercado

Análise Multi-conta

Início Rápido

Exemplo Básico

Guia de Implementação

Função Principal

Exemplo Completo com Múltiplos Níveis de Prioridade

Tipos de Conta & Estratégias

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

Melhores Práticas para Seleção de Contas

Incluir Contas Graváveis

Adicionar Programas Chave

Tratamento de Erros & Alternativas

Limitações & Considerações

Recursos Relacionados

Transações Serializadas

Referência de API

​Visão Geral

Casos de Uso Avançados

Compromissos

​Quando Usar Chaves de Conta

Planejamento Pré-transação

Integração Simplificada

Análise Rápida de Mercado

Análise Multi-conta

​Início Rápido

​Exemplo Básico

​Guia de Implementação

​Função Principal

​Exemplo Completo com Múltiplos Níveis de Prioridade

​Tipos de Conta & Estratégias

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

​Melhores Práticas para Seleção de Contas

Incluir Contas Graváveis

Adicionar Programas Chave

​Tratamento de Erros & Alternativas

​Limitações & Considerações

​Recursos Relacionados

Transações Serializadas

Referência de API

Visão Geral

Quando Usar Chaves de Conta

Início Rápido

Exemplo Básico

Guia de Implementação

Função Principal

Exemplo Completo com Múltiplos Níveis de Prioridade

Tipos de Conta & Estratégias

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

Melhores Práticas para Seleção de Contas

Tratamento de Erros & Alternativas

Limitações & Considerações

Recursos Relacionados