So erstellen Sie Ihre eigene Kryptowährung mit Python

Mit dem gegenwärtigen Anstieg der Kryptowährungen sorgt Blockchain für Aufsehen in der Technologiewelt. Diese Technologie hat vor allem aufgrund ihrer Fähigkeit, Sicherheit zu gewährleisten, Dezentralisierung durchzusetzen und Prozesse in mehreren Branchen - insbesondere in der Finanzbranche - zu beschleunigen, so viel Aufmerksamkeit auf sich gezogen.

Im Wesentlichen ist eine Blockchain eine öffentliche Datenbank, die den Besitz und die Übertragung digitaler Assets irreversibel dokumentiert und authentifiziert. Digitale Währungen wie Bitcoin und Ethereum basieren auf diesem Konzept. Blockchain ist eine aufregende Technologie, mit der Sie die Funktionen Ihrer Anwendungen transformieren können.

In letzter Zeit haben Regierungen, Organisationen und Einzelpersonen die Blockchain-Technologie verwendet, um ihre eigenen Kryptowährungen zu erstellen - und um nicht zurückgelassen zu werden. Als Facebook seine eigene Kryptowährung namens Libra vorschlug, regte die Ankündigung viele Gewässer auf der ganzen Welt auf.

Was wäre, wenn Sie auch nachziehen und Ihre eigene Version einer Kryptowährung erstellen könnten?

Ich dachte darüber nach und beschloss, einen Algorithmus zu entwickeln, der eine Krypto erstellt.

Ich habe beschlossen, die Kryptowährung fccCoin aufzurufen .

In diesem Tutorial werde ich den schrittweisen Prozess veranschaulichen, den ich zum Erstellen der digitalen Währung verwendet habe (ich habe die objektorientierten Konzepte der Programmiersprache Python verwendet).

Hier ist die grundlegende Blaupause des Blockchain-Algorithmus zum Erstellen der fccCoin :

class Block: def __init__(): #first block class pass def calculate_hash(): #calculates the cryptographic hash of every block class BlockChain: def __init__(self): # constructor method pass def construct_genesis(self): # constructs the initial block pass def construct_block(self, proof_no, prev_hash): # constructs a new block and adds it to the chain pass @staticmethod def check_validity(): # checks whether the blockchain is valid pass def new_data(self, sender, recipient, quantity): # adds a new transaction to the data of the transactions pass @staticmethod def construct_proof_of_work(prev_proof): # protects the blockchain from attack pass @property def last_block(self): # returns the last block in the chain return self.chain[-1] 

Lassen Sie mich nun erklären, was passiert ...

1. Erstellen der ersten Blockklasse

Eine Blockchain besteht aus mehreren Blöcken, die miteinander verbunden sind (das kommt mir bekannt vor, oder?).

Die Verkettung von Blöcken erfolgt so, dass der Rest der Kette ungültig wird, wenn ein Block manipuliert wird.

Bei der Anwendung des obigen Konzepts habe ich die folgende anfängliche Blockklasse erstellt:

import hashlib import time class Block: def __init__(self, index, proof_no, prev_hash, data, timestamp=None): self.index = index self.proof_no = proof_no self.prev_hash = prev_hash self.data = data self.timestamp = timestamp or time.time() @property def calculate_hash(self): block_of_string = "{}{}{}{}{}".format(self.index, self.proof_no, self.prev_hash, self.data, self.timestamp) return hashlib.sha256(block_of_string.encode()).hexdigest() def __repr__(self): return "{} - {} - {} - {} - {}".format(self.index, self.proof_no, self.prev_hash, self.data, self.timestamp) 

Wie Sie dem obigen Code entnehmen können, habe ich die Funktion __init __ () definiert , die wie bei jeder anderen Python-Klasse ausgeführt wird, wenn die Block- Klasse initiiert wird.

Ich habe die folgenden Parameter für die Initiierungsfunktion bereitgestellt:

  • self - Dies bezieht sich auf die Instanz der Block- Klasse, sodass auf die mit der Klasse verknüpften Methoden und Attribute zugegriffen werden kann.
  • index - Hiermit wird die Position des Blocks innerhalb der Blockchain verfolgt.
  • proof_no - Dies ist die Zahl, die beim Erstellen eines neuen Blocks (Mining genannt) erzeugt wird.
  • prev_hash - Dies bezieht sich auf den Hash des vorherigen Blocks innerhalb der Kette.
  • Daten - Auf diese Weise werden alle abgeschlossenen Transaktionen aufgezeichnet, z. B. die gekaufte Menge.
  • Zeitstempel - Hiermit wird ein Zeitstempel für die Transaktionen platziert.

