Admin: Created page with "{{#seo: |title=ERC20 Token Standard – Ethereum Smart Contracts – zaoniao Wiki |keywords=erc 20, token, ethereum, token standard, coin, blockchain, protocol |description=ER..."

2019-02-28T09:22:12Z

Created page with "{{#seo: |title=ERC20 Token Standard – Ethereum Smart Contracts – zaoniao Wiki |keywords=erc 20, token, ethereum, token standard, coin, blockchain, protocol |description=ER..."

New page

{{#seo:
|title=ERC20 Token Standard – Ethereum Smart Contracts – zaoniao Wiki
|keywords=erc 20, token, ethereum, token standard, coin, blockchain, protocol
|description=ERC20 is the Ethereum token standard which is used for ETH Smart contracts. ERC-20 coins gained popularity with crowdfunding companies via ICO. This token standard describes the functions and events that an Ethereum token contract has to implement.
}}
<amp/>
[[File:erc20.png|400px|right|ERC20 token]]
'''ERC20''' is the [[Ethereum]] token standard which is used for Ethereum [[Smart_contract|smart contracts]]. Developed in 2015, '''ERC-20''' defines a common list of rules that an Ethereum token has to implement. Giving developers the ability to program how new tokens will function within the Ethereum ecosystem. This token protocol became popular with crowdfunding companies via [[Initial_coin_offering|Initial Coin Offering]] (ICO).

Mercury Protocol's Global Messaging Token is an example of an application based on ERC20 tokens.

The [https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md ERC20] token standard describes the functions and events that an Ethereum token contract has to implement.

==The ERC20 Token Standard Interface==
Following is an interface contract declaring the required functions and events to meet the ERC20 standard:

<syntaxhighlight lang="javascript" line='line'>
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);

event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
</syntaxhighlight>

Most of the major tokens on the Ethereum blockchain are ERC-20-compliant. The [[GNT]] [[Golem Network Token]] is only partially-ERC20 blockchain-compliant as it does not implement the <code>approve(...)</code>, <code>allowance(..)</code> and <code>transferFrom(...)</code> functions, and the <code>Approval(...)</code> event.

Some of the tokens include further information describing the token contract:

<syntaxhighlight lang="javascript" line='line'>
string public constant name = "Token Name";
string public constant symbol = "SYM";
uint8 public constant decimals = 18; // 18 is the most common number of decimal places
</syntaxhighlight>

<br />

==How Does ERC-20 Token Contract Work?==

Following is a fragment of a token contract to demonstrate how a token contract maintains the token balance of Ethereum accounts:

<syntaxhighlight lang="javascript" line='line'>
contract TokenContractFragment {

// Balances for each account
mapping(address => uint256) balances;

// Owner of account approves the transfer of an amount to another account
mapping(address => mapping (address => uint256)) allowed;

// Get the token balance for account `tokenOwner`
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}

// Transfer the balance from owner's account to another account
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}

// Send `tokens` amount of tokens from address `from` to address `to`
// The transferFrom method is used for a withdraw workflow, allowing contracts to send
// tokens on your behalf, for example to "deposit" to a contract address and/or to charge
// fees in sub-currencies; the command should fail unless the _from account has
// deliberately authorized the sender of the message via some mechanism; we propose
// these standardized APIs for approval:
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}

// Allow `spender` to withdraw from your account, multiple times, up to the `tokens` amount.
// If this function is called again it overwrites the current allowance with _value.
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
}
</syntaxhighlight>

===Blockchain Token Balance===
For an example, assume that this token contract has two token holders:
* <code>0x1111111111111111111111111111111111111111</code> with a balance of 100 units
* <code>0x2222222222222222222222222222222222222222</code> with a balance of 200 units

The token contract's <code>balances</code> data structure will contain the following information:
balances[0x1111111111111111111111111111111111111111] = 100
balances[0x2222222222222222222222222222222222222222] = 200

The <code>balanceOf(...)</code> function will return the following values:
tokenContract.balanceOf(0x1111111111111111111111111111111111111111) will return 100
tokenContract.balanceOf(0x2222222222222222222222222222222222222222) will return 200

===Transfer Token Balance===
If <code>0x1111111111111111111111111111111111111111</code> wants to transfer 10 tokens to <code>0x2222222222222222222222222222222222222222</code>, <code>0x1111111111111111111111111111111111111111</code> will execute the function:
tokenContract.transfer(0x2222222222222222222222222222222222222222, 10)

The token contract's <code>transfer(...)</code> function will alter the <code>balances</code> data structure to contain the following information:
balances[0x1111111111111111111111111111111111111111] = 90
balances[0x2222222222222222222222222222222222222222] = 210

The <code>balanceOf(...)</code> function will now return the following values:
tokenContract.balanceOf(0x1111111111111111111111111111111111111111) will return 90
tokenContract.balanceOf(0x2222222222222222222222222222222222222222) will return 210

