How to use the command 'hardhat' (with examples)

The ‘hardhat’ command is a development environment for Ethereum software. It provides a set of tools and utilities for compiling, testing, and deploying Ethereum smart contracts. This article will illustrate several use cases of the ‘hardhat’ command with code examples, motivations, explanations, and sample outputs.

Use case 1: List available subcommands (or create a new project if no configuration exists)

Code:

hardhat

Motivation: This command is useful when you want to see a list of available ‘hardhat’ subcommands. It can also be used to create a new project if no configuration exists.

Explanation: Simply running ‘hardhat’ without any arguments will display a list of available subcommands. If no configuration file exists in the current directory, it will prompt you to create a new one by selecting a default or existing project.

Example output:

Usage: hardhat [GLOBAL OPTIONS] <command> [OPTIONS]

Commands:
  accounts       Print the list of accounts
  balance        See balance of an account
  clean          Clean the cache and delete all artifacts
  compile        Compile the entire project, building all artifacts
  console        Run a console with the Hardhat Runtime Environment pre-loaded
  flatten        Flatten and print contracts and their dependencies
  help           Shows a list of commands or help for one command
  node           Start a JSON-RPC server on top of Hardhat Network
  run            Run a user-defined script after compiling the project
  test           Run mocha tests
  --version, -v  Shows hardhat's version

Options:
  --config        A hardhat.config.js config file
  --network       The network to connect to
  --show-stack-traces     Show stack traces
  --help, -h     Shows help, or this message

Use case 2: Compile the current project and build all artifacts

Code:

hardhat compile

Motivation: Compiling a project is a necessary step before deploying or testing Ethereum smart contracts. This use case is useful when you want to build all the artifacts of the current project.

Explanation: Running ‘hardhat compile’ will invoke the compiler to compile the entire project, generating all the required contract artifacts. These artifacts include JSON files containing the contract bytecode, metadata, and ABI (Application Binary Interface) for interacting with the contracts.

Example output:

Compiling 4 contracts
Compiling contract1.sol...
Compiling contract2.sol...
Compilation finished successfully

Use case 3: Run a user-defined script after compiling the project

Code:

hardhat run path/to/script.js

Motivation: Sometimes you need to run custom scripts as part of your Ethereum development workflow. This command allows you to execute a specific script after compiling the project.

Explanation: By specifying the path to the script file after ‘hardhat run’, the command will compile the project and then execute the script. The script should be written in JavaScript and use the Hardhat Runtime Environment for interacting with the compiled contracts and other functionalities.

Example output:

Running script: path/to/script.js
Contract deployed at address: 0x123456789abcdef...

Use case 4: Run Mocha tests

Code:

hardhat test

Motivation: Testing is crucial for ensuring the correctness and robustness of Ethereum smart contracts. This command allows you to run the Mocha tests written for your project.

Explanation: Executing ‘hardhat test’ will run all the Mocha tests defined in the test files of your project. It will report the test results including passed and failed tests, test durations, and other relevant information.

Example output:

  Contract tests
    ✓ Should initialize the contract with the owner (1253ms)
    ✓ Should allow the owner to transfer ownership (836ms)
    ✓ Should prevent non-owners from transferring ownership (917ms)

  3 passing (8s)

Use case 5: Run all given test files

Code:

hardhat test path/to/file1.js path/to/file2.js

Motivation: Sometimes you may want to run specific test files instead of all the available tests. This use case allows you to execute multiple test files in a single command.

Explanation: By providing the paths to the desired test files after ‘hardhat test’, the command will run the specified test files only. This is useful when you want to individually test specific contracts or functionalities.

Example output:

  File1 tests
    ✓ Should initialize the contract with valid parameters (813ms)
    ✓ Should allow users to perform certain actions (1271ms)

  File2 tests
    ✓ Should handle certain scenarios correctly (2910ms)

  3 passing (5s)

Use case 6: Start a local Ethereum JSON-RPC node for development

Code:

hardhat node

Motivation: During Ethereum development, it is often necessary to interact with a local blockchain network. This command allows you to start a local Ethereum JSON-RPC node for development purposes.

Explanation: By running ‘hardhat node’, the command will start a local Ethereum JSON-RPC node using the Hardhat Network. This simulated blockchain network creates a local testing environment where you can deploy and interact with smart contracts without using real Ether.

Example output:

Started HTTP and WebSocket JSON-RPC server at http://localhost:8545/

Use case 7: Start a local Ethereum JSON-RPC node with a specific hostname and port

Code:

hardhat node --hostname hostname --port port

Motivation: In some cases, you may want to specify the hostname and port for the local Ethereum JSON-RPC node. This use case allows you to start the node with a custom hostname and port number.

Explanation: By providing the desired hostname and port values after ‘–hostname’ and ‘–port’ respectively, the ‘hardhat node’ command will start the local Ethereum JSON-RPC node with the specified configuration.

Example output:

Started HTTP and WebSocket JSON-RPC server at http://hostname:port/

Use case 8: Clean the cache and all artifacts

Code:

hardhat clean

Motivation: Over time, your Ethereum development project may accumulate unnecessary artifacts and cache data. This use case allows you to clean the cache and delete all the accumulated artifacts.

Explanation: Running ‘hardhat clean’ will delete the cache directory and all the artifacts generated during the compilation and testing processes. This action helps in keeping your project directory clean and removing any outdated or unnecessary files.

Example output:

Cache and artifacts cleaned successfully

Conclusion:

In this article, we covered various use cases of the ‘hardhat’ command, a development environment for Ethereum software. From compiling and testing smart contracts to running user-defined scripts and starting a local Ethereum node, ‘hardhat’ provides a comprehensive set of functionalities. By following the provided code examples and explanations, you can effectively use the ‘hardhat’ command for your Ethereum development tasks.