Cours Blockchain et Web3 · Module 1: Fondamentaux de la blockchain
Comment fonctionne la Blockchain - Anatomie d'un bloc
Dans cette leçon7
Content de te revoir ! Atlas est là. Maintenant que tu connais les bases, nous allons plonger plus en profondeur dans l'anatomie d'une seule chambre (bloc) et voir comment les tunnels (chaînes) les relient en un réseau ininterrompu.
Structure d'un bloc
Chaque chambre de notre cité souterraine a une structure précise :
┌─────────────────────────────────────────────────────────────────┐
│ BLOC #12345 │
├─────────────────────────────────────────────────────────────────┤
│ HEADER │
│ ├── Block Hash: 0x7f8a...3b2c (identifiant de cette chambre) │
│ ├── Previous Hash: 0x4e2d...9a1f (lien vers la précédente) │
│ ├── Timestamp: 2024-11-28 14:32:15 │
│ ├── Nonce: 2847593 │
│ └── Merkle Root: 0x9c3f...7d8e │
├─────────────────────────────────────────────────────────────────┤
│ BODY (Transactions) │
│ ├── TX1: Alice → Bob: 0.5 ETH │
│ ├── TX2: Carol → Dave: 1.2 ETH │
│ ├── TX3: Eve → Frank: 0.1 ETH │
│ └── ... (des centaines/milliers de transactions) │
└─────────────────────────────────────────────────────────────────┘Chaîne de blocs
Chaque bloc contient le hash du bloc précédent - cela crée une chaîne ininterrompue :
BLOC 100 BLOC 101 BLOC 102
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ Hash: 0xabc... │ │ Hash: 0xdef... │ │ Hash: 0x123... │
│ Prev: 0x999... │───▶│ Prev: 0xabc... │───▶│ Prev: 0xdef... │
│ Transactions... │ │ Transactions... │ │ Transactions... │
└─────────────────┘ └─────────────────┘ └─────────────────┘
Si quelqu'un modifiait une transaction dans le Bloc 100 :
- Le hash du Bloc 100 changerait
- Le prev hash du Bloc 101 ne correspondrait plus
- Toute la chaîne après le Bloc 100 serait INVALIDE !Merkle Tree - Arbre des transactions
Les transactions d'un bloc sont organisées selon une structure de Merkle Tree :
┌──────────────┐
│ Merkle Root │
│ 0x9c3f... │
└──────┬───────┘
│
┌────────────┴────────────┐
│ │
┌─────┴─────┐ ┌─────┴─────┐
│ Hash AB │ │ Hash CD │
└─────┬─────┘ └─────┬─────┘
│ │
┌──────┴──────┐ ┌──────┴──────┐
│ │ │ │
┌───┴───┐ ┌───┴───┐ ┌───┴───┐ ┌───┴───┐
│ TX A │ │ TX B │ │ TX C │ │ TX D │
└───────┘ └───────┘ └───────┘ └───────┘Grâce à cela, tu peux vérifier rapidement si une transaction se trouve dans un bloc !
Consensus - Comment les gardiens se mettent d'accord
Dans une cité décentralisée, nous avons besoin d'un mécanisme pour que tous les gardiens s'accordent sur l'état du réseau :
Proof of Work (PoW)
- Les mineurs résolvent des énigmes mathématiques
- Le premier à trouver une solution ajoute le bloc
- Nécessite beaucoup d'énergie (Bitcoin l'utilise encore)
Proof of Stake (PoS)
- Les validateurs « stakent » leur ETH
- Ils sont sélectionnés aléatoirement pour créer des blocs
- Ethereum l'utilise depuis 2022 (The Merge)
┌─────────────────────────────────────────────────────────────────┐
│ PROOF OF WORK vs PROOF OF STAKE │
├────────────────────────────┬────────────────────────────────────┤
│ PROOF OF WORK │ PROOF OF STAKE │
├────────────────────────────┼────────────────────────────────────┤
│ Mining │ Staking │
│ Beaucoup d'énergie │ Efficace (~99,95% de moins) │
│ Matériel nécessaire │ 32 ETH nécessaires │
│ Plus lent │ Plus rapide │
│ Récompense de bloc │ Récompense de validation │
└────────────────────────────┴────────────────────────────────────┘Finalisation d'une transaction
Combien de confirmations sont nécessaires pour qu'une transaction soit « sûre » ?
┌─────────────────────────────────────────────────────────────────┐
│ CONFIRMATIONS │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Ta TX dans le bloc #100 │
│ │
│ Bloc #100 → #101 → #102 → #103 → #104 → #105 │
│ ↑ 1 2 3 4 5 │
│ Ta TX confirmations │
│ │
│ Niveaux de sécurité : │
│ • 1 confirmation - basique (réorganisation possible) │
│ • 6 confirmations - sûr pour la plupart des cas │
│ • 12+ confirmations - très sûr (grosses sommes) │
│ │
└─────────────────────────────────────────────────────────────────┘Types de réseaux blockchain
┌─────────────────────────────────────────────────────────────────┐
│ TYPES DE BLOCKCHAIN │
├─────────────────────────────────────────────────────────────────┤
│ │
│ PUBLIQUE │ PRIVÉE │
│ • Ethereum, Bitcoin │ • Hyperledger Fabric │
│ • Ouverte à tous │ • Sur invitation seulement │
│ • Transparence totale │ • Accès contrôlé │
│ • Trustless │ • Nécessite la confiance │
│ │
│ PERMISSIONLESS │ PERMISSIONED │
│ • Aucune permission requise │ • Autorisation requise │
│ • Anonymat possible │ • Participants connus │
│ │
└─────────────────────────────────────────────────────────────────┘Résumé
Dans cette leçon, tu as appris :
- La structure d'un bloc (header, body, hash, transactions)
- Comment la chaîne de blocs garantit l'immuabilité
- Le Merkle Tree et la vérification des transactions
- Les mécanismes de consensus (PoW vs PoS)
- Les confirmations et la finalisation des transactions
- Les types de réseaux blockchain
Dans la prochaine leçon, nous explorerons les applications pratiques de la blockchain !
Code de cette leçon : index.js
// Simulation d'une blockchain
class Block {
constructor(index, data, previousHash) {
this.index = index;
this.timestamp = Date.now();
this.data = data;
this.previousHash = previousHash;
this.hash = this.calculateHash();
}
calculateHash() {
const str = this.index + this.timestamp + JSON.stringify(this.data) + this.previousHash;
let hash = 0;
for (let i = 0; i < str.length; i++) {
hash = ((hash << 5) - hash) + str.charCodeAt(i);
hash = hash & hash;
}
return Math.abs(hash).toString(16).padStart(16, '0');
}
}
class Blockchain {
constructor() {
this.chain = [this.createGenesisBlock()];
}
createGenesisBlock() {
return new Block(0, "Genesis Block", "0");
}
getLatestBlock() {
return this.chain[this.chain.length - 1];
}
addBlock(data) {
const newBlock = new Block(
this.chain.length,
data,
this.getLatestBlock().hash
);
this.chain.push(newBlock);
}
}
const myBlockchain = new Blockchain();
myBlockchain.addBlock({ from: "Atlas", to: "User", amount: 100 });
myBlockchain.addBlock({ from: "User", to: "Atlas", amount: 50 });
console.log("=== BLOCKCHAIN ===");
myBlockchain.chain.forEach((block, i) => {
console.log(`\nBloc #${i}:`);
console.log(` Hash: ${block.hash}`);
console.log(` Précédent: ${block.previousHash}`);
console.log(` Données: ${JSON.stringify(block.data)}`);
});
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. Quel élément ne fait PAS partie de l'en-tête d'un bloc ?
2. Que se passe-t-il si quelqu'un modifie une transaction dans le bloc n°100 ?
3. Depuis 2022, Ethereum utilise :
4. Combien de confirmations sont considérées comme sûres ?
5. La principale différence entre Bitcoin et Ethereum est :
6. Sur un testnet (par ex. Sepolia), tu peux :
7. Ethereum est un exemple de blockchain :
8. Un node dans un réseau blockchain est :
9. Une fonction de hachage (par ex. SHA-256) produit toujours :
10. L'immuabilité (immutability) dans la blockchain signifie :
Tâches pratiques dans le jeu
- Éditeur de code
Complète la fonction isChainValid qui vérifie que la chaîne n'a pas été modifiée
- Tri vertical
Ordonne les étapes de création d'un nouveau bloc :
- Tri horizontal
Ordonne les éléments d'une transaction blockchain :
- Éditeur de code
Complète la fonction mineBlock qui trouve un hash commençant par un nombre déterminé de zéros
- Clique dans l'ordre
Clique dans l'ordre sur les étapes du Proof of Work :
- Tri vertical
Ordonne les avantages du Proof of Stake par rapport au Proof of Work :
- Éditeur de code
Complète la classe Node avec une méthode broadcastBlock pour diffuser les blocs
- Tri horizontal
Ordonne le code qui crée le Genesis Block :
- Clique dans l'ordre
Clique dans l'ordre, du réseau le plus ancien au plus récent :
- Éditeur de code
Complète l'objet comparison avec les propriétés de Bitcoin et Ethereum
- Tri vertical
Ordonne les réseaux, du réseau de production au réseau de test :
- Éditeur de code
Complète l'objet networks avec la configuration de mainnet, sepolia et localhost
- Tri horizontal
Ordonne : Une blockchain publique est ...
- Clique dans l'ordre
Clique sur les types de nodes du réseau Ethereum :
- Éditeur de code
Complète la classe Blockchain avec les méthodes createGenesisBlock, getLatestBlock, addBlock
- Tri vertical
Ordonne les propriétés d'une bonne fonction de hachage :
- Éditeur de code
Complète la fonction simpleHash qui transforme une chaîne en nombre
- Tri horizontal
Ordonne le code qui ajoute un bloc à la chaîne :
- Clique dans l'ordre
Clique sur les étapes de construction d'une blockchain simple :
- Éditeur de code
Crée une blockchain, ajoute 3 blocs et valide la chaîne
Exercices après cette leçon
- QuestionQuiz : Que contient un bloc ?
- Exercice de codeValidation de la chaîne
- Remets dans l'ordreProcessus de création d'un bloc
- QuestionQuiz : Chaîne de blocs
- Remets dans l'ordreComposants d'une transaction
- Exercice de codeProof of Work simple
- QuestionQuiz : PoW vs PoS
- Clique dans l'ordreClique sur les éléments du PoW
- Remets dans l'ordreComparaison PoW et PoS
- Exercice de codeSimulation d'un réseau P2P
- QuestionQuiz : Confirmations
- Remets dans l'ordreConstruction du Genesis Block
- QuestionQuiz : Bitcoin vs Ethereum
- Clique dans l'ordreClique sur les réseaux blockchain
- Exercice de codeComparaison des réseaux
- QuestionQuiz : Mainnet vs Testnet
- Remets dans l'ordreHiérarchie des réseaux
- Exercice de codeConfiguration des réseaux
- QuestionQuiz : Types de blockchain
- Remets dans l'ordreTypes de blockchain
- QuestionQuiz : Node
- Clique dans l'ordreClique sur les types de nodes
- Exercice de codeClasse Blockchain
- QuestionQuiz : Hash
- Remets dans l'ordrePropriétés d'un hash
- Exercice de codeSimulation du hachage
- QuestionQuiz : Immutabilité
- Remets dans l'ordreAppel des méthodes de la blockchain
- Clique dans l'ordreClique dans l'ordre de construction d'une blockchain
- Exercice de codeImplémentation complète
- Projet à envoyerEnvoie ton projet au mentor
- DialogueFin du module 1