Zum Hauptinhalt springen
Change page

ERC-20-Token-Standard

Letzte Aktualisierung der Seite: 26. Februar 2026

DoGame5D (opens in a new tab)
MajorDom_DePINM (opens in a new tab)
rbmilchr (opens in a new tab)
+26

Einführung

Was ist ein Token?

Token können in Ethereum praktisch alles repräsentieren:

  • Reputationspunkte auf einer Online-Plattform
  • Fähigkeiten eines Charakters in einem Spiel
  • Finanzanlagen wie eine Unternehmensaktie
  • eine Fiatwährung wie USD
  • eine Unze Gold
  • und vieles mehr...

Eine so mächtige Funktion von Ethereum muss durch einen robusten Standard gehandhabt werden, richtig? Genau hier kommt ERC-20 ins Spiel! Dieser Standard ermöglicht es Entwicklern, Token-Anwendungen zu erstellen, die mit anderen Produkten und Dienstleistungen interoperabel sind. Der ERC-20-Standard wird auch verwendet, um zusätzliche Funktionen bereitzustellen.

Was ist ERC-20?

ERC-20 führt einen Standard für fungible Token ein. Mit anderen Worten: Sie haben eine Eigenschaft, die jeden Token (in Art und Wert) exakt gleich wie einen anderen Token macht. Ein ERC-20-Token verhält sich beispielsweise genau wie ETH, was bedeutet, dass 1 Token immer gleich allen anderen Token ist und sein wird.

Voraussetzungen

Hauptteil

Der ERC-20 (Ethereum Request for Comments 20), der im November 2015 von Fabian Vogelsteller vorgeschlagen wurde, ist ein Token-Standard, der eine API für Token innerhalb von Smart Contracts implementiert.

Beispielfunktionen, die ERC-20 bietet:

  • Token von einem Konto auf ein anderes übertragen
  • den aktuellen Token-Kontostand eines Kontos abrufen
  • das Gesamtangebot des im Netzwerk verfügbaren Tokens abrufen
  • genehmigen, ob eine bestimmte Menge an Token von einem Konto durch ein Drittanbieter-Konto ausgegeben werden darf

Wenn ein Smart Contract die folgenden Methoden und Ereignisse implementiert, kann er als ERC-20-Token-Vertrag bezeichnet werden. Sobald er bereitgestellt ist, ist er dafür verantwortlich, die erstellten Token auf Ethereum zu verfolgen.

Aus EIP-20 (opens in a new tab):

Methoden

1function name() public view returns (string)
2function symbol() public view returns (string)
3function decimals() public view returns (uint8)
4function totalSupply() public view returns (uint256)
5function balanceOf(address _owner) public view returns (uint256 balance)
6function transfer(address _to, uint256 _value) public returns (bool success)
7function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)
8function approve(address _spender, uint256 _value) public returns (bool success)
9function allowance(address _owner, address _spender) public view returns (uint256 remaining)
Alle anzeigen

Ereignisse

1event Transfer(address indexed _from, address indexed _to, uint256 _value)
2event Approval(address indexed _owner, address indexed _spender, uint256 _value)

Beispiele

Lassen Sie uns sehen, warum ein Standard so wichtig ist, um es uns einfach zu machen, jeden ERC-20-Token-Vertrag auf Ethereum zu überprüfen. Wir benötigen lediglich das Contract Application Binary Interface (ABI), um eine Schnittstelle zu einem beliebigen ERC-20-Token zu erstellen. Wie Sie unten sehen können, werden wir ein vereinfachtes ABI verwenden, um es zu einem reibungslosen Beispiel zu machen.

Web3.py-Beispiel

Stellen Sie zunächst sicher, dass Sie die Python-Bibliothek Web3.py (opens in a new tab) installiert haben:

1pip install web3
1from web3 import Web3
2
3
4w3 = Web3(Web3.HTTPProvider("https://cloudflare-eth.com"))
5
6dai_token_addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F" # DAI
7weth_token_addr = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" # Wrapped Ether (WETH)
8
9acc_address = "0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11" # Uniswap V2: DAI 2
10
11# Dies ist eine vereinfachte Contract Application Binary Interface (ABI) eines ERC-20-Token-Contracts.
12# Es stellt nur die Methoden: balanceOf(address), decimals(), symbol() und totalSupply() bereit.
13simplified_abi = [
14    {
15        'inputs': [{'internalType': 'address', 'name': 'account', 'type': 'address'}],
16        'name': 'balanceOf',
17        'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}],
18        'stateMutability': 'view', 'type': 'function', 'constant': True
19    },
20    {
21        'inputs': [],
22        'name': 'decimals',
23        'outputs': [{'internalType': 'uint8', 'name': '', 'type': 'uint8'}],
24        'stateMutability': 'view', 'type': 'function', 'constant': True
25    },
26    {
27        'inputs': [],
28        'name': 'symbol',
29        'outputs': [{'internalType': 'string', 'name': '', 'type': 'string'}],
30        'stateMutability': 'view', 'type': 'function', 'constant': True
31    },
32    {
33        'inputs': [],
34        'name': 'totalSupply',
35        'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}],
36        'stateMutability': 'view', 'type': 'function', 'constant': True
37    }
38]
39
40dai_contract = w3.eth.contract(address=w3.to_checksum_address(dai_token_addr), abi=simplified_abi)
41symbol = dai_contract.functions.symbol().call()
42decimals = dai_contract.functions.decimals().call()
43totalSupply = dai_contract.functions.totalSupply().call() / 10**decimals
44addr_balance = dai_contract.functions.balanceOf(acc_address).call() / 10**decimals
45
46# DAI
47print("===== %s =====" % symbol)
48print("Total Supply:", totalSupply)
49print("Addr Balance:", addr_balance)
50
51weth_contract = w3.eth.contract(address=w3.to_checksum_address(weth_token_addr), abi=simplified_abi)
52symbol = weth_contract.functions.symbol().call()
53decimals = weth_contract.functions.decimals().call()
54totalSupply = weth_contract.functions.totalSupply().call() / 10**decimals
55addr_balance = weth_contract.functions.balanceOf(acc_address).call() / 10**decimals
56
57# WETH
58print("===== %s =====" % symbol)
59print("Total Supply:", totalSupply)
60print("Addr Balance:", addr_balance)
Alle anzeigen

