Construindo um aplicativo Blockchain com JavaScript

Por

E aí, pessoal! Prontos para embarcar na viagem maluca das notícias de cripto? No nosso canal do Telegram, vamos explorar o mundo das criptomoedas com leveza e bom humor. É como um papo de bar sobre Bitcoin, só que sem a ressaca no dia seguinte! 😄 Junte-se a nós agora e vamos desvendar esse universo juntos! 💸🚀

☞ Junte-se ao Telegram

Introdução

Tudo bem, meu querido companheiro de codificação! Deixe-me guiá-lo por esta aventura blockchain usando meus anos de experiência em programação e uma pitada de humor.

Avanços inovadores modernos, como moedas digitais como Bitcoin e vários aplicativos descentralizados (DApps) em vários setores, são significativamente influenciados pela tecnologia blockchain. Essencialmente, um blockchain representa um banco de dados coletivo que registra transações em vários dispositivos, garantindo que os dados não possam ser modificados depois de registrados. Cada transação, ou “bloco”, está vinculada à anterior, formando uma sequência ininterrupta, daí o termo “blockchain”. Esta estrutura garante transparência, segurança e imutabilidade dos dados – qualidades cruciais para muitas aplicações.

JavaScript em Blockchain

JavaScript se destaca como uma linguagem de programação versátil e renomada, particularmente benéfica para a criação de soluções blockchain. Seu vasto ecossistema e o apoio robusto da comunidade facilitam o desenvolvimento de aplicações blockchain, oferecendo diversas vantagens:

  • Ampla adoção: Como Javascript é a linguagem principal usada para desenvolvimento web, é muito óbvio ter aplicação no cenário blockchain com aplicativos web.
  • Processamento assíncrono: Os recursos assíncronos do JavaScript, facilitados pelo Node.js, são ideais para lidar com múltiplas transações e interações em um ambiente blockchain.
  • Ecossistema rico: Ferramentas e bibliotecas no ecossistema JavaScript, como Node.js para desenvolvimento no lado do servidor e Express.js para APIs, agilizam o desenvolvimento de aplicativos blockchain.

Público

Como um desenvolvedor JavaScript experiente com anos de experiência, posso recomendar sinceramente este artigo para qualquer pessoa que queira expandir suas habilidades e mergulhar no fascinante mundo da tecnologia blockchain. Este guia orientará você no processo de configuração de seu ambiente de desenvolvimento, dividindo conceitos complexos em fundamentos compreensíveis, ajudando você a construir um aplicativo blockchain básico e, por fim, expondo-o por meio de uma API amigável. Esteja você ansioso para aprender ou procurando adicionar outra corda ao seu arco de desenvolvedor, este artigo é um recurso inestimável para sua jornada.

Capítulo 1: Configurando o ambiente de desenvolvimento

Instalando o Node.js

  • Baixe o node js em seu sistema no site oficial e prefira a versão LTS (Long Term Support), pois é recomendada a melhor para todos os sistemas operacionais e mantém a estabilidade.
  •  Siga as instruções de instalação específicas para o seu sistema operacional. A instalação inclui npm (Node Package Manager), essencial para gerenciar dependências do projeto.
  • Verifique se a instalação foi feita corretamente ou não executando os seguintes comandos no bash:
    1. nó -v
    2. npm -v

Depois de executar os comandos fornecidos, você deverá encontrar as versões correspondentes dos pacotes instalados em seu sistema, assumindo que o processo de instalação foi bem-sucedido.

Escolhendo um IDE

Escolhendo JavaScript como sua linguagem de programação, o Visual Studio Code (VSCode) é um excelente companheiro para lidar com todos os seus requisitos de desenvolvimento. Seus recursos poderosos e ambiente adaptável o tornam perfeito para o desenvolvimento de JavaScript.

  • Código do Visual Studio:
    1. Baixe o VsCode do site oficial
    2. Instale as extensões da seguinte forma:
      1. ESLint: Para identificar e corrigir problemas no código JavaScript.
      2. Mais bonito: para formatação de código consistente.
      3. Depurador para Chrome: para depurar código JavaScript em execução no Google Chrome.
      4. Node.js: para recursos de depuração do Node.js.

Instalando bibliotecas necessárias

