Verbindung zur Ethereum-Blockchain mit Node.js und Vonage

Blockchain ist ein weit verbreiteter Begriff, mit dem viele Innovationen verbunden sind. Die Blockchain ist im wahrsten Sinne des Wortes eine Kette von Blöcken, wobei jeder Block eine Information darstellt, die in einer öffentlichen Datenbank, der Kette, gespeichert ist. Eine solche Blockchain ist Ethereum, die das Konzept der Blockchain auf eine ganz neue Ebene hebt.

Ethereum ist ein verteilter Ledger, in dem sich die Nutzer bequem über die Ausführung von Code und die Aktualisierung von Daten einigen können. Der auszuführende Code ist eine verteilte Anwendung, die eine Logik enthält, die die Interaktion zwischen einer Benutzeroberfläche und den Daten auf der Blockchain ermöglicht. Ein wichtiges Hilfsmittel für die Interaktion zwischen der Blockchain und einer Benutzeroberfläche sind Ereignisse.

Intelligente Verträge senden Ereignisse von der Blockchain aus, auf die eine Benutzeroberfläche hören kann, um bestimmte Aktionen zu aktivieren und Ereignisprotokolle (Daten) in die Blockchain zu schreiben. Diese Protokolle können auch von der Benutzeroberfläche angefordert werden.

In diesem Tutorial lernen wir etwas über Blockchain-Ereignisse und wie diese Ereignisse mit der Vonage Conversation API verknüpft werden können. Vonage-Gesprächs-API um reale Anwendungen zu erstellen.

Der Code für diesen Artikel ist auf GitHub.

Voraussetzungen

• Grundlegendes Verständnis der Blockchain

• Grundlegendes Verständnis von JavaScript und Node.js

• Nodejs, Ganache-cli, und Trüffel auf Ihrem Rechner installiert

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

Eine Anwendung erstellen

Um mit der Vongage Conversation API zu beginnen, müssen Sie zunächst eine Anwendung erstellen. Dies können Sie über Ihr Vonage APIs Dashboard tun, indem Sie auf die Schaltfläche "Neue Anwendung erstellen" klicken.

Create Vonage APIs Application

Während des Erstellungsprozesses werden ein öffentlicher und ein privater Schlüssel generiert. Der private Schlüssel wird automatisch auf Ihren lokalen Rechner heruntergeladen und sollte sicher aufbewahrt werden.

Nachdem die Anwendung erstellt wurde, erhalten Sie eine Anwendungs-ID und einen API-Schlüssel für den programmatischen Zugriff auf die Vonage APIs-Anwendung sowie den privaten Schlüssel auf unserem lokalen Rechner.

Abhängigkeiten installieren

Der letzte Schritt, bevor wir mit dem Schreiben von Code beginnen, ist die Installation unserer Node.js-Abhängigkeiten mit NPM:

Als Nächstes richten Sie einige NPM-Skripte ein, die Ihnen bei der Ausführung der Anwendung helfen:

Solidity-Vertrag einrichten und kompilieren

Solidity ist eine hochentwickelte Programmiersprache zur Erstellung von Smart Contracts auf der Ethereum Blockchain. In diesem Tutorial werden wir einen Smart Contract einrichten, der Ereignisse von der Ethereum-Blockchain ausgibt, sobald eine Nachricht gesendet wurde.

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

Als Nächstes werden wir diesen intelligenten Vertrag in eine Form kompilieren, die von unserer Node.js-Anwendung problemlos verwendet werden kann. Diese Kompilierung erfolgt mit Truffle.

Sobald die Kompilierung abgeschlossen ist, wird eine JSON-Datei, die den Smart Contract beschreibt, in einem build/contracts Ordner im aktuellen Verzeichnis abgelegt.

Node.js-Anwendung einrichten

Um die reibungslose Ausführung unserer Anwendung zu gewährleisten, müssen wir einige Umgebungsvariablen in unserer Anwendung einrichten. Diese ermöglichen uns die einfache Nutzung der Vongage Conversation API zur Interaktion mit unserem Ethereum-Knoten.

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

