Povzetek prvega dela

V prvem delu smo se naučili osnov Pythona. Naučili smo se, kako if-elif-else in zanke delujejo v sistemu. V bistvu smo se naučili, kako narediti preprosto kodo na Pythonu. V tem delu bomo začeli ustvarjati našo verigo blokov. Torej, brez nadaljnjega odlašanja, začnimo!

Končni vodnik po Pythonu in Blockchainu: 2. del

Ustvarjanje naše Python Blockchain: predstavitev seznamov

V redu, dovolj z osnovami. Zdaj pa ustvarimo našo verigo blokov!

To bomo storili z uvedbo seznamov. Seznami so v bistvu skupina podatkov, ki so lahko katere koli vrste. Opredeljeni so tako:

List_name = [element 1, element 2, element 3 …… element n]

Elementi, kot smo že pojasnili, so lahko katere koli vrste podatkov. Lahko je celo število, float, niz ali celo drug seznam (ki ga bomo uporabili kasneje). Poglejmo, kako bo to delovalo. Za to bomo uporabili naš terminal:

Nekaj ​​stvari, ki jih je treba upoštevati iz zgornje kode.

Posamezne elemente seznama si predstavljajte kot bloke v verigi blokov. V resnici ni tako velik odsek, kasneje bomo to naredili bolj dodelano. Seznam sam veže vse te podatke, da dobi tisti “verižni” element verige blokov.

Zdaj boste opazili še indeksno številko vsakega elementa. Prvi element ima indeks 0. Zato, ko želimo natisniti prvi element, rečemo “blockchain [0]”.

Spreminjanje elementov seznama

Seznam, ki ga ni mogoče spremeniti, je neuporaben. Za dodajanje in odstranjevanje elementov s seznama potrebujete določbe. Zdaj vemo, da v Bitcoin podobnem blockchainu ni mogoče odstraniti elementov, vendar se še vedno ukvarjamo s seznamom.

Torej, kako bomo to storili?

Uporabili bomo dve funkciji seznama:

  • dodaj ()
  • pop ()

Funkcija dodajanja na seznam doda več elementov. Torej, vrnite naš stari seznam:

veriga blokov = [1, 2, 5.6].

Če mu želimo dodati »Blockgeeks«, bomo preprosto rekli: blockchain.append (»Blockgeeks«)

Zdaj, ko jo natisnemo, se prikaže:

[1, 2, 5.6, »Blockgeeks«]

Zdaj odstranimo nekaj podatkov.

Za to bomo uporabili funkcijo pop (), ki bo zadnji element odstranila s seznama. Torej, če naredimo blockchain.pop [], bo zdaj odstranil “Blockgeeks” in prikazal:

[1, 2, 5.6]

Dodajanje elementov med izvajanjem prek funkcij

Zdaj pa se zabavajmo.

Uporabili bomo funkcijo za dodajanje elementov na seznam med izvajanjem. Razmislite o tem programu:

veriga blokov = []

def add_list ():

   blockchain.append (3.2)

   tiskanje (veriga blokov)

add_list ()

add_list ()

add_list ()

Tako smo definirali funkcijo, imenovano “add_list ()”, ki bo dodala 3.2 na seznam verig blokov vsakič, ko jo pokličete. Ste opazili, kako smo razglasili prazen seznam z: blockchain = []? To je bilo storjeno zato, da vam lahko pokažemo, kako lahko podatke vnesete iz nič.

Torej, če jo natisnemo, bo videti tako. Spet smo spet na Visual Studio Code.

Končni vodnik po Pythonu in Blockchainu: 2. del

Dajanje seznama več lastnostim, podobnim Blockchainu

Do zdaj smo se precej ukvarjali z običajnim seznamom. Vendar pa mora obstajati bolj organska povezava med bloki.

Razlogi, zakaj so bloki povezani med seboj v resnični verigi blokov, so tudi ta, da vključujejo podatke prejšnjega bloka. Ravno to bomo storili tako, da bomo podatke zadnjega elementa dodali najnovejšemu elementu prek ugnezdenega seznama. V pythonu lahko s pomočjo indeksa [-1] dobite podatke zadnjega seznama.

Torej, če ima veriga blokov [1, 2, 3], potem vam veriga [-1] da 3.

Kakorkoli že, preverimo kodo, s funkcijo input () bomo od uporabnika dobili vrednost elementa verige blokov.

element1 = vnos ("Navedite prvi element verige blokov ")

veriga blokov = [element1]

