Capire le blockchain programmando una in R

Tutti parlano di criptovalute in questo periodo, complice l’hype su Bitcoin. Più interessante di chiedersi se siamo o meno in una bolla è capire come funziona davvero questa tecnologia e quali possibilità apre. La storia di Bitcoin parte da un white paper del 2008, "Bitcoin: A Peer-to-Peer Electronic Cash System". In quel documento l’autore, Satoshi Nakamoto (c’è ancora ampio dibattito su chi sia davvero Satoshi), presenta una nuova tecnologia e un’idea rivoluzionaria: una valuta elettronica decentralizzata che gira su qualcosa chiamato blockchain. Da lì l’idea si è diffusa e oggi si può applicare a molti altri ambiti.

Ho sentito parlare per la prima volta di blockchain a un incontro della BlockchainSociety a Oxford. Tutti sembravano entusiasti del potenziale di questa nuova tecnologia. E, a dirla tutta, suona davvero intrigante: un database decentralizzato e incorruttibile di transazioni monetarie, contratti o quello che preferisci (per esempio, macchine per il voto impossibili da violare). La promessa della blockchain per la comunità crypto è di sconvolgere interi settori rivoluzionando il concetto di fiducia, al punto da non aver più bisogno di terze parti come banche o avvocati: basta la forza della crittografia.

L’idea di base è intuitiva, ma capire come funziona tecnicamente una blockchain è un po’ più impegnativo. La settimana scorsa mi sono imbattuto in un articolo su R-bloggers in cui BigData Doc costruisce una blockchain interamente in R. Una blockchain in R non sarà la cosa più efficiente o pratica al mondo, ma è un ottimo modo per comprendere i principi di programmazione e crittografia che ci stanno dietro. Volevo capirla anche io, e per questo ho implementato una versione più piccola della blockchain in R: "Se riesci a programmarla, allora la capisci di sicuro".

Cos’è una blockchain?

Immagina di voler archiviare dei dati in modo sicuro. Per farlo, per prima cosa metti i dati in un contenitore, che chiami blocco. Nel caso di Bitcoin, ogni blocco contiene diverse transazioni finanziarie. Quando arrivano nuove transazioni (o ci sono nuovi dati) viene creato un nuovo blocco, che si aggiunge ai precedenti formando una catena: la blockchain.

Vediamo come le blockchain usano la crittografia per diventare praticamente impossibili da violare.

1. Blocchi

    block_example <- list(index = 1,
                     timestamp = "2018-01-05 17.00 MST",
                     data = "some data",
                     previous_hash = 0,
                     proof = 9,
                     new_hash = NULL)

Prima di iniziare a costruire la blockchain, cioè a concatenare diversi contenitori di dati, devi conoscere altri due concetti: hashing e algoritmi di Proof-of-Work.

2. Hash

Un hash aiuta a garantire l’integrità di un blocco collegandolo agli altri blocchi della catena. Una funzione di hash prende qualcosa in ingresso e restituisce un output univoco e cifrato. Un esempio: poni alla tua amica l’indovinello "Qual è il miglior programma di statistica: Stata o R?" e le dai l’hash della soluzione corretta: "71ec0b920622cf4358bbc21d6a8b41f903584808db53ec07a8aa79119304ce86". Lei può verificare da sola se ha la risposta giusta inserendo la sua risposta nella funzione di hash (nel nostro caso l’algoritmo SHA256):

    library("digest")

    digest("Stata" ,"sha256") # first try

    ## [1] "3ac273f00d52dc9caf89cbd71e73e5915229a588117ca3441630089409ddb7bc"

    digest("R", "sha256") # second try

    ## [1] "71ec0b920622cf4358bbc21d6a8b41f903584808db53ec07a8aa79119304ce86"

In che modo questo ti aiuta?

