Tutoriel Codage blockchain avec Python

Saviez-vous que le Bitcoin repose sur le principe de la blockchain ? Aujourd’hui, nous allons créer une Blockchain à partir de zéro en utilisant Python.

Qu’est-ce que la Blockchain ? 

Satoshi Nakamoto, une personne ou une organisation anonyme, a créé le Bitcoin en 2008. Le bitcoin est apparu comme une monnaie électronique de type peer-to-peer qui permet d’effectuer des transactions sans avoir recours à des organisations centralisées (banques). La plupart des gens ignorent que Satoshi a spécifié une méthode distribuée de stockage des informations dans le même article, qui est maintenant connue sous le nom de Blockchain.

Pour faire simple, la blockchain est un réseau décentralisé d’ordinateurs qui conserve les transactions dans un registre numérique partagé et irréversible.

La blockchain peut être décomposée en deux termes de base :

  • Un bloc est un endroit où l’on enregistre les transactions.
  • Une chaîne est une collection d’enregistrements connectés.

La blockchain est définie comme une chaîne de blocs connectés, chaque bloc stockant une transaction exécutée avec des spécifications particulières.

Chaque bloc est construit par-dessus le précédent, ce qui donne une chaîne de blocs irréversible. En d’autres termes, chaque bloc est dépendant du précédent. Il en résulte un système robuste et immuable dont l’intégrité peut être vérifiée par toute personne disposant des droits nécessaires.

La blockchain présente un ensemble de capacités intrigantes :

  • Immutabilité de l’histoire
  • Persistance de l’information
  • Pas d’erreur dans les données enregistrées.

De nombreux systèmes dépendent actuellement de la Blockchain, notamment les crypto-monnaies, les transferts d’actifs (NFT) et, peut-être, le vote dans un avenir proche.

Une Blockchain Python n’a pas besoin d’être une application sophistiquée avec des centaines de lignes de code. Il s’agirait essentiellement d’une collection de transactions liées les unes aux autres.

Commençons dès maintenant à développer une Blockchain de base en utilisant Python.

Création de la Blockchain avec Python

Avant de débuter, fixons ce que nous allons réaliser au cours de cette formation :

  • Créer un système Blockchain de base en Python.
  • Utiliser notre Blockchain avec des transactions prédéfinies écrites sous forme de chaînes de caractères.
  • Mettre à l’épreuve l’immuabilité de notre Blockchain.

Nous utiliserons des listes Python au lieu de JSON. Cela nous permettra de rationaliser le processus et de nous concentrer sur l’implémentation des principales fonctionnalités de la Blockchain.

Ce dont vous aurez besoin pour suivre ce tutoriel :

  • Compréhension des classes et méthodes Python
  • Utilisation basique de la ligne de commande.

Création de la classe BitcoinBlock

Créez un fichier main.py dans votre éditeur de code préféré. Nous travaillerons avec ce fichier.

Importez hashlib, un package qui nous permet de générer des communications cryptées à sens unique. Les transactions Blockchain sont sécurisées grâce à des méthodes de cryptographie telles que le hachage.

Une fonction de hachage est un algorithme qui prend des données (généralement une phrase codée) et produit une identification unique, parfois appelée “condensé” ou “signature”. Ce dernier composant est essentiel ; une fonction de hachage crée une identification sensiblement différente en sortie si l’entrée est légèrement différente. Nous verrons cela plus tard.

Pour l’instant, il suffit d’importer le module intégré hashlib :

# main.py file
"""
A simple Blockchain in Python
"""

import hashlib

Ce module contient la majorité des algorithmes de hachage dont vous aurez besoin. Rappelez-vous que nous utiliserons la méthode hashlib.sha256().

Entrons dans le Bitcoin Block, notre nom de blockchain complètement unique.

class BitcoinBlock:

def __init__(self, previous_block_hash, transaction_list):

self.previous_block_hash = previous_block_hash

self.transaction_list = transaction_list.

self.block_data = f"{' - '.join(transaction_list)} - {previous_block_hash}"

self.block_hash = hashlib.sha256(self.block_data.encode()).hexdigest()

Dans la prochaine section, nous allons décomposer chaque composant.

Explication BitcoinBlock :

Tout d’abord, nous construisons une classe appelée BitcoinBlock, qui sert de conteneur pour les objets ayant certaines caractéristiques (attributs) et actions (méthodes).

Ensuite, nous définissons la fonction __init__ (également connue sous le nom de constructeur), qui est appelée à chaque fois qu’un objet BitcoinBlock est créé.

Il y a trois paramètres à cette méthode :

  1.  self  : l’instance de chaque objet.
  2.  previous_block_hash : une référence au bloc précédent.
  3.  transaction_list  : une liste des transactions effectuées dans le bloc actuel.

