Como construir um blockchain em Python?

Se você quer aprender como construir um blockchain, então você veio ao lugar certo. Vamos mergulhar fundo para aprender como você pode construir um blockchain em python.

Existem toneladas de artigos sobre o blockchain, mas nem todos falam sobre a construção de um blockchain do zero. Como desenvolvedor, as teorias são importantes, mas você também precisa criar um blockchain para entender o conceito por trás dele completamente.

A ideia central por trás dos blockchains é sua natureza descentralizada. Você ficará fascinado com o fato de como tudo funciona por dentro. Blockchain pode parecer simples, mas por dentro existem muitos protocolos e algoritmos que fazem isso acontecer. Vamos usar Python para criar um blockchain do zero.

Você também pode salvar o artigo e marcá-lo como “How to build our blockchain.” Acredite em mim; o artigo irá ajudá-lo a longo prazo.

Nunca ouviu falar do blockchain? Então confira o curso gratuito do 101Blockchain. Se você deseja avançar em sua carreira, confira o curso Certified Enterprise Blockchain, onde aprenderá como funciona o blockchain corporativo. Vamos começar.

Você é um iniciante no Blockchain? Inscreva-se no Blockchain Free Course e comece sua jornada Blockchain agora.

Como construir um blockchain

A melhor maneira de aprender qualquer coisa é aprender fazendo. Para ter certeza de que você está na mesma página que eu, vamos verificar os requisitos primeiro. Também descreveremos brevemente o blockchain para que ambos estejamos na mesma página.

Como construir um blockchain em Python

Requerimento

O requisito básico para seguir o guia é saber codificar. Se você nunca codificou em sua vida, então este guia não é para você. Eu recomendo verificar os vários cursos para iniciantes que estão disponíveis online. Eu recomendo EdX, Udacity e Coursera para a melhor experiência de aprendizado.

Você já é um programador? Então, você deve saber sobre o Python básico. Além disso, ajudará você a seguir o tutorial “Como construir um blockchain”.

Leia agora: Guia definitivo do Quorum Blockchain

Criamos o tutorial para que todos possam acompanhar. Então, se você não sabe e deseja aprender como construir um blockchain do zero, você está convidado a fazê-lo!

Se você não conhece Python, não se preocupe, pois é fácil de aprender. Confira o Documentação Python para começar.

Vamos usar Python 3.6+ para o tutorial. Se você decidir usar outras versões do Python, talvez seja necessário pesquisar mais para que o código funcione. Para fins de tutorial, recomendo instalar a versão que estou usando.

Por último, você também deve saber sobre HTTP – o protocolo que é usado para se comunicar entre duas partes na Internet.

Instalando Python usando pip

Você precisa instalar o Python usando pip. Você também precisa instalar a biblioteca Requests e Flask. Para fazer isso, basta executar o comando abaixo.

$ pip install Flask == 0.12.2 solicitações == 2.18.4

Se estiver usando o ambiente Windows, você pode ir diretamente para python.org para baixar a versão mais recente do Python.

Quanto a mim, baixei o Python 3.8.1 – a compilação mais recente no momento em que escrevi o tutorial.

Para o IDE, prefiro usar o PyCharm. Estou usando a edição da comunidade Python para o tutorial. Você é livre para usar qualquer IDE de sua escolha. Outra ótima alternativa é o Visual Studio Code – um ambiente de desenvolvimento integrado de código aberto gratuito.

A última ferramenta de que você vai precisar é o Postman – um cliente HTTP. Alternativamente, você também pode usar cURL.

Também recomendo instalar um ambiente virtual para criar um ambiente completamente diferente para o seu desenvolvimento. Você pode seguir este guia para configurá-lo corretamente.

Blockchain revisitado

Antes de construirmos o blockchain, precisamos atualizar nossa ideia de blockchain. Isso nos ajudará a permanecer na mesma página.

