Weiter zum Hauptinhalt
Change page

Sprachen von Smart Contracts

Das Tolle an Ethereum ist, dass Smart Contracts mit relativ Entwickler-freundlichen Sprachen programmiert werden können. Wenn Sie mit Python oder einer anderen Sprache mit geschweiften Klammern(opens in a new tab) vertraut sind, können Sie eine Sprache mit vertrauter Syntax finden.

Die zwei häufig genutzten und aktuellsten Sprachen sind:

  • Solidity
  • Vyper

Für erfahrene Entwickler könnten außerdem Yul, eine intermediäre Sprache für die Ethereum-Virtual Machine, oder Yul+, eine Erweiterung für Yul, interessant sein.

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

Voraussetzungen

Vorwissen über andere Programmiersprachen, insbesondere JavaScript oder Python, ist hilfreich, um Smart-Contract-Sprachen und die Unterschiede zwischen den jeweiligen Sprachen schneller zu verstehen. Wir empfehlen Ihnen außerdem, sich mit dem Grundkonzept von Smart Contracts vertraut zu machen, bevor Sie sich die Unterschiede der Smart-Contract-Sprachen genauer ansehen. 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 Variable ist zur Kompilationszeit bekannt)
  • Unterstützt:
    • Vererbung (Sie können andere Smart Contracts erweitern)
    • Bibliotheken (Sie können wiederverwertbaren Code programmieren, den Sie von verschiedenen Smart Contracts aus abrufen können – wie z. B. in statischen Funktionen in einer statischen Klasse in anderen objektorientierten Programmiersprachen)
    • Komplexe benutzerdefinierte Typen

Beispiel

1// SPDX-License-Identifier: GPL-3.0
2pragma solidity >= 0.7.0;
3
4contract Coin {
5    // Das Schlüsselwort "public" macht Variablen
6    // für anderen Verträgen zugreifbar
7    address public minter;
8    mapping (address => uint) public balances;
9
10    // Ereignisse ermöglichen es Nutzern spezifisch auf
11    // von deklarierte Vertragsänderungen zu reagieren
12    event Sent(address from, address to, uint amount);
13
14    // Die Konstruktoranweisungen werden nur ausgeführt wenn
15    // der Vertrag erstellt wird
16    constructor() {
17        minter = msg.sender;
18    }
19
20    // Sendet eine Anzahl neu erstellter Coins an eine Adresse
21    // Kann nur vom Vertragsersteller aufgerufen werden
22    function mint(address receiver, uint amount) public {
23        require(msg.sender == minter);
24        require(amount < 1e60);
25        balances[receiver] += amount;
26    }
27
28    // Sendet eine Anzahl vorhandener Coins
29    // von einem Aufrufer an eine Adresse
30    function send(address receiver, uint amount) public {
31        require(amount <= balances[msg.sender], "Insufficient balance.");
32        balances[msg.sender] -= amount;
33        balances[receiver] += amount;
34        emit Sent(msg.sender, receiver, amount);
35    }
36}
Alles anzeigen
 Kopieren

Dieses Beispiel soll ein Gefühl vermitteln, wie die Smart-Contract-Syntax in Solidity aussieht. Für eine ausführliche Beschreibung aller Funktionen und Variablen sollten Sie die Dokumentation lesen(opens in a new tab).

Vyper

  • Pythonische Programmiersprache
  • Stark typisiert
  • Kompilierter Code ist kurz und nachvollziehbar
  • Effiziente Bytecode-Generierung
  • Hat beabsichtigterweise weniger Funktionen als Solidity – mit dem Ziel, die Smart Contracts sicherer und einfacherer auditierbar zu machen. Vyper bietet keine Untersützung für:
    • Modifikationen
    • Vererbung
    • Inline-Assembly
    • Funktionsüberladung
    • Operatorüberladung
    • Rekursive Abfragen
    • Schleifen mit unendlicher Länge
    • Binäre Fixpunkte

Weitere Informationen finden Sie im Vyper-Grundprinzip(opens in a new tab).

Beispiel

