Understanding ERC Standards

I got an opportunity to take a closer look at ERC standards, analyze and compare them. I believe that the information below would be helpful for every investor and ICO entrepreneur to understand what exactly ERC standards are.

This article sheds light on tokens and explains the features and functions of ERC standards to provide an understanding of what token contracts are and how developers can work with them.

ERC stands for Ethereum Request for Comments. It describes the functions and events that an Ethereum token contract has to implement. It is authored by Ethereum community developers in the form of a memorandum describing methods, behaviors, research, or innovations applicable to the working of the Ethereum ecosystem. This is an official protocol for proposing improvements to the Ethereum network. After core developers and community approval, the proposal becomes a standard.

The ERC standard defines an interface, which is the name of the functions as well as their signature. Signature means a list of their arguments. It also defines what these functions should do. But it does not define how you implement it and thus it does not include any code.

1.     ERC-20

The Ethereum token standard (ERC20) is used for Ethereum smart contracts. Developed in 2015, ERC20 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 (ICO). All Smart Contracts implementing this standard, by default can be listed to crypto exchanges without any extra technical work. As of January 2018, there were more than 21,000 ERC20 token contracts. 

The ERC20 Token Standard Interface

Following is an interface contract declaring the required functions and events to meet the ERC20 standard:

 1 // -----------------------------------------------------------------

 2 // ERC Token Standard #20 Interface

 4 // -----------------------------------------------------------------

 5 contract ERC20Interface {

 6     function totalSupply() public constant returns (uint);

 7     function balanceOf(address tokenOwner) public constant returns (uint balance);

 8     function allowance(address tokenOwner, address spender) public constant returns (uint remaining);

 9     function transfer(address to, uint tokens) public returns (bool success);

10     function approve(address spender, uint tokens) public returns (bool success);

11     function transferFrom(address from, address to, uint tokens) public returns (bool success);

12

13     event Transfer(address indexed from, address indexed to, uint tokens);

14     event Approval(address indexed tokenOwner, address indexed spender, uint tokens);

15 }

Most of the major tokens on the Ethereum blockchain are ERC20-compliant.

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

1     string public constant name = "Token_Name";2     string public constant symbol = "SYMBOL";3     uint8 public constant decimals = 18;  // 18 is the most common number of decimal places

All ERC20 tokens transact on the same network that your Ethereum wallet uses. Hence, an ETH address is also a GNT address, is also an EOS address, and so forth.

2.     ERC-721

The new game recently made several headlines within the cryptocurrency community because of its extremely unique based on the Ethereum network. CryptoKitties is a game in which players can buy, sell, trade, and breed digital cats. They can be thought of as “breedable Beanie Babies” in that each cat is unique (non-fungible) in some way. This uniqueness makes the CryptoKitties extremely collectible.

Kitty #489429 price=6.8816 ETH                    Kitty #58177 price=100000 ETH

Even WikiLeaks owns several high-value CryptoKitties!

We can emulate rare, collectible items with Ethereum tokens, and each of these tokens follows a novel standard in the Ethereum community known as ERC721 which are called ‘non-fungible’ i.e. unique tokens.  ERC721 is an Ethereum Improvement Proposal introduced by Dieter Shirley in late 2017.

In terms of collectible items, two items in a collection are not fungible if they have different characteristics. For physical coins, a gold coin is not fungible with a copper coin, because their differing characteristics give them different values to collectors.

The ERC721 Token Standard Interface

Following is an interface contract declaring the required functions and events to meet the ERC721 standard:

 1 // -----------------------------------------------------------------

 2 // ERC Token Standard #721 Interface

 4 // -----------------------------------------------------------------

 5 contract ERC20Interface {

 6  function name() constant returns (string name);

 7  function symbol() constant returns (string symbol);

 8  function balanceOf(address _owner) constant returns (uint balance);

 9   // Functions that define ownership

10  function ownerOf(uint256 _tokenId) constant returns (address owner);

11  function approve(address _to, uint256 _tokenId);

12  function takeOwnership(uint256 _tokenId);

13  function transfer(address _to, uint256 _tokenId);

14  function tokenOfOwnerByIndex(address _owner, uint256 _index) constant returns (uint tokenId);

15   // Token metadata

16  function tokenMetadata(uint256 _tokenId) constant returns (string infoUrl);

17   // events

18   event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);

19   event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);

20 }

3.     ERC-827

ERC827 is one of the latest token standards and improvements to ERC20 on the Ethereum network. In the current ERC20 model, only value can be transferred. However, by using ERC827, Ethereum users can transfer value as well as data in the transaction. The data is sent in bytes format.

 1 // -----------------------------------------------------------------

 2 // ERC Token Standard #827 Interface

 4 // -----------------------------------------------------------------

 5 contract ERC827Interface {

 6   function approve(address _spender, uint256 _value, bytes _data) public returns (bool);

 7   function transfer(address _to, uint256 _value, bytes _data) public returns (bool);

 8   function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool);

 9   }

4.     ERC-223

ERC223 is a modification of ERC20 token standard. This proposal was introduced by a developer, who decided to solve issues with the current ERC-20 standard for tokens. Below I excluded main features of this proposed standard.

Advantages:

• Provides a possibility to avoid accidentally lost tokens inside contracts that are not designed to work with sent tokens.

• Transfer to contracts consumes less gas than ERC-20: The transfer of ERC223 tokens to a contract is a one-step process rather than 2 step process (for ERC20)

• Allows developers to handle incoming token transactions, and reject non-supported tokens (not possible with ERC20)

Disadvantages and risks:

•  ERC-223 is a proposal right now, not a standard. Therefore, there are none of the high-profile ICO tokens deployed with this standard. Also, it is not yet implemented in any production   tokens that I found from my research.

•  Exchanges may need to do some modifications in order to support such token. There is a chance that some of the exchanges might not be prepared for it yet.

The benefits that this standard brings are not that high compared to risks of using unofficial token interface, which is not yet accepted by Ethereum foundation and is not a standard.

5.     ERC-190

The ERC190 standard proposes a specification for Ethereum smart contract packages.

Packaging is a core piece of modern software development which is missing from the Ethereum ecosystem. The lack of packaging limits the ability for developers to reuse code which negatively affects productivity and security.

I hope that it would be helpful for you to understand some basic knowledge of the popular token standards circulating within the Ethereum community.