Introduction à Solidity et aux Smart Contracts

Contexte du cours : Maîtrisez le Développement Web3 : Créer des DApps avec Solidity et React

1. Introduction au Web3, aux Blockchains et aux Smart Contracts

Le développement Web3 est en pleine effervescence, marquant une nouvelle ère pour internet. Alors que le Web2 est centralisé et basé sur des plateformes contrôlées par des entreprises, le Web3 vise à être décentralisé, transparent et plus résistant à la censure, grâce à des technologies comme la blockchain.

Qu'est-ce qu'une Blockchain ?

Imaginez un grand registre public, partagé et distribué sur des milliers d'ordinateurs à travers le monde. Chaque nouvelle entrée (transaction) est regroupée dans un "bloc", qui est ensuite lié cryptographiquement au bloc précédent, formant une "chaîne" de blocs. Cette structure garantit :

Immuabilité : Une fois qu'une transaction est enregistrée, elle ne peut plus être modifiée ou supprimée.
Transparence : Toutes les transactions sont visibles par tous les participants du réseau.
Décentralisation : Aucune autorité centrale ne contrôle le registre. Il est maintenu par un réseau de participants.

Ethereum est l'une des blockchains les plus populaires et la première à avoir introduit le concept de Smart Contracts.

Qu'est-ce qu'un Smart Contract ?

Un Smart Contract (ou contrat intelligent) est un programme informatique auto-exécutant stocké et exécuté sur une blockchain. Il s'agit d'un accord dont les termes sont écrits directement dans le code.

Analogie du distributeur automatique : Pensez à un distributeur automatique. Vous insérez de l'argent (condition), vous sélectionnez une boisson (condition), et le distributeur vous donne la boisson et votre monnaie (exécution automatique). Il n'y a pas besoin d'une personne pour valider la transaction. Le Smart Contract fonctionne de manière similaire, mais dans le monde numérique, sans intervention humaine après son déploiement.

Caractéristiques Clés des Smart Contracts :

Autonomie : Ils s'exécutent automatiquement lorsque les conditions prédéfinies sont remplies.
Immuabilité : Une fois déployés sur la blockchain, ils ne peuvent pas être modifiés. Leur comportement est fixé.
Transparence : Leur code est public et vérifiable par tous.
Fiabilité : L'exécution est garantie par le réseau blockchain et n'est pas sujette à l'erreur humaine ou à la censure d'une entité unique.

Les Smart Contracts sont au cœur de la plupart des applications décentralisées (DApps) et de la finance décentralisée (DeFi). Ils permettent de créer des systèmes sans intermédiaires, comme des systèmes de vote, des plateformes de prêt, des jeux, et bien plus encore.

2. Qu'est-ce que Solidity ?

Solidity est un langage de programmation orienté contrat conçu spécifiquement pour l'écriture de Smart Contracts sur la Machine Virtuelle Ethereum (EVM). L'EVM est l'environnement d'exécution de la blockchain Ethereum, où tous les Smart Contracts sont déployés et exécutés.

Origines et Influences

Créé par l'équipe Ethereum, Solidity a été fortement influencé par des langages comme JavaScript, C++ et Python. Il partage certaines similitudes syntaxiques, ce qui peut faciliter son apprentissage pour les développeurs ayant déjà une expérience dans ces langages.

Compilation pour l'EVM

Lorsque vous écrivez un Smart Contract en Solidity, ce code n'est pas directement exécuté par l'EVM. Il doit d'abord être compilé en bytecode (code machine de l'EVM). C'est ce bytecode qui est ensuite déployé sur la blockchain Ethereum et interprété par l'EVM.

Pourquoi Solidity ?

