Solidity est le langage utilisé pour écrire les smart contracts sur Ethereum. Contrairement à JavaScript ou Python, Solidity compile en bytecode exécuté par l’EVM (Ethereum Virtual Machine). Si tu veux créer un token, un protocole DeFi ou un NFT, tu devras passer par Solidity (ou des alternatives comme Vyper, mais Solidity est largement majoritaire). Ce guide te montrera les concepts de base sans supposer que tu sais coder.
Qu’est-ce que Solidity exactement ?
Un smart contract Solidity est un programme enregistré sur la blockchain Ethereum. Contrairement à un script classique qui s’exécute sur ton ordinateur, un contrat Solidity :
— S’exécute sur mille nœuds Ethereum en parallèle (décentralisation)
— Chaque opération coûte du gaz (c’est une ressource limitée)
— Une fois déployé, le code ne peut pas être modifié (immuabilité)
— Les données sont publiques (transparence)
Ces trois contraintes (coût, immuabilité, transparence) façonnent comment on écrit Solidity. Elles sont aussi ses forces : tu peux faire confiance au code parce qu’il est auditable, tu ne dépends pas d’un serveur central, et le résultat est vérifiable.
Les éléments de base : variables et types
En Solidity, tu dois déclarer le type de chaque variable. Les types courants :
uint256 (entiers positifs) : utilisé pour les montants de tokens, les balances, les timestamps.
address : une adresse Ethereum (20 bytes). Ex : 0x1234…
bool : vrai ou faux. Ex : est-ce que tu es owner ?
bytes32 : 32 bytes. Souvent utilisé pour des identifiants uniques.
string : du texte. Plus coûteux en stockage, donc à éviter quand possible.
Exemple concret : un contrat de portefeuille simple aurait une variable `mapping(address => uint256) balances` qui dit « pour chaque adresse, quelle balance elle possède ».
Les fonctions : comment on interagit
Une fonction Solidity exécute une action. Elle peut :
— Lire l’état (view, pure) : gratuit
— Modifier l’état (payable, normal) : coûte du gaz
Exemple d’une fonction simple :
`function transfer(address to, uint256 amount) public {
balances[msg.sender] -= amount;
balances[to] += amount;
}`
Ici, `msg.sender` = celui qui appelle la fonction. Chaque ligne consomme du gaz. Plus ton code est optimisé, moins ça coûte.
Modificateurs : ajouter des règles
Un modificateur ajoute une condition avant d’exécuter une fonction. Exemple : un modificateur `onlyOwner` qui vérifie que seul le propriétaire peut appeler une certaine fonction.
`modifier onlyOwner() {
require(msg.sender == owner);
_;
}`
Puis tu l’utilises : `function withdraw() public onlyOwner { … }`
Cela réduit la répétition et rend le code plus lisible.
Sécurité : les pièges courants
Reentrancy : si ta fonction appelle un contrat externe, ce contrat peut te rappeler récursivement. Solution : utilise le pattern « checks-effects-interactions » (vérifie, modifie l’état, puis appelle externe).
Overflow/Underflow : si tu ajoutes 1 à un uint256 égal à max, il devient 0. Solution : utilise OpenZeppelin SafeMath ou Solidity 0.8+ (qui protège par défaut).
Appels externes non sécurisés : ne fais pas confiance à un contrat externe. Vérifie ses sources et son code avant d’appeler.
Première étape : écrire et déployer
Les outils courants :
— Remix IDE : éditeur en ligne, simple pour débuter
— Hardhat : framework complet, recommandé pour les vrais projets
— Foundry : très rapide, pour les développeurs expérimentés
Pour ton premier contrat, utilise Remix : connecte ton wallet, écris le code, déploie sur testnet (Sepolia), puis observe la transaction. Ça prend 5 minutes et tu verras immédiatement si ton code a des erreurs.
Conclusion
Solidity n’est pas difficile, mais il exige de la rigueur : chaque variable a un type, chaque fonction a un coût, et la sécurité est à ta charge. Commence par Remix, écris un simple token ERC-20 en copiant une template OpenZeppelin, puis progresse vers des contrats plus complexes. La courbe d’apprentissage est raide au début, mais gratifiante.
—
