IMPLEMENTAÇÃO DE

BLOCKCHAIN
Protocolos de Consenso e Redes com Python

Relatório Técnico de Desenvolvimento

Modelagem de Blocos, Algoritmo Proof-of-Work e API Flask

Rio de Janeiro
2026
1 Introdução
O advento da tecnologia Blockchain introduziu um novo paradigma para o armazenamento
e transferência de informações de forma descentralizada. No seu nível mais fundamental,
uma blockchain é um registro digital imutável e distribuído. Este projeto detalha a cons-
trução de uma blockchain funcional utilizando Python, focando nos pilares de integridade
criptográfica e consenso distribuído.

2 Estrutura de Dados do Bloco

Cada bloco na corrente funciona como um recipiente para dados. Para garantir a segu-
rança, cada bloco deve conter o hash do bloco anterior, criando uma corrente matemática.
Se os dados de um bloco forem alterados, seu hash mudará, invalidando todos os blocos
subsequentes.
Os componentes essenciais de um bloco neste projeto são:

• Index: Identificador sequencial do bloco.

• Timestamp: Registro temporal da criação.

• Transactions: Lista de dados ou transferências incluídas.

• Proof (Nonce): O número resultante do esforço de mineração.

• Previous Hash: O elo criptográfico com o bloco antecessor.

2.1 A Função de Hash SHA-256

Utilizamos o algoritmo SHA-256 (Secure Hash Algorithm 256-bit). Ele gera uma assina-
tura digital de tamanho fixo a partir de qualquer entrada. Uma característica vital é a
resistência à colisão: é computacionalmente impossível encontrar duas entradas diferentes
que produzam o mesmo hash.

1
 3 Implementação em Python: O Core
A classe Blockchain gerencia a corrente, as transações pendentes e os métodos de vali-
dação. Abaixo, apresentamos a estrutura inicial da classe e a gestão de transações.
1 import hashlib
2 import json
3 from time import time
4
5 class Blockchain :
6 def __init__ ( self ) :
7 self . chain = []
8 self . c ur r e n t _ t r a n s a c t i o n s = []
9 # Criar o bloco Genesis
10 self . new_block ( previous_hash = ’1 ’ , proof =100)
11
12 def new_block ( self , proof , previous_hash = None ) :
13 block = {
14 ’ index ’: len ( self . chain ) + 1 ,
15 ’ timestamp ’: time () ,
16 ’ transactions ’: self . current_transactions ,
17 ’ proof ’: proof ,
18 ’ previous_hash ’: previous_hash or self . hash ( self . chain [ -1]) ,
19 }
20 self . cu r r e n t _ t r a n s a c t i o n s = []
21 self . chain . append ( block )
22 return block
23
24 def new_transaction ( self , sender , recipient , amount ) :
25 self . cu r r e n t _ t r a n s a c t i o n s . append ({
26 ’ sender ’: sender ,
27 ’ recipient ’: recipient ,
28 ’ amount ’: amount ,
29 })
30 return self . last_block [ ’ index ’] + 1
31
32 @staticmethod
33 def hash ( block ) :
34 block_string = json . dumps ( block , sort_keys = True ) . encode ()
35 return hashlib . sha256 ( block_string ) . hexdigest ()
36
37 @property
38 def last_block ( self ) :
39 return self . chain [ -1]
Listing 1: Definição da Classe Blockchain e Métodos de Bloco

2
 4 Mecanismo de Consenso: Proof-of-Work
O Proof-of-Work (PoW) é o mecanismo que impede ataques de spam e garante a segurança
da rede. Ele exige que o minerador resolva um problema matemático complexo para ter
o direito de adicionar um bloco à rede.

4.1 O Quebra-Cabeça Computacional

O desafio consiste em encontrar um número tal que o hash do bloco comece com uma
sequência específica de zeros. Neste projeto, definimos a dificuldade como 4 zeros iniciais
("0000").
1 def proof_of_work ( self , last_block ) :
2 last_proof = last_block [ ’ proof ’]
3 last_hash = self . hash ( last_block )
4
5 proof = 0
6 while self . valid_proof ( last_proof , proof , last_hash ) is False :
7 proof += 1
8 return proof
9
10 @staticmethod
11 def valid_proof ( last_proof , proof , last_hash ) :
12 guess = f ’{ last_proof }{ proof }{ last_hash } ’. encode ()
13 guess_hash = hashlib . sha256 ( guess ) . hexdigest ()
14 return guess_hash [:4] == " 0000 "
Listing 2: Implementação do Algoritmo Proof-of-Work
Este processo é assimétrico: encontrar o proof é difícil (exige milhares de iterações),
mas qualquer outro nó da rede pode validar o resultado instantaneamente com apenas
uma operação de hash.

3
 5 Interface de Rede e API
Para que a blockchain seja acessível, implementamos uma interface HTTP usando o Flask.
Isso permite que o nó receba transações e comandos de mineração remotamente.
1 from flask import Flask , jsonify , request
2 from uuid import uuid4
3
4 app = Flask ( __name__ )
5 node_identifier = str ( uuid4 () ) . replace ( ’ - ’ , ’ ’)
6 blockchain = Blockchain ()
7
8 @app . route ( ’/ mine ’ , methods =[ ’ GET ’ ])
9 def mine () :
10 last_block = blockchain . last_block
11 proof = blockchain . proof_of_work ( last_block )
12
13 blockchain . new_transaction ( sender = " 0 " , recipient = node_identifier ,
amount =1)
14
15 p_hash = blockchain . hash ( last_block )
16 block = blockchain . new_block ( proof , p_hash )
17
18 response = {
19 ’ message ’: " Novo Bloco Forjado " ,
20 ’ index ’: block [ ’ index ’] ,
21 ’ transactions ’: block [ ’ transactions ’] ,
22 ’ proof ’: block [ ’ proof ’] ,
23 ’ previous_hash ’: block [ ’ previous_hash ’] ,
24 }
25 return jsonify ( response ) , 200
26
27 @app . route ( ’/ chain ’ , methods =[ ’ GET ’ ])
28 def full_chain () :
29 return jsonify ({ ’ chain ’: blockchain . chain , ’ length ’: len ( blockchain .
chain ) }) , 200
30

31 if __name__ == ’ __main__ ’:
32 app . run ( host = ’ [Link] ’ , port =5000)
Listing 3: API Flask para Interação com o Nó

4
6 Guia de Execução
Para executar o projeto, siga os passos abaixo no terminal do sistema operacional:

1. Certifique-se de ter o Python 3.x instalado.

2. Instale a dependência do Flask: pip install Flask.

3. Execute o script: python seu_arquivo.py.

4. Utilize um navegador ou o curl para interagir:

• Ver a corrente: [Link]

• Minerar: [Link]

7 Conclusão
A implementação demonstrou a viabilidade de construir um sistema de registro distribuído
com poucas linhas de código em Python. Embora simplificada, esta estrutura contém
os fundamentos de segurança (SHA-256) e de controle de emissão (PoW) presentes em
tecnologias de escala global.

8 Trabalhos Futuros
Para uma versão de produção, seriam necessários protocolos de descoberta de nós P2P
(Peer-to-Peer ) e um sistema de resolução de conflitos baseado na regra da "Cadeia Mais
Longa", garantindo que todos os nós eventualmente convirjam para o mesmo estado da
blockchain, mesmo em condições de rede instáveis.