Wie erstellt man eine Blockchain mit Python?

Wussten Sie, dass Bitcoin auf einer Blockchain aufbaut? Heute werden wir eine Blockchain mit Python von Grund auf aufbauen

Was ist Blockchain?

Im Jahr 2008 wurde das Bitcoin-Papier von einer unbekannten Person oder Gruppe namens Satoshi Nakamoto veröffentlicht. Bitcoin kam als Peer-to-Peer-Version von elektronischem Bargeld auf den Markt, die Transaktionen ohne den Umweg über zentralisierte Institutionen (Banken) ermöglichte. Die meisten Menschen wissen nicht, dass Satoshi in demselben Papier eine verteilte Art der Informationsspeicherung definierte, die heute als Blockchain ist bekannt

Einfach ausgedrückt ist Blockchain ein gemeinsames, unveränderliches digitales Buch, das Transaktionen über ein dezentrales Computernetzwerk speichert.

Wir können Blockchain in zwei einfache Begriffe unterteilen

Block: Ein Bereich, in dem wir Transaktionen speichern
Kette: Eine Reihe von verknüpften Datensätzen

Dies definiert Blockchain als eine Kette von verknüpften Blöcken, wobei jeder Block eine mit bestimmten Parametern durchgeführte Transaktion speichert.

Jeder Block baut auf einen anderen Block auf, wodurch eine unumkehrbare Kette von Blöcken entsteht. Mit anderen Worten: Jeder Block hängt von einem anderen ab. So entsteht ein robustes und unveränderliches System, in dem jeder mit den richtigen Berechtigungen die Integrität überprüfen kann.

Blockchain führt eine Reihe interessanter Funktionen ein

Unveränderlichkeit der Geschichte
Beständigkeit der Informationen
Keine Fehler bei gespeicherten Daten

Viele Systeme verlassen sich derzeit auf Blockchain, z.B. Kryptowährungen, Vermögensübertragungen(NFTs) und möglicherweise in naher Zukunft auch Abstimmungen

Es ist erwähnenswert, dass eine Python-Blockchain kein komplexes Programm mit Tausenden von Codezeilen sein muss. Im Kern handelt es sich um eine Liste von Transaktionen, die miteinander verknüpft sind

Dies war natürlich nur eine kurze Erklärung, aber wenn Sie eine vollständige Anleitung wünschen, haben wir ein komplettes Tutorial über Blockchain für Anfänger erstellt. Schauen Sie es sich unbedingt an

Lassen Sie uns ohne weitere Verzögerung eine einfache Blockchain mit Python erstellen

Aufbau einer Blockchain mit Python

Bevor wir beginnen, lassen Sie uns definieren, was wir in diesem Tutorial tun werden

Aufbau eines einfachen Blockchain-Systems, geschrieben in Python
Verwendung unserer Blockchain mit vordefinierten Transaktionen, die als Strings dargestellt werden
Testen Sie die Unveränderlichkeit unserer Blockchain

Wir werden nicht JSON, sondern Python-Listen verwenden. So können wir den Prozess vereinfachen und uns auf die Anwendung der wichtigsten Konzepte einer Blockchain konzentrieren

Was Sie brauchen, um diesem Tutorial zu folgen

Verständnis von Klassen und Methoden in Python
Grundlegende Verwendung der Kommandozeile

Erstellen der Klasse Block

Öffnen Sie Ihren bevorzugten Code-Editor und erstellen Sie eine Datei main.py . Dies wird die Datei sein, mit der wir arbeiten werden.

Importieren Sie jetzt hashlib, ein Modul, mit dem wir einseitig verschlüsselte Nachrichten erstellen können. Mit Kryptographietechniken wie Hashing können Sie mit Blockchain sichere Transaktionen erstellen

Eine Hash-Funktion ist ein Algorithmus, der aus einigen Daten (in der Regel eine verschlüsselte Zeichenkette) eine eindeutige Kennung zurückgibt, die oft als "Digest" oder "Signatur" bezeichnet wird. Dieser letzte Teil ist von entscheidender Bedeutung. Bei einer Hash-Funktion führt ein kleiner Unterschied in der Eingabe zu einer völlig anderen Kennung als Ausgabe. Wir werden dies später in Aktion sehen

Für den Moment importieren Sie einfach das integrierte Modul hashlib

# main.py Datei

“

""

Eine

 einfache Blockchain in Python

“

""

import hashlib

Dieses Modul enthält die meisten der Hash-Algorithmen, die Sie benötigen. Denken Sie nur daran, dass wir die Funktion hashlib.sha256() verwendet werden

Kommen wir nun zum GeekCoinBlock, unserem ganz eigenen Blockchain-Namen

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()

Ich weiß, dass dies zu einem klobigen Stück Code führen kann. Lassen Sie uns im nächsten Abschnitt jeden Teil aufschlüsseln

GeekCoinBlock Erläuterung

Zunächst erstellen wir eine Klasse namens GeekCoinBlockeine Hülle für Objekte, die bestimmte Eigenschaften (Attribute) und Verhaltensweisen (Methoden) haben werden

