Glamsterdam Ethereum : risques, tests et report de Hoodi
Glamsterdam modifie les coûts de gas sur Ethereum et peut briser des hypothèses de contrats. Comprenez le report de Hoodi et les vérifications à mener.

Glamsterdam : pourquoi Ethereum reporte le fork de Hoodi
La prochaine mise à niveau d'Ethereum, Glamsterdam, est en cours de test sur des réseaux dédiés. Et ces essais ont déjà fait remonter un vrai sujet : selon Chainsecurity, certains projets pourraient ne plus se comporter comme prévu après l'activation des EIP-8037 et EIP-8038. Concrètement, ces propositions changent la facturation du gas pour certaines opérations, et la façon dont on calcule les coûts liés à l'état du réseau.
Le risque ne se résume pas à une simple hausse de frais. Des contrats et des applications peuvent s'appuyer, parfois sans le dire clairement, sur des hypothèses de coût ou de consommation de gas. Si ces hypothèses bougent, une transaction peut échouer, un mécanisme de protection peut réagir autrement, ou une opération qui passait jusque-là peut dépasser une limite prévue. À la suite de ces alertes, l'équipe Ethereum a décidé de retarder le fork et de ne pas mettre à niveau le réseau de test Hoodi tant que les problèmes ne sont pas clarifiés.
Voici ce qui est établi, quels projets devraient regarder leur code, et une façon pratique d'organiser cet audit. L'objectif est simple : repérer les dépendances réelles, sans partir en extrapolation.
Ce que changent les EIP-8037 et EIP-8038
Glamsterdam est la prochaine mise à niveau d'Ethereum. Parmi ses changements, les EIP-8037 et EIP-8038 révisent certains coûts de gas : le montant facturé pour des opérations spécifiques, ainsi que la manière de facturer le gas lié à l'état du réseau. C'est ce périmètre qui motive les vérifications de compatibilité en cours.
Le gas correspond au travail nécessaire pour exécuter une transaction. Il sert notamment à limiter les ressources mobilisées et à faire payer l'exécution. Du coup, on ne peut pas réduire ce type de changement à « une variation du coût moyen pour l'utilisateur ». Dans un contrat, le gas peut aussi devenir une contrainte : une opération doit tenir dans une limite, un appel doit passer une quantité de gas donnée, ou une logique suppose qu'un geste « coûte toujours à peu près pareil ».
Les faits établis et les limites de l'information
D'après les informations disponibles, ces deux EIP modifient le coût de certaines opérations et la facturation du gas lié à l'état. Chainsecurity a identifié des projets qui pourraient être exposés parce qu'ils s'appuient sur des invariants que les changements ne préserveraient plus. Un dépôt de ressources recense ces invariants, les explique, et propose des exemples et des consignes pour examiner un projet.
En revanche, l'annonce ne liste pas les huit invariants, ni les projets concernés, ni les conditions exactes d'exploitation. Il serait donc trop risqué d'en déduire qu'un protocole précis (ou une catégorie entière de contrats) est forcément touché. Pour savoir si un système est exposé, il faut regarder le détail du dépôt, puis le recouper avec le code et les usages réels du projet.
Ce que cela signifie pour une application
Même si l'interface d'un contrat ne change pas, une modification de tarification du gas peut casser des dépendances. Le risque peut concerner une transaction complexe, une séquence d'appels en chaîne, ou une opération qui se trouve juste au voisinage d'une limite. Il peut aussi se déplacer hors chaîne : scripts de déploiement, robots d'exécution, interfaces et services qui estiment le gas avant d'envoyer une transaction.
La vraie question n'est donc pas uniquement : « le contrat compile-t-il ? ». Il faut aussi savoir si les opérations critiques réussissent avec les nouvelles règles de calcul, et si les composants qui les déclenchent prennent les bonnes décisions quand le coût change ou quand ça échoue. Tant que les spécifications exactes et les cas couverts ne sont pas vérifiés, toute conclusion reste forcément conditionnelle.
Pourquoi les invariants des contrats sont en jeu
Un invariant est une propriété qu'un système suppose toujours vraie. Dans un contrat intelligent, ça peut être une relation entre des valeurs, une limite de gas attendue, ou une condition sur la façon dont des appels s'enchaînent. Certains invariants sont vérifiés dans le code. D'autres ne sont jamais écrits quelque part : ils vivent dans les choix de conception, les tests, ou les outils de l'équipe.
Et c'est justement ce deuxième cas qui est pénible à repérer. Un contrat peut fonctionner correctement pendant des années et continuer à dépendre d'un comportement qui n'est pas garanti sur le long terme. Une mise à niveau du protocole peut rendre cette hypothèse fausse, sans modifier une ligne du contrat. Ce n'est pas une preuve que Glamsterdam rend « tout incompatible » ; c'est un risque classique dès qu'une application s'appuie sur une infrastructure qui évolue.
Le coût de gas peut devenir une condition de fonctionnement
Prenons un exemple simple : un contrat fait plusieurs appels, et le projet a prévu une quantité de gas donnée pour chacun d'eux. Si le coût d'une opération change, le budget total prévu peut ne plus suffire. Visiblement, ça peut se traduire par un échec de transaction, mais ce que ça fait ensuite dépend du code : la transaction peut s'annuler, un traitement peut être interrompu, ou un système automatisé peut tenter de relancer sans fin.
Autre cas : une application estime le coût de la transaction hors chaîne, puis la soumet seulement si elle est en dessous d'un seuil. Si l'estimation devient fausse, vous pouvez obtenir des refus injustifiés ou des transactions qui échouent malgré le « ok » donné par le calcul. Le problème n'est alors pas seulement dans le contrat : il est dans toute la chaîne entre le calcul, la signature, l'envoi et le traitement.
Une dépendance peut être indirecte
Beaucoup d'équipes se focalisent sur leurs propres contrats. Sauf que, dans la pratique, une application DeFi, un portefeuille ou un service de garde dépend souvent aussi de bibliothèques, de contrats tiers et d'outils d'automatisation. Une hypothèse fragile peut se retrouver dans une couche moins regardée : un module de routage, un mécanisme de liquidation, ou un script utilisé uniquement lors d'une opération de maintenance.
C'est pour ça qu'un audit de compatibilité doit suivre le parcours des opérations critiques, pas seulement parcourir le contrat principal. Il faut identifier les appels qui traversent plusieurs composants, les limites de gas codées dans le code, et les dépendances aux estimations fournies par des logiciels externes. Les invariants publiés pour Glamsterdam peuvent aider à orienter la recherche, mais ils ne remplacent pas une analyse au contexte du projet.
Quels projets doivent vérifier leur compatibilité ?
La demande vise les développeurs de contrats, les auditeurs, et plus largement les équipes qui maintiennent des projets sur Ethereum. Elle touche aussi les éléments hors chaîne : l'annonce rappelle que les équipes qui coordonnent les mises à niveau ne peuvent pas auditer, seules, tous les projets et tout leur code applicatif.
Commencez par les systèmes dont l'échec a un impact immédiat sur les fonds, l'accès à un service, ou le bon fonctionnement d'un marché. Ça peut inclure des protocoles DeFi, des coffres, des contrats de règlement, des ponts ou des outils d'administration - à condition qu'ils reposent sur les invariants concernés. Cette liste sert surtout à prioriser : elle ne veut pas dire que tout ce qui ressemble à une catégorie donnée est forcément vulnérable.
Les signaux qui justifient une revue prioritaire
Cherchez dans le code, les tests et les outils d'exploitation :
- des limites ou des valeurs de gas codées en dur, ou des appels dont le budget est calculé à partir d'un coût attendu ;
- des transactions qui enchaînent de nombreux appels ou dépendent de plusieurs étapes qui doivent aboutir ;
- des scripts, robots ou services qui simulent une transaction avant de l'envoyer ;
- des mécanismes sensibles au temps : liquidations, enchères, opérations de règlement ;
- des fonctions rarement utilisées, mais indispensables pour récupérer, migrer ou administrer un contrat.
Ces éléments ne prouvent pas que le projet est exposé aux EIP-8037 ou EIP-8038. Ils montrent juste où une hypothèse de gas peut avoir des conséquences concrètes. Ensuite, il faut rapprocher ces composants des invariants recensés pour Glamsterdam, et vérifier si la dépendance est réelle (ou juste une coïncidence de forme).
Examiner aussi les systèmes hors chaîne
Dans la vraie vie, une transaction peut échouer avant même d'atteindre le contrat. Une interface peut estimer son coût, un robot peut décider de ne pas l'envoyer, ou un service peut la construire avec un budget trop bas. Dans le périmètre de revue, il faut donc inclure les clients, les scripts d'exploitation, les simulateurs, les systèmes de surveillance et les procédures manuelles.
Si votre équipe dépend de fournisseurs ou de bibliothèques tiers, ça aide de documenter qui maintient chaque composant et comment une mise à jour de protocole est prise en compte. Une dépendance n'est pas forcément un risque. Mais une dépendance sans responsable clairement identifié est plus difficile à tester et à corriger vite.
Pourquoi le fork de Hoodi est-il retardé ?
Après les constats de Chainsecurity, les développeurs d'Ethereum ont décidé de retarder le fork et de ne pas mettre à niveau Hoodi tant que les problèmes ne sont pas résolus. Cette décision s'inscrit dans le cadre des échanges AllCoreDev, où les équipes doivent avoir assez d'éléments pour savoir quoi faire ensuite. Elle bloque une étape de test, mais ne signifie pas que Glamsterdam est annulé.
Un réseau de test comme Hoodi sert à vérifier une mise à niveau dans un environnement distinct du réseau principal. Mais tester les règles du protocole ne suffit pas à garantir que toutes les applications construites dessus se comporteront correctement. Chaque projet a ses contrats, ses paramètres, ses services et ses procédures. Résultat : une modification peut être « correcte » côté protocole et, en même temps, casser une hypothèse fragile dans une application précise.
Une décision de prudence, pas une conclusion sur l'ensemble de l'écosystème
Ce report donne le temps de comprendre quels projets peuvent être touchés, et si des ajustements de spécification permettent d'éviter certains problèmes. La Fondation Ethereum indique qu'elle mobilise Chainsecurity et Dedaub, tout en menant des audits internes. C'est utile, mais ça ne couvre pas automatiquement chaque application et chaque composant hors chaîne.
En pratique, la démarche repose donc sur deux sources de travail : l'analyse côté protocole, et les retours des équipes qui connaissent leurs propres systèmes. Pour les mainteneurs, signaler une incompatibilité potentielle permet d'apporter des éléments concrets à la décision. Pour les utilisateurs, le report sert à réduire le risque, pas à conclure qu'un projet est « safe » ou « pas safe ».
Hegota suit son propre calendrier
L'annonce précise que les travaux sur Hegota continuent en parallèle. Il faut distinguer cette continuité de la décision concernant Glamsterdam : le report de l'étape sur Hoodi ne bloque pas tout le développement d'Ethereum. Les deux évolutions peuvent avancer en même temps, même si leurs calendriers et leurs décisions techniques restent séparés.
Pour les équipes applicatives, la conséquence pratique est simple : suivez les changements qui touchent vos dépendances, plutôt que de traiter chaque annonce comme si le réseau principal allait changer demain.
Comment auditer un projet avant Glamsterdam ?
Une revue utile doit produire quelque chose de concret : est-ce que le projet dépend d'un invariant concerné ? quel composant est exposé ? quel scénario échoue ? quelle correction est nécessaire ? Se contenter d'exécuter une suite de tests déjà en place ne suffit pas si ces tests ne couvrent pas les hypothèses identifiées. Il faut relier les changements annoncés aux parcours réellement utilisés par le produit.
Une méthode en cinq étapes
- Cartographiez les composants critiques. Listez contrats, bibliothèques, robots, interfaces, services d'estimation et procédures d'administration. Précisez quelles fonctions déplacent des fonds ou conditionnent l'accès à un service.
- Étudiez les invariants publiés pour Glamsterdam. Pour chacun, notez l'hypothèse visée, les exemples fournis et les endroits du projet où ça peut se raccrocher. Ne concluez pas à une exposition juste parce qu'un extrait de code « ressemble » à quelque chose.
- Cherchez les hypothèses explicites et implicites. Relevez les valeurs de gas, les appels imbriqués, les calculs de budget, les conditions d'arrêt et les attentes des systèmes hors chaîne. Demandez aux développeurs pourquoi chaque limite existe.
- Construisez des tests représentatifs. Reproduisez les opérations importantes avec les conditions de test pertinentes par rapport aux changements annoncés. Vérifiez succès, échecs, reprises et impacts sur l'état du système. Documentez aussi les hypothèses de l'environnement de test.
- Décidez et transmettez le résultat. Évaluez le risque, désignez un responsable, préparez une correction si nécessaire, et communiquez ce qui est utile aux équipes Ethereum.
Distinguer les niveaux de risque
Une grille simple évite de confondre un détail sans conséquence et un vrai risque opérationnel. Regardez chaque constat sous trois angles : la probabilité que le parcours réel soit touché, la gravité de l'impact, et la capacité du projet à détecter puis corriger. Un échec dans un outil de simulation interne ne pèse pas le même poids qu'une opération de liquidation ou un retrait impossible.
Pensez aussi au niveau de preuve. « Le code contient une limite de gas » est une observation. « Cette limite dépend d'un invariant modifié » est une hypothèse à vérifier. « Le parcours échoue dans les conditions de test » est un résultat reproductible. Ce tri rend les échanges avec les auditeurs plus rapides, et évite de gonfler une alerte de départ.
Partager les constats de façon exploitable
Si votre projet semble affecté, l'annonce demande de contacter l'équipe à l'adresse glamsterdam@ethereum.org. Un signalement utile précise le composant, l'invariant concerné, les conditions de reproduction, l'effet observé et les solutions envisagées. Inutile d'envoyer juste une inquiétude générale : sans scénario reproductible, il est difficile de dire si un changement de spécification est nécessaire.
Pour une équipe produit, c'est aussi l'occasion de revoir vos procédures de mise à niveau : qui surveille les changements, qui valide les tests, comment les utilisateurs sont informés, et quelles opérations peuvent être suspendues si une incompatibilité est confirmée. Oui, ça a un coût. Mais il est souvent plus bas que le coût d'une correction en urgence après activation sur un réseau utilisé en production.
Conclusion : transformer le délai en travail utile
Le report de Hoodi montre une chose assez fréquente : une évolution de protocole peut faire apparaître des dépendances qu'on ne voit pas forcément dans l'usage quotidien. Les EIP-8037 et EIP-8038 changent certains coûts de gas ; les risques mentionnés concernent des invariants dont certains projets dépendent, y compris dans leurs composants hors chaîne.
La bonne approche, ce n'est ni de supposer que tout le monde est touché, ni d'attendre passivement l'annonce suivante. Cartographiez vos opérations critiques, recoupez-les avec les invariants publiés, testez les scénarios réalistes, puis partagez des constats vérifiables. C'est ce qui permet de décider s'il faut corriger un projet ou ajuster une spécification avant que le changement ne soit activé sur un réseau utilisé en production.