Nel precedente articolo abbiamo visto come creare da zero una Blockchain, in particolare abbiamo sviluppato un semplice motore di blockchain che riprende i concetti di base presenti in bitcoin. Proviamo adesso a sviluppare la parte restante, integrando le funzioni mancanti che permettono il pieno funzionamento della blockchain in rete. Iniziamo!
L’interfaccia
Lavorando sempre all’interno del file node_server.py, creeremo l’interfaccia per interagire con la blockchain che abbiamo appena creato. Utilizzeremo un popolare microframework Python chiamato Flask per creare API REST interattive e chiamare vari azioni nel nostro nodo blockchain. Come qualsiasi framework Web, anche Flask ci aiuta ad ottimizzare il codice e renderlo il più leggibile possibile.
from flask import Flask, request #importiamo le librerie necessarie di Flask import requests # Creo l'istanze dell'applicazione Flask passando __name__come argomento app = Flask (__ name__) # Inizializzo la blockchain (con il relativo il blocco di genesi) blockchain = Blockchain()
Adesso, abbiamo bisogno di un percorso (endpoint) per inserire una nuova transazione nell’array delle transazioni pendenti attraverso il submit di un form (con method=post), che creeremo più avanti. Per il momento, ci serve definire questa funzione:
@app.route('/new_transaction', methods=['POST'])
def new_transaction():
tx_data = request.get_json() # dati in arrivo dal form attraverso il submit
required_fields = ["author", "content"]
# controllo tutti i campi obbligatori
for field in required_fields:
if not tx_data.get(field):
# ritorna un errore 404 nel caso uno dei due campi fosse vuoto
return "Invalid transaction data", 404
tx_data["timestamp"] = time.time() # aggiunge la data in formato timestamp
blockchain.add_new_transaction(tx_data) # aggiunge la transazione nell'array delle transazioni pendenti
return "Success", 201
Sviluppiamo di seguito, che verrà utilizzata dai nodi peers, un endpoint che restituisce una copia della catena sottoforma di stringa JSON. Questo endpoint potrà essere usato per interrogare tutti i blocchi e le transazioni presenti nella blockchain:
@app.route('/chain', methods=['GET'])
def get_chain():
chain_data = []
for block in blockchain.chain:
chain_data.append(block.__dict__)
return json.dumps({"length": len(chain_data),
"chain": chain_data,
"peers": list(peers)})
Ecco l’endpoint che permette di inviare una richiesta di mining convalidando le transazioni non verificate (se ovviamente l’array ha delle transazioni pendenti). Inoltre sviluppiamo un semplicissimo endpoint che ritorna le transazioni attualmente in stato di pending.
@app.route('/mine', methods=['GET'])
def mine_unconfirmed_transactions():
result = blockchain.mine()
if not result:
return "Nessuna transazione da minare"
return "Block #{} è stato minato.".format(result)
@app.route('/pending_tx')
def get_pending_tx():
return json.dumps(blockchain.unconfirmed_transactions)
Stabilire un meccanismo di consenso e dispersione
C’è un problema sulla blockchain in esecuzione su un computer. Sebbene abbiamo collegato i blocchi con il valore hash e applicato PoW, non è ancora possibile fidarsi di una singola entità (in questo caso, una singola macchina). Abbiamo bisogno di avere dati distribuiti o più nodi server per mantenere la blockchain in maniera distribuita. Quindi, per passare da un singolo nodo a una rete peer-to-peer, creiamo un meccanismo in modo che un nuovo nodo possa conoscere gli altri peer nella rete.
Un nuovo nodo che si unisce alla rete può chiamare la funzione register_with_existing_node attraverso il suo endpoint /register_with per registrarsi con i nodi esistenti nella rete. La funzione svolgerà i seguenti compiti:
- Richiede al nodo remoto di aggiungere un nuovo peer all’elenco di peer esistente
- Inizializza facilmente la blockchain del nuovo nodo recuperando il nodo remoto
- Risincronizza la blockchain con la rete se quel nodo non è più connesso alla rete
# Impostiamo innanzitutto un set vuoto che conterrà l'indirizzo host degli altri nodi della rete
peers = set()
# Endpoint per aggiungere un nuovo peer alla rete
@app.route('/register_node', methods=['POST'])
def register_new_peers():
# Recupera l'indirizzo dell'host del nodo peer
node_address = request.get_json()["node_address"]
# nel caso in cui non viene fornito l'indirizzo, ritorna un errore
if not node_address:
return "Invalid data", 400
# Aggiungi l'indirizzo del nodo al set
peers.add(node_address)
# Ritorna la blockchain
return get_chain()
# Endpoint per registrare un nuovo nodo. Al suo interno
# effettua una chiamata alla rotta "register_node" per
# registrare il nodo corrente con il nodo remoto specificato
# nella richiesta POST e alla fine aggiorna la rete blockchain
@app.route('/register_with', methods=['POST'])
def register_with_existing_node():
node_address = request.get_json()["node_address"]
if not node_address:
return "Invalid data", 400
data = {"node_address": request.host_url}
headers = {'Content-Type': "application/json"}
# Richiesta di registrazione con il nodo remoto
response = requests.post(node_address + "/register_node", data=json.dumps(data), headers=headers)
if response.status_code == 200:
global blockchain
global peers
# aggiorna la catena e i peers
chain_dump = response.json()['chain']
blockchain = create_chain_from_dump(chain_dump) # crea la blockchain per il nuovo nodo peer
peers.update(response.json()['peers'])
return "Registration successful", 200
else:
# Se viene sollevato un errore, l'API ritorna un response
return response.content, response.status_code
def create_chain_from_dump(chain_dump):
generated_blockchain = Blockchain()
generated_blockchain.create_genesis_block()
for idx, block_data in enumerate(chain_dump):
if idx == 0:
continue # salta il blocco di genesi
block = Block(block_data["index"],
block_data["transactions"],
block_data["timestamp"],
block_data["previous_hash"],
block_data["nonce"])
proof = block_data['hash']
added = generated_blockchain.add_block(block, proof)
if not added:
raise Exception("Catena manomessa!")
return generated_blockchain
Esiste un problema: quando la rete è formata da molti nodi, a causa di problemi intenzionali o non (come ad esempio la latenza di rete), la copia della catena di alcuni nodi potrebbe essere diversa. In tal caso i nodi devono concordare una versione della catena per mantenere l’integrità dell’intero sistema. In altre parole, dobbiamo raggiungere un consenso.
Un semplice algoritmo di consenso è quello di stabilire valida la catena più lunga se le catene dei nodi peer appaiono biforcute. Il motivo di questa scelta è che la catena più lunga dimostra il maggior lavoro svolto (PoW è molto meticoloso):
class Blockchain
...
def check_chain_validity(cls, chain):
# funzione che controlla se l'interna blockchain è corretta
result = True
previous_hash = "0"
# il ciclo for viene eseguito per tutti i blocchi presenti nella catena
for block in chain:
block_hash = block.hash
# cancella il campo hash per ricalcolare il valore hash usando la funzione compute_hash
delattr(block, "hash")
if not cls.is_valid_proof(block, block.hash) or previous_hash != block.previous_hash:
result = False
break
block.hash, previous_hash = block_hash, block_hash
return result
def consensus():
# La funzione implementa un semplice algoritmo di consenso.
# Va a controllare la lunghezza della catena. Se la lunghezza trovata è maggiore di
# tutte quelle possibili, allora la catena viene sostituita.
global blockchain
longest_chain = None
current_len = len(blockchain.chain)
for node in peers:
response = requests.get('{}/chain'.format(node))
length = response.json()['length']
chain = response.json()['chain']
if length > current_len and blockchain.check_chain_validity(chain):
# trovata una catena di lunghezza superiore e viene sostituita
current_len = length
longest_chain = chain
if longest_chain:
blockchain = longest_chain
return True
return False
Successivamente dobbiamo sviluppare un modo per qualsiasi nodo di informare la rete che ha estratto un blocco in modo che tutti possano aggiornare la propria blockchain e passare all’estrazione di altri blocchi. Altri nodi potrebbero dover solo verificare il PoW e aggiungere il blocco appena estratto alla rispettiva catena (ricorda che la verifica è facile quando si conosce il nonce):
# Endpoint che aggiunge il blocco appena minato alla catena.
# Il blocco richiede di essere verificato prima di poter essere inserito alla catena.
@app.route('/add_block', methods=['POST'])
def verify_and_add_block():
block_data = request.get_json()
block = Block(block_data["index"],
block_data["transactions"],
block_data["timestamp"],
block_data["previous_hash"])
proof = block_data['hash']
added = blockchain.add_block(block, proof)
if not added:
return "Il blocco è stato scartato dal nodo", 400
return "Block aggiunto alla catena", 201
def announce_new_block(block):
# Funzione che informa la rete dopo aver minato un blocco.
# Gli altri nodi peer devono solo verificare il PoW e
# aggiungere la stringa corrispondente.
for peer in peers:
url = "{}add_block".format(peer)
requests.post(url, data=json.dumps(block.__dict__, sort_keys=True))
La funzione announce_new_block() dovrebbe essere chiamata dopo che ogni blocco è stato estratto dai nodi in modo che gli altri peer possano aggiungerlo alla loro catena. Per questo motivo è necessario fare una piccola modifica al metodo mine, aggiungendo qualche riga in più nel blocco else.
@app.route('/mine', methods=['GET'])
def mine_unconfirmed_transactions():
result = blockchain.mine()
if not result:
return "Nessuna transazione da minare"
else:
# Nuove righe di codice
# Assicuriamoci di avere la lunghezza massima della catena,
# prima di comunicare con la rete
chain_length = len(blockchain.chain)
consensus()
if chain_length == len(blockchain.chain):
# annuncia a tutti i nodi peer che il blocco è stato minato
announce_new_block(blockchain.last_block)
return "Block #{} è stato minato.".format(blockchain.last_block.index)
Lo sviluppo dell’applicazione web
Ora è il momento di iniziare a sviluppare l’interfaccia dell’applicazione web. Abbiamo utilizzato il template engine Jinja2 per creare le view e alcuni stili CSS per migliorare l’estetica dell’interfaccia.
L’applicazione deve connettersi a un nodo nella rete blockchain per recuperare i dati e anche per inviare nuovi dati.
Nel nuovo file chiamato views.py, conterrà la logica necessaria all’applicazione web.
import datetime import json import requests from flask import render_template, redirect, request from app import app # Indirizzo del nodo a cui collegarsi per recuperare le informazioni CONNECTED_NODE_ADDRESS = "http://127.0.0.1:8081" posts = []
Svilupiamo la funzione fetch_posts che non farà altro che recuperare le informazioni della catena:
def fetch_posts():
get_chain_address = "{}/chain".format(CONNECTED_NODE_ADDRESS)
response = requests.get(get_chain_address)
if response.status_code == 200:
content = []
chain = json.loads(response.content)
for block in chain["chain"]:
for tx in block["transactions"]:
tx["index"] = block["index"]
tx["hash"] = block["previous_hash"]
content.append(tx)
global posts
posts = sorted(content,
key=lambda k: k['timestamp'],
reverse=True)
L’applicazione dispone di un modulo HTML per inserire l’input dell’utente ed effettuare una richiesta POST al nodo connesso per aggiungere transazioni all’array di transazioni pending. La transazione viene quindi estratta dalla rete e infine recuperata dopo aver ricaricato la pagina:
@app.route('/submit', methods=['POST'])
def submit_textarea():
post_content = request.form["content"]
author = request.form["author"]
post_object = {
'author': author,
'content': post_content,
}
# Submit della transazione
new_tx_address = "{}/new_transaction".format(CONNECTED_NODE_ADDRESS)
requests.post(new_tx_address,
json=post_object,
headers={'Content-type': 'application/json'})
# Ritorna in homepage
return redirect('/')
Eseguire correttamente la blockchain
Occorre innanzitutto aprire una finestra della console e posizionarsi sulla cartella del nostro progetto. Le istruzioni che seguono sono ottimizzate per l’uso con sistemi operativi Windows. Apriamo una finestra della console con il comando CMD dal menu Start.
Innanzitutto installiamo le dipendenze che abbiamo usato nel nostro codice:
pip install -r requests pip install -r Flask
Successivamente avviamo la blockchain sulla porta 8081:
set FLASK_APP=node_server.py flask run --port 8081
Apriamo una nuova finestra di console, e digitiamo il seguente comando:
python run_app.py
L’applicazione verrà avviata all’indirizzo http: // localhost: 5000
Avvio di istanze multiple (simulazione rete peer)
set FLASK_APP=node_server.py flask run --port 8081 | flask run --port 8082 | flask run --port 8083
In una nuova finestra di console, digitiamo il seguente comando (attenzione agli apici e alle virgolette):
curl -X POST http://127.0.0.1:8082/register_with -H "Content-Type: application/json" -d "{\"node_address\": \"http://127.0.0.1:8081\"}"
curl -X POST http://127.0.0.1:8083/register_with -H "Content-Type: application/json" -d "{\"node_address\": \"http://127.0.0.1:8081\"}"
L’applicazione viene eseguita con lo stesso comando di prima:
python run_app.py
Stavolta, quando creeremo le transazioni tramite l’interfaccia web e faremo il mining, tutti i nodi della rete aggiorneranno la catena.
La catena di ogni singolo nodo potrà essere controllata da questo comando:
curl -X GET http://localhost:8082/chain curl -X GET http://localhost:8083/chain
Per scaricare l’intero progetto, clicca qui.
