Comment créer une blockchain avec Python ?

Saviez-vous que le Bitcoin est construit sur une Blockchain ? Aujourd'hui, nous allons construire une Blockchain avec Python à partir de zéro.

Qu'est-ce que la blockchain ?

En 2008, le Papier bitcoin a été publié par un individu ou un groupe inconnu nommé Satoshi Nakamoto. Le bitcoin est apparu comme une version peer-to-peer de l'argent électronique qui permettait d'effectuer des transactions sans passer par des institutions centralisées (banques). La plupart des gens ne savent pas que dans ce même document, Satoshi a défini une méthode distribuée de stockage de l'information, aujourd'hui connue sous le nom de Blockchain.

Pour simplifier, la blockchain est un registre numérique partagé et immuable qui stocke les transactions sur un réseau décentralisé d'ordinateurs.

Nous pouvons diviser la blockchain en deux termes simples :

Bloc : Espace où sont stockées les transactions
Chaîne : Un ensemble d'enregistrements liés entre eux

La blockchain est définie comme une chaîne de blocs reliés entre eux, où chaque bloc stocke une transaction effectuée avec des paramètres spécifiques.

Chaque bloc est construit sur un autre bloc, créant ainsi une chaîne de blocs irréversible. En d'autres termes, chaque bloc dépend d'un autre. Il s'agit d'un système robuste et immuable dans lequel toute personne disposant des autorisations nécessaires peut vérifier l'intégrité.

La blockchain présente un ensemble intéressant de caractéristiques :

Immuabilité de l'histoire
Persistance de l'information
Pas d'erreurs dans les données stockées

De nombreux systèmes s'appuient actuellement sur la blockchain, tels que crypto-monnaies, le transfert d'actifs (NFT), et peut-être dans un avenir proche, le vote.

Il convient de mentionner qu'un Python La blockchain ne doit pas être un programme complexe avec des milliers de lignes de code. À la base, il s'agirait d'une liste de transactions liées les unes aux autres.

Bien entendu, il s'agit là d'une brève explication, mais si vous souhaitez un guide complet, nous avons réalisé un tutoriel complet sur Blockchain pour les débutants. Ne manquez pas d'y jeter un coup d'œil.

Sans plus attendre, construisons une blockchain simple avec Python.

Construire une blockchain avec Python

Avant de commencer, définissons ce que nous allons faire dans ce tutoriel :

Construire un système de blockchain simple écrit en Python
Utiliser notre Blockchain avec des transactions préétablies représentées sous forme de chaînes de caractères
Tester l'immutabilité de notre blockchain

Nous n'allons pas utiliser JSON mais des listes Python. Cela nous permettra de simplifier le processus et de nous concentrer sur l'application des concepts clés d'une Blockchain.

Ce dont vous aurez besoin pour suivre ce tutoriel :

Compréhension de la classes et méthodes en Python
Utilisation de base de la ligne de commande

Création de la classe Block

Ouvrez votre éditeur de code préféré et créez un fichier main.py fichier. C'est avec ce fichier que nous allons travailler.

Maintenant, importez hashlibBlockchain est un module qui nous permet de créer des messages cryptés à sens unique. Les techniques de cryptographie telles que le hachage permettent à la blockchain de créer des transactions sécurisées.

Une fonction de hachage est un algorithme qui prend des données (généralement une chaîne codée) et renvoie un identifiant unique, souvent appelé "condensé" ou "signature". Cette dernière partie est essentielle : avec une fonction de hachage, une légère différence dans les données d'entrée produit un identifiant radicalement différent en sortie. 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 comprend la plupart des algorithmes de hachage dont vous aurez besoin. Gardez à l'esprit que nous utiliserons l'algorithme hashlib.sha256() fonction.

Passons maintenant au GeekCoinBlock, notre nom de blockchain totalement original.

class GeekCoinBlock:
    
    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()

Je sais que cela peut donner lieu à un code compliqué. Décortiquons chaque partie dans la section suivante.

GeekCoinBlock Explication

Tout d'abord, nous créons une classe nommée GeekCoinBlockL'objet est une enveloppe pour les objets qui auront certaines caractéristiques (attributs) et certains comportements (méthodes).

Nous définissons ensuite le __init__ (également appelée constructeur), qui est invoquée à chaque fois qu'un objet GeekCoinBlock est créé.

Cette méthode a trois paramètres :

soi (l'instance de chaque objet)
bloc_précédent (référence au bloc précédent)
liste_des_transactions (liste des transactions effectuées dans le bloc en cours).

Nous stockons le hachage précédent et la liste des transactions et créons une variable d'instance données_bloc sous la forme d'une chaîne. Cela ne se produit pas avec les vraies crypto-monnaies, dans lesquelles nous stockons ce type de données sous la forme d'un autre hachage, mais pour des raisons de simplicité, nous stockerons chaque bloc de données sous la forme d'une chaîne de caractères.

Enfin, nous créons le fichier block_hashque d'autres blocs utiliseront pour continuer la chaîne. C'est là que la hashlib est utile ; au lieu de créer une fonction de hachage personnalisée, nous pouvons utiliser la fonction de hachage pré-construite sha256 pour créer des blocs immuables.

Cette fonction reçoit des chaînes (ou des octets) codées en tant que paramètres. C'est pourquoi nous utilisons l'élément block_data.encode() méthode. Ensuite, nous appelons hexdigest() pour renvoyer les données encodées au format hexadécimal.

Je sais que tout cela peut paraître insurmontable, alors jouons avec les éléments suivants hashlib sur un serveur Python coquille.

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 constater, une légère modification de l'entrée, par exemple "Python is great" (Python est génial) ou "Python is not great" (Python n'est pas génial), peut produire un hachage totalement différent. Tout cela est lié à l'intégrité de la blockchain. Si vous introduisez une petite modification dans une blockchain, son hachage changera radicalement. C'est la raison pour laquelle le dicton "Vous ne pouvez pas corrompre une blockchain" est vrai.