Dann definieren wir die Methode __init__ (auch Konstruktor genannt), die jedes Mal aufgerufen wird, wenn ein GeekCoinBlock Objekt erstellt wird

Diese Methode hat drei Parameter

selbst (die Instanz des jeweiligen Objekts)
vorheriger_block_hash (ein Verweis auf den vorherigen Block)
transaktions_liste (eine Liste der im aktuellen Block durchgeführten Transaktionen).

Wir speichern den vorherigen Hash und die Transaktionsliste und erstellen eine Instanzvariable block_data als String. Dies geschieht nicht bei echten Kryptowährungen, bei denen wir diese Art von Daten als einen weiteren Hash speichern, aber der Einfachheit halber speichern wir jeden Block von Daten als String

Schließlich erstellen wir den block_hash, der von anderen Blöcken verwendet wird, um die Kette fortzusetzen. Hier kommt hashlib ins Spiel. Anstatt eine eigene Hash-Funktion zu erstellen, können wir die vorgefertigte sha256 verwenden, um unveränderliche Blöcke zu erstellen

Diese Funktion empfängt kodierte Zeichenketten (oder Bytes) als Parameter. Aus diesem Grund verwenden wir die Methode block_data.encode(). Danach rufen wir hexdigest() auf, um die verschlüsselten Daten im hexadezimalen Format zurückzugeben

Ich weiß, dass dies alles überwältigend sein kann, also lassen Sie uns mit hashlib auf einer Python-Shell spielen

In [1]: import hashlib

In [2]: message = "Python ist toll"

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

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

In <x>[5]</x>: h1.hexdigest()
Out<x>[5]</x>: 'a40cf9cca ... 42ab97'

In [6]: h2 = hashlib.sha256(b "Python ist nicht toll")

In <x>[7]</x>: h2
Out<x>[7]</x>: <sha256 ... Objekt @ 0x7efcd55bfc90>

In <x>[8]</x>: h2.hexdigest()
Out<x>[8]</x>: 'fefe510a6a ... 97e010c0ea34'

Wie Sie sehen, kann eine geringfügige Änderung der Eingabe wie "Python ist großartig" in "Python ist nicht großartig" einen völlig anderen Hash ergeben. Das hat alles mit der Integrität der Blockchain zu tun. Wenn Sie eine kleine Änderung in eine Blockchain einführen, wird sich ihr Hash dramatisch verändern. Das ist der Grund, warum das Sprichwort "Man kann eine Blockchain nicht korrumpieren" wahr ist

Verwendung unserer Block-Klasse

Wir werden später eine ganze Blockchain-Klasse erstellen, aber für den Moment verwenden wir unsere Block-Klasse, um eine Kette von Blöcken (Blockchain) zu erstellen

Erstellen Sie in derselben Datei ein paar Transaktionen, die zum Beispiel aus einfachen Strings bestehen, die in Variablen gespeichert sind

class GeekCoinBlock:

..

= "Noah sendet 5 GC an Mark"

= "Mark sendet 2,3 GC an James"

= "James sendet 4,2 GC an Alisson"

= "Alisson sendet 1,1 GC an Noah"

GC bezieht sich natürlich auf GeekCoin

Erstellen Sie nun den ersten Block unserer Blockchain, indem Sie die Klasse GeekCoinBlock verwenden und seine Attribute ausgeben. Beachten Sie, dass der Parameter vorheriger_Hash des genesis-Blocks (erster Block, der anderen Blöcken vorausgeht) immer eine beliebige Zeichenkette oder ein Hash sein wird, in diesem Fall "firstblock".

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

print(f "Block 1 Daten: {block1.block_data}")
print(f "Block 1 Hash: {block1.block_hash}")

Dann machen wir dasselbe mit dem zweiten Block, übergeben aber den Hash des ersten Blocks als Argument vorheriger_Hash

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

print(f "Block 2 Daten: {block2.block_data}")
print(f "Block 2 Hash: {block2.block_hash}")

Lassen Sie uns die Ausgabe, die wir von diesem Code erhalten, ausführen und analysieren. Geben Sie noch einmal in Ihr Terminal ein

❯ python main.py
Block 1 Daten: Noah sendet 5 GC an Mark - Mark sendet 2.3 GC an James - firstblock
Block 1 Hash: 01e4e15242a9601725f4a86ca01fbddaaec7105b442955bb0efcadbfc759806d
Block 2 Daten: James sendet 4.2 GC an Alisson - Alisson sendet 1.1 GC an Noah - 01e4e15242a9601725f4a86ca01fbddaaec7105b442955bb0efcadbfc759806d
Block 2 Hash: 448c4306caf7f6937b0307f92f27fbea3bb73b3470363dee5026a1209dadcfa8

Im Moment sehen Sie nur Text und einige 64-Zeichen-Hashes, aber das entspricht ziemlich genau dem Mechanismus einer Blockchain

Sie beginnen mit einem Genesis-Block, der die Grundlage für alle anderen Blöcke bildet

Jeder kann die Integrität der Kette überprüfen, und deshalb ist eine Blockchain ein so sicheres System. Wenn wir zum Beispiel den Inhalt einer Transaktion leicht verändern, sagen wir

