Structure des frais

Algorithme de calcul des frais

Le montant total des frais d'une transaction est calculé par calculate_fee_details :

total_fee = base_fee + prioritization_fee

Les entrées sont le message de transaction, la valeur actuelle de lamports_per_signature (actuellement 5 000) et les frais de priorité dérivés des instructions de budget de calcul. Le montant total des frais est déduit du payeur de frais avant le début de l'exécution. Si la transaction échoue, les frais sont tout de même prélevés.

Frais de base

Les frais de base couvrent le coût de la vérification des signatures Ed25519 ainsi que toute vérification de signature par précompilation. Chaque signature dans la transaction est facturée, y compris les signatures vérifiées par les programmes de précompilation Ed25519, Secp256k1 et Secp256r1.

La fonction calculate_signature_fee calcule :

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 : le nombre de signatures Ed25519 sur la transaction (généralement une par signataire).
• num_ed25519_signatures, num_secp256k1_signatures, num_secp256r1_signatures : signatures vérifiées par les programmes de précompilation correspondants.
• lamports_per_signature : actuellement 5 000 lamports.

Distribution des frais

Les frais de base et les frais de priorité sont distribués différemment. La fonction calculate_reward_and_burn_fee_details dans le runtime calcule :

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

• Frais de base (transaction_fee) : 50 % sont brûlés (retirés de la masse monétaire en circulation) et 50 % vont au validator qui produit le bloc. Le pourcentage brûlé est DEFAULT_BURN_PERCENT = 50.
• Frais de priorité : 100 % vont au validator (rien n'est brûlé), conformément à SIMD-0096.

La récompense totale du validator pour une transaction est :

validator_reward = (base_fee / 2) + prioritization_fee

Frais de priorité

Les frais de priorité sont des frais optionnels qui augmentent la priorité d'ordonnancement d'une transaction. Une unité de calcul (CU) est une unité de calcul que le runtime mesurie lors de l'exécution de la transaction. Chaque opération (arithmétique, accès mémoire, syscall) coûte un nombre fixe de CU. Vous pouvez définir les frais de priorité en incluant des instructions de budget de calcul dans votre transaction. (Voir le guide d'utilisation des frais de priorité pour plus de détails.)

Formule des frais de priorité

La fonction get_prioritization_fee calcule :

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

Limite d'unités de calcul

La limite d'unités de calcul est le nombre maximum de CU qu'une transaction peut consommer. Si aucune instruction SetComputeUnitLimit n'est incluse, la valeur par défaut est calculée à partir du nombre et du type d'instructions (200 000 CU par instruction non intégrée, 3 000 par instruction intégrée). Voir Compute Budget pour plus de détails sur le calcul par défaut.

Prix de l'unité de calcul

Le prix de l'unité de calcul est un montant optionnel de micro-lamports payé pour chaque CU demandé. Le prix des CU détermine directement les frais de priorité. Pour définir le prix des CU, incluez une instruction SetComputeUnitPrice dans votre transaction.

Pour des estimations du prix des CU en temps réel, consultez les fournisseurs d'API de frais de priorité ci-dessous.

Priorité d'ordonnancement des transactions

L'ordonnanceur classe les transactions à l'aide de la fonction calculate_priority_and_cost :

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

• reward : les revenus de frais du validator = frais de priorité + part non brûlée des frais de base. Calculé par calculate_reward_for_transaction.
• cost : le coût estimé en CU de l'ordonnanceur (coûts de signature + coûts de verrou en écriture + coûts d'instruction data + coûts d'exécution du programme + coût de la taille des données des comptes chargés). Voir Compute Budget pour plus de détails.
• 1 000 000 : un multiplicateur pour préserver la précision, car le coût dépasse souvent la récompense en lamports bruts.
• +1 : empêche la division par zéro.

La priorité détermine l'ordre dans lequel les transactions sont retirées de la file d'attente de l'ordonnanceur pour être exécutées.

Exemple : Définir la limite de CU et le prix des CU

Les exemples ci-dessous montrent comment définir la limite de CU et le prix des CU sur une transaction à l'aide des 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);