Kako zgraditi verigo blokov v Pythonu?

Če se želite naučiti, kako zgraditi verigo blokov, ste prišli na pravo mesto. Potopimo se globoko, če želite izvedeti, kako lahko v pythonu zgradite verigo blokov.

Okoli verige blokov je veliko člankov, vendar vsi ne govorijo o gradnji verige blokov iz nič. Kot razvijalec so teorije pomembne, vendar morate ustvariti tudi verigo blokov, da boste v celoti razumeli koncept, ki stoji za tem.

Glavna ideja blockchain-ov je njegova decentralizirana narava. Fasciniralo vas bo dejstvo, kako vse to deluje znotraj. Blockchain se morda sliši preprosto, toda znotraj je veliko protokolov in algoritmov, ki to omogočajo. Python bomo uporabili za ustvarjanje verige blokov iz nič.

Članek lahko tudi shranite in ga dodate med zaznamke: »Kako zgraditi našo verigo blokov«. Verjemi mi; članek vam bo dolgoročno pomagal.

Še nikoli niste slišali za blockchain? Nato si oglejte brezplačni tečaj 101Blockchain. Če želite napredovati v svoji karieri, si oglejte tečaj Certified Enterprise Blockchain, kjer boste izvedeli, kako deluje blockchain podjetja. Začnimo.

Ste začetnik v Blockchainu? Vpišite se na brezplačni tečaj Blockchain in začnite svoje potovanje po Blockchainu zdaj.

Kako zgraditi verigo blokov

Najboljši način, da se česar koli naučite, je, da se učite s tem. Da se prepričate, da ste na isti strani kot jaz, najprej preverimo zahteve. Na kratko bomo tudi opisali verigo blokov, tako da bomo oba na isti strani.

Zahteva

Osnovna zahteva za vodenje je vedeti, kako kodirati. Če v življenju še niste kodirali, potem ta vodnik ni za vas. Priporočam, da si ogledate različne tečaje za začetnike, ki so na voljo na spletu. Za najboljšo učno izkušnjo priporočam EdX, Udacity in Coursera.

Si že programer? Potem bi morali vedeti o osnovnem Pythonu. Prav tako vam bo pomagal slediti vadnici “Kako zgraditi blokchain”.

Preberite zdaj: Končni vodnik Quorum Blockchain

Vadnico smo ustvarili tako, da jo lahko spremlja vsak. Torej, če ne veste in se želite naučiti, kako zgraditi verigo blokov iz nič, lahko to storite!

 Če Pythona ne poznate, ne skrbite, saj ga je enostavno pobrati. Oglejte si Python dokumentacija za začetek.

Za vadnico bomo uporabili Python 3.6+. Če se odločite za uporabo drugih različic Pythona, boste morda morali opraviti več raziskav, da bo koda delovala. Za vadnice priporočam namestitev različice, ki jo uporabljam.

Na koncu bi morali vedeti tudi HTTP – protokol, ki se uporablja za komunikacijo med obema stranema v internetu.

Namestitev Pythona z uporabo pipa

Python morate namestiti s pomočjo pipa. Namestiti morate tudi čudovito knjižnico Requests in Flask. Če želite to narediti, preprosto zaženite spodnji ukaz.

$ pip install Flask == 0.12.2 zahteve == 2.18.4

Če uporabljate okolje Windows, lahko neposredno pojdite na python.org in prenesete najnovejšo različico Pythona.

Jaz sem prenesel Python 3.8.1 – najnovejšo različico v času pisanja vadnice.

Za IDE raje uporabljam PyCharm. Za vadnico uporabljam izdajo skupnosti Python. Lahko uporabljate kateri koli IDE po svoji izbiri. Druga odlična alternativa je Visual Studio Code – brezplačno odprtokodno integrirano razvojno okolje.

Zadnje orodje, ki ga boste potrebovali, je Postman – odjemalec HTTP. Lahko pa uporabite tudi curl.

Priporočam tudi namestitev navideznega okolja, da ustvarite povsem drugačno okolje za svoj razvoj. Lahko sledite ta vodnik da ga pravilno nastavite.

Blockchain ponovno

