Congestionamento na Solana: a melhor forma de enviar transações

Introdução

"Falha na simulação da transação: blockhash não encontrado." "Falha ao enviar a transação." Essas mensagens de erro se tornaram comuns demais. O congestionamento da rede transformou até mesmo transações básicas em um jogo de sorte. Esse sofrimento é desnecessário.

Este guia apresenta estratégias simples para navegar com eficiência por períodos de tráfego intenso e garantir que suas transações sejam incluídas. Abordaremos métodos abrangentes para lidar com o congestionamento da rede, incluindo taxas de prioridade, otimização de unidades de computação e um truque secreto exclusivo da Helius para sempre incluir suas transações.

Neste guia, veremos:

• Uso de transações serializadas para definir taxas de prioridade
• Uso de chaves de conta para definir taxas de prioridade
• Estratégias avançadas de taxas de prioridade
• Técnicas de otimização de transações
• Uso de endpoints com stake para garantir a entrega

Taxas de prioridade

As taxas de prioridade funcionam como um mecanismo de oferta, permitindo que você sinalize aos validadores a importância da sua transação. Essas taxas, definidas em microlamports por unidade de computação, são determinadas pelas contas específicas com as quais sua transação interage, criando mercados de taxas independentes para cada conta. Ao definir essas taxas estrategicamente com base no congestionamento específico de cada conta, você pode aumentar significativamente as chances de sua transação ser incluída no próximo bloco.

A seguir, veremos como definir corretamente as taxas de prioridade usando diferentes abordagens com a Priority Fee API da Helius:

Transação serializada

A forma mais direta de definir taxas de prioridade é usar uma transação serializada. Uma transação serializada é uma representação binária de uma transação convertida em um buffer no formato de transmissão que pode ser enviado pela rede.

1. Serialize sua transação e envie-a para a API:

const serializedTx = transaction.serialize();

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      transaction: serializedTx,
      options: { recommended: true }
    }]
  }),
});

const { result } = await response.json();
const priorityFee = result.priorityFeeEstimate;

2. Adicione a taxa recomendada à sua transação — a ordem das instruções não importa:

transaction.add(
  ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  })
);

Chaves de conta

Outra abordagem é fornecer à Priority Fee API uma lista das chaves de conta envolvidas na transação:‍

1. Extraia as chaves de conta da sua transação:

const transaction = new Transaction();

// Add your instructions to the transaction

// Extract all account keys from the transaction
const accountKeys = transaction.compileMessage().accountKeys;

// Convert PublicKeys to base58 strings
const publicKeys = accountKeys.map(key => key.toBase58());

2. Envie as chaves de conta para a Priority Fee API:

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      accountKeys: publicKeys,
      options: { recommended: true }
    }]
  }),
});

const { result } = await response.json();
const priorityFee = result.priorityFeeEstimate;

3. Adicione a taxa recomendada à sua transação:

transaction.add(
  ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  })
);

Embora os dois métodos funcionem, recomendamos o uso de transações serializadas. O uso de chaves de conta exige o acompanhamento e a inclusão manual de todas as contas relevantes, o que pode gerar estimativas de taxas imprecisas caso alguma conta seja omitida.

O método de transação serializada elimina esse risco ao incluir automaticamente todas as contas necessárias e fornecer estimativas de taxas mais precisas com base no contexto completo da transação.

Estratégias avançadas de taxas de prioridade

Na maioria dos cenários, usar uma transação serializada com a taxa de prioridade recomendada é suficiente. No entanto, para um controle mais granular, a Priority Fee API permite solicitar estimativas para diferentes níveis de prioridade e habilitar a avaliação de slots vazios.

Níveis de prioridade

Veja um exemplo de como solicitar todos os níveis de taxa de prioridade:

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      transaction: serializedTx,
      options: {
        includeAllPriorityFeeLevels: true
      }
    }]
  }),
});

const { result } = await response.json();
console.log(result.priorityFeeLevels);

Isso retornará um objeto com diferentes níveis de prioridade:

{
  "priorityFeeLevels": {
    "min": 10000.0,
    "low": 10000.0,
    "medium": 10000.0,
    "high": 100000.0,
    "veryHigh": 5483924.800000011,
    "unsafeMax": 8698904817.0
  }
}

