Conecte-se à blockchain do Ethereum com Node.js e Vonage

Blockchain é um termo comumente utilizado, ao qual estão associadas muitas inovações. A blockchain é, literalmente, uma cadeia de blocos, em que cada bloco é uma informação armazenada em um banco de dados público, a cadeia. Um exemplo dessa blockchain é o Ethereum, que leva o conceito de blockchain a um nível totalmente novo.

O Ethereum é um livro-razão distribuído no qual os usuários podem chegar a um acordo de forma conveniente sobre a execução de código e as atualizações de dados. O código executado é uma aplicação distribuída que contém a lógica necessária para permitir a interação entre uma interface de usuário e os dados na blockchain. Os eventos são um importante facilitador das interações entre a blockchain e uma interface de usuário.

Os contratos inteligentes emitem eventos a partir da blockchain, que uma interface de usuário pode monitorar para acionar ações específicas e gravar registros de eventos (dados) na blockchain. Esses registros também podem ser solicitados pela interface de usuário.

Neste tutorial, vamos aprender sobre eventos de blockchain e como esses eventos podem ser vinculados à Conversation API da Vonage para criar aplicativos para o mundo real.

O código deste artigo está disponível no GitHub.

Pré-requisitos

• Noções básicas sobre a blockchain

• Conhecimentos básicos de JavaScript e Node.js

• Node.js, Ganache-clie Truffle instalados no seu computador

{"type":"signUp","props":{"number":false}}

Criar um aplicativo

Para começar a usar a Conversation API da Vonage, primeiro você precisa criar um aplicativo. Isso pode ser feito pelo painel de controle das APIs da Vonage, clicando no botão “Criar um novo aplicativo”.

Create Vonage APIs Application

Durante o processo de criação, são geradas chaves públicas e privadas. A chave privada é baixada automaticamente para o seu computador e deve ser mantida em local seguro.

Após a criação do aplicativo, você receberá um ID do aplicativo e uma chave de API para acessar programaticamente as APIs da Vonage, além da chave privada em nosso computador local.

Instalar dependências

O passo final antes de começarmos a escrever o código é instalar nossas dependências do Node.js com o NPM:

Em seguida, configure alguns scripts do NPM para ajudar na execução do aplicativo:

Configurar e compilar o contrato Solidity

Solidity é uma linguagem de programação de alto nível usada para criar contratos inteligentes na blockchain do Ethereum. Neste tutorial, vamos configurar um contrato inteligente para emitir eventos a partir da blockchain do Ethereum assim que uma mensagem for enviada.

contract TextMessage {
    // define event
    event NewText(address sender, string content);
    function sendMessage(address _sender, string memory _content) public {
        // emit event
        emit NewText(_sender, _content);
    }
}

A seguir, vamos compilar esse contrato inteligente de forma que possa ser facilmente utilizado pelo nosso aplicativo Node.js. Essa compilação é feita usando Truffle.

Assim que a compilação for concluída, um arquivo JSON que descreve o contrato inteligente é gerado em uma build/contracts pasta dentro do diretório atual.

Configurar o aplicativo Node.js

Para garantir o bom funcionamento do nosso aplicativo, precisamos definir algumas variáveis de ambiente nele. Elas nos permitem usar facilmente a Conversation API da Vongage para interagir com nosso nó Ethereum.

const dotenv = require('dotenv');
const fs = require('fs');
const path = require('path');
dotenv.config();

const pkey = fs.readFileSync(path.join(__dirname, 'private.key'), 'utf8');

module.exports = {
    NEXMO_PRIVATE_KEY: pkey,
    NEXMO_APPLICATION_ID: process.env.NEXMO_APPLICATION_ID,
    NEXMO_API_KEY: process.env.NEXMO_API_KEY,
    NEXMO_APP_SECRET: process.env.APP_SECRET
    };

O ID do aplicativo Nexmo, a chave da API e o segredo do aplicativo podem ser encontrados no painel do aplicativo e devem ser armazenados em um .env arquivo no diretório atual. Essas constantes são inicializadas com nossa instância do SDK da Vonage.

const { NEXMO_API_KEY, NEXMO_APPLICATION_ID, NEXMO_APP_SECRET, NEXMO_PRIVATE_KEY } = require('./config');
    
const nexmo = new Nexmo({
    apiKey: NEXMO_API_KEY,
    apiSecret: NEXMO_APP_SECRET,
    applicationId: NEXMO_APPLICATION_ID,
    privateKey: NEXMO_PRIVATE_KEY
});

A Conversation API da Vonage oferece uma série de APIs que permitem a comunicação em tempo real por diversos canais (voz, texto, Video). As interações por meio desses canais podem ser iniciadas criando uma Conversation.