Preden začnemo graditi verigo blokov, moramo osvežiti svojo idejo o verigi blokov. To nam bo pomagalo ostati na isti strani.

Blockchain je tehnologija porazdeljene knjige, pri kateri lahko vrstniki sodelujejo, sodelujejo in izvajajo transakcije brez potrebe po centralizirani entiteti. Vsak vrstnik ima kopijo knjige, zaradi česar hekerji ne morejo storiti goljufije v sistemu. Ključne značilnosti verige blokov vključujejo preglednost, nespremenljivost in varnost. Za zagotavljanje varnosti podatkov uporablja napredne algoritme kriptovalut. Za doseganje konsenza bo mreža verig blokov uporabljala soglasne algoritme, kot so Proof-of-Work, Proof-of-Stake itd..

Preberite tudi: Blockchain za začetnike: Vodnik za začetek

Začetek gradnje verige blokov

Z vsemi potrebnimi namestitvami smo zdaj pripravljeni začeti z našo vadnico »Kako zgraditi verigo blokov«.

Za začetek morate ustvariti datoteko blockchain.py.

1. Ustvarjanje verige blokov

Prvi korak je izdelati funkcionalno blockchain rešitev. Sprva moramo ustvariti razred Blockchain. Tam bomo ustvarili konstruktor, ki bo sprožil verigo in seznam transakcij. Seznam verig bo shranil naš blockchain, medtem ko bodo transakcije shranjene v matriki current_transacations.

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

Nato moramo ustvariti funkcijo new_block, ki bo uporabljena za ustvarjanje novih blokov in jih nato dodati v obstoječo verigo. Koda funkcije new_block je kot spodaj:

def new_block (self): # Ta funkcija ustvari nove bloke in nato doda obstoječi verižni prehod

Metoda new_transcaction bo ustvarila novo transakcijo in jo nato dodala na obstoječi seznam transakcij.

def new_transaction (self): # Ta funkcija doda novo transakcijo že obstoječim prehodom transakcij. Na voljo imamo tudi zgoščevalno funkcijo, ki se uporablja za ustvarjanje razprševanja bloka. @staticmethod def hash (block): # Uporablja se za zgoščevanje bloka

Zadnja funkcija, ki jo bomo ustvarili last_block. Uporablja se za klic zadnjega bloka v verigi.

Tu lahko ustvarimo tudi še tri funkcije.

  • register_node () → Če želite registrirati novo vozlišče in ga dodati v omrežje
  • valid_proof () → Zagotovil bo, kdaj težavo reši oddani blok v verigi
  • valid_chain () → S tem se preveri, ali so naslednji bloki v verigi veljavni ali ne.

Načrt za blockchain.py je videti spodaj.

razred Blockchain (objekt): def __init __ (self): self.chain = [] self.current_transactions = [] def new_block (self): # Ta funkcija ustvari nove bloke in nato doda obstoječi verižni podaji def new_transaction (self): #Ta funkcija doda novo transakcijo že obstoječim podajam transakcij @staticmethod def hash (blok): #Uporablja se za zgoščevanje bloka @property def last_block (self): # Kliče in vrne zadnji blok verižnega prehoda

Razred Blockchain upravlja celotno verigo. Definicije, opredeljene v razredu, upravljajo različna dejanja znotraj verige blokov.

Oglejmo si vsako od spodnjih metod.

Preberite zdaj: Kaj je blockchain shading: Uvod v rešitev za skaliranje blockchain

Zgradba bloka

Blok vsebuje ključne informacije o transakcijah in verigah. Vsak blok na verigi bo vseboval naslednje informacije

  • indeks
  • časovni žig v času Unixa
  • seznam transakcij
  • dokaz
  • Hash prejšnjega bloka

Večina informacij znotraj bloka je samoumevnih. Tu sta dve ključni spremenljivki previous_hash, ki vsebuje zgoščeno vrednost prejšnjega bloka. To je pomembno, saj zagotavlja, da je veriga blokov nespremenljiva in noben zlonamerni akter ne more posodobiti, izbrisati ali dodati nobenih podatkov v verigo.

Preberite zdaj: Zakaj bo Blockchain spremenil svet?

Dodajanje transakcije bloku

Z razumevanjem strukture bloka se naučimo, kako bloku dodamo transakcijo. Koda zanj je kot spodaj.