Blockchain é uma tecnologia de contabilidade distribuída em que os pares podem participar, interagir e executar transações sem a necessidade de uma entidade centralizada. Cada peer possui uma cópia do livro-razão, o que torna impossível para os hackers cometerem fraudes no sistema. Os principais recursos do blockchain incluem transparência, imutabilidade e segurança. Ele utiliza algoritmos avançados de criptomoeda para garantir a segurança dos dados. Além disso, para chegar a um consenso, uma rede blockchain utilizará algoritmos de consenso, como Prova de Trabalho, Prova de Participação e assim por diante.

Leia também: Blockchain para iniciantes: Guia de primeiros passos

Primeiros passos com a construção de um blockchain

Com todas as instalações de pré-requisito feitas, agora estamos prontos para começar com nosso tutorial, “Como construir um blockchain.”

Para começar, você precisa criar um arquivo blockchain.py.

1. Criação de Blockchain

A primeira etapa é fazer uma solução de blockchain funcional. Primeiramente, precisamos criar uma classe Blockchain. Lá, criaremos um construtor que iniciará a cadeia e a lista de transações. A lista da cadeia armazenará nosso blockchain, enquanto as transações serão armazenadas na matriz current_transacations.

def __init __ (self): self.chain = [] self.current_transactions = []

Em seguida, precisamos criar uma função new_block que será usada para criar novos blocos e, em seguida, adicioná-los à cadeia existente. O código para a função new_block é o seguinte:

def new_block (self): #Esta função cria novos blocos e, em seguida, adiciona ao passe de cadeia existente

O método new_transcaction irá criar uma nova transação e então adicionar a transação à lista de transações já existente.

def new_transaction (self): #Esta função adiciona uma nova transação à passagem de transações já existentes. Também temos uma função hash que é usada para criar o hash para um bloco. @staticmethod def hash (block): #Usado para fazer o hash de um bloco

A última função que vamos criar é last_block. É usado para chamar o último bloco da cadeia.

Também podemos criar mais três funções aqui.

  • register_node () → Para registrar um novo nó e adicioná-lo à rede
  • valid_proof () → Irá garantir que o tempo que um bloco enviado para a cadeia resolve o problema
  • valid_chain () → Isto irá verificar se os blocos subsequentes na cadeia são válidos ou não.

O blueprint para o blockchain.py se parece com o abaixo.

class Blockchain (objeto): def __init __ (self): self.chain = [] self.current_transactions = [] def new_block (self): #Esta função cria novos blocos e, em seguida, adiciona à passagem de cadeia existente def new_transaction (self): #Esta função adiciona uma nova transação para transações já existentes passar @staticmethod def hash (bloco): #Usado para fazer hash de um bloco @property def last_block (self): # Chama e retorna o último bloco da passagem da cadeia

A classe Blockchain gerencia toda a cadeia. As definições definidas na classe gerenciam as diferentes ações dentro do blockchain.

Vamos examinar cada um dos métodos abaixo.

Leia agora: O que é fragmentação de blockchain: uma introdução a uma solução de dimensionamento de blockchain

Estrutura de um bloco

Um bloco contém informações vitais sobre transações e cadeias. Qualquer bloco na cadeia conterá as seguintes informações

  • índice
  • carimbo de data / hora em tempo Unix
  • lista de transações
  • prova
  • Hash do bloco anterior

A maioria das informações dentro do bloco são autoexplicativas. Aqui, as duas variáveis ​​cruciais são o previous_hash, que contém o valor do hash do bloco anterior. Isso é importante porque garante que o blockchain seja imutável e nenhum agente malicioso possa atualizar, excluir ou adicionar quaisquer dados à cadeia.

Leia agora: Por que o Blockchain mudará o mundo?

Adicionando Transação a um Bloco

Com a estrutura do bloco compreendida, vamos agora aprender como adicionar uma transação ao bloco. O código para isso é o seguinte.