Utilisation de notre classe de blocs

Nous créerons une classe Blockchain complète plus tard, mais pour l'instant, utilisons notre classe Block pour créer une chaîne de blocs (Blockchain).

Dans le même fichier, créez quelques transactions composées de simples chaînes de caractères stockées dans des variables, par exemple :

class GeekCoinBlock:
    ...

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

Bien entendu, GC fait référence à GeekCoin.

Maintenant, construisez le premier bloc de notre Blockchain en utilisant la classe GeekCoinBlock et imprimez ses attributs. Tenez compte du fait que la classe précédent_hash du bloc de genèse (premier bloc qui précède les autres blocs) sera toujours une chaîne arbitraire ou un hachage, dans ce cas, "firstblock".

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

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

Ensuite, nous faisons la même chose avec le deuxième bloc, mais en passant le hachage du premier bloc en tant que paramètre précédent_hash argument.

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

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

Exécutons et analysons la sortie que nous obtenons de ce morceau de code. Une fois de plus, tapez dans votre terminal :

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

Pour l'instant, vous ne voyez que du texte et quelques hachages de 64 caractères, mais cela reprend à peu près le mécanisme d'une Blockchain.

Vous commencez par un bloc de genèse, la base de tous les autres blocs.

N'importe qui peut valider l'intégrité de la chaîne, et c'est pourquoi la blockchain est un système si sûr. Par exemple, si nous modifions légèrement le contenu d'une transaction, disons :

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

Nous constatons un changement radical dans le hachage des blocs.

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

Vous pouvez voir le projet actuel sur ce site Repo GitHub.

Coder une blockchain

Il n'est pas très intelligent de fonder l'intégrité de notre système sur des variables codées à la main, c'est pourquoi nous avons besoin d'une autre approche.

Nous avons les blocs. Il est temps de créer une classe qui les réunisse en une blockchain.

Commençons par supprimer les transactions et les objets de bloc précédents, puis utilisons 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(GeekCoinBlock("0", ['Genesis Block']))
    
    def create_block_from_transaction(self, transaction_list):
        previous_block_hash = self.last_block.block_hash
        self.chain.append(GeekCoinBlock(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]

Il s'agit à nouveau d'un énorme morceau de code. Décomposons chaque partie :

self.chain - La liste dans laquelle tous les blocs sont enregistrés. Il est possible d'accéder à chaque bloc par le biais d'index de liste.
générer_bloc_de_genèse - Ajouter le bloc Genesis ou premier bloc à 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 - Cela nous permet d'ajouter des blocs à la chaîne avec une simple liste de transactions. Il serait très ennuyeux de créer un bloc manuellement chaque fois que nous voulons enregistrer une transaction
chaîne_affichage - Imprime la chaîne de blocs à l'aide d'une boucle for
dernier_bloc - Une propriété qui nous permet d'accéder au dernier élément de la chaîne. Nous l'avons utilisée sur le create_block_from_transaction méthode.

Testons cette blockchain.

# main.py

import hashlib

class GeekCoinBlock:
    ...


class Blockchain:
    ...

t1 = "George sends 3.1 GC to Joe"
t2 = "Joe sends 2.5 GC to Adam"
t3 = "Adam sends 1.2 GC to Bob"
t4 = "Bob sends 0.5 GC to Charlie"
t5 = "Charlie sends 0.2 GC to David"
t6 = "David sends 0.1 GC 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 programme main.py fichier.

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

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

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

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

Félicitations ! 🙌 Vous venez de créer une blockchain Python simple à partir de zéro.

Vous pouvez maintenant renforcer l'immutabilité de la blockchain en utilisant des getters et setters et mettre en œuvre d'autres fonctionnalités telles que la preuve de travail, l'exploitation minièreou tout autre concept que nous avons expliqué dans le Article sur les principes fondamentaux de l'exploitation minière de Bitcoin.

Conclusion

La blockchain est la technologie qui se cache derrière Bitcoin, Etherium, et toutes les autres crypto-monnaies existantes. Dans cet article, vous avez appris à créer une Blockchain avec Python en utilisant des algorithmes de hachage tels que sha256, des classes et des objets.

Votre défi consiste à créer un système d'exploitation minière et, pourquoi pas, à le mettre en œuvre à l'aide d'une API REST en utilisant des structures telles que Django ou Flacon.

De nombreuses personnes font fortune grâce aux crypto-monnaies. Imaginez ce que vous pourriez faire si vous en créiez une par vous-même. 🤑

Continuez à coder ! 👨‍💻

Daniel Diaz

Auteur