Cours Blockchain et Web3 · Module 6: Bases de Solidity

Solidity - Le langage des mécanismes automatisés

3 min de lecture ·
Dans cette leçon6

Bienvenue dans la Salle des Mécanismes ! Ici Atlas. Aujourd'hui tu vas apprendre Solidity - le langage utilisé pour écrire les mécanismes automatisés (smart contracts) qui opèrent dans les tunnels de la Crypte.

Qu'est-ce que Solidity ?

Solidity est un langage de programmation créé spécifiquement pour Ethereum. Il permet d'écrire des smart contracts - des programmes qui s'exécutent sur la blockchain.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract HelloKrypta {
    string public message = "Bienvenue dans la Crypte !";

    function setMessage(string memory newMessage) public {
        message = newMessage;
    }
}

Structure d'un contrat

// 1. Licence (obligatoire depuis Solidity 0.6.8)
// SPDX-License-Identifier: MIT

// 2. Version du compilateur
pragma solidity ^0.8.20;

// 3. Imports (optionnel)
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

// 4. Définition du contrat
contract MyContract {
    // 5. Variables d'état
    uint256 public myNumber;
    address public owner;

    // 6. Events
    event NumberChanged(uint256 newNumber);

    // 7. Modificateurs
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    // 8. Constructeur
    constructor() {
        owner = msg.sender;
    }

    // 9. Fonctions
    function setNumber(uint256 _number) public onlyOwner {
        myNumber = _number;
        emit NumberChanged(_number);
    }
}

Types de données

// Types valeur
bool isActive = true;
uint256 amount = 1000;        // entier non signé (0 à 2^256-1)
int256 temperature = -10;      // entier signé
address wallet = 0x123...;     // adresse Ethereum (20 octets)
bytes32 hash = keccak256(...); // octets de taille fixe

// Types référence
string name = "Atlas";
bytes data = hex"001122";
uint256[] numbers;             // tableau dynamique
uint256[10] fixedArray;        // tableau fixe
mapping(address => uint256) balances;

// Struct
struct User {
    string name;
    uint256 balance;
    bool isActive;
}

Visibilité

contract Visibility {
    uint256 public publicVar;     // Accessible partout, getter automatique
    uint256 private privateVar;   // Uniquement dans ce contrat
    uint256 internal internalVar; // Ce contrat + ceux qui en héritent
    uint256 external externalVar; // Pas pour les variables !

    function publicFunc() public {}    // Accessible partout
    function privateFunc() private {}  // Uniquement en interne
    function internalFunc() internal {} // + contrats héritiers
    function externalFunc() external {} // Uniquement depuis l'extérieur
}

Fonctions - view, pure, payable

contract Functions {
    uint256 public value;

    // view - lit l'état, ne le modifie pas
    function getValue() public view returns (uint256) {
        return value;
    }

    // pure - ne lit ni ne modifie l'état
    function add(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }

    // payable - peut recevoir de l'ETH
    function deposit() public payable {
        // msg.value contient l'ETH envoyé
    }

    // ordinaire - peut modifier l'état
    function setValue(uint256 _value) public {
        value = _value;
    }
}

Résumé

  • Solidity - le langage des smart contracts
  • Structure d'un contrat
  • Types de données (valeur, référence)
  • Visibilité (public, private, internal, external)
  • Fonctions (view, pure, payable)
Code de cette leçon : index.js
// Solidity - bases de la syntaxe
// (simulation en JavaScript - le vrai Solidity nécessite un compilateur)

class SolidityContract {
  // Types de données en Solidity
  static TYPES = {
    // Entiers
    uint8: { min: 0, max: 255 },
    uint256: { min: 0, max: BigInt("2") ** BigInt("256") - BigInt("1") },
    int256: { min: -(BigInt("2") ** BigInt("255")), max: BigInt("2") ** BigInt("255") - BigInt("1") },

    // Booléen
    bool: [true, false],

    // Adresse (20 octets)
    address: "0x" + "0".repeat(40),

    // Bytes
    bytes32: "0x" + "0".repeat(64)
  };

  constructor() {
    // Variables d'état (stockées dans le storage)
    this.owner = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
    this.balance = BigInt(0);
    this.name = "MyToken";
    this.isActive = true;
  }
}

console.log("=== TYPES DE DONNÉES EN SOLIDITY ===\n");

console.log("TYPES ENTIERS :");
console.log("  uint8:   0 à 255");
console.log("  uint256: 0 à 2^256-1 (par défaut)");
console.log("  int256:  -2^255 à 2^255-1");

console.log("\nAUTRES TYPES :");
console.log("  bool:    true/false");
console.log("  address: 20 octets (adresse Ethereum)");
console.log("  bytes32: 32 octets (hash)");
console.log("  string:  texte dynamique");

console.log("\n=== EXEMPLE DE CONTRAT ===");
console.log(`
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract SimpleStorage {
    // Variables d'état
    uint256 public storedNumber;
    address public owner;
    string public name;
    bool public isActive;

    // Constructeur
    constructor(string memory _name) {
        owner = msg.sender;
        name = _name;
        isActive = true;
    }

    // Fonction pour stocker un nombre
    function store(uint256 _number) public {
        storedNumber = _number;
    }

    // Fonction view (lecture seule)
    function retrieve() public view returns (uint256) {
        return storedNumber;
    }
}
`);

