Une nouvelle version de Solidity, le langage de développement de contrats intelligents le plus populaire d’Ethereum, a été publiée

Compilation : Plan de traduction ; Source : soliditylang.org

La dernière version du compilateur Solidity v0.8.22 a été publiée. Le compilateur 0.8.22 inclut un certain nombre d’améliorations du langage et du compilateur, telles que les définitions d’événements au niveau des fichiers, l’optimisation incrémentielle des boucles non vérifiées, la prise en charge de l’importation de JSON d’assembly EVM, etc.

IMPORTANT

Cette version déprécie la prise en charge des EVM inférieurs à Constantinople (Constantinople), qui deviennent de plus en plus difficiles à maintenir. Ces versions archaïques sont depuis longtemps obsolètes sur le réseau principal et le réseau de test d’Ethereum, et nous soupçonnons qu’elles ne sont plus pertinentes pour d’autres réseaux. Les chemins de code et les solutions complexes ralentissent le développement de fonctionnalités et les tests pour les nouvelles versions, nous prévoyons donc de cesser de les prendre en charge dans les futures versions du compilateur. Si vous comptez sur l’assistance pour ces versions EVM, veuillez nous contacter[6] 。

Points forts des nouvelles fonctionnalités

incrément de boucle non vérifié

L’utilisation de l’arithmétique non vérifiée lors de l’augmentation du compteur de boucle est destinée à l’optimisation des gaz[7] monnaie courante. Illustrons avec l’exemple suivant d’une boucle et d’un compteur i :

for (uint i = 0 ; i < array.length ; ++i) {
acc += tableau[i] ; i n’est pas modifié par le corps de la boucle
}

Dans de nombreux cas (voir les conditions exactes ci-dessous), l’opération de comparaison fera en sorte que i n’atteindra jamais la valeur maximale de son type, il est donc prudent de supposer que la boucle s’arrêtera avant que la valeur maximale ne soit atteinte. Dans ce cas, un contrôle de sécurité du compteur serait redondant et un gaspillage de gaz. Cela encourage l’utilisateur à utiliser le long modèle non coché, qui enveloppe le compteur de manière incrémentielle dans un bloc arithmétique non vérifié à l’intérieur de la boucle, en contournant la vérification :

for (uint i = 0 ; i < array.length ;) {
acc += tableau[i] ;
unchecked { i++ ; } // i est incrémenté sans vérification de dépassement -- moins de gaz utilisé
}

Solidity 0.8.22 introduit une optimisation de vérification des dépassements de capacité qui génère automatiquement un incrément arithmétique non vérifié pour le compteur de boucles. Cette nouvelle optimisation élimine le besoin d’utiliser un long motif delta non vérifié dans les corps de boucle comme celui de l’exemple précédent.

En revanche, les nouvelles optimisations permettent aux utilisateurs de revenir à un code brut et plus lisible sans sacrifier l’efficacité du gaz.

Les conditions précises pour le contrôle d’évitement des déversements nouvellement optimisé sont les suivantes :

• Les conditions de cycle sont sous la forme d’i < ... où i est une variable locale (ci-après appelée « compteur de boucles »).
• Cette comparaison doit être effectuée sur le même type que le compteur de boucles, c’est-à-dire que le type de droite doit être implicitement converti en type du compteur de boucles afin que le compteur de boucles ne soit pas implicitement étendu avant la comparaison.
• Le compteur de boucle doit être une variable locale de type entier intégré.
• L’expression de la boucle doit être un préfixe ou un suffixe pour le compteur de boucle, i++ ou ++i.
• Le compteur de cycles ne peut pas être modifié dans un état de cycle ou dans un corps de cycle.

Pour clarifier la deuxième condition, considérez l’extrait de code suivant :

for (uint8 i = 0 ; in < UINT16(1000) ; ++I) {
corps de boucle
}

Dans ce cas, i est converti en uint16 avant la comparaison, et la condition n’est jamais réellement fausse, de sorte que la vérification de dépassement de capacité incrémentée ne peut pas être supprimée.

Notez également que < est le seul opérateur de comparaison qui déclenche l’optimisation. L’opérateur <= et les autres opérateurs sont délibérément exclus. De plus, l’opérateur doit être intégré - défini par l’utilisateur, < n’est pas éligible.

L’optimisation est simple et toujours bénéfique, elle sera donc activée même si le reste de l’optimiseur est désactivé à l’aide du paramètre commun settings.optimizer.enabled. Vous pouvez le désactiver explicitement en définissant settings.optimizer.details.simpleCounterForLoopUncheckedIncrement sur false dans l’entrée JSON standard. Il ne peut pas être désactivé à l’aide de l’interface de ligne de commande.

Ajustez l’optimiseur Yul pour régénérer les littéraux zéro