Nous enregistrons le hash précédent et la liste des transactions sous forme de chaîne dans la variable d’instance block data. Cela ne se produit pas dans les crypto-monnaies réelles, où nous enregistrons ce type de données sous la forme d’un autre hachage, mais par souci de simplicité, nous stockons chaque bloc de données sous la forme d’une chaîne.

Enfin, nous générons le hachage du bloc, qui sera utilisé par les blocs suivants pour continuer la chaîne. C’est ici que hashlib s’avère utile ; plutôt que d’écrire notre propre fonction de hachage, nous pouvons utiliser le sha256 pré-construit pour créer des blocs immuables.

Comme arguments, des chaînes codées (ou octets) sont envoyées à cette méthode. C’est pourquoi nous utilisons la fonction data.encode() du bloc. Ensuite, nous utilisons hexdigest() pour convertir les données codées au format hexadécimal.

Je comprends que tout cela puisse être intimidant, mais essayons hashlib sur un shell Python.

In [1]: import hashlib

In [2]: message = "Python is great"

In [3]: h1 = hashlib.sha256(message.encode())

In [4]: h1
Out[4]: <sha256 ... object @ 0x7efcd55bfbf0>

In [5]: h1.hexdigest()
Out[5]: 'a40cf9cca ... 42ab97'

In [6]: h2 = hashlib.sha256(b"Python is not great")

In [7]: h2
Out[7]: <sha256 ... object @ 0x7efcd55bfc90>

In [8]: h2.hexdigest()
Out[8]: 'fefe510a6a ... 97e010c0ea34'

Comme vous pouvez le voir, une petite modification dans l’entrée, comme “Python est incroyable” en “Python n’est pas génial”, peut donner un hachage complètement différent. Il s’agit de l’intégrité de la blockchain. Si vous apportez une petite modification à une blockchain, le hash changera de manière substantielle. C’est pourquoi l’adage “Vous ne pouvez pas corrompre une blockchain” est correct.

Utilisation de la classe BitcoinBlock

Nous développerons une classe Blockchain plus tard, mais pour l’instant, utilisons notre classe Block pour créer une chaîne de blocs (Blockchain).

Créez quelques transactions dans le même fichier qui sont constituées de chaînes de base conservées dans des variables, telles que :

class BitcoinBlock:
...

t1 = "Noah sends 5 BB to Mark"
t2 = "Mark sends 2.3 BB to James"
t3 = "James sends 4.2 BB to Alisson"
t4 = "Alisson sends 1.1 BB to Noah"

Bien sûr, BB est l’abréviation de BitcoinBlock.

Maintenant, en utilisant la classe BitcoinBlock, créez le premier bloc de notre Blockchain et publiez ses propriétés. Notez que le paramètre de hachage précédent du bloc genèse (le bloc initial qui précède les blocs suivants) sera toujours un texte ou un hachage aléatoire quelconque, dans ce cas “firstblock”.

block1 = BitcoinBlock('firstblock', [t1, t2])

print(f"Block 1 data: {block1.block_data}")
print(f"Block 1 hash: {block1.block_hash}")

Nous répétons ensuite le processus avec le deuxième bloc, mais cette fois, nous fournissons le hachage du premier bloc comme paramètre de hachage précédent.

block2 = BitcoinBlock(block1.block_hash, [t3, t4])

print(f"Block 2 data: {block2.block_data}")
print(f"Block 2 hash: {block2.block_hash}")

Exécutons ce morceau de code et examinons les résultats. Saisissez une nouvelle fois le code suivant dans votre terminal :

❯ python main.py
Block 1 data: Noah sends 5 BB to Mark - Mark sends 2.3 BB to James - firstblock
Block 1 hash: 01e4e15242a9601725f4a86ca01fbddaaec7105b442955bb0efcadbfc759806d
Block 2 data: James sends 4.2 BB to Alisson - Alisson sends 1.1 BB to Noah - 01e4e15242a9601725f4a86ca01fbddaaec7105b442955bb0efcadbfc759806d
Block 2 hash: 448c4306caf7f6937b0307f92f27fbea3bb73b3470363dee5026a1209dadcfa8

Pour l’instant, vous voyez simplement du texte et certains hachages de 64 caractères, mais le mécanisme d’une Blockchain est repris.

Vous commencez par un bloc de genèse, qui sert de base à tous les blocs ultérieurs.

N’importe qui peut confirmer l’intégrité de la chaîne, c’est pourquoi une Blockchain est un système si sûr. Par exemple, supposons que nous modifions considérablement la substance d’une transaction, disons :

t2 = "Mark sends 2.3 BB to James" -> t2 = "Mark sends 3.2 BB to James"

Le hachage des blocs a changé de façon spectaculaire.

Block 1 data: Noah sends 5 BB to Mark - Mark sends 3.2 BB to James - firstblock
Block 1 hash: 7a990bf1d70230bf2dad6160496c0b3046da7a17b1281fd1d4c63d4eac58e78c
Block 2 data: James sends 4.2 BB to Alisson - Alisson sends 1.1 BB to Noah - 7a990bf1d70230bf2dad6160496c0b3046da7a17b1281fd1d4c63d4eac58e78c
Block 2 hash: 569b977306ce88b53e001dca7ba00c03a51c60d6df4650e7657dcd136f2da0ac

