Hur man bygger en blockchain i Python?

Om du vill lära dig att bygga en blockchain har du kommit till rätt ställe. Låt oss dyka djupt för att lära oss hur du kan bygga en blockchain i python.

Det finns massor av artiklar runt blockchain, men inte alla pratar om att bygga en blockchain från grunden. Som utvecklare är teorier viktiga, men du måste också skapa en blockchain för att förstå konceptet bakom det helt.

Kärnidén bakom blockchains är dess decentraliserade natur. Du kommer att bli fascinerad av hur det hela fungerar inuti. Blockchain kan låta enkelt, men inuti finns det många protokoll och algoritmer som får det att hända. Vi ska använda Python för att skapa en blockchain från grunden.

Du kan också spara artikeln och lägga till den som “Hur man bygger vår blockchain”. Tro mig; artikeln hjälper dig på lång sikt.

Har du aldrig hört talas om blockchain? Kolla sedan in 101Blockchain gratis kurs. Om du vill utveckla din karriär, kolla in Certified Enterprise Blockchain-kursen där du lär dig hur företagets blockchain fungerar. Låt oss börja.

Är du nybörjare i Blockchain? Anmäl dig till Blockchain Free Course och starta din Blockchain-resa nu.

Hur man bygger en blockchain

Det bästa sättet att lära sig någonting är att lära sig genom att göra. För att se till att du är på samma sida som jag, låt oss först kolla kraven. Vi kommer också att kort beskriva blockchain så att vi båda är på samma sida.

Hur man bygger en blockchain i Python

Krav

Grundkravet för att följa guiden är att veta hur man kodar. Om du aldrig har kodat i ditt liv är den här guiden inte för dig. Jag rekommenderar att du tittar på de olika nybörjarkurser som finns tillgängliga online. Jag rekommenderar EdX, Udacity och Coursera för den bästa inlärningsupplevelsen.

Är du redan kodare? Då bör du veta om grundläggande Python. Det hjälper dig också att följa guiden “Hur man bygger en blockchain”.

Läs nu: Quorum Blockchain Ultimate Guide


Vi skapade självstudien så att alla kan följa. Så om du inte vet och vill lära dig att bygga en blockchain från grunden är du välkommen att göra det!

Om du inte känner till Python, oroa dig inte eftersom det är lätt att hämta. Kolla in Python-dokumentation för att starta.

Vi ska använda Python 3.6+ för handledningen. Om du bestämmer dig för att använda andra versioner av Python kan du behöva göra mer forskning för att koden ska fungera. För handledning rekommenderar jag att du installerar den version som jag använder.

Slutligen bör du också veta om HTTP – protokollet som används för att kommunicera mellan två parter på internet.

Installerar Python med pip

Du måste installera Python med pip. Du måste också installera underbara Requests and Flask-bibliotek. För att göra det, kör bara kommandot nedan.

$ pip installera kolven == 0.12.2 begäranden == 2.18.4

Om du använder Windows-miljön kan du direkt gå till python.org för att ladda ner den senaste versionen av Python.

När det gäller mig laddade jag ner Python 3.8.1 – den senaste versionen när jag skrev självstudien.

För IDE föredrar jag att använda PyCharm. Jag använder Python Community-utgåvan för självstudien. Du har frihet att använda valfri IDE. Ett annat bra alternativ är Visual Studio Code – en gratis, öppen källkod integrerad utvecklingsmiljö.

Det sista verktyget du behöver är Postman – en HTTP-klient. Alternativt kan du också använda cURL.

Jag rekommenderar också att du installerar en virtuell miljö för att skapa en helt annan miljö för din utveckling. Du kan följa den här guiden för att ställa in den ordentligt.

Blockchain Revisited

Innan vi går och bygger blockchain måste vi uppdatera vår idé om blockchain. Detta hjälper oss att hålla oss på samma sida.

Blockchain är en distribuerad huvudboksteknik där kamrater kan delta, interagera och genomföra transaktioner utan behov av en central enhet. Varje kollega har en kopia av huvudboken, vilket gör det omöjligt för hackare att göra bedrägerier i systemet. De viktigaste funktionerna i blockchain inkluderar transparens, oföränderlighet och säkerhet. Den använder avancerade kryptovalutealgoritmer för att säkerställa datasäkerhet. För att nå enighet kommer ett blockchain-nätverk att använda konsensusalgoritmer som Proof-of-Work, Proof-of-Stake, och så vidare.

Läs också: Blockchain för nybörjare: Komma igång-guide

Komma igång med att bygga en blockchain

Med alla nödvändiga installationer är vi nu redo att komma igång med vår handledning, “Hur man bygger en blockchain.”

För att komma igång måste du skapa en blockchain.py-fil.

1. Blockchain Creation

