How to Create and Use ERC20 Tokens on Ethereum

The Ethereum blockchain has revolutionized digital assets by enabling developers to create customizable, interoperable tokens through standardized protocols. Among these, the ERC20 token standard stands as one of the most widely adopted frameworks for launching fungible tokens—used for everything from decentralized finance (DeFi) to governance and rewards systems.

In this comprehensive guide, you'll learn what ERC20 tokens are, how they work under the hood, and how to implement them securely using best practices. We’ll walk through core functions, real-world code examples, and even build a simple token swap mechanism—perfect for developers or enthusiasts diving into blockchain development.

Whether you're planning to issue your own token or integrate existing ones into a dApp, this article delivers practical insights with SEO-optimized clarity.

👉 Discover how to deploy your first ERC20 token in minutes with trusted tools

What Is an ERC20 Token?

An ERC20 token is any smart contract on the Ethereum network that adheres to the ERC20 technical standard. This standard defines a set of rules and functions that ensure compatibility across wallets, exchanges, and decentralized applications.

By following the EIP-20 specification, developers guarantee their tokens can be easily integrated into the broader Ethereum ecosystem. Popular projects like USDT, UNI, and LINK all use the ERC20 standard.

Core Features of ERC20 Tokens

ERC20-compliant contracts must implement six essential functions and two events:

• totalSupply() – Returns the total number of tokens in circulation.
• balanceOf(address) – Checks the token balance of a specific wallet.
• transfer(address, uint) – Allows users to send tokens directly.
• allowance(owner, spender) – Queries how many tokens one address can spend on behalf of another.
• approve(address, uint) – Grants permission for another address to spend tokens.
• transferFrom(address, address, uint) – Enables pre-approved transfers (used in DeFi protocols).

Events:

• Transfer(from, to, value) – Logs every token movement.
• Approval(owner, spender, value) – Records approval actions.

These interfaces form the foundation of trustless interactions in decentralized environments.

Building an ERC20 Token: Step-by-Step Code Walkthrough

Let’s explore a minimal yet functional ERC20 implementation written in Solidity.

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

interface IERC20 {
    function totalSupply() external view returns (uint);
    function balanceOf(address account) external view returns (uint);
    function transfer(address recipient, uint amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint);
    function approve(address spender, uint amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint amount) external returns (bool);

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

This interface outlines all required methods. Now let’s see a full contract that implements it:

contract ERC20 is IERC20 {
    uint public totalSupply;
    mapping(address => uint) public balanceOf;
    mapping(address => mapping(address => uint)) public allowance;

    string public name = "Solidity ERC20 Test";
    string public symbol = "SET";
    uint8 public decimals = 18;

    function transfer(address recipient, uint amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[recipient] += amount;
        emit Transfer(msg.sender, recipient, amount);
        return true;
    }

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

    function transferFrom(address sender, address recipient, uint amount) external returns (bool) {
        allowance[sender][msg.sender] -= amount;
        balanceOf[sender] -= amount;
        balanceOf[recipient] += amount;
        emit Transfer(sender, recipient, amount);
        return true;
    }

    function mint(uint amount) external {
        balanceOf[msg.sender] += amount;
        totalSupply += amount;
        emit Transfer(address(0), msg.sender, amount);
    }

    function burn(uint amount) external {
        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;
        emit Transfer(msg.sender, address(0), amount);
    }
}

This basic version includes optional mint() and burn() functions for creating and destroying tokens—useful during initial distribution or buyback programs.

Why Use OpenZeppelin for Token Creation?

While writing raw Solidity gives you control, security risks increase without rigorous auditing. That's why most developers rely on OpenZeppelin Contracts, a battle-tested library for secure smart contract development.

Here’s how to create a production-ready ERC20 token using OpenZeppelin:

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

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.0.0/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
    constructor(string memory name, string memory symbol) ERC20(name, symbol) {
        _mint(msg.sender, 100 * 10**uint(decimals()));
    }
}

With just a few lines, you inherit secure implementations of all ERC20 functions. The _mint() call issues 100 tokens (accounting for 18 decimal places), assigned to the deployer.

👉 Learn how top projects launch secure tokens using industry-standard tools

Implementing Token Swaps Between ERC20 Contracts

One powerful use case is enabling direct peer-to-peer exchange of different ERC20 tokens without intermediaries.

Below is a simplified TokenSwap contract allowing two parties to trade predefined amounts:

pragma solidity ^0.8.13;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.0.0/contracts/token/ERC20/IERC20.sol";

contract TokenSwap {
    IERC20 public token1;
    address public owner1;
    uint public amount1;

    IERC20 public token2;
    address public owner2;
    uint public amount2;

    constructor(
        address _token1,
        address _owner1,
        uint _amount1,
        address _token2,
        address _owner2,
        uint _amount2
    ) {
        token1 = IERC20(_token1);
        owner1 = _owner1;
        amount1 = _amount1;
        token2 = IERC20(_token2);
        owner2 = _owner2;
        amount2 = _amount2;
    }

    function swap() public {
        require(msg.sender == owner1 || msg.sender == owner2, "Not authorized");
        require(token1.allowance(owner1, address(this)) >= amount1, "Token 1 allowance too low");
        require(token2.allowance(owner2, address(this)) >= amount2, "Token 2 allowance too low");

        _safeTransferFrom(token1, owner1, owner2, amount1);
        _safeTransferFrom(token2, owner2, owner1, amount2);
    }

    function _safeTransferFrom(
        IERC20 token,
        address sender,
        address recipient,
        uint amount
    ) private {
        bool sent = token.transferFrom(sender, recipient, amount);
        require(sent, "Token transfer failed");
    }
}

How It Works

Imagine Alice wants to trade 10 AliceCoin for 20 BobCoin with Bob:

1. Both approve the TokenSwap contract to spend their respective tokens.
2. Either party calls swap().
3. The contract verifies allowances and executes atomic transfers.
4. Both receive their new tokens instantly.

This pattern mirrors early decentralized exchange logic—simple, trustless, and transparent.

Frequently Asked Questions (FAQ)

What is the difference between ERC20 and other token standards?

ERC20 is designed for fungible tokens, where each unit is identical and interchangeable. In contrast, ERC721 handles non-fungible tokens (NFTs), where each token is unique.

Can I change the total supply after deployment?

Only if your contract includes a mint() or burn() function. Once deployed, logic cannot be altered—so plan supply mechanics carefully before launch.

Are all ERC20 tokens compatible with wallets?

Yes—any wallet supporting the ERC20 standard can display and manage compliant tokens. However, some may require manual addition via contract address.

Do I need to pay gas fees to transfer ERC20 tokens?

Yes. Every transaction on Ethereum requires gas, paid in ETH. Users bear these costs when transferring or approving tokens.

How do I verify my token contract on Etherscan?

After deployment, compile your code using the same settings and submit it via Etherscan’s Verify and Publish tool. This increases transparency and user trust.

Can someone else mint my token?

Only if your contract allows it—and only through defined functions like mint(). Lock down access using access control patterns (e.g., onlyOwner) to prevent unauthorized issuance.

Creating an ERC20 token opens doors to innovation in DeFi, gaming, loyalty programs, and more. By leveraging secure libraries like OpenZeppelin and understanding core mechanics like approvals and transfers, you can build reliable and scalable token solutions.

As blockchain adoption grows, mastering token standards becomes increasingly valuable—whether you're launching a project or integrating with existing ecosystems.

👉 Start exploring ERC20 development with powerful crypto tools today