In questo caso, nella funzione di hash non inserisci solo le informazioni sul blocco (indice, timestamp, dati), ma anche l’hash del blocco precedente. Ciò significa che puoi calcolare un hash valido solo se conosci l’hash del blocco precedente, che a sua volta è stato creato usando l’hash del blocco prima e così via. Questo fornisce una catena di blocchi immutabile e sequenziale. Se modificassi un blocco in seguito, dovresti ricalcolare tutti gli hash dei blocchi successivi.

    #Function that creates a hashed "block"
    hash_block <- function(block){
      block$new_hash <- digest(c(block$index,
                                 block$timestamp,
                                 block$data,
                                 block$previous_hash), "sha256")
      return(block)
    }

3. Proof-of-Work

Se c’è molta informazione da archiviare sulla blockchain, dovrai creare molti nuovi blocchi. In molti casi vuoi controllare quanti nuovi blocchi vengono creati. Per esempio, nelle criptovalute le monete perderebbero valore se si potessero creare all’infinito, ogni secondo.

Perciò aggiungiamo un algoritmo di "Proof-of-Work" (PoW) che controlla la difficoltà di creazione di un nuovo blocco. "Proof" significa che il computer ha eseguito una certa quantità di lavoro. In pratica l’obiettivo è creare un oggetto difficile da generare ma facile da verificare. Userò il seguente "compito" come PoW: trovare il prossimo numero divisibile per 99 e divisibile per il numero di proof dell’ultimo blocco.

    ### Simple Proof of Work Alogrithm
    proof_of_work <- function(last_proof){
      proof <- last_proof + 1

      # Increment the proof number until a number is found that is divisable by 99 and by the proof of the previous block
      while (!(proof %% 99 == 0 & proof %% last_proof == 0 )){
        proof <- proof + 1
      }

      return(proof)
    }

Nelle blockchain come Bitcoin o Ethereum il lavoro di creare nuovi blocchi è svolto dai cosiddetti miner. Quando bisogna creare un nuovo blocco, al network viene inviato un problema computazionale. Il miner che risolve per primo il problema di PoW crea il nuovo blocco e viene ricompensato in Bitcoin (è così che vengono effettivamente creati i nuovi Bitcoin). Questa "lotteria" per trovare la nuova proof corretta garantisce che il potere di creare nuovi blocchi sia decentralizzato. Quando un nuovo blocco viene minato, viene inviato a tutti così che ogni nodo della rete abbia una copia aggiornata della blockchain. L’idea che la blockchain più lunga nella rete (quella in cui è stato fatto "più lavoro") sia la versione valida è chiamata "consenso decentralizzato".

Nel caso di Bitcoin, il problema di PoW consiste nel trovare numeri che generino hash con un certo numero di zeri iniziali (la spiegazione migliore che ho trovato è questo video di Savjee). Per tenere conto dell’aumento della potenza di calcolo e del variare del numero di miner nella rete, la difficoltà del PoW può essere regolata per mantenere costante il tempo di creazione di un nuovo blocco a circa dieci minuti.

4. Aggiungere nuovi blocchi

Ora sai com’è fatto un blocco, come i blocchi si concatenano tramite hash e come il ritmo di creazione dei nuovi blocchi viene regolato dai PoW. Mettiamo tutto insieme in una funzione:

    #A function that takes the previous block and normally some data (in our case the data is a string indicating which block in the chain it is)
    gen_new_block <- function(previous_block){

      #Proof-of-Work
      new_proof <- proof_of_work(previous_block$proof)

      #Create new Block
      new_block <- list(index = previous_block$index + 1,
                        timestamp = Sys.time(),
                        data = paste0("this is block ", previous_block$index +1),
                        previous_hash = previous_block$new_hash,
                        proof = new_proof)

      #Hash the new Block
      new_block_hashed <- hash_block(new_block)

      return(new_block_hashed)
    }

Prima di iniziare a costruire la blockchain, devi far partire la catena da qualche parte. Si fa con il cosiddetto Genesis Block. Non contiene dati e ha valori arbitrari per proof e hash precedente (non c’è un blocco precedente).

    # Define Genesis Block (index 1 and arbitrary previous hash)
    block_genesis <-  list(index = 1,
                           timestamp = Sys.time(),
                           data = "Genesis Block",
                           previous_hash = "0",
                           proof = 1)

5. Costruire la blockchain

