Solidity – Die Smart Contract-Programmiersprache

Solidity ist eine objektorientierte Programmiersprache für die Entwicklung von Smart Contracts für die Blockchain, primär für Ethereum. Die Programmiersprache ist von der Syntax ähnlich zu JavaScript, C++ und Python.

Die Aufgabe von Solidity ist es, den Quellcode von Smart Contracts für die Ethereum Virtual Machine (EVM) bereitzustellen. Mit einem Compiler wird daraus ein Smart Contract. Ein Beispiel für einen Quellcode in Solidity sieht folgendermaßen aus:


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MyContract {
function helloWorld() public pure returns (string memory)
{
return "Hello, World!";
}
}

Wer einen Einstieg in die Entwicklung von Solidity sucht, sollte sich zunächst die Ethereum Developer Resources näher ansehen. In der Dokumentation zu Solidity gibt es zahlreiche Beispiele und Informationen, wie Smart Contracts oder andere Programme mit Solidity leicht zu erstellen sind.

Es gibt im Internet aber zahlreiche Quellen und Kurse, die beim Einstieg in Solidity helfen. Wer mit der Blockchain-Technologie arbeitet, kommt auf Dauer kaum um Solidity herum, vor allem nicht, wenn es um die Entwicklung von Smart Contracts geht.

Auf LinkedIn Learning stehen einige Kurse für die Entwicklung von Smart Contracts mit Remix und Solidity zur Verfügung, zum Beispiel „Blockchain: Grundlagen für Java-Entwickler“

Visual Studio und Visual Studio Code – Entwickeln mit Solidity

Um mit Solidity zu entwickeln, stehen mehrere IDEs zur Verfügung. Visual Studio kann mit Solidity zusammenarbeiten und auch Visual Studio Code kann als Editor mit Visual Studio Code genutzt werden. Microsoft stellt dazu Erweiterungen für Visual Studio Code zur Verfügung.

Um den Quellcode zu kompilieren, stellt Microsoft noch die Erweiterung ETHcode zur Verfügung. Die Erweiterung kann den Quellcode des Smart Contracts kompilieren und ausführen.

Dazu wird eine Verbindung zu den Ethereum-Testnetzwerken aufgebaut. Als dritte Erweiterung für die Entwicklung von Smart Contracts für die Ethereum-Blockchain sollten Entwickler, die mit Visual Studio arbeiten, noch das Blockchain Development Kit for Ethereum von Microsoft installieren.

Smart Contracts mit browserbasierter Umgebung entwickeln – Remix und ATOM

Über die Adresse https://remix.ethereum.org steht die browserbasierte Entwicklungsumgebung Remix zur Verfügung. Mit dieser ist es möglich, in der Ethereum-Blockchain Anwendungen zu entwickeln, ohne lokal ein Programm oder Erweiterungen installieren zu müssen.

Natürlich ist die Entwicklungsumgebung auch dazu in der Lage, Solidity-Code zu kompilieren. Wir gehen in diesem Beitrag noch ausführlich auf diese einfache Möglichkeit ein Smart Contracts zu entwickeln.

Der Editor ATOM ist ebenfalls sinnvoll beim Entwickeln von Smart Contracts für Ethereum. Für den Editor gibt es noch die Erweiterung Atom Solidity Linter und Etheratom.

Mit den beiden Erweiterungen für ATOM kann Solidity-Code effektiv entwickelt und in der Ethereum-Blockchain getestet werden.

Einstieg in Solidity mit Remix

Der einfachste und schnellste Weg, um in Solidity einzusteigen und Programme oder Smart Contracts mit Solidity zu entwickeln, geht über die bereits erwähnte, browserbasierte Entwicklungsumgebung Remix. Die Umgebung steht kostenlos zur Verfügung.

Eine Anmeldung oder Registrierung ist nicht notwendig, die IDE steht im Browser sofort zur Verfügung. Die komplette Entwicklung findet im Webbrowser statt.

Das bedeutet aber nicht, dass Remix nicht für professionelle Zwecke einsetzbar ist. Es lassen sich auch komplexe Smart Contracts auf Basis von Solidity mit Remix entwickeln.

