Estructura de tarifas

Algoritmo de cálculo de tarifas

La tarifa total de una transacción se calcula mediante calculate_fee_details:

total_fee = base_fee + prioritization_fee

Los parámetros de entrada son el mensaje de transacción, el lamports_per_signature actual (actualmente 5.000) y la tarifa de priorización derivada de las instrucciones de presupuesto de cómputo. La tarifa total se deduce del pagador de tarifas antes de que comience la ejecución. Si la transacción falla, la tarifa se cobra igualmente.

Tarifa base

La tarifa base cubre el costo de verificación de firma Ed25519 más cualquier verificación de firma de precompilación. Se cobra cada firma en la transacción, incluyendo las firmas verificadas por los programas de precompilación Ed25519, Secp256k1 y Secp256r1.

La función 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: el número de firmas Ed25519 en la transacción (típicamente una por firmante).
• num_ed25519_signatures, num_secp256k1_signatures, num_secp256r1_signatures: firmas verificadas por los programas de precompilación correspondientes.
• lamports_per_signature: actualmente 5.000 lamports.

Distribución de tarifas

La tarifa base y la tarifa de priorización se distribuyen de manera diferente. La función calculate_reward_and_burn_fee_details en el runtime calcula:

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

• Tarifa base (transaction_fee): el 50% se quema (se elimina del suministro circulante) y el 50% va al validador que produce el bloque. El porcentaje de quema es DEFAULT_BURN_PERCENT = 50.
• Tarifa de priorización: el 100% va al validador (nada se quema), según SIMD-0096.

La recompensa total del validador por una transacción es:

validator_reward = (base_fee / 2) + prioritization_fee

Tarifa de priorización

La tarifa de priorización es una tarifa opcional que aumenta la prioridad de programación de una transacción. Una unidad de cómputo (CU) es una unidad de computación que el runtime mide durante la ejecución de la transacción. Cada operación (aritmética, acceso a memoria, syscall) cuesta un número fijo de CUs. Puedes establecer la tarifa de priorización incluyendo instrucciones de presupuesto de cómputo en tu transacción. (Consulta la guía de cómo usar tarifas de prioridad para más detalles).

Fórmula de tarifa de priorización

La función get_prioritization_fee calcula:

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

Límite de unidades de cómputo

El límite de unidades de cómputo es el número máximo de CUs que una transacción puede consumir. Si no se incluye una instrucción SetComputeUnitLimit, el valor predeterminado se calcula a partir del número y tipo de instrucciones (200.000 CUs por instrucción no integrada, 3.000 por integrada). Consulta presupuesto de cómputo para más detalles sobre el cálculo predeterminado.

Precio de unidad de cómputo

El precio de unidad de cómputo es una cantidad opcional de micro-lamports pagados por cada CU solicitada. El precio de CU determina directamente la tarifa de priorización. Para establecer el precio de CU, incluye una instrucción SetComputeUnitPrice en tu transacción.

Para estimaciones de precio de CU en tiempo real, consulta los proveedores de API de tarifa de prioridad a continuación.

Prioridad de programación de transacciones

El programador clasifica las transacciones utilizando la función calculate_priority_and_cost:

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

• reward: los ingresos por tarifas del validador = tarifa de priorización + porción no quemada de la tarifa base. Calculado por calculate_reward_for_transaction.
• cost: el costo estimado de CU del programador (costos de firma + costos de bloqueo de escritura + costos de datos de instrucción + costos de ejecución de programa + costo de tamaño de datos de cuentas cargadas). Consulta Presupuesto de cómputo para más detalles.
• 1,000,000: un multiplicador para preservar la precisión, ya que el costo a menudo excede la recompensa en lamports sin procesar.
• +1: previene la división por cero.

La prioridad determina el orden en el que las transacciones se retiran de la cola del búfer del programador para su ejecución.

Ejemplo: configurar el límite de CU y el precio de CU

Los ejemplos a continuación muestran cómo establecer el límite de CU y el precio de CU en una transacción utilizando los SDK de 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);