Chapter 1: Introduction to Hardhat

This chapter introduces Hardhat, a development surroundings for Ethereum software. We’ll discover what Hardhat is, why you may select it over Truffle, and a way to set up a fundamental Hardhat mission.

What is Hardhat?

Hardhat is a improvement surroundings mainly designed for building Ethereum clever contracts and decentralized applications (dApps). It facilitates builders manipulate and streamline the complete development lifecycle, from writing and compiling Solidity code to trying out, deploying, and interacting with contracts. Hardhat emphasizes developer enjoy and aims to make constructing on Ethereum as green and fun as viable. It’s incredibly extensible, permitting you to customise it with plugins to suit your precise wishes.

Key features of Hardhat include:

• Local Ethereum Network: Hardhat comes with its personal built-in Ethereum network (Hardhat Network) that runs domestically to your system. This allows for immediate and isolated trying out without having to have interaction with stay testnets or mainnet.This speeds up development considerably.
• Console.log Debugging: You can use console.log statements within your Solidity smart contracts for debugging purposes. Hardhat makes these logs visible in your terminal during testing, making it easier to understand the execution flow.⁶
• Easy Contract Interaction: Hardhat provides tools to easily interact with deployed contracts, making it simple to send transactions, call functions, and inspect contract state.⁷
• Plugin Ecosystem: Hardhat’s functionality can be extended through a rich ecosystem of plugins.⁸ These plugins provide integrations with various equipment and offerings, such as Ethers.Js, Waffle, and Tenderly.
• Task Runner: Hardhat uses a venture runner device, allowing you to outline and execute not unusual development obligations (e.G., compiling, testing, deploying) with simple commands.
• TypeScript Support: Hardhat is written in TypeScript and presents outstanding TypeScript assist, improving code quality and maintainability.

Why use Hardhat over Truffle?

Both Hardhat and Truffle are famous improvement frameworks for Ethereum, however they’ve distinct strengths. While Truffle has been a long-standing and reliable device, Hardhat offers some compelling blessings:

• Improved Developer Experience: Hardhat is generally considered to have a more modern and user-friendly interface. Its focus on clear error messages and intuitive task management can make development smoother.¹²
• Faster Testing: Hardhat’s local network and the ability to use console.log for debugging often lead to faster testing cycles compared to Truffle.
• Extensibility: Hardhat’s plugin system is very flexible and allows for deep customization.¹³ While Truffle has a system for “boxes,” Hardhat’s plugin architecture is more streamlined.
• TypeScript Support: For projects that benefit from static typing, Hardhat’s first-class TypeScript support is a significant advantage.¹⁴ Truffle’s TypeScript integration is less mature.
• Network Management: While both offer network management, Hardhat’s configuration and switching between networks can be more straightforward.

It’s important to note that both frameworks are capable of building complex dApps. The best choice depends on individual preferences and project requirements. Many developers appreciate Hardhat’s focus on speed, developer experience, and modern tooling.

Setting up a Hardhat project

Here’s how to set up a basic Hardhat project:

1. Create a Project Directory:

Bash

mkdir my-hardhat-project
cd my-hardhat-project

2. Initialize a Node.js Project:

Bash

npm init -y  # or yarn init -y

This creates a package.json file in your project directory.

3. Install Hardhat:

Bash

npm install --save-dev hardhat  # or yarn add -D hardhat

4. Initialize Hardhat:

Bash

npx hardhat  # or yarn hardhat

This will present you with some options. Choose “Create a basic sample hardhat project”. This will set up a basic project structure with sample contracts, tests, and a configuration file (hardhat.config.js or hardhat.config.ts if you choose typescript).

Installing dependencies (npm, yarn)

We’ve already installed Hardhat using npm or yarn. Here’s a quick recap and some additional important dependencies you’ll likely need:

Hardhat: The core Hardhat package.

npm install --save-dev hardhat or yarn add -D hardhat

Ethers.js: A famous library for interacting with the Ethereum blockchain and smart contracts.

