Entenda o contrato inteligente de token ERC-20

contratos inteligentestokenssolidityerc-20

Intermediário

jdourlens

5 de abril de 2020

5 minutos de leitura minute read

comp-tutorial-metadata-tip-author 0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE

Um dos padrões de contrato inteligente mais significativos no Ethereum é conhecido como ERC-20, que surgiu como o padrão técnico usado para todos os contratos inteligentes na blockchain Ethereum para implementações de tokens fungíveis.

O ERC-20 define uma lista comum de regras a que todos os tokens fungíveis de Ethereum devem aderir. Consequentemente, este token padrão capacita os desenvolvedores de todos os tipos para prever com precisão como novos tokens funcionarão dentro do sistema Ethereum maior. Isto simplifica e facilita as tarefas dos desenvolvedores, porque eles podem prosseguir com o seu trabalho. sabendo que cada projeto novo não precisará ser feito toda vez que um novo token for lançado, contanto que o token siga as regras.

Veja aqui, apresentadas como uma interface, as funções que um ERC-20 deve implementar. Se você não tem certeza sobre o que é uma interface, confira nosso artigo sobre a programação OOP no 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}
Exibir tudo
 Copiar

Aqui está uma explicação detalhada da utilidade de cada função. Depois disso, apresentaremos uma implementação simples do token ERC-20.

Getters

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

Retorna a quantidade de tokens existentes. Esta função é um getter e não modifica o estado do contrato. Tenha em mente que não há "floats" em Solidity. Portanto, a maioria dos tokens adota 18 decimais e retorna a oferta total e outros resultados conforme seguido 1000000000000000000 por 1 token. Nem todos os tokens têm 18 decimais, e isso é algo que você realmente precisa estar atendo ao lidar com tokens.

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

Retorna a quantidade de tokens pertencentes a um endereço (account). Esta função é um getter e não modifica o estado do contrato.

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

O padrão ERC-20 permite que um endereço autorize outro endereço a recuperar tokens dele. Este getter retorna o número restante de tokens que o spender terá permissão para gastar em nome do owner. Esta função é um getter e não modifica o estado do contrato e deve retornar 0 por padrão.

Funções

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

Move amount (a quantidade) de tokens do endereço de chamada da função (msg.sender) para o endereço do destinatário. Esta função emite o evento de Transfer definido mais tarde. Se a transferência foi possível, retorna verdadeiro.

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

Defina o valor allowance the spender que pode ser transferido a partir do saldo da função caller (msg.sender). Esta função emite o evento de aprovação. A função retorna se o abono foi definido com sucesso.

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

Move amount de tokens do sender para o recipient usando o mecanismo de abono. o valor é então deduzido do abono do chamador. Esta função emite o evento Transfer.

Eventos

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

Este evento é emitido quando a quantidade de tokens (valor) é enviada do endereço from para o endereço to.

No caso de criação de novos tokens, a transferência é geralmente do endereço 0x00..0000, enquanto no caso de queima de tokens a transferência é para 0x00..0000.

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

Este evento é emitido quando a quantidade de tokens (value) é aprovada pelo owner para ser usada pelo spender.

Uma implementação básica de tokens ERC-20

Aqui está o código mais simples para basear seu token 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}
Exibir tudo
 Copiar

Outra excelente implementação do padrão ERC-20 é a implementação OpenZeppelin ERC-20(opens in a new tab).