Zum Hauptinhalt springen
Change page

Smart-Contract-Sprachen

Letzte Aktualisierung der Seite: 26. Februar 2026

PredatorixP (opens in a new tab)
Coram_DeoC (opens in a new tab)
franziheif (opens in a new tab)
+19

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 anderen Programmiersprache mit geschweiften Klammern (opens in a new tab) haben, werden Sie eine Sprache mit vertrauter Syntax finden.

Die beiden aktivsten und am besten gepflegten Sprachen sind:

  • Solidity
  • Vyper

Die Remix IDE bietet eine umfassende Entwicklungsumgebung zum Erstellen und Testen von Verträgen in Solidity und Vyper. Probieren Sie die browserbasierte Remix IDE aus (opens in a new tab), um mit dem Programmieren zu beginnen.

Erfahrenere Entwickler möchten vielleicht auch Yul verwenden, eine Zwischensprache für die Ethereum Virtual Machine, oder Yul+, eine Erweiterung von 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 sich zu tief in die Sprachvergleiche einarbeiten. 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

1// SPDX-License-Identifier: GPL-3.0
2pragma solidity >= 0.7.0;
3
4contract Coin {
5    // Das Schlüsselwort "public" macht Variablen
6    // von anderen Verträgen aus 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 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 Menge existierender Coins
29    // von einem beliebigen 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}
Alle anzeigen

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 siehe die Dokumentation (opens in a new tab).

Vyper

  • Pythonische Programmiersprache
  • Strenge Typisierung
  • Kleiner und verständlicher Compiler-Code
  • Effiziente Bytecode-Generierung
  • Hat absichtlich weniger Funktionen als Solidity mit dem Ziel, Verträge sicherer und einfacher zu prüfen (auditieren) zu machen. Vyper unterstützt Folgendes nicht:
    • Modifikatoren (Modifiers)
    • Vererbung
    • Inline-Assembly
    • Funktionsüberladung
    • Operatorüberladung
    • Rekursive Aufrufe
    • Endlosschleifen
    • Binäre Festkommazahlen

Für weitere Informationen lesen Sie die Grundprinzipien von Vyper (opens in a new tab).

Wichtige Links

Beispiel

1# Offene Auktion
2
3# Auktionsparameter
4# Begünstigter erhält Geld vom Höchstbietenden
5beneficiary: public(address)
6auctionStart: public(uint256)
7auctionEnd: public(uint256)
8
9# Aktueller Status der Auktion
10highestBidder: public(address)
11highestBid: public(uint256)
12
13# Wird am Ende auf true gesetzt, verbietet jegliche Änderung
14ended: public(bool)
15
16# Rückerstattete Gebote nachverfolgen, damit wir dem Auszahlungsmuster folgen können
17pendingReturns: public(HashMap[address, uint256])
18
19# Erstelle eine einfache Auktion mit `_bidding_time`
20# Sekunden Bietzeit im Namen der
21# Begünstigten-Adresse `_beneficiary`.
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 bei der Auktion mit dem gesendeten Wert
29# zusammen mit dieser Transaktion.
30# Der Wert wird nur zurückerstattet, wenn die
31# Auktion nicht gewonnen wird.
32@external
33@payable
34def bid():
35    # Prüfe, ob die Bietzeit abgelaufen ist.
36    assert block.timestamp < self.auctionEnd
37    # Prüfe, ob das Gebot hoch genug ist
38    assert msg.value > self.highestBid
39    # Verfolge die Rückerstattung für den vorherigen Höchstbietenden
40    self.pendingReturns[self.highestBidder] += self.highestBid
41    # Verfolge neues Höchstgebot
42    self.highestBidder = msg.sender
43    self.highestBid = msg.value
44
45# Ein zuvor zurückerstattetes Gebot abheben. Das Auszahlungsmuster wird
46# hier verwendet, um ein Sicherheitsproblem zu vermeiden. Wenn Rückerstattungen direkt
47# als Teil von bid() gesendet würden, könnte ein bösartiger Biet-Vertrag
48# diese Rückerstattungen blockieren und somit das Eingehen neuer, höherer Gebote verhindern.
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@external
58def endAuction():
59    # Es ist eine gute Richtlinie, Funktionen, die mit
60    # anderen Verträgen interagieren (d.h. sie rufen Funktionen auf oder senden Ether),
61    # in drei Phasen zu strukturieren:
62    # 1. Bedingungen prüfen
63    # 2. Aktionen ausführen (möglicherweise Bedingungen ändern)
64    # 3. Interaktion mit anderen Verträgen
65    # Wenn diese Phasen vermischt werden, könnte der andere Vertrag
66    # in den aktuellen Vertrag zurückrufen und den Zustand ändern oder bewirken,
67    # dass Effekte (Ether-Auszahlung) mehrfach ausgeführt werden.
68    # Wenn intern aufgerufene Funktionen Interaktionen mit externen
69    # Verträgen beinhalten, müssen sie ebenfalls als Interaktion mit
70    # externen Verträgen betrachtet werden.
71
72    # 1. Bedingungen
73    # Prüfe, ob die Endzeit der Auktion erreicht wurde
74    assert block.timestamp >= self.auctionEnd
75    # Prüfe, ob diese Funktion bereits 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)
Alle anzeigen

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 siehe die Dokumentation (opens in a new 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 EVM vertraut sind.

Yul

  • Zwischensprache für Ethereum.
  • Unterstützt die EVM und Ewasm (opens in a new tab), eine Ethereum-spezifische 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 von 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.

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}
Alle anzeigen

Wenn Sie bereits viel 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.
  • Zielt darauf ab, leicht erlernbar zu 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 ist.

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
Alle anzeigen

Wie man sich entscheidet

Wie bei jeder anderen Programmiersprache geht es meistens darum, das richtige Werkzeug für die richtige 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 großartig 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 großartig an Vyper?

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

Was ist großartig an Yul und Yul+?

  • Vereinfachte und funktionale Low-Level-Sprache.
  • Ermöglicht es, viel näher an die rohe EVM heranzukommen, was helfen kann, den Gasverbrauch 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 von Auditless (opens in a new tab) an.

Weiterführende Literatur

War dieser Artikel hilfreich?