Hoe bouw je een blockchain in Python?

Als je wilt leren hoe je een blockchain bouwt, dan ben je bij ons aan het goede adres. Laten we diep duiken om te leren hoe u een blockchain in Python kunt bouwen.

Er zijn heel veel artikelen over blockchain, maar ze praten niet allemaal over het helemaal opnieuw bouwen van een blockchain. Als ontwikkelaar zijn theorieën belangrijk, maar je moet ook een blockchain maken om het concept erachter volledig te begrijpen.

Het kernidee achter blockchains is het gedecentraliseerde karakter ervan. Je zult gefascineerd zijn door hoe het allemaal van binnen werkt. Blockchain klinkt misschien simpel, maar van binnen zijn er veel protocollen en algoritmen die het mogelijk maken. We gaan Python gebruiken om vanuit het niets een blockchain te maken.

U kunt het artikel ook opslaan en er een bladwijzer van maken als ‘Hoe onze blockchain te bouwen’. Geloof me; het artikel zal je op de lange termijn helpen.

Nog nooit van blockchain gehoord? Bekijk dan de gratis cursus van 101Blockchain. Als je je carrière wilt bevorderen, bekijk dan de Certified Enterprise Blockchain-cursus waar je leert hoe enterprise blockchain werkt. Laten we beginnen.

Ben je een beginner in Blockchain? Schrijf je in voor de Blockchain Free Course en start nu je Blockchain-reis.

Hoe een blockchain te bouwen

De beste manier om iets te leren, is door te leren door te doen. Laten we eerst eens kijken naar de vereisten om er zeker van te zijn dat u zich op dezelfde pagina bevindt als ik. We zullen blockchain ook kort beschrijven zodat we allebei op dezelfde pagina staan.

Hoe een blockchain te bouwen in Python

Vereiste

De basisvereiste om de gids te volgen, is te weten hoe u moet coderen. Als je nog nooit in je leven hebt gecodeerd, dan is deze gids niets voor jou. Ik raad aan om de verschillende cursussen op beginnersniveau te bekijken die online beschikbaar zijn. Ik raad EdX, Udacity en Coursera aan voor de beste leerervaring.

Ben je al een codeur? Dan zou u moeten weten over basis Python. Het zal je ook helpen om de tutorial “Hoe bouw je een blockchain” te volgen.

Nu lezen: Quorum Blockchain Ultimate Guide


We hebben de tutorial gemaakt zodat iedereen deze kan volgen. Dus als je het niet weet en wilt leren hoe je een blockchain helemaal opnieuw opbouwt, ben je welkom om dat te doen!

Als u Python niet kent, hoeft u zich geen zorgen te maken, want het is gemakkelijk op te halen. Bekijk de Python-documentatie starten.

We gaan Python 3.6+ gebruiken voor de tutorial. Als u besluit om andere versies van Python te gebruiken, moet u wellicht meer onderzoek doen om de code te laten werken. Voor zelfstudiedoeleinden raad ik aan om de versie die ik gebruik te installeren.

Ten slotte moet u ook op de hoogte zijn van HTTP – het protocol dat wordt gebruikt om tussen twee partijen op internet te communiceren.

Python installeren met pip

U moet Python installeren met pip. Je moet ook een prachtige Requests and Flask-bibliotheek installeren. Om dit te doen, voert u gewoon de onderstaande opdracht uit.

$ pip install Flask == 0.12.2 verzoeken == 2.18.4

Als u de Windows-omgeving gebruikt, kunt u rechtstreeks naar python.org gaan om de nieuwste versie van Python te downloaden.

Wat mij betreft, ik heb de Python 3.8.1 gedownload – de nieuwste build op het moment van schrijven van de tutorial.

Voor de IDE gebruik ik liever PyCharm. Ik gebruik de Python Community-editie voor de zelfstudie. U bent vrij om elke IDE van uw keuze te gebruiken. Een ander geweldig alternatief is Visual Studio Code – een gratis, open-source geïntegreerde ontwikkelomgeving.

De laatste tool die je nodig hebt, is Postman – een HTTP-client. Als alternatief kunt u ook cURL gebruiken.

Ik raad ook aan om een ​​virtuele omgeving te installeren om een ​​heel andere omgeving voor je ontwikkeling te creëren. U kunt volgen deze gids om het correct op te zetten.

Blockchain opnieuw bezocht