Remix kann den Programmcode und die anderen Ressourcen eines Programmes auf der lokalen Festplatte jeden Computers speichern, aber auch in Quellcode-Verwaltungen wie Gist, GitHub und anderen Systemen.

Um die Entwicklung mit Solidity zu beginnen, steht die Schaltfläche „Solidity“ zur Verfügung. Durch einen Klick passt Remix die Umgebung für die Entwicklung eines Smart Contracts an und integriert auch bereits einige Beispiele dafür.

Auf der linken Seite von Remix sind verschiedene Icons zu sehen. Das erste Icon in der Reihe öffnet „File Explorers“.

Durch das Aktivieren von Solidity in Remix erstellt die IDE erste Beispiele, die hier zu sehen sind. Hier legen Sie auch später eigene Workspaces und eigene Dateien für die Programmierung an.

Über „Contracts“ zeigt Remix einige Beispiele an. Durch einen Klick auf eine *.sol-Datei ist der Quellcode auf der rechten Seite zu sehen. Die geöffneten Dateien sind im oberen Bereich ebenfalls über verschiedene Registerkarten zu sehen.

Hier ist es auch möglich, zwischen den Dateien umzuschalten. Es ist in Remix problemlos umsetzbar, mehrere Programme und Smart Contracts gleichzeitig zu entwickeln.

Über das Zahnrad-Symbol im unteren Bereich stehen die allgemeinen Einstellungen für Remix zur Verfügung. Mehr ist für die erste Verwendung von Remix nicht zu wissen, der Einstieg ist sehr einfach.

Praxis mit der Solidity-Entwicklung in Remix

Beim Speichern von Quellcode in Remix dient auch der Cache des Webbrowsers als Storage. Daher sollten Entwickler vorsichtig damit sein, den Cache des Speichers zu löschen.

Es ist sinnvoll, eine Übertragung des Codes zu einer Codeverwaltung wie GitHub vorzunehmen, oder zumindest den Quellcode gelegentlich lokal zu speichern.

Für die Entwicklung von Smart Contracts mit Solidity spielt auch der Solidity Compiler eine Rolle. Dieser startet über das zweite Icon in der linken Leiste.

Über den Menüpunkt „Compiler“ lässt sich die Version von Solidity auswählen, mit welcher Remix den aktuellen Code kompilieren soll.

Auch die EVM-Version (Ethereum Virtual Machine), mit welcher der Smart Contract laufen soll, ist hier wählbar. Der Compiler ist bei der Entwicklung vor allem dazu notwendig, um regelmäßig den Code zu überprüfen und lokal ausführen zu können.

Über die Schaltfläche „Compile“ kompiliert Remix den Quellcode zu einem Smart Contract, mit den ausgewählten Einstellungen.

Mittels des nächsten Icons auf der linken Seite öffnet sich „Deploy & Run Transactions“. Damit lassen sich kompilierte Smart Contracts in der Blockchain oder auch lokal bereitstellen.

Über „Environment“ ist es möglich, mit „Javascript VM“ zunächst eine lokale Bereitstellung des Smart Contracts durchzuführen, um zu testen, ob der Code funktioniert.

Durch die Auswahl von „Injected Web3“ und „Web3 Provider“ sind auch Bereitstellungen in öffentlichen Blockchains möglich. In diesem Fall muss noch eine Anbindung an die jeweilige Blockchain erfolgen. Das lässt sich zum Beispiel auch über das Browser-Plugin MetaMask erledigen, das mit Remix zusammenarbeitet.

Über das Icon „Solidity Static Analysis“ startet ein Plug-in für Remix, das die IDE durch die Auswahl von Solidity beim Aufrufen integriert hat.

Die Analyse untersucht den Quellcode und zeigt an, wo es Verbesserungen und Probleme bei der Umsetzung des Smart Contracts gibt.

Vor allem Security-Hinweise und die Best Practices spiele eine wichtige Rolle, da dadurch der Quellcode des Smart Contracts sicherer gestaltet werden kann.

Unterhalb der „Solidity Static Analysis“ befindet sich das Icon zum Starten des Solidity Unit Testing. Damit sind Tests des Codes auch in Remix möglich.

Weitere Funktionen zum Testen finden sich im letzten Icon. Hier besteht die Möglichkeit, zusätzliche Plug-ins in die IDE zu laden.

Die bereits integrierten Plug-ins befinden sich im oberen Bereich und lassen sich hier auch deaktivieren. Bei „Inactive Modules“ stehen weitere Module für Remix zur Verfügung, zum Beispiel auch Solidity 2 UML.

Damit steht ein Unified Modeling Language (UML)-Klassendiagrammgenerator für Solidity-Smart Contracts in Remix zur Verfügung.

Erstellen eines ersten Smart Contracts mit Solidity und Remix

Um einen eigenen Smart Contract mit Remix zu erstellen, ist es am einfachsten, Remix zu öffnen und zunächst Solidity als Umgebung auszuwählen.

Über das File Explorer Icon steht oben das Plus Icon zur Verfügung, um einen neuen Workspace zu erstellen.

Über das Icon zum Erstellen einer neuen Datei integriert Remix diese in den neuen Workspace. Der Name der Datei muss die Endung *.sol haben, z. B. „hallo.sol“.

Remix öffnet die Datei anschließend. In der Mitte des Fensters können Sie mit der Programmierung beginnen. Ein Smart Contract auf Basis von Solidity beginnt immer zunächst mit der Pragmazeile.

Diese steuert, welche Basis der Smart Contract haben soll und welche Version von Solidity zum Einsatz kommt. Da Remix Intellisense beherrscht, schlägt die IDE die jeweiligen Werte vor.

Ein Beispiel für eine Pragmazeile ist:


pragma solidity >=0.7.0 <0.9.0;


Danach kommt die Zeile, die definiert, dass Sie einen Smart Contract entwickeln und der Name des Smart Contracts. Nach einer geschweiften Klammer beginnt der eigentliche Code für den Smart Contract, und er endet auch mit einer geschweiften Klammer:


contract Hallo {
}
</code<

Innerhalb des Smart Contracts kann es unter anderem ein Feld des Typs String geben, das eine Variable „hallo“ nutzt und einen Constructor. Im Constructor weisen wir in diesem Beispiel der Variable „hallo“ den Wert „Ich bin ein Smart Contract“ zu.


contract Hallo {
string hallo;
constructor() {
hallo = „Ich bin ein Smart Contract“;
}
}



Dieses einfache Beispiel lässt sich bereits kompilieren. Dazu klicken Sie in Remix auf das Icon zum Starten des Solidity-Compilers.

Für einen ersten Test ist es nicht notwendig, Anpassungen vorzunehmen. Wichtig ist, dass die Compiler-Version zur angegebenen Solidity-Version in der Pragmazeile passt. Über „Compile hallo.sol“ kompiliert Remix den Quellcode.

Erscheinen keine Fehler, ist der Code bis an diese Stelle korrekt.  Tauchen Fehler auf, zeigt das Remix an und Sie können den Code an der passenden Stelle verbessern.

Im unteren Bereich des Compilers zeigt dieser im Fehlerfall auch an, warum die Kompilierung nicht funktioniert.

Häufig vergessen Entwickler Semikolons ; am Ende der Zeile. Diese sind in Solidity genauso notwendig, wie in Java. Auch geöffnete und geschlossene, geschweifte Klammern vergessen Entwickler häufig, sodass der Compiler einen Fehler anzeigt.

Um den Smart Contract mit Aktionen zu füllen, ist es zu Beispiel möglich Funktionen zu integrieren, in diesem Beispiel unterhalb des Constructors:


contract Hallo {
string hallo;
constructor() {
hallo = „Hallo, ich bin ein Smart Contract“;
}
function hallofunktion() public view returns (string memory) {
return hallo;
}
}



Die Funktion „hallofunktion“ gibt den Wert der Variable „hallo“ öffentlich zurück. Dabei nutzt die Funktion „view“. Dadurch liest der Code den Wert nur aus, er ändert keine Werte.