O gerenciamento de bibliotecas JavaScript é feito através do npm (Node Package Manager). Para iniciar seu projeto e instalar os pacotes necessários, use o seguinte comando:

npm init -y
npm install express body-parser crypto

//express é a estrutura do nó 
//body-parser é o middleware para analisar as solicitações recebidas
//função criptográfica usada para hashing

Capítulo 2: Compreendendo os conceitos de Blockchain com JavaScript

Noções básicas de Blockchain em JavaScript

Um blockchain é composto por blocos que contêm:

  • Índice: Posição do bloco na cadeia.
  • Timestamp: Data e hora em que o bloco foi criado.
  • Dados: Dados de transação ou outras informações armazenadas no bloco.
  • Hash anterior: Hash do bloco anterior na cadeia, ligando os blocos.
  • Hash: Identificador exclusivo do bloco, gerado pelo hash de seu conteúdo.
const crypto = require(‘crypto’);

class Block {    
constructor(index, timestamp, data, previousHash = ”) {        
this.index = index;        
this.timestamp = carimbo de data/hora;        
this.data = dados;        
this.previousHash = previousHash;        
this.hash = this.calculateHash;    
}
    calculateHash {        
return crypto.createHash(‘sha256’)            < br/>.update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data))           
 .digest(‘hex’);    
}
}

Importância da descentralização, imutabilidade e mecanismos de consenso:

Descentralização: 

Nos sistemas blockchain, em vez de depender de uma autoridade central para armazenamento de dados e validação de transações, a responsabilidade é distribuída entre todos os nós participantes. Isso significa que cada nó mantém seu próprio registro (ou cópia) do razão, eliminando possíveis problemas causados ​​por um único ponto de controle.

Transparência:

Como pesquisador que explora o Ethereum, posso afirmar com segurança que cada nó e participante da rede tem acesso ao livro-razão, garantindo transparência inabalável em todo o sistema. As transações no Ethereum são exibidas publicamente para que todos possam ver no explorador de blockchain, proporcionando um ambiente aberto e transparente para todos os envolvidos.

Imutabilidade:

É crucial pensar bem antes de concluir uma transação, pois alterações ou reversões normalmente são impossíveis após o fato. Esse recurso é valioso para evitar fraudes e transações duplicadas.

Mecanismo de consenso:

Em uma rede, os mecanismos de consenso servem como diretrizes para que os nós decidam coletivamente sobre o status atual do livro-razão distribuído. Esses mecanismos são fundamentais para verificar e autenticar transações. Eles garantem que todos os nós participantes da Distributed Ledger Technology (DLT) concordam com o estado do razão.

Componentes de uma aplicação Blockchain

Estrutura de bloco em JavaScript:

const crypto = require(‘crypto’);

class Block {    
constructor(index, timestamp, data, previousHash = ”) {        
this.index = index;        
this.timestamp = carimbo de data/hora;        
this.data = dados;        
this.previousHash = previousHash;        
this.hash = this.calculateHash;        
this.nonce = 0; // Para prova de trabalho    
}

calculateHash {        
return crypto.createHash(‘sha256’)            
.update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce )            
.digest(‘hex’);    }

mineBlock(dificuldade) {        
while (this.hash.substring(0, dificuldade ) !== Array(dificuldade + 1).join(“0”)) {            
this.nonce++;            
this.hash = this.calculateHash;        
}        
console.log(“Bloco minerado: ” + this.hash);    
}
}

Criando e verificando transações usando JavaScript:

Numa blockchain, cada transação serve como uma unidade fundamental de dados, representando uma mudança de valor, a execução de um acordo ou qualquer alteração no estado geral da blockchain. O sistema coleta essas transações em blocos e depois as anexa ao blockchain.

Detalhes da transação:

  • Remetente: a chave pública ou identificação específica de quem está enviando.
  • Destinatário: A chave pública ou identificação específica do sortudo que está recebendo a transação.
  • Valor: o que está sendo repassado, seja dinheiro ou alguma informação.
  • Carimbo de data/hora: Quando eles decidiram enviar essa coisa.
  • Prova de autenticidade/assinatura: algum código supersecreto que mostra a legitimidade do negócio e não foi adulterado. Quem envia usa sua chave secreta para fechar o negócio, e todos os demais podem verificar se é real com a chave pública.

Snippet de código da transação:

