Entendendo blockchains programando uma em R

Todo mundo está falando de criptomoedas — muito por causa do hype em torno do Bitcoin. Mais interessante do que saber se existe uma bolha do Bitcoin é entender como essa tecnologia realmente funciona e do que ela é capaz. A história do Bitcoin começou com um whitepaper chamado "Bitcoin: A Peer-to-Peer Electronic Cash System" em 2008. Nesse documento, o autor com o pseudônimo Satoshi Nakamoto (ainda há muita discussão sobre quem Satoshi realmente é) apresenta uma tecnologia e uma ideia revolucionárias: uma moeda eletrônica descentralizada que roda sobre algo chamado blockchain. A ideia se espalhou a partir daí e hoje é aplicada em várias outras áreas.

Meu primeiro contato com blockchains foi em um encontro da BlockchainSociety em Oxford. Todo mundo lá parecia muito empolgado com o potencial dessa nova tecnologia. E, convenhamos, ela é mesmo intrigante: um banco de dados descentralizado e incorruptível de transações monetárias, contratos ou o que você quiser (por exemplo, urnas eletrônicas impossíveis de hackear). A promessa da blockchain para a comunidade cripto é que ela vai transformar indústrias inteiras ao revolucionar a confiança — a ponto de não precisarmos mais de terceiros como bancos ou advogados; bastaria o poder da criptografia.

Embora a ideia básica seja intuitiva, entender como as blockchains funcionam tecnicamente é um pouco mais difícil. Na semana passada, me deparei com este artigo no R-bloggers, em que o BigData Doc constrói uma blockchain inteiramente em R. Uma blockchain em R talvez não seja a coisa mais eficiente e prática do mundo, mas é uma ótima forma de entender os princípios de programação e criptografia por trás do conceito. Eu também queria entender melhor e, por isso, implementei uma versão menor da blockchain em R: "Se você consegue programar, você certamente entende".

O que é uma blockchain?

Imagine que seu objetivo é armazenar dados de forma segura. Para isso, você primeiro guarda os dados em um contêiner — que você chama de bloco. No caso do Bitcoin, cada bloco contém várias transações financeiras. Quando surgem novas transações (ou novos dados), um novo bloco é criado e adicionado aos anteriores para formar uma cadeia — a blockchain.

Vamos ver como as blockchains usam criptografia para se tornarem praticamente impossíveis de hackear.

1. Blocos

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

Antes de começar a construir a blockchain — isto é, encadear diferentes contêineres de dados — você precisa conhecer mais dois conceitos: hashing e algoritmos de prova de trabalho (Proof-of-Work).

2. Hash

Um hash ajuda a garantir a integridade de um bloco ao conectá-lo aos demais blocos da cadeia. Uma função de hash recebe algo como entrada e devolve uma saída criptografada única. Um exemplo seria o seguinte: você propõe a sua amiga um enigma — "Qual é o melhor programa de estatística: Stata ou R?" — e fornece a ela o hash da resposta correta: "71ec0b920622cf4358bbc21d6a8b41f903584808db53ec07a8aa79119304ce86". Agora ela pode verificar sozinha se acertou apenas inserindo sua resposta na função de hash (no seu caso, o algoritmo SHA256):

    library("digest")

    digest("Stata" ,"sha256") # primeira tentativa

    ## [1] "3ac273f00d52dc9caf89cbd71e73e5915229a588117ca3441630089409ddb7bc"

    digest("R", "sha256") # segunda tentativa

    ## [1] "71ec0b920622cf4358bbc21d6a8b41f903584808db53ec07a8aa79119304ce86"

E como isso ajuda?

Nesse caso, você não passa para a função de hash apenas as informações do bloco (índice, timestamp, dados), mas também o hash do bloco anterior. Isso significa que você só consegue calcular um hash válido se souber o hash do bloco anterior — que, por sua vez, foi criado usando o hash do bloco anterior a ele, e assim por diante. Isso cria uma cadeia sequencial e imutável de blocos. Se você alterasse um bloco depois, teria que recalcular todos os hashes dos blocos seguintes.

    #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. Prova de trabalho (Proof-of-Work)