nexmo.conversations.create({
    "name": CONV_NAME,
    "display_name": CONV_DISPLAY_NAME}, (error, result) => {
        if(error) {
            console.error(error);
        }
        else {
            console.log(result);
        }
    });

O ID da conversa retornado é usado para emitir e monitorar eventos que ocorrem nessa conversa.

Os usuários são então criados para interagir nessa conversa por meio de associação. Também registramos o ID de membro resultante.

nexmo.conversations.members.create(CONVERSATION_ID,
        {"action":"join", "user_id":USER_ID, "channel":{"type":"app"}},
        (error, result) => {
        if(error) {
            console.error(error);
         }
        else {
            console.log(result);
        }
    });

Conecte-se à blockchain do Ethereum

Para interagir com nosso nó local do Ethereum (um programa que se conecta à rede Ethereum, fornecido por Ganache-cli , neste caso, para fins de teste), por meio do Node.js, usamos o Web3, um conjunto de bibliotecas que fornece APIs para que aplicativos em JavaScript e Node.js se conectem a um nó do Ethereum.

const Web3 = require('web3');
    
const provider = new Web3.providers.WebsocketProvider('ws://localhost:8545');
let web3 = new Web3(provider);

Aqui, utilizamos um provedor WebSocket que conecta nossa aplicação Node.js ao Ganache-cli cliente RPC. O Ganache-cli precisa ser iniciado após a instalação com o comando:

Em seguida, passamos as informações sobre o contrato inteligente para nossa aplicação Node.js e instanciamos o contrato. As informações do contrato estão disponíveis no ABI (Interface Binária de Aplicação) contida no arquivo JSON gerado automaticamente a partir da compilação do nosso contrato inteligente.

let senderAccount = '0xA825e2B7b37377E955b8b892249611EAc7d8d3a0';
    
const contractJSON = JSON.parse(fs.readFileSync('../build/contracts/TextMessage.json'), 'utf8');
    
const abi = contractJSON.abi;
    
const contract = new web3.eth.Contract(abi, senderAccount);

Você pode notar, no trecho de código acima, que precisamos de uma Account a partir da qual as transações serão enviadas. Ganache-cli fornece algumas contas de teste e suas chaves privadas associadas, que são utilizadas ao longo de todo o processo de desenvolvimento.

Ganache-cli provides a couple of test accounts and their associated private keys which are used throughout the development process

Envie uma mensagem para a rede

Em seguida, enviamos uma mensagem ao nó do Ethereum e criamos um evento “Conversation” assim que o hash da transação fica disponível. O evento “Conversation” contém os dados (a mensagem enviada) da transação.

let receiverAccount = '0x7A5c662d8af4085a579586D50C2027320e5a13c3';
    
contract.methods.sendMessage(senderAccount, receiverAccount, message).send({
    from: senderAccount,
    // gas: 8500000,         // Gas sent with each transaction 
    gasPrice: 20000000000,  // 20 gwei (in wei) 
}).on('transactionHash', function (hash) {
    console.log('hash: ', hash);
    
    //send conversation event to create text
    nexmo.conversations.events.create(NEXMO_CONVERSATION_ID, {
        "type": "text",
        "from": NEXMO_MEMBER_ID,
        "body": {
            "text": message
        }
    }, (error, res) => {
        if (error) {
            console.error(error);
        } else {
            console.log('new text on the blockchain: ', res);
        }
    });
});

Fique atento aos eventos sobre blockchain

Também poderíamos monitorar o NewText evento emitido pela blockchain. Assim que esse evento for bem-sucedido, poderíamos emitir um evento de Conversação personalizado, que poderia ser usado por uma interface de usuário para monitorar as mensagens da blockchain.

contract.events.NewText(function (error, event) {
    if (error) {
        return error;
    } 
}).on('data', function (data) {
    nexmo.conversations.events.create(NEXMO_CONVERSATION_ID, {
        "type": "text:delivered",
        "from": NEXMO_MEMBER_ID,
        "body": {
            "text": data
        }
    }, (error, result) => {
        if (error) {
          return error;
        } else {
          return event;
        }
    });
})

Junte tudo

Agora é hora de testar nosso aplicativo! Primeiro, vamos nos certificar de que Ganache-cli está em execução no terminal e que nosso smart contract foi compilado com Truffle. Depois de fazer isso, executamos npm start em uma nova instância do terminal para executar nosso aplicativo.

Uma olhada nos nossos Ganache-cli registros no terminal deve mostrar o eth_sendTransaction e eth_subscribe APIs sendo chamadas em nosso nó Ethereum, o que indica o início de uma transação e a assinatura de um evento por nosso aplicativo Node.js

Logs in the terminal

E agora?

Poderíamos aprimorar esse aplicativo desenvolvendo um aplicativo de bate-papo completo na blockchain, incluindo um tratamento de erros mais robusto, indexação de mensagens na blockchain e muito mais!