ERC-20 implementation in Blockchain / Solidity - Mini Project: Build & Apply

ERC-20 Token Implementation

📖 Scenario: You are creating a simple cryptocurrency token on the Ethereum blockchain. This token will follow the ERC-20 standard, which means it has specific rules for how tokens are transferred and tracked.Imagine you want to create your own digital coins that people can send to each other, check balances, and approve others to spend on their behalf.

🎯 Goal: Build a basic ERC-20 token contract in Solidity that allows users to check balances, transfer tokens, and approve others to spend tokens for them.

📋 What You'll Learn

Create a contract named SimpleToken

Define state variables for name, symbol, decimals, and totalSupply

Create a mapping called balances to track token balances

Create a mapping called allowances to track approved spending

Implement balanceOf, transfer, approve, and transferFrom functions

Emit Transfer and Approval events appropriately

💡 Why This Matters

🌍 Real World

ERC-20 tokens are the most common standard for creating cryptocurrencies and digital assets on Ethereum and compatible blockchains. They enable easy token transfers and integration with wallets and exchanges.

💼 Career

Understanding ERC-20 token implementation is essential for blockchain developers working on decentralized finance (DeFi), NFT projects, and custom token creation.

1

Set up the contract and state variables

Create a Solidity contract named SimpleToken. Inside it, declare public state variables string name set to "SimpleToken", string symbol set to "STK", uint8 decimals set to 18, and uint256 totalSupply set to 1000000 * 10 ** 18. Also, create a mapping(address => uint256) balances to hold token balances.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract SimpleToken {
    // Your code here
}

Need a hint?

Start by declaring the contract and the variables exactly as described. Use public to allow reading these variables from outside.

2

Initialize balances and add allowances mapping

Add a constructor to the SimpleToken contract that assigns the entire totalSupply to the contract deployer's address using msg.sender. Also, declare a mapping(address => mapping(address => uint256)) allowances to track approved spending.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract SimpleToken {
    string public name = "SimpleToken";
    string public symbol = "STK";
    uint8 public decimals = 18;
    uint256 public totalSupply = 1000000 * 10 ** 18;

    mapping(address => uint256) public balances;
    
    // Your code here
}

Need a hint?

Use a constructor function to set the initial balance. Declare the nested mapping for allowances exactly as shown.

3

Implement transfer, approve, and transferFrom functions

Inside SimpleToken, implement three functions: transfer, approve, and transferFrom. transfer should move tokens from msg.sender to a recipient if the sender has enough balance. approve should allow a spender to spend a specified amount from the caller's balance. transferFrom should allow a spender to transfer tokens from an owner's balance if approved. Use require to check balances and allowances. Update balances and allowances accordingly.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract SimpleToken {
    string public name = "SimpleToken";
    string public symbol = "STK";
    uint8 public decimals = 18;
    uint256 public totalSupply = 1000000 * 10 ** 18;

    mapping(address => uint256) public balances;
    mapping(address => mapping(address => uint256)) public allowances;

    constructor() {
        balances[msg.sender] = totalSupply;
    }

    // Your code here
}

Need a hint?

Use require to check conditions. Update balances and allowances carefully. Don't forget to emit events after changes.

4

Add balanceOf function and test output

Add a public view function balanceOf that takes an address account and returns the token balance of that account from balances. Then, write a simple test line to print the balance of the contract deployer (msg.sender) using balanceOf(msg.sender). Since Solidity contracts do not print, simulate this by returning the balance in a public function called testBalance.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract SimpleToken {
    string public name = "SimpleToken";
    string public symbol = "STK";
    uint8 public decimals = 18;
    uint256 public totalSupply = 1000000 * 10 ** 18;

    mapping(address => uint256) public balances;
    mapping(address => mapping(address => uint256)) public allowances;

    constructor() {
        balances[msg.sender] = totalSupply;
    }

    function transfer(address to, uint256 amount) public returns (bool) {
        require(balances[msg.sender] >= amount, "Not enough balance");
        balances[msg.sender] -= amount;
        balances[to] += amount;
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    function approve(address spender, uint256 amount) public returns (bool) {
        allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) public returns (bool) {
        require(balances[from] >= amount, "Not enough balance");
        require(allowances[from][msg.sender] >= amount, "Allowance exceeded");
        balances[from] -= amount;
        balances[to] += amount;
        allowances[from][msg.sender] -= amount;
        emit Transfer(from, to, amount);
        return true;
    }

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

    // Your code here
}

Need a hint?

The balanceOf function returns the balance for any address. The testBalance function returns the deployer's balance to simulate output.