How to Create an ERC-20 Token Using Solidity

Roshan Raj Bhagat — Sat, 31 Oct 2026 09:25:52 +0000

Blockchain technology has changed how digital assets are created, transferred, and managed. Ethereum is one of the most widely used blockchain networks for developing digital tokens, decentralized applications (dApps), and smart contracts. Among its token standards, ERC-20 is commonly used to create fungible tokens for different business and blockchain applications.

If you are planning to launch a cryptocurrency, build a decentralized finance (DeFi) application, or introduce a utility token, understanding ERC-20 token development is a useful starting point.
In this tutorial, we will explain how to create an ERC-20 token using Solidity and OpenZeppelin. You will learn about the development requirements, smart contract structure, essential functions, and deployment process through practical code examples.

What Is an ERC-20 Token?

ERC-20 is a technical standard used to create fungible tokens on the Ethereum blockchain. It defines a common set of rules that tokens must follow to interact with compatible wallets, exchanges, and decentralized applications.

Fungible means that each token has the same value and properties as another token of the same type. For example, one unit of an ERC-20 token is interchangeable with another unit of that token.

ERC-20 tokens are commonly used for:

Utility tokens within blockchain applications.
Governance tokens for decentralized organizations.
DeFi applications and lending platforms.
Reward and loyalty programs.
Digital asset fundraising.

The standard includes functions such as transfer(), approve(), allowance(), and transferFrom(), which help applications manage token transactions.

Requirements for ERC-20 Token Development

Before writing the smart contract, prepare the development environment.
You will need:

1. - Solidity: A programming language used to write Ethereum smart contracts.

2. - OpenZeppelin Contracts: A library containing reusable and widely reviewed smart contract implementations.

3. - Remix IDE: A browser-based development environment for writing, compiling, and deploying Solidity contracts.

4. - MetaMask: A browser wallet used to connect to Ethereum-compatible networks.

5. - Ethereum Testnet: A testing network such as Sepolia for experimenting with smart contract deployment without spending real ETH.

You should also have a basic understanding of Solidity syntax, blockchain transactions, and Ethereum gas fees.

Step 1: Create an ERC-20 Smart Contract
Start by opening Remix IDE and creating a new Solidity file named

MyToken.sol.

For this example, we will use OpenZeppelin's ERC-20 implementation instead of writing token functionality from scratch.

Install the OpenZeppelin Contracts package in your project if you are using a local development environment:
npm install @openzeppelin/contracts

