Digital Transformation: comprendere la tecnologia Blockchain sviluppandone un esempio [GUIDA]


La “Digital Transformation” sta pervadendo sempre più ogni aspetto del nostro quotidiano introducendo costantemente nuovi servizi, nuovi software, maggiore efficienza, miglior operatività e riduzione dei costi. Ma cos’è di preciso la “Digital Transformation” ? Sicuramente non è solo un ridisegnare e migliorare i processi che governano il business utilizzando una combinazione di nuove e diverse soluzioni tecnologiche, ma è anche e sopratutto un nuovo approccio culturale al business per fare convergere molteplici forze digitali dirompenti e affrontare i cambiamenti tecnologici che al giorno d’oggi sono più rapidi di quanto non lo siano mai stati, impattano milioni di persone, cambiano lo status quo e, di fatto, possono portare alla paralisi le aziende impreparate a seguirla.

In questo articolo inizieremo ad affrontare il tema a partire dalla comprensione di una delle nuove tecnologie che stanno alimentando la Digital Transformation (insieme a diverse altre che affronteremo di volta in volta in altri articoli di approfondimento), la “Blockchain“, tecnologia su cui si basano tutte le “criptomonete” (compresa la più famosa, il Bitcoin). Il suo funzionamento non è semplice, in rete sono disponibili alcuni video complessi da seguire, diversi tutorial alquanto “rognosi” e, cosa più frustrante in assoluto, troppo pochi esempi…

Ma ecco una possibile alternativa: proviamo a seguire passo passo lo sviluppo di un esempio di  Blockchain, processo che, affrontando il tema dal punto di vista della scrittura del codice, ci porterà inevitabilmente a comprendere i vari aspetti ed elementi del modello implementato.

Se seguirete fino al termine questo articolo (liberamente tradotto dall’articolo  “Learn Blockchains by Building One” di Daniel van Flymen sul sito hackernoon.com) avrete realizzato una  Blockchain funzionante ed avrete acquisito una conoscenza di base dei suoi elementi !

Prima di cominciare:

Ricordate che una blockchain è una catena sequenziale ed  immutabile di record chiamati blocchi. I blocchi possono contenere transazioni, file o, in realtà, qualsiasi cosa vogliate. Ma la cosa fondamentale è che tutti i blocchi sono concatenati insieme utilizzando degli hash.

Se non sapete o non siete sicuri di cosa sia una funzione hash  qui potete trovare una breve spiegazione (in inglese).

A chi è indirizzata questa guida ? Per procedere speditamente è necessaria una certa familiarità con la lettura e la scrittura di codice Python ed una certa conoscenza di come funzionano le request HTTP, visto che tratteremo di Blockchain su HTTP.

Cosa ci serve ? Assicuratevi di aver installato Python 3.6+ (insieme a pip). Vi servirà anche Flask e la Requests library:

pip install Flask==0.12.2 requests==2.18.4

Infine è necessario un client HTTP come Postman o cURL, ma qualunque altro andrà bene lo stesso.

Dove trovo il sorgente finale ? E’ disponibile qui.


Step 1: Costruire una Blockchain

Utilizzando il vostro editor di testo preferito create un nuovo file chiamato blockchain.py. Utilizzeremo in questo esempio un singolo file, ma se doveste confondervi/smarrirvi potete sempre far riferimento al codice sorgente.

Rappresentare una Blockchain

Creeremo una classe Blockchain il cui costruttore produrrà inizialmente una lista vuota che conterrà la nostra blockchain, ed un’altra per contenere le transazioni:

class Blockchain(object):
    def __init__(self):
        self.chain = []
        self.current_transactions = []
        
    def new_block(self):
        # Creates a new Block and adds it to the chain
        pass
    
    def new_transaction(self):
        # Adds a new transaction to the list of transactions
        pass
    
    @staticmethod
    def hash(block):
        # Hashes a Block
        pass

    @property
    def last_block(self):
        # Returns the last Block in the chain
        pass

