Estructura de comisiones

Algoritmo de cálculo de comisiones

La comisión total de una transacción es calculada por calculate_fee_details:

total_fee = base_fee + prioritization_fee

Las entradas son el mensaje de la transacción, el valor actual de lamports_per_signature (actualmente 5.000) y la comisión de priorización derivada de las instrucciones de presupuesto de cómputo. La comisión total se deduce del pagador de comisiones antes de que comience la ejecución. Si la transacción falla, la comisión se cobra igualmente.

Comisión base

La comisión base cubre el coste de la verificación de firmas Ed25519, además de cualquier verificación de firmas de precompilados. Se cobra cada firma de la transacción, incluidas las verificadas por los programas precompilados 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 (normalmente una por firmante).
• num_ed25519_signatures, num_secp256k1_signatures, num_secp256r1_signatures: firmas verificadas por los programas precompilados correspondientes.
• lamports_per_signature: actualmente 5.000 lamports.

Distribución de comisiones

La comisión base y la comisión de priorización se distribuyen de forma diferente. La función calculate_reward_and_burn_fee_details del entorno de ejecución calcula:

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

• Comisión base (transaction_fee): el 50% se quema (se retira de la oferta circulante) y el 50% va al validator que produce el bloque. El porcentaje quemado es DEFAULT_BURN_PERCENT = 50.
• Comisión de priorización: el 100% va al validator (nada se quema), según SIMD-0096.

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

validator_reward = (base_fee / 2) + prioritization_fee

Comisión de priorización

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

Fórmula de la comisión 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 puede consumir una transacción. Si no se incluye ninguna 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 instrucción integrada). Consulta Compute Budget para más detalles sobre el cálculo predeterminado.

Precio de la unidad de cómputo

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

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

Prioridad de programación de transacciones

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

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

• reward: los ingresos del validator por comisiones = comisión de priorización + porción no quemada de la comisión base. Calculado por calculate_reward_for_transaction.
• cost: el coste estimado en CUs del programador (costes de firmas + costes de bloqueo de escritura + costes de instruction data + costes de ejecución del programa + coste del tamaño de datos de cuentas cargadas). Consulta Compute Budget para más detalles.
• 1.000.000: un multiplicador para preservar la precisión, ya que el coste suele superar la recompensa en lamports brutos.
• +1: evita la división por cero.

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

Ejemplo: Establecer 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 mediante los SDKs 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);