def add_list ():

   blockchain.append ([blockchain [-1], 3.2])

   tiskanje (veriga blokov)

add_list ()

add_list ()

add_list ()

Torej, ko to natisnete, boste dobili:

Končni vodnik po Pythonu in Blockchainu: 2. del

V redu, doslej smo svoji verigi blokov dali nekaj znakov, vendar še vedno nimamo ničesar blizu svojega delujočega modela. Ne skrbite, kaj se bo kmalu rešilo.

Približevanje delujočemu blockchainu

veriga blokov = []

“” “Oddelek 1” “”

def get_last_value ():

   """ izvlečenje zadnjega elementa seznama verig blokov """

   vrnitev (veriga blokov [-1])

def add_value (znesek_ transakcije, zadnja transakcija = [1]):

   blockchain.append ([zadnja transakcija, znesek transakcije])

“” “Oddelek 2” “”

def get_transaction_value ():

   user_value = float (vnos (‘Vnesite znesek transakcije’))

   vrni user_value

def get_user_choice ():

   user_input = input ("Prosimo, izberite tukaj: ")

   vrni user_input

“” “Oddelek 3” “”

def print_block ():

   za blok v verigi blokov:

       natisni ("Tu je vaš blok")

       tiskanje (blok)

“” “Oddelek 4” “”

def verify_chain ():

   indeks = 0

   veljavno = res

   za blok v verigi blokov:

       če je indeks == 0:

           indeks + = 1

           nadaljujte

       elif block [0] == blockchain [indeks – 1]:

           veljavno = res

       sicer:

           veljavno = napačno

           odmor

       indeks + = 1

   vrnitev veljavna

“” “Oddelek 5” “”

tx_amount = get_transaction_value ()

add_value (tx_amount)

medtem ko je True:

   natisni ("Izberite možnost")

   print (‘Izberite 1 za dodajanje nove transakcije’)

   print (‘Izberite 2 za tiskanje verige blokov’)

   print (‘Izberite 3, če želite manipulirati s podatki’)

   print (‘Izberite kar koli drugega, če želite zapreti’)

   user_choice = get_user_choice ()

   

   če je izbira uporabnika == 1:

       tx_amount = get_transaction_value ()

       add_value (tx_amount, get_last_value ())

   

   elif user_choice == 2:

       print_block ()

   

   elif user_choice == 3:

       if len (blockchain) >= 1:

           veriga blokov [0] = 2

   

   sicer:

       odmor

   

   če ne, verify_chain ():

       print (‘Blockchain manipulated’)

       odmor

Ja, vemo, da je to ogromen blok kode, vendar smo celoto razdelili na različne odseke, da boste lažje razumeli, kaj se dogaja in kateri koli del kode.

Kar smo tukaj poskušali narediti, je ustvariti prototip verige blokov, ki ni odvisna od statične deklaracije. To pomeni, da lahko uporabniki sami zapolnijo podatke med izvajanjem. To je razlog, zakaj, če vidite prvo vrstico kode, boste videli, da začnemo s praznim blockchainom.

V redu, zato začnimo z raziskovanjem odsekov.

Opomba: Predlagamo, da kopirate zgornjo kodo in jo shranite v novem oknu ali datoteki z dokumenti. V spodnji razlagi se bomo še naprej sklicevali na različne dele kode in lažje boste sledili.

Oddelek 1

def get_last_value ():

   """ izvlečenje zadnjega elementa seznama verig blokov """

   vrnitev (veriga blokov [-1])

def add_value (znesek_ transakcije, zadnja transakcija = [1]):

   blockchain.append ([zadnja transakcija, znesek transakcije])

Torej, v tem prvem odseku ste že morali biti dobro podkovani. Tukaj počnemo dve stvari:

  • Izvlečenje zadnjega elementa verige blokov
  • Dodajanje zadnjega elementa skupaj s trenutnim elementom v bloku v verigo blokov.

Oglejte si argumente v funkciji add_value:

  • Zadnja transakcija
  • Znesek transakcije

Transaction_amount je vrednost transakcije, ki bo vnesena v verigo blokov. Spremenljivka last_transaction pa je vrednost transakcije v zadnjem bloku, ki bo vstavljen v novi blok.

Zakaj torej inicializiramo last_transaction v [1]?

To se naredi zgolj zato, da se izognemo napaki med izvajanjem. Pomislite na to, če imamo opravka s prvim blokom verige blokov, potem ne bo imel nobene “last_transaction” kajne? Za obstoj koncepta “last_transaction” boste potrebovali vsaj dva bloka. Zato se, da se odstrani možnost kakršne koli napake v prvem bloku, last_transaction inicializira v [1].

