DEV Community: Victor Lins

Construindo uma Blockchain em Kotlin

Victor Lins — Tue, 31 May 2022 10:57:12 +0000

1. Visão geral

Blockchain é um livro-razão distribuído e imutável que facilita o processo de registro de transações e o rastreamento de ativos em uma rede empresarial. Um ativo pode ser tangível (uma casa, um carro, dinheiro, terras) ou intangível (propriedade intelectual, patentes, direitos autorais e criação de marcas) [1].

O objetivo desse artigo é que, ao construímos uma blockchain simples em Kotlin, tenhamos uma melhor compreensão de:

Como uma blockchain funciona;
Como funções hash e árvores de Merkle são utilizadas para manter e garantir a integridade da blockchain;
Como algoritmos de criptografia assimétrica e assinatura digital são usados para implementar importantes features relacionadas à integridade, confidencialidade e autenticidade dos dados armazenados.
Como o mecanismo de consenso chamado de Prova de trabalho (Proof-of-Work) funciona e como ele é utilizado no processo de mineração de novos blocos e mitigação de ataques de 51%;
Como expor as funcionalidades de uma blockchain através de uma API HTTP escrita em Kotlin e Ktor.

Redes P2P (peer-to-peer) são um componente chave usado pela tecnologia blockchain para tornar a rede descentralizada. Porém, para manter este artigo não tão extenso, discutiremos sobre o assunto em uma futura publicação.

Iniciaremos apresentando importantes conceitos e, em seguida, implementaremos uma blockchain em um contexto de criptomoedas.

É importante pontuar que esta não será uma blockchain totalmente funcional e pronta para produção. Esta é uma implementação para fins educacionais, para ajudá-lo a entender como funciona uma blockchain e que servirá de base para futuras publicações.

O código fonte completo está disponível no GitHub.

1.1. Funções Hash

Uma função hash é um algoritmo que mapeia dados de comprimento variável para dados de comprimento fixo. Em geral, um hash é representado em base hexadecimal [2].

Funções hash possuem características como:

Ser determinista: Um procedimento de hash deve ser determinístico - o que significa que, para um determinado valor de entrada, ele deve sempre gerar o mesmo valor de hash;
Ser computacionalmente eficiente: Deve ser rápido calcular o valor de hash para qualquer entrada;
Ser unidirecional: Não deve ser possível reverter um valor hash para obter a entrada original;
Ser resistente à colisão: Deve ser computacionalmente difícil encontrar duas entradas diferentes de qualquer tamanho que resultem no mesmo hash;

Em blockchain, funções hash são usadas em processos de:

Verificação de integridade dos dados;
Assinaturas digitais;
Mecanismo de consenso por Prova de trabalho (Proof-of-Work);

1.2. Árvores de Merkle

Árvores de Merkle são um tipo de estrutura no qual cada nó não folha da árvore contém valores de hash de seus próprios nós filhos. Desta maneira, a raiz é o hash de todos os dados contidos nas folhas [3].

Árvores de Merkle podem ser usadas para proteger qualquer tipo de dados armazenados, manuseados e transferidos dentro e entre computadores. Em blockchain, as árvores de Merkle podem ser utilizadas para garantir que blocos de dados recebidos de outros pares em uma rede P2P são recebidos intactos e inalterados, e até mesmo para verificar se os outros pares não mentem e enviam blocos falsos [4].

Árvore de Merkle binária:

1.3. Criptografia assimétrica

A criptografia assimétrica (conhecida como criptografia de chave pública) é um ramo da criptografia onde uma chave secreta pode ser dividida em duas partes, uma chave pública e uma chave privada. A chave pública pode ser dada a qualquer pessoa, confiável ou não, enquanto a chave privada deve ser mantida em segredo (assim como a chave na criptografia simétrica). A criptografia assimétrica tem dois casos de uso principais: confidencialidade e autenticação [5].

A imagem abaixo representa o processo de transmissão de uma mensagem com confidencialidade. Em primeiro lugar, o remetente criptografa a mensagem com a chave pública do destinatário, o remetente pode então enviar a mensagem (criptografada) com segurança. O destinatário então recebe a mensagem e pode descriptografá-la usando sua chave privada.

1.4. Assinatura digital

