Blockchain Beispielcode in Python

Blockchain-Technologie hat sich als revolutionär erwiesen und findet zunehmend Anwendung in verschiedenen Bereichen, von Finanztransaktionen bis hin zu sicheren Identitätsprüfungen. Python, als eine der populärsten Programmiersprachen, bietet eine hervorragende Möglichkeit, die Funktionsweise von Blockchains zu verstehen und zu implementieren. In diesem Artikel werden wir Schritt für Schritt einen einfachen Blockchain-Code in Python erstellen und erklären, wie dieser funktioniert. Wir werden die grundlegenden Konzepte wie Blöcke, Hashes und die Verkettung von Blöcken untersuchen, sowie einen Beispielcode durchgehen, der diese Konzepte veranschaulicht.

Einführung in die Blockchain-Technologie

Blockchain ist eine dezentrale Datenbanktechnologie, die Daten in sogenannten "Blöcken" speichert, die chronologisch miteinander verknüpft sind. Jeder Block enthält eine Liste von Transaktionen und einen Hash des vorherigen Blocks. Dies stellt sicher, dass die Blockchain fälschungssicher ist, da jede Änderung an einem Block die Hashes aller nachfolgenden Blöcke ungültig macht.

Grundlegende Konzepte

1. Block: Ein Block besteht aus einer Liste von Transaktionen, einem Zeitstempel und dem Hash des vorherigen Blocks.
2. Hash: Ein Hash ist eine eindeutige digitale Signatur, die durch eine Hash-Funktion erzeugt wird. Änderungen am Blockinhalt führen zu einem völlig anderen Hash.
3. Verkettung von Blöcken: Jeder Block enthält den Hash des vorherigen Blocks, wodurch eine Kette von Blöcken entsteht.

Beispielcode für eine einfache Blockchain in Python

Wir werden nun einen grundlegenden Beispielcode für eine Blockchain in Python erstellen. Dieser Code wird die grundlegenden Konzepte abdecken und eine einfache Implementierung einer Blockchain darstellen.

python
import hashlib
import json
from time import time

class Blockchain:
    def __init__(self):
        self.chain = []
        self.current_transactions = []
        # Create the genesis block
        self.new_block(previous_hash='1', proof=100)

    def new_block(self, proof, previous_hash=None):
        """
        Erzeugt einen neuen Block in der Blockchain
        :param proof: Der Proof, der mit dem Block verbunden ist
        :param previous_hash: (Optional) Hash des vorherigen Blocks
        :return: Neuer Block
        """
        block = {
            'index': len(self.chain) + 1,
            'timestamp': time(),
            'transactions': self.current_transactions,
            'proof': proof,
            'previous_hash': previous_hash or self.hash(self.chain[-1]),
        }
        self.current_transactions = []
        self.chain.append(block)
        return block

    def new_transaction(self, sender, recipient, amount):
        """
        Fügt eine neue Transaktion zur Liste der Transaktionen hinzu
        :param sender: Absender der Transaktion
        :param recipient: Empfänger der Transaktion
        :param amount: Betrag der Transaktion
        :return: Index des Blocks, der die Transaktion enthalten wird
        """
        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })
        return self.last_block['index'] + 1

    @staticmethod
    def hash(block):
        """
        Erzeugt einen SHA-256 Hash für einen Block
        :param block: Block
        :return: Hash des Blocks
        """
        block_string = json.dumps(block, sort_keys=True).encode()
        return hashlib.sha256(block_string).hexdigest()

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

    def proof_of_work(self, last_proof):
        """
        Einfacher Proof of Work Algorithmus:
        - Suche nach einer Zahl p', so dass hash(pp') ein führendes 4er Null enthält
        - p ist der vorherige Proof, p' ist der neue Proof
        :param last_proof: Der letzte Proof
        :return: Neuer Proof
        """
        proof = 0
        while self.valid_proof(last_proof, proof) is False:
            proof += 1
        return proof

    @staticmethod
    def valid_proof(last_proof, proof):
        """
        Überprüft, ob der Proof gültig ist
        :param last_proof: Der vorherige Proof
        :param proof: Der aktuelle Proof
        :return: True, wenn der Proof gültig ist, sonst False
        """
        guess = f'{last_proof}{proof}'.encode()
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"

# Beispiel für die Verwendung der Blockchain
blockchain = Blockchain()

# Neue Transaktionen hinzufügen
blockchain.new_transaction(sender="Alice", recipient="Bob", amount=50)
blockchain.new_transaction(sender="Bob", recipient="Charlie", amount=25)

# Proof of Work durchführen und neuen Block hinzufügen
last_proof = blockchain.last_block['proof']
proof = blockchain.proof_of_work(last_proof)
blockchain.new_block(proof)

# Blockchain anzeigen
for block in blockchain.chain:
    print(block)

Erklärungen zum Code

• Blockchain Klasse: Die Hauptklasse, die die Blockchain verwaltet. Sie enthält Methoden zum Erstellen neuer Blöcke und Transaktionen.
• new_block: Erstellt einen neuen Block und fügt ihn zur Kette hinzu.
• new_transaction: Fügt eine neue Transaktion zur Liste der Transaktionen hinzu.
• hash: Berechnet den Hash eines Blocks.
• proof_of_work: Implementiert den Proof of Work Algorithmus, um die Schwierigkeit des Minings zu bestimmen.
• valid_proof: Überprüft, ob der Proof den Anforderungen entspricht (führt zu einem Hash mit vier führenden Nullen).

Fazit

Dieser Beispielcode bietet einen grundlegenden Einstieg in die Blockchain-Technologie mit Python. Durch das Verständnis und die Implementierung dieses Codes können Sie die Grundprinzipien von Blockchains besser verstehen und auf komplexere Anwendungsfälle anwenden. Die Blockchain-Technologie hat das Potenzial, viele Branchen zu revolutionieren, und das Wissen über ihre Implementierung kann wertvolle Einblicke in diese spannende Technologie geben.