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, l'attuale lamports_per_signature (attualmente 5.000) e la commissione di prioritizzazione derivata dalle istruzioni del budget di calcolo. La commissione totale viene detratta dal pagatore delle commissioni prima dell'inizio dell'esecuzione. Se la transazione fallisce, la commissione viene comunque addebitata.

Commissione base

La commissione base copre il costo della verifica della firma Ed25519 più eventuali verificazioni di firma precompilate. Ogni firma nella transazione viene addebitata, 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 sulla transazione (tipicamente una per firmatario).
• num_ed25519_signatures, num_secp256k1_signatures, num_secp256r1_signatures: firme verificate dai corrispondenti programmi precompilati.
• lamports_per_signature: attualmente 5.000 lamport.

Distribuzione delle commissioni

La commissione base e la commissione di prioritizzazione 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 dall'offerta circolante) e il 50% va al validator che produce il blocco. La percentuale bruciata è DEFAULT_BURN_PERCENT = 50.
• Commissione di prioritizzazione: il 100% va al validator (nulla viene bruciato), secondo SIMD-0096.

La ricompensa totale del validatore per una transazione è:

validator_reward = (base_fee / 2) + prioritization_fee

Commissione di prioritizzazione

La commissione di prioritizzazione è una commissione opzionale che aumenta la priorità di pianificazione di una transazione. Un'unità di calcolo (CU) è un'unità di computazione che il runtime misura durante l'esecuzione della transazione. Ogni operazione (aritmetica, accesso alla memoria, syscall) costa un numero fisso di CU. Puoi impostare la commissione di prioritizzazione includendo istruzioni di budget di calcolo nella tua transazione. (Consulta la guida su come utilizzare le commissioni di priorità per i dettagli.)

Formula della commissione di prioritizzazione

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 dal numero e dal tipo di istruzioni (200.000 CU per istruzione non builtin, 3.000 per builtin). Consulta budget di calcolo per i dettagli sul calcolo predefinito.

Prezzo per unità di calcolo

Il prezzo per unità di calcolo è un importo opzionale di micro-lamport pagato per ogni CU richiesta. Il prezzo per CU determina direttamente la commissione di prioritizzazione. Per impostare il prezzo per 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à elencati di seguito.

Priorità di pianificazione 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 prioritizzazione + porzione non bruciata della commissione base. Calcolato da calculate_reward_for_transaction.
• cost: il costo CU stimato dello scheduler (costi delle firme + costi dei write lock + costi dei dati delle istruzioni + costi di esecuzione dei programmi + costo della dimensione dei dati degli account caricati). Vedi Compute Budget per i dettagli.
• 1.000.000: un moltiplicatore per preservare la precisione, poiché il costo spesso supera il reward in lamport grezzi.
• +1: previene la divisione per zero.

La priorità determina l'ordine in cui le transazioni vengono rimosse dalla coda del 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);