Smart-Contract-Sprachen

Ein großartiger Aspekt von Ethereum ist, dass Smart Contracts mit relativ entwicklerfreundlichen Sprachen programmiert werden können. Wenn Sie Erfahrung mit Python oder einer Programmiersprache mit geschweiften Klammern (öffnet in einem neuen Tab) haben, können Sie eine Sprache mit vertrauter Syntax finden.

Die beiden aktivsten und am besten gepflegten Sprachen sind:

Solidity
Vyper

Die integrierte Entwicklungsumgebung (IDE) Remix bietet eine umfassende Entwicklungsumgebung zum Erstellen und Testen von Verträgen in Solidity und Vyper. Probieren Sie die browserbasierte Remix-IDE aus (öffnet in einem neuen Tab), um mit dem Programmieren zu beginnen.

Erfahrenere Entwickler möchten vielleicht auch Yul verwenden, eine Zwischensprache für die Virtuelle Ethereum-Maschine (EVM), oder Yul+, eine Erweiterung für Yul.

Wenn Sie neugierig sind und dabei helfen möchten, neue Sprachen zu testen, die sich noch in der intensiven Entwicklung befinden, können Sie mit Fe experimentieren, einer aufstrebenden Smart-Contract-Sprache, die noch in den Kinderschuhen steckt.

Voraussetzungen

Vorkenntnisse in Programmiersprachen, insbesondere in JavaScript oder Python, können Ihnen helfen, die Unterschiede zwischen Smart-Contract-Sprachen zu verstehen. Wir empfehlen Ihnen außerdem, Smart Contracts als Konzept zu verstehen, bevor Sie zu tief in die Sprachvergleiche eintauchen. Einführung in Smart Contracts.

Solidity

Objektorientierte Hochsprache zur Implementierung von Smart Contracts.
Sprache mit geschweiften Klammern, die am stärksten von C++ beeinflusst wurde.
Statisch typisiert (der Typ einer Variablen ist zur Kompilierzeit bekannt).
Unterstützt:
- Vererbung (Sie können andere Verträge erweitern).
- Bibliotheken (Sie können wiederverwendbaren Code erstellen, den Sie aus verschiedenen Verträgen aufrufen können – wie statische Funktionen in einer statischen Klasse in anderen objektorientierten Programmiersprachen).
- Komplexe benutzerdefinierte Typen.

Wichtige Links

Beispielvertrag

// SPDX-License-Identifier: GPL-3.0
pragma solidity >= 0.7.0;

contract Coin {
    // Das Schlüsselwort "public" macht Variablen
    // zugänglich von anderen Verträgen
    address public minter;
    mapping (address => uint) public balances;

    // Ereignisse erlauben es Clients, auf spezifische
    // von Ihnen deklarierte Vertragsänderungen zu reagieren
    event Sent(address from, address to, uint amount);

    // Konstruktor-Code wird nur ausgeführt, wenn der Vertrag
    // erstellt wird
    constructor() {
        minter = msg.sender;
    }

    // Sendet eine Menge neu erstellter Coins an eine Adresse
    // Kann nur vom Vertragsersteller aufgerufen werden
    function mint(address receiver, uint amount) public {
        require(msg.sender == minter);
        require(amount < 1e60);
        balances[receiver] += amount;
    }

    // Sendet eine Menge existierender Coins
    // von einem beliebigen Aufrufer an eine Adresse
    function send(address receiver, uint amount) public {
        require(amount <= balances[msg.sender], "Insufficient balance.");
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
        emit Sent(msg.sender, receiver, amount);
    }
}

Dieses Beispiel soll Ihnen ein Gefühl dafür geben, wie die Syntax von Solidity-Verträgen aussieht. Für eine detailliertere Beschreibung der Funktionen und Variablen lesen Sie die Dokumentation (öffnet in einem neuen Tab).

Vyper

Pythonische Programmiersprache
Starke Typisierung
Kleiner und verständlicher Compiler-Code
Effiziente Bytecode-Generierung
Hat absichtlich weniger Funktionen als Solidity, mit dem Ziel, Verträge sicherer und einfacher überprüfbar (auditierbar) zu machen. Vyper unterstützt Folgendes nicht:
- Modifikatoren (Modifiers)
- Vererbung
- Inline-Assembly
- Überladen von Funktionen
- Überladen von Operatoren
- Rekursive Aufrufe
- Endlosschleifen
- Binäre Festkommazahlen

Seit v0.4.0 unterstützt Vyper ein Modulsystem (öffnet in einem neuen Tab). Die Wiederverwendung von Code wird durch Komposition anstelle von Klassenvererbung erreicht.