Se há muita informação para armazenar na blockchain, será preciso criar muitos novos blocos. Em muitos casos, você quer controlar quantos novos blocos são criados. No caso das criptomoedas, por exemplo, as moedas perderiam valor se fosse possível criar uma quantidade infinita delas a cada segundo.

Por isso, adicionamos um algoritmo de "prova de trabalho" (PoW) que controla a dificuldade de criar um novo bloco. "Prova" quer dizer que o computador realizou uma certa quantidade de trabalho. Na prática, a ideia é gerar algo difícil de criar, mas fácil de verificar. Vou usar a seguinte "tarefa" como PoW: encontrar o próximo número divisível por 99 e também divisível pelo número de prova (proof) do último bloco.

    ### 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)
    }

Em blockchains como Bitcoin ou Ethereum, a criação de novos blocos é feita pelos chamados mineradores. Quando um novo bloco precisa ser criado, um problema computacional é enviado para a rede. O minerador que resolve o problema de PoW primeiro cria o novo bloco e é recompensado em Bitcoins (é assim que novos Bitcoins são gerados). Essa espécie de "loteria" para encontrar a prova correta garante que o poder de criar novos blocos seja descentralizado. Quando um novo bloco é minerado, ele é distribuído para todos, de modo que cada nó da rede tenha uma cópia da blockchain mais recente. A ideia de que a blockchain mais longa na rede (a que recebeu "mais trabalho") é a versão válida é chamada de "consenso descentralizado".

No caso do Bitcoin, o PoW envolve encontrar números que gerem hashes com uma certa quantidade de zeros à esquerda (a melhor explicação que encontrei é este vídeo do Savjee). Para compensar o aumento da capacidade computacional e o número variável de mineradores na rede, a dificuldade do PoW pode ser ajustada para manter o tempo de criação de um novo bloco em torno de dez minutos.

4. Adicionando novos blocos

Agora você já sabe como é um bloco, como os blocos são encadeados por hashes e como o ritmo de criação de novos blocos é regulado por PoWs. Vamos juntar tudo isso em uma função:

    #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)
    }

Antes de começar a montar a blockchain, você precisa iniciar a cadeia em algum lugar. Isso é feito com o chamado bloco Gênese (Genesis Block). Ele não contém dados e usa valores arbitrários de proof e de hash anterior (já que não há bloco anterior).

    # 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. Construindo a blockchain

Agora você pode começar a construir a blockchain. Comece pelo bloco Gênese e depois adicione alguns blocos usando um loop.

    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 você quiser adicionar muitos outros blocos, vai notar que o tempo aumenta cada vez mais. O motivo é que o número de proof cresce exponencialmente.

Para criptomoedas como o Bitcoin, isso seria um problema, pois o tempo de criação de um novo bloco deve ser mais ou menos constante (cerca de 10 minutos no caso do Bitcoin). Por isso, a dificuldade do PoW precisa ser ajustada continuamente para levar em conta o aumento da capacidade computacional e a variação no número de mineradores conectados em um dado momento.

Por fim, é assim que um bloco da sua cadeia fica:

    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"

Conclusão

Neste post, você criou a menor blockchain possível. A ideia principal foi mostrar como uma blockchain é estruturada e apresentar alguns dos conceitos centrais por trás dela. Entender a aplicação brilhante da criptografia ajuda a explicar por que tanta gente se empolga com as possibilidades da blockchain.

Para colocar uma blockchain em produção, é preciso muito mais trabalho: configurar uma API, criar carteiras (wallets), assinaturas digitais com pares de chaves pública e privada etc. Também só arranhei a superfície do conceito de consenso descentralizado, que é o coração de uma rede blockchain.

Esta breve introdução se baseia no post de Gerald Nash, que implementou a "tiniest blockchain" em Python. Eu a implementei em R e adicionei a prova de trabalho (PoW) inspirada em Daniel van Flymen.

Para se aprofundar mais no tema, recomendo o brilhante e original whitepaper do Bitcoin, de Satoshi Nakamoto, e o post do BigData Doc.

Se você tiver comentários ou respostas a este post, fique à vontade para falar comigo no Twitter: estou em @jj_mllr ou conheça o @CorrelAid, uma rede de jovens analistas de dados que quer mudar o mundo com uma abordagem mais inclusiva, integrada e inovadora à análise de dados.