Weiter zum Hauptinhalt
Change page

Sprachen von Smart Contracts

Seite zuletzt aktualisiert: 26. Februar 2026

PredatorixPopens in a new tab
Coram_DeoCopens in a new tab
franziheifopens in a new tab
+18

Das Tolle an Ethereum ist, dass Smart Contracts mit relativ Entwickler-freundlichen Sprachen programmiert werden können. Wenn Sie Erfahrung mit Python oder einer Sprache mit geschweiften Klammernopens in a new tab haben, können Sie eine Sprache mit vertrauter Syntax finden.

Die zwei häufig genutzten und aktuellsten Sprachen sind:

  • Solidity
  • Vyper

Remix IDE bietet eine umfassende Entwicklungsumgebung zum Erstellen und Testen von Contracts in Solidity als auch in Vyper. Probieren Sie die Remix IDE im Browser ausopens in a new tab, um mit dem Programmieren zu beginnen.

Erfahrenere Entwickler möchten vielleicht auch Yul, eine Zwischensprache für die Ethereum Virtual Machine, oder Yul+, eine Erweiterung von Yul, verwenden.

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

Wichtige Links

Beispielvertrag

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 andere Verträge zugänglich
7    address public minter;
8    mapping (address => uint) public balances;
9
10    // Ereignisse ermöglichen es Clients, auf bestimmte
11    // von Ihnen deklarierte Vertragsänderungen zu reagieren
12    event Sent(address from, address to, uint amount);
13
14    // Konstruktor-Code wird nur ausgeführt, wenn der Vertrag
15    // erstellt wird
16    constructor() {
17        minter = msg.sender;
18    }
19
20    // Sendet eine Menge neu erstellter Münzen 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 Menge vorhandener Münzen
29    // von einem beliebigen Aufrufer an eine Adresse
30    function send(address receiver, uint amount) public {
31        require(amount <= balances[msg.sender], "Guthaben nicht ausreichend.");
32        balances[msg.sender] -= amount;
33        balances[receiver] += amount;
34        emit Sent(msg.sender, receiver, amount);
35    }
36}
Alles anzeigen

Dieses Beispiel soll ein Gefühl vermitteln, wie die Smart-Contract-Syntax in Solidity aussieht. Eine detailliertere Beschreibung der Funktionen und Variablen finden Sie in der Dokumentationopens in a new tab.

Vyper

  • Pythonische Programmiersprache
  • Starke Typisierung
  • 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

Für weitere Informationen lesen Sie die Begründung für Vyperopens in a new tab.

Wichtige Links

Beispiel

1# Offene Auktion
2
3# Auktionsparameter
4
5# Der Begünstigte erhält Geld vom Höchstbietenden
6
7beneficiary: public(address)
8auctionStart: public(uint256)
9auctionEnd: public(uint256)
10
11# Aktueller Stand der Auktion
12
13highestBidder: public(address)
14highestBid: public(uint256)
15
16# Wird am Ende auf „true“ gesetzt, verbietet jede Änderung
17
18ended: public(bool)
19
20# Nachverfolgung der zurückgezahlten Gebote, damit wir dem Auszahlungsmuster folgen können
21
22pendingReturns: public(HashMap[address, uint256])
23
24# Erstellt eine einfache Auktion mit `_bidding_time`
25
26# Sekunden Bietzeit im Namen der
27
28# Begünstigten-Adresse `_beneficiary`.
29
30@external
31def __init__(_beneficiary: address, _bidding_time: uint256):
32    self.beneficiary = _beneficiary
33    self.auctionStart = block.timestamp
34    self.auctionEnd = self.auctionStart + _bidding_time
35
36# Mit dem Wert, der zusammen mit dieser Transaktion
37
38# gesendet wird, auf die Auktion bieten.
39
40# Der Wert wird nur dann zurückerstattet,
41
42# wenn die Auktion nicht gewonnen wird.
43
44@external
45@payable
46def bid():
47    # Prüfen, ob die Bietfrist abgelaufen ist.
48    assert block.timestamp < self.auctionEnd
49    # Prüfen, ob das Gebot hoch genug ist
50    assert msg.value > self.highestBid
51    # Rückerstattung für den vorherigen Höchstbietenden nachverfolgen
52    self.pendingReturns[self.highestBidder] += self.highestBid
53    # Neues Höchstgebot nachverfolgen
54    self.highestBidder = msg.sender
55    self.highestBid = msg.value
56
57# Ein zuvor erstattetes Gebot abheben. Das Auszahlungsmuster wird
58
59# hier verwendet, um ein Sicherheitsproblem zu vermeiden. Wenn Rückerstattungen direkt
60
61# als Teil von bid() gesendet würden, könnte ein bösartiger Bietvertrag
62
63# diese Rückerstattungen blockieren und somit das Eingehen neuer, höherer Gebote verhindern.
64
65@external
66def withdraw():
67    pending_amount: uint256 = self.pendingReturns[msg.sender]
68    self.pendingReturns[msg.sender] = 0
69    send(msg.sender, pending_amount)
70
71# Die Auktion beenden und das höchste Gebot an
72
73# den Begünstigten senden.
74
75@external
76def endAuction():
77    # Es ist eine gute Richtlinie, Funktionen, die mit anderen Verträgen interagieren
78    # (d. h. sie rufen Funktionen auf oder senden Ether),
79    # in drei Phasen zu gliedern:
80    # 1. Überprüfung der Bedingungen
81    # 2. Ausführung von Aktionen (potenziell ändernde Bedingungen)
82    # 3. Interaktion mit anderen Verträgen
83    # Wenn diese Phasen vermischt werden, könnte der andere Vertrag
84    # in den aktuellen Vertrag zurückrufen und den Zustand ändern oder bewirken,
85    # dass Effekte (Ether-Auszahlung) mehrmals ausgeführt werden.
86    # Wenn intern aufgerufene Funktionen die Interaktion mit externen
87    # Verträgen beinhalten, müssen sie ebenfalls als Interaktion mit
88    # externen Verträgen betrachtet werden.
89
90    # 1. Bedingungen
91    # Prüfen, ob die Endzeit der Auktion erreicht ist
92    assert block.timestamp >= self.auctionEnd
93    # Prüfen, ob diese Funktion bereits aufgerufen wurde
94    assert not self.ended
95
96    # 2. Effekte
97    self.ended = True
98
99    # 3. Interaktion
100    send(self.beneficiary, self.highestBid)
Alles anzeigen

Dieses Beispiel soll ein Gefühl vermitteln, wie die Smart-Contract-Syntax in Vyper aussieht. Eine detailliertere Beschreibung der Funktionen und Variablen finden Sie in der Dokumentationopens 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 Ewasmopens in a new tab, ein WebAssembly im Ethereum-Stil, und ist als brauchbarer gemeinsamer Nenner beider Plattformen konzipiert.
  • 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
  • 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

Wichtige Links

Beispielvertrag

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 viel Erfahrung mit Smart Contracts haben, finden Sie eine vollständige ERC20-Implementierung in Yul hieropens in a new tab.

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

Wichtige Links

Beispielvertrag

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

Wie Sie die richtige Wahl treffen

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. Weitere Informationen dazu finden Sie im Abschnitt Lernen durch Programmieren.
  • 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.

Sprachvergleiche

Vergleiche von grundlegender Syntax, Vertragslebenszyklus, Schnittstellen, Operatoren, Datenstrukturen, Funktionen, Kontrollfluss und mehr finden Sie in diesem Spickzettel von Auditlessopens in a new tab

Weiterführende Lektüre

War dieser Artikel hilfreich?