La classe Blockchain gestirà la catena, memorizzerà le transazioni e conterrà alcuni metodi per aggiungere nuovi blocchi. Ma iniziamo con i metodi.

Come è fatto un blocco ?

Ogni blocco ha un indice, un timestamp (in formato Unix), una lista di transazioni, una proof (concetto che approfondiremo in seguito), e l’hash del blocco precedente.

Ecco un esempio di un blocco:

block = {
    'index': 1,
    'timestamp': 1506057125.900785,
    'transactions': [
        {
            'sender': "8527147fe1f5426f9dd545de4b27ee00",
            'recipient': "a77f5cdfa2934df3954a5c7c7da5df1f",
            'amount': 5,
        }
    ],
    'proof': 324984774000,
    'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
}

A questo punto dovrebbe essere più chiaro il concetto di catena (chain) in cui ogni nuovo blocco contiene l’hash del blocco che lo precede. Questo è un elemento cruciale in quanto garantisce l’immutabilità di una blockchain: se qualcuno modificasse un blocco precedente nella catena, allora tutti i blocchi successivi conterrebbero degli hash errati. Vale la pena sottolineare l’importanza di questo aspetto, è questa l’idea centrale su cui si basa il concetto di blockchain.

Aggiungere transazioni ad un Blocco

Ora ci serve un metodo, new_transaction(), per aggiungere transazioni ad un Blocco:

class Blockchain(object):
    ...
    
    def new_transaction(self, sender, recipient, amount):
        """
        Creates a new transaction to go into the next mined Block

        :param sender: <str> Address of the Sender
        :param recipient: <str> Address of the Recipient
        :param amount: <int> Amount
        :return: <int> The index of the Block that will hold this transaction
        """

        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })

        return self.last_block['index'] + 1

Dopo che il metodo new_transaction() ha aggiunto una transazione alla lista restituisce l’indice del blocco a cui la stessa sarà aggiunta, il prossimo blocco ad essere estratto (mined). Questo aspetto sarà utile, più avanti, all’utente che sottometterà la transazione.

Creare nuovi Blocchi

Quando la nostra Blockchain è istanziata dobbiamo inizializzarla con un “blocco di origine” (genesis block), cioè un blocco senza predecessori. Dovremo anche aggiungere la “prova” (proof) di estrazione al nostro blocco “di origine”,  il risultato del mining (la “proof of work“). Parleremo meglio di estrazione in seguito.

Oltre a realizzare nel costruttore il “blocco di origine”  devono essere aggiunti anche i metodi  new_block()new_transaction() e hash():

import hashlib
import json
from time import time


class Blockchain(object):
    def __init__(self):
        self.current_transactions = []
        self.chain = []

        # Create the genesis block
        self.new_block(previous_hash=1, proof=100)

    def new_block(self, proof, previous_hash=None):
        """
        Create a new Block in the Blockchain

        :param proof: <int> The proof given by the Proof of Work algorithm
        :param previous_hash: (Optional) <str> Hash of previous Block
        :return: <dict> New Block
        """

        block = {
            'index': len(self.chain) + 1,
            'timestamp': time(),
            'transactions': self.current_transactions,
            'proof': proof,
            'previous_hash': previous_hash or self.hash(self.chain[-1]),
        }

        # Reset the current list of transactions
        self.current_transactions = []

        self.chain.append(block)
        return block

    def new_transaction(self, sender, recipient, amount):
        """
        Creates a new transaction to go into the next mined Block

        :param sender: <str> Address of the Sender
        :param recipient: <str> Address of the Recipient
        :param amount: <int> Amount
        :return: <int> The index of the Block that will hold this transaction
        """
        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })

        return self.last_block['index'] + 1

    @property
    def last_block(self):
        return self.chain[-1]

    @staticmethod
    def hash(block):
        """
        Creates a SHA-256 hash of a Block

        :param block: <dict> Block
        :return: <str>
        """

        # We must make sure that the Dictionary is Ordered, or we'll have inconsistent hashes
        block_string = json.dumps(block, sort_keys=True).encode()
        return hashlib.sha256(block_string).hexdigest()

