Structure des frais

Algorithme de calcul des frais

Les frais totaux d'une transaction sont calculés par calculate_fee_details :

total_fee = base_fee + prioritization_fee

Les entrées sont le message de transaction, le lamports_per_signature actuel (actuellement 5 000), et les frais de priorisation dérivés des instructions de budget de calcul. Les frais totaux sont déduits du payeur de frais avant le début de l'exécution. Si la transaction échoue, les frais sont quand même facturés.

Frais de base

Les frais de base couvrent le coût de la vérification de signature Ed25519 plus toute vérification de signature de 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 priorisation 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 l'offre en circulation) et 50 % vont au validator producteur de bloc. Le pourcentage brûlé est DEFAULT_BURN_PERCENT = 50.
• Frais de priorisation : 100 % vont au validator (aucun n'est brûlé), selon SIMD-0096.

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

validator_reward = (base_fee / 2) + prioritization_fee

Frais de priorisation

Les frais de priorisation sont des frais optionnels qui augmentent la priorité de planification d'une transaction. Une unité de calcul (CU) est une unité de calcul que le runtime mesure pendant 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 priorisation en incluant des instructions de budget de calcul dans votre transaction. (Consultez le guide Comment utiliser les frais de priorité pour plus de détails.)

Formule des frais de priorisation

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). Consultez Budget de calcul 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ée. Le prix de la CU détermine directement les frais de priorisation. Pour définir le prix de la CU, incluez une instruction SetComputeUnitPrice dans votre transaction.

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

Priorité de planification des transactions

Le planificateur classe les transactions en utilisant la fonction calculate_priority_and_cost :

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

• reward : le revenu de frais du validateur = frais de priorisation + portion non brûlée des frais de base. Calculé par calculate_reward_for_transaction.
• cost : le coût CU estimé du planificateur (coûts de signature + coûts de verrouillage en écriture + coûts de données d'instruction + coûts d'exécution de programme + coût de taille des données de comptes chargés). Voir Budget de calcul 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 du planificateur pour exécution.

Exemple : définir la limite CU et le prix CU

Les exemples ci-dessous montrent comment définir la limite CU et le prix CU sur une transaction en utilisant les 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);