npm install --save-dev @ethersproject/ethers or yarn add -D @ethersproject/ethers

Waffle: A trying out library often used with Hardhat

 npm install --save-dev chai @ethereumjs/vm @nomicfoundation/hardhat-chai-matchers or yarn add -D chai @ethereumjs/vm @nomicfoundation/hardhat-chai-matchers

(Note: Older tutorials may use @openzeppelin/test-helpers, but Waffle is extra updated with Hardhat).

You can install other plugins and libraries as needed throughout your project development. Remember to apply the `--save-dev` flag (or -D) to store these dependencies as improvement dependencies in your `package.json ` file. This indicates that they may be only wanted throughout development and no longer in manufacturing.

FAQ: Introduction to Hardhat

This FAQ addresses common questions related to the introduction of Hardhat.

Q: What is the difference between Hardhat Network and a testnet like Goerli or Sepolia?

A: Hardhat Network is a local, in-memory Ethereum network that runs directly on your development machine. It’s designed for fast and isolated testing. Changes you make on Hardhat Network don’t affect any other networks. Testnets like Goerli or Sepolia are public, shared networks. Deploying to a testnet allows you to interact with your contracts in a more realistic environment, but it’s slower than using Hardhat Network and requires test ETH.

Q: Why do I need Ethers.js or Waffle if Hardhat has its own network?

A: Hardhat provides the environment (the network, task runner, etc.), but Ethers.js and Waffle are libraries that help you interact with that environment. Ethers.js is used for things like connecting to the network, deploying contracts, sending transactions, and interacting with contract functions. Waffle (or similar testing libraries) provides helpful tools for writing unit tests for your smart contracts. They make testing much easier.

Q: Can I use Truffle with Hardhat?

A: While you can’t directly use Truffle projects with Hardhat without some migration effort, you can use some of the same libraries. For example, if you’re comfortable with a testing library that works with Truffle, it might have a Hardhat-compatible version or equivalent. However, Hardhat is designed to be a complete development surroundings on its very own. It’s commonly recommended to stay with Hardhat’s environment of tools, which include Ethers.Js and Waffle, for a smoother enjoy.

Q: I’m getting an error when trying to install a dependency. What should I do?

A: Dependency installation issues can be tricky. Here are some common troubleshooting steps:

• Check your Node.js and npm/yarn versions: Make sure you have compatible versions. Outdated versions can cause problems. Use node -v and npm -v (or yarn -v) to check.
• Clear your package manager cache: Try npm cache clean --force (or yarn cache clean).
• Delete node_modules and package-lock.json (or yarn.lock): Sometimes these files can become corrupted. Delete them and then run npm install (or yarn install) again.
• Check for typos: Double-check the package name you’re trying to install. A simple typo can lead to errors.
• Look for error messages: The error message often provides clues about the cause of the problem. Search for the error message online to see if others have encountered similar issues.
• Check your internet connection: A poor internet connection can disrupt the download of packages.

Q: What is the hardhat.config.js (or hardhat.config.ts) file for?

A: This file is the heart of your Hardhat project configuration. It’s where you define settings like:

• Networks: Configure different Ethereum networks (Hardhat Network, Goerli, mainnet, etc.) and their connection details.
• Solidity Compiler: Specify the Solidity compiler version and settings.
• Paths: Customize the paths to your contracts, tests, and other project files.
• Plugins: Load and configure Hardhat plugins.
• Tasks: Define custom Hardhat tasks.

Q: Do I have to use TypeScript with Hardhat?

A: No, TypeScript is not required. You can use JavaScript as well. Hardhat has excellent TypeScript support, and it is recommended for larger projects where static typing can be beneficial, but it’s not mandatory.

Q: Where can I find more information about Hardhat?

A: The respectable Hardhat documentation is the best aid: https://hardhat.org/. It contains detailed explanations, tutorials, and API references. The Hardhat community forum and Discord server are also great places to ask questions and get help.