Blockchain

Lab Activité

Pré-requies

  • Node.js, Npm
  • VsCode
  • Postman (avec la Collection importée)
Visiter: https://learn-blockchain.now.sh
git clone https://proactionca.ent.cgi.com/bitbucket/scm/~marc.gagnon1/blockchain_lab.git
cd blockchain_lab/blockchain
npm install

7 étapes:

  • 🔲 Block class
  • 🔲 Blockchain class
  • ✅ Transaction class
  • ✅ Wallet class
  • ✅ P2P-Server class
  • 🔲 Miner class

Block Class

Comme nous avons vu mardi, un block contient 4 éléments importants :
timestamp - lastHash - hash - data
Alors, nous allons créer une Class "Block"

Dans le dossier "blockchain" créer un fichier block.js

cd blockchain
touch block.js

Initialisons la Class

class Block {
  constructor(timestamp, lastHash, hash, data) {
    this.timestamp = timestamp;
    this.lastHash = lastHash;
    this.hash = hash;
    this.data = data;
  }
}

Comme chacun des Blocks connait le Hash du block le précédent, nous devons créer une solution pour le premier Block. On le nomme "Genesis Block". C'est un Block pareil comme les autres par contre, nous allons "hardcoder" l'information.

Ajoutons à notre Class Block:

static genesis() {
  return new this('genesisTime', 'genesisLastHash', 'genesisHash', []);
}

Maintenant, nous devons donner à notre Blockchain le pouvoir de créer des nouveaux Blocks basés sur celui qui le précède ainsi que le "Data" qu'il contient.

Créons une function pour retourner le "Hash" du Block.

Tout d'abord nous devons importer un librairie pour l'algorithme voulu

const SHA256 = require('crypto-js/sha256');

Ensuite, ajouter la function pour retourner le Hash du Block.

static hash(timestamp, lastHash, data) {
  return SHA256(`${timestamp}${lastHash}${data}`).toString();
}

Nous avons maintenant la capabilité de trouver le Hash d'un Block, alors il nous reste plus qu'à l'utiliser.

static mineBlock(lastBlock, data) {
  let hash;
  let timestamp;
  const lastHash = lastBlock.hash;

  return new this(timestamp,lastHash,hash,data);
}

Ne pas oublier d'exporter la Class

module.exports = Block;

Tester pour vérifier que tout fonctionne comme prévu

npm run test_block_1

7 étapes:

  • ✅ Block class
  • 🔲 Blockchain class
  • ✅ Transaction class
  • ✅ Wallet class
  • ✅ P2P-Server class
  • 🔲 Miner class

Blockchain Class

Créons maintenant une Class pour le Blockchain, et créons le Genesis Block.

Dans le dossier blockchain, créer un fichier

touch blockchain.js

Notre Blockchain aura besoin de la Class Block

const Block = require('./block');

Ensuite, déclarons une Class pour notre Blockchain

class Blockchain {
  constructor() {
    this.chain = [Block.genesis()];
  }
}

Ajoutons à cette Class l'abilité d'ajouter des Blocks à la chaine

addBlock(data) {
  const block = Block.mineBlock(this.chain[this.chain.length - 1], data);
  this.chain.push(block);

  return block;
}

Ici, nous accèdons au dernier block que la chaîne contient et utilisons la fonction mineBlock() pour générer une nouveau block et par la suite, l'ajouter à la chaîne.

Exporter la Class

module.exports = Blockchain;

Et c'est le temps de tester

npm run test_blockchain_1

Comme dit plus tôt, un Blockchain est decentralisé alors, par définition, plusieurs personnes y sont connectés en même temps. Les nodes seront tous connectés ensemble par un serveur Express qui est déjà prêt dans votre git clone par contre, pour permettre la décentralisation, nous devons mettre plusieurs règles strictes en vigueur.

La première règle sera de vérifier que la chaîne est toujours bel et bien valide mais pour cela, il nous faut une fonctione pour recalculer le Hash d'un block donné.

Dans la Class Block, ajoutons:

static blockHash(block) {
  const { timestamp, lastHash, data, nonce, difficulty } = block;
  return Block.hash(timestamp, lastHash, data, nonce, difficulty);
}

Nous pouvons maintenant créer une function pour vérifier que le Blockchain est encore valide. Block par Block, nous recalculerons le hash pour être sur que celui-ci est valide et que l'information n'a pas été altéré car n'oubliez pas que changer une seul Byte donnera un hash complètement différent.

Ajoutons dans la Class Blockchain:

isValidChain(chain) {
  if (JSON.stringify(chain[0]) !== JSON.stringify(Block.genesis()))
    return false;
  for (let i = 1; i < chain.length; i++) {
    const block = chain[i];
    const lastBlock = chain[i - 1];
    if (
      block.lastHash !== lastBlock.hash ||
      block.hash !== Block.blockHash(block)
    ) {
      return false;
    }
  }
  return true;
}