def new_transaction (self): # Ta funkcija doda novo transakcijo že obstoječim transakcijam """To bo ustvarilo novo transakcijo, ki bo poslana v naslednji blok. Vseboval bo tri spremenljivke, vključno s pošiljateljem, prejemnikom in zneskom """ self.current_transactions.append ({‘pošiljatelj’: pošiljatelj, ‘prejemnik’: prejemnik ‘znesek’: znesek,}) return self.last_block [‘indeks’] + 1 Kot vidite, preprosto prikaže seznam trenutnih_transakcij z predmet, ki vsebuje tri spremenljivke → pošiljatelj, prejemnik, znesek.

Ko je dodajanje končano, metoda nato v verigo pošlje indeks blokov. To je naslednji blok, ki bo izkopan.

Ustvarjanje novih blokov

Preden začnemo ustvarjati nove bloke, moramo ustvariti blok geneze. Za to moramo uporabiti preprosto vrstico kode, kot je prikazano spodaj.

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

To vrstico je treba dodati v razred Blockchain.

Za metodo new_block () morate kot parametra poslati dve spremenljivki. Vključuje dokaz in previous_hash.

Zdaj pa si oglejmo metodo new_block () spodaj.

def new_block (self, proof, previous_hash = None): # Ta funkcija ustvari nove bloke in nato doda obstoječi verigi """Ta metoda bo vsebovala dokaz dveh parametrov, predhodno zgoščeno""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash ali self.hash (self.chain [-1]),}

# Trenutni seznam transakcij nastavite na prazen.

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

Pojasnimo kodo bloka new_block. Ustvarimo seznam blokov, ki vsebuje tri pomembne parametre. Ko so definirani, nato tudi napišemo kodo, da ponastavimo seznam trenutnih transakcij in nato dodamo blok v verigo. Ko je metoda new_block vrnjena, vrne blok.

Preberite zdaj: Priročnik za začetnike: Kaj je Ethereum Classic?

V nadaljevanju določimo tudi metodo last_block.

@property

def last_block (samo):

# Pokliče in vrne zadnji blok verige

vrni self.chain [-1]

Koda metode hash () je tudi spodaj:

 

def hash (block): # Uporablja se za zgoščevanje bloka """Koda za sledenje bo ustvarila hash bloka SHA-256 in zagotovila tudi urejenost slovarja""" block_string = json.dumps (block, sort_keys = True) .encode () return hashlib.sha256 (block_string) .hexdigest () Če do zdaj združite vso kodo, bomo imeli naslednji blockchain.py. Preverite spodaj.

 

