Se connecter à la blockchain Ethereum avec Node.js et Vonage

La blockchain est un terme couramment utilisé auquel sont associées de nombreuses innovations. La blockchain est, littéralement, une chaîne de blocs, où chaque bloc est une information stockée dans une base de données publique, la chaîne. L'une de ces blockchains est Ethereum, qui porte le concept de blockchain à un tout autre niveau.

Ethereum est un grand livre distribué où les utilisateurs peuvent se mettre d'accord sur l'exécution du code et la mise à jour des données. Le code exécuté est une application distribuée qui contient une logique permettant l'interaction entre une interface utilisateur et des données sur la blockchain. Les événements facilitent grandement les interactions entre la blockchain et une interface utilisateur.

Les contrats intelligents émettent des événements de la blockchain qu'une interface utilisateur peut écouter pour activer des actions spécifiques et écrire des journaux d'événements (données) sur la blockchain. Ces journaux peuvent également être demandés par l'interface utilisateur.

Dans ce tutoriel, nous en apprendrons plus sur les événements de la blockchain et sur la façon dont ces événements peuvent être liés à l'API de conversation de Vonage. Conversation API de Vonage de Vonage pour créer des Applications du monde réel.

Le code de cet article se trouve sur GitHub.

Conditions préalables

• Compréhension de base de la blockchain

• Compréhension de base de JavaScript et Node.js

• Nodejs, Ganache-cliet Truffle installés sur votre machine

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

Créer une application

Pour commencer à utiliser l'API Conversation de Vonage, vous devez d'abord créer une application. Vous pouvez le faire à partir de votre tableau de bord Vonage APIs en cliquant sur le bouton "Créer une nouvelle application".

Create Vonage APIs Application

Au cours du processus de création, des clés publiques et privées sont générées. La clé privée est automatiquement téléchargée sur votre machine locale et doit être conservée en lieu sûr.

Une fois l'application créée, vous recevrez un identifiant d'application et une clé API pour accéder de manière programmatique à l'application Vonage APIs, ainsi que la clé privée sur notre machine locale.

Installer les dépendances

La dernière étape avant de commencer à écrire du code est d'installer nos dépendances Node.js avec NPM :

Ensuite, mettez en place quelques scripts NPM pour faciliter l'exécution de l'application :

Mise en place et compilation du contrat Solidity

Solidity est un langage de programmation de haut niveau utilisé pour créer des contrats intelligents sur la blockchain Ethereum. Dans ce tutoriel, nous allons mettre en place un contrat intelligent pour émettre des événements à partir de la blockchain Ethereum une fois qu'un message a été envoyé.

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

Ensuite, nous allons compiler ce contrat intelligent sous une forme facilement utilisable par notre application Node.js. Cette compilation est réalisée à l'aide de Truffle.

Une fois la compilation effectuée, un fichier JSON décrivant le contrat intelligent est généré dans un dossier du répertoire courant. build/contracts dans le répertoire courant.

Configuration de l'application Node.js

Pour assurer la bonne exécution de notre application, nous avons besoin de quelques variables d'environnement mises en place dans notre application. Celles-ci nous permettent d'utiliser facilement la Conversation API de Vongage pour interagir avec notre nœud 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
    };

L'ID de l'application Nexmo, la clé API et le secret APP se trouvent sur le tableau de bord de l'application et doivent être stockés dans un fichier .env dans le répertoire actuel. Ces constantes sont initialisées avec notre instance SDK 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
});

L'API Conversation de Vonage fournit une série d'API permettant une communication en temps réel sur plusieurs canaux (voix, texte, vidéo). Les interactions via ces canaux peuvent être initiées en créant une Conversation.

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

L'identifiant de conversation renvoyé est utilisé pour émettre et écouter les événements qui se produisent dans cette conversation.

Les utilisateurs sont ensuite créés pour interagir dans cette conversation par l'intermédiaire de l'adhésion. Nous prenons également note de l'identifiant du membre qui en résulte.

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

Se connecter à la blockchain Ethereum

Pour interagir avec notre nœud Ethereum local (un programme qui se connecte au réseau Ethereum, fourni par le logiciel Ganache-cli dans ce cas à des fins de test) à travers Node.js, nous utilisons Web3, un ensemble de bibliothèques qui fournit des API pour les applications JavaScript et Node.js afin de se connecter à un Node Ethereum.

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

Ici, nous utilisons un fournisseur WebSocket qui connecte notre application Node.js au client Ganache-cli client RPC. Le fournisseur Ganache-cli doit être démarré après l'installation avec la commande :

Ensuite, nous transmettons des informations sur le contrat intelligent à notre application Node.js et nous instançons le contrat. Les informations sur le contrat se trouvent dans le fichier ABI (Application Binary Interface) contenue dans le fichier JSON autogénéré à partir de la compilation de notre smart contract.

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

Vous remarquerez peut-être dans l'extrait de code ci-dessus que nous avons besoin d'un Account à partir duquel les transactions seront envoyées. Ganache-cli fournit quelques Account de test et leurs clés privées associées qui sont utilisés tout au long du processus de développement.

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

Envoyer un message au réseau

Ensuite, nous envoyons un message au nœud Ethereum et créons un événement Conversation une fois que le hachage de la transaction est disponible. L'événement Conversation contient les données (message envoyé) de la transaction.

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

Écouter les événements liés à la blockchain

Nous pourrions également écouter l'événement NewText émis par la blockchain. Une fois que cet événement est réussi, nous pourrions émettre un événement Conversation personnalisé qui pourrait être utilisé par une interface utilisateur pour écouter les messages 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;
        }
    });
})

Tout assembler

Il est maintenant temps de tester notre application ! Tout d'abord, nous nous assurons que Ganache-cli s'exécute dans le terminal et que notre contrat intelligent a été compilé avec la commande Truffle. Une fois cela fait, nous lançons npm start dans une nouvelle instance de terminal pour exécuter notre application.

Un coup d'œil à nos Ganache-cli dans le terminal devrait montrer que les eth_sendTransaction et eth_subscribe appelées sur notre Node Ethereum, ce qui indique le début d'une transaction et une souscription à un événement par notre application Node.js.

Logs in the terminal

Quelle est la prochaine étape ?

Nous pourrions nous appuyer sur cette application en construisant une application de chat à part entière sur la blockchain, incluant une gestion des erreurs plus robuste, l'indexation des messages sur la blockchain, et bien plus encore !