def new_transaction (self): #Esta função adiciona uma nova transação a transações já existentes """Isso criará uma nova transação que será enviada para o próximo bloco. Ele conterá três variáveis, incluindo remetente, destinatário e montante """ self.current_transactions.append ({‘remetente’: remetente, ‘destinatário’: destinatário ‘quantia’: quantia,}) return self.last_block [‘índice’] + 1 Como você pode ver, ele simplesmente anexa a lista current_transaction com um objeto que contém três variáveis ​​→ remetente, destinatário, quantidade.

Uma vez que a adição é feita, o método então envia o índice do bloco para a cadeia. É o próximo bloco que vai ser minerado.

Criação de novos blocos

Antes de começarmos a criar novos blocos, precisamos criar o bloco genesis. Para fazer isso, precisamos usar uma linha simples de código conforme abaixo.

self.new_block (anterior_hash = 1, prova = 100)

Esta linha deve ser adicionada à sua classe Blockchain.

Para o método new_block (), você precisa enviar duas variáveis ​​como seus parâmetros. Inclui prova e anterior_hash.

Agora, vamos dar uma olhada no método new_block () abaixo.

def new_block (self, proof, previous_hash = None): #Esta função cria novos blocos e, em seguida, adiciona à cadeia existente """Este método conterá dois parâmetros de prova, hash anterior""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash or self.hash (self.chain [-1]),}

# Defina a lista de transações atuais como vazia.

   self.current_transactions = [] self.chain.append (bloquear) bloco de retorno

Vamos explicar o código do new_block. Criamos uma lista de blocos que contém os três parâmetros importantes. Depois de definidos, também escrevemos o código para redefinir a lista current_transaction e, em seguida, anexar o bloco à cadeia. O método new_block, quando chamado, retorna o bloco.

Leia agora: Guia para iniciantes: O que é Ethereum Classic?

Vamos também definir o método last_block abaixo.

@propriedade

def last_block (self):

# Chama e retorna o último bloco da cadeia

return self.chain [-1]

Além disso, o código para o método hash () é o seguinte:

def hash (bloco): # Usado para hash de um bloco """O código a seguir criará um hash de bloco SHA-256 e também garantirá que o dicionário seja ordenado""" block_string = json.dumps (block, sort_keys = True) .encode () return hashlib.sha256 (block_string) .hexdigest () Se você combinar todo o código até agora, teremos o seguinte blockchain.py. Confira abaixo.

class Blockchain (objeto): def __init __ (self): self.chain = [] self.current_transactions = [] self.new_block (previous_hash = 1, proof = 100) def new_block (self, proof, previous_hash = None): #This função cria novos blocos e, em seguida, adiciona à cadeia existente """Este método conterá dois parâmetros de prova, hash anterior""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash or self.hash (self.chain [-1]),} # Set a lista de transações atuais para esvaziar. self.current_transactions = [] self.chain.append (block) bloco de retorno def new_transaction (self): #Esta função adiciona uma nova transação às transações já existentes """Isso criará uma nova transação que será enviada para o próximo bloco. Ele conterá três variáveis, incluindo remetente, destinatário e quantidade """ self.current_transactions.append ({‘remetente’: remetente, ‘destinatário’: destinatário, ‘quantia’: quantia,}) return self.last_block [‘índice’] + 1 @staticmethod def hash (bloquear): #Usado para hash um bloco """O código a seguir criará um hash de bloco SHA-256 e também garantirá que o dicionário seja ordenado""" block_string = json.dumps (block, sort_keys = True) .encode () return hashlib.sha256 (block_string) .hexdigest () @property def last_block (self): # Chama e retorna o último bloco da cadeia return self.chain [ -1]

Prova de Implementação de Trabalho

Nossa próxima etapa na construção de blockchain.py é a implementação da Prova de Trabalho.

Então, o que é Prova de Trabalho? É um método de consenso utilizado para adicionar novos blocos à cadeia. Isso representa um desafio para o minerador e, uma vez que o minerador resolva o problema, o bloco é verificado. O mineiro, em troca, recebe uma recompensa com base na complexidade do problema.