class 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 funkcija ustvari nove bloke in nato doda obstoječi verigi """Ta metoda bo vsebovala dva parametra, predhodno zgoščeno""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash ali self.hash (self.chain [-1]),} # Set trenutni seznam transakcij izpraznite. self.current_transaction = [] self.chain.append (block) return block def new_transaction (self): # Ta funkcija doda novo transakcijo že obstoječim transakcijam """To bo ustvarilo novo transakcijo, ki bo poslana v naslednji blok. Vseboval bo tri spremenljivke, vključno s pošiljateljem, prejemnikom in zneskom """ self.current_transactions.append ({‘pošiljatelj’: pošiljatelj, ‘prejemnik’: prejemnik, ‘znesek’: znesek,}) return self.last_block [‘indeks’] + 1 @staticmethod def hash (block): #Uporablja se za zgoščevanje blok """Koda za sledenje bo ustvarila hash bloka SHA-256 in zagotovila tudi urejenost slovarja""" block_string = json.dumps (block, sort_keys = True) .encode () return hashlib.sha256 (block_string) .hexdigest () @property def last_block (self): # Pokliče in vrne zadnji blok verige return self.chain [ -1]

Dokazilo o izvajanju dela

Naš naslednji korak pri gradnji blockchain.py je implementacija Proof-of-Work.

Torej, kaj je dokaz o delu? To je metoda soglasja, ki se uporablja za dodajanje novih blokov v verigo. Rudarju predstavlja izziv in ko rudar reši težavo, se blok nato preveri. Rudar v zameno dobi nagrado glede na zapletenost problema.

Bitcoinov dokaz o delu je znan kot Hashcash. Zagotavlja, da soglasje Bitcoin omrežja deluje, kot je bilo predvideno.

Preberite tudi: Algoritmi soglasja: Koren tehnologije Blockchain

Določimo metodo proof_of_work (). Metoda bo del razreda Blockchain.

def proof_of_work (self, last_proof): """Na tej metodi je implementiran algoritem soglasja. Potrebna sta dva parametra, vključno z lastnostjo in last_proof""" proof = 0, medtem ko je self.valid_proof (last_proof, proof) False: proof + = 1 return proof @staticmethod def valid_proof (last_proof, proof): """Ta metoda potrdi blok""" ugibati = f ‘{last_proof} {dokaz}’. encode () guess_hash = hashlib.sha256 (ugibati) .hexigest () vrniti ugibati_hash [: 4] == "0000"

Prva metoda proof_of_work je preprosta; preprosto nastavi dokaz na 0 in nato zažene zanko while za zagon metode valid_proof. Če je napačno, ga dodajte v dokaz.

Težavnost zgoščevanja lahko povečate tako, da dodate več ničel.

To nas vodi do konca našega Blockchain.py. Naša koda stoji spodaj.

razred Blockchain (objekt): def __init __ (self): self.chain = [] self.current_transactions = [] self.new_block (previous_hash = 1, proof = 100) def proof_of_work (self, last_ last) """Na tej metodi je implementiran algoritem soglasja. Potrebna sta dva parametra, vključno z lastnostjo in last_proof""" proof = 0, medtem ko je self.valid_proof (last_proof, proof) False: proof + = 1 return proof @staticmethod def valid_proof (last_proof, proof): """Ta metoda potrdi blok""" ugibati = f ‘{last_proof} {dokaz}’. encode () guess_hash = hashlib.sha256 (ugibati) .hexigest () vrniti ugibati_hash [: 4] == "0000" def new_block (self, proof, previous_hash = None): # Ta funkcija ustvari nove bloke in nato doda obstoječi verigi """Ta metoda bo vsebovala dva parametra, predhodno zgoščeno""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash ali self.hash (self.chain [-1]),} # Set trenutni seznam transakcij izpraznite. self.current_transaction = [] self.chain.append (block) return block def new_transaction (self): # Ta funkcija doda novo transakcijo že obstoječim transakcijam """To bo ustvarilo novo transakcijo, ki bo poslana v naslednji blok. Vseboval bo tri spremenljivke, vključno s pošiljateljem, prejemnikom in zneskom """ self.current_transactions.append ({‘pošiljatelj’: pošiljatelj, ‘prejemnik’: prejemnik, ‘znesek’: znesek,})

 

vrni self.last_block [‘indeks’] + 1

@staticmethod

def hash (blok):

#Uporablja se za zgoščevanje bloka

“” ”Naslednja koda bo ustvarila razpršitev bloka SHA-256 in zagotovila tudi urejenost slovarja” ”

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

vrni hashlib.sha256 (niz_blokov) .hexdigest ()

@property

def last_block (samo):

# Pokliče in vrne zadnji blok verige

vrni self.chain [-1]

2. Integracija API-ja

Odlično, ustvarili smo verigo blokov, ki deluje! Za učinkovito uporabo moramo zdaj ustvariti API (Application Programming Interface).

Za to bomo uporabili priljubljeni Python Framework: Flask.

Bučka je mikrookvir, kar pomeni, da je lahka in lahko dodate knjižnice, ki jih potrebujete. Omogoča tudi enostavno ustvarjanje končne točke funkcije Python.

Če želite ustvariti API-je, moramo najprej zagotoviti, da lahko naša veriga blokov sprejema zahteve prek HTTP-ja. Za to moramo ustvariti več metod.

Zdaj bomo spremenili blockchain.py.

# Ustvarjanje vozlišča aplikacije app = Flask (__ name__) node_identifier = str (uuid4 ()). Replace (‘-‘, ”) # Inicializacija blockchain blockchain = Blockchain () @ app.route (‘/ mine’, methods = [ ‘GET’]) def mine (): return "Pridobivanje novega bloka" @ app.route (‘/ transakcije / novo’, metode = [‘POST’]) def new_transaction (): return "Dodajanje nove transakcije" @ app.router (‘/ chain’, methods = [‘GET’]) def full_chain (): response = {‘chain’: blockchain.chain, ‘length’: len (blockchain.chain)} return jsonify (response) , 200 če je __name__ == ‘__main__’: app.run (gostitelj ="0,0,0,0", pristanišče = 5000)

Koda je večinoma samoumevna. Najprej izvedemo iniciranje vozlišča. Nato ustvarimo naključno vozlišče. Ko končamo, nato inicializiramo svoj razred Blockchain. Ko končamo, moramo ustvariti tri končne točke, kot je prikazano spodaj.

  • / moja končna točka
  • / transakcije / nova končna točka
  • / končna točka verige

Končno zaženemo strežnik na 5000 vratih.

Aplikacija je zdaj že skoraj ustvarjena. Vse, kar moramo storiti, je ustvariti metodo razreda transakcij.

@ app.route (‘/ transakcije / novo’, metode = [‘POST’]) def new_transaction (): values ​​= request.get_json () # Preverjanje, ali so tam zahtevani podatki ali niso potrebni = [‘pošiljatelj’, ‘ prejemnik ‘,’ znesek ‘], če ne vsi (k v vrednostih za k v zahtevanih vrednostih): vrne’ Manjkajoče vrednosti ‘, 400 # ustvarjanje novega indeksa transakcije = blockchain.new_transaction (vrednosti [‘ pošiljatelj ‘], vrednosti [‘ prejemnik ‘ , vrednosti [‘znesek’]]) response = {‘message’: f’Transaction je predvideno za dodajanje bloka št. {index} ‘} return jsonify (response), 201

Preberite tudi: Tukaj je tisto, kar morate vedeti o Blockchain Dokazilu o delu

Rudarska končna točka

Zadnja končna točka, ki jo bomo ustvarili, je rudarska končna točka. Če želite to narediti, se moramo prepričati, da naredi naslednje tri stvari.

  • Dokazilo o izračunu dela
  • Kovati novo verigo blokov in jo nato dodati v verigo
  • Nagradite rudarja za njegovo delo

@ app.route (‘/ mine’, metode = [‘GET’]) def mine (): """Tu naredimo dokaz o delovanju algoritma""" last_block = blockchain.last_block last_proof = last_block [‘proof’] proof = blockchain.proof_of_work (last_proof) # nagrajuje rudarja za njegov prispevek. 0 določa, da je bil izkopan nov kovanec blockchain.new_transaction (sender ="0", prejemnik = identifikator vozlišča, količina = 1,) # zdaj ustvarite nov blok in ga dodajte v verigo previous_hash = blockchain.hash (last_block) block = blockchain.new_block (proof, previous_hash) response = {‘message’: ‘Novi blok je bilo ponarejeno ‘,’ indeks ‘: blok [‘ indeks ‘],’ transakcije ‘: blok [‘ transakcije ‘],’ dokaz ‘: blok [‘ dokaz ‘],’ prejšnji_haš ‘: blok [‘ prejšnji_haš ‘]} vrniti jsonify (odgovor), 200

Preberite zdaj: Priročnik za začetnike: Kaj je AION? Prva svetovna mreža blokovnih verig tretje generacije

3. Blockchain interakcija

Zadnji korak je interakcija z verigo blokov. Postman bomo uporabili za interakcijo z blockchain omrežjem z API-jem, ki smo ga pravkar ustvarili.

Zaženite spodnjo kodo na konzoli Python

python blockchain.py

Zaključek

To nas vodi do konca našega Kako zgraditi verigo blokov. Upam, da vam bodo zgornji koraki in kode pomagali zgraditi Blockchain v Pythonu. Torej, če ste novinec in si želite ustvariti kariero v Blockchainu, vam predlagamo, da začnete svojo blockchain kariero z našim brezplačnim tečajem Blockchain Fundamentals. Izberite nas za svojega študijskega partnerja in imeli vas bomo, dokler ne boste dobili sanjske službe.

Torej, kaj menite o blockchainu in njegovi izvedbi? Komentirajte spodaj in nam sporočite.

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