Lectures Publications Theses Events

ERC20

Solidity is a programming language for writing smart contracts. Solidity is the de facto standard language for Ethereum. Solidity is a statically typed language that is compiled to EVM opcodes that can be run on the Ethereum Virtual Machine (EVM).

In this exercise session, we will create a simple ERC20 cryptocurrency and deploy it on the Rinkeby testnet. If you do not have enough Ethers from the last exercise session, I can send you more.


Exercise 1:

Check Remix IDE/Metamask and make sure you have some test Ethers. If not, send me your address, so that I can send you 1 ETH.


We will implement a simplified ERC20 Token. There are tokens that only implement this simplified ERC20 token, for example the GNT token. For a simplified token, we need to implement the following interfaces:

 function totalSupply() external view returns (uint256);
 function balanceOf(address account) external view returns (uint256);
 function transfer(address recipient, uint256 amount) external returns (bool);
 event Transfer(address indexed from, address indexed to, uint256 value);

In order to implement the full ERC20 interface, you could implement those methods as well:

 function allowance(address owner, address spender) external view returns (uint256);
 function approve(address spender, uint256 amount) external returns (bool);
 function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
 event Approval(address indexed owner, address indexed spender, uint256 value);

Exercise 2: Implement the mapping of accounts to values. Also think about the minting. The minting process is the process, where you define how much tokens an address gets.

Implement the balanceOf function. This functions returns the balance from the mapping of accounts.


To prevent uint256 overflows, use SafeMath.sol from OpenZeppelin.


Exercise 3: Implement the transfer function, use SafeMath:

import "./SafeMath.sol";
...
contract X {
    using SafeMath for uint256;

Give your token a name, the number of decimal points (18), and implement the total supply function:

string public constant name = "Token Name";
string public constant symbol = "SYM";
uint8 public constant decimals = 18;  // 18 is the most common number of decimal places

Exercise 4: Implement the rest of the functionality of the simplified ERC20.


Since your contract is tested and running, you can deploy it on the Rinkeby testnet.


Exercise 5:

Deploy your contract and send me via MetaMask (0x0CbdF5B0c4E117619631bA4b97dC0d439ADAbD88) some tokens.


Solutions:

pragma solidity ^0.5.8;

import "./SafeMath.sol";

contract Blabla {
    using SafeMath for uint256;
    
    mapping (address => uint256) balances;
    
    uint256 total = 1000 * 10**2;
    
    string public constant name = "VSS Token";
    string public constant symbol = "Gugus";
    uint8 public constant decimals = 2;
    
    event Transfer(address indexed from, address indexed to, uint256 value);
    
    constructor() public {
        balances[msg.sender] = total;
    }
    
    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }
    
    function totalSupply() external view returns (uint256) {
        return total;
    }
    
    function transfer(address recipient, uint256 amount) external returns (bool) {
        require(balances[msg.sender] >= amount);
        balances[msg.sender] = balances[msg.sender].sub(amount);
        balances[recipient] = balances[recipient].add(amount);
        emit Transfer(msg.sender, recipient, amount);
        return true;
    }
}