Det första steget är att skapa en funktionell blockchain-lösning. Först måste vi skapa en Blockchain-klass. Där skapar vi en konstruktör som initierar kedjan och transaktionslistan. Kedjelistan lagrar vår blockchain, medan transaktionerna kommer att lagras i den nuvarande_transacations-arrayen.

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

Därefter måste vi skapa en new_block-funktion som kommer att användas för att skapa nya block och sedan lägga till dem i den befintliga kedjan. Koden för new_block-funktionen är som nedan:

def new_block (self): # Denna funktion skapar nya block och lägger sedan till det befintliga kedjepasset

Metoden new_transcaction skapar en ny transaktion och lägger sedan till transaktionen i den redan existerande transaktionslistan.

def new_transaction (self): # Denna funktion lägger till en ny transaktion till redan existerande transaktioner passerar Vi har också en hash-funktion som används för att skapa hash för ett block. @staticmethod def hash (block): # Används för att hasha ett block

Den sista funktionen som vi ska skapa last_block. Det används för att ringa det sista blocket i kedjan.

Vi kan också skapa ytterligare tre funktioner här.

  • register_node () → För att registrera en ny nod och lägga till den i nätverket
  • valid_proof () → Säkerställer att ett inlämnat block till kedjan löser problemet
  • valid_chain () → Detta kontrollerar om efterföljande block i kedjan är giltiga eller inte.

Ritningen för blockchain.py ser ut som nedan.

klass Blockchain (objekt): def __init __ (self): self.chain = [] self.current_transactions = [] def new_block (self): # Denna funktion skapar nya block och lägger sedan till det befintliga kedjepasset def new_transaction (self): #Denna funktion lägger till en ny transaktion till redan befintliga transaktioner passera @staticmethod def hash (block): # Används för att hashing ett block @property def last_block (själv): # Ringer och returnerar det sista blocket i kedjepasset

Blockchain-klassen hanterar hela kedjan. Definitionerna definierade under klassen hanterar de olika åtgärderna inom blockchain.

Låt oss gå igenom var och en av metoderna nedan.

Läs nu: Vad är blockchain sharding: En introduktion till en blockchain-skalningslösning

Struktur av ett block

Ett block innehåller viktig information om transaktioner och kedjor. Varje block i kedjan kommer att innehålla följande information

  • index
  • tidsstämpel i Unix-tid
  • transaktionslista
  • bevis
  • Tidigare block hash

Det mesta av informationen inom blocket är självförklarande. Här är de två viktiga variablerna previous_hash, som innehåller hash-värdet för det föregående blocket. Detta är viktigt eftersom det ser till att blockchain är oföränderlig och ingen skadlig aktör kan uppdatera, ta bort eller lägga till data i kedjan.

Läs nu: Varför Blockchain kommer att förändra världen?

Lägga till transaktion i ett block

Med blockets struktur förstått, låt oss nu lära oss hur man lägger till en transaktion i blocket. Koden för det är som nedan.

def new_transaction (self): # Den här funktionen lägger till en ny transaktion till redan existerande transaktioner """Detta skapar en ny transaktion som skickas till nästa block. Den innehåller tre variabler inklusive avsändare, mottagare och belopp """ self.current_transactions.append ({‘avsändare’: avsändare, ‘mottagare’: mottagare ‘belopp’: belopp,}) returnerar själv.last_block [‘index’] + 1 Som du kan se, lägger det helt enkelt till den aktuella_transaktionslistan med en objekt som innehåller tre variabler → avsändare, mottagare, belopp.

När tillägget är klart skickar metoden blockindex till kedjan. Det är nästa block som kommer att brytas.

Skapa nya block

Innan vi börjar skapa nya block måste vi skapa Genesis-blocket. För att göra det måste vi använda en enkel kodrad enligt nedan.

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

Denna rad bör läggas till i din Blockchain-klass.

För metoden new_block () måste du skicka två variabler som parametrar. Det inkluderar bevis och tidigare_hash.

Låt oss nu titta på metoden new_block () nedan.

def new_block (self, proof, previous_hash = None): # Denna funktion skapar nya block och lägger sedan till den befintliga kedjan """Denna metod innehåller två parametrar bevis, tidigare hash""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash eller self.hash (self.chain [-1]),}

# Ställ in aktuell transaktionslista till tom.

   self.current_transactions = [] self.chain.append (block) returblock

Låt oss förklara koden för new_block. Vi skapar en blocklista som innehåller de tre viktiga parametrarna. När de väl har definierats skriver vi också koden för att återställa listan med nuvarande_transaktioner och lägger sedan till blocket i kedjan. Metoden new_block, när den anropas, returnerar blocket.

Läs nu: Nybörjarguide: Vad är Ethereum Classic?

Låt oss också definiera metoden last_block nedan.

@fast egendom

def last_block (själv):

# Ringer och returnerar det sista blocket i kedjan

