Kostenstructuur

Algoritme voor kostenberekening

De totale kosten voor een transactie worden berekend door calculate_fee_details:

total_fee = base_fee + prioritization_fee

De invoergegevens zijn het transactiebericht, de huidige lamports_per_signature (momenteel 5.000) en de prioriteringskosten afgeleid van compute budget-instructies. De totale kosten worden afgetrokken van de betaler voordat de uitvoering begint. Als de transactie mislukt, worden de kosten toch in rekening gebracht.

Basiskosten

De basiskosten dekken de kosten van Ed25519-handtekeningverificatie plus eventuele precompile-handtekeningverificaties. Elke handtekening in de transactie wordt in rekening gebracht, inclusief handtekeningen geverifieerd door de Ed25519-, Secp256k1- en Secp256r1- precompile-programma's.

De calculate_signature_fee functie berekent:

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: het aantal Ed25519-handtekeningen op de transactie (meestal één per ondertekenaar).
• num_ed25519_signatures, num_secp256k1_signatures, num_secp256r1_signatures: handtekeningen geverifieerd door de bijbehorende precompile-programma's.
• lamports_per_signature: momenteel 5.000 lamports.

Kostenverdeling

De basiskosten en prioriteringskosten worden verschillend verdeeld. De calculate_reward_and_burn_fee_details functie in de runtime berekent:

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

• Basiskosten (transaction_fee): 50% wordt verbrand (verwijderd uit de circulerende voorraad) en 50% gaat naar de blokproducerende validator. Het verbrandingspercentage is DEFAULT_BURN_PERCENT = 50.
• Prioriteringskosten: 100% gaat naar de validator (niets wordt verbrand), volgens SIMD-0096.

De totale beloning van de validator voor een transactie is:

validator_reward = (base_fee / 2) + prioritization_fee

Prioriteringsvergoeding

De prioriteringsvergoeding is een optionele vergoeding die de planningsprioriteit van een transactie verhoogt. Een compute unit (CU) is een rekeneenheid die de runtime meet tijdens de uitvoering van transacties. Elke operatie (rekenkundig, geheugentoegang, syscall) kost een vast aantal CU's. Je kunt de prioriteringsvergoeding instellen door compute budget-instructies in je transactie op te nemen. (Zie de How to Use Priority Fees guide voor details.)

Formule voor prioriteringsvergoeding

De get_prioritization_fee functie berekent:

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

Compute unit-limiet

De compute unit-limiet is het maximum aantal CU's dat een transactie mag verbruiken. Als er geen SetComputeUnitLimit instructie is opgenomen, wordt de standaardwaarde berekend op basis van het aantal en type instructies (200.000 CU's per niet-builtin instructie, 3.000 per builtin). Zie Compute Budget voor details over de standaardberekening.

Compute unit-prijs

De compute unit-prijs is een optioneel bedrag aan micro-lamports dat wordt betaald voor elke gevraagde CU. De CU-prijs bepaalt direct de prioriteringsvergoeding. Om de CU-prijs in te stellen, neem je een SetComputeUnitPrice instructie op in je transactie.

Voor realtime CU-prijsschattingen, zie de priority fee API-providers hieronder.

Transactieplanning prioriteit

De scheduler rangschikt transacties met behulp van de calculate_priority_and_cost functie:

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

• reward: het vergoedingsinkomen van de validator = prioriteringsvergoeding + niet-verbrand deel van de basisvergoeding. Berekend door calculate_reward_for_transaction.
• cost: de door de scheduler geschatte CU-kosten (handtekeningkosten + write lock-kosten + instruction data-kosten + programma- uitvoeringskosten + geladen accounts data size-kosten). Zie Compute Budget voor details.
• 1.000.000: een vermenigvuldiger om precisie te behouden, aangezien de kosten vaak hoger zijn dan de beloning in ruwe lamports.
• +1: voorkomt deling door nul.

De prioriteit bepaalt de volgorde waarin transacties uit de buffer van de scheduler worden gehaald voor uitvoering.

Voorbeeld: de CU-limiet en CU-prijs instellen

De onderstaande voorbeelden laten zien hoe je de CU-limiet en CU-prijs op een transactie instelt met behulp van Solana SDK's.

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);