Eigene Kryptowährung von Grund auf erstellen – Nathan Ang

Wie wir sehen können, wurde eine Blockchain erfolgreich erstellt und wir haben 3 Blöcke mit einem eigenen Hash und dem Hash des vorherigen Blocks in der Kette.

Denken Sie daran, dass sich auch der Hash des manipulierten Blocks ändern würde, wenn jemand Daten in der Blockkette ändern würde, wodurch die Kette unterbrochen würde. Wenn also jemand den Wert einer Transaktion ändert, um ihm mehr Geld zu geben, würde dies die Kette unterbrechen. Wenn diese Person jedoch die Hashes jedes Blocks in der Kette neu berechnet, kann sie daraus wieder eine gültige Blockchain erstellen, die die manipulierten Daten enthält. Dies ist sehr gut mit einem Computer möglich, der die Hashwerte des Blocks und des vorherigen Blocks in Sekunden neu berechnen kann.

Damit dies nicht passiert, basiert die Blockchain-Technologie auf dem so genannten Proof-of-Work-Algorithmus.

Der einfachste Weg für mich, dies zu verstehen, bestand darin, mir vorzustellen, dass wir drei Variablen haben: x, y und z. Wir haben z, kennen y nicht und müssen einen Wert x so finden, dass x * y = z. Um dies zu lösen, sollten wir zunächst einen beliebigen Wert für x erraten, z. B. 1. Wir multiplizieren 1 * y und erhalten die Rückmeldung, wenn dieser Wert gleich z ist. Wenn dies nicht der Fall ist, sollten wir einen anderen Wert für x versuchen, z. B. 2. Wir multiplizieren 2 * x und sehen, ob es gleich z ist. Wir tun dies für jeden möglichen Wert von x, bis wir x * y = z erhalten. Dieser Vorgang wird aufgerufen rohe Gewalt, bei dem wir jeden Versuch berechnen, bis wir zufällig die richtige Antwort berechnen. Sobald wir diesen Wert für x erhalten haben, speichern wir ihn in unserem Block, was sich auf den Hash auswirkt (und ihn zum richtigen macht).

Beachten Sie, dass dies ein sehr einfaches Beispiel ist und nicht implementiert werden würde, da es zu schnell ist, um es zu lösen. Ein Beispiel für eines, das tatsächlich verwendet werden würde, ist das Folgende: Aber ja, ein Proof-of-Work-Algorithmus stellt sicher, dass sich das Umschreiben der gesamten Blockchain nicht lohnt, da wir ein neues 'x' lösen müssten (das tatsächlich aufgerufen wird) 'nonce' in diesem Kontext) für jeden Block und es würde ein dauern sehr lange Zeit.

Der Prozess der Lösung dieses Proof-of-Work, um einen neuen Block für unsere Krypowährung zu erstellen, wird aufgerufen Bergbau. Für unsere Kryptowährung habe ich einen Proof-of-Work-Algorithmus implementiert, der einen variablen Unsinn auflöst, sodass der Hash des Blocks mit "1234" beginnt.

Klasse Blockchain (Objekt):
def __init __ (self):
self.chain = [self.addGenesisBlock()];
self.pendingTransactions = [];
Selbstschwierigkeit = 4;
self.minerRewards = 50;
self.blockSize = 10;        def addTransaction (self, sender, reciever, amt, keyString, senderKey):
keyByte = keyString.encode ("ASCII");
senderKeyByte = senderKey.encode ("ASCII");        #print (type (keyByte), keyByte);        key = RSA.import_key (keyByte);
senderKey = RSA.import_key (senderKeyByte);        wenn nicht absender oder nicht empfänger oder nicht amt:
print ("Transaktionsfehler 1");
falsch zurückgeben;        transaction = Transaktion (Absender, Empfänger, amt);        transaction.signTransaction (key, senderKey);        wenn nicht transaction.isValidTransaction ():
print ("Transaktionsfehler 2");
falsch zurückgeben;
self.pendingTransactions.append (Transaktion);
return len (self.chain) + 1;Klasse Block (Objekt):
...
def mineBlock (Selbst, Schwierigkeit):
arr = [];
für i in range (0, schwierigkeit):
arr.append (i + 1);
#compute bis zum Beginn des Hash = 0123..Schwierigkeit
arrStr = map (str, arr);  
hashPuzzle = '' .join (arrStr);
#print (len (hashPuzzle));
während self.hash[0:difficulty] ! = hashPuzzle:
self.nonse + = 1;
self.hash = self.calculateHash ();
'' '
print ("Nonse:", self.nonse);
print ("Hash-Versuch:", self.hash);
print ("Hash We Want:", hashPuzzle, "...");
drucken("");
#schlaf (0,8);
'' '
drucken("");
print ("Block Mined! Nonse zum Lösen des Arbeitsnachweises:", self.nonse);
return True;

Wenn wir dies testen, indem wir einen neuen Block mit seinen eigenen Transaktionen abbauen, erhalten wir:

Klasse Blockchain (Objekt):
...
def addTransaction (self, sender, reciever, amt, keyString, senderKey):
keyByte = keyString.encode ("ASCII");
senderKeyByte = senderKey.encode ("ASCII");                key = RSA.import_key (keyByte);
senderKey = RSA.import_key (senderKeyByte);                wenn nicht absender oder nicht empfänger oder nicht amt:
print ("Transaktionsfehler 1");
falsch zurückgeben;                transaction = Transaktion (Absender, Empfänger, amt);                transaction.signTransaction (key, senderKey);                wenn nicht transaction.isValidTransaction ():
print ("Transaktionsfehler 2");
falsch zurückgeben;
self.pendingTransactions.append (Transaktion);
return len (self.chain) + 1;        def generateKeys (self):
key = RSA.generate (2048)
private_key = key.export_key ()
file_out = open ("private.pem", "wb")
file_out.write (private_key)                public_key = key.publickey (). export_key ()
file_out = open ("receiver.pem", "wb")
file_out.write (public_key)
#print (key.export_key ());
return key.publickey (). export_key (). decode ('ASCII');Klasse Transaktion (Objekt):
...
def signTransaction (self, key, senderKey):
if (self.hash! = self.calculateHash ()):
print ("Transaktionsmanipulationsfehler");
falsch zurückgeben;
if (str (key.publickey (). export_key ())! = str (senderKey.publickey (). export_key ())):
print ("Transaktionsversuch, von einer anderen Brieftasche signiert zu werden");
falsch zurückgeben;                self.signature = "gemacht";
#print (key.sign (self.hash, ""));
print ("Made Signature!");
return True;        def isValidTransaction (self):
if (self.hash! = self.calculateHash ()):
falsch zurückgeben;
if (self.sender == self.reciever):
falsch zurückgeben;
if (self.sender == "Miner Rewards"):
return True;
wenn nicht self.signature oder len (self.signature) == 0:
print ("Keine Unterschrift!")
falsch zurückgeben;
return True;

Klasse Blockchain (Objekt):
...
def register_node (self, address):
parsedUrl = urlparse (Adresse);
self.nodes.add (parsedUrl.netloc);

Klasse Blockchain (Objekt):
...
def resolveConflicts (self):
Nachbarn = self.nodes;
newChain = None;                maxLength = len (self.chain);                für Knoten in Nachbarn:
response = orders.get (f'http: // {node} / chain ');                        if response.status_code == 200:
length = response.json ()['length'];
chain = response.json ()['chain'];                        if length> maxLength und self.isValidChain ():
maxLength = length;
newChain = chain;                wenn newChain:
self.chain = self.chainJSONdecode (newChain);
print (self.chain);
return True;                falsch zurückgeben;