What is an ERC20 token?

If you are new to the blockchain space you will quickly hear about ERC20 tokens, but what are ERC20 tokens? That’s exactly what we will explain in this post.

Ethereum Request for Comments

ERC is an acronym and stands for “Ethereum Request for Comments”. These are usually technical documents that form application-level standards for Ethereum smart contract developers. They are often token standards, like the ERC20 one. But there are many other ones like ERC721 && ERC1155, they can also be other things such as registries, library, and package formats. It is very common within the developer communities to have some kind of “Request for comments” solution to come up with improvements and ideas. The proposal to have such a standard also for Ethereum came from the GitHub user ethers and you can find that GitHub thread here.

The ERC20 token standard

The ERC20 token standard is just a blueprint and a set of rules for how to create fungible tokens on Ethereum. All tokens on Ethereum and Ethereum compatible blockchains are nothing but smart contracts that are created with a programming language such as Solidity or Vyper.

Many people want to create tokens for many different reasons. It’s perfectly possible to create fungible tokens on Ethereum in many different ways. However, to make sure that everything fits together and that all tokens implement the same kind of functions and logic — different standards are necessary.

Without a common standard and a set of rules, no wallets would be able to implement all tokens in existence. The same is true for exchanges. The only reason ERC20 tokens are supported by most wallets is because of the common standard that each token is following.

You can compare this to electrical wall outlets. For the USA we have one standard which enables almost all electrical devices to plug into the wall to receive electricity. The same is true for other continents like Europe, Asia, and Australia. Standards are followed to make sure maximum compatibility.

What is forced to exist on an ERC20 token?

For a smart contract to be considered an ERC20 token it needs to implement the ERC20 interface which consists of some methods (functions) & events. Some of these will be mandatory to implement while some are optional but recommended.

Methods

Optional:

• name – This method should return the name of the token as a string.
• symbol – This method should return the symbol of the token as a string.
• decimals – This method should return the number of decimals that the token uses as a uint8. The most commonly used is 18 decimals.

Mandatory:

• totalSupply – This method should return the total supply of the tokens as a uint256.
• balanceOf – This method takes one argument that should be an address. The method should return the balance of that address.
• transfer – This method takes two arguments — to (address) && value (uint256). The method should return a true bool if successful. The method should throw an error if the caller doesn’t have enough balance for the transfer to take place. If a transfer is successful a Transfer event must be emitted.
• transferFrom – This method takes three arguments — from (address), to (address) && value (uint256). It should return a true bool if successful and emit a Transfer event.This method is usually used by other smart contracts to transfer funds on your behalf.
• approve – This method takes two arguments — spender && value. It should return a true bool if successful. This method is called whenever a user wants to approve someone to spend tokens on their behalf. Commonly used in defi to approve smart contracts to spend a user’s tokens.
• allowance – This method takes two arguments — owner && spender. It should return a uint256 with the remaining amount that the spender is still allowed to withdraw from the owner.

Events

There are two events that have to be emitted when certain things happen in the contract. These are:

• Transfer – This event has to trigger whenever a transfer is done within the contract.
• Approval – This event has to trigger whenever a successful call to the approve method is done.

Example contract

Here is an example of an ERC20 contract written in Solidity that implements the IERC20 interface from OpenZeppelin:

pragma solidity ^0.4.24;

import "./IERC20.sol";
import "../../math/SafeMath.sol";

/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
 * Originally based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 */