Voordat we de blockchain gaan bouwen, moeten we ons idee van blockchain opfrissen. Dit zal ons helpen om op dezelfde pagina te blijven.

Blockchain is een gedistribueerde grootboektechnologie waar peers kunnen deelnemen, communiceren en transacties kunnen uitvoeren zonder dat een gecentraliseerde entiteit nodig is. Elke peer heeft een kopie van het grootboek, wat het voor hackers onmogelijk maakt om fraude in het systeem te plegen. De belangrijkste kenmerken van blockchain zijn onder meer transparantie, onveranderlijkheid en veiligheid. Het maakt gebruik van geavanceerde cryptocurrency-algoritmen om gegevensbeveiliging te garanderen. Om consensus te bereiken, gebruikt een blockchain-netwerk consensusalgoritmen zoals Proof-of-Work, Proof-of-Stake, enzovoort..

Lees ook: Blockchain voor beginners: handleiding voor beginners

Aan de slag met het bouwen van een blockchain

Nu alle vereiste installaties zijn voltooid, zijn we nu klaar om aan de slag te gaan met onze zelfstudie ‘Hoe bouw je een blockchain’.

Om te beginnen, moet u een blockchain.py-bestand maken.

1. Blockchain-creatie

De eerste stap is om een ​​functionele blockchain-oplossing te maken. In eerste instantie moeten we een Blockchain-klasse maken. Daar zullen we een constructor maken die de ketting- en transactielijst zal starten. De kettinglijst zal onze blockchain opslaan, terwijl de transacties worden opgeslagen in de current_transacations-array.

def __init __ (self): self.chain = [] self.current_transactions = []

Vervolgens moeten we een new_block-functie maken die zal worden gebruikt om nieuwe blokken te maken en deze vervolgens aan de bestaande keten toe te voegen. De code voor de functie new_block is als volgt:

def new_block (self): #Deze functie maakt nieuwe blokken en voegt vervolgens toe aan de bestaande kettingpas

De methode new_transcaction maakt een nieuwe transactie aan en voegt de transactie vervolgens toe aan de reeds bestaande transactielijst.

def new_transaction (self): #Deze functie voegt een nieuwe transactie toe aan reeds bestaande transacties pass. We hebben ook een hash-functie die wordt gebruikt om de hash voor een blok te maken. @staticmethod def hash (block): #Gebruikt voor het hashen van een blok

De laatste functie die we gaan maken last_block. Het wordt gebruikt om het laatste blok in de ketting aan te roepen.

We kunnen hier ook nog drie functies maken.

  • register_node () → Om een ​​nieuw knooppunt te registreren en toe te voegen aan het netwerk
  • valid_proof () → Zorgt ervoor dat een ingediend blok aan de ketting het probleem oplost
  • valid_chain () → Dit zal controleren of de volgende blokken in de keten geldig zijn of niet.

De blauwdruk voor de blockchain.py ziet er als volgt uit.

class Blockchain (object): def __init __ (self): self.chain = [] self.current_transactions = [] def new_block (self): #Deze functie maakt nieuwe blokken en voegt vervolgens toe aan de bestaande chain pass def new_transaction (self): #Deze functie voegt een nieuwe transactie toe aan reeds bestaande transacties pass @staticmethod def hash (block): #Gebruikt voor het hashen van een blok @property def last_block (self): # Roept en retourneert het laatste blok van de chain pass

De Blockchain-klasse beheert de hele keten. De definities die onder de klasse zijn gedefinieerd, beheren de verschillende acties binnen de blockchain.

Laten we elk van de onderstaande methoden doornemen.

Nu lezen: wat is blockchain-sharding: een inleiding tot een blockchain-schaaloplossing

Structuur van een blok

Een blok bevat essentiële informatie over transacties en ketens. Elk blok in de ketting bevat de volgende informatie

  • inhoudsopgave
  • tijdstempel in Unix-tijd
  • transacties lijst
  • bewijs
  • Vorige blok-hash

De meeste informatie in het blok spreekt voor zich. Hier zijn de twee cruciale variabelen de vorige_hash, die de hash-waarde van het vorige blok bevat. Dit is belangrijk omdat het ervoor zorgt dat de blockchain onveranderlijk is en dat geen enkele kwaadwillende actor gegevens kan bijwerken, verwijderen of toevoegen aan de ketting.