Il codice dovrebbe essere di per se abbastanza autoesplicativo oltre al fatto che l’autore ha inserito anche alcuni commenti e docstrings a chiarimento.

Il lavoro di rappresentazione della nostra blockchain è quasi completato, ma ora dobbiamo occuparci di come i nuovi blocchi sono creati/estratti (mined).

Comprendere la “Proof of Work”

Un algoritmo di “Proof of Work” (PoW) ha il compito di creare/estrarre nuovi blocchi da aggiungere alla blockchain individuando la soluzione numerica di un problema. Tale soluzione numerica deve essere difficile da trovare, ma facile da verificare (in termini computazionali) da chiunque nella rete. Questo è il concetto fondamentale che definisce un algoritmo di “Proof of Work”. Vediamo un semplice esempio per chiarire meglio il concetto.

Diciamo che l’hash di un intero x moltiplicato un altro intero y debba finire con 0. Quindi hash(x * y) = ac23dc...0. E per questo esempio fissiamo x = 5. Vediamolo in Python:

from hashlib import sha256
x = 5
y = 0  # We don't know what y should be yet...
while sha256(f'{x*y}'.encode()).hexdigest()[-1] != "0":
    y += 1
print(f'The solution is y = {y}')

La soluzione è y = 21 visto che l’hash prodotto finisce con 0:

hash(5 * 21) = 1253e9373e...5e3600155e860

Nel mondo dei Bitcoin l’algoritmo di “Proof of Work” utilizzato si chiama Hashcash, non differisce molto dal nostro esempio elementare ed è l’algoritmo che i “miners” utilizzano nella competizione di risolvere il problema matematico e creare nuovi blocchi.  Semplificando la sua difficoltà è determinata dal numero di caratteri da ricercare in una stringa. I “miners” (minatori) sono ricompensati per ogni soluzione trovata con un coin (in una transazione) e tutti gli altri utenti in rete possono facilmente verificare tale soluzione.

Implementate un algoritmo di “Proof of Work”

Proviamo ad implementare un algoritmo simile per la nostra blockchain. La nostra regola sarà simile all’esempio precedente:

Effettuare l’hash di un numero p insieme all’hash della soluzione del blocco precedente cercando il valore di p che dia come risultato un hash i cui 4 caratteri iniziali siano 0.

import hashlib
import json

from time import time
from uuid import uuid4


class Blockchain(object):
    ...
        
    def proof_of_work(self, last_proof):
        """
        Simple Proof of Work Algorithm:
         - Find a number p' such that hash(pp') contains leading 4 zeroes, where p is the previous p'
         - p is the previous proof, and p' is the new proof

        :param last_proof: <int>
        :return: <int>
        """

        proof = 0
        while self.valid_proof(last_proof, proof) is False:
            proof += 1

        return proof

    @staticmethod
    def valid_proof(last_proof, proof):
        """
        Validates the Proof: Does hash(last_proof, proof) contain 4 leading zeroes?

        :param last_proof: <int> Previous Proof
        :param proof: <int> Current Proof
        :return: <bool> True if correct, False if not.
        """

        guess = f'{last_proof}{proof}'.encode()
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"

Per adeguare la complessità dell’algoritmo potremmo modificare il numero di zeri iniziali richiesti, ma ci fermeremo a 4 visto che anche l’aggiunta anche di un solo zero fa una grande differenza rispetto al tempo necessario per trovare la soluzione.

La nostra classe è quasi pronta e possiamo iniziare le interazioni utilizzando le HTTP request.


Step 2: La nostra Blockchain in un API

Utilizzeremo il Python Flask Framework, un micro-framework che facilita la mappatura degli end point in funzioni Python. Questo ci consentirà di interagire con la nostra blockchain via web utilizzando le HTTP request.

