Congestion sur Solana : comment envoyer au mieux vos transactions Solana

Introduction

« Échec de la simulation de la transaction : blockhash introuvable. » « Échec de l’envoi de la transaction. » Ces messages d’erreur sont devenus bien trop courants. La congestion du réseau transforme même les transactions les plus simples en jeu de hasard. Cette situation n’est pas une fatalité.

Ce guide présente des stratégies simples pour gérer efficacement les périodes de forte activité et garantir la confirmation de vos transactions. Nous aborderons des approches complètes pour faire face à la congestion du réseau, notamment les frais de priorité, l’optimisation des unités de calcul et l’astuce secrète exclusive de Helius pour toujours faire confirmer vos transactions.

Dans ce guide, nous verrons comment :

• Utiliser des transactions sérialisées pour les frais de priorité
• Utiliser des clés de compte pour les frais de priorité
• Appliquer des stratégies avancées de frais de priorité
• Optimiser les transactions
• Exploiter des endpoints stakés pour garantir la livraison

Frais de priorité

Les frais de priorité servent de mécanisme d’enchères et vous permettent de signaler aux validateurs l’importance de votre transaction. Ces frais, exprimés en microlamports par unité de calcul, dépendent des comptes spécifiques avec lesquels votre transaction interagit, ce qui crée des marchés de frais indépendants pour chaque compte. En définissant ces frais de manière stratégique selon la congestion propre à chaque compte, vous pouvez considérablement augmenter les chances que votre transaction soit incluse dans le prochain bloc.

Voyons maintenant comment définir correctement les frais de priorité selon différentes approches à l’aide de la Priority Fee API de Helius :

Transaction sérialisée

La méthode la plus simple pour définir les frais de priorité consiste à utiliser une transaction sérialisée. Une transaction sérialisée est une représentation binaire d’une transaction convertie en buffer au format réseau, qui peut être transmis sur le réseau.

1. Sérialisez votre transaction et transmettez-la à l’API :

const serializedTx = transaction.serialize();

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      transaction: serializedTx,
      options: { recommended: true }
    }]
  }),
});

const { result } = await response.json();
const priorityFee = result.priorityFeeEstimate;

2. Ajoutez les frais recommandés à votre transaction — l’ordre des instructions n’a pas d’importance :

transaction.add(
  ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  })
);

Clés de compte

Une autre approche consiste à fournir à la Priority Fee API la liste des clés de compte impliquées dans la transaction :‍

1. Extrayez les clés de compte de votre transaction :

const transaction = new Transaction();

// Add your instructions to the transaction

// Extract all account keys from the transaction
const accountKeys = transaction.compileMessage().accountKeys;

// Convert PublicKeys to base58 strings
const publicKeys = accountKeys.map(key => key.toBase58());

2. Transmettez les clés de compte à la Priority Fee API :

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      accountKeys: publicKeys,
      options: { recommended: true }
    }]
  }),
});

const { result } = await response.json();
const priorityFee = result.priorityFeeEstimate;

3. Ajoutez les frais recommandés à votre transaction :

transaction.add(
  ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  })
);

Les deux méthodes fonctionnent, mais celle des transactions sérialisées est recommandée. L’utilisation de clés de compte nécessite de suivre et d’inclure manuellement tous les comptes concernés, ce qui peut entraîner des estimations de frais inexactes si certains comptes sont omis. 

La méthode de la transaction sérialisée élimine ce risque en incluant automatiquement tous les comptes nécessaires et en fournissant des estimations de frais plus précises à partir du contexte complet de la transaction.

Stratégies avancées de frais de priorité

Dans la plupart des cas, il suffit d’utiliser une transaction sérialisée avec les frais de priorité recommandés. Pour un contrôle plus précis, la Priority Fee API vous permet toutefois de demander des estimations pour différents niveaux de priorité et d’activer l’évaluation des slots vides.

Niveaux de priorité

Voici un exemple pour demander tous les niveaux de frais de priorité :

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      transaction: serializedTx,
      options: {
        includeAllPriorityFeeLevels: true
      }
    }]
  }),
});

const { result } = await response.json();
console.log(result.priorityFeeLevels);

Cette requête renvoie un objet contenant différents niveaux de priorité :

{
  "priorityFeeLevels": {
    "min": 10000.0,
    "low": 10000.0,
    "medium": 10000.0,
    "high": 100000.0,
    "veryHigh": 5483924.800000011,
    "unsafeMax": 8698904817.0
  }
}