2. oddelek

def get_transaction_value ():

   user_value = float (vnos (‘Vnesite znesek transakcije’))

   vrni user_value

def get_user_choice ():

   user_input = input ("Prosimo, izberite tukaj: ")

   vrni user_input

Poimenujmo ta odsek vhodni odsek. Tu imamo dve funkciji:

  • get_transaction_value ()
  • get_user_choice ()

V prvi funkciji uporabnika prosimo, da vnese vrednost zneska transakcije, ki jo želi vnesti v verigo blokov. Zdaj ne pozabite, da funkcija input () vrne vrednost niza. Torej s funkcijo float () spremenimo to številko v plavajočo številko.

V drugi funkciji bomo prosili uporabnika, da vnese svojo izbiro.

Zdaj se morda sprašujete: “O kakšni izbiri govoriš?”

No, vzemite razdelek 5. Natančneje zanka while. Ali vidite možnost, ki jo tam vprašamo?

natisni ("Izberite možnost")

print (‘Izberite 1 za dodajanje nove transakcije’)

print (‘Izberite 2 za tiskanje verige blokov’)

print (‘Izberite 3, če želite manipulirati s podatki’)

print (‘Izberite kar koli drugega, če želite zapreti’)

Torej, funkcija get_user_choice () se uporablja za izbiro uporabnika, ki pomaga razumeti, kaj želi storiti.

Oddelek 3

def print_block ():

   za blok v verigi blokov:

       natisni ("Tu je vaš blok")

       tiskanje (blok)

To je zelo neposreden odsek. Z zanko for uporabljamo za tiskanje vsakega bloka verige blokov.

Oddelek 4

def verify_chain ():

   indeks = 0

   veljavno = res

   za blok v verigi blokov:

       če je indeks == 0:

           indeks + = 1

           nadaljujte

       elif block [0] == blockchain [indeks – 1]:

           veljavno = res

       sicer:

           veljavno = napačno

           odmor

       indeks + = 1

   vrnitev veljavna

Zdaj to še nismo storili.

V tem poglavju preverjamo veljavnost verige blokov. Kaj točno s tem mislimo.

Kot morda že veste, mora biti veriga blokov nespremenljiva. Ker še ne uporabljamo nobenih zgoščevalnih funkcij, uporabimo nekaj drugega, da pokažemo, da je bila veriga posežena. Zato v tej funkciji uporabljamo funkcijo verify_chain.

Torej, kaj počnemo tukaj?

Prvič, imamo dve spremenljivki:

  • Indeks = Števec, s katerim bomo šli skozi bloke v verigi blokov
  • Veljavno = logična spremenljivka, ki bo vrnila True ali False kot končno vrednost te funkcije

Po tem uporabljamo zanko for, da gremo skozi verigo blokov, podobno kot v prejšnjem razdelku, kjer smo zanko uporabili za tiskanje blokov. V zanki uporabljamo tri pogojne stavke, pojdimo skozi vsakega od njih:

Pododdelek if

S tem se preveri, ali je indeks 0 ali ne. Če je, se indeks poveča za 1

Pododdelek elif

To je del, kjer preverjamo, ali je bilo kakšno poseganje opravljeno ali ne. Če želite razumeti, kako to deluje, si predstavljajte ta scenarij.

Končni vodnik po Pythonu in Blockchainu: 2. del

Kot vidite, je prvi element bloka B vsebina prejšnjega bloka. V tem pododdelku torej preverjamo, ali je prvi element bloka enak elementom prejšnjega bloka. Če je, potem je ta funkcija True, sicer vrne False.

Oddelek 5

tx_amount = get_transaction_value ()

add_value (tx_amount)

medtem ko je True:

   natisni ("Izberite možnost")

   print (‘Izberite 1 za dodajanje nove transakcije’)

   print (‘Izberite 2 za tiskanje verige blokov’)

   print (‘Izberite 3, če želite manipulirati s podatki’)

   print (‘Izberite kar koli drugega, če želite zapreti’)

   user_choice = get_user_choice ()

   

   če je izbira uporabnika == 1:

       tx_amount = get_transaction_value ()

       add_value (tx_amount, get_last_value ())

   

   elif user_choice == 2:

       print_block ()

   

   elif user_choice == 3:

       if len (blockchain) >= 1:

           veriga blokov [0] = 2

   

   sicer:

       odmor

   

   če ne, verify_chain ():

       print (‘Blockchain manipulated’)

       Odmor