Serviranno tre metodi:

  • /transactions/new per creare una nuova transazione in un blocco
  • /mine per richiedere al server di estrarre un nuovo blocco
  • /chain per restituire l’intera Blockchain

Configurare Flask

Il nostro “server” rappresenterà un singolo nodo nella nostra rete blockchain. Vediamo un po’ di codice:

import hashlib
import json
from textwrap import dedent
from time import time
from uuid import uuid4

from flask import Flask


class Blockchain(object):
    ...


# Instantiate our Node
app = Flask(__name__)

# Generate a globally unique address for this node
node_identifier = str(uuid4()).replace('-', '')

# Instantiate the Blockchain
blockchain = Blockchain()


@app.route('/mine', methods=['GET'])
def mine():
    return "We'll mine a new Block"
  
@app.route('/transactions/new', methods=['POST'])
def new_transaction():
    return "We'll add a new transaction"

@app.route('/chain', methods=['GET'])
def full_chain():
    response = {
        'chain': blockchain.chain,
        'length': len(blockchain.chain),
    }
    return jsonify(response), 200

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

In breve in questo frammento di codice trovate:

  • Linea 15: Istanzia in nostro Nodo. Maggiori informazioni su Flask qui.
  • Linea 18: Crea un nome casuale per il nostro nodo.
  • Line 21: Istanzia la nostra classe Blockchain.
  • Linee 24–26: Creano l’endpoint  /mine, una richiesta GET .
  • Linee 28–30: Creano l’endpoint /transactions/new, una richiesta POST dal momento che gli invieremo dei dati
  • Linee 32–38: Creano l’endpoint /chain, che restituisce l’intera Blockchain.
  • Linee 40–41: Eseguono il server sulla porta 5000.

L’endpoint delle transazioni

Questo è l’aspetto di una richiesta di transazione, ciò che l’utente invia al server:

{
 "sender": "my address",
 "recipient": "someone else's address",
 "amount": 5
}

Avendo nella classe il metodo per aggiungere transazioni ad un blocco il resto non è complesso. Vediamo la funzione per aggiungere transazioni:

import hashlib
import json
from textwrap import dedent
from time import time
from uuid import uuid4

from flask import Flask, jsonify, request

...

@app.route('/transactions/new', methods=['POST'])
def new_transaction():
    values = request.get_json()

    # Check that the required fields are in the POST'ed data
    required = ['sender', 'recipient', 'amount']
    if not all(k in values for k in required):
        return 'Missing values', 400

    # Create a new Transaction
    index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])

    response = {'message': f'Transaction will be added to Block {index}'}
    return jsonify(response), 201

L’endpoint Mining

L’endpoint mining è quello che si occupa della “magia” facendo tre cose:

  1. Calcolare il “Proof of Work”
  2. Ricompensare il miner (noi) aggiungendo una transazione che ci da 1 coin
  3. Creare il nuovo blocco aggiungendolo alla chain
import hashlib
import json

from time import time
from uuid import uuid4

from flask import Flask, jsonify, request

...

@app.route('/mine', methods=['GET'])
def mine():
    # We run the proof of work algorithm to get the next proof...
    last_block = blockchain.last_block
    last_proof = last_block['proof']
    proof = blockchain.proof_of_work(last_proof)

    # We must receive a reward for finding the proof.
    # The sender is "0" to signify that this node has mined a new coin.
    blockchain.new_transaction(
        sender="0",
        recipient=node_identifier,
        amount=1,
    )

    # Forge the new Block by adding it to the chain
    previous_hash = blockchain.hash(last_block)
    block = blockchain.new_block(proof, previous_hash)

    response = {
        'message': "New Block Forged",
        'index': block['index'],
        'transactions': block['transactions'],
        'proof': block['proof'],
        'previous_hash': block['previous_hash'],
    }
    return jsonify(response), 200

