Fee-Struktur

Fee-Berechnungsalgorithmus

Die Gesamtgebühr für eine Transaktion wird durch calculate_fee_details berechnet:

total_fee = base_fee + prioritization_fee

Die Eingaben sind die Transaktionsnachricht, das aktuelle lamports_per_signature (derzeit 5.000) und die Priorisierungsgebühr, die aus Compute-Budget- Anweisungen abgeleitet wird. Die Gesamtgebühr wird vor der Ausführung vom Fee-Zahler abgezogen. Schlägt die Transaktion fehl, wird die Gebühr trotzdem berechnet.

Grundgebühr

Die Grundgebühr deckt die Kosten der Ed25519-Signaturverifizierung sowie etwaige Precompile-Signaturverifizierungen ab. Jede Signatur in der Transaktion wird berechnet, einschließlich der Signaturen, die durch die Precompile-Programme Ed25519, Secp256k1 und Secp256r1 verifiziert werden.

Die Funktion calculate_signature_fee 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 (in der Regel eine pro Signer).
• num_ed25519_signatures, num_secp256k1_signatures, num_secp256r1_signatures: Signaturen, die durch die entsprechenden Precompile-Programme verifiziert werden.
• lamports_per_signature: derzeit 5.000 lamports.

Fee-Verteilung

Die Grundgebühr und die Priorisierungsgebühr werden unterschiedlich verteilt. Die Funktion calculate_reward_and_burn_fee_details in der Runtime berechnet:

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

• Grundgebühr (transaction_fee): 50 % werden verbrannt (aus dem Umlauf entfernt) und 50 % gehen an die blockproduzierenden Validatoren. Der Verbrennungsprozentsatz ist DEFAULT_BURN_PERCENT = 50.
• Priorisierungsgebühr: 100 % gehen an die Validatoren (nichts wird verbrannt), gemäß SIMD-0096.

Die Gesamtvergütung der Validatoren für eine Transaktion beträgt:

validator_reward = (base_fee / 2) + prioritization_fee

Priorisierungsgebühr

Die Priorisierungsgebü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. Die Priorisierungsgebühr kann durch Hinzufügen von Compute-Budget- Anweisungen zur Transaktion festgelegt werden. (Weitere Informationen finden Sie im Leitfaden zur Verwendung von Priority Fees.)

Formel für die Priorisierungsgebü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 anhand der Anzahl und Art der Anweisungen berechnet (200.000 CUs pro Nicht-Builtin-Anweisung, 3.000 pro Builtin). Weitere Informationen zur Standardberechnung finden Sie unter Compute Budget.

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 Priorisierungsgebühr. Um den CU-Preis festzulegen, fügen Sie eine SetComputeUnitPrice-Anweisung in Ihre Transaktion ein.

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

Transaktionsplanungspriorität

Der Scheduler ordnet Transaktionen mithilfe der Funktion calculate_priority_and_cost:

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

• reward: das Fee-Einkommen der Validatoren = Priorisierungsgebühr + nicht verbrannter Anteil der Grundgebühr. Berechnet durch calculate_reward_for_transaction.
• cost: die geschätzten CU-Kosten des Schedulers (Signaturkosten + Schreibsperrkosten + instruction data-Kosten + Programmausführungskosten + Kosten für die Datengröße geladener Konten). Weitere Informationen finden Sie unter Compute Budget.
• 1.000.000: ein Multiplikator zur Wahrung der Präzision, da die Kosten in rohen lamports häufig die Vergütung übersteigen.
• +1: verhindert eine Division durch null.

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

Beispiel: Festlegen des CU-Limits und des CU-Preises

Die folgenden Beispiele zeigen, wie das CU-Limit und der CU-Preis einer Transaktion mithilfe der 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);