Comment gérer les erreurs de solidité? (exiger, retourner, affirmer)

Comprendre la gestion des erreurs dans la solidité

Solidity, le langage de programmation principal pour les contrats intelligents Ethereum, fournit plusieurs mécanismes de gestion des erreurs . Ces mécanismes sont cruciaux pour garantir que les contrats se comportent de manière prévisible et en toute sécurité lorsque des conditions inattendues ou non valides se produisent. Les principaux outils disponibles pour la gestion des erreurs dans Solidity sont require , revert et assert . Chacune de ces fonctions sert un objectif différent et doit être utilisée de manière appropriée en fonction de la situation.

Utilisation require pour la validation d'entrée

La fonction require est principalement utilisée pour valider les entrées et les conditions avant d'exécuter la logique de base d'une fonction. Si la condition fournie pour require est évaluée à false , la transaction est retenue et toutes les modifications apportées à l'État sont annulées. De plus, require que les développeurs permettent aux développeurs de fournir un message d'erreur personnalisé.

Exemple:

 function transfer(address to, uint amount) public { require(amount > 0, 'Amount must be greater than zero'); require(balance[msg.sender] >= amount, 'Insufficient balance'); balance[msg.sender] -= amount; balance[to] += amount;

}

Dans cet exemple, require garantit que l'expéditeur a un solde suffisant et que le montant transféré est valide. Si l'une ou l'autre condition échoue, la transaction revient avec un message d'erreur clair.

Utilisation revert pour les conditions d'erreur personnalisées

La fonction revert offre plus de flexibilité que require en permettant aux développeurs de réintégrer l'exécution à tout moment d'une fonction. Il est particulièrement utile lorsqu'il s'agit d' une logique complexe ou de plusieurs conditions qui peuvent ne pas être facilement gérées par une seule instruction require .

Exemple:

 function withdraw(uint amount) public { if (amount > balance[msg.sender]) { revert('Insufficient funds for withdrawal'); } if (block.timestamp < lockTime[msg.sender]) { revert('Funds are locked until a later time'); } balance[msg.sender] -= amount; payable(msg.sender).transfer(amount);

}

Dans ce scénario, revert est utilisé pour gérer deux conditions distinctes qui pourraient empêcher un retrait. Chaque condition est évaluée séparément et un message spécifique est renvoyé lorsque la condition échoue.

Utilisation assert pour la détection des erreurs internes

La fonction assert est destinée à vérifier les invariants et à attraper des erreurs internes qui ne devraient jamais se produire dans des circonstances normales. Contrairement à require et revert , l'utilisation assert consomme tout le gaz fourni dans la transaction lorsqu'il est déclenché. Par conséquent, il doit être réservé aux situations où un bug critique est suspecté.

Exemple:

 function calculateSum(uint a, uint b) internal pure returns (uint) { uint sum = a + b; assert(sum >= a); return sum;

}

Dans cette fonction, assert garantit que l'opération d'addition n'entraîne pas un sous-écoulement ou un débordement. Si une telle anomalie se produit, la transaction revient, indiquant un bogue potentiel dans le code.

Différences entre require , revert et assert

La compréhension des distinctions entre require , revert et assert est essentielle pour une gestion efficace des erreurs dans la solidité:

• Consommation de gaz : require et revert à ne consommer que du gaz jusqu'au point de l'erreur, tandis que assert consomme tous les gaz fournis.
• Cas d'utilisation : require est le meilleur pour la validation des entrées, revert les conditions personnalisées et assert les vérifications de la logique interne.
• Messages d'erreur : les deux require et revert les messages d'erreur personnalisés; assert ne fournit pas de moyen de retourner des messages personnalisés dans les anciennes versions de la solidité (avant 0,8.0).

Le choix de la méthode de gestion des erreurs appropriée garantit que vos contrats intelligents sont à la fois sécurisés et efficaces .

Erreurs personnalisées dans la solidité

À partir de Solidity 0.8.0 , les développeurs peuvent définir des types d'erreur personnalisés , qui sont plus économes en gaz et lisibles que les messages d'erreur basés sur des chaînes. Les erreurs personnalisées sont définies à l'aide du mot clé error et peuvent être utilisées en conjonction avec revert .

Exemple:

 error InsufficientBalance(uint requested, uint available); error FundsLocked(uint releaseTime, uint currentTime); Fonction se retirer (montant uint) public {


if (amount > balance[msg.sender]) { revert InsufficientBalance(amount, balance[msg.sender]); } if (block.timestamp < lockTime[msg.sender]) { revert FundsLocked(lockTime[msg.sender], block.timestamp); } balance[msg.sender] -= amount; payable(msg.sender).transfer(amount);
 }

En utilisant des erreurs personnalisées , les développeurs peuvent fournir des informations d'erreur structurées qui sont à la fois faciles à comprendre et efficaces en termes d'utilisation du gaz.

Questions fréquemment posées

Q: Puis-je utiliser assert pour la validation d'entrée? R: Non, assert ne doit pas être utilisée pour la validation d'entrée. Il est conçu pour les contrôles internes et ne doit être utilisé que pour détecter le code inaccessible ou les bogues critiques .

Q: Comment les erreurs personnalisées économisent-elles le gaz par rapport aux messages de chaîne? R: Les erreurs personnalisées sont codées sous forme de sélecteurs de quatre octets , similaires aux signatures de fonction, qui sont beaucoup plus courtes et moins chères que les messages de chaîne complets. Il en résulte une baisse des coûts de gaz lorsqu'une erreur est déclenchée.

Q: Que se passe-t-il si je ne gère pas les erreurs dans mon contrat? R: Si les erreurs ne sont pas correctement gérées, des conditions non valides ou inattendues peuvent entraîner des changements d'état incorrects , une perte de fonds ou des vulnérabilités qui peuvent être exploitées par les attaquants.

Q: Puis-je combiner require et revert dans la même fonction? R: Oui, require et revert peuvent être utilisées ensemble dans la même fonction. require est généralement utilisée pour des vérifications de condition simples, tandis que revert est utilisé pour des renversés plus complexes ou conditionnels plus tard dans la fonction.