A Guide to Creating and Deploying an ERC-20 Token Using Hardhat

This guide walks through the process of building, testing, and deploying a custom ERC-20 token on a local Ethereum blockchain network using Hardhat. It is intended for educational purposes to help developers understand smart contract development.

Prerequisites and Initial Setup

Before starting, ensure you have Node.js and npm installed on your system. These are essential for managing the project dependencies and running the development tools.

To begin, create a new directory for your project and initialize it as an npm package. This sets up the necessary structure for your Hardhat project.

npm init
npm install --save-dev hardhat

After installing Hardhat, run its initialization command to generate a basic project skeleton with sample contracts, scripts, and configuration files.

Understanding the Smart Contract Development

Solidity is the primary programming language for writing Ethereum smart contracts. It is a statically-typed language designed for developing contracts that run on the Ethereum Virtual Machine.

The project's contracts are stored in the contracts directory. Hardhat provides an example Greeter.sol file, but we will create a new token contract.

Create a file named Fool.sol in the contracts directory. This contract will implement a token named "Fool" with the symbol "FOOL".

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract Fool is ERC20, ERC20Burnable, Pausable, Ownable {
    constructor() ERC20("Fool", "FOOL") {
        _mint(msg.sender, 100000000 * 10 ** decimals());
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount)
        internal
        whenNotPaused
        override
    {
        super._beforeTokenTransfer(from, to, amount);
    }
}

Key Contract Components and Standards

The contract inherits from several OpenZeppelin contracts, which provide secure and audited implementations of common standards.

ERC-20 Standard: This is the most widely adopted standard for fungible tokens on Ethereum. It defines a common interface for tokens, including functions for transferring tokens, checking balances, and managing allowances. The standard ensures compatibility across various applications like wallets and exchanges.

ERC20Burnable Extension: This extension adds functionality for token holders to destroy their own tokens or tokens delegated to them. It provides methods to reduce the total token supply.

Pausable Functionality: This component allows the contract owner to halt all token transfers, minting, and burning. This is a critical safety feature for emergency situations or discovered vulnerabilities.

Ownable Access Control: This pattern restricts specific functions to the address that deployed the contract. It provides basic administrative controls to protect sensitive operations.

Compiling the Smart Contract

With the contract written, the next step is to compile it into bytecode that can run on the Ethereum Virtual Machine. Hardhat handles this process automatically.

Run the compile command in your project root directory:

npx hardhat compile

Hardhat reads the configuration from hardhat.config.js, processes all contracts in the contracts directory, and generates artifact files in the artifacts folder. These artifacts contain the bytecode and application binary interface (ABI) necessary for deployment and interaction.

Deploying to a Local Network

Deployment requires a running Ethereum network. Hardhat includes a built-in local network for development and testing purposes.

Starting the Local Network

Launch the local Hardhat network in a terminal:

npx hardhat node

This command starts a local Ethereum node and provides several test accounts with their private keys. These accounts are pre-funded with test Ether for development purposes.

Creating the Deployment Script

Create a deploy.js file in the scripts directory with the following code:

const hre = require("hardhat");

async function main() {
  const [owner] = await hre.ethers.getSigners();
  
  console.log(`Deploying contract from account:`, owner.address);
  console.log("Account balance:", (await owner.getBalance()).toString());
  console.log("Chain ID:", (await owner.getChainId()).toString());

  const Fool = await hre.ethers.getContractFactory("Fool");
  const fool = await Fool.deploy();
  
  await fool.deployed();
  
  console.log("Contract deployed to:", fool.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

Executing the Deployment

With the local network running, execute the deployment script in a separate terminal:

npx hardhat run --network localhost scripts/deploy.js

The script will output the deployment details including the contract address, which you'll need for interacting with the contract. The local network terminal will show the transaction details, including gas usage and block information.

Building a Testing Interface

To interact with your deployed token, create a simple React-based decentralized application (dApp). This interface will allow you to view token information and perform transfers.

Setting Up the React Application

Create a new React application in a web directory within your project:

npx create-react-app web --template typescript
cd web
npm install ethers antd

Create a .env file in the web directory with environment variables for the contract address and test accounts:

REACT_APP_CONTRACT_ADDRESS=your_contract_address_here
REACT_APP_DEPLOYER=deployer_account_address
REACT_APP_DEPLOYER_PRIVATE_KEY=deployer_private_key
REACT_APP_RECEIVER=receiver_account_address

Replace the placeholder values with the actual addresses from your deployment. Remember that these are test accounts and should never be used with real funds or on mainnet.

Implementing the Interface Logic

The main application component connects to the local Ethereum node, initializes the contract instance, and provides functions for querying token data and executing transfers.

Key functions include:

Fetching token details (name, symbol, decimals, total supply)
Checking account balances
Executing token transfers between accounts
Listening for transfer events

The interface displays these details in a user-friendly format and provides form controls for initiating transactions. Explore more strategies for building effective blockchain interfaces.

Testing Token Functionality

With both the local network and React interface running, you can test the token's functionality:

View the initial token supply allocated to the deployer account
Check the basic token information (name, symbol, decimals)
Initiate transfers to other accounts
Verify balance changes after transactions
Monitor transaction events in real-time

Each transaction will consume a small amount of test ETH as gas fees, which will be reflected in the account balances shown in the interface.

Frequently Asked Questions

What is Hardhat and why is it used for smart contract development?
Hardhat is a development environment that helps professionals build, test, and debug Ethereum applications. It provides essential tools for compiling contracts, running tests, and deploying to networks. The platform simplifies workflow automation and introduces advanced functionality throughout the development process.

How does the ERC-20 standard benefit token development?
The ERC-20 standard establishes a common set of rules for Ethereum tokens, ensuring compatibility across wallets, exchanges, and other applications. This standardization reduces development time and increases interoperability between different projects and platforms within the ecosystem.

What security considerations should I keep in mind when developing tokens?
Always use audited libraries like OpenZeppelin for fundamental contract components. Implement proper access controls, include emergency stop mechanisms, and thoroughly test all functionality. Remember that deployed contracts are immutable, so comprehensive testing is essential before mainnet deployment.

Can I deploy this same contract to public testnets or mainnet?
Yes, the same contract can be deployed to public networks by updating the Hardhat configuration with appropriate network settings and using accounts with real ETH for gas fees. Always test extensively on testnets before considering mainnet deployment.

What are the gas implications of the different functions in the token contract?
Functions that modify state (transfers, minting, burning) require gas, while view functions that only read data are free. Complex operations and storage updates cost more gas. The Pausable functionality adds minimal overhead but provides important emergency control.

How can I add additional functionality to my token contract?
You can extend the basic implementation by adding new functions or integrating additional OpenZeppelin extensions. Common enhancements include voting mechanisms, time-locked transactions, snapshot capabilities, or permissioned transfers. Always research the security implications of new features.

Important Considerations and Next Steps

Remember that each time you restart the local network, you need to redeploy your contract and update the contract address in your frontend environment variables. If you modify the contract code, you must recompile and copy the updated artifacts to your frontend application.

This example demonstrates the complete workflow for creating and testing a basic ERC-20 token. View real-time tools that can help streamline your development process further.

For deeper learning about blockchain technology, consider academic resources and documented implementations from established projects. The ecosystem offers extensive documentation and community support for developers expanding their knowledge.

Future enhancements could include creating non-fungible tokens (NFTs), implementing more complex contract logic, or integrating with decentralized finance protocols. The skills learned from this basic token implementation provide a foundation for more advanced blockchain development.