Ao usar criptografia assimétrica, as mensagens podem ser assinadas com uma chave privada e, em seguida, qualquer pessoa com a chave pública pode verificar se a mensagem foi criada por alguém que possui a chave privada correspondente. Isso pode ser combinado com um sistema de prova de identidade para saber qual entidade (pessoa ou grupo) realmente possui essa chave privada, fornecendo autenticação [5].

1.5. Blocos

O nome blockchain vem do fato de que os dados são armazenados em blocos, e cada bloco é conectado ao bloco anterior, formando uma estrutura em cadeia. Com a tecnologia blockchain, você só pode adicionar (anexar) novos blocos à blockchain. Você não pode modificar ou excluir qualquer bloco depois que ele for adicionado à blockchain [6].

De forma simplificada, um bloco é composto pelas seguintes propriedades:

Previous Hash: Hash de bloco anterior;
Transactions: Lista de transações incluídas no bloco;
Timestamp: Momento em que o bloco foi gerado;
Nonce: Número arbitrário que os mineradores devem encontrar - essencialmente adivinhar - para produzir um hash dentro de um conjunto de hashes válidos. Esse processo faz parte do mecanismo de consenso por prova de trabalho (PoW), que iremos entender durante o andamento desse artigo;
Hash: Um hash calculado a partir do conteúdo do bloco;

1.5.1. Hash do bloco

O hash do bloco é uma das propriedades mais importantes do bloco. Ele é calculado a partir de todos os dados do bloco. Isso significa que, se algo no bloco mudar, o hash original não será mais válido.

O hash do bloco também pode ser pensado como o identificador exclusivo do bloco. Usamos hashes de bloco para preservar a sua integridade e referenciar explicitamente o bloco anterior.

Com isso, quanto mais profundo o bloco estiver na blockchain, mais difícil será modificá-lo, pois exigiria modificações em cada bloco consecutivo.

1.5.2. Bloco Genesis

O bloco genesis é o primeiro bloco de uma blockchain. É a base na qual os próximos blocos serão adicionados para formar uma cadeia de blocos.

Cada bloco em uma blockchain armazena uma referência ao bloco anterior. No caso do Bloco Genesis, não há bloco anterior para referência.

1.6. Mecanismo de consenso por Prova de trabalho (Proof-of-Work)

Mecanismos de consenso (também conhecidos como protocolos de consenso ou algoritmos de consenso) permitem que sistemas distribuídos (redes de computadores) trabalhem em conjunto, cheguem a um consenso sobre o estado da rede e permaneçam seguros.

1.6.1 Mineração de novos blocos

Em blockchain, prova de trabalho é o algoritmo que define a dificuldade e as regras para o trabalho que os mineradores fazem. A mineração é o ato de adicionar blocos válidos (que inclui garantir que todas as transações presentes no bloco são válidas) à cadeia.

A prova de trabalho exige que os mineradores passem por uma intensa corrida de tentativa e erro para encontrar o "nonce" para um bloco através da realização de uma ampla gama de funções de hash com diferentes valores de "nonce".

O algoritmo de consenso de prova de trabalho define um bloco válido como aquele cujo valor de hash é menor que um determinado limite. A dificuldade determina o alvo para o hash. Quanto menor o alvo, menor o conjunto de hashes válidos.

Essa prova (desafio criptográfico) exige que os mineradores encontrem um resultado de uma função hash dentro desse conjunto de hashes válidos, que é computacionalmente difícil (mas factível) de ser descoberto, porém é facilmente verificável por ele e pelos demais mineradores e clientes da rede [7] [8].

O vencedor dessa corrida compartilha o novo bloco com o resto da rede e é recompensando pelo seu trabalho.

Em um contexto de criptomoedas, a recompensa é feita através da geração de novas moedas, que são transferidas para o minerador do bloco.

1.6.2 Segurança e consenso

Blockchains dependem de uma única fonte de verdade. E os utilizadores escolherão sempre a cadeia mais longa. A maior cadeia é aceita como válida pois ela teve o maior trabalho computacional realizado.

Quanto mais "trabalho" for feito, quanto maior a cadeia e quanto maior o número do bloco, mais certeza a rede pode ter do estado atual das coisas.

Para criar blocos maliciosos, ainda que válidos, o atacante precisaria de mais de 51% do poder de mineração da rede para superar todos os demais mineradores. Seria preciso muito poder computacional para poder executar essa quantidade de "trabalho" [7].

1.7. Transações