Für weitere Informationen lesen Sie die Grundprinzipien (Rationale) von Vyper (öffnet in einem neuen Tab).

Wichtige Links

Beispiel

# Offene Auktion

# Auktionsparameter
# Begünstigter erhält Geld vom Höchstbietenden
beneficiary: public(address)
auctionStart: public(uint256)
auctionEnd: public(uint256)

# Aktueller Status der Auktion
highestBidder: public(address)
highestBid: public(uint256)

# Wird am Ende auf true gesetzt, verbietet jegliche Änderung
ended: public(bool)

# Verfolgt zurückerstattete Gebote, damit wir dem Auszahlungsmuster folgen können
pendingReturns: public(HashMap[address, uint256])

# Erstellt eine einfache Auktion mit `_bidding_time`
# Sekunden Bietzeit im Namen der
# Begünstigten-Adresse `_beneficiary`.
@deploy
def __init__(_beneficiary: address, _bidding_time: uint256):
    self.beneficiary = _beneficiary
    self.auctionStart = block.timestamp
    self.auctionEnd = self.auctionStart + _bidding_time

# Biete bei der Auktion mit dem Wert, der
# zusammen mit dieser Transaktion gesendet wird.
# Der Wert wird nur zurückerstattet, wenn die
# Auktion nicht gewonnen wird.
@external
@payable
def bid():
    # Prüfe, ob die Bietzeit abgelaufen ist.
    assert block.timestamp < self.auctionEnd
    # Prüfe, ob das Gebot hoch genug ist
    assert msg.value > self.highestBid
    # Verfolge die Rückerstattung für den vorherigen Höchstbietenden
    self.pendingReturns[self.highestBidder] += self.highestBid
    # Verfolge neues Höchstgebot
    self.highestBidder = msg.sender
    self.highestBid = msg.value

# Zahle ein zuvor zurückerstattetes Gebot aus. Das Auszahlungsmuster wird
# hier verwendet, um ein Sicherheitsproblem zu vermeiden. Wenn Rückerstattungen direkt
# als Teil von bid() gesendet würden, könnte ein bösartiger bietender Vertrag
# diese Rückerstattungen blockieren und somit das Eingehen neuer höherer Gebote verhindern.
@external
def withdraw():
    pending_amount: uint256 = self.pendingReturns[msg.sender]
    self.pendingReturns[msg.sender] = 0
    send(msg.sender, pending_amount)

# Beende die Auktion und sende das Höchstgebot
# an den Begünstigten.
@external
def endAuction():
    # Es ist eine gute Richtlinie, Funktionen, die mit
    # anderen Verträgen interagieren (d.h. sie rufen Funktionen auf oder senden Ether),
    # in drei Phasen zu strukturieren:
    # 1. Bedingungen prüfen
    # 2. Aktionen ausführen (möglicherweise Bedingungen ändern)
    # 3. Interaktion mit anderen Verträgen
    # Wenn diese Phasen vermischt werden, könnte der andere Vertrag
    # in den aktuellen Vertrag zurückrufen und den Zustand ändern oder bewirken,
    # dass Effekte (Ether-Auszahlung) mehrfach ausgeführt werden.
    # Wenn intern aufgerufene Funktionen Interaktionen mit externen
    # Verträgen beinhalten, müssen sie auch als Interaktion mit
    # externen Verträgen betrachtet werden.

    # 1. Bedingungen
    # Prüfe, ob die Endzeit der Auktion erreicht wurde
    assert block.timestamp >= self.auctionEnd
    # Prüfe, ob diese Funktion bereits aufgerufen wurde
    assert not self.ended

    # 2. Effekte
    self.ended = True

    # 3. Interaktion
    send(self.beneficiary, self.highestBid)

Dieses Beispiel soll Ihnen ein Gefühl dafür geben, wie die Syntax von Vyper-Verträgen aussieht. Für eine detailliertere Beschreibung der Funktionen und Variablen lesen Sie die Dokumentation (öffnet in einem neuen Tab).

Yul und Yul+

Wenn Sie neu bei Ethereum sind und noch nicht mit Smart-Contract-Sprachen programmiert haben, empfehlen wir Ihnen, mit Solidity oder Vyper zu beginnen. Beschäftigen Sie sich erst mit Yul oder Yul+, wenn Sie mit den Best Practices für die Sicherheit von Smart Contracts und den Besonderheiten der Arbeit mit der Virtuellen Ethereum-Maschine (EVM) vertraut sind.

Yul