Torej, to je dolg odsek, zato ga bomo morali razdeliti na različne pododdelke (spet).

Pododdelek 1: Inicializacija

tx_amount = get_transaction_value ()

add_value (tx_amount

Začnemo z inicializacijo prvega bloka verige blokov. Dobimo vrednost zneska transakcije (tx_amount) in nato vrednost vnesemo v blok verige blokov.

Pododdelek 2: Izbira

medtem ko je True:

   natisni ("Izberite možnost")

   print (‘Izberite 1 za dodajanje nove transakcije’)

   print (‘Izberite 2 za tiskanje verige blokov’)

   print (‘Izberite 3, če želite manipulirati s podatki’)

   print (‘Izberite kar koli drugega, če želite zapreti’)

   user_choice = get_user_choice ()

Ok, pododdelek 1 naprej, vsi drugi pododdelki bodo izvedeni v tej zanki while. Torej, prva stvar, ki jo počnemo, je, da uporabnikom omogočimo, da izberejo, kaj natančno želijo:

  • Dodajte novo transakcijo
  • Natisnite verigo blokov
  • Manipulirajte s podatki
  • Zaprite postopek

Po tem user_choice shrani uporabnikove podatke

Pododdelek 3: if-elif-elif-else

Torej imamo glede na izbiro 4 možnosti. Koda je videti tako:

če je izbira uporabnika == 1:

       tx_amount = get_transaction_value ()

       add_value (tx_amount, get_last_value ())

   

   elif user_choice == 2:

       print_block ()

   

   elif user_choice == 3:

       if len (blockchain) >= 1:

           veriga blokov [0] = 2

   sicer:

       odmor

  • Najprej dodamo transakcijo v verigo blokov. Uporabniški vnos izpolnimo in shranimo v tx_amount. Ko dobimo vrednost transakcije, to dodamo skupaj z vrednostjo elementov iz zadnjega bloka v verigo blokov
  • Drugič, za tiskanje verige blokov prikličemo funkcijo tiskanja
  • Tretjič, je funkcija manipulacije. To smo vključili samo zato, da vam pokažemo, kako se bo ta veriga blokov odzvala, če bodo podatki manipulirani. Torej, tukaj se zgodi, da spremenimo prvi element verige blokov v 2. To deluje samo, če ima veriga blokov več kot 1 element (pogoj if to preveri)

    Preverite naslednji pododdelek, če želite vedeti, kaj se bo zgodilo naprej

  • Zadnji del je precej enostaven. Če uporabnik pošlje drugo možnost, se aktivira blok else, ki preprosto uporabi “break” za izhod iz zanke while

Pododdelek 4: Verifikacijski klic

če ne, verify_chain ():

       print (‘Blockchain manipulated’)

       Odmor

Če se uporabnik odloči za manipulacijo z verigo blokov, to vpliva na ta pododdelek. Zdaj ne pozabite, da verify_chain () vrne logično vrednost:

  • Prav
  • Lažno

Če je bila manipulacija izvedena, funkcija »verify_chain«) vrne False.

Zdaj ta pododdelek uporablja ne ključna beseda, ki False spremeni v True. To pa aktivira funkcijo tiskanja znotraj bloka if za tiskanje “Blockchain manipulated”.

Rezultati programa

Torej, zdaj vemo, kako deluje program. Oglejmo si izhode.

Končni vodnik po Pythonu in Blockchainu: 2. del

Torej, da gremo skozi to, kar smo storili zgoraj

V našo verigo blokov smo vnesli 3 vrednosti: 23,5, 43,1 in 5,89

Nato smo natisnili verigo blokov, ki daje to:

Končni vodnik po Pythonu in Blockchainu: 2. del

Nato smo poskušali manipulirati z našo verigo blokov s spreminjanjem podatkov, vendar je naš vgrajeni sistem za preverjanje to ujel in dal ta izhod:

Končni vodnik po Pythonu in Blockchainu: 2. del

V redu, tako da imamo do zdaj postavljeno precej dobro strukturo. Vendar moramo še vedno vključiti razprševanje in funkcije preverjanja dela za našo kodo. Ker torej že vemo, kaj so seznami, se seznanimo s tupi in slovarji.

Tuples in slovarji

Tuple in slovarji so podatkovne strukture skupaj s seznami. Primerjajmo te tri in ugotovimo, kako delujejo.