A prova de trabalho do Bitcoin é conhecida como Hashcash. Ele garante que o consenso da rede bitcoin funcione conforme o pretendido.

Leia também: Algoritmos de consenso: a raiz da tecnologia Blockchain

Vamos definir o método proof_of_work (). O método fará parte da classe Blockchain.

def proof_of_work (self, last_proof): """Este método é onde o algoritmo de consenso é implementado. Leva dois parâmetros, incluindo self e last_proof""" prova = 0 enquanto self.valid_proof (last_proof, prova) é False: prova + = 1 retorno prova @staticmethod def valid_proof (last_proof, prova): """Este método valida o bloco""" suposição = f ‘{última_prova} {prova}’. encode () suposição_hash = hashlib.sha256 (suposição) .hexigest () retorno suposição_hash [: 4] == "0000"

O primeiro método proof_of_work é simples; ele simplesmente define proof como 0 e então executa um loop while para executar o método valid_proof. Se for falso, adicione um à prova.

Você pode aumentar a dificuldade do hash adicionando mais zeros.

Isso nos leva ao final do nosso Blockchain.py. Nosso código fica como abaixo.

classe Blockchain (objeto): def __init __ (self): self.chain = [] self.current_transactions = [] self.new_block (previous_hash = 1, proof = 100) def proof_of_work (self, last_proof): """Este método é onde o algoritmo de consenso é implementado. Leva dois parâmetros, incluindo self e last_proof""" prova = 0 enquanto self.valid_proof (last_proof, prova) é False: prova + = 1 retorno prova @staticmethod def valid_proof (last_proof, prova): """Este método valida o bloco""" suposição = f ‘{última_prova} {prova}’. encode () suposição_hash = hashlib.sha256 (suposição) .hexigest () retorno suposição_hash [: 4] == "0000" def new_block (self, proof, previous_hash = None): #Esta função cria novos blocos e, em seguida, adiciona à cadeia existente """Este método conterá dois parâmetros de prova, hash anterior""" block = {‘index’: len (self.chain) + 1, ‘timestamp’: time (), ‘proof’: proof, previous_hash: previous_hash or self.hash (self.chain [-1]),} # Set a lista de transações atuais para esvaziar. self.current_transactions = [] self.chain.append (block) bloco de retorno def new_transaction (self): #Esta função adiciona uma nova transação às transações já existentes """Isso criará uma nova transação que será enviada para o próximo bloco. Ele conterá três variáveis, incluindo remetente, destinatário e quantidade """ self.current_transactions.append ({‘remetente’: remetente, ‘destinatário’: destinatário, ‘quantia’: quantia,})

return self.last_block [‘index’] + 1

@staticmethod

def hash (bloquear):

#Usado para fazer hash de um bloco

“” ”O código a seguir criará um hash de bloco SHA-256 e também garantirá que o dicionário seja ordenado” ””

block_string = json.dumps (block, sort_keys = True) .encode ()

return hashlib.sha256 (block_string) .hexdigest ()

@propriedade

def last_block (self):

# Chama e retorna o último bloco da cadeia

return self.chain [-1]

2. Integração API

Ótimo, criamos um blockchain que funciona! Agora, para usá-lo de forma eficaz, precisamos criar uma API (Interface de Programação de Aplicativo).

Para fazer isso, vamos usar o popular Python Framework: Flask.

Flask é uma microestrutura, o que significa que é leve e você pode adicionar as bibliotecas de que precisa. Ele também permite que você crie um ponto final de função Python facilmente.

Para criar APIs, primeiro precisamos garantir que nosso blockchain possa aceitar solicitações por HTTP. Para fazer isso, temos que criar mais métodos.

Agora, vamos modificar o blockchain.py.

