Há muito tempo tenho vontade de criar um tutorial. No entanto, sempre tive um certo pudor, além do receio de ser (percebido como) apenas mais um.

Sempre estabeleci como condição para um tutorial que o assunto tratado fosse realmente relevante e original. Agora, finalmente, surge a oportunidade de desenvolver um tutorial original sobre esse sistema importante, ainda pouco compreendido, mas cada vez mais presente na realidade do mundo moderno.

A mídia fala constantemente sobre blockchain e seus derivados — como as criptomoedas e os contratos inteligentes mas, para muitos, incluindo colegas de profissão, esses conceitos ainda são envoltos em uma névoa de imprecisão, quando não de total confusão. Este guia tem como objetivo destacar o aspecto concreto dessas tecnologias, trazendo à tona sua implementação real por meio de código, e mostrando, na prática, como interagir com elas dentro do ambiente computacional.

Neste tutorial uso a linguagem Go, tanto pela simplicidade como por seu uso crescente nos projetos voltados à Blockchain. Qualquer LLM poderá refatorar o código facilmente para qualquer outra linguagem, como Python.

O que é uma Blockchain?

O termo “blockchain” vem da junção das palavras em inglês block (bloco) e chain (cadeia), e descreve exatamente o que ela é: uma cadeia de blocos ligados entre si, onde cada bloco contém um conjunto de dados, um carimbo de data/hora (timestamp), e um hash que o conecta ao bloco anterior. Essa estrutura torna os dados praticamente imutáveis, sendo largamente usada para garantir transparência e segurança em ambientes descentralizados.

Um Pouco de História

A ideia de encadear blocos usando hashes não surgiu com o Bitcoin. Já em 1991, Stuart Haber e W. Scott Stornetta propuseram um sistema computacional para armazenar documentos com carimbos de tempo de forma segura — sem possibilidade de adulteração. Esse trabalho é considerado uma das raízes da blockchain moderna. Foi somente em 2008 que Satoshi Nakamoto uniu essa ideia com o conceito de dinheiro digital, criando o Bitcoin e, com ele, a blockchain como a conhecemos hoje.

Conceitos-chave para Entender

🧩 Bloco

Cada bloco é como uma página em um livro-razão digital. Ele possui:

• Carimbo de data/hora (T1, T2, T3…): Indica quando o bloco foi criado.
• Hash do bloco anterior (PreHash): Uma “impressão digital” do bloco anterior, que o conecta à cadeia.
• Hash atual (Root Hash): Calculado com base no conteúdo do bloco e serve para garantir sua integridade.
• Dados: Pode conter qualquer informação — transações financeiras, contratos, documentos, etc.

Como se vê, o hash do bloco anterior se liga ao hash atual, conectando a cadeia. Se qualquer informação em um bloco for alterada, seu hash muda. Isso quebra a cadeia, tornando evidente que houve uma tentativa de adulteração.

🔐 Hashing

Hashing é o processo de aplicar uma função criptográfica sobre um dado para obter uma sequência de caracteres (o hash). Um dos algoritmos mais usados é o SHA-256, criado pela NSA e adotado amplamente desde os anos 2000. Ele transforma qualquer entrada (como um texto ou número) em uma sequência hexadecimal de 64 caracteres. Pequenas mudanças no dado original geram hashes completamente diferentes — um princípio chamado efeito avalanche.

⛏️ Prova de Trabalho (Proof of Work)

A Prova de Trabalho surgiu para resolver o problema da confiança em redes descentralizadas, como no Bitcoin. Ela exige que os participantes gastem poder computacional para adicionar novos blocos, tornando ataques muito caros e, portanto, inviáveis. A ideia foi inspirada em sistemas anti-spam dos anos 90 (como o Hashcash de Adam Back), onde uma tarefa computacional dificultava o envio de emails em massa.

🛠️ Construindo uma Blockchain Simples em Go

Agora que (provavelmente) entendemos os conceitos, vamos ver como isso se traduz em código.

Etapa 1: Definir a Estrutura do Bloco

package main

import (
    "crypto/sha256"
    "fmt"
    "time"
)

type Block struct {
    Index     int
    Timestamp string
    Data      string
    PrevHash  string
    Hash      string
}

🧱 Aqui definimos os principais componentes do bloco. Veja que a estrutura lógica do bloco define todos os ítens (atributos) do bloco, como ilustrado na Fig 1. Ele é uma estrutura básica, mas com tudo o que precisamos para construir a cadeia.

Etapa 2: Criar o Bloco Gênesis

func createGenesisBlock() Block {
    return Block{
        Index:     0,
        Timestamp: time.Now().String(),
        Data:      "Genesis Block",
        PrevHash:  "",
        Hash:      calculateHash(0, "", "Genesis Block"),
    }
}

