Introduzindo o “blockchain” com python

Olá galera, estamos voltando com mais um diário de bordo, hoje o assunto é sobre “blockchain”, o que é, como funciona e por fim um exemplo prático de como criar um “blockchain”(cadeia de blocos) simples em python.

Quando falamos de blockchain, você lembra logo de criptomoedas e tem alguns que acaba pensando ser apenas sobre Bitcoin, segundo o Felipe Pontes "Blockchain é o conceito base de toda criptomoeda, mas não é limitado a esse escopo e pode ser aplicado de diversas maneiras."

Como funciona?

A blockchain significa cadeia de blocos, logo ela é feita de vários blocos formando uma cadeia, um bloco normalmente ele é composto por: uma data, um índice, algum dado(pode ser uma mensagem, um array de dados, etc.) e o hash do bloco anterior.

Entretanto, para que o blockchain fique seguro, temos que criptografa-los, no exemplo que iremos trabalhar, vamos utilizar o sha256 da biblioteca padrão hashlib, com ele criará uma string com 64 caracteres. Por fim, podemos dizer que o blockchain será uma lista de hashes.

Para isso, como o nosso bloco é feito de hashs, eles precisam ser validos. Neste exemplo, para vemos se o mesmo é valido, vamos dizer que ele tem que começar com quatro "0", no caso, "0000xyz". Está validação é chamada de difficulty(dificuldade), quanto maior a dificuldade, mais tempo terá para encontrar o hash valido. Caso o hash não seja valido de primeira, temos que achar uma forma de mudar, consegui um hash diferente, não é mesmo?

Sabemos que o hash, ele sempre utiliza o mesmo dado, resultando no mesmo hash, para isso mudar, usamos o nonce, o mesmo nada mais é que um valor arbitrário, um número simples que será incrementado no decorrer do processo sempre que um hash não for valido.

Como você reparou, todo bloco tem o hash do bloco anterior, mas o primeiro bloco como fica? Chamamos o primeiro bloco de gêneses, pois ele é o primeiro bloco da cadeia, onde não existe o hash anterior, para isso basta criar um valor arbitrário que irá representar o hash do bloco anterior.

Blockchain, na prática

Sabe o que vamos precisar? Então, esses são os topicos:

Construir a blockchain
Criptografar os blocos
Checar a validade de um hash
Recuperar hash anterior
Adicionar um novo bloco

Neste exemplo, iremos ter dois arquivos: blockchain.py e main.py.

Vamos primeiro criando o arquivo blockchain.py nele iniciaremos implementando a class e importando as libs que iremos utilizar:

from hashlib import sha256
from datetime import datetime


class Blockchain:
     pass

Agora você cria o construtor e nele vamos inicializar uma lista, que será a nossa cadeia de blocos e o nosso bloco gêneses:

def __init__(self):
        self.blocks = []
        self.set_genesis_block()

Feito isso, agora iremos implementar a função "self.set_genesis_block()" onde você vai iniciar o seu bloco gênesis, nele vamos precisar: dos dados, o timestamp para ter a data e hora do momento, o hash anterior que iremos implementar um valor arbitrário, o índice(posição do bloco na cadeia) e por fim a criptografia dele.

def set_genesis_block(self):
        data = 'Hello, World!'
        timestamp = datetime.utcnow().timestamp()
        prev_hash = 0
        index = 0
        self.hash_block(data, timestamp, prev_hash, index)

Para implementar a função "self.hash_block", vamos precisar criar uma estrutura de repetição e implementar o hash do bloco, verificando se ele já é valido antes de adicionar na cadeia de blocos.

def hash_block(self, data, timestamp, prev_hash, index):
        hash = ''
        nonce = 1

        while not self.is_hash_valid(hash):
            block = f'{data}:{timestamp}:{prev_hash}:{index}:{nonce}'
            hash = sha256(block.encode()).hexdigest()
            nonce += 1

        print('[nonce]', nonce)
        self.blocks.append(hash)

A função "self.is_hash_valid" ela é bem simples a implementação dela:

def is_hash_valid(self, hash):
        return hash.startswith('0000')

Contudo, visto que já criamos o bloco gênesis e a função que valida se o bloco é valido, só precisamos agora, criar mais três funções a "get_last_hash" que pega o hash do bloco anterior, o "add_new_block" que serve para adicionar um novo bloco na cadeia e por fim, o "get_all_blocks" para obter a cadeia completa.

def get_last_hash(self):
        return self.blocks[-1]

def add_new_block(self, data):
        index = len(self.blocks)
        prev_hash = self.get_last_hash()
        timestamp = datetime.utcnow().timestamp()
        self.hash_block(data, timestamp, prev_hash, index)

def get_all_blocks(self):
        return self.blocks[:]

Para finalizamos este exemplo, precisamos criar o arquivo main.py que será o arquivo principal de execução, nele vamos importar o arquivo que acabamos de criar, e adicionar três blocos como teste e por fim mostrar a cadeia de blocos

main.py

from blockchain import Blockchain


if __name__ == '__main__':
    blockchain = Blockchain()

    blockchain.add_new_block('Block First!')
    blockchain.add_new_block('Blockchain is very nice!')
    blockchain.add_new_block('Speak some languages ?')

    print(blockchain.get_all_blocks())

Com isso, finalizamos o artigo de hoje, com este exemplo incrível, onde aprendemos o que é blockchain, como ele funciona e como criar um exemplo simples e prático. Estou deixando o link do repositório do github sobre este exemplo na referência.

Este foi o diário de bordo #09 vamos nos despedindo por aqui. Voltaremos com mais um diário de bordo.