returnera självkedja [-1]

Koden för metoden hash () är också som nedan:

def hash (block): # Används för att hasha ett block """Följande kod skapar en SHA-256 block-hash och säkerställer också att ordlistan beställs""" block_string = json.dumps (block, sort_keys = True) .encode () return hashlib.sha256 (block_string) .hexdigest () Om du kombinerar all kod tills nu har vi följande blockchain.py. Kontrollera det nedan.

klass Blockchain (objekt): 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 funktionen skapar nya block och läggs sedan till i den befintliga kedjan """Denna metod innehåller två parametrar bevis, tidigare hash""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash or self.hash (self.chain [-1]),} # Set den aktuella transaktionslistan ska tömmas. self.current_transactions = [] self.chain.append (block) return block def new_transaction (self): #Denna funktion lägger till en ny transaktion till redan existerande transaktioner """Detta skapar en ny transaktion som skickas till nästa block. Den innehåller tre variabler inklusive avsändare, mottagare och belopp """ self.current_transactions.append ({‘avsändare’: avsändare, ‘mottagare’: mottagare, ‘belopp’: belopp,}) returnerar själv.last_block [‘index’] + 1 @staticmethod def hash (block): # Används för hashing ett block """Följande kod skapar en SHA-256 block-hash och säkerställer också att ordlistan beställs""" block_string = json.dumps (block, sort_keys = True) .encode () return hashlib.sha256 (block_string) .hexdigest () @ fastighet def last_block (själv): # Anropar och returnerar det sista blocket i kedjereturen själv. -1]

Bevis på arbetsimplementering

Vårt nästa steg i att bygga blockchain.py är Proof-of-Work-implementeringen.

Så, vad är bevis på arbete? Det är en konsensusmetod som används för att lägga till nya block i kedjan. Det utgör en utmaning för gruvarbetaren, och när gruvarbetaren löser problemet, verifieras blocket. Gruvarbetaren får i gengäld en belöning baserad på problemkomplexiteten.

Bitcoins Arbetsbevis kallas Hashcash. Det säkerställer att bitcoin-nätverkets konsensus fungerar som avsett.

Läs också: Konsensusalgoritmer: Roten till Blockchain-teknologin

Låt oss definiera proof_of_work () -metoden. Metoden kommer att ingå i Blockchain-klassen.

def proof_of_work (själv, last_proof): """Denna metod är där du konsensusalgoritmen implementeras. Det tar två parametrar inklusive själv och last_proof""" proof = 0 medan self.valid_proof (last_proof, proof) är False: proof + = 1 return proof @staticmethod def valid_proof (last_proof, proof): """Denna metod validerar blocket""" gissa = f ‘{last_proof} {proof}’. koda () gissa_hash = hashlib.sha256 (gissa) .hexigest () returnera gissa_hash [: 4] == "0000"

Den första metoden proof_of_work är enkel; det sätter helt enkelt beviset till 0 och kör sedan en stund-loop för att köra metoden valid_proof. Om det är falskt, lägg sedan till en i beviset.

Du kan öka hashens svårighet genom att lägga till fler nollor.

Detta leder oss till slutet av vår Blockchain.py. Vår kod står som nedan.

klass Blockchain (objekt): def __init __ (self): self.chain = [] self.current_transactions = [] self.new_block (previous_hash = 1, proof = 100) def proof_of_work (self, last_proof): """Denna metod är där du konsensusalgoritmen implementeras. Det tar två parametrar inklusive själv och last_proof""" proof = 0 medan self.valid_proof (last_proof, proof) är False: proof + = 1 return proof @staticmethod def valid_proof (last_proof, proof): """Denna metod validerar blocket""" gissa = f ‘{last_proof} {proof}’. koda () gissa_hash = hashlib.sha256 (gissa) .hexigest () returnera gissa_hash [: 4] == "0000" def new_block (self, proof, previous_hash = None): # Denna funktion skapar nya block och lägger sedan till den befintliga kedjan """Denna metod innehåller två parametrar bevis, tidigare hash""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash or self.hash (self.chain [-1]),} # Set den aktuella transaktionslistan ska tömmas. self.current_transactions = [] self.chain.append (block) return block def new_transaction (self): #Denna funktion lägger till en ny transaktion till redan existerande transaktioner """Detta skapar en ny transaktion som skickas till nästa block. Den innehåller tre variabler inklusive avsändare, mottagare och belopp """ self.current_transactions.append ({‘avsändare’: avsändare, ‘mottagare’: mottagare, ‘belopp’: belopp,})

returnera själv.last_block [‘index’] + 1

@staticmethod

def hash (block):

# Används för att hasha ett block

“” “Följande kod skapar en SHA-256-hash och säkerställer också att ordlistan är ordnad” “”

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

returnera hashlib.sha256 (block_string) .hexdigest ()

