Writing your first smart contract — build an ERC-20 token with Hardhat

mkdir my-token && cd my-token
npm init -y
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox
npx hardhat init
# Select "Create a JavaScript project"

# Install OpenZeppelin contracts
npm install @openzeppelin/contracts

This gives you a complete development environment with compilation, testing, deployment, and verification tools.

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

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

contract MyToken is ERC20, Ownable {
    uint256 public constant MAX_SUPPLY = 1_000_000 * 10 ** 18;

    constructor()
        ERC20("MyToken", "MTK")
        Ownable(msg.sender)
    {
        // Mint half the supply to the deployer
        _mint(msg.sender, MAX_SUPPLY / 2);
    }

    /// @notice Owner can mint new tokens up to MAX_SUPPLY
    function mint(address to, uint256 amount) public onlyOwner {
        require(totalSupply() + amount <= MAX_SUPPLY, "Exceeds max supply");
        _mint(to, amount);
    }

    /// @notice Anyone can burn their own tokens
    function burn(uint256 amount) public {
        _burn(msg.sender, amount);
    }
}

OpenZeppelin's ERC20 base contract implements all 6 standard functions (totalSupply, balanceOf, transfer, allowance, approve, transferFrom) plus events. You inherit battle-tested, audited code.

const { expect } = require('chai');
const { ethers } = require('hardhat');

describe('MyToken', function () {
  let token, owner, addr1, addr2;

  beforeEach(async function () {
    [owner, addr1, addr2] = await ethers.getSigners();
    const MyToken = await ethers.getContractFactory('MyToken');
    token = await MyToken.deploy();
  });

  it('should set the correct name and symbol', async function () {
    expect(await token.name()).to.equal('MyToken');
    expect(await token.symbol()).to.equal('MTK');
  });

  it('should mint half supply to deployer', async function () {
    const balance = await token.balanceOf(owner.address);
    const maxSupply = await token.MAX_SUPPLY();
    expect(balance).to.equal(maxSupply / 2n);
  });

  it('should transfer tokens between accounts', async function () {
    const amount = ethers.parseEther('100');
    await token.transfer(addr1.address, amount);
    expect(await token.balanceOf(addr1.address)).to.equal(amount);
  });

  it('should not allow minting beyond max supply', async function () {
    const maxSupply = await token.MAX_SUPPLY();
    await expect(
      token.mint(addr1.address, maxSupply)
    ).to.be.revertedWith('Exceeds max supply');
  });

  it('should only allow owner to mint', async function () {
    await expect(
      token.connect(addr1).mint(addr1.address, 100n)
    ).to.be.reverted;
  });

  it('should allow burning own tokens', async function () {
    const amount = ethers.parseEther('100');
    await token.burn(amount);
    const balance = await token.balanceOf(owner.address);
    const expected = (await token.MAX_SUPPLY()) / 2n - amount;
    expect(balance).to.equal(expected);
  });
});

Run with npx hardhat test. All tests should pass.

// scripts/deploy.js
const hre = require('hardhat');

async function main() {
  const MyToken = await hre.ethers.getContractFactory('MyToken');
  const token = await MyToken.deploy();
  await token.waitForDeployment();

  const address = await token.getAddress();
  console.log('MyToken deployed to:', address);

  // Wait for a few confirmations before verifying
  console.log('Waiting for confirmations...');
  await token.deploymentTransaction().wait(5);

  // Verify on Etherscan
  await hre.run('verify:verify', {
    address: address,
    constructorArguments: [],
  });
  console.log('Contract verified on Etherscan');
}

main().catch(console.error);

# Configure Sepolia in hardhat.config.js, then:
npx hardhat run scripts/deploy.js --network sepolia

After deployment, your token is live on Sepolia. Anyone can see the verified source code on Etherscan, interact with it, and add it to their MetaMask wallet.