Die zweite Methode in der Klasse, berechne_hash , generiert den Hash der Blöcke unter Verwendung der obigen Werte. Das SHA-256-Modul wird in das Projekt importiert, um das Abrufen der Hashes der Blöcke zu unterstützen.

Nachdem die Werte in den kryptografischen Hash-Algorithmus eingegeben wurden, gibt die Funktion eine 256-Bit-Zeichenfolge zurück, die den Inhalt des Blocks darstellt.

Auf diese Weise wird Sicherheit in Blockchains erreicht - jeder Block hat einen Hash und dieser Hash basiert auf dem Hash des vorherigen Blocks.

Wenn jemand versucht, einen Block in der Kette zu kompromittieren, haben die anderen Blöcke ungültige Hashes, was zu einer Störung des gesamten Blockchain-Netzwerks führt.

Letztendlich wird ein Block so aussehen:

{ "index": 2, "proof": 21, "prev_hash": "6e27587e8a27d6fe376d4fd9b4edc96c8890346579e5cbf558252b24a8257823", "transactions": [ {'sender': '0', 'recipient': 'Quincy Larson', 'quantity': 1} ], "timestamp": 1521646442.4096143 } 

2. Erstellen der Blockchain-Klasse

Die Hauptidee einer Blockchain besteht, wie der Name schon sagt, darin, mehrere Blöcke miteinander zu verketten.

Daher werde ich eine Blockchain- Klasse erstellen, die bei der Verwaltung der Funktionsweise der gesamten Kette hilfreich ist. Hier wird der größte Teil der Aktion stattfinden.

Die Blockchain- Klasse verfügt über verschiedene Hilfsmethoden zum Ausführen verschiedener Aufgaben in der Blockchain.

Lassen Sie mich die Rolle jeder der Methoden in der Klasse erklären.

ein. Konstruktormethode

Diese Methode stellt sicher, dass die Blockchain instanziiert wird.

class BlockChain: def __init__(self): self.chain = [] self.current_data = [] self.nodes = set() self.construct_genesis() 

Hier sind die Rollen seiner Attribute:

  • self.chain - Diese Variable enthält alle Blöcke.
  • self.current_data - Diese Variable speichert alle abgeschlossenen Transaktionen im Block.
  • self.construct_genesis () - Diese Methode kümmert sich um die Erstellung des Anfangsblocks.

b. Aufbau des Genesis-Blocks

Die Blockchain erfordert eine Methode construct_genesis , um den ersten Block in der Kette zu erstellen. In der Blockchain-Konvention ist dieser Block etwas Besonderes, da er den Beginn der Blockchain symbolisiert.

In diesem Fall erstellen wir es, indem wir einfach einige Standardwerte an die Methode construct_block übergeben .

Ich habe sowohlproof_no als auch prev_hash den Wert Null gegeben, obwohl Sie jeden gewünschten Wert angeben können.

def construct_genesis(self): self.construct_block(proof_no=0, prev_hash=0) def construct_block(self, proof_no, prev_hash): block = Block( index=len(self.chain), proof_no=proof_no, prev_hash=prev_hash, data=self.current_data) self.current_data = [] self.chain.append(block) return block 

c. Neue Blöcke bauen

Die Methode construct_block wird zum Erstellen neuer Blöcke in der Blockchain verwendet.

Folgendes geschieht mit den verschiedenen Attributen dieser Methode:

  • index - Dies repräsentiert die Länge der Blockchain.
  • proof_nor & prev_hash - die Aufrufermethode übergibt sie;
  • Daten - Dies enthält eine Aufzeichnung aller Transaktionen, die in keinem Block des Knotens enthalten sind.
  • self.current_data: Hiermit wird die Transaktionsliste auf dem Knoten zurückgesetzt. Wenn ein Block erstellt und die Transaktionen ihm zugewiesen wurden, wird die Liste zurückgesetzt, um sicherzustellen, dass zukünftige Transaktionen zu dieser Liste hinzugefügt werden. Und dieser Prozess wird kontinuierlich stattfinden;
  • self.chain.append () - Diese Methode verbindet neu erstellte Blöcke mit der Kette.
  • return - Zuletzt wird ein konstruiertes Blockobjekt zurückgegeben.