Em criptomoedas como o Bitcoin, as transações são compostas por dois componentes: entradas (inputs) e saídas (outputs).

Uma transação é, essencialmente, uma transferência de valor.

As entradas fornecem uma prova da origem dos valores transferidos e que são de propriedade do "remetente". As entradas sempre se referem a uma saída existente de uma transação anterior. As transações gastam saídas de transações anteriores e geram novas saídas que podem ser gastas por transações no futuro.

Assim como na estrutura do bloco, também iremos registrar o momento em que a transação foi criada e ter um identificador exclusivo (hash) dessa transação, que também garantirá sua integridade.

Com isso, uma transação pode ser representada pelas seguintes propriedades:

Inputs: Lista de entradas da transação;
Outputs: Lista de saídas da transação;
Timestamp: Momento em que a transação foi criada;
Hash: Um hash calculado a partir do conteúdo da transação;

2. Implementação em Kotlin

Após o entendimento de todos esses conceitos, chegou o momento de iniciarmos a nossa implementação em Kotlin.

IDE utilizada: IntelliJ IDEA 2022.1 (Community Edition)

Versão do Kotlin: 1.6.20

2.1. Função Hash

Assim como o Bitcoin, usaremos o algoritmo criptográfico SHA-256 para o cálculo de hash. Podemos implementá-lo em Kotlin através de uma extensão da classe String da seguinte forma:

2.2. Criptografia assimétrica e assinatura digital

A criptografia de curva elíptica (ECC) é uma técnica de criptografia assimétrica baseada na teoria da curva elíptica que pode ser usada para criar chaves criptográficas mais rápidas, menores e mais eficientes [9].

O ECC é uma alternativa ao algoritmo criptográfico Rivest-Shamir-Adleman (RSA) e é mais usado para assinaturas digitais em criptomoedas, como Bitcoin e Ethereum, bem como criptografia unidirecional de e-mails, dados e software [9].

O ECDSA é um esquema de assinatura digital criptograficamente seguro, baseado na criptografia de curva elíptica (ECC) [10] [11].

A seguir, iremos implementar funções responsáveis pela criação de pares de chaves, assinatura digital e alguns métodos auxiliares:

2.3. Estrutura das transações

O processo de armazenamento de transações na blockchain consiste, essencialmente, em criar transações (composta por Entradas e Saídas), assiná-las, incluí-las em um pool de transações a serem processadas e, a partir do processo de mineração, incluí-las nos blocos minerados.

2.4. Estrutura dos blocos

No mecanismo de consenso por prova de trabalho (Proof-of-Work), um bloco para ser considerado válido, além de ser composto por transações válidas, precisa que o hash gerado a partir do seu conteúdo atenda à um objetivo.

Para isso, é necessário resolver um desafio criptográfico. Esse processo consiste em encontrar um número arbitrário (nomeado como "nonce" e que faz parte do conteúdo do bloco).

Em nosso desafio, o valor de "nonce" encontrado deve permitir a geração de um valor hash com um certo número de 0s no início. A quantidade de 0s no inicio da hash determina a dificuldade de resolver o desafio criptográfico.

2.5. Armazenando a blockchain e validando a integridade dos blocos

Agora que criamos as classes relacionadas aos blocos e transações, vamos implementar uma blockchain.

Em nossa versão de blockchain, há algumas simplificações:

Não existe um limite fixo para o número de transações que um bloco em uma blockchain pode conter;
Cada novo bloco minerado, consome toda a lista atual de transações pendentes do pool de transações.
O intervalo entre a geração de novos blocos não é gerenciado;
O nível de dificuldade de mineração de novos blocos é fixo (Previamente estabelecido na geração do bloco genesis);
Não há recompensa por bloco minerado e não há taxas ao enviar transações;
Você pode pré-alocar valores a partir do bloco genesis para o dono (você) do par de chaves criadas na Wallet padrão (Iremos falar sobre a implementação da Wallet em breve);

Nossa Blockchain é considerada válida quando:

Estiver vazia;
Houver um único bloco e ele for válido;
Houver mais de um bloco e iterarmos por cada bloco garantindo que:
- O bloco atual é válido;
- O bloco anterior é válido;
- Que o hash do bloco anterior é corretamente referenciado no bloco atual;

2.6. Wallet

O objetivo da carteira é criar uma interface mais simples para o usuário transacionar valores na blockchain.