contract ERC20 is IERC20 {
  using SafeMath for uint256;

  mapping (address => uint256) private _balances;

  mapping (address => mapping (address => uint256)) private _allowed;

  uint256 private _totalSupply;

  /**
  * @dev Total number of tokens in existence
  */
  function totalSupply() public view returns (uint256) {
    return _totalSupply;
  }

  /**
  * @dev Gets the balance of the specified address.
  * @param owner The address to query the balance of.
  * @return An uint256 representing the amount owned by the passed address.
  */
  function balanceOf(address owner) public view returns (uint256) {
    return _balances[owner];
  }

  /**
   * @dev Function to check the amount of tokens that an owner allowed to a spender.
   * @param owner address The address which owns the funds.
   * @param spender address The address which will spend the funds.
   * @return A uint256 specifying the amount of tokens still available for the spender.
   */
  function allowance(
    address owner,
    address spender
   )
    public
    view
    returns (uint256)
  {
    return _allowed[owner][spender];
  }

  /**
  * @dev Transfer token for a specified address
  * @param to The address to transfer to.
  * @param value The amount to be transferred.
  */
  function transfer(address to, uint256 value) public returns (bool) {
    require(value <= _balances[msg.sender]);
    require(to != address(0));

    _balances[msg.sender] = _balances[msg.sender].sub(value);
    _balances[to] = _balances[to].add(value);
    emit Transfer(msg.sender, to, value);
    return true;
  }

  /**
   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
   * Beware that changing an allowance with this method brings the risk that someone may use both the old
   * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
   * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
   * @param spender The address which will spend the funds.
   * @param value The amount of tokens to be spent.
   */
  function approve(address spender, uint256 value) public returns (bool) {
    require(spender != address(0));

    _allowed[msg.sender][spender] = value;
    emit Approval(msg.sender, spender, value);
    return true;
  }

  /**
   * @dev Transfer tokens from one address to another
   * @param from address The address which you want to send tokens from
   * @param to address The address which you want to transfer to
   * @param value uint256 the amount of tokens to be transferred
   */
  function transferFrom(
    address from,
    address to,
    uint256 value
  )
    public
    returns (bool)
  {
    require(value <= _balances[from]);
    require(value <= _allowed[from][msg.sender]);
    require(to != address(0));

    _balances[from] = _balances[from].sub(value);
    _balances[to] = _balances[to].add(value);
    _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
    emit Transfer(from, to, value);
    return true;
  }

  /**
   * @dev Increase the amount of tokens that an owner allowed to a spender.
   * approve should be called when allowed_[_spender] == 0. To increment
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param spender The address which will spend the funds.
   * @param addedValue The amount of tokens to increase the allowance by.
   */
  function increaseAllowance(
    address spender,
    uint256 addedValue
  )
    public
    returns (bool)
  {
    require(spender != address(0));

    _allowed[msg.sender][spender] = (
      _allowed[msg.sender][spender].add(addedValue));
    emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
    return true;
  }

  /**
   * @dev Decrease the amount of tokens that an owner allowed to a spender.
   * approve should be called when allowed_[_spender] == 0. To decrement
   * allowed value is better to use this function to avoid 2 calls (and wait until
   * the first transaction is mined)
   * From MonolithDAO Token.sol
   * @param spender The address which will spend the funds.
   * @param subtractedValue The amount of tokens to decrease the allowance by.
   */
  function decreaseAllowance(
    address spender,
    uint256 subtractedValue
  )
    public
    returns (bool)
  {
    require(spender != address(0));

    _allowed[msg.sender][spender] = (
      _allowed[msg.sender][spender].sub(subtractedValue));
    emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
    return true;
  }

  /**
   * @dev Internal function that mints an amount of the token and assigns it to
   * an account. This encapsulates the modification of balances such that the
   * proper events are emitted.
   * @param account The account that will receive the created tokens.
   * @param amount The amount that will be created.
   */
  function _mint(address account, uint256 amount) internal {
    require(account != 0);
    _totalSupply = _totalSupply.add(amount);
    _balances[account] = _balances[account].add(amount);
    emit Transfer(address(0), account, amount);
  }

  /**
   * @dev Internal function that burns an amount of the token of a given
   * account.
   * @param account The account whose tokens will be burnt.
   * @param amount The amount that will be burnt.
   */
  function _burn(address account, uint256 amount) internal {
    require(account != 0);
    require(amount <= _balances[account]);

    _totalSupply = _totalSupply.sub(amount);
    _balances[account] = _balances[account].sub(amount);
    emit Transfer(account, address(0), amount);
  }

  /**
   * @dev Internal function that burns an amount of the token of a given
   * account, deducting from the sender's allowance for said account. Uses the
   * internal burn function.
   * @param account The account whose tokens will be burnt.
   * @param amount The amount that will be burnt.
   */
  function _burnFrom(address account, uint256 amount) internal {
    require(amount <= _allowed[account][msg.sender]);

    // Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
    // this function needs to emit an event with the updated approval.
    _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
      amount);
    _burn(account, amount);
  }
}

OpenZeppelin is a library for secure smart contract development. You can find the repository of OpenZeppelin over here.