Lees nu: waarom Blockchain de wereld zal veranderen?

Transactie aan een blok toevoegen

Nu we de structuur van het blok hebben begrepen, gaan we nu kijken hoe we een transactie aan het blok kunnen toevoegen. De code ervoor is zoals hieronder.

def new_transaction (self): #Deze functie voegt een nieuwe transactie toe aan reeds bestaande transacties """Hierdoor wordt een nieuwe transactie aangemaakt die naar het volgende blok wordt gestuurd. Het bevat drie variabelen, waaronder afzender, ontvanger en bedrag """ self.current_transactions.append ({‘sender’: sender, ‘recipient’: recipient ‘amount’: amount,}) return self.last_block [‘index’] + 1 Zoals je kunt zien, voegt het simpelweg de current_transaction lijst toe met een object dat drie variabelen bevat → afzender, ontvanger, bedrag.

Zodra de toevoeging is voltooid, verzendt de methode de blokindex naar de ketting. Het is het volgende blok dat gedolven gaat worden.

Nieuwe blokken maken

Voordat we beginnen met het maken van nieuwe blokken, moeten we het genesisblok maken. Om dit te doen, hebben we een eenvoudige regel code nodig, zoals hieronder.

self.new_block (previous_hash = 1, proof = 100)

Deze regel moet worden toegevoegd aan uw Blockchain-klasse.

Voor de methode new_block () moet u twee variabelen als parameters verzenden. Het bevat bewijs en previous_hash.

Laten we nu eens kijken naar de methode new_block () hieronder.

def new_block (self, proof, previous_hash = None): #Deze functie maakt nieuwe blokken en voegt vervolgens toe aan de bestaande keten """Deze methode bevat twee parameters proof, vorige hash""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash of self.hash (self.chain [-1]),}

# Stel de huidige transactielijst in op leeg.

   self.current_transactions = [] self.chain.append (blok) retourblok

Laten we de code van het nieuwe_blok uitleggen. We maken een blokkeringslijst met de drie belangrijke parameters. Zodra ze zijn gedefinieerd, schrijven we ook de code om de current_transaction-lijst te resetten en voegen we het blok toe aan de ketting. De new_block methode, wanneer deze wordt aangeroepen, geeft het blok terug.

Nu lezen: beginnershandleiding: wat is Ethereum Classic?

Laten we hieronder ook de methode last_block definiëren.

@eigendom

def last_block (zelf):

# Roept en retourneert het laatste blok van de ketting

return self.chain [-1]

De code voor de hash () – methode is ook als volgt:

def hash (block): #Gebruikt voor het hashen van een blok """De volgende code maakt een SHA-256-blokhash en zorgt er ook voor dat het woordenboek wordt geordend""" block_string = json.dumps (block, sort_keys = True) .encode () return hashlib.sha256 (block_string) .hexdigest () Als je alle code tot nu toe combineert, hebben we de volgende blockchain.py. Bekijk het hieronder.

class Blockchain (object): def __init __ (self): self.chain = [] self.current_transactions = [] self.new_block (previous_hash = 1, proof = 100) def new_block (self, proof, previous_hash = None): #This functie maakt nieuwe blokken en voegt vervolgens toe aan de bestaande keten """Deze methode bevat twee parameters proof, vorige hash""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash of self.hash (self.chain [-1]),} # Set de huidige transactielijst leeg. self.current_transactions = [] self.chain.append (block) return block def new_transaction (self): #Deze functie voegt een nieuwe transactie toe aan reeds bestaande transacties """Hierdoor wordt een nieuwe transactie aangemaakt die naar het volgende blok wordt gestuurd. Het bevat drie variabelen, waaronder afzender, ontvanger en bedrag """ self.current_transactions.append ({‘sender’: sender, ‘recipient’: recipient, ‘amount’: amount,}) retourneer self.last_block [‘index’] + 1 @staticmethod def hash (block): #Gebruikt voor hashing een blok """De volgende code maakt een SHA-256-blokhash en zorgt er ook voor dat het woordenboek wordt geordend""" block_string = json.dumps (block, sort_keys = True) .encode () return hashlib.sha256 (block_string) .hexdigest () @property def last_block (self): # Roept en retourneert het laatste blok van de keten return self.chain [ -1]

Bewijs van uitvoering van het werk

Onze volgende stap bij het bouwen van blockchain.py is de Proof-of-Work-implementatie.

