Deployment von Smart Contracts auf die Blockchain [blockcentric #5]

Unsere Artikelserie „blockcentric“ behandelt Blockchain-verwandte Technologien, Projekte, Organisation und Konzerne. Die Serie enthält Wissen und Ergebnisse unserer Arbeit sowie Neuigkeiten, aus diesem Bereich.
Unser Anwendungsfall „Blockchain in der Supply Chain“ ist in mehrere Teile gegliedert:
Teil 1 (General introduction)
Teil 2 (Supply Chain platform)
Teil 3 (Implementation on the shop floor)
Teil 4 (Smart Contracts for asset tracking)
Dieser Artikel (Deploying Smart Contracts on the blockchain)
Eine entsprechende Implementierung ist auf unserer Demo Seite zu finden: https://asset-tracker.codecentric.de/

1. Smart Contracts

Smart Contracts sind einer der interessantesten Aspekte, wenn es um das Thema Blockchain im Allgemeinen oder Ethereum im Speziellen geht. Sie bilden das Herzstück einer dezentralisierten Applikation und ermöglichen uns die Entwicklung einer neuen Form von Software.

In diesem Artikel geht es darum, einen beispielhaften Smart Contract mithilfe verschiedener Tools zu kompilieren, auf einem Ethereum Testnetzwerk zu deployen und anschließend zu nutzen.

2. Truffle – Das Allzweck-Framework für Ethereum

Zunächst widmen wir uns Truffle. Hierbei handelt es sich um ein Entwickler-Framework, das unseren Alltag mit Smart Contracts um ein Vielfaches einfacher gestaltet. Es unterstützt uns beim Managen von verschiedenen Netzwerken, bzw. dem Migrieren auf eben diese, und bietet uns eine interaktive Konsole für eine direkte Kommunikation mit unserem Smart Contract. Zunächst begeben wir uns dafür auf unsere Konsole und installieren truffle:

npm install -g truffle

In einem leeren Verzeichnis führen wir nun folgenden Befehl aus, um eine Default-Umgebung für unseren Contract zu schaffen:

truffle init

Wichtig ist für uns zunächst die Konfigurationsdatei truffle.js. Hierbei tragen wir nachfolgende Modulkonfigurationen ein:

1module.exports =
2  networks: {
3    development: {
4      host: 'localhost',
5      port: 8545,
6      network_id: '*'},
7    rinkeby: {
8      host: 'localhost',
9      port: 8545,
10      network_id: 4,
11      gas: 4612390,
12     },
13   },
14};

Der erste Teil ist für Testzwecke gedacht, der zweite definiert unser ausgewähltes Live-Netzwerk, in unserem Fall Rinkeby. Die Netzwerke können wir nun über das Flag
“–network rinkeby” aufrufen. Folgende Konfigurationswerte sind hierbei außerdem nützlich:

gas

Gibt das Gaslimit für das Veröffentlichen an. (default 4712388 wei)

gasPrice

Gasmenge, die für das Veröffentlichen genutzt wird. (default 100 gwei )

from

Gibt die Adresse an, von der aus unser Smart Contract migriert wird. (Default ist der erste Account unseres Ethereum Clients)

Für einen Überblick über die verschiedenen Werteinheiten ist folgender Artikel sehr zu empfehlen.

Nun benötigen wir einen Smart Contract, den wir auf unsere Blockchain schreiben können. Hierfür wird ein einfaches “Hello World” Skript verwendet. Das Solidity-Skript sieht folgendermaßen aus:

1pragma solidity ^0.4.2;
2contract helloWorld { 
3 function sayHelloWorld () returns (string) { 
4   return 'HelloWorld'; 
5 } 
6}

Unser Solidity-Skript wird nun in den “contract” Ordner kopiert. Der Inhalt des Unterverzeichnisses wird mit folgendem Befehl (aus dem Hauptverzeichnis des Projektes heraus) kompiliert und ist somit bereit, um veröffentlicht bzw. genutzt zu werden:

truffle compile

Nach dem Kompilieren kümmern wir uns um die Migrationsdateien. Hierbei handelt es sich um JavaScript-Dateien, die uns helfen, unser Skript auf den verschiedenen Netzwerken zu veröffentlichen. Sie sind zuständig für das Anstoßen der Deployment Tasks und sind sehr nützlich bei wiederholten Migrationen auf privaten Blockchain-Netzwerken.

Beim Initiieren von Truffle wurde bereits eine Beispieldatei erstellt, die wir kopieren und anpassen können. Hierbei setzen wir lediglich den Namen unseres Contracts ein:

1var helloWorld = artifacts.require("./helloWorld.sol");
2
3module.exports = function(deployer) {
4   deployer.deploy(helloWorld);
5};

Mittlerweile sollte unsere Projektstruktur folgenden Aufbau haben:

1TestApplikation
2   .idea
3    - build
4      -- contracts
5        --- helloWorld.json
6        --- Migrations.json
7    - contracts
8      -- helloworld.sol
9      -- Migrations.sol
10    - migrations
11      -- 1_initial_migration.js
12      -- 2_deployHelloWorld.js
13    - test
14   index.html
15   package.json
16   truffle.js