1# Öffne Auktion
2
3# Auktionsparameter
4# Begünstigter erhält Geld vom Meistbietenden
5beneficiary: public(address)
6auctionStart: public(uint256)
7auctionEnd: public(uint256)
8
9# Aktueller Stand der Auktion
10highestBidder: public(address)
11highestBid: public(uint256)
12
13# Setze am Ende auf wahr, um jede Änderung zu verbieten
14ended: public(bool)
15
16# Erstattete Gebote nachverfolgen, um dem Abhebemuster folgen zu können
17pendingReturns: public(HashMap[address, uint256])
18
19# Eine einfache Auktion mit `_bidding_time`
20# Sekunden Bieterzeit für die
21# Begünstigtenadresse `_beneficiary` erstellen.
22@external
23def __init__(_beneficiary: address, _bidding_time: uint256):
24    self.beneficiary = _beneficiary
25    self.auctionStart = block.timestamp
26    self.auctionEnd = self.auctionStart + _bidding_time
27
28# Biete in der Auktion mit dem Betrag der
29# zusammen mit dieser Transaktion gesendet wurde.
30# Der Betrag wird nur erstattet, wenn die
31# Auktion nicht gewonnen wurde.
32@external
33@payable
34def bid():
35    # Prüfe, ob die Bietezeit vorrüber ist.
36    assert block.timestamp < self.auctionEnd
37    # Prüfe, ob Gebot hoch genug ist
38    assert msg.value > self.highestBid
39    # Verfolge die Erstattung der vorigen Meistbietenden nach
40    self.pendingReturns[self.highestBidder] += self.highestBid
41    # Verfolge das neue Höchstgebot nach
42    self.highestBidder = msg.sender
43    self.highestBid = msg.value
44
45# Ziehe ein zuvor erstattetes Gebot zurück. Das Abhebemuster
46# wird verwendet um ein Sicherheitsproblem zu vermeiden. Wenn Erstattungen direkt
47# als Teil von bid() gesendet würden, könnte ein böswilliger Bieter-Vertrag
48# diese Erstattungen blockieren und damit den Eingang neuer Höchstgebote.
49@external
50def withdraw():
51    pending_amount: uint256 = self.pendingReturns[msg.sender]
52    self.pendingReturns[msg.sender] = 0
53    send(msg.sender, pending_amount)
54
55# Beende die Auktion und sende das Höchstgebot
56# an den Begünstigten.
57@extern
58def endAuction():
59    # Es ist eine gute Richtlinie, Funktionen zu strukturieren, die
60    # mit anderen Verträgen interagieren (d. h. sie rufen Funktionen auf oder senden Ether),
61    # in drei Phasen zu unterteilen:
62    # 1. Bedingungen prüfen
63    # 2. Aktionen ausführen (potentiell die Bedingungen ändernd)
64    # 3. mit anderen Verträgen interagieren
65    # Wenn diese Abschnitte vermischt werden, könnte der andere Vertrag
66    # zurück im aktuellen Vertrag ein Aufruf durchführen und den Zustand verändern oder
67    # Effekte (Ether-Auszahlung) mehrfach ausführen.
68    # Wenn interne Funktionen aufgerufen werden, die eine Interaktion mit externen
69    # Verträgen beinhalten, muss auch die Interaktion mit
70    # den externen Verträgen berücksichtigt werden.
71
72    # 1. Bedingungen
73    # Prüfe ob der Zeitpunkt des Auktionsendes erreicht wurde
74    assert block.timestamp >= self.auctionEnd
75    # Prüfe ob diese Funktion bereit aufgerufen wurde
76    assert not self.ended
77
78    # 2. Effekte
79    self.ended = True
80
81    # 3. Interaktion
82    send(self.beneficiary, self.highestBid)
Alles anzeigen
 Kopieren

Dieses Beispiel soll ein Gefühl vermitteln, wie die Smart-Contract-Syntax in Vyper aussieht. Eine ausführlicher Beschreibung aller Funktionen und Variablen finden Sie in der Dokumentation(opens in a new tab).

Yul und Yul+

Falls Sie noch nicht mit Ethereum vertraut sind und Sie noch nie mit Smart-Contract-Sprachen programmiert haben, empfehlen wir Ihnen, zunächst mit Solidity oder Vyper anzufangen. Verwenden Sie Yul oder Yul+ bitte nur dann, wenn Sie sich mit den bewähren Methoden für sicheres Programmieren mit Smart-Contract-Sprachen und den Besonderheiten beim Arbeiten mit der EVM auskennen.