class Transaction {    
constructor(fromAddress, toAddress, amount) {        
this.fromAddress = fromAddress;        
this.toAddress = toAddress;        
this.amount = valor;        
this.timestamp = new Date.toISOString;    
}
    calculateHash {        
return crypto.createHash(‘sha256’)            < br/>.update(this.fromAddress + this.toAddress + this.amount + this.timestamp)            
.digest(‘hex’);    
}

signTransaction(signingKey) {        
if (signingKey.getPublic(‘hex’) !== this.fromAddress) {            
throw new Error(‘Você não pode assinar transações para outras carteiras!’);        
}

 const hashTx = this.calculateHash;        
const sig = SigningKey.sign(hashTx, ‘base64’);        
this.signature = sig.toDER(‘hex’);    }
    isValid {        
if (this.fromAddress === null) retornar verdadeiro;

if (!this.signature || this.signature.length === 0) {            
lançar novo erro(‘Não assinatura nesta transação’);       
 }

const publicKey = ec.keyFromPublic(this.fromAddress, ‘hex’);        
return publicKey.verify(this.calculateHash, this.signature);    
}
}

A verificação de uma transação garante sua autenticidade, confirmando que o signatário é legítimo e possui fundos suficientes. Este processo geralmente envolve a verificação da integridade da assinatura digital e a verificação de que o saldo da conta do remetente é igual ou superior ao valor da transação.

class Blockchain {    
construtor {        
this.chain = [this.createGenesisBlock];        
this.pendingTransactions = [];        
this.miningReward = 100;    
}

createGenesisBlock {        
retornar novo bloco (Data.parse(‘2024-01-01’), [], ‘0’);    
}
    getLatestBlock {        
retornar this.chain[this.chain.length – 1];    
}

minePendingTransactions(miningRewardAddress) {        
deixe bloco = novo Bloco (Date.now, this.pendingTransactions, this.getLatestBlock.hash);        
block.mineBlock(this.difficulty);

console.log(‘Bloco extraído com sucesso !’);        
this.chain.push(block);
        this.pendingTransactions = [            
nova transação( null, miningRewardAddress, this.miningReward)        
];   
 }
    addTransaction(transaction) {        
if (!transaction.fromAddress || !transaction. toAddress) {            
lançar novo erro(‘A transação deve incluir o endereço de e para’);        }

if (!transaction.isValid) {            
throw new Error(‘Não é possível adicionar inválido transação para cadeia’);        
}
        this.pendingTransactions.push(transaction);    
}

getBalanceOfAddress(endereço) {        
let balance = 0;

for (const block of this.chain) {            
for ( const trans de block.data) {               
 if (trans.fromAddress === endereço) {                   
 balance -= trans.amount;               
 }

if (trans.toAddress === endereço) {                   < br/> saldo += trans.valor;                
}           
 }       
 }
        devolver saldo;    
}
    isChainValid {        
for (seja i = 1; i < this.chain.length ; i++) {            
const currentBlock = this.chain[i];            
const previousBlock = this.chain[i – 1];
            if (!currentBlock.hasValidTransactions) {                
retorne falso;            
}
            if (currentBlock.hash !== currentBlock.calculateHash) {                
retornar falso;            
}
            if (currentBlock.previousHash !== previousBlock.hash) {                
retornar falso;            
}        
}
        retorna verdadeiro;    
}
}

Visão geral dos algoritmos de consenso compatíveis com JavaScript:

Prova de Trabalho (PoW):

Em termos mais simples, Prova de Trabalho (frequentemente chamada de mineração) é um método usado para validar transações e criar novos blocos em um blockchain. Os usuários competem para resolver problemas matemáticos complexos ou “quebra-cabeças criptográficos”. O primeiro a resolver o quebra-cabeça adiciona o próximo bloco à cadeia. Este processo é protegido por algoritmos de hash, que garantem a integridade e segurança do blockchain.

Em termos mais simples, quando se trata de colocar a Prova de Trabalho (PoW) em ação, ferramentas para esse fim são oferecidas no Bitcoin Development Suite, que inclui o Bitcoin Core.

Prova de participação (PoS):

