Estrutura de taxas

Algoritmo de cálculo de taxas

A taxa total de uma transação é calculada por calculate_fee_details:

total_fee = base_fee + prioritization_fee

Os parâmetros de entrada são a mensagem da transação, o lamports_per_signature atual (atualmente 5.000) e a taxa de priorização derivada das instruções de orçamento de computação. A taxa total é deduzida do pagador de taxas antes do início da execução. Se a transação falhar, a taxa ainda é cobrada.

Taxa base

A taxa base cobre o custo da verificação de assinatura Ed25519 mais quaisquer verificações de assinatura de precompilação. Cada assinatura na transação é cobrada, incluindo assinaturas verificadas pelos programas de precompilação Ed25519, Secp256k1 e Secp256r1.

A função calculate_signature_fee calcula:

signature_count = num_transaction_signatures
                + num_ed25519_signatures
                + num_secp256k1_signatures
                + num_secp256r1_signatures   (if feature enabled)

base_fee = signature_count * lamports_per_signature

• num_transaction_signatures: o número de assinaturas Ed25519 na transação (normalmente uma por signatário).
• num_ed25519_signatures, num_secp256k1_signatures, num_secp256r1_signatures: assinaturas verificadas pelos programas de precompilação correspondentes.
• lamports_per_signature: atualmente 5.000 lamports.

Distribuição de taxas

A taxa base e a taxa de priorização são distribuídas de forma diferente. A função calculate_reward_and_burn_fee_details no runtime calcula:

burn_amount     = transaction_fee * 50 / 100
validator_share = (transaction_fee - burn_amount) + priority_fee

• Taxa base (transaction_fee): 50% é queimada (removida da oferta circulante) e 50% vai para o validator que produz o bloco. A percentagem de queima é DEFAULT_BURN_PERCENT = 50.
• Taxa de priorização: 100% vai para o validator (nada é queimado), conforme SIMD-0096.

A recompensa total do validator por uma transação é:

validator_reward = (base_fee / 2) + prioritization_fee

Taxa de priorização

A taxa de priorização é uma taxa opcional que aumenta a prioridade de agendamento de uma transação. Uma unidade de computação (CU) é uma unidade de computação que o runtime contabiliza durante a execução da transação. Cada operação (aritmética, acesso à memória, syscall) custa um número fixo de CUs. Você pode definir a taxa de priorização incluindo instruções de orçamento de computação na sua transação. (Consulte o guia Como Usar Taxas de Prioridade para detalhes.)

Fórmula da taxa de priorização

A função get_prioritization_fee calcula:

micro_lamport_fee = compute_unit_price * compute_unit_limit
prioritization_fee = ceil(micro_lamport_fee / 1,000,000)

Limite de unidades de computação

O limite de unidades de computação é o número máximo de CUs que uma transação pode consumir. Se nenhuma instrução SetComputeUnitLimit for incluída, o padrão é calculado a partir do número e tipo de instruções (200.000 CUs por instrução não-builtin, 3.000 por builtin). Consulte Orçamento de Computação para detalhes sobre o cálculo padrão.

Preço da unidade de computação

O preço da unidade de computação é uma quantidade opcional de micro-lamports paga por cada CU solicitada. O preço da CU determina diretamente a taxa de priorização. Para definir o preço da CU, inclua uma instrução SetComputeUnitPrice na sua transação.

Para estimativas de preço de CU em tempo real, consulte os fornecedores de API de taxa de prioridade abaixo.

Prioridade de agendamento de transações

O agendador classifica as transações usando a função calculate_priority_and_cost:

Priority = reward * 1,000,000 / (cost + 1)

• reward: a receita de taxas do validator = taxa de priorização + porção não queimada da taxa base. Calculada por calculate_reward_for_transaction.
• cost: o custo estimado de CU do agendador (custos de assinatura + custos de bloqueio de escrita + custos de dados de instrução + custos de execução de programa + custo de tamanho de dados de contas carregadas). Consulte Orçamento de computação para detalhes.
• 1.000.000: um multiplicador para preservar a precisão, já que o custo frequentemente excede a recompensa em lamports brutos.
• +1: previne divisão por zero.

A prioridade determina a ordem na qual as transações são retiradas da fila do buffer do agendador para execução.

Exemplo: definindo o limite de CU e o preço de CU

Os exemplos abaixo mostram como definir o limite de CU e o preço de CU numa transação usando SDKs da Solana.

const limitInstruction = ComputeBudgetProgram.setComputeUnitLimit({
  units: 300_000
});

const priceInstruction = ComputeBudgetProgram.setComputeUnitPrice({
  microLamports: 1
});

import {
  LAMPORTS_PER_SOL,
  SystemProgram,
  Transaction,
  Keypair,
  Connection,
  ComputeBudgetProgram,
  sendAndConfirmTransaction
} from "@solana/web3.js";

const connection = new Connection("http://localhost:8899", "confirmed");

const sender = Keypair.generate();
const recipient = new Keypair();

const airdropSignature = await connection.requestAirdrop(
  sender.publicKey,
  LAMPORTS_PER_SOL
);
await connection.confirmTransaction(airdropSignature, "confirmed");

// Create compute budget instructions
const limitInstruction = ComputeBudgetProgram.setComputeUnitLimit({
  units: 300_000
});
const priceInstruction = ComputeBudgetProgram.setComputeUnitPrice({
  microLamports: 1
});

const transferInstruction = SystemProgram.transfer({
  fromPubkey: sender.publicKey,
  toPubkey: recipient.publicKey,
  lamports: 0.01 * LAMPORTS_PER_SOL
});

// Add the compute budget and transfer instructions to a new transaction
const transaction = new Transaction()
  .add(limitInstruction)
  .add(priceInstruction)
  .add(transferInstruction);

const signature = await sendAndConfirmTransaction(connection, transaction, [
  sender
]);

console.log("Transaction Signature:", signature);

import {
  LAMPORTS_PER_SOL,
  SystemProgram,
  Transaction,
  Keypair,
  Connection,
  ComputeBudgetProgram,
  sendAndConfirmTransaction
} from "@solana/web3.js";

const connection = new Connection("http://localhost:8899", "confirmed");

const sender = Keypair.generate();
const recipient = new Keypair();

const airdropSignature = await connection.requestAirdrop(
  sender.publicKey,
  LAMPORTS_PER_SOL
);
await connection.confirmTransaction(airdropSignature, "confirmed");

// Create compute budget instructions
const limitInstruction = ComputeBudgetProgram.setComputeUnitLimit({
  units: 300_000
});
const priceInstruction = ComputeBudgetProgram.setComputeUnitPrice({
  microLamports: 1
});

const transferInstruction = SystemProgram.transfer({
  fromPubkey: sender.publicKey,
  toPubkey: recipient.publicKey,
  lamports: 0.01 * LAMPORTS_PER_SOL
});

// Add the compute budget and transfer instructions to a new transaction
const transaction = new Transaction()
  .add(limitInstruction)
  .add(priceInstruction)
  .add(transferInstruction);

const signature = await sendAndConfirmTransaction(connection, transaction, [
  sender
]);

console.log("Transaction Signature:", signature);