Qu’est-ce que Solidity ? Un langage de programmation de contrats intelligents

Une simple ligne de code Solidity, malencontreusement insérée, a permis à un pirate de s'emparer de 3,6 millions d'ETH. Le code a exécuté les instructions à la lettre. C'est là le plus inquiétant. Solidity gère les transactions financières. Son code source est généralement accessible à tous. Et une fois un contrat en production, il est impossible de le corriger discrètement : la faille persiste, les fonds restent exposés et le monde entier peut y accéder. C'est le langage de programmation dominant pour écrire des contrats intelligents sur Ethereum et toutes les blockchains EVM associées. En simplifiant le langage, on constate que la plupart des solutions DeFi et NFT reposent sur Solidity. Puissant. Mais aussi impitoyable. Voici ce qu'est Solidity, comment le code s'exécute concrètement, à quoi ressemble un premier contrat et pourquoi la sécurité est une priorité absolue.

Solidity est-il un langage de programmation ?

Tous les guides disent la même chose : Solidity est un langage de haut niveau pour les contrats intelligents. Soit. Cela ne vous avance guère. Mais de quel type de langage s’agit-il ? Statiquement typé. Orienté objet. Avec des accolades et des points-virgules, une syntaxe empruntée à JavaScript, C++ et Python. Si vous avez déjà déployé du code dans l’un de ces langages, un fichier `.sol` vous semblera familier en une dizaine de minutes.

Gavin Wood en a esquissé les contours en 2014, avec l'aide d'une petite équipe Ethereum dont faisait partie Christian Reitwiessner. L'objectif était clair : permettre aux utilisateurs d'écrire des contrats intelligents pour une blockchain publique. Son unité centrale est le « contrat ». On peut le considérer comme une « classe » qui réside sur une chaîne : il gère un état, expose des fonctions et hérite d'autres classes. La particularité réside dans son lieu d'exécution. Une fois compilé en bytecode, le même contrat s'exécute de manière identique sur chaque nœud d'un réseau décentralisé, chaque nœud vérifiant les autres. Cette exigence explique pourquoi Solidity semble si limité.

Fonctionnement de Solidity : du code à l’EVM

Ce qui est intéressant avec Solidity, ce n'est pas sa syntaxe, mais son architecture en pipeline. Un code lisible devient un code que des milliers de machines s'engagent à exécuter de la même manière. Le déterminisme est fondamental. Si deux nœuds exécutaient le même contrat et obtenaient des réponses différentes, le réseau ne pourrait pas déterminer le solde de chacun. Cette exigence explique en grande partie les limitations particulières du langage : impossible de générer un nombre aléatoire ou d'appeler une API web externe en cours d'exécution. Tout doit être reproductible au sein même de la chaîne.

Le compilateur et le bytecode

Vous écrivez un fichier `.sol`, lisible par un humain et de haut niveau. Le compilateur Solidity, `solc`, le transforme en bytecode EVM, une longue suite d'opérations de bas niveau, ainsi qu'une ABI qui liste les fonctions du contrat. C'est ce bytecode qui est exécuté sur la chaîne de compilation. Personne ne le lit manuellement. Il s'agit de la cible machine, de la même manière que le C est converti en assembleur.

L'EVM et le gaz

La machine virtuelle Ethereum exécute ce bytecode. Chaque nœud Ethereum en possède une. Chaque opération effectuée par cette machine engendre des frais de gaz, payés en ETH. Le gaz n'est pas un détail. Il permet au réseau de tarifer les calculs et de se protéger : une boucle infinie ne bloque pas la chaîne ; elle consomme simplement le gaz de l'expéditeur et provoque un retour à la normale. Une bonne implémentation de Solidity permet de limiter les frais de gaz.

L'ABI

L'ABI, ou Interface Binaire d'Application, est la représentation JSON permettant de communiquer avec un contrat déployé. Un portefeuille comme MetaMask, ou une application décentralisée (dApp) frontale, l'utilise pour encoder un appel de fonction au format attendu par la machine virtuelle Elastic (EVM), puis décoder la réponse. L'ABI fait office de pont entre l'interface utilisateur et le contrat hébergé à une adresse sur la blockchain.

Rédiger votre premier contrat intelligent Solidity

Assez de théorie. Le moyen le plus rapide de comprendre Solidity est de lire un petit contrat et d'en identifier les éléments.

Anatomie d'un contrat

```solidité

// Identifiant de licence SPDX : MIT

pragma solidité ^0.8.20;

Compteur de contrat {

uint256 public count;

event Incremented(uint256 newCount);

function increment() public {

count += 1;

emit Incremented(count);

}

}

```