O usuário deve ser capaz de:

Criar uma nova carteira (Que irá gerar um par de chaves);
Ver o saldo de sua carteira;
Enviar moedas para outros destinatários (referenciados por suas publicKey);

2.7. API HTTP

Nesse momento, começaremos a criar uma API HTTP para nossa blockchain.

Primeiro, iremos representar nossa blockchain em formato JSON:

Note na representação acima, que no primeiro bloco (genesis), há uma pré-alocação de 1000 unidades. A partir do segundo bloco, as entradas das transações são mapeadas em saídas (usadas também como forma de troco). Caso o remetente não deseje enviar todo o valor para o destinatário, o troco será devolvido ao remetente).

A seguir, há uma descrição dos endpoints a serem implementados:

Method	URL	Description
GET	/blockchain/blocks	Get all blocks
GET	/blockchain/blocks/{index}	Get block by index
POST	/blockchain/blocks	Mine a new block
GET	/blockchain/status	Blockchain status
GET	/my_wallet	Get my wallet information
POST	/my_wallet/transactions	Create a new transaction
POST	/wallets	Create a new wallet

2.7.1 Criando uma API HTTP em Kotlin e Ktor

Ktor é um framework Kotlin que pode ser usado para construir facilmente APIs HTTP.

Nossa aplicação em Ktor requer as seguintes dependências:

val ktorVersion = "2.0.1"
val logbackVersion = "1.2.11"

implementation("io.ktor:ktor-server-core:$ktorVersion")
implementation("io.ktor:ktor-server-netty:$ktorVersion")
implementation("io.ktor:ktor-server-html-builder:$ktorVersion")
implementation("io.ktor:ktor-server-content-negotiation:$ktorVersion")
implementation("io.ktor:ktor-serialization-jackson:$ktorVersion")

implementation("ch.qos.logback:logback-classic:$logbackVersion")

Ao criarmos nossa API HTTP, é importante isolar os modelos relacionados às regras de negócio, dos que serão expostos através da API. Portanto, para cada estrutura criada anteriormente (Blockchain, Block, Transaction, Wallet, etc) foi criada uma representação a ser exposta em formato JSON.

Na camada de API, utilizamos a biblioteca Jackson, biblioteca poderosa e eficiente que trata da serialização e desserialização de objetos Java/Kotlin e suas representações JSON.

Em seguida, implementaremos a API em Ktor, sem tantas validações, com objetivo apenas de tornar acessível externamente a blockchain para fins de aprendizado:

3. Conclusão

Espero que você tenha gostado do artigo e agora tenha uma melhor compreensão de como uma blockchain funciona.

Em futuros artigos, iremos explorar assuntos relacionados à arquitetura de redes, mecanismos de consenso e como podemos tornar nossa blockchain descentralizada.

O código não é perfeito, então caso perceba algo a ser corrigido ou melhorado na implementação, sinta-se à vontade para contribuir com o projeto.

O código fonte completo está disponível no GitHub.

Obrigado :)

4. Referências

Como configurar uma rede privada Ethereum na DigitalOcean

Victor Lins — Mon, 28 Mar 2022 11:35:21 +0000

Ethereum é um software executado em uma rede de computadores que garante que dados e pequenos programas de computador, chamados contratos inteligentes, sejam replicados e processados em todos os computadores da rede, sem um coordenador central. Seu objetivo é criar um computador mundial descentralizado e autossustentável, resistente à censura e imparável [1].

Blockchain Ethereum
Assim como o Bitcoin, o Ethereum possui uma blockchain, que contém blocos de dados (transações e contratos inteligentes). Os blocos são criados ou minerados por alguns participantes e distribuídos para outros participantes que os validam [1].

Um minerador, ao validar um novo bloco, é recompensado com uma certa quantia de valor por fazer esse trabalho. Qual é esse valor? A blockchain Ethereum usa um token digital intrínseco chamado "Ether" [2].

Protocolo Ethereum
Ethereum também é um protocolo, e isso significa que podem existir várias redes independentes em conformidade com esse protocolo mas que não interagem entre si. Com isso, uma rede privada é uma rede completamente isolada da rede principal Ethereum [3].

Normalmente, as redes privadas são criadas por organizações para armazenar dados que não devem ser visíveis fora da mesma. Além disso, elas podem ser usadas para o desenvolvimento e testes de aplicativos descentralizados (dApps) e smart contracts antes de um lançamento na rede principal.