Now, write the following smart contract:

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {

constructor(uint256 initialSupply)
    ERC20("MyToken", "MTK")
{
    _mint(
        msg.sender,
        initialSupply * 10 ** decimals()
    );
}

This contract creates a basic ERC-20 token named MyToken with the symbol MTK.

Let's understand the important parts of this code.

1. Solidity Version

pragma solidity ^0.8.20;
This specifies the compatible Solidity compiler versions. The compiler must be version 0.8.20 or later within the specified compatible range.

2. OpenZeppelin Import

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
This imports the ERC-20 implementation from OpenZeppelin. It provides standard token functionality, including transfers, approvals, balances, and allowances.

3. Token Name and Symbol

ERC20("MyToken", "MTK")
This defines the token name as MyToken and its symbol as MTK.

4. Initial Token Supply

_mint( msg.sender, initialSupply * 10 ** decimals() );

The _mint() function creates the initial token supply and assigns it to the wallet deploying the contract.

ERC-20 uses 18 decimals by default in this implementation. Therefore, entering 1000000 as the initial supply creates one million whole tokens, represented internally in their smallest units.

Step 2: Compile the Smart Contract

After writing the contract, open the Solidity Compiler section in Remix IDE.

Follow these steps:

Select a compatible Solidity compiler version, such as 0.8.20.
Open the MyToken.sol file.
Click the Compile button.
Check for compiler errors or warnings.
Review the compiled contract details.

If compilation succeeds, Remix will generate the contract artifacts required for deployment.

Step 3: Deploy the ERC-20 Token

Once the contract is compiled, you can deploy it using Remix.

For testing, select the Remix JavaScript VM environment. This allows you to deploy the contract without connecting an external wallet.

For a public testnet deployment:

Connect MetaMask to the Sepolia testnet.
Select the Injected Provider environment in Remix.
Choose the MyToken contract.
Enter the initial supply, such as 1000000.
Click Deploy.
Confirm the transaction in MetaMask.

After the transaction is confirmed, Remix will display the deployed contract address.

Keep this address because it identifies your token contract on the blockchain.

Important: A successful testnet deployment does not mean the contract is ready for production. Review the contract, test its functions, and complete an appropriate security assessment before mainnet deployment.

Step 4: Test ERC-20 Token Functions

ERC-20 provides several standard functions that applications can use to interact with tokens.

Here are some important examples:

Check Token Balance

function checkBalance(address account) public view returns (uint256) { return balanceOf(account); }

This function returns the token balance of a specified wallet address.

Transfer Tokens

The standard ERC-20 implementation already includes this function:
transfer(address recipient, uint256 amount)

It allows a token holder to transfer tokens to another wallet.

Approve Token Spending

approve(address spender, uint256 amount) This allows a token holder to authorize another address to spend a specified amount of tokens on their behalf. Transfer Approved Tokens transferFrom( address sender, address recipient, uint256 amount )
This function allows an approved spender to transfer tokens from another wallet within the approved allowance.

These functions make ERC-20 tokens compatible with many Ethereum-based applications, including wallets, exchanges, and DeFi protocols.

Step 5: Verify and Test the Contract

Before deploying an ERC-20 token to Ethereum mainnet, perform functional and security testing.

Important checks include:

Verify the token name, symbol, and total supply.
Test transfers between different wallet addresses.
Check balance updates after transactions.
Test approval and allowance functionality.
Confirm that unauthorized accounts cannot transfer another user's tokens.
Review contract dependencies and compiler settings.
Check for unexpected behavior and integration issues.

You can also use automated testing frameworks such as Hardhat or Foundry to test contract functions and transaction scenarios.

After deployment, you can verify the contract source code on Etherscan. Verification helps other users inspect the published contract source and compare it with the deployed bytecode.

Security Considerations for ERC-20 Token Development

Creating a token contract is only one part of a blockchain project. Security should be considered throughout development.

Here are some important considerations:

Use Established Libraries: OpenZeppelin provides established implementations of common token standards. Using these implementations can reduce the need to write frequently used token logic from scratch.

**Test Before Mainnet Deployment: **Deploy the contract to a testnet and test different transaction scenarios before using real assets.

Review Token Permissions: Carefully examine minting, burning, pausing, ownership, and spending permissions if your token includes these features.

Avoid Unnecessary Functions: Every additional feature can introduce more code and potential security risks. Include only functions required by the project's purpose.

Arrange a Smart Contract Audit: An independent security review can help identify vulnerabilities, access-control problems, and implementation mistakes.

Conclusion

Creating an ERC-20 token using Solidity is a practical way to understand Ethereum-based token development. With OpenZeppelin, developers can implement standard token functionality without manually writing every ERC-20 function.

However, a production-ready token requires more than a working smart contract. Tokenomics, access permissions, testing, security reviews, wallet compatibility, and deployment planning also need attention.
Businesses planning to launch utility tokens, governance tokens, or other Ethereum-based digital assets should evaluate their technical requirements before development begins.

If your business is planning an Ethereum-based token project, Comfygen Technologies provides ERC-20 token development services, including smart contract development and token implementation. Exploring the right development approach can help you prepare your project requirements and move toward a well-tested blockchain solution.

DEV Community: Roshan Raj Bhagat

How to Create an ERC-20 Token Using Solidity

What Is an ERC-20 Token?

Requirements for ERC-20 Token Development

Security Considerations for ERC-20 Token Development

Conclusion