t2 = "Mark sendet 2,3 GC an James" -> t2 = "Mark sendet 3,2 GC an James"

Wir sehen eine dramatische Veränderung im Hash der Blöcke

Block 1 Daten: Noah sendet 5 GC an Mark - Mark sendet 3.2 GC an James - firstblock
Block 1 Hash: 7a990bf1d70230bf2dad6160496c0b3046da7a17b1281fd1d4c63d4eac58e78c
Block 2 Daten: James sendet 4.2 GC an Alisson - Alisson sendet 1.1 GC an Noah - 7a990bf1d70230bf2dad6160496c0b3046da7a17b1281fd1d4c63d4eac58e78c
Block 2 Hash: 569b977306ce88b53e001dca7ba00c03a51c60d6df4650e7657dcd136f2da0ac

Sie können das aktuelle Projekt in diesem GitHub Repo siehe

Kodierung einer Blockchain

Es ist nicht besonders clever, die Integrität unseres Systems auf handcodierte Variablen zu stützen.

Wir haben die Blöcke. Es ist an der Zeit, eine Klasse zu erstellen, die sie zu einer Blockchain zusammenfügt

Beginnen wir damit, unsere vorherigen Transaktionen und Blockobjekte zu löschen und dann den folgenden Code zu verwenden

# 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 "Daten {i 1}: {self.chain<x>[i]</x>.block_data}")
 print(f "Hash {i 1}: {self.chain<x>[i]</x>.block_hash}\n")

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

Dies ist wieder ein riesiges Stück Code. Lassen Sie uns jeden Teil aufschlüsseln

self.chain - Die Liste, in der alle Blöcke aufgezeichnet sind. Wir können auf jeden Block über Listenindizes zugreifen.
generate_genesis_block - Hängt den genesis oder ersten Block an die Kette an. Der vorherige Hash des Blocks ist "0", und die Liste der Transaktionen ist einfach "Genesis Block".
create_block_from_transaction - Damit können wir Blöcke an die Kette anhängen, die nur eine Liste von Transaktionen enthalten. Es wäre sehr lästig, jedes Mal einen Block manuell zu erstellen, wenn wir eine Transaktion aufzeichnen wollen.
display_chain - Gibt die Kette der Blöcke mit einer for-Schleife aus
letzter_block - Eine Eigenschaft, mit der wir auf das letzte Element der Kette zugreifen können. Wir haben sie mit der Methode create_block_from_transaction verwendet.

Lassen Sie uns diese Blockchain testen

# main.py

import hashlib

class GeekCoinBlock:
...


class Blockchain:
...

t1 = "George sendet 3.1 GC an Joe"
t2 = "Joe sendet 2.5 GC an Adam"
t3 = "Adam sendet 1.2 GC an Bob"
t4 = "Bob sendet 0.5 GC an Charlie"
t5 = "Charlie sendet 0.2 GC an David"

t6 = "

David sendet 0,1 GC an 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()

Führen Sie nun die Datei main.py aus

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

Daten 2: George sendet 3.1 GC an Joe - Joe sendet 2.5 GC an Adam - 39331a6a2ea1cf31a5014b2a7c9e8dfad82df0b0666e81ce04cf8173cc5aed3e
Hash 2: 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5

Daten 3: Adam sendet 1.2 GC an Bob - Bob sendet 0.5 GC an Charlie - 98cf363aecb33989aea0425a3c1287268bd86f63851bc08c0734a31db08506d5
Hash 3: 6f1cfcc3082488b97db8fdf8ed33f9ac7519be3e285a37a6fcc2f1904f373589

Data 4: Charlie sendet 0.2 GC an David - David sendet 0.1 GC an Eric - 6f1cfcc3082488b97db8fdf8ed33f9ac7519be3e285a37a6fcc2f1904f373589

Raute

4: 869df2f03c9860767d35b30a46233fbeea89a3000ae5019d1491e3829d1ab929

Herzlichen Glückwunsch! 🙌 Sie haben gerade eine einfache Python-Blockchain von Grund auf erstellt

Sie können nun die Unveränderlichkeit der Blockchain durch die Verwendung von Gettern und Settern verstärken und andere Funktionen wie Proof-of-Work, Bergbau oder andere Konzepte implementieren, die wir im Artikel Grundlagen des Bitcoin-Minings erläutert haben

Fazit

Blockchain ist die Technologie hinter Bitcoin, Etherium und jede andere Kryptowährung. In diesem Artikel haben Sie gelernt, wie Sie eine Blockchain mit Python erstellen können, indem Sie Hash-Algorithmen wie sha256, Klassen und Objekte verwenden

Ihre Aufgabe ist es, ein Mining-System zu erstellen und warum nicht, es mit einer REST-API unter Verwendung von Frameworks wie Django oder Flachmann zu implementieren

Viele Menschen machen ein Vermögen mit Kryptowährungen. Stellen Sie sich nur einmal vor, was Sie erreichen könnten, wenn Sie selbst ein solches System erstellen. 🤑

Programmieren Sie weiter! 👨‍💻

Daniel Diaz

Autor