O que faremos a seguir:

Configuraremos uma rede privada;
Configuraremos full nodes;
Mineraremos alguns novos blocos;
Por fim, criaremos uma transação enviando tokens ganhos como recompensa pela mineração de novos blocos;

Contexto

Criaremos uma rede privada com 2 full nodes. O primeiro será responsável por inicializar a blockchain e ser o primeiro signatário, enquanto o segundo será adicionado a rede em um estágio posterior.

Um full node é responsável por validar as transações e blocos e, em seguida, por retransmiti-los para outros participantes da rede [4].

1ª etapa: Criação de uma instância Ubuntu

A Digital Ocean, provedora de infraestrutura em nuvem, permite criar máquinas virtuais por meio de um de seus produtos: https://www.digitalocean.com/products/droplets

Para publicação desse guia, foram utilizadas instâncias Ubuntu da Digital Ocean com as seguintes especificações:

Ubuntu 20.04 (LTS) x64
1 GB / 1 CPU;
25 GB SSD Disk;
1000 GB Transfer;
Datacenter Region: New York 1 (nyc1);
VPC Network: default-nyc1 (DEFAULT);

2ª etapa: Instalação do Geth no Ubuntu via PPAs

Go-ethereum (geth) é a interface de linha de comando implementada em Go para executar um full node Ethereum.

Uma das maneiras de instalar o geth em distribuições Ubuntu é através de PPAs (Personal Package Archives).

Para instalá-lo, execute os seguintes comandos:

sudo add-apt-repository -y ppa:ethereum/ethereum 
sudo apt-get update 
sudo apt-get install ethereum

3ª etapa: Criação do bloco Genesis

O primeiro bloco de uma blockchain, chamado de bloco Genesis, pode ser configurado a partir de um arquivo .json.

Abra uma interface de linha de comando e crie um diretório para armazenar os dados da nova blockchain privada e navegue até ele:

cd ~ && mkdir private-blockchain && cd private-blockchain

Com um editor de texto de sua preferência, crie o arquivo genesis.json com as seguintes informações:

{
  "config": {
    "chainId": <insira um valor inteiro positivo arbitrário>,
    "homesteadBlock": 0,
    "eip150Block": 0,
    "eip155Block": 0,
    "eip158Block": 0,
    "byzantiumBlock": 0,
    "constantinopleBlock": 0,
    "petersburgBlock": 0,
    "istanbulBlock": 0,
    "berlinBlock": 0,
    "londonBlock": 0,
    "ethash": {}
  },
  "difficulty": "1",
  "gasLimit": "8000000",
  "alloc": {}
}

chainId

Parâmetro que identifica a cadeia atual e é usado para proteção contra ataques de repetição. Você deve configurá-lo com um valor inteiro positivo arbitrário.

Existe um site dedicado ao registro das chains da EVM (Ethereum Virtual Machine) e seus IDs correspondentes: https://chainlist.org/

homesteadBlock, eip150Block, eip155Block, etc

São parâmetros relacionados à bifurcação da cadeia e versionamento dela.

À medida que o desenvolvimento do protocolo Ethereum avança, novos recursos Ethereum ficam disponíveis. Para habilitar esses recursos em sua rede privada, você deve agendar um hard fork.

No nosso caso, vamos deixá-los com valor 0, já que estamos iniciando uma nova blockchain.

ethash

Ethash é um algoritmo de consenso por prova de trabalho (PoW / Proof of Work). Como ele é o algoritmo de consenso padrão, nenhum parâmetro adicional precisa ser configurado para usá-lo.

difficulty

Corresponde ao nível de dificuldade para minerar um novo bloco. Definir esse valor baixo é útil em uma blockchain privada, pois permite minerar novos blocos rapidamente.

gasLimit

Esse valor afeta o quanto de computação da EVM (Ethereum Virtual Machine) pode acontecer em um único bloco. Com uma dificuldade de mineração baixa, os blocos se moverão muito rápido. Você pode definir um valor alto para evitar atingir o limite e desacelerar sua rede. Com isso, uma maior quantidade de transações poderão ser processadas por bloco.

alloc

Permite definir uma lista de carteiras com uma pré-alocação de tokens ao iniciar a blockchain. Como poderemos minerar tokens rapidamente, não será necessário usar essa opção.