Em termos mais simples, o Proof of Stake escolhe os validadores não apenas com base na quantidade de moedas que eles possuem como garantia, mas também considera fatores como a idade das moedas e um toque de aleatoriedade. O processo de seleção favorece os validadores que possuem moedas por períodos mais longos e aqueles com uma aposta maior, ao mesmo tempo que garante a justiça por meio de um baixo valor de hash e um alto valor total apostado. Esses validadores preferenciais são então encarregados de adicionar um novo bloco ao blockchain.

Implementação do desenvolvedor: ferramentas e bibliotecas para PoS são fornecidas pelo Ethereum 2.0 SDK

Prova de Participação Delegada (DPoS):

Em termos mais simples, este sistema emprega uma abordagem democrática para confirmar transações e criar novos blocos. Fá-lo permitindo votos entre os participantes (referidos como “delegados”) para autenticar transações e construir novos blocos numa blockchain.

Implementação do desenvolvedor: EOSIO SDK fornece ferramentas e bibliotecas para DPoS.

Capítulo 3: Construindo um Blockchain Simples com JavaScript

Neste tutorial, nos aprofundaremos na arquitetura do blockchain, abordando a criação de classes essenciais como blocos, definindo seus atributos e entendendo como esses blocos e seus parâmetros estão interconectados.

Criando a classe de bloco

Blockchain como o nome representa é composto de blocos e cada classe de bloco possui atributos básicos como:

  • Índice: Um identificador numérico para a posição do bloco na blockchain.
  • Timestamp: A hora em que o bloco foi criado.
  • Dados: Os dados ou transações armazenadas no bloco. Isso pode incluir informações como detalhes da transação, dados do usuário, etc.
  • PreviousHash: O hash do bloco anterior da cadeia, garantindo continuidade e segurança.
  • Hash: Um identificador exclusivo para o bloco, gerado pelo hash do conteúdo do bloco.
  • Nonce: Um número usado para o algoritmo de Prova de Trabalho, que é ajustado até que um hash válido seja encontrado.

Implemente métodos para calcular o hash do bloco usando a sintaxe JavaScript:

  • createGenesisBlock: Cria o primeiro bloco no blockchain, conhecido como bloco genesis.
  • getLatestBlock: recupera o bloco mais recente no blockchain.
  • adBlock: Adiciona um novo bloco ao blockchain após minerá-lo.
  • isChainValid: valida a integridade do blockchain garantindo que o hash de cada bloco corresponda e que os hashes anteriores sejam consistentes.

Criando a classe Blockchain

Defina uma classe Blockchain para gerenciar a cadeia e implementar métodos para adicionar novos blocos:

class Blockchain {    
construtor {        
this.chain = [this.createGenesisBlock];        
esta.dificuldade = 4;  // Nível de dificuldade para mineração    
}
    // Método para criar o bloco de gênese    
createGenesisBlock {
retornar novo Bloco(0, “01/01/2024”, “Bloco Gênesis”, “0”);    
}

 // Método para recuperar o último bloco da cadeia    < br/>getLatestBlock {        
return this.chain[this.chain.length – 1];    
}

// Método para adicionar um novo bloco à cadeia após minerá-lo    
addBlock(newBlock) {        
newBlock.previousHash = this.getLatestBlock.hash;        
newBlock.mineBlock(this.dificuldade);        
this.chain.push(newBlock);    
}

 // Método para validar a integridade do blockchain    
isChainValid {        
for (seja i = 1; i < this.chain.length; i++) {            
const currentBlock = esta.cadeia[i];            
const previousBlock = this.chain[i – 1];

// Verifique se o o hash do bloco atual está correto            
if (currentBlock.hash !== currentBlock.calculateHash) {                
return false;           
 }
            // Verifique se o hash anterior do bloco atual corresponde ao hash do bloco anterior            
if (currentBlock.previousHash !== previousBlock.hash) {                
retornar falso;            
}       
 }        
retornar verdadeiro;    
}
}

Capítulo 4: Implementando Mecanismos de Consenso em JavaScript

Comprovante de Trabalho

Em termos mais simples, Prova de Trabalho (frequentemente chamada de mineração) é um sistema onde os participantes da rede, ou mineradores, competem para resolver problemas matemáticos complexos que são como quebra-cabeças com códigos criptográficos. O mineiro que resolver o quebra-cabeça primeiro adiciona o próximo bloco à cadeia de dados conhecida como blockchain e recebe uma recompensa. Este processo envolve o uso de hashing para manter o blockchain seguro. A complexidade desses quebra-cabeças ajuda a manter a segurança do blockchain e regula a rapidez com que novos blocos são adicionados à cadeia.