Sécurité : Conçu avec la sécurité en tête, Solidity inclut des fonctionnalités pour prévenir les vulnérabilités courantes.
Écosystème Mature : Bénéficie d'un vaste écosystème d'outils, de frameworks et de communautés pour le développement et l'audit.
Spécificité Blockchain : Il intègre des concepts natifs à la blockchain (gestion des adresses, de l'Ether, etc.) qui simplifient le développement.
Turing-complet (avec restrictions) : Permet d'écrire des logiques complexes et d'implémenter n'importe quel algorithme computable.

3. Anatomie d'un Smart Contract en Solidity

Découvrons les composants fondamentaux d'un Smart Contract en Solidity à travers un exemple simple.

Structure de Base

// SPDX-License-Identifier: MIT
// Déclare la licence du code. Important pour la communauté et l'audit.

pragma solidity ^0.8.0;
// Pragma : Indique la version du compilateur Solidity à utiliser.
// ^0.8.0 signifie "compatible avec les versions 0.8.0 et supérieures, mais inférieures à 0.9.0".

contract MonPremierContrat {
    // Le mot-clé 'contract' définit le contrat.
    // 'MonPremierContrat' est le nom de notre contrat.

    // Variables d'état : Stockées de manière permanente sur la blockchain.
    string public message = "Bonjour le monde des Smart Contracts !";

    // Fonction de type 'view' : Ne modifie pas l'état, coûte 0 gaz pour la lecture (hors transaction).
    function lireMessage() public view returns (string memory) {
        return message;
    }

    // Fonction qui modifie l'état : Coûte du gaz pour être exécutée (car elle change la blockchain).
    function definirMessage(string memory _nouveauMessage) public {
        message = _nouveauMessage;
    }
}

Explication des Composants

SPDX-License-Identifier: MIT: C'est une convention pour indiquer la licence de votre code. C'est une bonne pratique pour clarifier les droits d'utilisation. MIT est une licence permissive populaire.
pragma solidity ^0.8.0;:
- Le mot-clé pragma est utilisé pour activer certaines fonctionnalités du compilateur ou vérifier sa version.
- solidity ^0.8.0 signifie que le code est compatible avec n'importe quelle version du compilateur Solidity allant de 0.8.0 (inclus) jusqu'à 0.9.0 (exclus). Il est crucial d'utiliser une version du compilateur compatible pour éviter des problèmes inattendus.
contract MonPremierContrat { ... }:
- Le mot-clé contract est utilisé pour déclarer un Smart Contract.
- MonPremierContrat est le nom de notre contrat. Tout le code du contrat est enfermé entre les accolades {}.
Variables d'état (string public message;):
- Ce sont des variables dont la valeur est stockée de manière permanente sur la blockchain. Elles définissent l'état du contrat.
- string est le type de donnée.
- public est un spécificateur de visibilité. Il signifie que la variable est accessible de l'intérieur et de l'extérieur du contrat. Pour les variables d'état public, Solidity génère automatiquement une fonction view pour lire leur valeur.
- message est le nom de la variable.
- "Bonjour le monde des Smart Contracts !" est sa valeur initiale.
Fonctions (function lireMessage() ...):
- Les fonctions contiennent la logique exécutable du contrat.
- lireMessage():
  - public : Signifie que la fonction peut être appelée de l'intérieur ou de l'extérieur du contrat.
  - view : Indique que la fonction ne modifie pas l'état de la blockchain. Elle ne fait que lire des données. Les fonctions view sont gratuites à exécuter si elles sont appelées en dehors d'une transaction.
  - returns (string memory) : Spécifie le type de valeur que la fonction retourne. memory est un emplacement de données temporaire pour les variables de type référence (comme string ou array).
- definirMessage(string memory _nouveauMessage):
  - public : La fonction est accessible de l'extérieur.
  - Cette fonction modifie l'état (message = _nouveauMessage;). De ce fait, elle coûte du "gaz" (frais de transaction sur Ethereum) pour être exécutée.
  - string memory _nouveauMessage : _nouveauMessage est un paramètre de la fonction. Le préfixe _ est une convention courante pour les paramètres afin de les distinguer des variables d'état.

Autres Concepts Importants

Types de visibilité des fonctions :
- external : Ne peut être appelée que de l'extérieur du contrat.
- public : Peut être appelée de l'intérieur et de l'extérieur du contrat.
- internal : Ne peut être appelée que de l'intérieur du contrat ou par des contrats dérivés.
- private : Ne peut être appelée que de l'intérieur du contrat où elle est définie.
pure : Similaire à view, mais n'accède à aucune variable d'état du contrat. Elle ne fait que des calculs basés sur ses paramètres.
payable : Une fonction marquée payable peut recevoir des Ether lors de son appel. Sans ce modificateur, l'appel de la fonction avec de l'Ether échouera.
Constructeur (constructor()):
- Une fonction spéciale qui est exécutée une seule fois lors du déploiement du contrat.
- Elle est utilisée pour initialiser les variables d'état.
```
contract MonContratAvecConstructeur {
    address public deployer;

    constructor() {
        deployer = msg.sender; // L'adresse qui a déployé le contrat
    }
}
```
msg.sender et msg.value:
- msg.sender : L'adresse de la personne (ou du contrat) qui a appelé la fonction actuelle.
- msg.value : La quantité d'Ether (en Wei) envoyée avec l'appel de la fonction.
Événements (event):
- Les événements sont un moyen pour les Smart Contracts de "communiquer" avec le monde extérieur.
- Lorsqu'un événement est émis, il est enregistré dans les logs de transaction de la blockchain et peut être écouté par des applications décentralisées (DApps) ou des services externes.
- Utile pour la notification de l'état ou le débogage.
```
event MessageModifie(address indexed _qui, string _ancienMessage, string _nouveauMessage);

function definirMessage(string memory _nouveauMessage) public {
    string memory ancien = message;
    message = _nouveauMessage;
    emit MessageModifie(msg.sender, ancien, message); // Émettre l'événement
}
```
require() et revert():
- require(condition, "message d'erreur") : Utilisé pour valider les entrées ou les conditions avant d'exécuter la logique. Si la condition est fausse, la transaction est annulée et tout le gaz dépensé est remboursé (sauf le gaz utilisé avant le require).
- revert("message d'erreur") : Arrête immédiatement l'exécution et annule la transaction. Utile pour des conditions plus complexes ou des erreurs spécifiques.

4. Développement Pratique avec Solidity : L'IDE Remix

Pour débuter avec Solidity, l'environnement de développement intégré (IDE) Remix est un excellent point de départ. C'est un IDE basé sur le navigateur, ce qui signifie que vous n'avez rien à installer localement.

Fonctionnalités de Remix

Éditeur de code : Pour écrire votre code Solidity.
Compilateur : Pour transformer votre code Solidity en bytecode EVM.
Déploiement et exécution : Pour déployer vos contrats sur différentes blockchains (réseaux de test comme Sepolia, ou des environnements simulés) et interagir avec eux.
Débogueur : Pour analyser le comportement des transactions.

Étapes pour le premier déploiement dans Remix (Conceptuel)

Ouvrez Remix : Allez sur https://remix.ethereum.org/.
Créez un nouveau fichier : Dans l'explorateur de fichiers (icône en haut à gauche), cliquez sur l'icône de nouveau fichier et nommez-le MonPremierContrat.sol.
Collez le code : Copiez le code de MonPremierContrat que nous avons vu plus haut dans l'éditeur.
Compilez : Allez dans l'onglet "Solidity Compiler" (icône du marteau). Assurez-vous que la version du compilateur correspond à votre pragma (ex: 0.8.x). Cliquez sur "Compile MonPremierContrat.sol".
Déployez : Allez dans l'onglet "Deploy & Run Transactions" (icône Ethereum).
- Choisissez un environnement. Pour un test rapide, "JavaScript VM (Shanghai)" est parfait car il simule une blockchain locale.
- Sélectionnez votre contrat dans le menu déroulant "Contract".
- Cliquez sur le bouton "Deploy".
Interagissez : Une fois déployé, votre contrat apparaîtra sous "Deployed Contracts". Vous pourrez appeler les fonctions lireMessage (bouton bleu) et definirMessage (bouton orange, nécessitant un paramètre) et observer les résultats.

5. Résumé et Prochaines Étapes

Nous avons fait un tour d'horizon de :

L'importance du Web3 et des Blockchains pour un internet décentralisé.
Ce que sont les Smart Contracts : des programmes auto-exécutants sur la blockchain, offrant immuabilité et transparence.
Solidity : le langage principal pour écrire ces contrats sur Ethereum, avec ses spécificités et sa syntaxe.
Les composants clés d'un contrat Solidity : pragma, contract, variables d'état, fonctions (public, view, pure, payable), constructor, events, et msg.sender/msg.value.
L'outil pratique Remix IDE pour commencer le développement.

Ce n'est que le début ! Pour maîtriser le développement Web3, les prochaines étapes incluront :

Types de données avancés en Solidity (mappings, structs, enums).
Meilleures pratiques de sécurité pour écrire des contrats robustes.
Tests de contrats avec des frameworks comme Hardhat ou Foundry.
Déploiement sur des réseaux de test réels (ex: Sepolia).
Développement d'interfaces utilisateur (Front-end) pour interagir avec vos contrats via React et les bibliothèques Web3 (Ethers.js, Wagmi, viem).

Les Smart Contracts sont une technologie puissante qui permet de construire des applications décentralisées et transparentes. Avec Solidity, vous tenez la clé pour commencer à bâtir le futur du web.