Para inicializar o bloco de genesis a partir dos parâmetros definidos no arquivo genesis.json, execute o seguinte comando:

geth --datadir . init genesis.json

Observe o resultado da execução do comando e verifique que na última linha do resultado é exibido algo como: "INFO [03-19|21:43:14.533] Successfully wrote genesis state..". Essa mensagem significa que a inicialização da blockchain privada foi feita com sucesso.

4ª etapa: Inicialização de um full node Ethereum

Para iniciar um full node e ter acesso ao Geth JavaScript Console, execute o seguinte comando:

geth --datadir . --networkid <Use o mesmo valor que você definiu como sendo o chainId> --nodiscover --http --http.corsdomain "*" --http.api "eth,net,web3,personal,miner,admin" --allow-insecure-unlock console 2>> eth.log

--datadir: configura a localização do diretório onde os dados da blockchain serão armazenados;
--networkid: As redes Ethereum têm dois identificadores, um ID de rede e um ID de cadeia. Embora muitas vezes tenham o mesmo valor, eles têm usos diferentes. A comunicação ponto a ponto entre os nós usa o ID da rede, enquanto o processo de assinatura da transação usa o ID da cadeia. No nosso caso, iremos usar o mesmo valor que foi definido como chainId, pois não queremos usar o mesmo ID da rede principal [9].
--nodiscover: desativa o mecanismo de descoberta de novos nós (para que a adição de um novo nó como signatário seja feita de forma manual);
--http: habilita o servidor HTTP-RPC. O geth aceita, por padrão, conexões na interface de loopback (127.0.0.1) na porta 8545;
--http.corsdomain: Como o servidor HTTP pode ser acessado de qualquer aplicativo local, uma proteção adicional é incorporada ao servidor para evitar o uso indevido da API por páginas web. Como estamos em um ambiente de testes, podemos habilitar o acesso de qualquer origem utilizando "*";
--http.api: permite que os módulos listados sejam usados em chamadas HTTP;
--allow-insecure-unlock: é usado para permitir o desbloqueio de conta de forma insegura ao usar a API HTTP-RPC. Como estamos em um ambiente de testes, usaremos essa flag para ser possível enviar transações através do console geth;
console: Inicia o console JavaScript interativo geth;

Acesso ao console Geth

Você pode iniciar o full node de mineração como um console ou executar o console separadamente e anexá-lo à um full node de mineração, com o comando attach:

geth --datadir . attach ipc:geth.ipc

Para monitorar a execução do geth, execute os seguintes comandos em uma outra interface de linha de comando:

cd ~/private-blockchain && tail -f eth.log

5ª etapa: Criação de uma nova conta

Esse etapa considera que você esteja dentro do Geth JavaScript console.

Para criar uma nova conta, execute o seguinte comando passando como parâmetro uma senha segura que será usada para encriptar sua nova conta:

personal.newAccount("<secure password>")

O resultado do comando anterior será o endereço da conta criada.

Um endereço como:

"0xd55859a0125c8f248905419e68b1fd603a9e7328"

O atributo "coinbase" representa o endereço da conta para onde as recompensas de mineração irão ser transferidas. Como nenhuma conta havia sido considerada como coinbase até o momento, o endereço da primeira conta criada foi definida como coinbase.

Com isso, os seguintes comandos retornarão o mesmo endereço:

eth.accounts[0]

eth.coinbase

Para consultar a quantidade de tokens em sua conta, execute o seguinte comando no console Geth:

web3.fromWei(eth.getBalance(eth.coinbase), "ether")

6ª etapa: Inicializar mineração

Para começar o processo de mineração de CPU usando um número determinado de threads (nesse caso, estamos passando como parâmetro o valor 1), execute o seguinte comando:

miner.start(1)

A partir de uma interface de linha de comando, você poderá executar os seguintes comandos para monitorar o andamento do processo de mineração:

cd ~/private-blockchain
tail -f eth.log

E perceberá que a seguinte mensagem será exibida como informativo:

Generating DAG in progress...

A saída mostra o DAG (directed acyclic graph) sendo criado. Esse processo é parte do configuração inicial do algoritmo de consenso ethash.

Considerando as especificações das instâncias Ubuntu utilizadas nesta publicação, o processo de geração do DAG durou aproximadamente 30 minutos.

