Getting Started with Hardhat for Smart Contracts
Tags: node, ethereum, solidity, hardhat
Published: 2023-06-04 08:54:05

---
title: Getting Started with Hardhat for Smart Contracts
published: true
tags: node, ethereum, solidity, hardhat
---

In the world of Ethereum development, one tool stands out for its robustness and versatility: [Hardhat](https://hardhat.org/). This tool is designed to help developers manage, test, and deploy smart contracts on Ethereum with ease. In this post, we'll dive into what Hardhat is, how it works, and how it uses RPC. Moreover, we'll walk you through the steps of compiling and interacting with smart contracts using Hardhat (on a test environment).

## What is Hardhat?
Hardhat is a development environment and task runner for Ethereum that helps developers build and interact with smart contracts. It is designed to provide developers with a seamless experience in writing, testing, and deploying smart contracts. It comes with built-in TypeScript support, debugging, and networking capabilities, making it a one-stop-shop for Ethereum development.

## How it Works?
Hardhat works by setting up a local Ethereum network on your machine for development purposes. This local network, called Hardhat Network, allows you to execute and test your smart contracts in a controlled environment. It provides detailed error messages and console.log functionality, which makes debugging a breeze.

## Hardhat and RPC
The Hardhat Network communicates with your Ethereum node via an API called JSON-RPC (Remote Procedure Call). RPC allows a client to interact with a remote server. In the case of Hardhat, it connects to the Ethereum node (either a local one or a remote one) and sends requests to interact with the blockchain, like deploying a smart contract or querying a transaction. Hardhat uses the Ethereum JSON-RPC API, which is a set of methods used to interact with the Ethereum network.

## Compiling and Interacting with Smart Contracts
Lets walk through an example of compiling and interacting with a smart contract using Hardhat.

### Step 1: Install Hardhat
First, you need to install Hardhat. Make sure you have Node.js installed, then run the following command in your terminal:

```bash
npm install --save-dev hardhat
```

### Step 2: Create a New Hardhat Project
Next, create a new Hardhat project by running the following command:

```bash
npx hardhat
```

Choose "Create an empty hardhat.config.js" when prompted. This will create a new directory with the necessary configuration file (hardhat.config.js) in the root folder.

### Step 3: Write The Smart Contract
Create a new file in the contracts directory (/contracts), say HelloWorld.sol, and add the following Solidity code:

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.3;

contract HelloWorld {
    function sayHello() public pure returns (string memory) {
        return "Hello, Hardhat!";
    }
}
```

### Step 4: Compile The Smart Contract
Compile the smart contract by running the following command:

```bash
npx hardhat compile
```

### Step 5: Write a Test
Create a new file in the test directory (/test), say HelloWorld.test.js, and add the following JS code:

```javascript
const { expect } = require("chai");

describe("HelloWorld contract", function () {
  it("Should return the right greeting", async function () {
    const HelloWorld = await ethers.getContractFactory("HelloWorld");
    const helloWorld = await HelloWorld.deploy();
    await helloWorld.deployed();
    
    expect(await helloWorld.sayHello()).to.equal("Hello, Hardhat!");
  });
});
```

#### Let's break it down:

```javascript
const { expect } = require("chai");
```
This line imports the expect function from the chai library, which is a popular JavaScript testing library. expect is used to make assertions about your code.

```javascript
const HelloWorld = await ethers.getContractFactory("HelloWorld");
```

This line creates a contract factory for the HelloWorld contract. A contract factory is an object that can be used to deploy new instances of a contract.

```javascript
const helloWorld = await HelloWorld.deploy();
```

This line deploys an instance of the HelloWorld contract.

```javascript
await helloWorld.deployed();
```

This line waits for the contract to be deployed. Contract deployment is an asynchronous operation that involves a transaction being mined on the Ethereum network.

```javascript
expect(await helloWorld.sayHello()).to.equal("Hello, Hardhat!");
```

This line calls the sayHello function of the HelloWorld contract and checks that it returns the string "Hello, Hardhat!". 

### Step 6: Run The Test
Run the test by executing the following command:

```bash
npx hardhat test
```

If everything is set up correctly, you should see a message saying your test passed.

That's it! You have just written, compiled, deployed (to a test network) and tested a smart contract with Hardhat.

## Summary

Hardhat is a development environment to compile, deploy, test, and debug your Ethereum software. It helps developers manage and automate the recurring tasks involved in building smart contracts and performing complex deployments. 🚀