Na classe Block, vamos incorporar o conceito de Prova de Trabalho criando uma função ‘mineBlock’. Esta função ajustará continuamente o nonce até que o hash codificado do bloco satisfaça um padrão de complexidade específico (por exemplo, o hash deve começar com um número especificado de zeros).

Trecho de código:

bloco de classe {    
construtor(index, timestamp, data, previousHash = ”) {        
this.index = index;        
this.timestamp = carimbo de data/hora;        
this.data = dados;        
this.previousHash = previousHash;        
this.hash = this.calculateHash;        
this.nonce = 0;   
 }

 // Calcule o hash do bloco usando SHA-256    
calculateHash {        
return crypto.createHash(‘sha256’)            
.update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce)            
.digest(‘hex’);    
}

    // Implementando prova de trabalho    
mineBlock(dificuldade) {        
while (this.hash.substring(0, dificuldade) !== Array(dificuldade +
1).join(“0”)) {            
this.nonce++;            
this.hash = this.calculateHash;       
 }        
console.log(`Bloco extraído: ${this.hash}`);    
}
}

Atualize a classe Blockchain para validar a prova antes de adicionar novos blocos.

class Blockchain {    
construtor {        
this.chain = [this.createGenesisBlock];        
esta.dificuldade = 4;    
}

 // Crie o bloco de gênese    createGenesisBlock {        
retornar novo Bloco(0, “01/01/2024”, “Bloco Gênesis”, “0”);    
}

// Obtenha o último bloco da cadeia    
getLatestBlock {        
retornar this.chain[this.chain.length – 1];    
}

// Adicionar um novo bloco à cadeia    
addBlock(newBlock) {        
newBlock.previousHash = this.getLatestBlock.hash;        
newBlock.mineBlock(this.dificuldade);  // Implementando Prova de Trabalho        
this.chain.push(newBlock);    
}

// Verifique se o blockchain é válido    
isChainValid {        
for (seja i = 1; i < this.chain.length; i++) {            
const currentBlock = this. cadeia[eu];            
const previousBlock = this.chain[i – 1];
            if (currentBlock.hash !== currentBlock.calculateHash) {                
retorna falso;           
 }
            if (currentBlock.previousHash !== previousBlock.hash) {                
retornar falso;           
 }        
}        
retornar verdadeiro;    
}
}

Capítulo 5: Criando uma API Blockchain simples com JavaScript

Desenvolver uma blockchain é apenas o primeiro passo; também deve ser prático para o uso diário. Para atingir esse objetivo, devemos projetar uma interface amigável, como uma API (Application Programming Interface) simples, que permita fácil interação.

Configurando o ambiente da API

Para criar uma API eficaz, é crucial que você primeiro prepare o espaço de trabalho instalando todas as ferramentas e frameworks necessários para o seu desenvolvimento.

  • Instale o nó e o npm 
  • Inicialize seu projeto com o comando: npm init -y
  • Instale Express: npm install express -save (Express é a estrutura node js que ajuda na construção de APIs mais rapidamente)
  • Instale o analisador de corpo para lidar com a solicitação recebida: npm install body-parser -save

Construindo a API

Depois de preparar sua configuração, vamos prosseguir com a criação da Interface de Programação de Aplicativo (API). Essa interface permitirá que os usuários se comuniquem com o blockchain, observem o estado atual da cadeia e até mesmo acrescentem novos blocos a ela.

Crie o servidor com Express:

const express = require(‘express’);
const bodyParser = require(‘body-parser’);
const Blockchain = require(‘./blockchain’);  //Importa a classe Blockchain

const app = express;
app.use(bodyParser.json);

demoBlockchain = novo Blockchain;  // Inicialize uma nova instância Blockchain

Definir pontos de extremidade da API

app.get(‘/blocks’, (req, res) => {     //endpoint para obter o blockchain    
res.json(demoBlockchain.chain);});

//este é o endpoint para criar um novo bloco