Yul

  • Intermediäre Sprache für Ethereum.
  • Unterstützt die EVM und Ewasm(opens in a new tab), eine Ethereum ähnliche WebAssembly, sie ist so konzipiert, dass sie ein nutzbarer gemeinsamer Nenner für beide Plattformen ist
  • Ein gutes Ziel für High-Level-Optimierungsstufen, von denen sowohl EVM als auch eWASM-Plattformen gleichermaßen profitieren können

Yul+

  • Eine hocheffiziente Yul-Erweiterung auf unterer Ebene
  • Wurde ursprünglich für einen Optimistic Rollup-Vertrag konzipiert
  • Yul+ kann als ein Vorschlag für ein experimentelles Upgrade für Yul betrachtet werden, das neue Funktionen hinzufügt

Beispiel

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

1{
2    function power(base, exponent) -> result
3    {
4        switch exponent
5        case 0 { result := 1 }
6        case 1 { result := base }
7        default
8        {
9            result := power(mul(base, base), div(exponent, 2))
10            if mod(exponent, 2) { result := mul(base, result) }
11        }
12    }
13    let res := power(calldataload(0), calldataload(32))
14    mstore(0, res)
15    return(0, 32)
16}
Alles anzeigen

Wenn Sie bereits Erfahrung mit Smart Contracts haben, finden Sie hier(opens in a new tab) eine vollständige ERC20-Implementierung in Yul.

Fe

  • Statisch typisierte Sprache für die Ethereum-Virtual Machine (EVM)
  • Inspiriert von Python und Rust
  • Es soll einfach zu erlernen sein – auch für Entwickler, die neu im Ethereum-Ökosystem sind
  • Die Fe-Entwicklung befindet sich noch in der Anfangsphase, die Alpha-Version der Sprache wurde im Januar 2021 veröffentlicht

Beispiel

Im Folgenden ist ein einfacher Vertrag in Fe implementiert:

1type BookMsg = bytes[100]
2
3contract GuestBook:
4    pub guest_book: map<address, BookMsg>
5
6    event Signed:
7        book_msg: BookMsg
8
9    pub def sign(book_msg: BookMsg):
10        self.guest_book[msg.sender] = book_msg
11
12        emit Signed(book_msg=book_msg)
13
14    pub def get_msg(addr: address) -> BookMsg:
15        return self.guest_book[addr].to_mem()
16
Alles anzeigen

So wählen Sie die richtige Sprache

Wie bei jeder anderen Programmiersprache geht es vor allem darum, das geeignete Tool für den richtigen Job nach den persönlichen Präferenzen zu wählen.

Im Folgenden finden Sie einige Apsekte, die Sie in Betracht ziehen können, wenn Sie noch keine der Sprachen ausprobiert haben:

Was ist gut an Solidity?

  • Wenn Sie Anfänger sind, gibt es viele Tutorials und Lerntools. Mehr dazu finden Sie im Bereich Beim Programmieren lernen.
  • Gute Entwicklertools verfügbar
  • Solidity hat eine große Entwickler-Community. Das bedeutet, dass Sie höchstwahrscheinlich ziemlich schnell Antworten auf Ihre Fragen finden.

Was ist gut an Vyper?

  • Gute Einstiegsmöglichkeit für Python-Entwickler, um Smart Contracts kennenzulernen und in das Thema einzusteigen
  • Vyper bietet weniger Funktionen und das erleichtert ein schnelleres Prototyping von Ideen.
  • Vyper hat sich zum Ziel gesetzt, leicht auditierbar und möglichst für Menschen lesbar zu sein.

Was ist gut an Yul und Yul+?

  • Einfache und funktionale Low-Level-Sprachen
  • Ermöglicht die Annäherung an rohe EVM, was dazu beitragen kann, den Ressourcnverbrauch Ihrer Smart Contracts zu optimieren.

Vergleich zwischen den Sprachen

Für Vergleiche von Basissyntax, des Vertragslebenszyklus, Schnittstellen, Operatoren, Datenstrukturen, Funktionen, Steuerungsfluss und mehr sollten Sie sich diesen Spickzettel von Auditless(opens in a new tab) ansehen.

Weiterführende Informationen

back-to-top ↑

War dieser Artikel hilfreich?