Conéctate a la Blockchain de Ethereum con Node.js y Vonage

Blockchain es un término de uso común que lleva asociadas muchas innovaciones. La cadena de bloques es, literalmente, una cadena de bloques, donde cada bloque es una pieza de información almacenada en una base de datos pública, la cadena. Una de estas cadenas de bloques es Ethereum, que lleva el concepto de cadena de bloques a un nivel completamente nuevo.

Ethereum es un libro mayor distribuido en el que los usuarios pueden acordar cómodamente la ejecución de código y la actualización de datos. El código que se ejecuta es una aplicación distribuida que contiene lógica para permitir la interacción entre una interfaz de usuario y los datos de la blockchain. Un importante facilitador de las interacciones entre la blockchain y una interfaz de usuario son los eventos.

Los contratos inteligentes emiten eventos de la cadena de bloques que una interfaz de usuario puede escuchar para activar acciones específicas y escribir registros de eventos (datos) en la cadena de bloques. Estos registros también pueden ser solicitados por la interfaz de usuario.

En este tutorial, aprenderemos acerca de los eventos de blockchain y cómo estos eventos podrían vincularse con la Conversation API de Vonage para crear aplicaciones reales.

El código de este artículo está en GitHub.

Requisitos previos

• Conocimientos básicos de Blockchain

• Conocimientos básicos de JavaScript y Node.js

• Nodejs, Ganache-cliy Truffle instalados en su máquina

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

Crear una aplicación

Para comenzar a usar la Conversation API de Vonage, primero debes crear una aplicación. Esto se puede hacer a través de tu panel de API de Vonage haciendo clic en el botón "Crear una nueva aplicación".

Create Vonage APIs Application

Durante el proceso de creación, se generan las claves pública y privada. La clave privada se descarga automáticamente en tu máquina local y debes guardarla a buen recaudo.

Una vez creada la aplicación, recibirás un ID de aplicación y una clave de API para acceder mediante programación a la aplicación de API de Vonage, junto con la clave privada en nuestra máquina local.

Instalar dependencias

El último paso antes de empezar a escribir código es instalar nuestras dependencias de Node.js con NPM:

A continuación, configure algunos scripts NPM para ayudar a ejecutar la aplicación:

Establecer y compilar el contrato Solidity

Solidity es un lenguaje de programación de alto nivel utilizado para crear contratos inteligentes en la Blockchain de Ethereum. En este tutorial, configuraremos un contrato inteligente para que emita eventos desde la Blockchain de Ethereum una vez que se haya enviado un mensaje.

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 continuación, compilaremos este contrato inteligente en una forma que pueda ser utilizada fácilmente por nuestra aplicación Node.js. Esta compilación se realiza utilizando Truffle.

Una vez realizada la compilación, se genera un archivo JSON que describe el contrato inteligente en una carpeta dentro del directorio actual. build/contracts dentro del directorio actual.

Configuración de aplicaciones Node.js

Para asegurar la ejecución sin problemas de nuestra aplicación, necesitamos algunas variables de entorno configuradas en nuestra aplicación. Estas nos permiten utilizar fácilmente la Conversation API de Vongage para interactuar con nuestro nodo 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
    };

El ID de la aplicación Nexmo, la clave API y el secreto APP se encuentran en el panel de control de la aplicación y deben almacenarse en un archivo .env dentro del directorio actual. Estas constantes se inicializan con nuestra instancia de Vonage SDK.

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
});

La Conversation API de Vonage ofrece una gran cantidad de API para permitir la comunicación en tiempo real a través de varios canales (voz, texto, Video). Las interacciones a través de estos canales pueden iniciarse creando una Conversación.

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

El ID de conversación devuelto se utiliza para emitir y escuchar los eventos que se produzcan en esta conversación.

Los usuarios se creado para interactuar en esta conversación mediante afiliación. También tomamos nota del ID de miembro 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);
        }
    });

Conectarse a la cadena de bloques Ethereum

Para interactuar con nuestro Nodo Ethereum local (un programa que se conecta a la red Ethereum, proporcionado por Ganache-cli en este caso con fines de prueba) a través de Node.js, utilizamos Web3un conjunto de librerías que proporciona APIs para aplicaciones JavaScript y Node.js para conectarse a un Nodo Ethereum.

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

Aquí, usamos un proveedor WebSocket que conecta nuestra aplicación Node.js al cliente Ganache-cli cliente RPC. El Ganache-cli necesita ser iniciado después de la instalación con el comando

A continuación, pasamos información sobre el contrato inteligente a nuestra aplicación Node.js e instanciamos el contrato. La información del contrato se encuentra en el archivo ABI (Application Binary Interface) contenida en el archivo JSON autogenerado al compilar nuestro 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);

Como puede observar en el fragmento de código anterior, necesitamos una Account desde la que se enviarán las transacciones. Ganache-cli proporciona un par de cuentas de prueba y sus claves privadas asociadas que se utilizan a lo largo del proceso de desarrollo.

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

Enviar un mensaje a la red

A continuación, enviamos un mensaje al Nodo Ethereum y creamos un evento de Conversación una vez que el hash de la transacción esté disponible. El evento Conversation contiene los datos (mensaje enviado) de la transacción.

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);
        }
    });
});

Escuche los eventos de Blockchain

También podríamos escuchar el NewText evento emitido desde la Blockchain. Una vez que este evento tenga éxito, podríamos emitir un evento de Conversación personalizado que podría ser utilizado por una interfaz de usuario para escuchar mensajes de la 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;
        }
    });
})

Póngalo todo junto

Ha llegado el momento de probar nuestra aplicación. Primero, nos aseguramos de que Ganache-cli se está ejecutando en el terminal y nuestro contrato inteligente se ha compilado con Truffle. Una vez hecho esto, ejecutamos npm start en una nueva instancia de terminal para ejecutar nuestra aplicación.

Un vistazo a nuestros Ganache-cli en el terminal debería mostrar que eth_sendTransaction y eth_subscribe en nuestro nodo Ethereum, lo que indica el inicio de una transacción y la suscripción a un evento por parte de nuestra aplicación Node.js.

Logs in the terminal

¿Y ahora qué?

Podríamos ampliar esta aplicación creando una aplicación de chat completa en la cadena de bloques, con un tratamiento de errores más sólido, indexación de mensajes en la cadena de bloques y mucho más.