Notare come il destinatario del blocco estratto è l’indirizzo del nostro nodo e che la maggior parte di quanto facciamo qui  è interagire con i metodi della nostra classe . A questo punto siamo pronti ad interagire con la nostra blockchain.


 Step 3: Interagire con la nostra Blockchain

Potete utilizzare cURL o Postman per interagire con l’API in rete.

Lanciamo il server:

$ python blockchain.py
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Proviamo ad estrarre un blocco effettuando una request GET a http://localhost:5000/mine:

Una GET request (con Postman )

Ora creiamo una transazione effettuando una request POST a http://localhost:5000/transactions/new con un body contenente la struttura della nostra transazione:

Una POST request (con Postman )

Se non utilizzate Postman potete effettuare delle request equivalenti usando cURL:

$ curl -X POST -H "Content-Type: application/json" -d '{
 "sender": "d4ee26eee15148ee92c6cd394edd974e",
 "recipient": "someone-other-address",
 "amount": 5
}' "http://localhost:5000/transactions/new"

Dopo aver estratto altri due blocchi (per averne un totale di 3) proviamo ad ispezionare l’intera chain effettuando la richiesta   http://localhost:5000/chain:

{
  "chain": [
    {
      "index": 1,
      "previous_hash": 1,
      "proof": 100,
      "timestamp": 1506280650.770839,
      "transactions": []
    },
    {
      "index": 2,
      "previous_hash": "c099bc...bfb7",
      "proof": 35293,
      "timestamp": 1506280664.717925,
      "transactions": [
        {
          "amount": 1,
          "recipient": "8bbcb347e0634905b0cac7955bae152b",
          "sender": "0"
        }
      ]
    },
    {
      "index": 3,
      "previous_hash": "eff91a...10f2",
      "proof": 35089,
      "timestamp": 1506280666.1086972,
      "transactions": [
        {
          "amount": 1,
          "recipient": "8bbcb347e0634905b0cac7955bae152b",
          "sender": "0"
        }
      ]
    }
  ],
  "length": 3
}

 


 Step 4: Consenso

Questo aspetto è molto interessante. Abbiamo realizzato una Blockchain che accetta transazioni e ci consente di estrarre nuovi blocchi, ma  la caratteristica principale di una Blockchain è di essere decentralizzata.  Ma se è decentralizzata come facciamo ad assicurare che tutti i vari nodi rappresentino la stessa catena ? Questo è chiamato “problema del Consenso” e dovremo implementare un algoritmo di consenso se vogliamo  avere più di un nodo nella nostra rete blockchain.

Registrare nuovi Nodi

Prima di implementare un algoritmo di consenso ci serve una modalità per informare i singoli nodi dell’esistenza di altri nodi nella rete, in ogni nodo nella nostra rete dovrebbe essere presente un registro degli altri nodi. Ci servono quindi dei nuovi endpoint:

  1. /nodes/register per accettare una lista di nuovi nodi in forma di URL.
  2. /nodes/resolve per implementare il nostro algoritmo di consenso che possa risolvere i conflitti ed assicurare che un nodo gestisca la catena corretta.

Dovremo quindi modificare il costruttore della nostra Blockchain e  realizzare un metodo per registrare i nodi:

...
from urllib.parse import urlparse
...


class Blockchain(object):
    def __init__(self):
        ...
        self.nodes = set()
        ...

    def register_node(self, address):
        """
        Add a new node to the list of nodes

        :param address: <str> Address of node. Eg. 'http://192.168.0.5:5000'
        :return: None
        """

        parsed_url = urlparse(address)
        self.nodes.add(parsed_url.netloc)

Notare che è stata utilizzata l’istruzione <code”>set() per memorizzare la lista dei nodi. Questo è un modo semplice per garantire che l’aggiunta di nuovi nodi sia idempotente: ciò significa che non importa quante volte aggiungiamo un nodo specifico, esso apparirà sempre solo una volta.

Implementare l’Algoritmo di Consenso