Quelques éléments suffisent à tout mettre en œuvre. La ligne `pragma` spécifie la version du compilateur, empêchant ainsi une recompilation silencieuse en cas d'incompatibilité. `contract Counter` ouvre le contrat, comme une classe. `count` est une variable d'état, stockée de manière permanente sur la blockchain. `increment()` est une fonction publique accessible à tous. `event Incremented` enregistre chaque modification afin que les applications externes puissent réagir. Du code orienté objet, reposant sur une blockchain.

Les outils que vous utilisez réellement

Pour commencer, aucune installation n'est requise. Remix est un EDI pour navigateur : écrivez, compilez et déployez du code Solidity en quelques clics, ce qui en fait la plateforme de référence pour apprendre Solidity. Les projets concrets utilisent des frameworks locaux. Hardhat et Foundry gèrent correctement la compilation, les tests et le déploiement. Et la quasi-totalité des développeurs s'appuient sur OpenZeppelin, une bibliothèque de contrats audités et réutilisables pour la gestion des jetons et le contrôle d'accès, plutôt que de réinventer du code risqué.

Du code à une adresse réelle

Déployer signifie envoyer le bytecode compilé dans une transaction. Testez d'abord sur un réseau de test gratuit. Sepolia est généralement choisi sur 2026. Connectez un portefeuille comme MetaMask. Ne déployez sur le réseau principal que lorsque le contrat fonctionne correctement. Le déploiement engendre des frais de gaz, payés en ETH. Et voici une information capitale : une fois déployé, le code est immuable. Vous ne pouvez pas modifier un contrat en production. C'est ce fait précis, plus que toute autre particularité de syntaxe, qui justifie la section suivante.

Quelles blockchains prennent en charge Solidity ?

Solidity a cessé d'être le « langage d'Ethereum » il y a des années. De nombreux réseaux ont adopté la machine virtuelle Ethereum (EVM) pour réutiliser les outils d'Ethereum, si bien que Solidity est devenu le langage commun de toute une famille de chaînes. ChainList recense plus de 385 blockchains compatibles avec l'EVM en 2020. Parmi les plus importantes : Polygon, BNB Chain, Arbitrum , Base et Avalanche, qui utilisent toutes le même bytecode que celui généré par votre fichier `.sol`.

Ethereum reste le centre névralgique. Il détient environ 45 milliards de dollars de valeur bloquée, soit plus de la moitié de la DeFi totale, selon DeFiLlama . Et l'activité est en pleine croissance : près de 8,7 millions de nouveaux contrats intelligents ont été déployés au cours du seul quatrième trimestre 2025, d'après les estimations de Token Terminal. Pour un développeur, cette portée est la principale raison de privilégier Solidity à un langage lié à une seule blockchain.

Alors, qu'est-ce qui est construit avec Solidity ? Presque toutes les catégories d'applications décentralisées que vous connaissez. Les protocoles de prêt et de trading DeFi. Les contrats ERC-20 qui sous-tendent la plupart des tokens, les contrats ERC-721 qui sous-tendent les NFT. Les DAO encodent leurs règles de vote en Solidity. Les stablecoins gèrent leur offre avec. Les jeux on-chain y stockent leur logique. Lorsqu'un projet affirme être « sur Ethereum », il y a fort à parier que quelqu'un l'a écrit et déployé en Solidity.

Pourquoi la sécurité des contrats intelligents Solidity est-elle difficile ?

Les propriétés qui font la force de Solidity sont aussi celles qui rendent ses failles si coûteuses. Le code contient des fonds. Le code source est souvent public. Il est impossible de le corriger. Un attaquant peut lire votre contrat à loisir, et les fonds sont immédiatement disponibles. Ce n'est pas un langage qui permet de développer rapidement et de prendre des risques. Je n'ai jamais travaillé avec un logiciel où l'écart entre « ça compile » et « c'est sûr » est aussi important.

Réentrance et piratage de la DAO

La vulnérabilité classique de Solidity est la réentrance. Un contrat envoie des ETH à une adresse externe avant de mettre à jour son propre solde interne, et le contrat destinataire effectue des retraits répétés avant même que le premier appel ne soit terminé. En juin 2016, cette faille a précisément permis à The DAO de dérober environ 3,6 millions d'ETH, soit l'équivalent de 60 millions de dollars à l'époque. Cet incident a provoqué la scission d'Ethereum en Ethereum (ETH) et Ethereum Classic, une chaîne toujours active aujourd'hui. La solution ? Dérisoire : mettre à jour son solde interne d'abord, puis envoyer les fonds en dernier. Ce schéma a même un nom : « checks-effects-interactions ».

Dépassement d'entier et SafeMath

