Comprendre le contrat intelligent de jeton ERC-20

contrats intelligentsjetonssolidityerc-20

Débutant

jdourlens

5 avril 2020

5 minutes de lecture minute read

comp-tutorial-metadata-tip-author 0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE

L'un des plus importantes normes de contrat intelligent sur Ethereum est connue sous le nom de ERC-20, qui est apparu comme le standard technique de référence pour tous les contrats intelligents sur la blockchain Ethereum pour les implémentations de jetons fongibles.

ERC-20 définit une liste commune de règles auxquelles tous les jetons Ethereum fongibles devraient adhérer. Par conséquent, cette norme de jeton permet aux développeurs de tous types de prédire avec précision comment de nouveaux jetons fonctionneront au sein du système Ethereum dans son ensemble. Cela simplifie et facilite les tâches des développeurs, car ils peuvent se concentrer sur leur travail tout en sachant que chacun de leurs projets et chaque nouveau projet n'aura pas besoin d'être refait ou modifié à chaque fois qu'un nouveau jeton est publié, à condition que le jeton respecte les règles.

Voici les fonctions, présentées comme une interface, que tout jeton ERC-20 doit implémenter. Si vous n'êtes pas sûr de ce qu'est une interface : consultez notre article sur la programmation orientée objet dans 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}
Afficher tout
 Copier

Voici une explication ligne par ligne de ce à quoi sert chaque fonction. Après cela, nous présenterons une implémentation simple du jeton ERC-20.

Getters

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

Renvoie le nombre total de jetons existants. Cette fonction est un getter et ne modifie pas l'état du contrat. Gardez à l'esprit qu'il n'y a pas de nombres décimaux dans Solidity. C'est pourquoi la plupart des jetons adoptent 18 décimales et retournent le total des jetons ainsi que d'autres résultats sous la forme de 1000000000000000000 pour 1 jeton. Tous les jetons n'ont pas nécessairement 18 décimales et c'est donc un élément à surveiller lorsqu'on manipule des jetons.

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

Renvoie le nombre de jetons détenus par une adresse (compte). Cette fonction est un getter et ne modifie pas l'état du contrat.

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

La norme ERC-20 permet à une adresse de donner une allocation (« allowance ») à une autre adresse pour pouvoir récupérer des jetons à partir de celle-ci. Ce getter retourne le nombre restant de jetons que le dépenseur sera autorisé à dépenser au nom du propriétaire. Cette fonction est un getter et ne modifie pas l'état du contrat et doit retourner 0 par défaut.

Fonctions

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

Déplace le montant amount de jetons de l'adresse de l'appelant de la fonction (msg.sender) à l'adresse du destinataire. Cette fonction émet l'événement Transfert que nous expliquerons plus tard. Il renvoie « vrai » si le transfert a été possible.

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

Définit le montant de l'allocation que le dépenseur spender est autorisé à transférer à partir du solde de l'appelant de la fonction (msg.sender). Cette fonction émet l'événement d'approbation « Approval ». La fonction retourne si l'allocation a été mise en place avec succès.

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

Déplace le montant amount de jetons de l'expéditeur vers le destinataire en utilisant le mécanisme de provision « allowance ». le montant est ensuite déduit de la provision « allowance » de l'appelant. Cette fonction émet l'événement Transfert .

Événements

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

Cet événement est émis lorsque le nombre de jetons (valeur) est envoyé depuis l'adresse de à l'adresse à.

Dans le cas du minage de nouveaux jetons, le transfert s'opère généralement depuis l'adresse 0x00..000 alors que dans le cas d'une destruction de jetons, le transfert s'opère vers l'adresse 0x00..0000.

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

Cet événement est émis lorsque le nombre de jetons (value) est approuvé par le propriétaire owner pour etre utilisé par le dépenseur spender.

Une implémentation basique des jetons ERC-20

Voici le code le plus simple possible à prendre comme base pour votre jeton ERC-20 :

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}
Afficher tout
 Copier

Une autre excellente implémentation de la norme de jeton ERC-20 est l'implémentation OpenZeppelin ERC-20(opens in a new tab).