d. Überprüfung der Gültigkeit

Die Methode check_validity ist wichtig, um die Integrität der Blockchain zu bewerten und sicherzustellen, dass keine Anomalien vorliegen .

Wie bereits erwähnt, sind Hashes für die Sicherheit der Blockchain unerlässlich, da bereits die geringste Änderung des Objekts zur Generierung eines völlig neuen Hashs führt.

Daher verwendet diese check_validity- Methode if- Anweisungen, um zu überprüfen, ob der Hash jedes Blocks korrekt ist.

Außerdem wird überprüft, ob jeder Block auf den rechten vorherigen Block zeigt, indem der Wert seiner Hashes verglichen wird. Wenn alles korrekt ist, wird true zurückgegeben. Andernfalls wird false zurückgegeben.

@staticmethod def check_validity(block, prev_block): if prev_block.index + 1 != block.index: return False elif prev_block.calculate_hash != block.prev_hash: return False elif not BlockChain.verifying_proof(block.proof_no, prev_block.proof_no): return False elif block.timestamp <= prev_block.timestamp: return False return True 

e. Hinzufügen von Transaktionsdaten

Die new_data- Methode wird zum Hinzufügen der Transaktionsdaten zu einem Block verwendet. Es ist eine sehr einfache Methode: Sie akzeptiert drei Parameter (Absenderdetails, Empfängerdetails und Menge) und hängt die Transaktionsdaten an die Liste self.current_data an .

Jedes Mal, wenn ein neuer Block erstellt wird, wird diese Liste diesem Block zugewiesen und erneut zurückgesetzt, wie in der Methode construct_block erläutert .

Sobald die Transaktionsdaten zur Liste hinzugefügt wurden, wird der Index des nächsten zu erstellenden Blocks zurückgegeben.

Dieser Index wird berechnet, indem 1 zum Index des aktuellen Blocks hinzugefügt wird (der der letzte in der Blockchain ist). Die Daten helfen einem Benutzer bei der zukünftigen Übermittlung der Transaktion.

def new_data(self, sender, recipient, quantity): self.current_data.append({ 'sender': sender, 'recipient': recipient, 'quantity': quantity }) return True 

f. Arbeitsnachweis hinzufügen

Proof of Work ist ein Konzept, das den Missbrauch der Blockchain verhindert. Ihr Ziel ist es einfach, eine Zahl zu identifizieren, die ein Problem löst, nachdem ein bestimmter Rechenaufwand erledigt wurde.

Wenn der Schwierigkeitsgrad beim Identifizieren der Nummer hoch ist, wird von Spam und Manipulationen an der Blockchain abgeraten.

In diesem Fall verwenden wir einen einfachen Algorithmus, der Menschen davon abhält, Blöcke abzubauen oder Blöcke einfach zu erstellen.

@staticmethod def proof_of_work(last_proof): '''this simple algorithm identifies a number f' such that hash(ff') contain 4 leading zeroes f is the previous f' f' is the new proof ''' proof_no = 0 while BlockChain.verifying_proof(proof_no, last_proof) is False: proof_no += 1 return proof_no @staticmethod def verifying_proof(last_proof, proof): #verifying the proof: does hash(last_proof, proof) contain 4 leading zeroes? guess = f'{last_proof}{proof}'.encode() guess_hash = hashlib.sha256(guess).hexdigest() return guess_hash[:4] == "0000" 

G. Den letzten Block bekommen

Lastly, the latest_blockmethod is a helper method that assists in obtaining the last block in the blockchain. Remember that the last block is actually the current block in the chain.

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

Let’s sum everything together

Here is the entire code for creating the fccCoin cryptocurrency.

You can also get the code on this GitHub repository.