Dus, wat is Proof of Work? Het is een consensusmethode die wordt gebruikt om nieuwe blokken aan de ketting toe te voegen. Het vormt een uitdaging voor de mijnwerker en zodra de mijnwerker het probleem heeft opgelost, wordt het blok geverifieerd. De mijnwerker krijgt in ruil daarvoor een beloning op basis van de complexiteit van het probleem.

Het Proof of Work van Bitcoin staat bekend als Hashcash. Het zorgt ervoor dat de consensus van het bitcoin-netwerk werkt zoals bedoeld.

Lees ook: Consensus-algoritmen: de basis van de blockchain-technologie

Laten we de methode proof_of_work () definiëren. De methode maakt deel uit van de Blockchain-klasse.

def proof_of_work (self, last_proof): """Bij deze methode wordt het consensus-algoritme geïmplementeerd. Er zijn twee parameters nodig, waaronder self en last_proof""" proof = 0 terwijl self.valid_proof (last_proof, proof) is False: proof + = 1 return proof @staticmethod def valid_proof (last_proof, proof): """Deze methode valideert het blok""" gok = f ‘{last_proof} {bewijs}’. codeer () gok_hash = hashlib.sha256 (gok). hexigest () terug gok_hash [: 4] == "0000"

De eerste proof_of_work-methode is eenvoudig; het zet gewoon proof op 0 en voer dan een while-lus uit om de valid_proof-methode uit te voeren. Als het niet waar is, voeg er dan een toe aan het bewijs.

U kunt de moeilijkheidsgraad van de hash vergroten door meer nullen toe te voegen.

Dit leidt ons naar het einde van onze Blockchain.py. Onze code staat zoals hieronder.

class Blockchain (object): def __init __ (self): self.chain = [] self.current_transactions = [] self.new_block (previous_hash = 1, proof = 100) def proof_of_work (self, last_proof): """Bij deze methode wordt het consensus-algoritme geïmplementeerd. Er zijn twee parameters nodig, waaronder self en last_proof""" proof = 0 terwijl self.valid_proof (last_proof, proof) is False: proof + = 1 return proof @staticmethod def valid_proof (last_proof, proof): """Deze methode valideert het blok""" gok = f ‘{last_proof} {bewijs}’. codeer () gok_hash = hashlib.sha256 (gok). hexigest () terug gok_hash [: 4] == "0000" def new_block (self, proof, previous_hash = None): #Deze functie maakt nieuwe blokken en voegt vervolgens toe aan de bestaande keten """Deze methode bevat twee parameters proof, vorige hash""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash of self.hash (self.chain [-1]),} # Set de huidige transactielijst leeg. self.current_transactions = [] self.chain.append (block) return block def new_transaction (self): #Deze functie voegt een nieuwe transactie toe aan reeds bestaande transacties """Hierdoor wordt een nieuwe transactie aangemaakt die naar het volgende blok wordt gestuurd. Het bevat drie variabelen, waaronder afzender, ontvanger en bedrag """ self.current_transactions.append ({‘afzender’: afzender, ‘ontvanger’: ontvanger, ‘bedrag’: bedrag,})

retourneer self.last_block [‘index’] + 1

@staticmethod

def hash (blok):

#Gebruikt om een ​​blok te hashen

“” “De volgende code maakt een SHA-256 blokhash en zorgt er ook voor dat het woordenboek geordend is” “”

block_string = json.dumps (block, sort_keys = True) .encode ()

retourneer hashlib.sha256 (block_string) .hexdigest ()

@eigendom

def last_block (zelf):

# Roept en retourneert het laatste blok van de ketting

return self.chain [-1]

2. API-integratie

Geweldig, we maken een blockchain die werkt! Om het effectief te gebruiken, moeten we een API (Application Programming Interface) maken.

Om dit te doen, gaan we het populaire Python Framework gebruiken: Flask.

Flask is een micro-framework, wat betekent dat het lichtgewicht is, en dat u de bibliotheken kunt toevoegen die u nodig heeft. Het stelt u ook in staat om eenvoudig een Python-functie-eindpunt te maken.

Om API’s te maken, moeten we er eerst voor zorgen dat onze blockchain verzoeken via HTTP kan accepteren. Om dit te doen, moeten we meer methoden creëren.

Nu gaan we de blockchain.py aanpassen.