La nouvelle version s’appuie sur le support de l’opcode PUSH0 introduit dans la version 0.8.20 en ajoutant le rematérialiseur[8] [9] L’étape d’optimisation est étendue pour toujours régénérer le littéral zéro au lieu de le stocker en tant que référence variable, ce qui permet d’utiliser PUSH0 à la place de DUP pour réduire les coûts de gaz. Pour s’assurer que cela est fait efficacement, Rematerialiser et UnusedPruner sont ajoutés Des étapes sont ajoutées à la séquence de nettoyage par défaut de l’optimiseur Yul.

Ajout de la prise en charge de l’importation de JSON d’assembly EVM (expérimental)

Cette nouvelle version ajoute une prise en charge expérimentale de l’importation d’assemblys EVM, ce qui ouvre la possibilité à des outils externes d’effectuer des super-optimisations avant la génération de bytecode. L’objectif principal de cette fonctionnalité est de définir un format de sérialisation pour les assemblys EVM de bas niveau afin que les assemblys générés par le compilateur puissent être exportés, modifiés et réimportés, reprenant ainsi le processus de compilation normal.

Important : Il s’agit d’une fonctionnalité expérimentale qui n’est actuellement pas disponible en production. Nous proposons cette fonctionnalité dans cette version afin que vous puissiez l’essayer et nous faire part de vos commentaires.

Permet de définir des événements au niveau du fichier

Solidity 0.8.22 vous permet de définir des événements au niveau du fichier. Les définitions d’événements peuvent désormais être placées en dehors du champ d’application du contrat. Cela offre une autre option pour l’organisation du code sans avoir à encapsuler artificiellement les événements dans une bibliothèque.

De plus, cette version corrige un bogue qui provoquait une erreur lors de la génération d’un NatSpec lors de l’émission d’un événement défini dans un contrat externe ou une interface pour le code. Dans la version précédente (0.8.21), le compilateur Solidity a ajouté la prise en charge de l’accès restreint aux événements définis dans les contrats et les interfaces qui ne sont pas hérités du contrat actuel, mais le bogue empêchait l’utilisation complète de la fonctionnalité.

Avec cette correction de bogue et l’autorisation des définitions d’événements au niveau des fichiers, la dernière version de Solidity permet aux utilisateurs de compiler les exemples suivants sans aucune erreur :

interface I {
événement Evénement Etranger() ;
}
contrat C {
événement Evénement Etranger() ;
}
événement E() ;
contrat D {
function f() public {
L’émission d’un événement étranger déclenchait une erreur interne sur 0.8.21
émet I.EvénementEtranger() ;
émettre C.EvénementEtranger() ;
Émission d’un événement au niveau du fichier. Nouvelle fonctionnalité.
émet E() ;
}
}

Journal complet des modifications

Caractéristiques de la langue

• Permet de définir des événements au niveau du fichier.

Fonctionnalités du compilateur

• Générateur de code : Suppression des vérifications de dépassement de capacité redondantes pour certaines boucles for lorsque la variable count ne déborde pas.
• Interface de ligne de commande : Ajout de l’option --no-import-callback pour empêcher le compilateur de charger les fichiers sources qui ne sont pas explicitement donnés dans l’interface de ligne de commande ou l’entrée JSON standard.
• Interface de ligne de commande : Ajout d’une option expérimentale --import-asm-json pour importer des assemblys EVM au format utilisé par --asm-json. Interface de ligne de commande : utilisez la gravité et la coloration appropriées pour les messages d’erreur générés en dehors du pipeline compilé.
• EVM : Obsolète prise en charge des versions EVM « homestead », « tangerineWhistle », « spuriousDragon » et « byzantium ».
• Analyseur : Supprime le mode de récupération d’erreur expérimentale (--error-recovery/settings.parserErrorRecovery).
• SMTChecker : Prend en charge les opérateurs définis par l’utilisateur.
• Yul Optimizer : Si PUSH0 est pris en charge, préfère utiliser zéro littéral au lieu de stocker des valeurs nulles dans les variables.
• Yul Optimizer : Exécute les étapes Rematerializer et UnusedPruner à la fin de la séquence de nettoyage par défaut.

Corrections de bugs

• Générateur de code : Correction d’un problème où la sortie via le générateur de code via IR dépendait des fichiers trouvés dans les rappels d’importation. Dans certains cas, différentes affectations d’ID AST peuvent modifier l’ordre des fonctions dans l’ordonnancement interne, ce qui donne lieu à des bytecodes apparemment différents mais sémantiquement équivalents.
• NatSpec : Correction d’une erreur interne lors de la demande de documentation utilisateur ou de documentation de développement pour un contrat qui émet un événement défini dans un contrat ou une interface externe.
• SMTChecker : Correction d’une erreur d’encodage qui provoquait l’expansion de la boucle une fois terminée.
• SMTChecker : Correction d’incohérences dans les vérifications d’état constant lorsqu’une boucle while ou for est déroulée avant une vérification d’état.
• Yul Optimizer : Correction d’un problème où les noms de variables Yul générés par le compilateur pendant CSE affectaient les décisions de remplacement, ce qui entraînait un bytecode différent (mais équivalent) dans certains cas.