Blockchain

ERC-20

• ERC-20 introduces a standard for fungible tokens: every unit of a token is exactly the same (in type and value) as every other unit. Just like ETH, 1 token is and will always be equal to any other 1 token of the same contract.
• ERC-20 (Ethereum Request for Comments 20) was proposed by Fabian Vogelsteller in November 2015 (published as EIP-20, co-authored with Vitalik Buterin). It is a token standard that defines an API for tokens implemented in smart contracts.
• Because all ERC-20 tokens share the same interface, any wallet, exchange or dApp that supports the standard can work with any ERC-20 token without custom code.
• Well-known ERC-20 tokens include stablecoins such as USDC and DAI, wrapped Ether (WETH) and many governance tokens.

Example functionalities ERC-20 provides

• Transfer tokens from one account to another.
• Get the current token balance of an account.
• Get the total supply of the token available on the network.
• Approve whether an amount of tokens from an account can be spent by a third-party account.

If a smart contract implements the following methods and events, it can be called an ERC-20 token contract. Once deployed, it is responsible for keeping track of the created tokens on Ethereum.

ERC-20 Methods and Events

Understanding decimals and approve/transferFrom

• Decimals: the EVM has no fractions, so balances are stored as whole numbers. With decimals = 18, a balance of 1,500,000,000,000,000,000 is displayed as 1.5 tokens.
• Two-step spending: to let a dApp (e.g. an exchange contract) take tokens, the owner first calls approve(exchange, amount); later the exchange calls transferFrom(owner, exchange, amount). This is how contracts “pull” tokens.
• Security tip: approve only the amount you need. Unlimited approvals to an untrusted or compromised contract can let it drain your tokens.
• Tokens sent directly to a contract that was not designed to handle them can be lost forever – ERC-20 has no built-in way for receiving contracts to reject transfers.

Minimal ERC-20 Implementation (for learning)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract MyToken {
    string public name = "My Token";
    string public symbol = "MYT";
    uint8  public decimals = 18;
    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    constructor(uint256 initialSupply) {
        totalSupply = initialSupply * 10 ** decimals;
        balanceOf[msg.sender] = totalSupply;
        emit Transfer(address(0), msg.sender, totalSupply);       // minting
    }

    function transfer(address to, uint256 value) external returns (bool) {
        require(balanceOf[msg.sender] >= value, "insufficient balance");
        balanceOf[msg.sender] -= value;
        balanceOf[to] += value;
        emit Transfer(msg.sender, to, value);
        return true;
    }

    function approve(address spender, uint256 value) external returns (bool) {
        allowance[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    function transferFrom(address from, address to, uint256 value) external returns (bool) {
        require(balanceOf[from] >= value, "insufficient balance");
        require(allowance[from][msg.sender] >= value, "allowance exceeded");
        allowance[from][msg.sender] -= value;
        balanceOf[from] -= value;
        balanceOf[to] += value;
        emit Transfer(from, to, value);
        return true;
    }
}

For production, use a well-audited library implementation rather than writing a token from scratch.

Key Takeaways

Question / Answer (15 questions)

MCQ Test : Check Your Understanding (5 questions)

Select an option and press Check Answer, or answer all questions and press Submit Test to see your score. Each answer comes with an explanation.

Bibliography/References

The notes, questions and MCQs on this page are original explanations written for this course. The works listed below were consulted and are cited for attribution and further reading. Product names, logos and trademarks belong to their respective owners. Short quotations, where used, are marked and attributed.

1. Vogelsteller, F., & Buterin, V. (2015). ERC-20: Token Standard. Ethereum Improvement Proposals, no. 20. https://eips.ethereum.org/EIPS/eip-20
2. ethereum.org. (n.d.). ERC-20 Token Standard. Ethereum Developer Documentation. https://ethereum.org/en/developers/docs/standards/tokens/erc-20/
3. Solidity Team. (n.d.). Solidity Documentation. https://docs.soliditylang.org/
4. Solidity Team. (n.d.). Security Considerations. Solidity Documentation. https://docs.soliditylang.org/en/latest/security-considerations.html
5. Antonopoulos, A. M., & Wood, G. (2018). Mastering Ethereum: Building Smart Contracts and DApps. O’Reilly Media.