Tutoriel de solidité pour les débutants

Solidity est un langage de programmation de haut niveau utilisé pour rédiger des contrats intelligents auto-exécutants sur la blockchain Ethereum, permettant aux développeurs de créer des applications décentralisées sécurisées et efficaces.

Jul 20, 2025 at 07:21 am

Introduction à la solidité et aux contrats intelligents

Solidity est un langage de programmation de haut niveau et de type statiquement spécialement conçu pour écrire des contrats intelligents sur la blockchain Ethereum. Les contrats intelligents sont des accords d'auto-exécution qui appliquent et exécutent automatiquement des conditions sans intermédiaires. La compréhension de la solidité est essentielle pour les développeurs visant à construire des applications décentralisées (DAPP) sur Ethereum ou d'autres blockchains compatibles EVM.

La syntaxe de Solidity est similaire à JavaScript, ce qui le rend relativement accessible aux développeurs familiers avec la programmation Web. Cependant, l'environnement blockchain introduit des concepts uniques tels que les frais de gaz, les changements d'État et la finalité des transactions que les développeurs doivent comprendre avant d'écrire des contrats sécurisés et efficaces.

Configuration de l'environnement de développement

Avant de plonger dans l'écriture du code de solidité, il est crucial de mettre en place un environnement de développement approprié. Cela comprend l'installation d'outils qui vous permettent d'écrire, de compiler et de déployer des contrats intelligents.

• Installez Node.js et NPM : ce sont des conditions préalables pour de nombreux outils de développement Ethereum.
• Installer la truffe : un cadre de développement Ethereum populaire. Exécutez npm install -g truffle dans votre terminal.
• Installez Ganache : une blockchain personnelle pour le développement Ethereum. Téléchargez la version GUI ou CLI à partir de trufflesuite.com/ganache .
• Configurer un éditeur de code : Visual Studio Code avec l'extension Solidity par Juan Blanco est fortement recommandé.

Une fois que l'environnement est prêt, vous pouvez commencer à créer et tester des contrats intelligents localement avant de les déployer sur un test de test ou de mainnet.

Rédiger votre premier contrat intelligent Solidity

Créons un simple contrat intelligent qui stocke un nombre et permet à quiconque de le récupérer ou de le mettre à jour. Cet exemple démontre la syntaxe et la structure de solidité de base.

 pragma solidity ^0.8.0; contrat simplesorage {



uint storedData; function set(uint x) public { storedData = x; } function get() public view returns (uint) { return storedData; }
 }

• Pragma Solidity ^ 0,8,0; Spécifie la version de Solidity utilisée pour compiler le contrat.
• Contrat Simplestorage {...} définit un nouveau contrat nommé Simplestorage.
• uint stockdData; déclare une variable d'état de type entier non signé.
• La fonction SET (UInt x) public {...} permet à quiconque de mettre à jour la valeur stockée.
• fonction get () public View Returns (UInt) récupère la valeur stockée sans modifier l'état du contrat.

Ce contrat de base illustre comment les données peuvent être stockées et accessibles sur la blockchain.

Compilation et déploiement du contrat

Après avoir écrit le contrat, l'étape suivante consiste à le compiler et à le déployer à l'aide de la truffe et de la ganache.

• Créez un projet de truffes : exécutez truffle init dans un nouveau répertoire.
• Placez le dossier du contrat dans le contracts/ dossier.
• Créez un fichier de migration dans le dossier migrations/ . Exemple:

 const SimpleStorage = artifacts.require('SimpleStorage'); module.exports = fonction (déploieur) {
 deployer.Deploy (SimpLestorage);
 };

• Démarrez la ganache et assurez-vous qu'elle s'exécute sur le port 7545.
• Exécutez truffle compile pour compiler votre code de solidité.
• Exécutez truffle migrate pour déployer le contrat vers la blockchain locale.

Une fois déployé, vous pouvez interagir avec le contrat à l'aide de la console de truffe ou d'une interface frontale.

Interagir avec le contrat intelligent

Après le déploiement, vous pouvez interagir avec le contrat à l'aide de la console de truffe ou d'un frontend DAPP. Voici comment le faire via la console:

• Ouvrez la console de truffe : exécutez truffle console .
• Retrouvez l'instance du contrat déployé :
  SimpleStorage.deployed().then(function(instance) { contract = instance; })
• Appelez la fonction Get :
  contract.get().then(function(value) { console.log(value); })
• Appelez la fonction SET :
  contract.set(42, { from: '0xYourAccountAddress' })

Chaque interaction avec le contrat implique l'envoi d'une transaction (pour les modifications d'état comme SET) ou l'appel d'une fonction de vue (comme Get). Les transactions nécessitent du gaz et sont extraites, tandis que les fonctions de vue sont en lecture seule et gratuites.

Pièges et meilleures pratiques courantes

Le développement dans la solidité nécessite une attention aux détails en raison de la nature immuable et coûteuse du code de la blockchain.

• Évitez d'utiliser des versions de solidité obsolète . Utilisez toujours la dernière version stable pour bénéficier des améliorations de la sécurité.
• Utilisez la bibliothèque SafeMath pour les opérations arithmétiques pour éviter les vulnérabilités de débordement et de sous-écoulement.
• Testez soigneusement à l'aide de tests unitaires et d'outils comme le test de truffes et HardHat.
• Déployer sur des TestNets comme Goerli ou Sepolia avant Mainnet pour éviter les erreurs coûteuses.
• Audite votre code ou utilisez des outils comme Slither et Mythx pour détecter les vulnérabilités.

Comprendre ces meilleures pratiques garantit que vos contrats sont sécurisés, efficaces et prêts à utiliser en production.

Questions fréquemment posées

Q: Quelle est la différence entre une fonction marquée comme view et celle qui modifie l'état?

R: Une fonction view ne modifie pas l'état du contrat et peut être appelé sans dépenser du gaz. Les fonctions qui modifient l'état nécessitent une transaction et coûtent donc le gaz.

Q: Puis-je mettre à jour un contrat intelligent déployé?

R: Les contrats intelligents sont immuables une fois déployés. Pour mettre à jour, vous devez déployer un nouveau contrat et éventuellement utiliser un contrat de proxy pour maintenir la compatibilité en arrière.

Q: Comment gérer les erreurs de solidité?

R: Utiliser require() , assert() et revert() pour gérer les erreurs. require() est utilisé pour valider les entrées et les conditions, tandis que assert() vérifie les erreurs internes.

Q: Est-il possible de supprimer un contrat intelligent de la blockchain?

R: Non, vous ne pouvez pas supprimer entièrement un contrat. Cependant, vous pouvez utiliser la fonction selfdestruct pour supprimer son code et transférer les fonds restants vers une autre adresse.