# De app-knoop maken app = Flask (__ name__) node_identifier = str (uuid4 ()). Replace (‘-‘, ”) # Initialiseren blockchain blockchain = Blockchain () @ app.route (‘/ mine’, methodes = [ ‘GET’]) def mine (): return "Mijnbouw van een nieuw blok" @ app.route (‘/ transacties / nieuw’, methodes = [‘POST’]) def new_transaction (): return "Een nieuwe transactie toevoegen" @ app.router (‘/ chain’, method = [‘GET’]) def full_chain (): response = {‘chain’: blockchain.chain, ‘length’: len (blockchain.chain)} return jsonify (antwoord) , 200 als __name__ == ‘__main__’: app.run (host ="0.0.0.0", poort = 5000)

De code spreekt voor het grootste deel voor zich. We doen eerst een knooppuntinitiatie. Vervolgens maken we een willekeurig knooppunt. Als we klaar zijn, initialiseren we onze Blockchain-klasse. Als u klaar bent, moeten we drie eindpunten maken, zoals hieronder.

  • / mine eindpunt
  • / transacties / nieuw eindpunt
  • / chain eindpunt

Ten slotte draaien we de server op poort 5000.

De app is nu bijna gemaakt. Het enige dat we hoeven te doen, is de transactieklasse-methode maken.

@ app.route (‘/ transaction / new’, method = [‘POST’]) def new_transaction (): values ​​= request.get_json () # Controleren of de vereiste gegevens aanwezig zijn of niet vereist = [‘afzender’, ‘ ontvanger ‘,’ bedrag ‘] indien niet alle (k in waarden voor k in vereist): retourneer’ Ontbrekende waarden ‘, 400 # een nieuwe transactie-index maken = blockchain.new_transaction (waarden [‘ afzender ‘], waarden [‘ ontvanger ‘ , values ​​[‘amount’]]) response = {‘message’: f’Transaction wordt toegevoegd aan Block No. {index} ‘} return jsonify (response), 201

Lees ook: hier is wat u moet weten over Blockchain Proof Of Work

Mijn eindpunt

Het laatste eindpunt dat we gaan maken, is het mijneindpunt. Om dit te doen, moeten we ervoor zorgen dat het de volgende drie dingen doet.

  • Bewijs van werk berekening
  • Smeed een nieuwe blockchain en voeg deze vervolgens toe aan de ketting
  • Beloon de mijnwerker voor zijn werk

@ app.route (‘/ mine’, methodes = [‘GET’]) def mine (): """Hier laten we het proof of work-algoritme werken""" last_block = blockchain.last_block last_proof = last_block [‘proof’] proof = blockchain.proof_of_work (last_proof) # beloont de mijnwerker voor zijn bijdrage. 0 geeft aan dat er een nieuwe munt is gedolven blockchain.new_transaction (sender ="0", recipient = node_identifier, amount = 1,) # maak nu het nieuwe blok aan en voeg het toe aan de ketting previous_hash = blockchain.hash (last_block) block = blockchain.new_block (proof, previous_hash) response = {‘message’: ‘The new block is vervalst ‘,’ index ‘: block [‘ index ‘],’ transacties ‘: block [‘ transacties ‘],’ proof ‘: block [‘ proof ‘],’ previous_hash ‘: block [‘ previous_hash ‘]} retourneren jsonify (antwoord), 200

Nu lezen: beginnershandleiding: wat is AION? Wereldwijd eerste blockchain-netwerk van de derde generatie

3. Blockchain-interactie

De laatste stap is om te communiceren met de blockchain. We gaan Postman gebruiken om te communiceren met het blockchain-netwerk met behulp van de API die we zojuist hebben gemaakt.

Voer de onderstaande code uit op de Python-console

python blockchain.py

Gevolgtrekking

Dit leidt ons naar het einde van onze How to build a blockchain. Ik hoop dat de bovenstaande stappen en codes je zullen helpen bij het bouwen van een Blockchain in Python. Dus als je een beginneling bent en een carrière in Blockchain wilt opbouwen, raden we je aan om je blockchain-carrière te beginnen met onze gratis Blockchain Fundamentals-cursus. Kies ons als je studiepartner en we hebben je tot je je droombaan niet krijgt.

Dus, wat vind je van blockchain en de implementatie ervan? Reageer hieronder en laat het ons weten.

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me
Like this post? Please share to your friends:
Adblock
detector
map