Si voleu aprendre a construir una cadena de blocs, heu arribat al lloc adequat. Anem a bussejar a fons per aprendre com es pot construir una cadena de blocs a Python.
Hi ha un munt d’articles al voltant de blockchain, però no tots parlen de construir una blockchain des de zero. Com a desenvolupador, les teories són importants, però també heu de crear una cadena de blocs per entendre el concepte que hi ha darrere.
La idea bàsica darrere de les cadenes de blocs és la seva naturalesa descentralitzada. Us fascinarà el fet de com funciona tot dins. Blockchain pot semblar senzill, però a l’interior hi ha molts protocols i algorismes que fan que això passi. Utilitzarem Python per crear una cadena de blocs des de zero.
També podeu desar l’article i afegir-lo a les adreces d’interès com a “Com es construeix la nostra cadena de blocs”. Creu-me; l’article us ajudarà a la llarga.
No heu sentit a parlar mai de blockchain? A continuació, consulteu el curs gratuït de 101Blockchain. Si voleu avançar en la vostra carrera professional, consulteu el Certified Enterprise Blockchain Course on apreneu com funciona el blockchain empresarial. Comencem.
Ets un principiant a Blockchain? Inscriviu-vos al curs gratuït Blockchain i comenceu ara el vostre viatge Blockchain.
Com construir una cadena de blocs
La millor manera d’aprendre qualsevol cosa és aprendre fent. Per assegurar-vos que sou a la mateixa pàgina que jo, primer comprovem els requisits. També descriurem breument blockchain perquè tots dos estiguem a la mateixa pàgina.
Requisit
El requisit bàsic per seguir la guia és saber codificar. Si mai no heu codificat a la vostra vida, aquesta guia no és adequada per a vosaltres. Recomano consultar els diversos cursos de nivell per a principiants disponibles en línia. Recomano EdX, Udacity i Coursera per obtenir la millor experiència d’aprenentatge.
Ja sou codificador? A continuació, heu de saber sobre Python bàsic. A més, us ajudarà a seguir el tutorial “Com construir una cadena de blocs”.
Llegiu ara: Quorum Blockchain Ultimate Guide
Hem creat el tutorial perquè tothom el pugui seguir. Per tant, si no ho sabeu i voleu aprendre a construir una cadena de blocs des de zero, podeu fer-ho!
Si no coneixeu Python, no us preocupeu, ja que és fàcil recollir-lo. Consulteu el Documentació de Python per començar.
Utilitzarem Python 3.6+ per al tutorial. Si decidiu utilitzar altres versions de Python, és possible que hàgiu de fer més investigacions perquè el codi funcioni. A propòsit de tutorial, recomano instal·lar la versió que estic fent servir.
Per últim, també heu de saber sobre HTTP: el protocol que s’utilitza per comunicar-se entre dues parts a Internet.
Instal·lació de Python mitjançant pip
Cal instal·lar Python mitjançant pip. També heu d’instal·lar una meravellosa biblioteca de sol·licituds i Flask. Per fer-ho, simplement executeu l’ordre següent.
$ pip install Flask == 0.12.2 sol·licituds == 2.18.4
Si utilitzeu l’entorn Windows, podeu anar directament a python.org per descarregar la versió més recent de Python.
Pel que fa a mi, he descarregat Python 3.8.1, la versió més recent en el moment d’escriure el tutorial.
Per a l’IDE, prefereixo utilitzar PyCharm. Estic fent servir l’edició Python Community per al tutorial. Podeu utilitzar qualsevol IDE que vulgueu. Una altra gran alternativa és Visual Studio Code, un entorn de desenvolupament integrat de codi obert gratuït.
L’última eina que necessiteu és Postman, un client HTTP. Com a alternativa, també podeu utilitzar cURL.
També recomano instal·lar un entorn virtual per crear un entorn completament diferent per al vostre desenvolupament. Pots seguir aquesta guia per configurar-lo correctament.
Blockchain revisat
Abans d’anar a construir el blockchain, hem d’actualitzar la nostra idea de blockchain. Això ens ajudarà a mantenir-nos a la mateixa pàgina.
Blockchain és una tecnologia de llibre major distribuïda on els companys poden participar, interactuar i executar transaccions sense la necessitat d’una entitat centralitzada. Cada parell té una còpia del llibre major, cosa que fa impossible que els pirates informàtics puguin fer fraus al sistema. Les funcions clau de blockchain inclouen transparència, immutabilitat i seguretat. Utilitza algoritmes avançats de criptomoneda per garantir la seguretat de les dades. A més, per arribar al consens, una xarxa de cadenes de blocs utilitzarà algoritmes de consens, com ara Prova de treball, Prova d’estaca, etc..
Llegiu també: Blockchain per a principiants: Guia d’introducció
Introducció a la creació d’un blockchain
Amb totes les instal·lacions prerequisides realitzades, ara estem preparats per començar amb el nostre tutorial “Com construir una cadena de blocs”.
Per començar, heu de crear un fitxer blockchain.py.
1. Creació de blockchain
El primer pas és fer una solució funcional de blockchain. Al principi, hem de crear una classe Blockchain. Allà crearem un constructor que iniciarà la llista de transaccions i cadena. La llista de cadenes emmagatzemarà la nostra cadena de blocs, mentre que les transaccions s’emmagatzemaran a la matriu current_transacations.
def __init __ (self): self.chain = [] self.current_transactions = []
A continuació, hem de crear una funció new_block que s’utilitzarà per crear blocs nous i, a continuació, afegir-los a la cadena existent. El codi per a la funció new_block és el següent:
def new_block (self): # Aquesta funció crea blocs nous i després s’afegeix al pas de cadena existent
El mètode new_transcaction crearà una transacció nova i, a continuació, afegirà la transacció a la llista de transaccions ja existent.
def new_transaction (self): #Aquesta funció afegeix una nova transacció a la passada de transaccions ja existents També tenim una funció de hash que s’utilitza per crear el hash d’un bloc. @staticmethod def hash (bloc): #S’utilitza per hash d’un bloc
La darrera funció que crearem last_block. S’utilitza per trucar a l’últim bloc de la cadena.
Aquí també podem crear tres funcions més.
- register_node () → Per registrar un nou node i afegir-lo a la xarxa
- valid_proof () → Assegurarà que si un bloc enviat a la cadena resol el problema
- valid_chain () → Això comprovarà si els blocs posteriors de la cadena són vàlids o no.
El plànol de blockchain.py és el següent.
class Blockchain (object): def __init __ (self): self.chain = [] self.current_transactions = [] def new_block (self): # Aquesta funció crea blocs nous i després s’afegeix al pas de cadena existent def new_transaction (self): #Aquesta funció afegeix una nova transacció a les transaccions ja existents pass @staticmethod def hash (bloc): #Se fa servir per calcular un bloc @property def last_block (self): # Truca i retorna l’últim bloc del pas de cadena
La classe Blockchain gestiona tota la cadena. Les definicions definides a la classe gestionen les diferents accions dins de la cadena de blocs.
Anem a revisar cadascun dels mètodes següents.
Llegiu ara: Què és la distribució de blockchain: una introducció a una solució d’escala de blockchain
Estructura d’un bloc
Un bloc conté informació vital sobre transaccions i cadenes. Qualsevol bloc de la cadena contindrà la informació següent
- índex
- marca de temps en temps Unix
- llista de transaccions
- prova
- Hash de bloc anterior
La majoria de la informació del bloc s’explica per si mateixa. Aquí, les dues variables crucials són previous_hash, que conté el valor hash del bloc anterior. Això és important, ja que assegura que la cadena de blocs és immutable i que cap actor maliciós pot actualitzar, suprimir o afegir dades a la cadena.
Llegiu ara: per què Blockchain canviarà el món?
Addició de transaccions a un bloc
Amb l’estructura del bloc entesa, ara aprendrem a afegir una transacció al bloc. El codi és el següent.
def new_transaction (self): # Aquesta funció afegeix una nova transacció a les transaccions ja existents """Això crearà una nova transacció que s’enviarà al bloc següent. Contindrà tres variables que inclouen remitent, destinatari i import """ self.current_transactions.append ({‘sender’: sender, ‘recipient’: recipient ‘amount’: amount,}) return self.last_block [‘index’] + 1 Com podeu veure, simplement afegeix la llista current_transaction amb un objecte que conté tres variables → remitent, destinatari, quantitat.
Un cop feta l’addició, el mètode envia l’índex de blocs a la cadena. És el següent bloc que s’extreurà.
Creació de nous blocs
Abans de començar a crear nous blocs, hem de crear el bloc de gènesi. Per fer-ho, hem d’utilitzar una línia de codi senzilla com es mostra a continuació.
self.new_block (previous_hash = 1, prova = 100)
Aquesta línia s’hauria d’afegir a la vostra classe Blockchain.
Per al mètode new_block (), heu d’enviar dues variables com a paràmetres. Inclou proves i previous_hash.
Ara fem una ullada al mètode new_block () que es mostra a continuació.
def new_block (self, proof, previous_hash = None): # Aquesta funció crea blocs nous i després s’afegeix a la cadena existent """Aquest mètode contindrà dos paràmetres de prova, hash anterior""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: prova, previous_hash: previous_hash o self.hash (self.chain [-1]),}
# Establiu la llista de transaccions actual a buida.
self.current_transactions = [] self.chain.append (bloc) bloc de retorn
Expliquem el codi del nou_bloc. Creem una llista de blocs que conté els tres paràmetres importants. Un cop definits, també escrivim el codi per restablir la llista de transaccions actuals i, a continuació, afegim el bloc a la cadena. Quan es crida, el mètode new_block retorna el bloc.
Llegiu ara: Guia per a principiants: què és Ethereum Classic?
A continuació, definim el mètode last_block.
@propietat
def last_block (auto):
# Truca i retorna l’últim bloc de la cadena
tornar self.chain [-1]
A més, el codi per al mètode hash () és el següent:
def hash (bloc): #S’utilitza per hash d’un bloc """El codi següent crearà un hash de bloc SHA-256 i també garantirà que el diccionari estigui ordenat""" block_string = json.dumps (block, sort_keys = True) .encode () return hashlib.sha256 (block_string) .hexdigest () Si combineu tot el codi fins ara, tindrem el següent blockchain.py. Comproveu-ho a continuació.
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 La funció crea blocs nous i després s’afegeix a la cadena existent """Aquest mètode contindrà dos paràmetres de prova, hash anterior""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash o self.hash (self.chain [-1]),} # Set la llista de transaccions actual es buida. self.current_transactions = [] self.chain.append (block) return block def new_transaction (self): #Aquesta funció afegeix una nova transacció a les transaccions ja existents """Això crearà una nova transacció que s’enviarà al següent bloc. Contindrà tres variables que inclouen remitent, destinatari i import """ self.current_transactions.append ({‘sender’: sender, ‘recipient’: recipient, ‘amount’: amount,}) return self.last_block [‘index’] + 1 @staticmethod def hash (block): #Used for hashing un bloc """El codi següent crearà un hash de bloc SHA-256 i també garantirà que el diccionari estigui ordenat""" block_string = json.dumps (block, sort_keys = True) .encode () return hashlib.sha256 (block_string) .hexdigest () @property def last_block (self): # Truca i retorna l’últim bloc de la cadena return self.chain [ -1]
Prova de la implementació del treball
El nostre següent pas en la creació de blockchain.py és la implementació de la prova de treball.
Llavors, què és la prova de treball? És un mètode de consens que s’utilitza per afegir nous blocs a la cadena. Suposa un desafiament per al miner i, una vegada que el miner resol el problema, es verifica el bloc. A canvi, el miner obté una recompensa basada en la complexitat del problema.
La prova de treball de Bitcoin es coneix com a Hashcash. Assegura que el consens de la xarxa bitcoin funcioni tal com es pretenia.
Llegiu també: Algoritmes de consens: l’arrel de la tecnologia Blockchain
Definim el mètode proof_of_work (). El mètode formarà part de la classe Blockchain.
def proof_of_work (self, last_proof): """Aquest mètode és on s’implementa l’algorisme de consens. Es necessiten dos paràmetres, inclosos self i last_proof""" prova = 0 mentre que self.valid_proof (last_proof, proof) és False: proof + = 1 return return @staticmethod def valid_proof (last_proof, proof): """Aquest mètode valida el bloc""" guess = f ‘{last_proof} {proof}’. encode () guess_hash = hashlib.sha256 (guess) .hexigest () return guess_hash [: 4] == "0000"
El primer mètode proof_of_work és senzill; simplement estableix la prova a 0 i, a continuació, executa un bucle while per executar el mètode valid_proof. Si és fals, afegiu-ne un a la prova.
Podeu augmentar la dificultat del hash afegint més zeros.
Això ens condueix al final del nostre Blockchain.py. El nostre codi és el següent.
classe 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): """Aquest mètode és on s’implementa l’algorisme de consens. Es necessiten dos paràmetres, inclosos self i last_proof""" prova = 0 mentre que self.valid_proof (last_proof, proof) és False: proof + = 1 return return @staticmethod def valid_proof (last_proof, proof): """Aquest mètode valida el bloc""" guess = f ‘{last_proof} {proof}’. encode () guess_hash = hashlib.sha256 (guess) .hexigest () return guess_hash [: 4] == "0000" def new_block (self, proof, previous_hash = None): # Aquesta funció crea blocs nous i després s’afegeix a la cadena existent """Aquest mètode contindrà dos paràmetres de prova, hash anterior""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash o self.hash (self.chain [-1]),} # Set la llista de transaccions actual es buida. self.current_transactions = [] self.chain.append (block) return block def new_transaction (self): #Aquesta funció afegeix una nova transacció a les transaccions ja existents """Això crearà una nova transacció que s’enviarà al següent bloc. Contindrà tres variables que inclouen remitent, destinatari i import """ self.current_transactions.append ({‘sender’: remitent, ‘destinatari’: destinatari, ‘import’: import,})
torna self.last_block [‘index’] + 1
@staticmethod
hash def (bloc):
#S’utilitza per calcular un bloc
“” “El codi següent crearà un hash de bloc SHA-256 i també garantirà que el diccionari estigui ordenat” “”
block_string = json.dumps (block, sort_keys = True) .encode ()
return hashlib.sha256 (block_string) .hexdigest ()
@propietat
def last_block (auto):
# Truca i retorna l’últim bloc de la cadena
tornar self.chain [-1]
2. Integració d’API
Genial, creem una cadena de blocs que funciona. Ara, per utilitzar-lo eficaçment, hem de crear una API (Application Programming Interface).
Per fer-ho, utilitzarem el popular Python Framework: Flask.
Flask és un microestructura, el que significa que és lleuger i podeu afegir les biblioteques que necessiteu. També us permet crear punt final de la funció Python fàcilment.
Per crear API, primer hem de garantir que la nostra cadena de blocs pugui acceptar sol·licituds mitjançant HTTP. Per fer-ho, hem de crear més mètodes.
Ara, modificarem blockchain.py.
# Creació del node de l’aplicació app = Flask (__ name__) node_identifier = str (uuid4 ()). Replace (‘-‘, ”) # Initializing blockchain blockchain = Blockchain () @ app.route (‘/ mine’, methods = [ ‘GET’]) def mine (): retorn "S’està extraient un bloc nou" @ app.route (‘/ transactions / new’, methods = [‘POST’]) def new_transaction (): retorn "Afegint una nova transacció" @ app.router (‘/ chain’, methods = [‘GET’]) def full_chain (): response = {‘chain’: blockchain.chain, ‘length’: len (blockchain.chain)} return jsonify (resposta) , 200 si __name__ == ‘__main__’: app.run (host ="0.0.0.0", port = 5000)
La majoria del codi s’explica per si mateix. Primer fem una iniciació de node. A continuació, creem un node aleatori. Un cop fet, inicialitzem la nostra classe Blockchain. Un cop fet, hem de crear tres punts finals a continuació.
- / punt final meu
- / transaccions / nou punt final
- / extrem final de la cadena
Finalment, executem el servidor al port 5000.
L’aplicació ja està gairebé creada. Tot el que hem de fer és crear el mètode de classe de transaccions.
@ app.route (‘/ transactions / new’, methods = [‘POST’]) def new_transaction (): values = request.get_json () # Comprovació de si hi ha o no les dades requerides = [‘remitent’, ‘ destinatari ‘,’ quantitat ‘] si no tots (k en valors per a k obligatoris): retorna’ Valors que falten ‘, 400 # creant un índex de transacció nou = blockchain.new_transaction (valors [‘ remitent ‘], valors [‘ destinatari ‘) , values [‘amount’]]] response = {‘message’: f’Transaction està programat per afegir-se al número de bloc {index} ‘} return jsonify (resposta), 201
Llegiu també: Això és el que heu de saber sobre la prova de treball de la cadena de blocs
Punt final de mineria
L’últim punt final que crearem és el punt final de mineria. Per fer-ho, ens hem d’assegurar que faci les tres coses següents.
- Càlcul de la prova del treball
- Forgeu una nova cadena de blocs i afegiu-la a la cadena
- Premi al miner pel seu treball
@ app.route (‘/ mine’, methods = [‘GET’]) def mine (): """Aquí fem que l’algorisme de prova de treball funcioni""" last_block = blockchain.last_block last_proof = last_block [‘proof’] proof = blockchain.proof_of_work (last_proof) # premiant al miner per la seva contribució. 0 especifica que s’ha extret una nova moneda blockchain.new_transaction (remitent ="0", recipient = identificador_node, quantitat = 1,) # ara creeu el nou bloc i afegiu-lo a la cadena previous_hash = blockchain.hash (last_block) block = blockchain.new_block (proof, previous_hash) response = {‘message’: ‘El nou bloc s’ha falsificat ‘,’ index ‘: block [‘ index ‘],’ transactions ‘: block [‘ transactions ‘],’ proof ‘: block [‘ proof ‘],’ previous_hash ‘: block [‘ previous_hash ‘]} return jsonify (resposta), 200
Llegiu ara: Guia per a principiants: què és AION? Primera xarxa mundial de blockchain de tercera generació
3. Interacció Blockchain
L’últim pas és interactuar amb la cadena de blocs. Utilitzarem Postman per interactuar amb la xarxa blockchain mitjançant l’API que acabem de crear.
Executeu el codi següent a la consola Python
python blockchain.py
Conclusió
Això ens condueix al final del nostre Com construir una cadena de blocs. Espero que els passos i codis anteriors us ajudin a construir un Blockchain a Python. Per tant, si sou un principiant i aspireu a construir una carrera a Blockchain, us suggerim que comenceu la vostra carrera blockchain amb el nostre curs gratuït de fonaments de Blockchain Trieu-nos com a company d’estudi i us tindrem fins que no obtingueu el vostre treball de somni.
Llavors, què en penseu sobre blockchain i la seva implementació? Comenta a continuació i fes-nos-ho saber.