Möchtest du verstehen, was ERC20-Token sind und wie du sogar deinen eigenen erstellen kannst?
In diesem Ratgeber erfährst du alles Wichtige rund um ERC20-Tokens – von den technischen Grundlagen über eine Schritt-für-Schritt-Anleitung zur Erstellung deines eigenen Tokens bis hin zu fortgeschrittenen Themen wie Sicherheit und Integration.
Außerdem schauen wir uns reale Anwendungsfälle an und wagen einen Blick in die Zukunft.
Für alle, die wenig Zeit haben, werden ERC20 Tokens in diesem Video erklärt:
Die folgende Tabelle fasst die wichtigsten Merkmale zusammen:
| Feature | Beschreibung |
|---|---|
| Definition | ERC20 Tokens sind digitale Vermögenseinheiten, die auf der Ethereum-Blockchain nach einem festgelegten Standard operieren und durch Smart Contracts verwaltet werden. |
| Interoperabilität | Alle ERC20-Token folgen denselben Standards, wodurch sie von Wallets, Börsen und DApps universell unterstützt werden, ohne dass spezifische Anpassungen nötig sind. |
| Wichtige Funktionen |
|
| Vorteile | ERC20 bietet einfache Integration und breite Akzeptanz, was Entwicklern ermöglicht, sich auf die Projektlogik zu konzentrieren, statt auf grundlegende Token-Funktionen. |
| Token-Erstellung | Das Erstellen eines eigenen ERC20 Tokens kann relativ einfach mit Tools wie der Remix IDE erfolgen und erfordert keinen umfangreichen technischen Aufwand. |
| Anwendungsfälle | ERC20-Token finden vielfältige Anwendungen, z.B. als Stablecoins, Governance-Tokens für DeFi-Protokolle oder Utility-Tokens in verschiedenen Apps und Spielen. |
| Zukunftsperspektiven | ERC20-Tokens sind zentral für das Ethereum-Ökosystem und werden kontinuierlich durch neue Entwicklungen wie ERC223 und ERC777 erweitert und verbessert. |
Einführung in ERC20 Tokens
Was sind ERC20 Tokens?
ERC20-Token sind digitale Vermögenseinheiten auf der Ethereum-Blockchain, die einem gemeinsamen Standard folgen.
Vereinfacht gesagt: Ein ERC20-Token ist wie eine eigene kleine Kryptowährung, die du auf Ethereum erstellen und verwalten kannst.
Anders als Ether (ETH), die interne Währung des Ethereum-Netzwerks, werden ERC20-Token von Benutzern (z. B. Entwicklern oder Unternehmen) mittels Smart Contracts herausgegeben.
Der Begriff ERC20 steht für “Ethereum Request for Comment 20” – es handelt sich dabei um einen technischen Vorschlag, der zum Standard wurde.
Jeder ERC20-Token ist fungibel, das heißt jede Einheit ist gleichwertig und austauschbar – genau wie jede 1€-Münze den gleichen Wert hat, egal welche konkrete Münze du in der Hand hältst.
Ein ERC20-Token existiert ausschließlich als Eintrag in einem Smart Contract. Dieser Smart Contract verwaltet ein Register aller Kontostände: Er weiß, welche Ethereum-Adresse wie viele Token besitzt.
Wenn du Token von A nach B sendest, ruft der Smart Contract eine Funktion auf, die den Kontostand von A verringert und den von B erhöht. Alle ERC20-Token “sprechen dieselbe Sprache”, d. h. sie halten sich an die gleichen Regeln und Funktionen.
Dadurch können Wallets, Börsen und DApps jeden ERC20-Token verstehen und unterstützen, ohne für jeden Token individuell programmiert werden zu müssen.
Warum sind ERC20 Tokens wichtig im Ethereum-Netzwerk?
Der ERC20-Standard war ein Meilenstein für Ethereum und einer der Hauptgründe für dessen Erfolg. Vor seiner Einführung entwickelte jeder Token-Herausgeber eigene Techniken – das führte oft zu Inkompatibilitäten und Chaos.
Mit ERC20 gibt es nun ein einheitliches Regelwerk, was Interoperabilität ermöglicht: Ein ERC20-Token lässt sich nahtlos in den gängigen Ethereum-Wallets speichern, auf Krypto-Börsen traden und in Smart Contracts verwenden, ohne dass für jeden neuen Token spezieller Code geschrieben werden muss.
Dies hat eine wahre Token-Revolution ausgelöst. Insbesondere während des ICO-Booms 2017 nutzten unzählige Projekte ERC20-Token, um Kapital einzusammeln – schnell und ohne eigene Blockchain.
Heute gibt es tausende ERC20-Token für unterschiedlichste Zwecke. Ob Stablecoins (wertstabile Token gekoppelt an z. B. den US-Dollar), Governance-Token zur Abstimmung in DeFi-Protokollen oder Utility-Token, die in Apps und Spielen eingesetzt werden – sie alle basieren auf ERC20.
Grundlagen der ERC20 Tokens
Definition und technische Spezifikationen
ERC20 ist ein technischer Standard (Ethereum Improvement Proposal 20), der genau definiert, wie ein Token-Smart-Contract auf Ethereum aufgebaut sein muss, damit er als ERC20-Token gilt.
Konkret schreibt ERC20 eine Reihe von Funktionen und Events vor, die der Smart Contract implementieren soll. Die wichtigsten davon sind:
totalSupply – Gibt die Gesamtmenge aller verfügbaren Token aus dem Vertrag an.
balanceOf(address) – Liefert den Token-Kontostand einer bestimmten Ethereum-Adresse. So kann man abfragen, wie viele Token ein Nutzer besitzt.
transfer(address _to, uint256 _wert) – Überträgt Token vom eigenen Konto an eine andere Adresse (z. B. du sendest deinem Freund 50 Token).
approve(address _spender, uint256 _wert) – Erteilt einer anderen Adresse die Genehmigung, eine bestimmte Anzahl deiner Token auszugeben. Dies ist nötig, um z. B. einem Smart Contract (wie einer Börse oder einem DeFi-Protokoll) Zugriff auf deine Token zu geben, ohne deinen privaten Schlüssel preiszugeben.
transferFrom(address _from, address _to, uint256 _wert) – Überträgt Token von einer Adresse an eine andere, vorausgesetzt, diese Übertragung wurde zuvor mittels approve genehmigt. Diese Funktion nutzen z. B. Smart Contracts, um in deinem Namen Token zu bewegen (etwa wenn du Token an einer Börse verkaufst).
allowance(address _owner, address _spender) – Zeigt an, wie viele Token ein Spender (spender) von einem Eigentümer (owner) noch transferieren darf. Mit anderen Worten: das verbleibende Guthaben einer erteilten Genehmigung.
Zusätzlich zu diesen Funktionen definiert ERC20 auch zwei wichtige Events (Ereignisse), die der Smart Contract auslösen soll: Transfer (wenn Token übertragen werden) und Approval (wenn eine Genehmigung erteilt wird).
Diese Events ermöglichen es Wallets und Anwendungen, Transaktionen mitzuverfolgen und Benutzer z. B. über eine erfolgreiche Überweisung zu benachrichtigen.
Alle ERC20-Token teilen diese standardisierten Funktionen und Events. Das bedeutet, dass jedes Wallet und jede Börse, die einmal gelernt hat, wie man mit einem ERC20-Token umgeht, automatisch mit allen ERC20-Tokens umgehen kann.
Entwickler fügen oft noch optionale Eigenschaften hinzu, wie z. B. einen name (Name des Tokens, etwa “MyToken”), ein symbol (Ticker-Symbol, z. B. “MYT”) und decimals (Anzahl der Nachkommastellen, z. B. 18 wie bei Ether).
Diese erleichtern die Handhabung, sind aber per ERC20-Standard nicht zwingend vorgeschrieben.
Vorteile von ERC20 gegenüber anderen Token-Standardarten
Warum gerade ERC20? Der größte Vorteil ist die breite Unterstützung und Einfachheit. Da ERC20 seit Jahren der meistgenutzte Token-Standard ist, existiert ein gewaltiges Ökosystem darum herum. Wallets, Börsen und Tools sind perfekt auf ERC20 abgestimmt.
Für dich als Entwickler heißt das: Du kannst dich auf die Logik deines Projekts konzentrieren, während die grundlegenden Token-Funktionen bereits gelöst sind.
Ein Vergleich mit anderen Standards zeigt die Stärken von ERC20
Gegenüber keinem Standard: Würdest du einen Token ohne etablierten Standard programmieren, müsste jede Wallet und Börse deinen speziellen Code unterstützen – ein enormer Aufwand, der nahezu unbezahlbar ist. ERC20 beseitigt diese Hürde durch seine Einheitlichkeit.
Gegenüber anderen Ethereum-Standards: Ethereum kennt auch andere Token-Standards für spezielle Zwecke. Zum Beispiel ERC721 für Non-Fungible Tokens (NFTs) – also einzigartige, nicht austauschbare Gegenstände wie Sammelkarten oder Kunst.
Oder ERC1155 für Multi-Token (eine Mischung, oft in Spielen genutzt). Doch wenn es um austauschbare Wertmarken geht (z. B. Währungen, Punktesysteme, Anteile), ist ERC20 nach wie vor der Goldstandard.
Er ist einfacher als neuere Alternativen und hat sich in der Praxis bewährt. Selbst neuere Blockchains wie Binance Smart Chain verwenden mit BEP-20 praktisch einen Klon des ERC20-Standards – ein Beleg dafür, wie erfolgreich das Modell ist.
Eigene Blockchain vs. ERC20: Ein weiterer Vorteil ist, dass du keine eigene Blockchain entwickeln musst, um einen eigenen Coin herauszugeben.
Ein ERC20-Token nutzt die robuste Infrastruktur von Ethereum mit. Dein Token profitiert von der Sicherheit und Dezentralisierung des Ethereum-Netzwerks, ohne dass du dich um Miner, Netzwerkknoten oder ein eigenes Konsensverfahren kümmern musst.
Das reduziert drastisch die Komplexität, um ein neues Krypto-Projekt an den Start zu bringen.
Natürlich ist kein Standard perfekt. ERC20 hat im Laufe der Zeit auch seine Schwächen gezeigt (z. B. das versehentliche Versenden von Tokens an falsche Adressen wie Smart Contracts, die nicht darauf vorbereitet sind).
Doch die Ethereum-Community hat darauf reagiert und neue Standards vorgeschlagen – ohne jedoch ERC20s Vorherrschaft bisher zu brechen. Für dich als Einsteiger ist ERC20 der beste Startpunkt, da er gut dokumentiert, erprobt und universell unterstützt ist.
Erstellen deines ersten ERC20 Tokens
Jetzt, da du weißt, was ERC20-Token sind, fragst du dich vielleicht: Wie kann ich selbst so einen Token erstellen?
Tatsächlich ist das Erstellen eines eigenen Tokens viel einfacher, als es klingt. Du brauchst kein riesiges Entwicklerteam – ein einzelner Smart Contract in Solidity reicht aus. Dennoch gibt es einige Dinge, die du vorher bedenken und vorbereiten solltest.
Vorüberlegungen: Was du vor dem Start wissen musst
Bevor du in die Tastatur haust, kläre für dich ein paar Grundfragen und sorge für die richtige Umgebung:
Zweck deines Tokens: Überlege dir, warum du einen Token erstellst. Hat er einen klaren Nutzen? Zum Beispiel als Belohnungssystem in deiner App, als Zahlungsmittel in einer Community oder vielleicht als Governance-Token, mit dem Abstimmungen durchgeführt werden.
Ein klarer Zweck hilft dir bei den folgenden Entscheidungen – und macht den Token für Nutzer attraktiver.
Ethereum-Wallet und Konto: Du benötigst eine Ethereum-Adresse, die du kontrollierst, um den Token zu erstellen und zu verwalten. Am einfachsten ist eine Wallet wie MetaMask.
Installiere die MetaMask-Browsererweiterung und erstelle eine Wallet, falls du noch keine hast. Diese Wallet wird später den Token-Vertrag deployen und z. B. die ersten Token halten.
Entwicklungsumgebung: Für das Schreiben und Testen des Smart Contracts brauchst du eine Umgebung. Remix ist eine hervorragende Web-IDE, die direkt im Browser läuft – ideal für Einsteiger.
Alternativ kannst du auch lokale Werkzeuge wie Truffle oder Hardhat nutzen, falls du dich damit wohler fühlst. Für den Anfang nehmen wir Remix, weil es ohne Installation sofort funktioniert.
Kenntnisse in Solidity: Solidity ist die Programmiersprache, in der Ethereum-Smart-Contracts geschrieben werden. Grundkenntnisse sind hilfreich.
Du musst kein Profi sein, um einen ERC20 zu schreiben, aber ein Verständnis von grundlegenden Programmierkonzepten (Variablen, Funktionen, etc.) ist nötig. Keine Sorge – wir gehen die Schritte gleich gemeinsam durch.
Ether für Gas-Gebühren: Jede Aktion auf Ethereum kostet Gebühren (Gas) in Form von Ether. Für das Testen kannst du Testnetzwerke nutzen, wo du kostenloses Test-Ether bekommst.
Möchtest du aber deinen Token auf dem echten Ethereum-Mainnet veröffentlichen, brauchst du je nach Komplexität des Vertrags etwas echtes Ether, um die Deployment-Transaktion zu bezahlen.
Als Anfänger solltest du zuerst immer im Testnetz (z. B. Goerli oder Sepolia) üben, bevor du echtes Geld ausgibst.
Hast du alles beisammen? Dann legen wir los mit der eigentlichen Entwicklung!
Schritt-für-Schritt-Anleitung zum Erstellen eines Tokens
Nun erstellen wir Schritt für Schritt deinen ersten ERC20-Token. In diesem Beispiel nehmen wir an, du möchtest einen einfachen Token namens MyToken mit dem Symbol MYT erstellen.
Der Token soll z. B. insgesamt 1.000 Einheiten haben, die komplett an dich (den Ersteller) gehen.
Entwicklungsumgebung einrichten: Öffne die Remix-IDE in deinem Browser. Remix ist ein Online-Editor speziell für Solidity. Auf der linken Seite kannst du über das Dateisymbol ein neues Datei-Projekt anlegen.
Lege eine neue Datei an, z. B. MyToken.sol. Stelle in Remix rechts oben sicher, dass als Compiler eine passende Solidity-Version ausgewählt ist (z. B. 0.8.xx).
Als Laufzeitumgebung (Environment) kannst du zunächst “Remix VM (London)” wählen, was eine simulierte Blockchain im Browser ist – ideal zum Testen. Später, für das Deployment, wechseln wir dann auf ein Testnetz über MetaMask.
Den Smart Contract schreiben: Jetzt geht’s ans Coden. In die Datei MyToken.sol schreiben wir unseren Token-Vertrag. Um Fehler zu vermeiden, verwenden wir am besten eine fertige, bewährte Vorlage.
Das OpenZeppelin-Projekt stellt sichere Standardimplementierungen bereit, die wir importieren können. Unten ein minimalistisches Beispiel eines ERC20-Vertrags:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;import „@openzeppelin/contracts/token/ERC20/ERC20.sol“;contract MyToken is ERC20 {constructor(uint256 initialSupply) ERC20(„MyToken“, „MYT“) {_mint(msg.sender, initialSupply);}}
Schauen wir uns das kurz an: Wir importieren die ERC20-Bibliothek von OpenZeppelin, die bereits alle Standardfunktionen enthält. Unser Vertrag MyToken erbt davon.
Im Konstruktor (constructor) legen wir Name und Symbol fest und wir rufen _mint auf, um die angegebene initialSupply an Token zu erschaffen.
msg.sender (der Ersteller des Vertrags – also du) erhält diese Token. Wenn du z. B. initialSupply als 1000 (bei 18 Dezimalstellen bedeutet das in Wirklichkeit 1000 * 10^18 Base-Units) angibst, bekommst du nach Deployment 1000 MYT auf dein Konto gutgeschrieben.
Natürlich könntest du den Code noch erweitern (z. B. ein fixes Gesamtangebot ohne Parameter, Funktionen zum Nachprägen, etc.), aber dieses Grundgerüst reicht für einen funktionierenden Token. Sobald dein Code fertig ist, klicke rechts auf den Compile-Button in Remix – der Code sollte sich fehlerfrei kompilieren.
Deployment des Smart Contracts auf Ethereum: Ist der Smart Contract fehlerfrei erstellt und kompiliert, kannst du ihn ins Netzwerk bringen (deployen).
Wechsle in Remix die Umgebung von der VM auf “Injected Provider – MetaMask”, um Remix mit deinem MetaMask-Wallet zu verbinden.
Stelle in MetaMask sicher, dass du mit dem gewünschten Testnet verbunden bist (z. B. dem Sepolia Test Network) und etwas Test-Ether dort hast.
Klicke in Remix auf Deploy – MetaMask wird sich öffnen und dich bitten, die Transaktion zu bestätigen. Sobald du bestätigst, wird der Vertrag im Testnetz erstellt. Glückwunsch – du hast soeben deinen eigenen ERC20-Token erschaffen! 🎉
Remix zeigt dir nach erfolgreicher Deployment die Contract-Adresse deines neuen Tokens an. Kopiere diese Adresse.
Du kannst sie z. B. im Blockchain-Explorer (für Sepolia etwa Etherscan für Sepolia) eingeben, um deinen Vertrag zu finden.
In MetaMask kannst du nun über “Token hinzufügen” die Vertragsadresse einfügen, damit auch dein Wallet den neuen Token erkennt. Du solltest deinen Token MyToken (MYT) samt Kontostand sehen können.
Wenn du nun Token an andere schicken möchtest, kannst du das über den Vertrag oder direkt in MetaMask tun – im Hintergrund ruft MetaMask die transfer-Funktion deines Smart Contracts auf.
Diese drei Schritte – Spezifikation festlegen, Smart Contract programmieren, Deployment durchführen – sind die Kernphasen zur Erstellung jedes ERC20-Tokens.
Natürlich gibt es noch Feinheiten (z. B. Kontrakt auf dem Mainnet deployen, was identisch abläuft, nur mit echten ETH-Gebühren). Doch an dieser Stelle hast du das Wichtigste gelernt: Du hast einen eigenen Token erstellt und erste Transaktionen durchgeführt.
Fortgeschrittene Konzepte und Best Practices
Nachdem die Grundlagen gelegt sind, wollen wir auf einige fortgeschrittene Punkte eingehen.
Besonders wenn du planst, deinen Token ernsthaft einzusetzen oder gar öffentlich anzubieten, sind Sicherheit und saubere Umsetzung entscheidend.
Wir behandeln nun einige Best Practices, häufige Stolperfallen und wie dein Token letztlich in Wallets und Börsen integriert wird.
Sicherheitsaspekte bei der Erstellung von ERC20 Tokens
Sicherheit ist das A und O bei Smart Contracts – schließlich verwaltet dein ERC20-Token echtes Geld (oder Werte). Hier sind einige wichtige Sicherheitsaspekte und Tipps:
Verwende bewährte Bibliotheken: Wie oben demonstriert, solltest du möglichst auf erprobte Implementierungen zurückgreifen (z. B. OpenZeppelin).
Diese wurden von vielen Entwicklern geprüft. Eigenen ERC20-Code komplett from scratch zu schreiben, birgt das Risiko, dass du versehentlich vom Standard abweichst oder Bugs einbaust.
Integer-Überläufe und -Unterläufe: Frühere Solidity-Versionen hatten das Problem, dass Zahlen “überlaufen” konnten (z. B. wenn eine sehr große Zahl durch Addition wieder auf 0 springt).
Heutige Solidity-Versionen verhindern das größtenteils automatisch, aber es schadet nicht, vorsichtig zu sein. Nutze gegebenenfalls Solidity ab v0.8+, wo arithmetische Überläufe eine Ausnahme auslösen, oder setze SafeMath-Libs ein, wenn du ältere Versionen nutzen musst.
approve/transferFrom-Muster beachten: Ein klassisches ERC20-Problem ist das sogenannte Allowance-Race. Wenn ein User dir eine bestimmte Anzahl Token per approve freigibt und dann seine Meinung ändert und einen neuen Wert approved, kann es zu einem Timing-Problem kommen.
Best Practice: Immer erst auf 0 setzen und dann den neuen Wert freigeben, oder moderne Erweiterungen wie ERC20 Permit (Off-Chain Signaturen für Approvals) nutzen, die solche Probleme mindern.
Keine versteckten Hintertüren: Es mag verlockend klingen, im Smart Contract Funktionen einzubauen, mit denen du z. B. Tokens einfrieren oder neue erzeugen kannst.
Bedenke aber: Soll dein Token Vertrauen genießen, muss der Code transparent und fair sein. Hintertüren können von der Community entdeckt werden und deinem Projekt schaden.
Wenn du spezielle Funktionen brauchst (z. B. Nachschub an Token erzeugen = Minting, oder Notfallstopp), dokumentiere sie klar und überlege, ob sie wirklich nötig sind.
Smart Contract Audits: Für professionelle Projekte ist es üblich, den Code von unabhängigen Experten prüfen zu lassen (Audit).
Diese Sicherheitsprüfungen entdecken Schwachstellen, bevor ein Angreifer sie findet. Als einzelner Entwickler ist ein voll bezahltes Audit vielleicht nicht immer realistisch, aber zumindest ein Peer-Review (durch andere Entwickler in der Community) ist goldwert.
Häufige Fehler und wie man sie vermeidet
Bei der Entwicklung von ERC20-Tokens treten typischerweise einige Fehler auf, vor allem wenn man noch nicht so erfahren ist. Hier sind ein paar häufige Fallen – und wie du sie umgehen kannst:
Falsche Parameter (Decimals/Supply): Ein verbreiteter Fehler ist es, die Dezimalstellen und anfängliche Menge falsch zu kalkulieren. Beispiel: Du willst 1.000 Token erstellen und setzt initialSupply = 1000.
Hast du decimals = 18 (Standard), bedeutet das tatsächlich 0,000001000 Token in menschlicher Sichtweise, weil 18 Nachkommastellen berücksichtigt werden!
Lösung: Überlege dir vorher, wie viele Gesamt-Token im Umlauf sein sollen und stelle sicher, dass du die Dezimalstellen in die Berechnung einbeziehst. Oft setzen Entwickler decimals = 18 und geben die Gesamtmenge in wei (10^-18 Ether) an.
In unserem Beispiel oben haben wir das geschickt gelöst, indem wir die Anzahl als Parameter übergeben – so kannst du beim Deployen einfach 1000 * 10^18 angeben.
Ungetesteter Code: Der Eifer ist groß, schnell auf Mainnet zu gehen. Doch ungeprüfter Code ist gefährlich. Teste deinen Smart Contract ausgiebig im Testnetz.
Probiere alle Funktionen durch: Token versenden, approve und transferFrom nutzen, schauen was passiert, wenn jemand mehr Token senden will als er hat (sollte fehlschlagen) etc. Viele Fehler zeigen sich erst im Praxistest.
Denke daran: Einmal auf Mainnet veröffentlicht, lässt sich der Code nicht mehr ändern!
Nicht genügend Ether für Gebühren: Es klingt trivial, aber viele vergessen es: Du brauchst genug Ether, um den Deployment-Vorgang und auch spätere Transaktionen zu bezahlen.
Smart Contracts können recht groß sein, was die einmaligen Deployment-Kosten erhöht. Wenn der Gas-Preis gerade hoch ist, kann das Deployment teuer werden. Plane also genügend Puffer ein. Für Tests im Testnetz kannst du dir von sogenannten Faucets gratis Test-Ether holen.
Standard nicht exakt eingehalten: Manchmal weichen Entwickler bewusst oder unbewusst vom Standard ab – etwa indem sie die transfer-Funktion anders gestalten oder Events vergessen. Das führt fast immer zu Kompatibilitätsproblemen.
Ein bekanntes Beispiel: Ein frühes Token (z. B. Tether USDT) hatte eine transfer-Funktion, die keinen booleschen Rückgabewert lieferte, obwohl der Standard das vorsieht. Dadurch kam es zu Schwierigkeiten in Anwendungen, die einen true/false-Wert erwarteten.
Vermeide Abweichungen, es sei denn, du hast einen sehr guten Grund und dir ist klar, welche Folgen das hat. Halte dich im Zweifel strikt an die Vorlage von OpenZeppelin oder die offizielle ERC20-Spezifikation.
Sicherheitslücken übersehen: Wir haben es im vorherigen Abschnitt erwähnt – oft schleichen sich Fehler ein, die erst Angreifer aufdecken.
Typische Versäumnisse sind fehlende Prüfungen (z. B. dass transfer nicht an Adresse 0x0 erfolgen sollte) oder fehlende Schutzmechanismen beim Nachprägen von Token.
Die beste Gegenmaßnahme ist: informiere dich (es gibt Checklisten für sichere Solidity-Verträge), lasse deinen Code von anderen anschauen und lerne aus bekannten Vorfällen.
Wenn du diese Punkte beachtest, bist du schon auf einem sehr guten Weg, die häufigsten Stolperfallen zu vermeiden. Als Anfänger hilft es enorm, sich an bestehenden, funktionierenden Projekten zu orientieren und nicht alles neu erfinden zu wollen.
Integration in Wallets und Börsen
Sobald dein ERC20-Token live ist, möchtest du wahrscheinlich, dass andere ihn nutzen können. Wie kommt dein Token also ins Wallet der Nutzer oder sogar an eine Börse? Zum Glück sorgt der ERC20-Standard auch hier für eine reibungslose Integration.
Wallet-Integration: Jede Ethereum-Wallet kann prinzipiell ERC20-Token verwalten. Bekannte Wallets wie MetaMask, Trust Wallet oder Hardware-Wallets (Ledger, Trezor) haben häufig schon vordefinierte Tokenlisten, in denen populäre ERC20-Token automatisch angezeigt werden.
Dein eigener, neuer Token wird dort zunächst nicht bekannt sein – aber das ist kein Problem. In Wallets gibt es die Option “Custom Token hinzufügen” (bei MetaMask etwa musst du die Vertragsadresse deines Tokens eintragen).
Danach kennt die Wallet Name, Symbol und Dezimalstellen deines Tokens und kann das Guthaben anzeigen. Es ist hilfreich, Informationen über deinen Token öffentlich bereitzustellen – z. B. auf einer Webseite oder indem du den Smart Contract auf Etherscan verifizierst – so können Wallets diese Daten automatisch abrufen.
Einige Wallets greifen auf Dienste wie Etherscan oder CoinGecko zurück, um Token-Metadaten und Logos anzuzeigen.
Ein guter Tipp: Verifiziere deinen Contract auf Etherscan (das kannst du nach dem Deployment machen, indem du dort den Source Code hochlädst), dann erscheint dein Token als “grüner Haken” verifiziert, was für Transparenz sorgt.
Börsen-Integration: Wenn du planst, deinen Token handelbar zu machen, gibt es zwei Wege – zentralisiert oder dezentral. Für zentralisierte Börsen (wie Binance, Coinbase & Co.) musst du normalerweise ein Bewerbungs- und Prüfungsverfahren durchlaufen.
Börsen schauen auf Aspekte wie Projekt-Substanz, Liquidität, Team und natürlich die technische Sicherheit deines Tokens. Hier zahlt es sich aus, wenn dein Token-Code sauber und verifiziert ist und eventuell ein Audit vorweisen kann.
Die Listung auf großen Börsen ist anspruchsvoll und oft erst für etablierte Projekte realistisch. Dezentrale Börsen (DEX) hingegen, wie Uniswap oder SushiSwap, erlauben es jedem, einen Token zu handeln.
Du könntest z. B. auf Uniswap ein Liquiditätspaar eröffnen (z. B. MYT/ETH), indem du etwas ETH und einige deiner Token hinterlegst. Schon ist dein Token für jeden handelbar – zumindest gegen ETH in diesem Pool.
Beachte jedoch: Nur weil der Token technisch handelbar ist, heißt das nicht, dass er automatisch einen Marktwert hat. Dafür brauchst du Interesse und Vertrauen von Nutzern.
Anwendungsfälle und Beispiele von ERC20 Tokens
Nicht ohne Grund ist ERC20 so populär: Die Vielzahl an Anwendungsfällen ist beeindruckend.
Hier werfen wir einen Blick auf bekannte ERC20-Token und wofür sie genutzt werden. Außerdem sehen wir uns an, wie verschiedene Projekte (und Unternehmen) ERC20-Token in der Praxis einsetzen.
Bekannte ERC20 Tokens und ihre Anwendungsfälle
Einige ERC20-Token kennst du vielleicht bereits dem Namen nach, ohne es zu wissen. Hier eine Auswahl prominenter ERC20-Token und wofür sie stehen:
Tether (USDT) – USDT ist ein Stablecoin, der 1:1 an den US-Dollar gekoppelt ist. Er wird auf Ethereum als ERC20-Token ausgegeben (neben anderen Netzwerken) und dient dazu, Dollarwerte einfach im Krypto-Ökosystem zu transferieren.
Trader nutzen USDT, um zwischen Krypto-Handelspaaren zu wechseln, ohne in echtes Fiat-Geld gehen zu müssen.
USD Coin (USDC) – Ähnlich wie Tether ist USDC ein an den Dollar gebundener Stablecoin auf Ethereum.
USDC wird von Unternehmen (Circle und Coinbase) herausgegeben und gilt als einer der vertrauenswürdigsten Stablecoins, da er regelmäßig geprüft wird.
Uniswap (UNI) – UNI ist der Governance-Token der dezentralen Börse Uniswap.
Inhaber von UNI können über die Weiterentwicklung und Parameter des Uniswap-Protokolls abstimmen. UNI wurde als “Dankeschön” an frühe Nutzer verteilt und hat heute eine wichtige Rolle in der Verwaltung des Projekts.
Chainlink (LINK) – LINK ist ein Utility-Token, der das dezentrale Oracle-Netzwerk Chainlink antreibt.
Smart Contracts können auf externe Daten zugreifen (z. B. Preise, Wetterdaten), indem sie Chainlink-Oracles nutzen und in LINK dafür bezahlen. Knotenbetreiber, die diese Daten liefern, müssen LINK halten und können es als Belohnung verdienen.
Basic Attention Token (BAT) – BAT ist ein Token aus dem Werbebereich. Die Firma Brave (mit ihrem gleichnamigen Web-Browser) nutzt BAT, um ein neues Werbemodell umzusetzen: Nutzer verdienen BAT für das Anschauen von Werbung und Werbetreibende bezahlen in BAT für Aufmerksamkeit.
BAT ist somit ein Beispiel, wie ERC20-Token in eine bestehende Branche (Online-Werbung) integriert wurden.
Maker (MKR) – MKR ist der Governance- und Utility-Token von MakerDAO, dem Protokoll hinter dem dezentralen Stablecoin DAI.
MKR-Inhaber dürfen über Änderungen am System abstimmen (z. B. Sicherheitenquoten) und tragen Verantwortung für die Stabilität von DAI. Interessant: MKR wird auch zur Deckung von Schulden im System verwendet – im Ernstfall können MKR-Token neu ausgegeben werden, um DAI zu stabilisieren, was den Wert von MKR beeinflusst.
(Viele weitere) – Die Liste könnte lange weitergehen: von Spieltoken wie Enjin Coin (ENJ) für Gaming-Assets, über Wrapped Tokens wie WBTC (Wrapped Bitcoin, ein ERC20 der Bitcoin repräsentiert) bis hin zu Fan-Token für Sportteams – nahezu jeder erdenkliche Anwendungsfall wurde schon als ERC20 umgesetzt.
Analyse von Fallstudien: Wie Unternehmen ERC20 Tokens nutzen
ERC20-Token sind nicht nur ein Spielzeug für Krypto-Enthusiasten oder Tech-Startups – auch gestandene Unternehmen und Organisationen nutzen diesen Standard, um neue Geschäftsmodelle zu entwickeln. Werfen wir einen Blick auf ein paar exemplarische Fälle:
Finanzdienstleister (Beispiel: Circle mit USDC) – Das Unternehmen Circle (in Zusammenarbeit mit Coinbase) hat mit USD Coin einen ERC20-Stablecoin geschaffen, der im Finanzwesen hohe Wellen schlägt.
USDC dient als Brücke zwischen traditionellem Geld und der Blockchain-Welt. Unternehmen können damit z. B. internationale Überweisungen schneller und günstiger abwickeln, ohne die Volatilität von Bitcoin & Co. Circle hält für jeden ausgegebenen USDC einen realen Dollar als Reserve.
Hier zeigt sich, wie ein Unternehmen den ERC20-Standard nutzt, um Vertrauen (durch Transparenz und Reservenachweis) mit der Effizienz der Blockchain zu kombinieren.
Browser und Online-Werbung (Beispiel: Brave mit BAT) – Das zuvor erwähnte Basic Attention Token (BAT) der Brave Browser-Plattform ist ein Paradebeispiel, wie ein Startup ein eigenes Ökosystem mit ERC20 aufbaut.
Brave, ein Webbrowser-Unternehmen, hat keinen eigenen Coin erfunden, sondern setzt auf Ethereum: BAT-Token werden an Millionen Browser-Nutzer verteilt und bilden das Herzstück eines innovativen Werbesystems.
Die Nutzer können ihre verdienten BAT wiederum an Websites oder Content-Ersteller als Unterstützung weitergeben.
Dieses Modell wäre ohne einen leicht integrierbaren Token kaum umsetzbar gewesen. Ethereum lieferte hier die Basis, ohne dass Brave eine eigene Infrastruktur entwickeln musste.
Dezentrale Finanzplattformen (Beispiel: Aave, Compound) – DeFi-Unternehmen wie Aave oder Compound sind eigentlich Smart-Contract-Protokolle, doch man kann sie als “Unternehmen” im weiteren Sinne betrachten, die Dienstleistungen (Kredite, Zinsen) anbieten.
Ihre Tokens (AAVE, COMP) sind ERC20 und erfüllen Governance- und Incentive-Zwecke. Gleichzeitig nutzen diese Protokolle andere ERC20-Token (z. B. DAI, USDC), um ihre Finanzdienstleistungen bereitzustellen.
Hier sieht man ein ganzes Netzwerk von ERC20-Tokens im Zusammenspiel: Ein Nutzer hinterlegt z. B. einen ERC20-Token als Sicherheit und erhält dafür einen anderen ERC20-Token gutgeschrieben, der seinen Anteil am Liquiditätspool repräsentiert.
Tokenisierung von Vermögenswerten – Einige Firmen beschäftigen sich mit der Tokenisierung realer Werte, etwa Immobilien, Aktien oder Rohstoffe.
Ein bekanntes Beispiel war die Ausgabe von digitalen Anleihen durch die spanische Bank Santander, bei der Ethereum als Plattform genutzt wurde.
Dabei repräsentierte ein ERC20-Token einen bestimmten Anteil an einer Anleihe. Solche Projekte zeigen die Weiterentwicklung traditioneller Finanzprodukte mithilfe von ERC20-Token.
Die Token können leichter transferiert und getradet werden und sie ermöglichen z. B. kleine Trader den Zugang zu Anlageklassen, die sonst schwer zugänglich wären.
Zukunftsperspektiven und Weiterentwicklung von ERC20 Tokens
Die Welt der Kryptowährungen entwickelt sich rasend schnell und auch um ERC20 herum gibt es ständige Neuerungen. Schauen wir zum Abschluss in die Zukunft: Welche Trends zeichnen sich in der Token-Entwicklung ab und welche Rolle wird ERC20 in der wachsenden DeFi-Welt spielen?
Trends in der Token-Entwicklung
Obwohl ERC20 heute der dominante Standard für fungible Token ist, ruht sich die Ethereum-Community nicht darauf aus. Neue Standards und Verbesserungen wurden vorgeschlagen, um Grenzfälle und Schwächen von ERC20 anzugehen. Einige Trends und Entwicklungen sind:
Neue Token-Standards: Erweiterungen wie ERC223 oder ERC777 wollten das Handling von Tokens sicherer machen (z. B. verhindern, dass Tokens an Verträge verloren gehen, die sie nicht annehmen können, oder Hooks anbieten, um Aktionen beim Erhalt von Tokens auszuführen).
Bisher konnten sie ERC20 jedoch nicht verdrängen – oft, weil ERC20 “gut genug” ist und die Netzwerkeffekte stark sind. Dennoch könnten spezialisierte Standards in Zukunft an Bedeutung gewinnen, gerade wenn bestimmte Features gefragt sind.
Multi-Token-Standards: Der Standard ERC1155 kombiniert fungible und nicht-fungible Token in einem Vertrag. Er wird vor allem im Gaming-Bereich genutzt (vom Unternehmen Enjin initiiert).
Solche Entwicklungen zeigen, dass die Community nach effizienteren Wegen sucht, viele Token-Typen zu verwalten. Für klassische Währungen bleibt aber ERC20 einfacher.
Layer-2 und Skalierung: Ethereum hatte zeitweise mit hohen Gebühren und begrenztem Durchsatz zu kämpfen. Die Zukunft der Token wird daher eng mit Layer-2-Lösungen und Sidechains verknüpft sein.
Bereits jetzt migrieren viele Projekte ihre ERC20-Token auf Netzwerke wie Polygon, Arbitrum oder Optimism (allesamt Netze, die EVM-kompatibel sind, sodass der ERC20-Code unverändert läuft).
Die Tokens können dort günstiger und schneller transferiert werden. In Zukunft werden Entwickler wahrscheinlich Cross-Chain- und Multi-Chain-Token ausgeben, die auf mehreren Plattformen parallel existieren.
Tokenomics und intelligente Token: Immer mehr Projekte experimentieren mit komplexen Tokenomics – zum Beispiel Token, die sich selbst vernichten (burn) bei jeder Transaktion, um die Umlaufmenge zu reduzieren, oder Tokens mit integrierten Mechanismen für Staking und Belohnungen.
Solche Funktionen gehen über das ERC20-Grundgerüst hinaus und werden on top in Smart Contracts implementiert. Die Standards könnten sich anpassen, um solche häufigen Muster zu unterstützen.
Regulatorische Konformität: Ein weiterer Aspekt der Zukunft ist die Regulierung. Für Security-Tokens (digitale Wertpapiere) wurden Standards wie ERC1400 vorgeschlagen, die z. B. Whitelists für Investoren oder regulatorische Auflagen technisch abbilden.
Es ist zu erwarten, dass die nächste Generation von Tokens vermehrt Features haben wird, die regulatorische Anforderungen integrieren – gerade wenn traditionelle Finanzprodukte auf Ethereum gebracht werden.
Kurzum, ERC20 wird ergänzt durch neue Ideen, bleibt aber vermutlich noch lange der Ausgangspunkt. Viele Innovationen bauen auf ihm auf oder sind rückwärtskompatibel.
Als Entwickler lohnt es sich, diese Trends im Auge zu behalten – wer früh z. B. das Potential von Layer-2 erkennt, kann seinen Token darauf vorbereiten und den Nutzern viel Geld an Gebühren sparen.
Die Rolle von ERC20 in DeFi (Decentralized Finance)
DeFi – die dezentralisierte Finanzwelt – hat Ethereum in den letzten Jahren eine Explosion an Nutzung beschert. Und fast alle diese DeFi-Anwendungen basieren auf ERC20-Token. Die Rolle von ERC20 in DeFi ist so zentral, dass man sagen kann: Ohne ERC20 kein DeFi-Boom.
Warum ist das so? DeFi steht für Finanzdienstleistungen ohne Mittelsmänner und dafür braucht es austauschbare, programmierbare Werte – eine Rolle, die ERC20-Token perfekt ausfüllen. Ein paar Beispiele:
Dezentrale Börsen (DEX): Plattformen wie Uniswap oder SushiSwap sind im Kern nichts anderes als Smart Contracts, die ERC20-Token gegen ERC20-Token tauschen.
Wenn du auf Uniswap ETH gegen DAI tauschst, läuft im Hintergrund alles über ERC20-Schnittstellen (Ether wird dafür zuvor in einen “Wrapped Ether” ERC20-Token gewandelt, da ETH selbst kein ERC20 ist).
Kreditplattformen: Protokolle wie Aave, Compound oder MakerDAO verwenden ERC20-Token, um Kredite abzubilden. Du hinterlegst z. B. einen ERC20-Token als Sicherheit und bekommst einen anderen ERC20-Token als Darlehen.
Sogar die Zinsgutschriften geschehen oft in Form von Token (Compound gibt cTokens, Aave aTokens aus, die deinen Anteil plus Zinsen repräsentieren).
Derivate und Synthhetics: Plattformen wie Synthetix oder dYdX erstellen synthetische Assets (z. B. Token, die Aktienkurse nachbilden). Diese synthetischen Assets sind wiederum ERC20-Tokens, die mittels Smart Contracts besichert und getrackt werden.
Yield Farming und Liquidity Mining: Diese Konzepte belohnen Nutzer für die Bereitstellung von Liquidität oder Kapital an ein Protokoll – die Belohnung erfolgt üblicherweise in Form von neu generierten ERC20-Governance-Token. So wurde z. B. der COMP-Token von Compound verteilt, was das Konzept des Yield Farmings populär machte.
Governance: DeFi-Projekte setzen auf Dezentralisierung und Entscheidungen werden oft durch Abstimmungen der Token-Inhaber getroffen. Hier kommen die Governance-Token ins Spiel (wie UNI, COMP, AAVE etc.), die alle ERC20 sind.
Über Smart Contracts (Voting-Systeme) können Token-Inhaber Vorschläge einreichen und abstimmen, wodurch die Community die Kontrolle behält.
Die Zahlen sprechen Bände: In DeFi-Protokollen sind derzeit Werte in Milliardenhöhe eingeschlossen (Total Value Locked, TVL), fast vollständig in Form von ERC20-Tokens.
Dieser Trend dürfte anhalten. Selbst mit dem Aufkommen alternativer Layer-1-Blockchains oder Layer-2-Netzwerken bleibt der ERC20-Standard im Ethereum-Ökosystem der gemeinsame Nenner, auf den sich alles zurückführen lässt.
Für dich bedeutet das: Kenntnisse in ERC20 und den damit verbundenen Mechanismen sind ein Schlüssel, um die DeFi-Welt zu verstehen und mitzugestalten.
Ressourcen und Tools für die Entwicklung von ERC20 Tokens
Zum Abschluss möchten wir dir noch einige hilfreiche Ressourcen, Tools und Communitys an die Hand geben. Die Ethereum-Welt ist komplex, aber es gibt zahlreiche Angebote, die den Einstieg erleichtern und bei Problemen weiterhelfen.
Empfohlene Entwicklungstools und Plattformen
Remix IDE – Die webbasierte Entwicklungsumgebung, die wir in der Anleitung benutzt haben. Ideal, um direkt loszulegen und kleine Smart Contracts zu schreiben und zu testen.
Hardhat – Ein leistungsfähiges Entwicklungstool (Framework) für Ethereum-Projekte. Hardhat erlaubt es, lokale Ethereum-Knoten zu simulieren, Scripts zum Deployen zu schreiben und Tests in JavaScript/TypeScript durchzuführen.
Viele professionelle Entwickler schwören auf Hardhat wegen seiner Flexibilität und Plugins.
Truffle & Ganache – Truffle ist ein älteres, etabliertes Framework zum Entwickeln, Testen und Deployen von Ethereum-Contracts.
Ganache ist ein zugehöriges Tool, das eine lokale Blockchain zu Testzwecken bereitstellt. Zusammen bieten sie eine solide Suite, um Smart Contracts im größeren Stil zu entwickeln.
OpenZeppelin Contracts – Eine Bibliothek von geprüften Smart Contracts. Besonders der ERC20-Code von OpenZeppelin ist der De-facto-Standard, um einen sicheren Ausgangspunkt für deinen Token zu haben.
Anstatt das Rad neu zu erfinden, kannst du diese Bibliothek importieren (wie oben gezeigt) und dich darauf verlassen, dass die Kernfunktionen korrekt und sicher implementiert sind.
Solidity-Dokumentation – Nicht zu vergessen: die offizielle Dokumentation der Programmiersprache Solidity (soliditylang.org). Dort findest du das Sprachreferenz, Tutorials und Hinweise zu Best Practices. Für jeden, der tiefer einsteigen will, ist dies eine essenzielle Quelle.
Etherscan – Der bekannteste Ethereum-Blockchain-Explorer. Neben dem reinen Durchsuchen von Transaktionen bietet Etherscan Entwicklern die Möglichkeit, ihren Smart Contract zu verifizieren (d. h. den Source Code offenzulegen und vom Explorer kompilieren zu lassen, um zu bestätigen, dass der Code dem auf der Chain entspricht).
Zudem stellt Etherscan APIs bereit, mit denen du Token-Daten auslesen kannst. Es gibt auch einen Token Tracker, wo du siehst, welche ERC20-Token neu erstellt wurden, inklusive Statistiken.
Infura/Alchemy – Diese Dienste bieten skalierbare Ethereum-APIs an. Wenn du eine Anwendung entwickelst, die mit deinem Token-Smart-Contract interagieren soll (z. B. eine Web-App oder Mobile-App), kannst du über Infura oder Alchemy Zugang zum Ethereum-Netz bekommen, ohne einen eigenen Node zu betreiben.
Für die Contract-Entwicklung an sich nicht zwingend nötig, aber gut zu wissen, falls dein Projekt wächst.
Token-Generatoren – Es gibt auch Online-Plattformen, auf denen du mit ein paar Klicks einen einfachen ERC20-Token erstellen kannst, ohne selbst zu programmieren. Beispiele sind Webseiten wie Token-Factory oder ähnliche.
Allerdings ist Vorsicht geboten: Du solltest immer verstehen, was der generierte Smart Contract tut, bevor du ihn deployst. Diese Tools können für Prototypen nützlich sein, ersetzen aber nicht das Verständnis der Materie.
Wichtige Communitys und Foren für Entwickler
Niemand muss alles alleine herausfinden. Die Blockchain-Community ist sehr aktiv und hilfsbereit. Hier einige Anlaufstellen, wenn du Fragen hast oder dich austauschen möchtest:
Ethereum Stack Exchange – Ein Q&A-Forum speziell für Ethereum- und Smart-Contract-Fragen. Wenn du ein konkretes Problem oder Fehlermeldungen hast, findest du dort oft bereits Antworten.
Falls nicht, kannst du selbst Fragen stellen (achte auf präzise Angaben). Die Community dort ist technisch versiert und lösungsorientiert.
Reddit (/r/ethereum & /r/ethdev) – Auf Reddit gibt es mehrere Unterforen (Subreddits) zu Ethereum. r/ethereum ist allgemein, r/ethdev speziell für Entwickler. Dort werden News diskutiert, Fragen gestellt und Projekte vorgestellt.
Ein guter Ort, um am Puls der Entwicklung zu bleiben oder auch mal Anfängerfragen zu stellen.
Ethereum Discord & Telegram – Es existieren offizielle und inoffizielle Discord-Server sowie Telegram-Gruppen rund um Ethereum. Beispielsweise hat die Ethereum Foundation einen Discord und viele Projekte (wie Solidity, Hardhat, etc.) haben eigene Channel.
Hier kannst du in Echtzeit mit anderen Entwicklern chatten. Oft tummeln sich dort auch die Maintainer der Tools, die direkt helfen können.
Lokale Meetup-Gruppen – Abseits des Internets lohnt sich ein Blick auf lokale Ethereum- oder Blockchain-Meetups in deiner Stadt. Dort triffst du Gleichgesinnte, vom Anfänger bis zum Profi und kannst direkt voneinander lernen.
Gerade wenn du langfristig in dem Bereich arbeiten oder ein Projekt starten willst, ist Networking nie verkehrt.
Offizielle Ressourcen & Blogs – Folge den offiziellen Blogs von Ethereum, ConsenSys oder bekannten Entwicklern auf Twitter. Die Ethereum Foundation veröffentlicht Forschungsergebnisse und Neuigkeiten, die OpenZeppelin-Blogs analysieren Sicherheitsvorfälle – all das hilft dir, über Trends und Best Practices informiert zu bleiben.