Codage de la blockchain

Nous ne pouvons pas compter sur des variables codées à la main pour assurer l’intégrité du système, nous avons donc besoin d’une stratégie différente.

Nous avons les blocs de construction. Il est temps de créer une classe qui les relie à une Blockchain.

Pour commencer, supprimez nos transactions précédentes et les objets blockchain avant d’exécuter le code ci-dessous.

# main.py

class Blockchain:
def __init__(self):
self.chain = []
self.generate_genesis_block()

def generate_genesis_block(self):
self.chain.append(BitcoinBlock("0", ['Genesis Block']))

def create_block_from_transaction(self, transaction_list):
previous_block_hash = self.last_block.block_hash
self.chain.append(BitcoinBlock(previous_block_hash, transaction_list))

def display_chain(self):
for i in range(len(self.chain)):
print(f"Data {i + 1}: {self.chain[i].block_data}")
print(f"Hash {i + 1}: {self.chain[i].block_hash}\n")

@property
def last_block(self):
return self.chain[-1]

C’est un autre énorme morceau de code. Disséquons chaque section :

self.chain – La liste contenant tous les blocs. On peut accéder à chaque bloc en utilisant des index de liste.

generate genesis block – Ajoute le bloc initial ou genèse de la chaîne. Le hachage précédent du bloc est “0”, et la liste des transactions est simplement “Genesis Block”.

create block from transaction – Cette fonction nous permet d’ajouter des blocs à la chaîne en utilisant simplement une liste de transactions. Il serait très peu pratique de devoir construire manuellement un bloc chaque fois que nous voulons enregistrer une transaction.

display chain – Imprime la chaîne de blocs en utilisant une boucle for

last block – Propriété permettant de récupérer le dernier élément de la chaîne. Elle a été appliquée à la fonction create block from transaction.

Mettons cette Blockchain à l’épreuve.

# main.py

import hashlib

class BitcoinBlock:
...


class Blockchain:
...

t1 = "George sends 3.1 BB to Joe"
t2 = "Joe sends 2.5 BB to Adam"
t3 = "Adam sends 1.2 BB to Bob"
t4 = "Bob sends 0.5 BB to Charlie"
t5 = "Charlie sends 0.2 BB to David"
t6 = "David sends 0.1 BB to Eric"

myblockchain = Blockchain()

myblockchain.create_block_from_transaction([t1, t2])
myblockchain.create_block_from_transaction([t3, t4])
myblockchain.create_block_from_transaction([t5, t6])

myblockchain.display_chain()

Exécutez maintenant le fichier main.py.

Data 1: Genesis Block - 0
Hash 1: 39331a6a2ea1cf31a5014b2a7c9e8dfad82df0b0666e81ce04cf8173cc5aed3e

Data 2: George sends 3.1 BB to Joe - Joe sends 2.5 BB to Adam - 39331a6a2ea1cf31a5014b2a7c9e8dfad82df0b0666e81ce04cf8173cc5aed3e
Hash 2: 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5

Data 3: Adam sends 1.2 BB to Bob - Bob sends 0.5 BB to Charlie - 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5
Hash 3: 6f1cfcc3082488b97db8fdf8ed33f9ac7519be3e285a37a6fcc2f1904f373589

Data 4: Charlie sends 0.2 BB to David - David sends 0.1 BB to Eric - 6f1cfcc3082488b97db8fdf8ed33f9ac7519be3e285a37a6fcc2f1904f373589
Hash 4: 869df2f03c9860767d35b30a46233fbeea89a3000ae5019d1491e3829d1ab929

Toutes nos félicitations ! Vous venez de construire une Blockchain Python de base à partir de zéro.

Vous pouvez maintenant augmenter l’immuabilité de la blockchain en utilisant des getters et setters, ainsi qu’incorporer d’autres fonctionnalités comme la preuve de travail, le minage, ou toute autre notion abordée dans la page des fondations du minage de bitcoin.

Conclusion :

La blockchain est la technologie qui alimente le Bitcoin, l’Etherium et toutes les autres crypto-monnaies. Dans cet article, vous avez appris à établir une blockchain à l’aide de Python en utilisant des algorithmes de hachage tels que sha256, des classes et des objets.

Votre tâche consiste à concevoir un système de minage et, si possible, à l’implémenter avec une API REST en utilisant des frameworks tels que Django ou Flask.

De nombreux individus génèrent de grosses sommes d’argent grâce aux crypto-monnaies. Réfléchissez à ce que vous pourriez faire si vous en construisez une vous-même.

Continuez à coder !

You may also like

Leave a reply

Votre adresse e-mail ne sera pas publiée.