Bekannte Probleme

Problem beim Empfang von ERC-20-Token

Bis zum 20.06.2024 gingen aufgrund dieses Problems ERC-20-Token im Wert von mindestens 83.656.418 $ verloren. Beachten Sie, dass eine reine ERC-20-Implementierung für dieses Problem anfällig ist, es sei denn, Sie implementieren zusätzlich zum Standard eine Reihe von Einschränkungen, wie unten aufgeführt.

Wenn ERC-20-Token an einen Smart Contract gesendet werden, der nicht für die Verarbeitung von ERC-20-Token ausgelegt ist, können diese Token dauerhaft verloren gehen. Dies geschieht, weil der empfangende Vertrag nicht über die Funktionalität verfügt, die eingehenden Token zu erkennen oder darauf zu reagieren, und es im ERC-20-Standard keinen Mechanismus gibt, um den empfangenden Vertrag über die eingehenden Token zu benachrichtigen. Dieses Problem tritt hauptsächlich auf folgende Weise auf:

  1. Token-Übertragungsmechanismus
  • ERC-20-Token werden mit den Funktionen transfer oder transferFrom übertragen
    • Wenn ein Benutzer Token mit diesen Funktionen an eine Vertragsadresse sendet, werden die Token übertragen, unabhängig davon, ob der empfangende Vertrag für deren Verarbeitung ausgelegt ist
  1. Fehlende Benachrichtigung
    • Der empfangende Vertrag erhält keine Benachrichtigung oder keinen Rückruf, dass Token an ihn gesendet wurden
    • Wenn dem empfangenden Vertrag ein Mechanismus zur Verarbeitung von Token fehlt (z. B. eine Fallback-Funktion oder eine dedizierte Funktion zur Verwaltung des Token-Empfangs), stecken die Token effektiv in der Adresse des Vertrags fest
  2. Keine integrierte Verarbeitung
    • Der ERC-20-Standard enthält keine obligatorische Funktion, die empfangende Verträge implementieren müssen, was zu einer Situation führt, in der viele Verträge eingehende Token nicht ordnungsgemäß verwalten können

Mögliche Lösungen

Obwohl es nicht möglich ist, dieses Problem bei ERC-20 vollständig zu verhindern, gibt es Methoden, mit denen die Wahrscheinlichkeit eines Token-Verlusts für den Endbenutzer erheblich verringert werden kann:

  • Das häufigste Problem tritt auf, wenn ein Benutzer Token an die Adresse des Token-Vertrags selbst sendet (z. B. USDT, die an die Adresse des USDT-Token-Vertrags eingezahlt werden). Es wird empfohlen, die Funktion transfer(..) einzuschränken, um solche Übertragungsversuche rückgängig zu machen. Erwägen Sie das Hinzufügen der Überprüfung require(_to != address(this)); innerhalb der Implementierung der Funktion transfer(..).
  • Die Funktion transfer(..) ist im Allgemeinen nicht für die Einzahlung von Token in Verträge vorgesehen. Stattdessen wird das Muster approve(..) & transferFrom(..) verwendet, um ERC-20-Token in Verträge einzuzahlen. Es ist möglich, die Übertragungsfunktion so einzuschränken, dass die Einzahlung von Token in beliebige Verträge damit nicht zulässig ist. Dies kann jedoch die Kompatibilität mit Verträgen beeinträchtigen, die davon ausgehen, dass Token mit der Funktion transfer(..) in Verträge eingezahlt werden können (z. B. Uniswap-Liquiditätspools).
  • Gehen Sie immer davon aus, dass ERC-20-Token in Ihrem Vertrag landen können, selbst wenn Ihr Vertrag niemals welche erhalten soll. Es gibt keine Möglichkeit, versehentliche Einzahlungen auf Empfängerseite zu verhindern oder abzulehnen. Es wird empfohlen, eine Funktion zu implementieren, mit der versehentlich eingezahlte ERC-20-Token extrahiert werden können.
  • Erwägen Sie die Verwendung alternativer Token-Standards.

Aus diesem Problem sind einige alternative Standards hervorgegangen, wie z. B. ERC-223 oder ERC-1363.

Weiterführende Literatur

Andere Standards für fungible Token

Tutorials: Mit ERC-20 auf Ethereum bauen

War dieser Artikel hilfreich?