Os níveis de prioridade correspondem a diferentes percentis das taxas de transações recentes:

• min: percentil 0
• low: percentil 25
• medium: percentil 50
• high: percentil 75
• veryHigh: percentil 95
• unsafeMax: percentil 100 (use com cuidado)

Para aumentar ainda mais as taxas de inclusão das transações, considere usar os níveis de prioridade high ou very high. No entanto, tenha cuidado ao usar níveis de prioridade mais altos, especialmente veryHigh e unsafeMax, pois eles podem aumentar significativamente os custos das transações.‍

Avaliação de slots vazios

Uma atualização recente da Priority Fee API permite estimar taxas de forma mais inteligente ao considerar slots vazios. Quando os blocos não contêm transações para uma determinada conta, você pode configurar a API para avaliar esses slots como tendo taxas zero, gerando estimativas mais precisas durante períodos de baixa atividade na rede:

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      transaction: serializedTx,
      options: {
        recommended: true,
        evaluateEmptySlotAsZero: true
      }
    }]
  }),
});

Quando evaluateEmptySlotAsZero está habilitado, a API:

• Identifica blocos sem transações para suas contas
• Contabiliza esses slots vazios como tendo taxas zero
• Reduz as estimativas durante períodos de baixo congestionamento
• Evita pagamentos excessivos quando a atividade da rede está baixa

Estratégias de otimização de transações

Além das taxas de prioridade, a otimização de transações envolve vários componentes essenciais que funcionam em conjunto para aumentar as taxas de inclusão:

Gerenciamento de unidades de computação

1. Use o SDK da Helius para obter as unidades de computação ideais para sua transação:‍

const response = await helius.rpc.getComputeUnits({
  transaction: serializedTransaction
});

const computeUnits = response.computeUnits;

2. Adicione o limite de unidades de computação à sua transação:

transaction.add(
  ComputeBudgetProgram.setComputeUnitLimit({
    units: computeUnits
  })
);

Níveis de compromisso

‍Para a maioria das aplicações, usar o nível de compromisso processed oferece o melhor equilíbrio. Ele:

• Oferece o menor tempo de confirmação
• Fornece segurança suficiente para a maioria dos casos de uso
• Reduz o risco de expiração do hash do bloco
• Minimiza transações descartadas durante congestionamentos

Sempre use o mesmo nível de compromisso ao enviar e confirmar transações para manter a consistência no comportamento da sua aplicação.

Configuração de RPC

Defina maxRetries como 0 e implemente sua própria lógica de repetição para ter mais controle sobre o reenvio de transações. Use skipPreflight: true para reduzir a latência. Isso é especialmente útil durante períodos de alto congestionamento:

const signature = await connection.sendTransaction(transaction, {
  maxRetries: 0,
  skipPreflight: true
});

Como usar um endpoint com stake

O endpoint com stake da Helius fornece acesso direto e garantido a conexões com stake, eliminando a necessidade de otimizar manualmente as taxas de prioridade:

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

// Transaction will be processed with optimal priority
const signature = await connection.sendTransaction(transaction);

O endpoint com stake:

• Oferece largura de banda com stake garantida
• Reduz falhas de transações durante congestionamentos
• Proporciona uma propagação mais rápida das transações por meio de infraestrutura dedicada

Conclusão

O uso eficaz das taxas de prioridade é essencial para incluir transações com sucesso na Solana, especialmente durante períodos de congestionamento da rede. Ao aproveitar a Priority Fee API da Helius e implementar as estratégias apresentadas, você pode aumentar significativamente as taxas de sucesso das transações sem deixar de considerar os custos. Acompanhe as novidades e adapte-se às condições da rede para obter os melhores resultados.

Se você leu até aqui, agradecemos! Esperamos que este guia tenha ajudado você a entender como otimizar suas transações na Solana. Assine nossa newsletter para não perder nenhuma novidade sobre a Solana.

Quer se aprofundar ainda mais?

Explore os artigos mais recentes no blog da Helius e continue hoje mesmo sua jornada pela Solana.