Ship your first ERC-20 token
in ~60 minutes.

Install OpenZeppelin Contracts:

npm install @openzeppelin/contracts

Inside contracts/, create MyToken.sol:

// 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);
    }
}

This contract:

• Uses the battle-tested ERC20 implementation from OpenZeppelin
• Sets the name to MyToken and symbol to MTK
• Mints the whole initialSupply to the deployer address

Compile the project to make sure everything works:

npx hardhat compile

We’ll write two simple tests:

• Initial supply is minted to the deployer
• Transfers work and balances change as expected

Create test/MyToken.ts:

import { expect } from "chai";
import { ethers, loadFixture } from "hardhat";

describe("MyToken", function () {

  async function deployTokenFixture() {
    const [owner, user] = await ethers.getSigners();

    // 1,000,000 MTK with 18 decimals
    const initialSupply = 1_000_000n * 10n ** 18n;

    const Token = await ethers.getContractFactory("MyToken");
    const token = await Token.deploy(initialSupply);
    await token.waitForDeployment();

    return { token, owner, user, initialSupply };
  }

  it("mints initial supply to the deployer", async () => {
    const { token, owner, initialSupply } =
      await loadFixture(deployTokenFixture);

    expect(await token.totalSupply()).to.equal(initialSupply);
    expect(await token.balanceOf(owner.address)).to.equal(initialSupply);
  });

  it("transfers tokens between accounts", async () => {
    const { token, owner, user } =
      await loadFixture(deployTokenFixture);

    await expect(
      token.transfer(user.address, 1000n)
    ).to.changeTokenBalances(
      token,
      [owner, user],
      [-1000n, 1000n]
    );
  });

});

Run the tests:

npx hardhat test

You should see:

MyToken
  ✓ mints initial supply to the deployer
  ✓ transfers tokens between accounts

2 passing

function tokens(n: number) {
  return BigInt(n) * 10n ** 18n;
}

We’ll deploy first to the built-in Hardhat network, then to Sepolia.

1. Create a deploy script

In scripts/, create deploy-token.ts:

import { network } from "hardhat";

async function main() {
  const { ethers, networkName } = await network.connect();

  console.log(`Deploying MyToken to ${networkName}...`);

  const initialSupply = 1_000_000n * 10n ** 18n;

  const Token = await ethers.getContractFactory("MyToken");
  const token = await Token.deploy(initialSupply);
  await token.waitForDeployment();

  const address = await token.getAddress();
  console.log("MyToken deployed at:", address);
}

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

2. Deploy to the local Hardhat network

Simply run:

npx hardhat run scripts/deploy-token.ts

This uses the default simulated network from Hardhat and prints the address. Good for quick sanity checks.

3. Configure Sepolia network

Open hardhat.config.ts and add a basic Sepolia config. For a beginner-friendly version you can use environment variables via process.env:

import { config as loadEnv } from "dotenv";
import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox-ethers";

loadEnv();

const config: HardhatUserConfig = {
  solidity: {
    version: "0.8.20",
    settings: {
      optimizer: { enabled: true, runs: 200 },
    },
  },
  networks: {
    sepolia: {
      url: process.env.SEPOLIA_RPC_URL,
      accounts: process.env.DEPLOYER_PRIVATE_KEY
        ? [process.env.DEPLOYER_PRIVATE_KEY]
        : [],
    },
  },
};

export default config;

In your project root create a .env:

SEPOLIA_RPC_URL=<your-sepolia-rpc-url>
DEPLOYER_PRIVATE_KEY=<private-key-with-test-eth>

4. Deploy to Sepolia

Now run the same script, but specifying the network:

npx hardhat run scripts/deploy-token.ts --network sepolia

You’ll see logs and the deployed token address. Save this address — we’ll need it for Etherscan and for interacting with the token later.

Verifying your contract on Etherscan makes the source code publicly readable and enables the “Write / Read” tabs in the explorer.

1. Install Etherscan plugin (Toolbox)

If you started from Hardhat’s TypeScript template with toolbox, you likely already have it. If not:

npm install --save-dev @nomicfoundation/hardhat-toolbox-ethers

Make sure it’s imported in hardhat.config.ts:

import "@nomicfoundation/hardhat-toolbox-ethers";

2. Add Etherscan API key

Extend your .env:

ETHERSCAN_API_KEY=<your-etherscan-api-key>

And the config:

etherscan: {
  apiKey: process.env.ETHERSCAN_API_KEY,
}

3. Verify the token

Use the deployed address printed by your deploy script and run:

npx hardhat verify --network sepolia <deployed_address> 10000000000000000000000000

The last argument is the initialSupply you passed to the constructor (1,000,000 tokens with 18 decimals).