How to Build an ERC20 Token Contract on Ethereum

·

Creating your own ERC20 token is a foundational skill for any blockchain developer. Whether you're building a decentralized application (dApp), launching a community currency, or experimenting with smart contracts, understanding how to implement an ERC20-compliant token is essential. In this guide, we’ll walk through the process of building a simple yet powerful ERC20 token using Solidity and OpenZeppelin—step by step.

The resulting token can be used in games, loyalty programs, or even as a prototype for a real-world cryptocurrency. We’ll call our example token Gold (GLD)—a fictional in-game currency that demonstrates core ERC20 functionality.

Understanding the Basics of ERC20 Tokens

ERC20 is a technical standard used for smart contracts on the Ethereum blockchain. It defines a common set of rules that all fungible tokens must follow, enabling seamless integration across wallets, exchanges, and dApps.

Key features of an ERC20 token include:

By adhering to this standard, your token becomes instantly compatible with the broader Ethereum ecosystem.

Building Your First ERC20 Token

Let’s create a basic ERC20 token called GLDToken using Solidity and OpenZeppelin's secure contract library.

// contracts/GLDToken.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

contract GLDToken is ERC20 {
    constructor(uint256 initialSupply) ERC20("Gold", "GLD") {
        _mint(msg.sender, initialSupply);
    }
}

What This Code Does:

Once deployed, the contract automatically assigns the total supply to the address that deployed it.

👉 Learn how to deploy your first token today with step-by-step tools and templates.

Querying Balances and Transferring Tokens

After deployment, you can interact with your token using standard ERC20 functions.

Check Balance

To check the balance of the deployer:

> GLDToken.balanceOf(deployerAddress)
1000000000000000000000

This returns the balance in wei-like units—the smallest denomination based on decimal precision.

Transfer Tokens

Send tokens to another address:

> GLDToken.transfer(otherAddress, 300000000000000000000)
> GLDToken.balanceOf(otherAddress)
300000000000000000000
> GLDToken.balanceOf(deployerAddress)
700000000000000000000

These operations are fully compliant with the ERC20 standard and can be executed via web3 libraries like Ethers.js or Web3.js.

The Role of Decimals in Token Design

One of the most misunderstood aspects of ERC20 tokens is the decimals field.

Why Decimals Matter

Solidity does not support floating-point numbers. You cannot send 1.5 GLD directly—you must use integers. To simulate fractional values, we scale everything up using decimals.

For example:

🔍 Important: The decimals value is only for display purposes. Internally, all calculations use whole numbers. Wallets and interfaces adjust the display by dividing the raw balance by 10 ** decimals.

Default Behavior

OpenZeppelin’s ERC20 contract defaults to 18 decimals, matching ETH and most major tokens like DAI and USDC.

function decimals() public view virtual override returns (uint8) {
    return 18;
}

You can override this if needed—for example, setting it to 6 for a stablecoin-like precision:

function decimals() public view virtual override returns (uint8) {
    return 6;
}

However, unless you have a strong reason (like compatibility with legacy systems), stick with 18 decimals.

Practical Example

To send 5 GLD with 18 decimals:

transfer(recipient, 5 * (10 ** 18));

Always remember: user-facing inputs should be converted before calling contract methods.

Using Preset Contracts: ERC20PresetMinterPauser

For faster development, OpenZeppelin provides ready-to-use presets like ERC20PresetMinterPauser.

This contract includes built-in roles for:

It also uses Access Control to manage permissions securely.

Benefits of Using Presets

Use this when you want a feature-rich token without writing custom logic.

👉 Explore secure smart contract templates used by top blockchain projects.

Core Keywords for SEO and Visibility

To ensure this content ranks well in search engines and meets user intent, here are the core keywords naturally integrated throughout:

These terms align with common developer searches and help improve discoverability while maintaining natural readability.

Frequently Asked Questions (FAQ)

Q: Can I change the total supply after deployment?

A: Yes—but only if your contract allows minting. If you use _mint() in a function accessible post-deployment (e.g., with a minter role), you can increase supply. However, reducing total supply isn't direct; tokens must be burned via _burn().

Q: Is it safe to use OpenZeppelin contracts?

A: Absolutely. OpenZeppelin provides thoroughly audited, battle-tested libraries used by thousands of production projects. Always import from official sources and verify versions.

Q: What happens if I set decimals to 0?

A: Your token becomes indivisible—like Bitcoin’s satoshis but without sub-units. You could only send whole numbers (1, 2, 3...). This is rare and typically only used for special NFT-like fungible tokens.

Q: Can I rename my token after deployment?

A: No. The name and symbol are hardcoded in the contract. Changing them requires redeploying a new contract, which breaks continuity and trust.

Q: How do wallets know my token’s decimal value?

A: Wallets call the decimals() function automatically when they detect an ERC20 token. They then format balances accordingly—so accurate decimals are crucial for correct display.

Q: Do I need to pay gas to transfer tokens?

A: Yes. Every transfer executes a state change on the Ethereum blockchain, which requires gas fees paid in ETH. Users must hold ETH to cover these costs.

Final Thoughts

Building an ERC20 token doesn’t have to be complex. With OpenZeppelin’s secure libraries and a clear understanding of core concepts like decimals and minting, anyone can create a functional, standards-compliant token in minutes.

Whether you're prototyping a game economy or laying the groundwork for a community-driven project, mastering ERC20 development opens doors to innovation on Ethereum.

👉 Start building and testing your own tokens with integrated developer tools and resources.