# Criando o nó do aplicativo app = Flask (__ name__) node_identifier = str (uuid4 ()). Replace (‘-‘, ”) # Inicializando blockchain blockchain = Blockchain () @ app.route (‘/ mine’, methods = [ ‘GET’]) def mine (): return "Minerando um novo bloco" @ app.route (‘/ transactions / new’, methods = [‘POST’]) def new_transaction (): return "Adicionando uma nova transação" @ app.router (‘/ chain’, methods = [‘GET’]) def full_chain (): response = {‘chain’: blockchain.chain, ‘length’: len (blockchain.chain)} return jsonify (resposta) , 200 se __name__ == ‘__main__’: app.run (host ="0.0.0.0", porta = 5000)

O código é autoexplicativo em sua maior parte. Primeiro, fazemos uma iniciação de nó. Em seguida, criamos um nó aleatório. Uma vez feito isso, inicializamos nossa classe Blockchain. Uma vez feito isso, precisamos criar três endpoints conforme abaixo.

  • / meu endpoint
  • / transações / novo endpoint
  • / ponto final da cadeia

Finalmente, rodamos o servidor na porta 5000.

O aplicativo está quase criado. Tudo o que precisamos fazer é criar o método de classe de transações.

@ app.route (‘/ transactions / new’, methods = [‘POST’]) def new_transaction (): values ​​= request.get_json () # Verificar se os dados necessários estão lá ou não necessários = [‘remetente’, ‘ destinatário ‘,’ quantia ‘] se não todos (k em valores para k é obrigatório): retornar’ Valores ausentes ‘, 400 # criando uma nova transação index = blockchain.new_transaction (valores [‘ remetente ‘], valores [‘ destinatário ‘ , values ​​[‘amount’]]) response = {‘message’: f’Transaction está agendada para ser adicionada ao Bloco No. {index} ‘} return jsonify (response), 201

Leia também: Aqui está o que você precisa saber sobre a prova de trabalho do Blockchain

Extremidade de mineração

O último endpoint que iremos criar é o endpoint de mineração. Para fazer isso, temos que nos certificar de que ele faz as seguintes três coisas.

  • Cálculo da Prova de Trabalho
  • Forjar um novo blockchain e, em seguida, adicioná-lo à cadeia
  • Recompense o mineiro por seu trabalho

@ app.route (‘/ mine’, methods = [‘GET’]) def mine (): """Aqui fazemos o algoritmo de prova de trabalho funcionar""" last_block = blockchain.last_block last_proof = last_block [‘proof’] proof = blockchain.proof_of_work (last_proof) # recompensando o minerador por sua contribuição. 0 especifica que a nova moeda foi extraída blockchain.new_transaction (sender ="0", destinatário = node_identifier, amount = 1,) # agora crie o novo bloco e adicione-o à cadeia previous_hash = blockchain.hash (last_block) block = blockchain.new_block (prova, previous_hash) response = {‘message’: ‘O novo bloco foi forjado ‘,’ índice ‘: bloco [‘ índice ‘],’ transações ‘: bloco [‘ transações ‘],’ prova ‘: bloco [‘ prova ‘],’ anterior_hash ‘: bloco [‘ anterior_hash ‘]} retorno jsonify (resposta), 200

Leia agora: Guia para iniciantes: o que é AION? Rede Blockchain de Primeira Geração Mundial

3. Interação Blockchain

A última etapa é interagir com o blockchain. Vamos usar o Postman para interagir com a rede blockchain usando a API que acabamos de criar.

Execute o código abaixo no console Python

python blockchain.py

Conclusão

Isso nos leva ao final de nosso How to build a blockchain. Espero que as etapas e códigos acima ajudem você a construir um Blockchain em Python. Portanto, se você é um novato e deseja construir uma carreira no Blockchain, sugerimos que comece sua carreira no Blockchain com nosso Curso Básico Gratuito do Blockchain. Escolha-nos como seu parceiro de estudo e nós o teremos até que você não consiga o emprego dos seus sonhos.

Então, o que você acha sobre o blockchain e sua implementação? Comente abaixo e deixe-nos saber.