Zwischensprache für Ethereum.
Unterstützt die EVM und Ewasm (öffnet in einem neuen Tab), ein auf Ethereum zugeschnittenes WebAssembly, und ist als nutzbarer gemeinsamer Nenner beider Plattformen konzipiert.
Gutes Ziel für High-Level-Optimierungsstufen, von denen sowohl EVM- als auch Ewasm-Plattformen gleichermaßen profitieren können.

Yul+

Eine Low-Level-, hocheffiziente Erweiterung für Yul.
Ursprünglich für einen Optimistic Rollup-Vertrag entwickelt.
Yul+ kann als experimenteller Upgrade-Vorschlag für Yul betrachtet werden, der neue Funktionen hinzufügt.

Wichtige Links

Beispielvertrag

Das folgende einfache Beispiel implementiert eine Potenzfunktion. Es kann mit solc --strict-assembly --bin input.yul kompiliert werden. Das Beispiel sollte in der Datei input.yul gespeichert werden.

{
    function power(base, exponent) -> result
    {
        switch exponent
        case 0 { result := 1 }
        case 1 { result := base }
        default
        {
            result := power(mul(base, base), div(exponent, 2))
            if mod(exponent, 2) { result := mul(base, result) }
        }
    }
    let res := power(calldataload(0), calldataload(32))
    mstore(0, res)
    return(0, 32)
}

Wenn Sie bereits viel Erfahrung mit Smart Contracts haben, finden Sie hier (öffnet in einem neuen Tab) eine vollständige ERC-20-Implementierung in Yul.

Fe

Statisch typisierte Sprache für die Virtuelle Ethereum-Maschine (EVM).
Inspiriert von Python und Rust.
Soll leicht zu erlernen sein – auch für Entwickler, die neu im Ethereum-Ökosystem sind.
Die Entwicklung von Fe befindet sich noch in einem frühen Stadium, die Sprache hatte ihre Alpha-Veröffentlichung im Januar 2021.

Wichtige Links

Beispielvertrag

Das Folgende ist ein einfacher Vertrag, der in Fe implementiert wurde.

type BookMsg = bytes[100]

contract GuestBook:
    pub guest_book: map<address, BookMsg>

    event Signed:
        book_msg: BookMsg

    pub def sign(book_msg: BookMsg):
        self.guest_book[msg.sender] = book_msg

        emit Signed(book_msg=book_msg)

    pub def get_msg(addr: address) -> BookMsg:
        return self.guest_book[addr].to_mem()

Wie man sich entscheidet

Wie bei jeder anderen Programmiersprache geht es hauptsächlich darum, das richtige Werkzeug für die jeweilige Aufgabe zu wählen, sowie um persönliche Vorlieben.

Hier sind ein paar Dinge, die Sie beachten sollten, wenn Sie noch keine der Sprachen ausprobiert haben:

Was ist das Tolle an Solidity?

Wenn Sie Anfänger sind, gibt es viele Tutorials und Lernwerkzeuge. Mehr dazu finden Sie im Abschnitt Lernen durch Programmieren.
Gute Entwickler-Tools verfügbar.
Solidity hat eine große Entwickler-Community, was bedeutet, dass Sie höchstwahrscheinlich recht schnell Antworten auf Ihre Fragen finden werden.

Was ist das Tolle an Vyper?

Großartiger Einstieg für Python-Entwickler, die Smart Contracts schreiben möchten.
Vyper hat eine geringere Anzahl an Funktionen, was es ideal für das schnelle Prototyping von Ideen macht.
Vyper zielt darauf ab, leicht überprüfbar (auditierbar) und maximal menschenlesbar zu sein.

Was ist das Tolle an Yul und Yul+?

Einfache und funktionale Low-Level-Sprache.
Ermöglicht es, viel näher an die reine EVM heranzukommen, was helfen kann, den Gas-Verbrauch Ihrer Verträge zu optimieren.

Sprachvergleiche

Für Vergleiche der grundlegenden Syntax, des Vertragslebenszyklus, der Schnittstellen, Operatoren, Datenstrukturen, Funktionen, des Kontrollflusses und mehr, schauen Sie sich diesen Spickzettel (Cheatsheet) von Auditless (öffnet in einem neuen Tab) an.

Smart-Contract-Sprachen

Voraussetzungen

Solidity

Wichtige Links

Beispielvertrag

Vyper

Wichtige Links

Beispiel

Yul und Yul+

Wichtige Links

Beispielvertrag

Fe

Wichtige Links

Beispielvertrag

Wie man sich entscheidet

Was ist das Tolle an Solidity?

Was ist das Tolle an Vyper?

Was ist das Tolle an Yul und Yul+?

Sprachvergleiche

Weiterführende Literatur