Quando o processo de geração do DAG é concluído, a seguinte mensagem é exibida como informativo:

Generated ethash verification cache...

Após o DAG ser gerado, a mineração de novos blocos é iniciada.

Quando um bloco é extraído, são adicionados tokens ao saldo da sua conta como recompensa. Este é um bom indicador se o processo de mineração foi bem-sucedido ou não.

Ao minerar um novo bloco, será exibido algo como:

INFO [03-19|22:21:08.660] Successfully sealed new block number=1 sealhash=976c5d..862079 hash=f58c06..f22756 elapsed=30m49.597s INFO [03-19|22:21:08.714] 🔨 mined potential block number=1 hash=f58c06..f22756

Se continuarmos a mineração, o saldo de sua conta continuará aumentando à medida que novos blocos são minerados.

7ª etapa: Repita as etapas 2-5 em uma segunda instância para configurar seu segundo full node Ethereum

Certifique-se de que o mesmo arquivo genesis.json seja usado ao iniciar o blockchain no segundo full node.

Não inicie a mineração (6ª Etapa) na segunda instância, pois queremos que o segundo full node esteja na mesma rede / blockchain que o do primeiro. Faremos esse processo através de uma etapa de pareamento.

8ª etapa: Pareamento dos full nodes
Consideramos que nessa etapa você tenha dois full nodes em funcionamento, com as mesmas definições de bloco genesis, mas que apenas o primeiro esteja minerando novos blocos.

Antes de tudo, verifique que eles não estão pareados através do Geth console em ambas as instâncias:

admin.peers

O comando anterior deve retornar:

[]

Em seguida, precisaremos obter as informações sobre o primeiro full node para usá-las nas configurações de pareamento.

node-01

admin.nodeInfo.enode

O resultado do comando anterior será algo no seguinte formato:

"enode://pubkey@ip:port?discport=0"

Altere o valor do ip para o endereço IP privado do primeiro full node e adicione essa informação ao segundo full node com o seguinte comando:

node-02

admin.addPeer("enode://pubkey@ip:port")

Exemplo:

admin.addPeer("enode://2527461a25c9db1732e6105e1be50113e9203222381510a0e6a0139a78a4bfccecfeff962db192dcf32c8fc57cebe6209c1fa060ceb1b01432a22b57fb562833@10.136.0.2:30303")

Após a execução do comando anterior, os full nodes serão pareados.

Para verificar se o pareamento foi concluído, execute o comando admin.peers novamente em ambas a instâncias após alguns segundos:

node-02

admin.peers

O resultado será algo como:

[{
    caps: ["eth/66", "snap/1"],
    enode: "enode://2527461a25c9db1732e6105e1be50113e9203222381510a0e6a0139a78a4bfccecfeff962db192dcf32c8fc57cebe6209c1fa060ceb1b01432a22b57fb562833@10.136.0.2:30303?discport=0",
    id: "c27af002910cc0681dfb02df71a5c4e6c3f7d89a91dad1b957acf7014ac54903",
    name: "Geth/v1.10.16-stable-20356e57/linux-amd64/go1.17.5",
    network: {
      inbound: false,
      localAddress: "10.136.0.3:38204",
      remoteAddress: "10.136.0.2:30303",
      static: true,
      trusted: false
    },
    protocols: {
      eth: {
        difficulty: 131073,
        head: "0xe65d3192a9678e4eff3c117a30e9c1db3cf750e62c7410f8932ef3f7123b2690",
        version: 66
      },
      snap: {
        version: 1
      }
    }
}]

9ª etapa: Transação entre contas

Como os dois full nodes estão pareados, enviaremos alguns tokens entre as contas que criamos. Neste exemplo, enviaremos 1 ETH da conta criada no node-01 para a conta criada no node-02. Essa é uma maneira de verificar se toda configuração foi bem-sucedida.

node-01

Para enviar uma transação, execute os seguintes comandos:

personal.unlockAccount(eth.coinbase)

eth.sendTransaction({from: eth.coinbase, to: "<endereço da conta de destino>", value: web3.toWei(1, "ether")})

Após um novo bloco ser minerado, fazendo com que sua transação seja confirmada, verifique que o saldo da conta criada a partir do node-02 será de valor 1.

Com isso, concluímos a configuração de uma rede privada ethereum.

Referências: