Smart-Contract-Development: "Arbeiten mit Lochkarten" im 21 Jahrhundert

Dapps

Anwendungen im Kontext von Smart Contracts werden als Decentralized App oder Dapp bezeichnet. Sie bestehen aus einer UI einem oder mehreren Smart Contract und dem zugehörigen State auf der Blockchain. Werden für den Anwendungsfall auch Daten aus der realen Welt benötigt, sind weitere Services integriert:

UI und Umsysteme können mit altbekannten Technologien und Architekturmustern umgesetzt werden.
Auf die Blockchain wird mittels eines Clients zugegriffen.

Die Blockchain kann also im Kontext von Dapps als verteilte Datenbank (State) und verteiltes Service-Repository (Smart Contract) verstanden werden.

Smart Contract schreiben und deployen

Ein Smart Contract hat ähnlich einer Klasse Variablen, die den aktuellen Zustand abbilden, und Methoden, die diese Variablen (State) verändern können.

Um einen Smart Contract ausführbar zu machen wird zuerst der Sourcecode mittels eines Compilers in Bytecode umgewandelt, welcher in einer Laufzeitumgebung ausgeführt werden kann. Zusätzlich zum Bytecode liefert der Compiler eine Interfacedefinition für den Contract.

Ein Smart Contract hat somit einige Ähnlichkeit mit einem in einer virtuellen Maschine deployten Service, der über seine API angesprochen werden kann.

Um einen Smart Contract zu deployen muss er in einer Blockchain abgelegt werden. Dazu wird eine Transaktion in die Blockchain aufgenommen, die den Bytecode des Smart Contracts enthält. Als Ergebnis der Transaktion erhält der Absender die Adresse des Smart Contracts in der Blockchain.

Smart Contract aufrufen

Mit der Adresse des Smart Contracts in der Blockchain und dem Interface kann nun jeder Node der Blockchain den Smart Contract ansprechen. Die folgenden Beispielbefehle sind für die CLI des Ethereum Clients geth. ABI steht dabei für Application Binary Interface, dem Interface-Format der Laufzeitumgebung.

smartContractStub = eth.contract($smartContractABI);
smartContract = smartContractStub.add($smartContractAdress);

Um den aktuellen State des Smart Contracts abzufragen reicht ein einfacher Methodenaufruf in der lokalen virtuellen Maschine.

smartContract.getBalance();

Um den Zustand eines Smart Contracts zu verändern muss eine Transaktion in die Blockchain erfolgen, welche die Adresse des Contracts, die aufzurufende Methode und die Methoden-Parameter beinhaltet.

smartContract.setBalance.sendTransaction(10);

Wird die Transaktion in der Blockchain akzeptiert ist der neue State in der Blockchain festgeschrieben. Dies ist immer mit einer zeitlichen Verzögerung verbunden, die mehrere Minuten dauern kann.

Smart Contract may never die

Da der Code des Smart Contracts unter ein festen Adresse ablegt ist, und die Blockchain nachträglich nicht veränderbar ist, ist es nicht möglich den Smart Contract zurückzunehmen oder durch eine neue Version zu ersetzen.

Das ist insbesondere bei Bugs im Smart Contract problematisch.

Um diesem Problem zu begegnen ist es möglich Smart Contracts abschaltbar zu machen. Für Ethereum, welches Solidity als Programmiersprache für Contracts verwendet, wird dies durch die Funktion „selfdestruct“ und eine Vererbung gelöst:

// this contract is used to make other contracts „killable“
contract mortal {
    /* Define variable owner of the type address*/
    address owner;
    /* this function is executed at initialization and sets the owner of 
       the contract */
    function mortal() { owner = msg.sender; }
    /* Function to recover the funds on the contract */
    function kill() { if (msg.sender == owner) selfdestruct(owner); }
}

contract ContractA is mortal { … }

Eine Deaktivierung des Contract ist nur durch den Owner (Deployer des Contract) möglich.

Damit ergibt sich der folgende Life-Cycle für einen Smart Contract:

Lochkarten im 21 Jahrhundert

Durch die Ablage des Bytecodes in der Blockchain kann schnell das Gefühl aufkommen Softwareentwicklung wie im letzten Jahrhundert zu betreiben:

  1. Sourcecode anpassen
  2. Lochkarte neu stanzen (Smart Contract kompilieren)
  3. Lochkarte zum Großrechner tragen (Transaktion mit Smart Contract an die Blockchain schicken)
  4. Zeitfenster auf dem Großrechner abwarten (Bestätigung der Transaktion abwarten)
  5. Ergebnis abholen (State über Methodenaufruf inspizieren um Fehler zu finden)
  6. Goto 1.

Es gibt zwar ein paar Tools, die bei diesem Prozess unterstützen doch selbst bei bekanntesten Smart Contract Plattformen Ethereum sind diese weit entfernt von heutigen IDEs wie Eclipse, Idea oder Netbeans. Das ist zum einen der rasanten Weiterentwicklung von Ethereum selbst geschuldet. Zum anderen scheint die Community rund um Ethereum nicht in der Lage oder willens zu sein sich auf eine stringente Toolchain zu einigen.

In Summe muss, sowohl wegen des aktuellen Tool Stacks, als auch wegen der immanenten Wartezeiten, bei der Arbeit mit einer Blockchain mit signifikant längeren Entwicklungszyklen gerechnet werden, als man von der modernen Softwareentwicklung gewohnt ist.