Par la suite, lorsque nous recevons une chaîne Valide et plus longue que la nôtre, elle devient automatiquement la nouvelle chaîne car la stratégie appliquée est celle que la chaîne ayant le plus de Block remplace toujours la précédente.

Ajoutons dans la Class Blockchain:

replaceChain(newChain) {
  if (newChain.length <= this.chain.length) {
    console.log('Received chain is not longer than the current chain');
    return;
  } else if (!this.isValidChain(newChain)) {
    console.log('Received chain is invalid')
  }

  console.log('Replacing the current chain with new chain');
  this.chain = newChain;
}

7 étapes:

  • ✅ Block class
  • ✅ Blockchain class
  • ✅ Transaction class
  • ✅ Wallet class
  • ✅ P2P-Server class
  • 🔲 Miner class

             | ctrl+`          | ctrl+shift+5    | ctrl+shift+5
Windows  --> | npm run dev1    | npm run dev2    | npm run dev3
Linux/VM --> | npm run dev1_vm | npm run dev2_vm | npm run dev3_vm

Par ces commandes, nous venons de simuler 3 utilisateurs différents sur notre Blockchain.

Il est grand temps de tester et de voir le résultat!

Avec le résultat de Postman, on peut voir que la Class Blockchain a utlisé la Class Block pour créer le Genesis Block donc, nous avons un Blockchain fonctionnel!

Protégeons là maintenant!

Mining Class

Vous vous rappelez des fameuses 4 ligne de code qui utilise plus d'électricité que 159 pays, il est maintenant temps de le coder.

  • Mining : Trouver un hash.
  • Proof-Of-Work : Hash ayant le nombre de 0 égal à la difficulté.

Pour implémenter le Mining et la Proof-Of-Work nous aurons besoin de faire quelques mise à jours.
De notre fichier block.js, enlevons de nos importations:

const SHA256 = require('crypto-js/sha256');

Et importons :

const adjustDifficulty = require('./difficulty');
const ChainUtil = require('../chain-util');
const { DIFFICULTY } = require('../config.json');

Initialisons la Class Block avec 2 autres éléments. Soit:

  • Nonce
  • Difficulty

Ajoutons au Constructor de la Class Block:

constructor(..., nonce, difficulty = DIFFICULTY) {
    ...
    this.nonce = nonce;
    this.difficulty = difficulty;
  }

Ajoutons un nonce et une difficulty "hardcoder" au Genesis Block

static genesis() {
  return new this(
    ...,
    0,
    this.difficulty,
  );
}

La function qui retourne le Hash de notre block doit maintenant tenir compte du nonce et de la difficulté dans son calcul, alors remplacons la function par celle-ci:

static hash(timestamp, lastHash, data, nonce, difficulty) {
  return ChainUtil.hash(
    `${timestamp}${lastHash}${data}${nonce}${difficulty}`,
  );
}

Faisons une mise à jour de la function mineBlock() dans le Class Block.

static mineBlock(lastBlock, data) {
  let hash, timestamp;
  const lastHash = lastBlock.hash;
  let { difficulty } = lastBlock;
  let nonce = 0;

  do {
    nonce++;
    timestamp = Date.now();
    difficulty = adjustDifficulty(lastBlock, timestamp);
    hash = Block.hash(timestamp, lastHash, data, nonce, difficulty);
  } while (hash.substring(0, difficulty) !== '0'.repeat(difficulty));
  return new this(timestamp, lastHash, hash, data, nonce, difficulty);
}

Testons nos changements finaux.

npm run test_blockchain_final
npm run test_block_final

C'est maintenant au tour de notre ordinateur de travailler. Voyons qu'est-ce que Miner en temps réel!

Minez quelques Blocks pour voir comment réagit la difficulté dynamique, avez-vous trouvez quelque chose de bizarre dans la difficulté?

Change de node pour le mining, comment réagi celui du port 3000 qu'on utilise depuis le début

Regarder les transactions, nous pouvons voir les signatures que nous avons parler mardi.

7 étapes:

  • ✅ Block class
  • ✅ Blockchain class
  • ✅ Transaction class
  • ✅ Wallet class
  • ✅ P2P-Server class
  • ✅ Miner class

Challenge d'implémentation

  • 🔲 Algorithme différente que SHA256, même pousser à inventer votre propre Algorithme 😄
  • 🔲 Implémenter une difficulé dynamique selon le temps de Block que vous voulez atteindre.
  • 🔲 Limitation d'un block (length, size).
  • 🔲 Exploreur de Blockchain (MongoDB)
  • 🔲 etc, etc, etc.

Merci de votre participation!