HomeEIPs
EIPsERC-20
ERC-20

Token Standard

FinalStandards Track: ERC
Created: 2015-11-19
Fabian Vogelsteller <fabian@ethereum.org>, Vitalik Buterin <vitalik.buterin@ethereum.org>
Original linkEdit
1 min read

The ERC-20 Token Standard is a set of rules and guidelines that define a common interface for tokens on the Ethereum network. It was proposed by Vitalik Buterin and Fabian Vogelsteller in November 2015 as an Ethereum Improvement Proposal (EIP-20). The standard provides a basic set of functions that any token on the Ethereum network can implement, making it easier for developers to create and interact with tokens.

The ERC-20 Token Standard defines six functions that a token contract must implement: name, symbol, decimals, totalSupply, balanceOf, and transfer. These functions allow users to check the name, symbol, and total supply of a token, as well as transfer tokens between accounts and check the balance of a specific account. The standard also includes an event called Approval, which is triggered whenever a user approves another user to spend their tokens.

The ERC-20 Token Standard is important because it allows different tokens on the Ethereum network to be easily exchanged and used by other applications. For example, a wallet application can use the standard to display the balance of a user's tokens, and a decentralized exchange can use the standard to trade different tokens without needing to implement custom code for each token.

There are already many ERC-20-compliant tokens deployed on the Ethereum network, and different teams have written different implementations of the standard with different trade-offs. For example, some implementations may prioritize gas efficiency, while others may prioritize security. The OpenZeppelin and ConsenSys implementations are two examples of ERC-20 implementations that are widely used.

Overall, the ERC-20 Token Standard is a key component of the Ethereum ecosystem, providing a common interface for tokens that allows for interoperability and ease of use.

Video
Anyone may contribute to propose contents.
Go propose
Original

Simple Summary

A standard interface for tokens.

Abstract

The following standard allows for the implementation of a standard API for tokens within smart contracts. This standard provides basic functionality to transfer tokens, as well as allow tokens to be approved so they can be spent by another on-chain third party.

Motivation

A standard interface allows any tokens on Ethereum to be re-used by other applications: from wallets to decentralized exchanges.

Specification

Token

Methods

NOTES:

  • The following specifications use syntax from Solidity 0.4.17 (or above)
  • Callers MUST handle false from returns (bool success). Callers MUST NOT assume that false is never returned!

name

Returns the name of the token - e.g. "MyToken".

OPTIONAL - This method can be used to improve usability, but interfaces and other contracts MUST NOT expect these values to be present.

function name() public view returns (string)

symbol

Returns the symbol of the token. E.g. "HIX".

OPTIONAL - This method can be used to improve usability, but interfaces and other contracts MUST NOT expect these values to be present.

function symbol() public view returns (string)

decimals

Returns the number of decimals the token uses - e.g. 8, means to divide the token amount by 100000000 to get its user representation.

OPTIONAL - This method can be used to improve usability, but interfaces and other contracts MUST NOT expect these values to be present.

function decimals() public view returns (uint8)

totalSupply

Returns the total token supply.

function totalSupply() public view returns (uint256)

balanceOf

Returns the account balance of another account with address _owner.

function balanceOf(address _owner) public view returns (uint256 balance)

transfer

Transfers _value amount of tokens to address _to, and MUST fire the Transfer event. The function SHOULD throw if the message caller's account balance does not have enough tokens to spend.

Note Transfers of 0 values MUST be treated as normal transfers and fire the Transfer event.

function transfer(address _to, uint256 _value) public returns (bool success)

transferFrom

Transfers _value amount of tokens from address _from to address _to, and MUST fire the Transfer event.

The transferFrom method is used for a withdraw workflow, allowing contracts to transfer tokens on your behalf. This can be used for example to allow a contract to transfer tokens on your behalf and/or to charge fees in sub-currencies. The function SHOULD throw unless the _from account has deliberately authorized the sender of the message via some mechanism.

Note Transfers of 0 values MUST be treated as normal transfers and fire the Transfer event.

function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)

approve

Allows _spender to withdraw from your account multiple times, up to the _value amount. If this function is called again it overwrites the current allowance with _value.

NOTE: To prevent attack vectors like the one described here and discussed here, clients SHOULD make sure to create user interfaces in such a way that they set the allowance first to 0 before setting it to another value for the same spender. THOUGH The contract itself shouldn't enforce it, to allow backwards compatibility with contracts deployed before

function approve(address _spender, uint256 _value) public returns (bool success)

allowance

Returns the amount which _spender is still allowed to withdraw from _owner.

function allowance(address _owner, address _spender) public view returns (uint256 remaining)

Events

Transfer

MUST trigger when tokens are transferred, including zero value transfers.

A token contract which creates new tokens SHOULD trigger a Transfer event with the _from address set to 0x0 when tokens are created.

event Transfer(address indexed _from, address indexed _to, uint256 _value)

Approval

MUST trigger on any successful call to approve(address _spender, uint256 _value).

event Approval(address indexed _owner, address indexed _spender, uint256 _value)

Implementation

There are already plenty of ERC20-compliant tokens deployed on the Ethereum network. Different implementations have been written by various teams that have different trade-offs: from gas saving to improved security.

Example implementations are available at

History

Historical links related to this standard:

Copyright and related rights waived via CC0.

Further reading
Anyone may contribute to propose contents.
Go propose
Adopted by projects
Anyone may contribute to propose contents.
Go propose

Not miss a beat of EIPs' update?

Subscribe EIPs Fun to receive the latest updates of EIPs Good for Buidlers to follow up.

View all
Serve Ethereum Builders, Scale the Community.
Resources
GitHub
Supported by