📜 O bloco gênesis é o primeiro bloco da blockchain. Ele é especial porque não possui um antecessor. No Bitcoin, ele foi minerado por Satoshi Nakamoto em 3 de janeiro de 2009. Uma curiosidade: sua mensagem de dados incluía o título de uma manchete de jornal daquele dia, uma crítica à crise bancária da época.

Etapa 3: Função de Hash

func calculateHash(index int, prevHash, data string) string {
    record := fmt.Sprintf("%d%s%s", index, prevHash, data)
    hash := sha256.New()
    hash.Write([]byte(record))
    return fmt.Sprintf("%x", hash.Sum(nil))
}

🔍 Essa função garante a integridade do bloco, produzindo um hash único com base nas suas informações. Isso é o que torna a blockchain resistente a modificações: se qualquer dado mudar, o hash será diferente.

Etapa 4: Criar a Blockchain

type Blockchain struct {
    Chain []Block
}

func (bc *Blockchain) addBlock(data string) {
    prevBlock := bc.Chain[len(bc.Chain)-1]
    newBlock := Block{
        Index:     prevBlock.Index + 1,
        Timestamp: time.Now().String(),
        Data:      data,
        PrevHash:  prevBlock.Hash,
        Hash:      calculateHash(prevBlock.Index+1, prevBlock.Hash, data),
    }
    bc.Chain = append(bc.Chain, newBlock)
}

🔗 Aqui a cadeia começa a tomar forma. Cada novo bloco contém o hash do anterior, criando a estrutura de “cadeia”.

Etapa 5: Iniciar e Usar a Blockchain

func main() {
    blockchain := Blockchain{}
    blockchain.Chain = append(blockchain.Chain, createGenesisBlock())

    blockchain.addBlock("Primeiro bloco depois do genesis")
    blockchain.addBlock("Segundo bloco depois do genesis")

    for _, block := range blockchain.Chain {
        fmt.Printf("Index: %d, Timestamp: %s, Data: %s, PrevHash: %s, Hash: %s\n",
            block.Index, block.Timestamp, block.Data, block.PrevHash, block.Hash)
    }
}

📤 A execução do código imprime cada bloco da cadeia, demonstrando como a estrutura vai se formando e se conectando.

Etapa 6: Saída Esperada

Index: 0, Timestamp: ..., Data: Genesis Block, PrevHash: , Hash: 6b3d...
Index: 1, Timestamp: ..., Data: Primeiro bloco depois do genesis, PrevHash: 6b3d..., Hash: 2c6e...
Index: 2, Timestamp: ..., Data: Segundo bloco depois do genesis, PrevHash: 2c6e..., Hash: 9c4a...

📊 Você verá blocos encadeados, com cada PrevHash correspondendo ao Hash do bloco anterior.

🧠 O que mais?

A blockchain construída acima é funcional, mas ainda simples. Você pode expandir com:

✅ Validação da Blockchain

func (bc *Blockchain) isValid() bool {
    for i := 1; i < len(bc.Chain); i++ {
        prevBlock := bc.Chain[i-1]
        block := bc.Chain[i]
        if block.PrevHash != prevBlock.Hash || block.Hash != calculateHash(block.Index, block.PrevHash, block.Data) {
            return false
        }
    }
    return true
}

🔎 Esta função verifica se a cadeia é válida. É um conceito essencial para detectar fraudes ou inconsistências em sistemas descentralizados.

🔨 Prova de Trabalho (Opcional)

Você pode implementar um campo nonce no bloco e ajustar o algoritmo de hash para que o resultado comece com, por exemplo, “0000”. Isso simula a mineração usada no Bitcoin, onde é preciso tentar milhões de combinações até encontrar um hash com a “dificuldade” exigida.

🌐 Descentralização

Até agora, nossa blockchain é local e centralizada. Em um projeto mais complexo, você pode usar:

• Go-Ethereum: Implementação oficial do Ethereum em Go.
• Gorilla Websocket: Para comunicação P2P entre nós (nodes).
• Go-Swagger: Para criar APIs REST que expõem a blockchain.

🎓 Conclusão da primeira parte

Construir uma blockchain do zero é uma excelente forma de aprender estruturas de dados, criptografia, segurança da informação e sistemas distribuídos. Começando com algo simples, você pode continuar a adicionar camadas de complexidade: provas de consenso, contratos inteligentes, persistência em disco, interfaces gráficas e muito mais.

Se você chegou até aqui você está mais perto de entender não só como a blockchain funciona, mas por que ela é revolucionária. Na segunda parte deste pequeno guia, vou mostrar a lógica estrutural de um contrato inteligente e como adicioná-lo à Blockchain.

Estou desenvolvendo um tutorial completo (e executável!) sobre o tema, que abrigarei em meu Github. Você pode acompanhar — e contribuir.