Die Nexmo-Anwendungs-ID, der API-Schlüssel und das APP-Geheimnis sind auf dem Dashboard der Anwendung zu finden und sollten in einer .env Datei innerhalb des aktuellen Verzeichnisses gespeichert werden. Diese Konstanten werden mit unserer Vonage SDK-Instanz initialisiert.

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

Die Vonage Conversation API bietet eine Vielzahl von APIs, die Echtzeitkommunikation über verschiedene Kanäle (Sprache, Text, Video) ermöglichen. Interaktionen über diese Kanäle können durch das Erstellen einer Konversation.

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

Die zurückgegebene Konversations-ID wird zum Senden und Abhören von Ereignissen verwendet, die in dieser Konversation auftreten.

Benutzer werden dann erstellt um an dieser Konversation über Mitgliedschaft. Wir notieren uns auch die daraus resultierende Mitglieds-ID.

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

Verbindung mit der Ethereum-Blockchain

Zur Interaktion mit unserem lokalen Ethereum-Knoten (ein Programm, das sich mit dem Ethereum-Netzwerk verbindet, bereitgestellt von Ganache-cli in diesem Fall zu Testzwecken) über Node.js, verwenden wir Web3eine Reihe von Bibliotheken, die APIs für JavaScript- und Node.js-Anwendungen bereitstellen, um eine Verbindung zu einem Ethereum Node herzustellen.

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

Hier verwenden wir einen WebSocket-Provider, der unsere Node.js-Anwendung mit dem Ganache-cli RPC-Client verbindet. Der Ganache-cli muss nach der Installation mit dem Befehl gestartet werden:

Als Nächstes übergeben wir Informationen über den intelligenten Vertrag an unsere Node.js-Anwendung und instanziieren den Vertrag. Die Vertragsinformationen finden sich in der ABI (Application Binary Interface), die in der JSON-Datei enthalten ist, die bei der Kompilierung unseres intelligenten Vertrags automatisch generiert wurde.

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

Wie Sie vielleicht im obigen Codeschnipsel sehen, benötigen wir ein Konto, von dem aus die Transaktionen gesendet werden sollen. Ganache-cli stellt einige Testkonten und die dazugehörigen privaten Schlüssel bereit, die während des gesamten Entwicklungsprozesses verwendet werden.

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

Senden einer Nachricht an das Netzwerk

Als Nächstes senden wir eine Nachricht an den Ethereum-Knoten und erstellen ein Konversationsereignis, sobald der Transaktionshash verfügbar ist. Das Gesprächsereignis enthält die Daten (gesendete Nachricht) der Transaktion.

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

Für Blockchain-Veranstaltungen zuhören

Wir könnten auch auf das NewText Ereignis, das von der Blockchain ausgegeben wird. Sobald dieses Ereignis erfolgreich ist, könnten wir ein benutzerdefiniertes Konversationsereignis ausgeben, das von einer Benutzeroberfläche verwendet werden könnte, um auf Nachrichten von der Blockchain zu warten.

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

Alles zusammenfügen

Jetzt ist es an der Zeit, unsere Anwendung zu testen! Zuerst stellen wir sicher, dass Ganache-cli im Terminal läuft und unser Smart Contract mit Truffle. Sobald dies geschehen ist, starten wir npm start in einer neuen Terminalinstanz, um unsere Anwendung auszuführen.

Ein Blick auf unsere Ganache-cli Logs im Terminal sollte die eth_sendTransaction und eth_subscribe APIs auf unserem Ethereum-Knoten aufgerufen werden, was den Beginn einer Transaktion und das Abonnement eines Ereignisses durch unsere Node.js-Anwendung anzeigt

Logs in the terminal

Was kommt als Nächstes?

Wir könnten auf dieser Anwendung aufbauen, indem wir eine vollwertige Chat-Anwendung auf der Blockchain entwickeln, einschließlich einer robusteren Fehlerbehandlung, Indizierung von Nachrichten auf der Blockchain und vieles mehr!