Die Ausgabe ist ein String. Wichtig bei der Verwendung von Variablen in Solidity und Smart Contracts mit Ethereum ist der Umgang mit der Speicherung der Werte und Variablen.

Die EVM muss einen Speicher zur Verfügung haben, der für die Variable zur Verfügung steht. In diesem Beispiel erfolgt das in der Zeile:

function hallo() public view returns (string memory) {

Durch Angabe von „memory“. Das legt fest, dass die Daten im Arbeitsspeicher zur Verfügung stehen sollen.  Nach dem erfolgreichen Kompilieren des Vertrags kann die Funktion über das Icon zum Bereitstellen bereits getestet werden.

Durch Auswahl von „JavaScript VM“  bei der Bereitstellung von Smart Contracts führt Remix den Smart Contract nicht in der öffentlichen Ethereum-Blockchain aus, sondern in einer Remix-lokalen Ethereum-VM.

Für einen Test reicht es aus, die Option „Javascript VM“ auszuwählen und auf „Deploy“ zu klicken. Anschließend zeigt Remix im unteren Bereich des Fensters an, dass der Smasrt Contract erfolgreich gelaufen ist.

Links unten im Fenster zeigt der Bereitstellungsassistent die erfolgreiche Transaktion in der lokalen Blockchain an, welche den Smart Contract angelegt hat.

Funktionen des Smart Contracts zeigt Remix mit einer Schaltfläche an, die durch einen Klick die Funktion im Smart Contract startet.

Unterhalb der Schaltfläche zeigt Remix das Ergebnis der Funktion an. In diesem Beispiel ist das die Ausgabe des Strings „Ich bin ein Smart Contract“

Der Smart Contract führt in diesem Beispiel keine Aktionen aus, sondern liest nur Werte aus der lokalen Blockchain aus. Sinnvolle Smart Contracts führen natürlich auch Aktionen aus, schreiben also auch Werte in die Blockchain.

In diesem Beispiel erstellen wir dazu eine weitere Funktion, die einen Wert in die Variable der Blockchain zurückschreibt und ergänzen den Smart Contract:



contract Hallo {
string hallo;
constructor() {
hallo = „Hallo, ich bin ein Smart Contract“;
}

function hallofunktion() public view returns (string memory) {
return hallo;
}

function hallofunktion2(string calldata a) public {
hallo= a;
}
}

Die neue Funktion „hallofunktion2“ setzt den String-Wert auf a und ändert die Variable „hallo“ auf „a“. Das ist natürlich ein sehr einfaches Beispiel. Anschließend kann auch dieser Smart Contract wieder über die Bereitstellen-Funktion in Remix in der lokalen Javascript-VM gespeichert werden.

Danach stehen zwei Smart Contracts in der Blockchain bereit, denn die erste Version haben wir bereit auf der Blockchain gespeichert.

Die Erweiterung und anschließend Bereitstellung des erweiterten Smart Contracts wird als neuer Smart Contract in der Blockchain gespeichert.

Der Compiler zeigt den neuen Smart Contract unterhalb des anderen Smart Contracts an. Der neue Smart Contract verfügt über zwei Funktionen und damit auch über zwei Schaltflächen.

Durch einen Klick auf das Feld neben „hallofunktion2“ lässt sich jetzt der Wert beliebig ändern, zum Beispiel zu „Hallo, ich bin ein neuer Smart Contract“.

Durch das Aufrufen der ersten Schaltfläche „hallofunktion“ liest diese den neuen Wert aus der Blockchain aus. Das Ausführen von Aktionen über die Funktion „hallofunktion2“ löst eine Transaktion auf der Blockchain aus.

Fazit

Mit Remix können Entwickler sehr schnell in die Programmierung von Smart Contracts mit Ethereum und Solidity einsteigen.

Die Speicherung und Ausführung von Smart Contracts und deren Transaktionen ist problemlos auch in einer eigenen Blockchain möglich, zu Testzwecken auch in der JavaScript-VM von Remix.

In der Dokumentation von Solidity gibt es zahlreiche Informationen dazu. Wer Solidity mit Remix nutzt, erhält einige Beispiel Smart Contracts, die sich erweitern und für eigene Funktionen nutzen lassen.