Cours Blockchain et Web3 · Module 6: Bases de Solidity
Solidity - Le langage des mécanismes automatisés
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. Quelle ligne de code déclare correctement la version de Solidity dans un smart contract ?
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
Exercices après cette leçon
- QuestionVersion de Solidity
- Remets dans l'ordreStructure d'un contrat
- QuestionTypes entiers
- Exercice de codePremier smart contract
- QuestionType address
- Clique dans l'ordreDéclaration de fonction
- QuestionVisibilité des fonctions
- Exercice de codeFonction avec paramètres
- QuestionModificateur view
- Remets dans l'ordreNiveaux de visibilité
- QuestionModificateur pure
- Exercice de codeFonction pure
- Remets dans l'ordreVariables d'état vs locales
- QuestionType bool
- Clique dans l'ordreMapping - les bases
- Exercice de codeMapping en pratique
- QuestionTableaux en Solidity
- Remets dans l'ordreOpérations sur les tableaux
- Exercice de codeTravailler avec les tableaux
- QuestionStructures (Structs)
- Remets dans l'ordreDéclaration de struct
- Exercice de codeCréation de struct
- QuestionEvents en Solidity
- Clique dans l'ordreDéclaration d'un event
- Exercice de codeÉmettre un event
- QuestionModificateur payable
- Remets dans l'ordreModificateurs personnalisés
- Exercice de codeImplémentation d'un modificateur
- QuestionRequire vs Assert
- Clique dans l'ordreUtilisation de require
- Exercice de codeGestion des erreurs
- QuestionRevert
- Remets dans l'ordreErreurs personnalisées
- Exercice de codeCustom error
- QuestionHéritage de contrats
- Remets dans l'ordreStructure de l'héritage
- QuestionConstructor
- Clique dans l'ordreImplémentation du constructor
- QuestionString vs bytes
- Remets dans l'ordreMsg.sender
- Exercice de codeSmart contract complet
- Projet à envoyerProjet - Contrat avancé
- DialogueRésumé du module