Que sont les variables et constantes immuables dans Solidity et comment permettent-elles d'économiser du gaz ?

Comprendre les variables immuables dans Solidity

1. Les variables immuables dans Solidity sont déclarées à l'aide du mot-clé immuable et ne peuvent être attribuées qu'une seule fois lors de la construction du contrat. Une fois définies, leurs valeurs ne peuvent être modifiées tout au long du cycle de vie du contrat.

2. Ces variables sont résolues au moment du déploiement, permettant au compilateur d'optimiser le stockage en les plaçant dans les métadonnées du contrat plutôt que dans les emplacements de stockage utilisés pour les variables d'état normales.

3. Étant donné que les variables immuables n'occupent pas de stockage mutable, elles éliminent le besoin d'opérations SSTORE après le déploiement, qui comptent parmi les opcodes les plus coûteux d'Ethereum.

4. La valeur d'une variable immuable est généralement attribuée au sein du constructeur, ce qui la rend idéale pour les paramètres connus au moment du déploiement mais qui varient entre les instances du même contrat.

5. L'utilisation d'immuables améliore la clarté du code en signalant l'intention : les développeurs savent que certaines valeurs sont fixes après le déploiement, réduisant ainsi le risque de modifications involontaires.

Le rôle des constantes dans l'optimisation du gaz

1. Les constantes sont définies à l'aide du mot-clé constant et doivent se voir attribuer une valeur lors de la déclaration. Leurs valeurs sont codées en dur dans le bytecode lors de la compilation.

2. Étant donné que les valeurs constantes sont intégrées directement dans les instructions EVM, leur lecture n'entraîne aucun coût d'accès au stockage : cela signifie qu'aucune opération SLOAD n'est effectuée lors de la récupération de leurs valeurs.

3. Toute fonction qui utilise une constante aura cette valeur intégrée, remplaçant ainsi la référence de variable par sa valeur littérale au moment de la compilation.

4. Ce comportement d'intégration réduit à la fois le gaz d'exécution et la taille du contrat, car il n'est pas nécessaire d'allouer ou de référencer un stockage persistant pour ces valeurs.

5. Les constantes conviennent mieux aux valeurs véritablement statiques dans tous les déploiements, telles que les paramètres de protocole ou les coefficients mathématiques utilisés dans les calculs.

Différences entre les immuables et les constantes

1. Bien que les deux économisent du gaz en évitant les coûts de stockage d'exécution, les constantes nécessitent que leurs valeurs soient connues au moment de la compilation, tandis que les immuables permettent l'affectation pendant la construction.

2. Une constante ne peut dépendre d'aucune entrée ou d'un état externe : il doit s'agir d'une expression constante au moment de la compilation, telle qu'un nombre, une chaîne ou le résultat d'un appel de fonction pur avec des entrées constantes.

3. Les variables immuables offrent plus de flexibilité ; ils peuvent accepter les arguments du constructeur, permettant à différentes instances de contrat d'avoir des valeurs différentes tout en bénéficiant de coûts d'exécution réduits.

4. Du point de vue de l'utilisation du gaz, les constantes offrent généralement une optimisation légèrement meilleure puisque leurs valeurs sont entièrement résolues avant le déploiement, tandis que les immuables impliquent une initialisation unique pendant la construction.

5. Une mauvaise utilisation de l'un ou l'autre type, par exemple en déclarant immuable une valeur qui change fréquemment, peut conduire à des conceptions rigides. Un bon alignement des cas d'utilisation est donc essentiel.

Les mécanismes d’économie de gaz expliqués

1. Chaque lecture du stockage EVM à l'aide de SLOAD consomme au moins 2 100 gaz, tandis que l'accès aux valeurs stockées dans l'espace de code (comme les constantes) coûte près de zéro.

2. L'écriture sur le stockage avec SSSTORE est encore plus coûteuse, coûtant jusqu'à 20 000 gaz lors de la première écriture et 5 000 lors des mises à jour ultérieures. Les immuables évitent entièrement ce coût après la construction.

3. En déplaçant les données du stockage vers des régions de mémoire initialisées par le code ou le constructeur, les constantes et les immuables réduisent l'empreinte opérationnelle des contrats intelligents.

4. Les contrats qui s'appuient fortement sur des valeurs de configuration, telles que les pourcentages de frais, les listes d'adresses autorisées ou les plafonds de jetons, bénéficient de manière significative lorsque celles-ci sont déclarées comme constantes ou immuables.

5. Les optimisations du compilateur exploitent ces déclarations pour minimiser les opérations redondantes, supprimer les vérifications inutiles et générer un bytecode plus léger, améliorant ainsi encore l'efficacité.

Foire aux questions

Une variable immuable peut-elle être modifiée après l'exécution du constructeur ? Non. Une fois qu’une variable immuable est définie dans le constructeur, elle ne peut plus être modifiée. Toute tentative de réaffectation entraînera une erreur de compilation.

Existe-t-il des restrictions sur les types qui peuvent être déclarés comme constants ? Oui. Seuls les types de valeur tels que uint, int, bool, adresse et chaîne littéraux (avec certaines limitations) peuvent être constants. Les tableaux et les structures ne peuvent pas être déclarés constants à moins qu'ils ne soient dans un assemblage en ligne ou dans des cas particuliers gérés par des versions plus récentes du compilateur.

Les variables immuables augmentent-elles le coût du gaz de déploiement ? Ils peuvent légèrement augmenter le coût de déploiement en raison de la logique du constructeur, mais cela est compensé par des économies à long terme lors des interactions. L’effet net sur plusieurs transactions est généralement une réduction significative des dépenses totales en gaz.

Que se passe-t-il si j'essaie d'attribuer une variable immuable en dehors du constructeur ? Le compilateur Solidity générera une erreur. L'affectation de variables immuables est limitée exclusivement au contexte du constructeur, garantissant leur intégrité et leur prévisibilité.