Ethereum & Smart Contracts (Avancé) — Module 1/3 — 20 min

Solidity et le développement dApps

Solidity et le développement de dApps

Qu'est-ce que Solidity ?

Solidity est le langage de programmation principal pour écrire des smart contracts sur Ethereum. Créé en 2014 par Gavin Wood, il est aujourd'hui maintenu par la Ethereum Foundation.

Solidity est un langage orienté objet, typé statiquement, influencé par JavaScript, Python et C++. Il compile en **bytecode EVM** exécutable sur la blockchain.

Structure d'un smart contract Solidity

Un contrat Solidity se compose de plusieurs éléments :

  • pragma : indique la version du compilateur
  • contract : déclare le contrat (équivalent d'une classe)
  • state variables : données stockées de façon permanente en blockchain
  • functions : la logique du contrat
  • events : permettent d'émettre des logs sur la blockchain
  • modifiers : conditions réutilisables appliquées aux fonctions

    • Les types de données fondamentaux

    TypeDescriptionExemple
    `uint256`Entier non signé 256 bitsMontants, compteurs
    `address`Adresse Ethereum 20 octetsWallet, contrat
    `bool`Booléentrue / false
    `string`Chaîne de caractèresNoms, descriptions
    `mapping`Table de hachage clé→valeurSoldes d'utilisateurs
    `struct`Type composé personnaliséObjet avec champs
    `array`Tableau de valeursListes dynamiques

    Visibilité des fonctions

    public : accessible par tous (externe et interne)

    private : accessible uniquement dans le contrat

    internal : accessible dans le contrat et les contrats héritants

    external : accessible uniquement de l'extérieur

    Les outils essentiels de développement

    Remix IDE

    Environnement de développement en ligne accessible à [remix.ethereum.org](https://remix.ethereum.org) :

  • Éditeur Solidity avec coloration syntaxique
  • Compilateur intégré
  • Déploiement sur réseau local simulé (JavaScript VM)
  • Idéal pour les débutants et le prototypage rapide

    • Hardhat

    Framework professionnel pour le développement de smart contracts :

  • Réseau local Ethereum simulé (Hardhat Network)
  • Tests automatisés avec Mocha/Chai
  • Scripts de déploiement réutilisables
  • Plugins pour vérification Etherscan, gas reporting, etc.

    • Foundry

    Alternative en Rust, plus rapide que Hardhat :

  • Tests écrits en Solidity directement
  • Fuzzing automatique des inputs
  • Très apprécié des développeurs avancés

    • Le cycle de développement d'une dApp

    1. Conception : définir la logique métier et les fonctions

    2. Développement : coder les smart contracts en Solidity

    3. Tests : tests unitaires et d'intégration

    4. Audit de sécurité : faire auditer le code par des experts

    5. Déploiement : publier sur testnet (Sepolia) puis mainnet

    6. Frontend : connecter une interface React avec ethers.js ou wagmi

    7. Maintenance : surveiller, upgarder si nécessaire

    Les réseaux de test (Testnets)

    Avant de déployer sur le mainnet Ethereum (coûteux), les développeurs utilisent des réseaux de test où les ETH sont gratuits :

  • Sepolia : testnet principal recommandé par Ethereum Foundation
  • Goerli : ancien testnet, déprécié en 2023
  • Hardhat Network : réseau local simulé, le plus rapide

    • Déployer un contrat : les étapes

    1. Compiler le contrat → obtenir le bytecode et l'ABI

    2. Créer une transaction de déploiement (sans destinataire)

    3. Payer les frais de gas pour le déploiement

    4. Recevoir l'adresse du contrat déployé

    5. Interagir via l'ABI depuis le frontend

    L'**ABI** (Application Binary Interface) est le schéma qui décrit les fonctions et événements d'un contrat, permettant au frontend de l'appeler correctement.

    Les patterns de sécurité importants

    Checks-Effects-Interactions

    Toujours vérifier les conditions → modifier l'état → puis appeler des contrats externes. Évite les attaques de réentrance comme le hack du DAO en 2016 (60M$).

    OpenZeppelin

    Bibliothèque de contrats sécurisés et audités : ERC-20, ERC-721, Ownable, AccessControl, etc. Utiliser ces implémentations éprouvées plutôt que de tout recoder.

    Points clés à retenir