app.post(‘/mine’, ( req, res) => {    
const newBlock = new Block(        
demoBlockchain.chain.length,        
Date.now,        
req.body.data,        
demoBlockchain.getLatestBlock.hash   
);    
demoBlockchain.addBlock(newBlock);
    res.send(`Bloco extraído com sucesso: ${newBlock.hash}`);
});

Iniciar o servidor

app.listen(3000, => {    
console.log(‘API Blockchain em execução na porta 3000’);
}) ;
nó server.js

Capítulo 6: Executando e testando o aplicativo

Não consigo enfatizar o suficiente a importância desta fase para garantir que seu blockchain opere sem problemas e forneça os resultados esperados. Como alguém que passou anos trabalhando com diversas tecnologias de blockchain, já vi inúmeros projetos falharem por negligenciarem essa etapa crítica. Não cometa o mesmo erro – invista tempo testando e refinando minuciosamente seu blockchain antes de lançá-lo no mercado. Confie em mim; seus usuários vão agradecer por isso!

Executando o aplicativo

  1. Inicie o servidor: navegue até o diretório do seu projeto e execute o destino: node server.js
  2. Obtenha a confirmação do servidor: API Blockchain em execução na porta 3000
  3. Acessando o Aplicativo: Seu aplicativo agora está rodando localmente em http://localhost:3000, ficando pronto para aceitar solicitações HTTP

Testando com Postman

Como investidor em criptografia, muitas vezes confio em ferramentas como o Postman para garantir que minhas APIs de blockchain estejam funcionando de maneira ideal. Com o Postman, posso enviar facilmente solicitações HTTP e analisar as respostas retornadas. Esta ferramenta é inestimável quando se trata de testar e verificar o desempenho da minha API, mantendo meus investimentos seguros e eficientes.

  • Instalar o carteiro
  • Testando o endpoint Blockchain
  • Teste o endpoint de mineração
  • Verifique o blockchain
(Etapa 1)node server.js
API Blockchain em execução na porta 3000

//http://localhost: 3.000/bloco

(Etapa 2)[    
{        
“índice”: 0 ,        
“carimbo de data e hora”: 1636568887994,        
“dados”: “Bloco Gênesis”,       
 “ previousHash”: “0”,       
 “hash”:
“81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”   
 }
]

(Etapa 3){    
“dados”: {        < br/>“valor”: 100,        
“remetente”: “John Doe”,        
“destinatário”: “Jane Smith ”   
 }
}

(Etapa 4){   
 “mensagem”: “Bloco extraído com sucesso”,    
“bloqueio”: {        
“índice”: 1,        
“carimbo de data/hora”: 1636578990123,        
“dados”: {            
“quantidade”: 100,            
“remetente”: “John Doe”,            
“destinatário”: “Jane Smith”        
},
“hash anterior”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”,       
 “hash”
“5a1cdd657c8d0d 3c0f12c2bb2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2”    
}
}

 (Etapa 5)[    {
“índice”: 0,        “carimbo de data/hora”: 1636568887994,        “dados”: “Bloco Gênesis”,        “anteriorHash”: “0”,        “hash”:“81f1a4ab4d484c64f1b4c524b1d8f2fef8f2 bca7853d44682e12022fb2d803b9”    },    {        “índice”: 1,        “carimbo de data e hora “ 81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”,        “hash”: 8caa82ff4a9a2”    } ]
curl http://localhost:3000/blocks //Ver o blockchain
[   
 {       
 “índice”: 0,        
“carimbo de data e hora”: 1636568887994,       
 “dados”: “Bloco Gênesis”,       
 “hash anterior”: “0”,       
 “hash”:
“81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”    
}
]

//Mineração de um novo blockcurl -X POST -H “Content-Type: application /json” -d ‘{“dados”: {“quantidade”: 100, “remetente”: “John Doe”, “receptor”: “Jane Smith”}}’ http://localhost:3000/mine

//verifique o blockcurl http://localhost:3000/blocks

[   
 {       
 “índice”: 0,        
“carimbo de data e hora”: 1636568887994,       
 “ dados”: “Bloco Gênesis”,       
 “anteriorHash”: “0”,       
 “hash”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”    < br/>},    
{       
 “índice”: 1,       
 “carimbo de data e hora ”: 1636578990123,        
“dados”: {           
 “quantidade”: 100,            
“remetente ”: “John Doe”,           
“receptor”: “Jane Smith”       
 },        
“hash anterior”: “81f1a4ab4d484c64f1b4c524b1d8f2fef8f2bca7853d44682e12022fb2d803b9”,       
 “hash”
“5a1cdd657c8d0d3c0f12c2bb 2c9fdf32a7d2d4ad13fcb78170a8caa82ff4a9a2”    
}
]

