Solidity 0.8.28 — Nouvelles fonctionnalités et breaking changes

# Solidity 0.8.28 — Nouvelles fonctionnalités et breaking changes

Solidity 0.8.28, publié en mars 2026, introduit des améliorations de performance, un nouveau support de stockage transient, et plusieurs corrections de bugs qui affectent les contrats en production.

Nouvelles fonctionnalités

1. Stockage transient (TSTORE/TLOAD)

Solidity 0.8.28 ajoute le support natif pour le stockage transient introduit avec l'EIP-1153 (activé dans Cancun).

Qu'est-ce que le stockage transient ?

Le stockage transient fonctionne comme le stockage régulier, mais les données sont effacées à la fin de la transaction. C'est parfait pour les variables temporaires qui n'ont pas besoin de persister.

// Nouveau mot-clé : transient
contract ReentrancyGuard {
    // Avant : coûtait 20,000 gas (SSTORE)
    bool private locked;

    // Après : coûte 100 gas (TSTORE)
    bool private transient locked;

    modifier nonReentrant() {
        require(!locked, "Reentrant call");
        locked = true;
        _;
        locked = false;
    }

    function withdraw() external nonReentrant {
        // Logique sécurisée
    }
}

Économies de gas :

• SSTORE (stockage permanent) : ~20,000 gas

• TSTORE (stockage transient) : ~100 gas

• 200x moins cher pour les données temporaires

Cas d'usage :

• Guards de réentrance

• Variables temporaires de calcul

• État inter-fonctions dans une même transaction

• Locks temporaires

2. Amélioration du custom errors

Les custom errors peuvent maintenant inclure des sélecteurs personnalisés :

// Avant : le sélecteur était auto-généré
error InsufficientBalance(uint256 requested, uint256 available);

// Après : vous pouvez spécifier le sélecteur
error InsufficientBalance(uint256 requested, uint256 available)
    selector(0x12345678);

Utile pour la compatibilité avec des systèmes existants ou des ABIs standardisées.

3. Optimisations du compilateur

Le compilateur génère désormais un bytecode 5-15% plus petit pour les contrats complexes grâce à :

• Meilleure inline des fonctions internes

• Élimination de code mort améliorée

• Optimisation des sauts conditionnels

# Comparez la taille du bytecode
solc --bin Contract.sol # Avant : 24,576 bytes
solc --bin Contract.sol # Après : 22,103 bytes (10% de réduction)

4. Support amélioré pour immutable

Les variables immutable peuvent maintenant être initialisées dans des expressions plus complexes :

contract Config {
    // Avant : ne compilait pas
    uint256 public immutable DEADLINE = block.timestamp + 30 days;

    // Après : fonctionne (évalué au déploiement)
    uint256 public immutable DEADLINE = _calculateDeadline();

    function _calculateDeadline() private view returns (uint256) {
        return block.timestamp + 30 days;
    }
}

Breaking changes

1. Changement de comportement de abi.decode

abi.decode est maintenant plus strict avec les données invalides.

// Avant : retournait des valeurs par défaut pour les données invalides
bytes memory badData = hex"1234";
(uint256 value) = abi.decode(badData, (uint256)); // value = 0

// Après : revert sur les données invalides
(uint256 value) = abi.decode(badData, (uint256)); // REVERT

Migration : Utilisez try/catch si vous décodez des données externes non fiables.

2. Avertissements pour tx.origin

Utiliser tx.origin génère maintenant un warning du compilateur (préparation pour dépréciation future).

// ❌ Warning : "Use of tx.origin is discouraged"
require(tx.origin == msg.sender, "No contract calls");

// ✅ Utilisez msg.sender ou une whitelist
require(msg.sender == owner, "Not authorized");

3. Suppression de fonctionnalités dépréciées

• suicide (alias de selfdestruct) : supprimé (utilisez selfdestruct directement)

• throw : supprimé (utilisez revert)

• var : supprimé (utilisez des types explicites)

Corrections de bugs critiques

CVE-2026-001 : Storage collision dans les héritages multiples

Un bug rare causait des collisions de slots de stockage avec des hiérarchies d'héritage complexes.

Affecté : Solidity 0.8.20 - 0.8.27

// Pattern problématique
contract A { uint256 public x; }
contract B { uint256 public y; }
contract C is A, B {
    uint256 public z; // Pouvait écraser y dans certains cas
}

Fix : Mise à niveau vers 0.8.28 et redéploiement des contrats affectés.

Bug de génération de bytecode avec unchecked

Les blocs unchecked imbriqués généraient parfois un bytecode incorrect.

// Pattern buggy en 0.8.27
unchecked {
    uint256 a = x + 1;
    unchecked {
        uint256 b = a + 1; // Pouvait overflow incorrectement
    }
}

Guide de migration

Étape 1 : Mettre à jour le pragma

// Avant
pragma solidity ^0.8.20;

// Après
pragma solidity ^0.8.28;

Étape 2 : Recompiler et tester

forge build
forge test

Étape 3 : Remplacer le stockage par transient si possible

// Avant
bool private locked;

// Après (économie de gas)
bool private transient locked;

Étape 4 : Corriger les warnings

solc --warnings Contract.sol

Faut-il migrer immédiatement ?

OUI si :

• Vous utilisez des héritages multiples complexes (CVE-2026-001)

• Vous utilisez des blocs unchecked imbriqués

• Vous déployez de nouveaux contrats

PEUT ATTENDRE si :

• Vos contrats sont simples et déjà audités

• Vous êtes en production sans les bugs critiques

MIGRATION RECOMMANDÉE : 0.8.28 est une mise à niveau stable avec des économies de gas significatives. Migrez vos nouveaux contrats immédiatement et planifiez la migration des contrats existants.

Checklist de migration

• [ ] Mettre à jour pragma solidity vers ^0.8.28

• [ ] Recompiler avec forge build ou hardhat compile

• [ ] Exécuter la suite de tests complète

• [ ] Remplacer le stockage temporaire par transient

• [ ] Corriger les utilisations de tx.origin

• [ ] Ajouter try/catch autour de abi.decode non fiable

• [ ] Comparer la taille du bytecode (devrait diminuer)

• [ ] Tester sur un testnet avant la production

Ressources

• Changelog Solidity 0.8.28

• Documentation EIP-1153 (Transient Storage)

• Guide de migration

Conclusion

Solidity 0.8.28 apporte des gains de performance significatifs grâce au stockage transient et aux optimisations du compilateur. Les corrections de bugs critiques rendent cette mise à niveau essentielle pour les nouveaux projets. Migrez dès que possible pour profiter des économies de gas et de la sécurité améliorée.

Prochaine étape : Testez vos contrats avec Solidity 0.8.28 sur un testnet et mesurez les économies de gas.

---

*Pratiquez le stockage transient et les fonctionnalités 0.8.28 sur Solingo — maîtrisez Solidity avec des défis interactifs.*