Ora puoi iniziare a costruire la blockchain. Parti con il blocco Genesis e poi aggiungi qualche blocco con un ciclo.

    blockchain <- list(block_genesis)
    previous_block <- blockchain[[1]]

      # How many blocks should we add to the chain after the genesis block
      num_of_blocks_to_add <- 5

      # Add blocks to the chain
      for (i in 1: num_of_blocks_to_add){
        block_to_add <- gen_new_block(previous_block) 
        blockchain[i+1] <- list(block_to_add)
        previous_block <- block_to_add

        print(cat(paste0("Block ", block_to_add$index, " has been added", "\n",
                   "\t", "Proof: ", block_to_add$proof, "\n",
                   "\t", "Hash: ", block_to_add$new_hash)))
      }

    ## Block 2 has been added
    ##  Proof: 99
    ##  Hash: 7d3dfbb58b410838769f6080dbc62a44a4c5d411a41048c4e597d26dccd1cd38NULL
    ## Block 3 has been added
    ##  Proof: 198
    ##  Hash: 4f8bdd79d751f9e9829c14c52a737f257285b61e54b29531dd59bf1a530f1097NULL
    ## Block 4 has been added
    ##  Proof: 396
    ##  Hash: 512b877c4ff92605d9fe10ac73ced20f748742964f306c211c4691f15425a26eNULL
    ## Block 5 has been added
    ##  Proof: 792
    ##  Hash: a3baaa025186c5bcb2238a888bc65e705ffe73c17dc5c8f26ee337fd62867993NULL
    ## Block 6 has been added
    ##  Proof: 1584
    ##  Hash: d12c3f54c14f3287a9f31ab542271197ba6a658cee561a9289819dd563fe4991NULL

Se vuoi aggiungere molti altri blocchi, noterai che richiede sempre più tempo. Il motivo è che il numero di proof cresce esponenzialmente.

Per criptovalute come Bitcoin questo sarebbe un problema, perché il tempo per creare un nuovo blocco dovrebbe rimanere più o meno costante (circa 10 minuti nel caso di Bitcoin). Per questo la difficoltà del PoW va regolata continuamente per tenere conto dell’aumento della potenza di calcolo e del variare del numero di miner in rete in un dato momento.

Infine, ecco come appare un blocco della tua catena:

    blockchain[[5]]

    ## $index
    ## [1] 5
    ## 
    ## $timestamp
    ## [1] "2018-02-08 12:02:56 GMT"
    ## 
    ## $data
    ## [1] "this is block 5"
    ## 
    ## $previous_hash
    ## [1] "26cdc16a4560df5fa2fd521dbca22670e2475c35d3dd90781872bee98a164eef"
    ## 
    ## $proof
    ## [1] 792
    ## 
    ## $new_hash
    ## [1] "2eef25bf0bc4ee81e8c7cd1dfda65855b4ba32aba218d8c525a03a72b3454d74"

Conclusioni

In questo breve post hai creato la più piccola blockchain. L’obiettivo principale era mostrare com’è fatta una blockchain e introdurre alcuni concetti fondamentali che la sostengono. Capire l’applicazione geniale della crittografia spiega perché le possibilità della blockchain entusiasmino così tante persone.

Per mettere in produzione una blockchain serve molto più lavoro: impostare un’API, creare wallet, firme digitali con coppie di chiavi pubbliche-private, ecc. Ho anche solo sfiorato il concetto di consenso decentralizzato, che è il cuore della rete blockchain.

Questa breve introduzione si basa sul post di Gerald Nash, che ha implementato la "più piccola blockchain" in Python. Io l’ho implementata in R e ho aggiunto la PoW di Daniel van Flymen.

Per approfondire l’argomento blockchain ti consiglio l’originale e brillante white paper su Bitcoin di Satoshi Nakamoto e il post di BigData Doc.

Se hai commenti o risposte a questo post, scrivimi su Twitter: mi trovi su @jj_mllr o dai un’occhiata a @CorrelAid, una rete di giovani data analyst che vuole cambiare il mondo con un approccio ai dati più inclusivo, integrato e innovativo.