Den ERC-20-Token-Smart-Contract verstehen

Smart ContractsTokenSolidityErste SchritteErc-20

Beginner

jdourlens

5. April 2020

4 Minuten Lesedauer minute read

comp-tutorial-metadata-tip-author 0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE

Einer der wichtigsten Smart-Contract-Standards auf Ethereum ist als ERC-20 bekannt, der sich als technischer Standard für alle Smart Contracts auf der Ethereum-Blockchain für fungible Token-Implementierungen durchgesetzt hat.

ERC-20 definiert eine gemeinsame Liste von Regeln, an die sich alle fungible Ethereum-Token halten sollten. Folglich ermöglicht dieser Tokenstandard allen Entwicklern, die Funktionsweise neuer Token innerhalb des größeren Ethereum-Systems zu prognostizieren. Das vereinfacht und erleichtert die Arbeit der Entwickler, denn sie können mit ihrer Arbeit fortfahren, da sie wissen, dass nicht jedes neue Projekt von Grund auf neu erstellt werden muss, wenn ein neuer Token veröffentlicht wird, solange der Token den Regeln entspricht.

Hier sind die Funktionen, die ein ERC-20 implementieren muss, dargestellt in Form einer Schnittstelle. Wenn Sie unsicher sind, was eine Schnittstelle ist: Lesen Sie unseren Beitrag über OOP-Programmierung in Solidity(opens in a new tab).

1pragma solidity ^0.6.0;
2
3interface IERC20 {
4
5    function totalSupply() external view returns (uint256);
6    function balanceOf(address account) external view returns (uint256);
7    function allowance(address owner, address spender) external view returns (uint256);
8
9    function transfer(address recipient, uint256 amount) external returns (bool);
10    function approve(address spender, uint256 amount) external returns (bool);
11    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
12
13
14    event Transfer(address indexed from, address indexed to, uint256 value);
15    event Approval(address indexed owner, address indexed spender, uint256 value);
16}
Alles anzeigen
 Kopieren

Hier wird Zeile für Zeile erklärt, wofür die einzelnen Funktionen da sind. Danach stellen wir eine einfache Implementierung eines ERC-20-Tokens vor.

Getters

1function totalSupply() external view returns (uint256);
 Kopieren

Gibt die Anzahl der vorhandenen Token zurück. Diese Funktion ist ein Getter und verändert den Zustand des Vertrags nicht. Beachten Sie, dass es in Solidity keine Floats gibt. Daher nehmen die meisten Token 18 Dezimalstellen an und geben den Gesamtvorrat und andere Ergebnisse wie folgt zurück: 10000000000000000000000 für 1 Token. Nicht jeder Token hat 18 Dezimalstellen. Darauf müssen Sie beim Umgang mit Token unbedingt achten.

1function balanceOf(address account) external view returns (uint256);
 Kopieren

Gibt die Anzahl der Token zurück, die eine Adresse (Konto) besitzt. Diese Funktion ist ein Getter und verändert den Zustand des Vertrags nicht.

1function allowance(address owner, address spender) external view returns (uint256);
 Kopieren

Der ERC-20-Standard ermöglicht es einer Adresse, einer anderen Adresse eine Genehmigung zu erteilen, um Token von ihr abrufen zu können. Dieser Getter gibt die verbleibende Anzahl an Token zurück, die der Spender im Namen des Owner ausgeben darf. Diese Funktion ist ein Getter und ändert den Zustand des Vertrags nicht. Sie sollte standardmäßig 0 zurückgeben.

Funktionen

1function transfer(address recipient, uint256 amount) external returns (bool);
 Kopieren

Verschiebt die Anzahl von Token von der Adresse des Funktionsaufrufers (msg.sender) zur Empfängeradresse. Diese Funktion löst das später definierte Ereignis Transfer aus. Sie gibt true zurück, wenn die Übertragung möglich war.

1function approve(address spender, uint256 amount) external returns (bool);
 Kopieren