Come già accennato un conflitto si verifica quando un nodo ha una catena diversa rispetto a un altro nodo. Per risolvere questo problema  definiamo la regola secondo cui la catena valida più lunga è autoritativa. In altre parole la catena più lunga sulla rete è de-facto una sola. Usando questo algoritmo realizziamo il consenso tra i nodi della nostra rete.

...
import requests


class Blockchain(object)
    ...
    
    def valid_chain(self, chain):
        """
        Determine if a given blockchain is valid

        :param chain: <list> A blockchain
        :return: <bool> True if valid, False if not
        """

        last_block = chain[0]
        current_index = 1

        while current_index < len(chain):
            block = chain[current_index]
            print(f'{last_block}')
            print(f'{block}')
            print("\n-----------\n")
            # Check that the hash of the block is correct
            if block['previous_hash'] != self.hash(last_block):
                return False

            # Check that the Proof of Work is correct
            if not self.valid_proof(last_block['proof'], block['proof']):
                return False

            last_block = block
            current_index += 1

        return True

    def resolve_conflicts(self):
        """
        This is our Consensus Algorithm, it resolves conflicts
        by replacing our chain with the longest one in the network.

        :return: <bool> True if our chain was replaced, False if not
        """

        neighbours = self.nodes
        new_chain = None

        # We're only looking for chains longer than ours
        max_length = len(self.chain)

        # Grab and verify the chains from all the nodes in our network
        for node in neighbours:
            response = requests.get(f'http://{node}/chain')

            if response.status_code == 200:
                length = response.json()['length']
                chain = response.json()['chain']

                # Check if the length is longer and the chain is valid
                if length > max_length and self.valid_chain(chain):
                    max_length = length
                    new_chain = chain

        # Replace our chain if we discovered a new, valid chain longer than ours
        if new_chain:
            self.chain = new_chain
            return True

        return False

Il primo metodo valid_chain() verifica se una chain è valida analizzando ogni singolo blocco e verificando sia l’hash che la proof.

resolve_conflicts() è invece un metodo che analizza i nodi vicini della rete scaricandone le singole chain e verificandole utilizzando il metodo di cui sopra. Se il metodo individua una chain valida più lunga della propria sostituisce la propria con quella individuata.

Registriamo due endpoint alla nostra API, uno per l’aggiunta di nodi vicini e l’altro per la risoluzione dei conflitti:

@app.route('/nodes/register', methods=['POST'])
def register_nodes():
    values = request.get_json()

    nodes = values.get('nodes')
    if nodes is None:
        return "Error: Please supply a valid list of nodes", 400

    for node in nodes:
        blockchain.register_node(node)

    response = {
        'message': 'New nodes have been added',
        'total_nodes': list(blockchain.nodes),
    }
    return jsonify(response), 201


@app.route('/nodes/resolve', methods=['GET'])
def consensus():
    replaced = blockchain.resolve_conflicts()

    if replaced:
        response = {
            'message': 'Our chain was replaced',
            'new_chain': blockchain.chain
        }
    else:
        response = {
            'message': 'Our chain is authoritative',
            'chain': blockchain.chain
        }

    return jsonify(response), 200

A questo punto potete utilizzare una macchina diversa, se lo desiderate, per generare diversi nodi sulla vostra rete, oppure potete utilizzare porte diverse sullo stesso computer. Utilizzando quest’ultimo metodo potremo avere due nodi sulla stessa macchina:   http://localhost:5000 e http://localhost:5001.

 
Registrazione di un nuovo nodo

Estraiamo poi alcuni nuovi blocchi sul nodo 2 per essere sicuri di avere una catena più lunga. Successivamente invocando il metodo GET /nodes/resolve sul nodo 2 la catena verrà sostituita dall’algoritmo di consenso:

L’algoritmo di consenso all’opera

E questo è tutto… ora potete coinvolgere alcuni amici per effettuare un test più esteso della vostra blokchain !


Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

This site uses Akismet to reduce spam. Learn how your comment data is processed.