import hashlib import time class Block: def __init__(self, index, proof_no, prev_hash, data, timestamp=None): self.index = index self.proof_no = proof_no self.prev_hash = prev_hash self.data = data self.timestamp = timestamp or time.time() @property def calculate_hash(self): block_of_string = "{}{}{}{}{}".format(self.index, self.proof_no, self.prev_hash, self.data, self.timestamp) return hashlib.sha256(block_of_string.encode()).hexdigest() def __repr__(self): return "{} - {} - {} - {} - {}".format(self.index, self.proof_no, self.prev_hash, self.data, self.timestamp) class BlockChain: def __init__(self): self.chain = [] self.current_data = [] self.nodes = set() self.construct_genesis() def construct_genesis(self): self.construct_block(proof_no=0, prev_hash=0) def construct_block(self, proof_no, prev_hash): block = Block( index=len(self.chain), proof_no=proof_no, prev_hash=prev_hash, data=self.current_data) self.current_data = [] self.chain.append(block) return block @staticmethod def check_validity(block, prev_block): if prev_block.index + 1 != block.index: return False elif prev_block.calculate_hash != block.prev_hash: return False elif not BlockChain.verifying_proof(block.proof_no, prev_block.proof_no): return False elif block.timestamp <= prev_block.timestamp: return False return True def new_data(self, sender, recipient, quantity): self.current_data.append({ 'sender': sender, 'recipient': recipient, 'quantity': quantity }) return True @staticmethod def proof_of_work(last_proof): '''this simple algorithm identifies a number f' such that hash(ff') contain 4 leading zeroes f is the previous f' f' is the new proof ''' proof_no = 0 while BlockChain.verifying_proof(proof_no, last_proof) is False: proof_no += 1 return proof_no @staticmethod def verifying_proof(last_proof, proof): #verifying the proof: does hash(last_proof, proof) contain 4 leading zeroes? guess = f'{last_proof}{proof}'.encode() guess_hash = hashlib.sha256(guess).hexdigest() return guess_hash[:4] == "0000" @property def latest_block(self): return self.chain[-1] def block_mining(self, details_miner): self.new_data( sender="0", #it implies that this node has created a new block receiver=details_miner, quantity= 1, #creating a new block (or identifying the proof number) is awarded with 1 ) last_block = self.latest_block last_proof_no = last_block.proof_no proof_no = self.proof_of_work(last_proof_no) last_hash = last_block.calculate_hash block = self.construct_block(proof_no, last_hash) return vars(block) def create_node(self, address): self.nodes.add(address) return True @staticmethod def obtain_block_object(block_data): #obtains block object from the block data return Block( block_data['index'], block_data['proof_no'], block_data['prev_hash'], block_data['data'], timestamp=block_data['timestamp']) 

Now, let’s test our code to see if it works.

blockchain = BlockChain() print("***Mining fccCoin about to start***") print(blockchain.chain) last_block = blockchain.latest_block last_proof_no = last_block.proof_no proof_no = blockchain.proof_of_work(last_proof_no) blockchain.new_data( sender="0", #it implies that this node has created a new block recipient="Quincy Larson", #let's send Quincy some coins! quantity= 1, #creating a new block (or identifying the proof number) is awarded with 1 ) last_hash = last_block.calculate_hash block = blockchain.construct_block(proof_no, last_hash) print("***Mining fccCoin has been successful***") print(blockchain.chain) 

It worked!

Here is the output of the mining process:

***Mining fccCoin about to start*** [0 - 0 - 0 - [] - 1566930640.2707076] ***Mining fccCoin has been successful*** [0 - 0 - 0 - [] - 1566930640.2707076, 1 - 88914 - a8d45cb77cddeac750a9439d629f394da442672e56edfe05827b5e41f4ba0138 - [{'sender': '0', 'recipient': 'Quincy Larson', 'quantity': 1}] - 1566930640.5363243] 

Conclusion

There you have it!

That’s how you could create your own blockchain using Python.

Let me say that this tutorial just demonstrates the basic concepts for getting your feet wet in the innovative blockchain technology.

If this coin were deployed as-is, it could not meet the present market demands for a stable, secure, and easy-to-use cryptocurrency.

Therefore, it can still be improved by adding additional features to enhance its capabilities for mining and sending financial transactions.

Nonetheless, it’s a good starting point if you decide to make your name known in the amazing world of cryptos.

If you have any comments or questions, please post them below.

Happy (crypto) coding!