ERC-20, ERC-721, and other Smart Contract Standards Explained
Tags: ethereum, erc20, defi, web3
Published: 2021-09-17 11:31:27

> *I recently wrote on article on [my website](https://ciaran.co.za) covering the basics of Ethereum-based DeFi Applications for web Developers.*

> *This is a snippet on tokens which was the one of the key things I was attempting ti summarize well. If you enjoy this piece, please check out the full article on my website!*

---

## The Most Popular Ethereum Smart Contract Standards (ERC-20, ERC-721, ERC-777, ERC-1155) 

ERC (Ethereum Request for Comment) Token interface standards make smart contracts composeable. This means they will stay compatible despite changes to decentralized exchanges. Each standard defines a specific combination of 'rules' that a token must adhere to. There is a really great article [covering ERC-20 makeup interaction basics](https://ethereum.org/en/developers/tutorials/understand-the-erc-20-token-smart-contract/) - ERC-20 is the most common (and possibly simple) standard, and is best explored first.

Each smart contract has a set of mandatory functions - for example, an ERC-20 token has: `totalSupply`, `balanceOfWallet`, `transferFrom`, and more. We also use the smart contract to store functions for handling transactions and balances.

I want to cover a few of the basics of the tokens you will most commonly encounter. By no means are these comprehensive descriptions - they're simply a catch-up, to help you get comfortable with the terminology (and application), just enough so that you can start exploring interesting smart contracts that other people have written.

> The [Ethereum Improvements Proposals Website](https://eips.ethereum.org/) is the central location for platform, api and contract standard proposals. It's a cool place to look around once you've got some basic understanding of the more popular ERC standards.

### ERC-20

> [The Standard Fungible Token Interface](https://tokenmint.io/blog/mintable-erc20-token-explained.html) 

This is the most common, and what is considered the 'base standard'. Most ETH based tokens you'll encounter are ERC-20 Tokens. These can be used for purposes such as managing voting or currency systems - where fungiblity is important. An ERC-20 Token can also be used to create, as mentioned, a cryptocurrency on the Ethereum blockchain.  

A great place to start if you want to write ERC-20 contracts is this tutorial which covers [creating an ERC-20 token on Ropsten Test Net](https://www.quicknode.com/guides/solidity/how-to-create-and-deploy-an-erc20-token). I used this tutorial to create [`$lemToken`](https://ropsten.etherscan.io/token/0x422b16d7f90bd9d732fbe7c6cfddb50e0d38c606).

While the other tokens in this aticle have documentation pages linked in this article, if you're going to read just one of the standards I would recommend ERC-20. It's what most other smart contract standards are modelled after in one way or another - [**The ERC-20 Standard**](https://docs.openzeppelin.com/contracts/3.x/erc20)


### ERC-721

> [The Standard Non-Fungible Token Interface](https://medium.com/geekculture/mint-an-nft-and-erc-721-smart-contract-easy-step-by-step-4fafff151fbe) 

A `721` is non-fungible (ie. it has a no 1:1 value). I saw it referred to as a "deed" which made the most sense to me personally. While the standard has many feautures it shares with ERC-20, it's got a unique `tokenId` field - which adds its infamous functionality of being a uniquely identifiably token. 

There's some further discussion around how the "art itself" that you might mint as an NFT appears in the NFT itself as, essentially, a link to an off-chain copy of the resource - but this has some pretty practical reasons for it. 

Once you have a decent understanding of how ERC-20 works (and have perhaps tried to create your own), I'd highly recommend doing the [tutorial on minting a 10,000 piece unique art collection](https://medium.com/rarible-dao/how-to-mint-a-10-000-item-generative-art-nft-collection-with-21-lines-of-javascript-dfa603cc56d5). It glosses over the finer details of smart contracts, but is one of the best catch up articles on the NFT space that I've found. 

For a little extra research, it's important looking into [ipfs](https://ipfs.io/#why), which is a distributed web concept most often employed for storing the actual "asset" part of digial art on the blockchain. This is one of the core components of working with dApps - it's unavoidable at this point.

### ERC-777

> [Non-Standard Fungible Token](https://docs.openzeppelin.com/contracts/3.x/erc777) 

Triple-seven is a fungible token standard, which attempts to add functionality to what would otherwise be similar to an ERC-20. Essentially, it's for building tokens with complex functionality. I would recommend this [Jordi Baylina talk on ERC-777 from DappCon](https://www.youtube.com/watch?v=CVdZ09iqQj8) as an introduction (once you've read the docs, of course).

The key feature of ERC-777 is **receive hooks**, which is a type of function that can be called when tokens are sent to it. As a web developer, the general goal of React Hooks is a good comparison here - *hooks attempt to make it easier to control the flow of a complex set of actions*.

> By this point, you've probably realised that most popular smart contract technology is made up of not one, but rather a network of contracts. This is an important concept to grasp, in order to understand the boundaries of immuatability and malleability of the network.

### ERC-1155

- [An Attempt at a Fungibility-Agnostic Token](https://docs.openzeppelin.com/contracts/3.x/erc1155) 

ERC-1155 is a standard combining efforts of all the contracts we've explored so far, creating a way to write contracts that manage multiple token types. Within a single contract, we can work with fungible, non-fungible, and almost any other sort of token in between. It does all of this while attempting to be even more efficient and cheap to work with than other smart contract standards.

It has a massive difference in gas fees (which we'll get to next) compared to other token standards, and you'll most often see it used in applications like dApp Games. These sorts of applications have the most cause to use a cheap and malleable method of managing a complex internal token system.

ERC-1155 is sometimes referred to as the *lazy minting* standard - it's the cheapest, most functional and most approachable for newcomers. Whether or not the implications of the "lazy" label fit remains to be seen, however no such label should never discourage you from exploring.