Fee-Struktur

Fee-Berechnungsalgorithmus

Die Gesamt-Fee für eine Transaktion wird durch calculate_fee_details berechnet:

total_fee = base_fee + prioritization_fee

Die Eingaben sind die Transaktionsnachricht, die aktuelle lamports_per_signature (derzeit 5.000) und die Priorisierungs-Fee, die aus Compute-Budget-Anweisungen abgeleitet wird. Die Gesamt-Fee wird vom Fee-Zahler vor Beginn der Ausführung abgezogen. Wenn die Transaktion fehlschlägt, wird die Fee dennoch berechnet.

Basis-Fee

Die Basis-Fee deckt die Kosten der Ed25519-Signaturverifizierung sowie alle Precompile-Signaturverifizierungen ab. Jede Signatur in der Transaktion wird berechnet, einschließlich Signaturen, die von den Ed25519-, Secp256k1- und Secp256r1- Precompile-Programmen verifiziert werden.

Die calculate_signature_fee Funktion berechnet:

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: die Anzahl der Ed25519-Signaturen in der Transaktion (typischerweise eine pro Signer).
• num_ed25519_signatures, num_secp256k1_signatures, num_secp256r1_signatures: Signaturen, die von den entsprechenden Precompile-Programmen verifiziert werden.
• lamports_per_signature: derzeit 5.000 Lamports.

Fee-Verteilung

Die Basis-Fee und die Priorisierungs-Fee werden unterschiedlich verteilt. Die calculate_reward_and_burn_fee_details Funktion in der Runtime berechnet:

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

• Basis-Fee (transaction_fee): 50% werden verbrannt (aus dem Umlauf entfernt) und 50% gehen an den blockproduzierenden Validator. Der Verbrennungsprozentsatz ist DEFAULT_BURN_PERCENT = 50.
• Priorisierungs-Fee: 100% gehen an den Validator (nichts wird verbrannt), gemäß SIMD-0096.

Die Gesamtbelohnung des Validators für eine Transaktion beträgt:

validator_reward = (base_fee / 2) + prioritization_fee

Prioritätsgebühr

Die Prioritätsgebühr ist eine optionale Gebühr, die die Planungspriorität einer Transaktion erhöht. Eine Compute Unit (CU) ist eine Berechnungseinheit, die die Runtime während der Transaktionsausführung misst. Jede Operation (Arithmetik, Speicherzugriff, Syscall) kostet eine feste Anzahl von CUs. Sie können die Prioritätsgebühr festlegen, indem Sie Compute Budget Anweisungen in Ihre Transaktion aufnehmen. (Siehe den Leitfaden zur Verwendung von Prioritätsgebühren für Details.)

Formel für die Prioritätsgebühr

Die Funktion get_prioritization_fee berechnet:

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

Compute Unit Limit

Das Compute Unit Limit ist die maximale Anzahl von CUs, die eine Transaktion verbrauchen darf. Wenn keine SetComputeUnitLimit Anweisung enthalten ist, wird der Standardwert aus der Anzahl und Art der Anweisungen berechnet (200.000 CUs pro Nicht-Builtin-Anweisung, 3.000 pro Builtin). Siehe Compute Budget für Details zur Standardberechnung.

Compute Unit Preis

Der Compute Unit Preis ist ein optionaler Betrag in Mikro-Lamports, der für jede angeforderte CU gezahlt wird. Der CU-Preis bestimmt direkt die Prioritätsgebühr. Um den CU-Preis festzulegen, fügen Sie eine SetComputeUnitPrice Anweisung in Ihre Transaktion ein.

Für Echtzeit-CU-Preisschätzungen siehe die unten aufgeführten priority fee API-Anbieter.

Transaktionsplanungspriorität

Der Scheduler ordnet Transaktionen mithilfe der calculate_priority_and_cost Funktion:

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

• reward: das Gebühreneinkommen des Validators = priority fee + nicht verbrannter Anteil der Basisgebühr. Berechnet durch calculate_reward_for_transaction.
• cost: die vom Scheduler geschätzten CU-Kosten (Signaturkosten + Write-Lock-Kosten + Instruction-Data-Kosten + Programmausführungskosten + Kosten für geladene Kontodatengröße). Siehe Compute Budget für Details.
• 1.000.000: ein Multiplikator zur Erhaltung der Präzision, da die Kosten oft die Belohnung in rohen Lamports übersteigen.
• +1: verhindert Division durch Null.

Die Priorität bestimmt die Reihenfolge, in der Transaktionen aus dem Puffer des Schedulers zur Ausführung entfernt werden.

Beispiel: Festlegen des CU-Limits und CU-Preises

Die folgenden Beispiele zeigen, wie das CU-Limit und der CU-Preis für eine Transaktion mithilfe von Solana-SDKs festgelegt werden.

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