0x01: Write Your First Smart Contract Using Hardhat and Solidity (Step-by-Step)

Write Your First Smart Contract Using Hardhat : If you’re stepping into the world of blockchain development, welcome aboard! 🚀 It’s an exciting space. And one of the best ways to start your journey is by writing your very first smart contract using Solidity and Hardhat. In this tutorial, I’ll walk you through each step — from writing a simple smart contract to compiling it and understanding its artifacts.

By the end of this article, you’ll be confident enough to write, compile, and inspect your smart contracts like a true Ethereum developer. Let’s dive into it!

🧠 What is a Smart Contract?

Before we get into the code, here’s a quick breakdown.

A smart contract is a program that runs on the Ethereum blockchain. It’s self-executing, transparent, and can’t be tampered with once deployed. Solidity is the programming language used to write these contracts, and Hardhat is a developer tool that simplifies the process of building, testing, and deploying them.

🔧 Why Hardhat?

If you’re wondering why I’m choosing Hardhat over other tools like Truffle, here’s why:

• Easy to configure
• Excellent plugin ecosystem
• Smooth testing environment
• Fast compile and deployment scripts
• Works well with TypeScript, Ethers.js, and Solidity

🧱 Project Setup: Write Your First Smart Contract Using Hardhat and Solidity

Let’s Get Building!

Step 1: Make a New Project Directory

Open your terminal and create a new folder:

mkdir simple-smartcontract
cd simple-smartcontract

Step 2: Initialize Node.js Project

npm init -y

This will create a package.json file, which manages your project dependencies.

Step 3: Install Hardhat

Now, install Hardhat locally in your project:

npm install --save-dev hardhat

After installation, let’s create a new Hardhat project:

npx hardhat

You’ll get a prompt asking what you want to do. Select:
“Create a basic sample project” → Hit Enter → Type “yes” when asked to install dependencies.

Now you should have a folder structure like:

contracts/
scripts/
test/
hardhat.config.js

Congrats! 🎉 You just created your first Hardhat project.

📄 Writing Your First Solidity Smart Contract

Go to the contracts folder and create a new file called SimpleStorage.sol.

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

contract SimpleStorage {
    uint256 private data;

    function set(uint256 _data) public {
        data = _data;
    }

    function get() public view returns (uint256) {
        return data;
    }
}

Explanation:

• data: A private variable to store a number.
• set: Function to store a number.
• get: Function to retrieve the number.

This contract is intentionally simple to help you understand the building blocks.

🛠️ Compiling Smart Contracts with Hardhat

Now, let’s compile your contract.

In the root directory, run:

npx hardhat compile

If everything goes well, you’ll see something like:

Compiled 1 Solidity file successfully

After compilation, Hardhat creates a new folder called artifacts/.

📁 Understanding Hardhat Artifacts

Let’s talk about what just happened under the hood.

When Hardhat compiles your smart contract, it generates:

• ABI (Application Binary Interface): This defines how you can interact with your contract from the outside (like a frontend app).
• Bytecode: This is the machine-readable version of your contract — what gets deployed to the blockchain.

You’ll find these inside artifacts/contracts/SimpleStorage.sol/SimpleStorage.json.

Open that file, and you’ll see a long JSON object. Look for:

"abi": [ ... ],
"bytecode": "0x..."

These are the keys that tools like Ethers.js or Web3.js use to interact with the deployed contract.

💡 VS Code Tips for Solidity

If you’re using Visual Studio Code, I highly recommend the following extensions:

• Solidity by Juan Blanco – Syntax highlighting and compilation
• Hardhat Toolbox – Integration with Hardhat test and run environment
• Prettier Solidity Plugin – For consistent formatting

Also, use .sol file icons for better visibility by installing Material Icon Theme.

These small tweaks can drastically improve your development experience.

🔍 Testing It Live (Optional, But Recommended!)

Hardhat is great for local testing. Let’s create a quick script to test our smart contract.

Create a file scripts/test.js and add this:

const hre = require("hardhat");

async function main() {
  const Storage = await hre.ethers.getContractFactory("SimpleStorage");
  const storage = await Storage.deploy();

  await storage.deployed();
  console.log("Contract deployed to:", storage.address);

  const tx = await storage.set(123);
  await tx.wait();

  const value = await storage.get();
  console.log("Stored value is:", value.toString());
}

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

Run it:

npx hardhat run scripts/test.js

You should see output like:

Contract deployed to: 0x...
Stored value is: 123

🎉 Boom! Your contract is deployed locally and tested.

🔍 Summary: What You Learned

Let’s recap what we did in this chapter of our Solidity + Hardhat tutorial series:

✅ Set up a Node.js + Hardhat project
✅ Installed Hardhat and initialized a basic template
✅ Wrote your first smart contract (SimpleStorage.sol)
✅ Compiled it using npx hardhat compile
✅ Understood what ABI and bytecode are
✅ Ran a script to deploy and test your contract locally
✅ Boosted VS Code with Solidity extensions

🌱 Where to Go From Here?

You’ve just laid the foundation for your smart contract development journey. From here, you can:

• Add events to your contract
• Learn about testing using Mocha/Chai with Hardhat
• Explore deployment to testnets like Sepolia or Goerli
• Use frontend tools like Ethers.js or React to interact with your contract
• Learn contract security best practices (important!)

Each of these will be covered in upcoming chapters of this series. Stick around!

💬 Final Thoughts

Writing your first smart contract can feel like a big deal — and it is. But as you’ve seen today, Hardhat makes the process beginner-friendly and powerful. Whether you’re building a decentralized voting app or the next big DeFi project, understanding the basics is crucial.

Remember: Code small. Test early. Deploy smart.

Thanks for coding along! Let me know in the comments or tweet at me if you found this helpful. 🚀

✅ Frequently Asked Questions (FAQs)

📢 Spread the Word

If this tutorial helped you, share it with your dev friends or post it on Twitter, Reddit, or your tech groups. The more people learn about Solidity and Hardhat, the better the ecosystem becomes.

Written by: [Jeetendra Joshi]
A passionate blockchain developer, helping beginners enter Web3 the right way.