Struttura delle commissioni

Algoritmo di calcolo delle commissioni

La commissione totale per una transazione viene calcolata da calculate_fee_details:

total_fee = base_fee + prioritization_fee

Gli input sono il messaggio della transazione, il valore attuale di lamports_per_signature (attualmente 5.000) e la commissione di priorità derivata dalle istruzioni del budget di calcolo. La commissione totale viene dedotta dal pagante prima dell'esecuzione. Se la transazione fallisce, la commissione viene comunque addebitata.

Commissione base

La commissione base copre il costo della verifica della firma Ed25519 e le verifiche delle firme precompilate. Ogni firma nella transazione viene addebita, incluse le firme verificate dai programmi precompilati Ed25519, Secp256k1 e Secp256r1.

La funzione calculate_signature_fee calcola:

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: il numero di firme Ed25519 nella transazione (in genere una per firmatario).
• num_ed25519_signatures, num_secp256k1_signatures, num_secp256r1_signatures: firme verificate dai rispettivi programmi precompilati.
• lamports_per_signature: attualmente 5.000 lamports.

Distribuzione delle commissioni

La commissione base e la commissione di priorità vengono distribuite in modo diverso. La funzione calculate_reward_and_burn_fee_details nel runtime calcola:

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

• Commissione base (transaction_fee): il 50% viene bruciato (rimosso dalla circolazione) e il 50% va al validator che produce il blocco. La percentuale bruciata è DEFAULT_BURN_PERCENT = 50.
• Commissione di priorità: il 100% va al validator (nessuna quota viene bruciata), secondo SIMD-0096.

La ricompensa totale del validator per una transazione è:

validator_reward = (base_fee / 2) + prioritization_fee

Commissione di priorità

La commissione di priorità è una commissione opzionale che aumenta la priorità di schedulazione di una transazione. Un'unità di calcolo (CU) è un'unità di elaborazione misurata dal runtime durante l'esecuzione della transazione. Ogni operazione (aritmetica, accesso alla memoria, syscall) ha un costo fisso in CU. È possibile impostare la commissione di priorità includendo istruzioni del budget di calcolo nella transazione. (Consulta la guida Come utilizzare le commissioni di priorità per i dettagli.)

Formula della commissione di priorità

La funzione get_prioritization_fee calcola:

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

Limite di unità di calcolo

Il limite di unità di calcolo è il numero massimo di CU che una transazione può consumare. Se non viene inclusa alcuna istruzione SetComputeUnitLimit, il valore predefinito viene calcolato in base al numero e al tipo di istruzioni (200.000 CU per istruzione non integrata, 3.000 per quelle integrate). Consulta Compute Budget per i dettagli sul calcolo predefinito.

Prezzo dell'unità di calcolo

Il prezzo dell'unità di calcolo è un importo opzionale in micro-lamports pagato per ogni CU richiesta. Il prezzo CU determina direttamente la commissione di priorità. Per impostare il prezzo CU, includi un'istruzione SetComputeUnitPrice nella tua transazione.

Per stime in tempo reale del prezzo CU, consulta i provider di API per le commissioni di priorità di seguito.

Priorità di schedulazione delle transazioni

Lo scheduler classifica le transazioni utilizzando la funzione calculate_priority_and_cost:

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

• reward: il reddito da commissioni del validator = commissione di priorità + quota non bruciata della commissione base. Calcolato da calculate_reward_for_transaction.
• cost: il costo CU stimato dallo scheduler (costi delle firme + costi di blocco in scrittura + costi di instruction data + costi di esecuzione del programma + costo della dimensione dei dati degli account caricati). Consulta Compute Budget per i dettagli.
• 1.000.000: un moltiplicatore per preservare la precisione, poiché il costo spesso supera la ricompensa in lamports grezzi.
• +1: previene la divisione per zero.

La priorità determina l'ordine in cui le transazioni vengono estratte dal buffer dello scheduler per l'esecuzione.

Esempio: impostazione del limite CU e del prezzo CU

Gli esempi seguenti mostrano come impostare il limite CU e il prezzo CU su una transazione utilizzando gli SDK 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);