Avant Solidity 0.8, les opérations arithmétiques pouvaient se terminer silencieusement par un dépassement de capacité. Ajouter 1 à la valeur maximale d'un `uint256` entraînait un retour à zéro, une faille exploitée par les attaquants pour générer des soldes de jetons absurdes, comme lors de l'incident BeautyChain (fraude au président) en 2018. Pendant des années, les développeurs se sont prémunis contre ce problème grâce à une bibliothèque appelée SafeMath, qui fut un temps l'un des fichiers les plus importés de Solidity. La version 0.8 a ensuite intégré des mécanismes de contrôle des dépassements de capacité au langage même. Le bug arithmétique le plus courant est désormais corrigé par défaut, sans qu'aucune bibliothèque supplémentaire ne soit requise.

Les audits et leur coût

Les erreurs étant irréversibles, les projets sérieux investissent dans un audit. Ils s'appuient sur les composants audités d'OpenZeppelin, puis font appel à des entreprises spécialisées pour auditer l'ensemble du système. Selon les données de marché de Sherlock , un audit professionnel de contrat intelligent coûte généralement entre 25 000 et plus de 100 000 dollars pour un protocole DeFi. Les audits Solidity sont généralement 25 à 40 % moins chers que les audits Rust équivalents, du fait d'un vivier de talents plus important. Les bonnes entreprises sont également très demandées. Un protocole de taille moyenne peut attendre des semaines pour obtenir un rendez-vous, puis encore plusieurs semaines pour recevoir le rapport. Rien de tout cela n'est rapide, et rien n'est facultatif.

La bonne nouvelle, c'est que les dégâts se réduisent. Les pertes en cryptomonnaies dues aux failles de sécurité spécifiques à la finance décentralisée (DeFi) ont chuté à environ 680 millions de dollars en 2025, soit une baisse d'environ 74 % par rapport au pic de 2,62 milliards de dollars atteint en 2022, selon Immunefi . L'amélioration des outils et les contrôles de sécurité désormais intégrés au compilateur expliquent en partie cette diminution.

Solidity comparé aux autres langages de contrats intelligents

Solidity a des concurrents. Et il n'est même pas le plus sûr. Vyper est minimaliste et proche de Python, volontairement épuré pour limiter les risques d'erreurs. Curve s'appuie sur Vyper. Rust alimente les contrats sur Solana et NEAR ; plus sûr à certains égards, mais plus difficile à apprendre et plus coûteux à auditer. Alors pourquoi Solidity domine-t-il encore ? Non pas grâce à sa conception, mais grâce aux effets de réseau. L'outillage le plus complet, les bibliothèques les plus auditées, un écosystème EVM entier de chaînes et de portefeuilles : tout cela utilise déjà Solidity.

Si vous souhaitez commercialiser vos produits là où se trouvent déjà les utilisateurs et l'argent, Solidity est le choix pragmatique par défaut, même si un concurrent est techniquement plus sûr.

Devriez-vous apprendre la programmation Solidity en 2026 ?

L'engouement spéculatif autour des cryptomonnaies s'est calmé, mais la demande de développeurs maîtrisant Solidity est restée forte. D'après Electric Capital , Ethereum a accueilli environ 16 181 nouveaux développeurs entre janvier et septembre 2025, et près de 74 % des développeurs multichaînes travaillent sur les chaînes EVM. C'est là que se trouvent les emplois rémunérateurs et les bibliothèques réutilisables.

Pour apprendre la programmation Solidity de manière rationnelle : commencez par Remix, lisez la documentation officielle de Solidity, puis familiarisez-vous avec les contrats d'OpenZeppelin pour comprendre comment les professionnels structurent les tokens et le contrôle d'accès. Déployez de petits projets sur un réseau de test jusqu'à ce que les principes de sécurité deviennent automatiques et non plus mémorisables. La compétence rare ne réside pas dans l'écriture de code Solidity compilable ; beaucoup de développeurs en sont capables. Ce qui compte vraiment pour un développeur Solidity, c'est d'écrire du code qui résiste à une attaque d'un adversaire – quelqu'un qui a lu votre contrat et qui a des intérêts financiers en jeu.

Pourquoi Solidity reste le langage par défaut

Solidity est le langage par défaut pour une raison concrète, et non par effet de mode. Il est compatible avec toutes les chaînes EVM. Il offre la panoplie d'outils la plus complète. Il est au cœur de la plupart des projets DeFi et NFT. Mais la première chose à maîtriser n'est pas la syntaxe. C'est ceci : sur une blockchain, le code déployé est définitif et les bugs sont permanents. Apprenez le langage et les principes de sécurité simultanément, car ils sont indissociables. La prochaine étape, simple et gratuite, consiste à ouvrir Remix, à écrire un contrat de dix lignes et à le déployer sur un réseau de test cette semaine.

Jordan Morris

Jordan Morris is an AI expert with over a decade of experience and the author of a widely-read blog focused on artificial intelligence. His content spans a range of topics—from the ethics of machine learning to real-world applications of neural networks in business. Known for his clear writing and deep insights, Jordan has become a trusted voice in the AI community, appealing to both newcomers and seasoned professionals alike.