@fast egendom

def last_block (själv):

# Ringer och returnerar kedjans sista block

returnera självkedja [-1]

2. API-integration

Bra, vi skapar en blockchain som fungerar! För att kunna använda det effektivt måste vi skapa ett API (Application Programming Interface).

För att göra det ska vi använda det populära Python Framework: Flask.

Flaskan är ett mikroramverk, vilket innebär att den är lätt och du kan lägga till de bibliotek du behöver. Det gör det också möjligt för dig att enkelt skapa Python-funktionens slutpunkt.

För att skapa API: er måste vi först se till att vår blockchain kan acceptera förfrågningar via HTTP. För att göra det måste vi skapa fler metoder.

Nu kommer vi att ändra blockchain.py.

# Skapa app-nod-appen = Flaska (__ name__) node_identifier = str (uuid4 ()). Ersätt (‘-‘, ”) # Initiera blockchain blockchain = Blockchain () @ app.route (‘/ mine’, metoder = [ ‘GET’]) def mine (): return "Bryta ett nytt block" @ app.route (‘/ transaktioner / ny’, metoder = [‘POST’]) def new_transaction (): return "Lägger till en ny transaktion" @ app.router (‘/ chain’, methods = [‘GET’]) def full_chain (): response = {‘chain’: blockchain.chain, ‘length’: len (blockchain.chain)} returnera jsonify (svar) , 200 om __name__ == ‘__main__’: app.run (host ="0.0.0.0", port = 5000)

Koden är självförklarande för det mesta. Vi gör först en nodinitiering. Därefter skapar vi en slumpmässig nod. När du är klar initierar vi sedan vår Blockchain-klass. När du är klar måste vi skapa tre slutpunkter enligt nedan.

  • / min slutpunkt
  • / transaktioner / ny slutpunkt
  • / kedjans slutpunkt

Slutligen kör vi servern på 5000-port.

Appen är nu nästan skapad. Allt vi behöver göra är att skapa transaktionsklassmetoden.

@ app.route (‘/ transaktioner / ny’, metoder = [‘POST’]) def new_transaction (): värden = begäran.get_json () # Kontrollerar om nödvändig data finns eller inte krävs = [‘avsändare’, ‘ mottagare ‘,’ belopp ‘] om inte alla (k i värden för k i krävs): returnera’ Saknade värden ‘, 400 # skapa ett nytt transaktionsindex = blockchain.new_transaction (värden [‘ avsändare ‘], värden [‘ mottagare ‘ , värden [‘mängd’]]) svar = {‘meddelande’: f’Transaktion är planerad att läggas till i blocknummer. {index} ‘} returnera jsonify (svar), 201

Läs också: Här är vad du behöver veta om Blockchain-bevis på arbete

Mining Endpoint

Den sista slutpunkten som vi ska skapa är gruvans slutpunkt. För att göra det måste vi se till att det gör följande tre saker.

  • Proof of Work-beräkning
  • Skapa ny blockchain och lägg sedan till den i kedjan
  • Belöna gruvarbetaren för hans arbete

@ app.route (‘/ mine’, methods = [‘GET’]) def mine (): """Här får vi bevis på att arbetsalgoritmen fungerar""" last_block = blockchain.last_block last_proof = last_block [‘proof’] proof = blockchain.proof_of_work (last_proof) # belönar gruvarbetaren för hans bidrag. 0 anger att nytt mynt har bryts blockchain.new_transaction (avsändare ="0", mottagare = node_identifier, mängd = 1,) # skapa nu det nya blocket och lägg till det i kedjan previous_hash = blockchain.hash (last_block) block = blockchain.new_block (proof, previous_hash) response = {‘message’: ‘Det nya blocket har förfalskats ‘,’ index ‘: block [‘ index ‘],’ transaktioner ‘: block [‘ transaktioner ‘],’ proof ‘: block [‘ proof ‘],’ previous_hash ‘: block [‘ previous_hash ‘]} retur jsonify (svar), 200

Läs nu: Nybörjarguide: Vad är AION? Världens första tredje generationens blockchain-nätverk

3. Blockchain-interaktion

Det sista steget är att interagera med blockchain. Vi ska använda Postman för att interagera med blockchain-nätverket med det API vi just skapade.

Kör koden nedan på Python Console

python blockchain.py

Slutsats

Detta leder oss till slutet av hur vi bygger en blockchain. Hoppas att stegen och koderna ovan hjälper dig att bygga en Blockchain i Python. Så om du är nybörjare och strävar efter att bygga en karriär inom Blockchain föreslår vi att du börjar din blockchain-karriär med vår gratis Blockchain Fundamentals-kurs. Välj oss som din studiepartner så får vi dig tills du inte får ditt drömjobb.

Så, vad tycker du om blockchain och dess implementering? Kommentera nedan och låt oss veta.

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