3. Geth – Kommandozeilen-Interface für die Blockchain

Geth ist ein Kommandozeilen-Interface, das einen vollständigen Ethereum-Node lokal laufen lässt und diesen auch mit der tatsächlichen Blockchain synchronisiert. Dies ermöglicht uns die Kommunikation mit dem Netzwerk zum Ausführen von Transaktionen, Mining oder dem Veröffentlichen von Smart Contracts. Hierfür muss beim erstmaligen Starten die Ethereum-Blockchain bzw. unser Testnetzwerk heruntergeladen werden. Dies nimmt einmalig etwas Zeit in Anspruch (Hierbei bleibt Zeit für die eine oder andere Tasse Kaffee). Diesen Prozess starten wir also mit den benötigten Flags sowie den verwendeten APIs.

geth --rinkeby --rpc --rpcapi web3,personal,eth

Während das Testnetzwerk Rinkeby heruntergeladen wird und die ersten Tassen geleert wurden, schauen wir uns die Konsole von Geth einmal genauer an. Hierfür starten wir ein neues Fenster und öffnen die Konsole, indem wir uns auf die laufende Instanz aufschalten.

geth attach

Nun erstellen wir uns einen Account für unser Testnetzwerk und überprüfen anschließend, ob alles funktioniert hat, indem wir uns alle bestehenden Accounts anzeigen lassen.

personal.newAccount("MyPassword")
eth.accounts

4. Rinkeby – Deployment auf einem Testnetzwerk

Wie bereits weiter oben angedeutet, verwenden wir das Netzwerk Rinkeby. Dies verfolgt, ähnlich dem Kovan-Netzwerk, einen Proof of Authority anstelle eines Proof of Work bzw. Proof of Stake Ansatz.

Um einen Contract auf dieses Netzwerk zu deployen, benötigen wir etwas Ether. Über die Rinkeby-Seite können wir uns zu Testzwecken Ether schicken lassen (Rinkeby Faucet ). Hierbei müssen wir lediglich einen öffentlichen Post bei Google+, Twitter oder Facebook erstellen, der unseren Public Key als Inhalt hat. Diesen verlinken wir anschließend auf der Faucet-Seite von Rinkeby, sodass wir unser Ether bekommen. Mit folgendem command überprüfen wir nun unser Ether “Bankkonto”.

eth.getBalance(eth.coinbase);

Mit unserem Ether ist es uns möglich, den Smart Contract auf dem Testnetzwerk zu veröffentlichen. Hierfür ist es nötig, den erstellten Account in unserer geth-Konsole zu entsperren.

web3.personal.unlockAccount("AccountAdresse", "Passwort");

Optional ist es möglich, einen Zeitparameter zu übergeben, der festlegt, wie lange der Account für Transaktionen genutzt werden kann. In unserem Testszenario ergibt dies Sinn, da viele Dinge in diesem Umfeld mehrere Anläufe benötigen, bis sie entsprechend funktionieren. Anschließend können wir unseren Smart Contract auf das Rinkeby-Netzwerk deployen. Dabei reicht es aus, im Hauptverzeichnis des Projektes truffle --network rinkeby migrate aufzurufen, wodurch all unsere Migrationsdateien ausgeführt werden.

Nun, da wir unseren Vertrag veröffentlich haben, wollen wir uns ein paar Möglichkeiten ansehen, wie wir diesen verwenden können. Zunächst bietet “Etherscan.io” die Funktion an, auf den Vertrag zuzugreifen. Für diesen Zweck gehen wir auf rinkeby.etherscan.io und suchen, mit Hilfe unserer Contract-Adresse, unser Solidity-Skript. Hier sehen wir eine Übersicht über vergangene Transaktionen, den Bytecode/Opcode sowie die Möglichkeit nach ähnlichen Contracts zu suchen.

Um nun mit unserem Contract zu interagieren, nutzen wir ein weiteres Mal Truffle und starten die Konsole des Frameworks:

truffle --network rinkeby console

Zunächst prüfen wir, ob alles funktioniert hat. Hierbei sollten alle Informationen zu unserem Contract aufgelistet werden:

helloWorld.deployed();

Anschließend wollen wir die funktion sayHelloWorld() aus unserem Skript aufrufen:

contract = helloWorld.deployed().then((instance) => helloContract = instance);

contract.sayHelloWorld.call();

Geschafft! Nun sollten wir auf unserer Konsole die Antwort unseres Smart Contracts lesen, nachdem wir ihn auf Rinkeby veröffentlich haben.

5. Fazit

In diesem Artikel haben wir uns dem Deployment von Smart Contracts gewidmet. Hierbei haben wir das Testnetzwerk Rinkeby genutzt, allerdings lässt sich das gezeigte Vorgehen ebenfalls auf die Main-Blockchain von Ethereum anwenden. Es werden laufend neue Werkzeuge entwickelt und vorgestellt, die uns diese Arbeitsschritte vereinfachen. Es lohnt sich ein Auge auf die zukünftigen Neuerungen zu halten.

Mehr zum Thema Blockchain bei der codecentric AG gibt es hier: Blockchain Paper-Bag-Lunch