Les niveaux de priorité correspondent à différents centiles des frais de transaction récents :

• min : 0e centile
• low : 25e centile
• medium : 50e centile
• high : 75e centile
• veryHigh : 95e centile
• unsafeMax : 100e centile (à utiliser avec prudence)

Pour améliorer davantage le taux de confirmation des transactions, envisagez d’utiliser les niveaux de priorité high ou very high. Soyez toutefois prudent avec les niveaux de priorité supérieurs, en particulier veryHigh et unsafeMax, car ils peuvent augmenter considérablement le coût des transactions.‍

Évaluation des slots vides

Une mise à jour récente de la Priority Fee API permet d’estimer les frais plus intelligemment en tenant compte des slots vides. Lorsque des blocs ne contiennent aucune transaction pour un compte donné, vous pouvez configurer l’API afin qu’elle considère que les frais de ces slots sont nuls, ce qui fournit des estimations plus précises lorsque l’activité du réseau est faible :

const response = await fetch(heliusEndpoint, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 'helius-example',
    method: 'getPriorityFeeEstimate',
    params: [{
      transaction: serializedTx,
      options: {
        recommended: true,
        evaluateEmptySlotAsZero: true
      }
    }]
  }),
});

Lorsque evaluateEmptySlotAsZero est activé, l’API :

• Identifie les blocs sans transaction pour vos comptes
• Considère que les frais de ces slots vides sont nuls
• Réduit les estimations lorsque la congestion est faible
• Évite de payer trop lorsque l’activité du réseau est faible

Stratégies d’optimisation des transactions

Au-delà des frais de priorité, l’optimisation des transactions repose sur plusieurs éléments clés qui permettent ensemble d’améliorer leur taux de confirmation :

Gestion des unités de calcul

1. Utilisez le SDK Helius pour obtenir le nombre optimal d’unités de calcul pour votre transaction :‍

const response = await helius.rpc.getComputeUnits({
  transaction: serializedTransaction
});

const computeUnits = response.computeUnits;

2. Ajoutez la limite d’unités de calcul à votre transaction :

transaction.add(
  ComputeBudgetProgram.setComputeUnitLimit({
    units: computeUnits
  })
);

Niveaux d’engagement

‍Pour la plupart des applications, le niveau d’engagement processed offre le meilleur équilibre. Il :

• Offre le délai de confirmation le plus court
• Garantit une sécurité suffisante pour la plupart des cas d’usage
• Réduit le risque d’expiration du blockhash
• Minimise les transactions abandonnées en période de congestion

Utilisez toujours le même niveau d’engagement pour envoyer et confirmer les transactions afin de garantir un comportement cohérent de votre application.

Configuration RPC

Définissez maxRetries sur 0 et implémentez votre propre logique de nouvelle tentative afin de mieux contrôler la retransmission des transactions. Utilisez skipPreflight: true pour réduire la latence. Cette approche est particulièrement utile pendant les périodes de forte congestion :

const signature = await connection.sendTransaction(transaction, {
  maxRetries: 0,
  skipPreflight: true
});

Utiliser un endpoint staké

L’endpoint staké de Helius offre un accès direct et garanti aux connexions stakées, ce qui évite d’optimiser manuellement les frais de priorité :

const connection = new Connection(
  'https://staked.helius-rpc.com?api-key=YOUR_API_KEY'
);

// Transaction will be processed with optimal priority
const signature = await connection.sendTransaction(transaction);

L’endpoint staké :

• Garantit une bande passante stakée
• Réduit les échecs de transaction en période de congestion
• Accélère la propagation des transactions grâce à une infrastructure dédiée

Conclusion

L’utilisation efficace des frais de priorité est essentielle pour faire confirmer les transactions sur Solana, en particulier lorsque le réseau est congestionné. En exploitant la Priority Fee API de Helius et en appliquant les stratégies présentées, vous pouvez considérablement améliorer le taux de réussite des transactions tout en maîtrisant les coûts. Suivez l’état du réseau et adaptez-vous à ses conditions pour obtenir des résultats optimaux.

Si vous avez lu jusqu’ici, merci ! Nous espérons que ce guide vous a aidé à comprendre comment optimiser vos transactions sur Solana. Abonnez-vous à notre newsletter pour ne manquer aucune actualité concernant Solana. 

Vous souhaitez aller plus loin ?

Découvrez dès aujourd’hui les derniers articles du blog Helius et poursuivez votre parcours sur Solana.