Capítulo 7: Exemplo prático de construção de um aplicativo Blockchain com JavaScript

Execução passo a passo

  • Etapa 1: Crie a classe Block com os atributos necessários usando a sintaxe JavaScript.
bloco de classe {    
construtor(index, timestamp, data, previousHash = ”) {        
this.index = index;        
this.timestamp = carimbo de data/hora;        
this.data = dados;        
this.previousHash = previousHash;        
this.hash = this.calculateHash;        
this.nonce = 0;    
}
}
  • Etapa 2: Implemente o método calculaHash.
calculateHash {   
 return crypto.createHash(‘sha256’)        
.update(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce)       
 .digest(‘hex’);
}
  • Etapa 3: Defina a classe Blockchain e inicialize-a com um bloco genesis.
class Blockchain {    
construtor {        
this.chain = [this.createGenesisBlock];    
}
}
  • Etapa 4: Implemente métodos para adicionar novos blocos e recuperar o bloco mais recente usando JavaScript.
getLatestBlock {    
return this.chain[this.chain.length – 1];
}

addBlock(newBlock) {    
newBlock.previousHash = this.getLatestBlock.hash;    
newBlock.hash = newBlock.calculateHash;    
this.chain.push(newBlock);}
  • Etapa 5: adicione a funcionalidade Prova de Trabalho à classe Block e atualize a classe Blockchain.
mineBlock(dificuldade) {    
while (this.hash.substring(0, dificuldade) !== Array(dificuldade + 1).join(“0”)) {        
this.nonce++;        
this.hash = this.calculateHash;    
}
}
  • Etapa 6: configure o ambiente da API para lidar com solicitações usando o Express.
npm init -y
npm install express -save                        //Configurando o projeto e
o diretório

const expresso = require(‘expresso’);      //Configurando o serverconst expresso bodyParser = require(‘body-parser’);
const Blockchain = require(‘./blockchain’); // Supondo que você tenha a classe Blockchain dos capítulos anteriores

const app = express;app.use(bodyParser.json);

const demoBlockchain = novo Blockchain;
app.get(‘/blocks’, (req, res) => {    res.json(demoBlockchain.chain);});

app.post(‘/mine’, (req, res) => {            //criando um novo bloco             const newBlock = new Bloquear(
demoBlockchain.chain.length,
        Date.now,
        req.body.data ,
        demoBlockchain.getLatestBlock.hash
);
    newBlock.mineBlock(2); Supondo uma dificuldade de 2 para PoW    demoBlockchain.addBlock(newBlock);    
res.send(`Bloco extraído com sucesso: ${newBlock.hash}`);
});
app.listen(3000, => {                               //iniciando o servidor    console.log(‘Blockchain API rodando na porta 3000’);});

nó server.js
  • Etapa 7: teste o aplicativo minerando um novo bloco e verificando o blockchain usando Postman ou curl.
No carteiro, envie a solicitação:
Solicitação GET para http://localhost:3000/blocks.
{    < br/>“dados”: {       
 “quantidade”: 10,       
 “remetente”: “Alice”,       
 “receptor”: “Bob”   
 }
}

Em curl:curl
http://localhost:3000/blocks

Vamos resumir as etapas acima em poucas palavras

Vamos seguir o processo passo a passo para dar vida ao seu aplicativo blockchain:

  1. Comece definindo as classes Block e Blockchain para estabelecer a estrutura central do seu blockchain.
  2. Incorpore Prova de Trabalho adicionando o método mineBlock à classe Block, garantindo que cada bloco atenda à dificuldade necessária antes de ser adicionado à cadeia.
  3. Configure uma API usando Express que permita interagir com seu blockchain, possibilitando operações como visualizar a cadeia e adicionar novos blocos.
  4. Execute e teste seu aplicativo com Postman ou curl para verificar se tudo funciona conforme o esperado, desde a mineração de blocos até a recuperação dos dados do blockchain.

Boa codificação!!

2024-08-14 21:30