Končni vodnik po Pythonu in Blockchainu: 2. del

Tuple so precej podobne Seznamom, vendar jih po ustvarjanju ni mogoče urejati. Slovarji pa imajo v našem primeru zgoraj enostavne identifikatorje, kot sta NAME1 IN NAME2, ki shranjujejo vrednosti. Ko jih ustvarite, jih lahko urejate.

Te podatkovne strukture bomo uporabljali v našem novem in izboljšanem blockchainu.

Morda se sprašujete: “Kakšen smisel ima to početje?”

No, transakcije, bloki itd. Vsebujejo veliko metapodatkov, ki jih je treba shraniti. Pomislite na vse metapodatke, ki jih je mogoče shraniti v transakciji:

  • ID pošiljatelja
  • ID prejemnika
  • Datum transakcije
  • Znesek transakcije

Dodajanje vseh teh podatkov nam pomaga pri sledenju naših transakcij.

Dodajanje rudarskih funkcij in dokazil o delu

Torej, prva stvar, ki jo moramo storiti, je dodati funkcije rudarjenja in dokaze o delu. Rudarstvo je postopek, s katerim rudarji rešujejo kriptografsko trde uganke, da bi našli bloke, ki jih dodajo v verigo blokov. Za rudarjenje teh blokov dobijo rudarji nagrado, imenovano blokovna nagrada.

Po drugi strani pa je dokaz o delu metoda rudarjenja in soglasja, ki se uporablja v mnogih kriptovalutah, kot je Bitcoin. V našem blockchainu bomo uporabljali dokaz o delu.

Če bi povzeli, kako Proof Of Work Protocol deluje z verigo blokov.

  • Rudarji rešujejo kriptografske uganke, da “izkopljejo” blok, da ga dodajo v verigo blokov.
  • Ta postopek zahteva ogromno energije in računalniške porabe. Sestavljanke so bile zasnovane tako, da otežujejo in obremenjujejo sistem.
  • Ko rudar reši uganko, svoj blok predstavi omrežju v preverjanje.
  • Preverjanje, ali blok pripada verigi ali ne, je izjemno preprost postopek.

V redu, poglejmo si našo kodo:

“” “Oddelek 1” “”

uvozi hashlib

uvoz json

nagrada = 10,0

genesis_block = {

   ‘previous_hash’: ”,

   ‘indeks’: 0,

   ‘transakcija’: [],

   “nonce”: 23

}

blockchain = [genesis_block]

odprte transakcije = []

owner = ‘Blockgeeks’

def hash_block (blok):

   vrni hashlib.sha256 (json.dumps (blok) .encode ()). hexdigest ()

“” “Oddelek 2” “”

def valid_proof (transakcije, last_hash, nonce):

   ugibati = (str (transakcije) + str (last_hash) + str (nonce)). encode ()

   guess_hash = hashlib.sha256 (ugibati) .hexdigest ()

   natisni (ugani_haš)

   vrni ugibanje [0: 2] == ’00’

def pow ():

   last_block = veriga blokov [-1]

   last_hash = hash_block (zadnji_blok)

   nonce = 0

   čeprav ni veljaven_odporen (odprte_transakcije, last_hash, nonce):

       nonce + = 1

   vrnitev nonce

“” “Oddelek 3” “”

def get_last_value ():

   """ izvlečenje zadnjega elementa seznama verig blokov """

   vrnitev (veriga blokov [-1])

def add_value (prejemnik, pošiljatelj = lastnik, znesek = 1,0):

   transakcija = {‘pošiljatelj’: pošiljatelj,

   ‘prejemnik’: prejemnik,

   ‘znesek’: znesek}

   open_transaction.append (transakcija)

“” “Oddelek 4” “”

def mine_block ():

   last_block = veriga blokov [-1]

   hashed_block = hash_block (zadnji_blok)

   nonce = pow ()

   reward_transaction = {

           ‘sender’: ‘RUDARSTVO’,

           ‘prejemnik’: lastnik,

           ‘znesek’: nagrada

       }

   open_transactions.append (posel_nakup)

   blok = {

       ‘previous_hash’: hashed_block,

       ‘index’: len (blockchain),

       ‘transakcija’: odprte_transakcije,

       ‘nonce’: nonce

   }

   blockchain.append (blok)

“” “Oddelek 5” “”

def get_transaction_value ():

   tx_recipient = input (‘Vnesite prejemnika transakcije:’)

   tx_amount = float (vnos (‘Vnesite znesek transakcije’))

   vrni tx_recipient, tx_amount

def get_user_choice ():

   user_input = input ("Prosimo, izberite tukaj: ")

   vrni user_input

“” “Oddelek 6” “”

def print_block ():

   za blok v verigi blokov:

       natisni ("Tu je vaš blok")

       tiskanje (blok)

“” “Oddelek 7” “”

medtem ko je True:

   natisni ("Izberite možnost")

   print (‘Izberite 1 za dodajanje nove transakcije’)

   print (‘Izberite 2 za rudarjenje novega bloka’)

   print (‘Izberite 3 za tiskanje verige blokov’)

   print (‘Izberite karkoli drugega, če želite zapreti’)

   user_choice = get_user_choice ()

   

   če je izbira uporabnika == 1:

       tx_data = get_transaction_value ()

       prejemnik, znesek = tx_data

       add_value (prejemnik, znesek = znesek)

       natisni (odprt_posel)

   elif user_choice == 2:

       mine_block ()

   elif user_choice == 3:

       print_block ()

   

   sicer:

       odmor

Ok, analizirajmo kodo.

Oddelek 1

uvozi hashlib

uvoz json

nagrada = 10,0

genesis_block = {

   ‘previous_hash’: ”,

   ‘indeks’: 0,

   ‘transakcija’: [],

   “nonce”: 23

}

blockchain = [genesis_block]

odprte transakcije = []

owner = ‘Blockgeeks’

def hash_block (blok):

   vrni hashlib.sha256 (json.dumps (blok) .encode ()). hexdigest ()

Prva stvar, ki jo počnemo tukaj, je uvoz knjižnic razprševanja. Posebej uvažamo:

  • hashlib: za uporabo njihovih funkcij razprševanja
  • json: Ta paket potrebujemo za pretvorbo bloka iz slovarja v niz.

Po tem razglasimo “nagrado”, globalno spremenljivko, ki bo shranila nagrado za rudarski blok, ki jo bomo podelili našim rudarjem za rudarstvo bloka.

Naslednji imamo svoj blok geneze. Blok geneze je prvi blok v verigi blokov. V našem bloku uporabljamo 4 metapodatke:

  • Prejšnja_haš: Shrani zgoščevanje prejšnjega bloka. To bo prazen niz, saj blok geneze ne bo imel predhodnega zgoščenega znaka.
  • Kazalo: To je indeks bloka v verigi blokov. Ker je blok geneze prvi blok, se njegov indeks inicializira na 0. Ne pozabite, da je pri programski terminologiji prvi element na seznamu na 0. mestu
  • Transakcija: Transakcija, ki je shranjena znotraj verige blokov. Ker tega nima, je prazen seznam.
  • Nonce: To bomo razložili kasneje. Inicializira se na 23, kar je lažna vrednost.

Ko je blok geneze inicializiran, se doda v verigo blokov v naslednjem koraku prek blockchain = [genesis_block].

Odprte transakcije: Seznam, ki upravlja vse neporavnane transakcije v verigi blokov. Na začetku je prazen seznam.

Ker smo lastnik in pošiljatelj te transakcije, smo to že na začetku inicializirali

Naprej imamo funkcijo zgoščevanja hash_block ()

Znotraj njega vrnemo razpršitev bloka z uporabo tega izraza:

hashlib.sha256 (json.dumps (blok) .encode ()). hexdigest ()

Torej, poglejmo, kaj počnemo tukaj:

  • Uporaba hashlibovega algoritma razprševanja sha256.
  • Nato začne delovati funkcija json.dumps in pretvori blok, ki je slovar, v niz, oblikovan v json. Vendar hashlib tega ne more prebrati, zato bomo imeli naslednje ….
  • Funkcija encode (). S tem pretvorite niz v obliki zapisa json v niz UTF-8, ki ga lahko bere hashlib.
  • Izhod hashliba je bajtna hash. Tako končno uporabimo metodo hexdigest (), da jo pretvorimo v običajni niz.

2. oddelek

def valid_proof (transakcije, last_hash, nonce):

   ugibati = (str (transakcije) + str (last_hash) + str (nonce)). encode ()

   guess_hash = hashlib.sha256 (ugibati) .hexdigest ()

   natisni (ugani_haš)

   vrni ugibanje [0: 2] == ’00’

def pow ():

   last_block = veriga blokov [-1]

   last_hash = hash_block (zadnji_blok)

   nonce = 0

   čeprav ni veljaven_odporen (odprte_transakcije, last_hash, nonce):

       nonce + = 1

   vrnitev nonce

V 2. poglavju imamo dve funkciji:

  • Veljaven_odporen
  • Funkcija prahu

veljavno_odporno ()

def valid_proof (transakcije, last_hash, nonce):

   ugibati = (str (transakcije) + str (last_hash) + str (nonce)). encode ()

   guess_hash = hashlib.sha256 (ugibati) .hexdigest ()

   natisni (ugani_haš)

   vrni ugibanje [0: 2] == ’00’

Torej, funkcija valid_proof () ima tri argumente:

  • Transakcije: Transakcije znotraj bloka
  • Last hash: hash zadnjega bloka
  • Nonce

Ok, kaj točno je torej nonce? No, pred tem moramo vedeti, kaj pomeni težava. “Težavnost” je ideja, da bi kar najbolj otežili rudarstvo. Če rudarjenje ni težko, bodo vsi kovanci v sistemu enostavno črpani, zaradi česar bodo popolnoma neuporabni.

Torej, način izračunavanja zgoščene vrednosti sistema je tako, da združimo transakcije, zgoščene podatke zadnjega bloka in nonce v en niz in jih nato zgostimo. Hash je sprejemljiv le, če sta njegovi prvi črki nič.

Tako prinašamo težave. Nemogoče je predvideti, kako se bo izkazalo, da je hash in je bolj srečen žreb. Zato je izredno težko dobiti razpršitev, ki se začne s točno določenim vzorcem (na primer 2 0s).

Funkcija vrne True, če ima program veljavno zgoščeno, in False, če ne.

Funkcija pow ()

Naslednji je dokaz o delu ali funkcija pow ().

def pow ():

   last_block = veriga blokov [-1]

   last_hash = hash_block (zadnji_blok)

   nonce = 0

   čeprav ni veljaven_odporen (odprte_transakcije, last_hash, nonce):

       nonce + = 1

   vrnitev nonce

Ta funkcija je precej preprosta:

  • Najprej izvlečemo zadnji blok iz verige blokov in ga damo v last_block
  • Nato razpršimo last_block in jih postavimo v last_hash
  • Zanke while se izvajajo, dokler funkcija valid_proof ne vrne TRUE. ( ne convert bo pretvoril TRUE v FALSE in s tem prekinil zanko)
  • Nonce se nato vrne.

Oddelek 3

def get_last_value ():

   """ izvlečenje zadnjega elementa seznama verig blokov """

   vrnitev (veriga blokov [-1])

def add_value (prejemnik, pošiljatelj = lastnik, znesek = 1,0):

   transakcija = {‘pošiljatelj’: pošiljatelj,

   ‘prejemnik’: prejemnik,

   ‘znesek’: znesek}

   open_transaction.append (transakcija)

V tem poglavju imamo spet dve funkciji:

  • get_last_value
  • add_value

Get_last_value ()

Ta je precej preprost. Izvleče zadnji blok verige blokov.

dodaj_vrednost ()

Funkcija zajema metapodatke o transakciji, in sicer:

  • Ime pošiljatelja
  • Ime prejemnika
  • Znesek transakcije

Po tem je transakcija dodana na seznam odprtih transakcij.

Oddelek 4

def mine_block ():

   last_block = veriga blokov [-1]

   hashed_block = hash_block (zadnji_blok)

   nonce = pow ()

   reward_transaction = {

           ‘sender’: ‘RUDARSTVO’,

           ‘prejemnik’: lastnik,

           ‘znesek’: nagrada

       }

   open_transactions.append (posel_nakup)

   blok = {

       ‘previous_hash’: hashed_block,

       ‘index’: len (blockchain),

       ‘transakcija’: odprte_transakcije,

       ‘nonce’: nonce

   }

   blockchain.append (blok)

V tem razdelku imamo eno funkcijo, funkcijo mine_block (), ki vam bo omogočila rudarjenje blokov

Torej, v tej funkciji se bo zgodilo naslednje:

  • Izvlecite zadnji blok verige blokov in ga postavite v last_block
  • Razprši zadnji blok
  • Uporabite funkcijo pow (), da izvlečete nonce
  • Ustvarite nagradno_ transakcijo, ki nagradi rudarja, torej nas z zneskom nagrade, ki smo ga nastavili prej (10,0 kovancev)
  • Nagrada_transaction se doda na seznam open_transaction
  • Končno imamo z novim odobrenim noncem končno nov blok, ki nam pomaga pridobiti metapodatke novega bloka,
  • Novi blok je dodan verigi blokov

Oddelek 5

def get_transaction_value ():

   tx_recipient = input (‘Vnesite prejemnika transakcije:’)

   tx_amount = float (vnos (‘Vnesite znesek transakcije’))

   vrni tx_recipient, tx_amount

def get_user_choice ():

   user_input = input ("Prosimo, izberite tukaj: ")

   vrni user_input

V tem poglavju imamo dve funkciji:

  • get_transaction_value ()
  • get_user_choice ()

# 1 get_transaction_value ()

Ta funkcija zajema metapodatke o transakciji, kot sta ime prejemnika in znesek transakcije.

Hkrati si oglejte povratno izjavo.

vrni tx_recipient, tx_amount

Ta funkcija vrača tuple (prej smo se pogovarjali o tortih?)

# 2 get_user_choice

Ta funkcija v bistvu sprejme izbiro uporabnika in jo vrne. To je precej podobno funkciji get_user_choice () v prejšnjem programu.

Oddelek 6

def print_block ():

   za blok v verigi blokov:

       natisni ("Tu je vaš blok")

       tiskanje (blok)

Podobno kot pri zadnjem programu je tudi to funkcija tiskanja, ki tiska verigo blokov.

Oddelek 7

medtem ko je True:

   natisni ("Izberite možnost")

   print (‘Izberite 1 za dodajanje nove transakcije’)

   print (‘Izberite 2 za rudarjenje novega bloka’)

   print (‘Izberite 3 za tiskanje verige blokov’)

   print (‘Izberite kar koli drugega, če želite zapreti’)

   user_choice = get_user_choice ()

   

   če je izbira uporabnika == 1:

       tx_data = get_transaction_value ()

       prejemnik, znesek = tx_data

       add_value (prejemnik, znesek = znesek)

       natisni (odprte transakcije)

   elif user_choice == 2:

       mine_block ()

   elif user_choice == 3:

       print_block ()

   

   sicer:

       odmor

Tudi to je podobno kot pri zadnjem programu. Uporabnik ima na izbiro:

  • Vnesite transakcijo
  • Mine blok
  • Natisnite verigo blokov

Oglejmo si zdaj rezultate programa.

Rezultat programa

V prvi vrsti izberemo možnost 2 in izkopljemo blok. Ko to storite, dobimo naslednji blok zgoščevanja:

Končni vodnik po Pythonu in Blockchainu: 2. del

To se zdi osupljivo, dokler ne boste malo bolj pozorni in preverili zadnjega razprševanja:

“001f946e8c2172affa830ef27761270aab2de515ffac8ae90e5de95b48dc366c”

Ali vidite, kaj je tako posebnega pri tej razpršitvi?

Se spomnite težav, ki smo si jih zastavili prej? Posebej smo iskali hash, ki se je začel z “00”. To je razlog, zakaj je računalnik tekel skozi več zgoščenk tako, da je spreminjal nonce, dokler ni končno naletel na razpršitev, ki je izpolnjevala določena težavna merila.

V redu, zdaj pa dodajte transakcijo. Recimo, da želim poslati Samu 2,4 kovanca, izbrali bomo možnost 1 in dobili bomo naslednje rezultate:

Končni vodnik po Pythonu in Blockchainu: 2. del

Bodite pozorni na zadnjo vrstico. Prikazuje dve dosedanji transakciji.

Počakaj … dve transakciji? Pravkar smo naredili eno prav?

Ne čisto. Se spomnite, da smo pred tem izkopali blok, kajne? Torej je tukaj prikazana tudi blok transakcija nagrajevanja.

Na koncu natisnimo verigo blokov.

Končni vodnik po Pythonu in Blockchainu: 2. del

Tako imamo dva bloka:

  • Najprej imamo blok geneze, za katerega smo se razglasili. Nonce je bilo nekaj, kar smo si dali v sebe, tj.23
  • Nato imamo drugi blok, ki vključuje rudarsko transakcijo in transakcijo, ki smo jo sami opravili s “Samom”. Nonce bloka je 93

Zaključek

Torej, tu ste. Vsaj nekaj delava blockchain kodirano prek Pythona. Če vas zanima več, nadaljujte z lastnimi raziskavami. Menimo, da je python jezik, ki bi ga morali obvladati, če se želite razvijati. Je izredno zabaven in enostaven za učenje jezik, ki lahko odpre vrata neomejenim možnostim.

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me