===Approve And TransferFrom Token Balance===
'''ERC20 Source code'''
If <code>0x1111111111111111111111111111111111111111</code> wants to authorise <code>0x2222222222222222222222222222222222222222</code> to transfer some tokens to <code>0x2222222222222222222222222222222222222222</code>, <code>0x1111111111111111111111111111111111111111</code> will execute the function:
tokenContract.approve(0x2222222222222222222222222222222222222222, 30)

The <code>approve</code> data structure will now contain the following information:
tokenContract.allowed[0x1111111111111111111111111111111111111111][0x2222222222222222222222222222222222222222] = 30

If <code>0x2222222222222222222222222222222222222222</code> wants to later transfer some tokens from <code>0x1111111111111111111111111111111111111111</code> to itself, <code>0x2222222222222222222222222222222222222222</code> executes the <code>transferFrom(...)</code> function:
tokenContract.transferFrom(0x1111111111111111111111111111111111111111, 0x2222222222222222222222222222222222222222, 20)

The <code>balances</code> data structure will be altered to contain the following information:
tokenContract.balances[0x1111111111111111111111111111111111111111] = 70
tokenContract.balances[0x2222222222222222222222222222222222222222] = 230

And the <code>approve</code> data structure will now contain the following information:
tokenContract.allowed[0x1111111111111111111111111111111111111111][0x2222222222222222222222222222222222222222] = 10
<code>0x2222222222222222222222222222222222222222</code> can still spend 10 tokens from <code>0x1111111111111111111111111111111111111111</code>.

The <code>balanceOf(...)</code> function will now return the following values:
tokenContract.balanceOf(0x1111111111111111111111111111111111111111) will return 70
tokenContract.balanceOf(0x2222222222222222222222222222222222222222) will return 230

<br />

==Sample Fixed Supply Token Contract==
Following is a sample [https://github.com/bokkypoobah/Tokens#fixed-supply-token Fixed Supply Token] contract with a fixed supply of 1,000,000 units that are initially assigned to the owner of the contract. This token has 18 decimal places:
'''ERC20 Code''':
<syntaxhighlight lang="javascript" line='line'>
pragma solidity ^0.4.18;

// ----------------------------------------------------------------------------
// 'FIXED' 'Example Fixed Supply Token' token contract
//
// Symbol : FIXED
// Name : Example Fixed Supply Token
// Total supply: 1,000,000.000000000000000000
// Decimals : 18
//
// Enjoy.
//
// (c) BokkyPooBah / Bok Consulting Pty Ltd 2017. The MIT Licence.
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}

// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);

event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}

// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}

// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;

event OwnershipTransferred(address indexed _from, address indexed _to);

function Owned() public {
owner = msg.sender;
}

modifier onlyOwner {
require(msg.sender == owner);
_;
}

function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}

// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and an
// initial fixed supply
// ----------------------------------------------------------------------------
contract FixedSupplyToken is ERC20Interface, Owned {
using SafeMath for uint;

string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;

mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;

// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function FixedSupplyToken() public {
symbol = "FIXED";
name = "Example Fixed Supply Token";
decimals = 18;
_totalSupply = 1000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
Transfer(address(0), owner, _totalSupply);
}

// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}

// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}

// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}

// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}

// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}

// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}

// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}

// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}

// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
}
</syntaxhighlight>

See [https://medium.com/bitfwd/how-to-issue-your-own-token-on-ethereum-in-less-than-20-minutes-ac1f8f022793 How to issue your own token on Ethereum in less than 20 minutes] for steps to deploy a token contract.

==Further Information On ERC20 network and platform for tokens==
* Ethereum.org Token page: https://www.ethereum.org/token.
* Etherscan token selection of popular tokens: https://etherscan.io/tokens
* EtherScan ERC20 token search: https://etherscan.io/token-search
* The HumanStandardToken: a specialisation of ERC20 that provides a name, decimals, symbol and version as public variables, so these can be read from the contract and do not need to be configured: https://github.com/ConsenSys/Tokens/blob/master/Token_Contracts/contracts/HumanStandardToken.sol
* Token Factory, an application that lets you create these tokens, just to play around with: https://tokenfactory.surge.sh
* ERC 20 Blockchain Libraries:
** OpenZeppelin: https://github.com/OpenZeppelin/zeppelin-solidity/tree/master/contracts/token
** Minime token contract that allows to clone itself, so it can be used for things like voting, or even splitting off a token for a separate application: https://github.com/Giveth/minime

==See also==
* [[Ethereum Based Tokens]]
* [[Mining]]
* [[BTC China]]
* [[CEX.IO]]

==Source==
[http://wikipedia.org/ http://wikipedia.org/]

[[de:ERC20]]

[[Category:Ethereum]]

ERC20 - Revision history

Admin: Created page with "{{#seo: |title=ERC20 Token Standard – Ethereum Smart Contracts – zaoniao Wiki |keywords=erc 20, token, ethereum, token standard, coin, blockchain, protocol |description=ER..."