Legen Sie die Höhe der Allowance also die Freigabe fest, die der Spender vom Guthaben des Funktionsaufrufers (msg.sender) übertragen darf. Diese Funktion löst das Genehmigungsereignis aus. Die Funktion gibt zurück, ob die Freigabe erfolgreich gesetzt wurde.

1function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
 Kopieren

Verschiebt die Anzahl an Token vom Sender zum Recipient, also Empfänger, unter Verwendung des Genehmigungsmechanismus. Der Betrag wird dann von der Vergütung des Abfragers abgezogen. Diese Funktion löst das Ereignis Transfer aus.

Ereignisse

1event Transfer(address indexed from, address indexed to, uint256 value);
 Kopieren

Dieses Ereignis wird ausgegeben, wenn die Anzahl an Token (Wert) von der from-Adresse an die to-Adresse gesendet wird.

Bei der Prägung neuer Token erfolgt die Überweisung in der Regel von der 0x00..0000-Adresse, während im Falle von brennenden Token die Übertragung zu 0x00..0000 erfolgt.

1event Approval(address indexed owner, address indexed spender, uint256 value);
 Kopieren

Dieses Ereignis wird ausgegeben, wenn die Anzahl an Token (value) vom Owner, also Eigentümer, zur Verwendung durch den Spender genehmigt wurde.

Eine einfache Implementierung von ERC-20-Token

Im Folgenden finden Sie einen sehr einfachen Code, den Sie als Grundlage für Ihren ERC-20-Token verwenden können:

1pragma solidity ^0.8.0;
2
3interface IERC20 {
4
5    function totalSupply() external view returns (uint256);
6    function balanceOf(address account) external view returns (uint256);
7    function allowance(address owner, address spender) external view returns (uint256);
8
9    function transfer(address recipient, uint256 amount) external returns (bool);
10    function approve(address spender, uint256 amount) external returns (bool);
11    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
12
13
14    event Transfer(address indexed from, address indexed to, uint256 value);
15    event Approval(address indexed owner, address indexed spender, uint256 value);
16}
17
18
19contract ERC20Basic is IERC20 {
20
21    string public constant name = "ERC20Basic";
22    string public constant symbol = "ERC";
23    uint8 public constant decimals = 18;
24
25
26    mapping(address => uint256) balances;
27
28    mapping(address => mapping (address => uint256)) allowed;
29
30    uint256 totalSupply_ = 10 ether;
31
32
33   constructor() {
34    balances[msg.sender] = totalSupply_;
35    }
36
37    function totalSupply() public override view returns (uint256) {
38    return totalSupply_;
39    }
40
41    function balanceOf(address tokenOwner) public override view returns (uint256) {
42        return balances[tokenOwner];
43    }
44
45    function transfer(address receiver, uint256 numTokens) public override returns (bool) {
46        require(numTokens <= balances[msg.sender]);
47        balances[msg.sender] = balances[msg.sender]-numTokens;
48        balances[receiver] = balances[receiver]+numTokens;
49        emit Transfer(msg.sender, receiver, numTokens);
50        return true;
51    }
52
53    function approve(address delegate, uint256 numTokens) public override returns (bool) {
54        allowed[msg.sender][delegate] = numTokens;
55        emit Approval(msg.sender, delegate, numTokens);
56        return true;
57    }
58
59    function allowance(address owner, address delegate) public override view returns (uint) {
60        return allowed[owner][delegate];
61    }
62
63    function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
64        require(numTokens <= balances[owner]);
65        require(numTokens <= allowed[owner][msg.sender]);
66
67        balances[owner] = balances[owner]-numTokens;
68        allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
69        balances[buyer] = balances[buyer]+numTokens;
70        emit Transfer(owner, buyer, numTokens);
71        return true;
72    }
73}
Alles anzeigen
 Kopieren

Eine weitere hervorragende Implementierung des ERC-20 Token-Standards ist die OpenZeppelin ERC-20 Implementierung(opens in a new tab).