Tu as repéré une erreur dans cette leçon ?

Teste tes connaissances

Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.

  1. 1. Quelle ligne de code déclare correctement la version de Solidity dans un smart contract ?

  2. 2. Quel type de données en Solidity représente les entiers non négatifs ?

Voici 2 des 16 questions de cette leçon. Réponds aux autres dans le jeu.

Tâches pratiques dans le jeu

  • Tri vertical

    Placez les éléments d'un smart contract de base dans le bon ordre :

  • Éditeur de code

    Créez un objet représentant un contrat simple avec un champ 'myNumber' de valeur 42

  • Clique dans l'ordre

    Placez les éléments dans le bon ordre pour créer une déclaration de fonction retournant une valeur uint

  • Éditeur de code

    Écrivez une fonction setValue qui prend un paramètre 'value' et affecte le champ this.storedValue

  • Tri horizontal

    Placez les visibilités de fonction de la plus restrictive à la plus ouverte :

  • Éditeur de code

    Écrivez une fonction add qui additionne deux nombres sans utiliser les champs de l'objet

  • Tri vertical

    Placez correctement le code montrant la différence entre une variable d'état et une variable locale :

  • Clique dans l'ordre

    Placez les éléments dans le bon ordre pour créer un mapping stockant les soldes des adresses

  • Éditeur de code

    Créez un objet 'balances' et ajoutez un solde de 100 pour l'adresse '0x123'

  • Tri horizontal

    Placez dans l'ordre les étapes de l'ajout d'un élément à un tableau en Solidity :

  • Éditeur de code

    Créez un tableau 'numbers', ajoutez-y les nombres 1, 2, 3 et retournez la longueur du tableau

  • Tri vertical

    Placez correctement la déclaration de la structure Person :

  • Éditeur de code

    Créez un objet person avec les champs name: 'Alice' et age: 25

  • Clique dans l'ordre

    Placez les éléments dans le bon ordre pour créer la déclaration de l'event Transfer

  • Éditeur de code

    Écrivez une fonction transfer qui 'émet' un event via console.log avec les informations du transfert

  • Tri vertical

    Placez correctement la déclaration du modificateur personnalisé onlyOwner :

  • Éditeur de code

    Écrivez une fonction onlyOwner qui vérifie si caller === owner et lève une erreur sinon

  • Clique dans l'ordre

    Placez les éléments dans le bon ordre pour créer une validation du solde

  • Éditeur de code

    Écrivez une fonction withdraw qui vérifie si balance >= amount et lève une erreur sinon

  • Tri horizontal

    Placez dans l'ordre les étapes de définition et d'utilisation d'une erreur personnalisée en Solidity :

  • Éditeur de code

    Créez une classe InsufficientBalanceError étendant Error et utilisez-la dans une fonction

  • Tri vertical

    Placez correctement l'exemple d'héritage de contrats :

  • Clique dans l'ordre

    Placez les éléments dans le bon ordre pour créer un constructor définissant le propriétaire

  • Tri horizontal

    Que représente msg.sender dans une transaction ?

  • Éditeur de code

    Créez une classe SimpleStorage avec un constructeur, une variable d'état, des fonctions set et get ainsi qu'un event

  1. QuestionVersion de Solidity
  2. Remets dans l'ordreStructure d'un contrat
  3. QuestionTypes entiers
  4. Exercice de codePremier smart contract
  5. QuestionType address
  6. Clique dans l'ordreDéclaration de fonction
  7. QuestionVisibilité des fonctions
  8. Exercice de codeFonction avec paramètres
  9. QuestionModificateur view
  10. Remets dans l'ordreNiveaux de visibilité
  11. QuestionModificateur pure
  12. Exercice de codeFonction pure
  13. Remets dans l'ordreVariables d'état vs locales
  14. QuestionType bool
  15. Clique dans l'ordreMapping - les bases
  16. Exercice de codeMapping en pratique
  17. QuestionTableaux en Solidity
  18. Remets dans l'ordreOpérations sur les tableaux
  19. Exercice de codeTravailler avec les tableaux
  20. QuestionStructures (Structs)
  21. Remets dans l'ordreDéclaration de struct
  22. Exercice de codeCréation de struct
  23. QuestionEvents en Solidity
  24. Clique dans l'ordreDéclaration d'un event
  25. Exercice de codeÉmettre un event
  26. QuestionModificateur payable
  27. Remets dans l'ordreModificateurs personnalisés
  28. Exercice de codeImplémentation d'un modificateur
  29. QuestionRequire vs Assert
  30. Clique dans l'ordreUtilisation de require
  31. Exercice de codeGestion des erreurs
  32. QuestionRevert
  33. Remets dans l'ordreErreurs personnalisées
  34. Exercice de codeCustom error
  35. QuestionHéritage de contrats
  36. Remets dans l'ordreStructure de l'héritage
  37. QuestionConstructor
  38. Clique dans l'ordreImplémentation du constructor
  39. QuestionString vs bytes
  40. Remets dans l'ordreMsg.sender
  41. Exercice de codeSmart contract complet
  42. Projet à envoyerProjet - Contrat avancé
  43. DialogueRésumé du module