Hardhat
Using Hardhat to Deploy To Phron
Introduction
Hardhat is a flexible and extensible Ethereum development environment that streamlines the smart contract development process. Since Phron is Ethereum-compatible, you can use Hardhat to develop and deploy smart contracts on Phron.
Hardhat takes a task-based approach to development, where you can define and execute tasks that perform specific actions. These actions include compiling and deploying contracts, running tests, and more. Tasks are highly configurable, so you can create, customize, and execute tasks that are tailored to meet your needs.
You can also extend Hardhat's functionality through the use of plugins. Plugins are external extensions that integrate with Hardhat to provide additional features and tools for your workflow. For example, there are plugins for common Ethereum libraries, like Ethers.js and viem, a plugin that extends the Chai assertion library to include Ethereum-specific functionality, and more. All of these plugins can be used to extend your Hardhat project on Phron.
This guide will provide a brief introduction to Hardhat and show you how to use Hardhat to compile, deploy, and debug Ethereum smart contracts on the Phron TestNet.
Please note that although Hardhat comes with a Hardhat Network component, which provides a local development environment, you should use a local Phron development node instead. You can connect a Phron development node to Hardhat just like you would with any other network.
Checking Prerequisites
To get started, you will need the following:
Have MetaMask installed and connected to Phron
Have an account with funds. You can get DEV tokens for testing on Phron once every 24 hours from the Phron Faucet
To test out the examples in this guide on Phron, you will need to have your own endpoint and API key, which you can get from one of the supported Endpoint Providers
Create a Hardhat Project
You will need to create a Hardhat project if you don't already have one. You can create one by completing the following steps:
Create a directory for your project
Initialize the project, which will create a
package.json
fileInstall Hardhat
Create a Hardhat project
Note
npx
is used to run executables installed locally in your project. Although Hardhat can be installed globally, it is recommended to install it locally in each project so that you can control the version on a project-by-project basis.
A menu will appear, which will allow you to create a new project or use a sample project. For this example, you can choose Create an empty hardhat.config.js, which will create a Hardhat configuration file for your project
Hardhat Configuration File
The Hardhat configuration file is the entry point into your Hardhat project. It defines various settings and options for your Hardhat project, such as the Solidity compiler version to use and the networks you can deploy your contracts to.
To start, your hardhat.config.js
should resemble the following:
For this example, you can leave the Solidity compiler version to 0.8.20
; however, if you are using a different contract that requires a newer version, don't forget to update the version here.
Next, you'll need to modify your configuration file to add the network configurations for the network you want to deploy your contract to. For Phron networks, you'll need to specify the following:
url
- the RPC endpoint of the nodechainId
- the chain ID, which is used to validate the networkaccounts
- the accounts that can be used to deploy and interact with contracts. You can either enter an array of the private keys for your accounts or use an HD Wallet
For this example, the network will be Phron, but you can modify the configuration to use any of the Phron networks:
If you are planning on using any plugins with your project, you'll need to install the plugin and import it into the hardhat.config.js
file. Once a plugin has been imported, it becomes part of the Hardhat Runtime Environment, and you can leverage the plugin's functionality within tasks, scripts, and more.
For this example, you can install the hardhat-ethers
plugin and import it into the configuration file. This plugin provides a convenient way to use the Ethers.js library to interact with the network.
Additionally, you'll need to install the hardhat-ignition-ethers
plugin to enable deployment of smart contracts with Hardhat Ignition. You can install it with the following command:
To import both plugins, add the following require
statements to the top of the Hardhat configuration file:
For more information on the available configuration options, please refer to Hardhat's documentation on Configuration.
The Contract File
Now that you've configured your project, you can begin the development process by creating your smart contract. The contract will be a simple one that will let you store a value that can be retrieved later, called Box
.
To add the contract, you'll take the following steps:
Create a
contracts
directoryCreate a
Box.sol
fileOpen the file and add the following contract to it:
Compile the Contract
The next step is to compile the Box.sol
smart contract. For this, you can use the built-in compile
task, which will look for Solidity files in the contracts
directory and compile them using the version and compiler settings defined in the hardhat.config.js
file.
To use the compile
task, all you have to do is run:
After compilation, an artifacts
directory is created that holds the bytecode and metadata of the contract, which are .json
files. It’s a good idea to add this directory to a .gitignore
file.
If you make changes to the contract after you've compiled it, you can compile it again using the same command. Hardhat will look for any changes and recompile the contract. If no changes are found, nothing will be compiled. If needed, you can force a compilation using the clean
task, which will clear the cache and delete the old artifacts.
Deploy the Contract
To deploy the contract, you'll use Hardhat Ignition, a declarative framework for deploying smart contracts. Hardhat Ignition is designed to make it easy to manage recurring tasks surrounding smart contract deployment and testing. For more information, be sure to check out the Hardhat Ignition docs.
To set up the proper file structure for your Ignition module, create a folder named ignition
and a subdirectory called modules
. Then add a new file to it called Box.js
. You can take all three of these steps with the following command:
Next, you can write your Hardhat Ignition module. To get started, take the following steps:
Import the
buildModule
function from the Hardhat Ignition moduleExport a module using
buildModule
Use the
getAccount
method to select the deployer accountDeploy the
Box
contractReturn an object from the module. This makes the
Box
contract accessible for interaction in Hardhat tests and scripts
To run the script and deploy the Box.sol
contract, use the following command, which requires you to specify the network name as defined in your hardhat.config.js
. If you don't specify a network, hardhat will deploy the contract to a local hardhat network by default.
NoteIf you're using another Phron network, make sure that you specify the correct network. The network name needs to match how it's defined in the
hardhat.config.js
file.
You'll be prompted to confirm the network you wish to deploy to. After a few seconds after you confirm, the contract is deployed, and you'll see the contract address in the terminal.
Congratulations, your contract is live! Save the address, as you will use it to interact with this contract instance in the next step.
Interact with the Contract
There are a couple of ways that you can interact with your newly deployed contract using Hardhat: you can use the console
task, which spins up an interactive JavaScript console, or you can create another script and use the run
task to execute it.
Using the Hardhat Console
The Hardhat console uses the same execution environment as the tasks and scripts, so it automatically uses the configurations and plugins defined in the hardhat.config.js
.
To launch the Hardhat console
, you can run:
Next, you can take the following steps, entering one line at a time:
Create a local instance of the
Box.sol
contractConnect the local instance to the deployed contract, using the address of the contract
Interact with the attached contract. For this example, you can call the
store
method and store a simple value
The transaction will be signed by your account configured in the hardhat.config.js
file and broadcasted to the network. The output should look similar to:
Notice your address labeled from
, the address of the contract, and the data
that is being passed. Now, you can retrieve the value by running:
You should see 5
, or the value you initially stored.
Using a Script
Similarly to the deployment script, you can create a script to interact with your deployed contract, store it in the scripts
directory, and run it using the built-in run
task.
To get started, create a set-value.js
file in the scripts
directory:
Now paste the following contract into the set-value.js
file:
To run the script, you can use the following command:
The script should return 2
as the value.
Hardhat Forking
You can fork any EVM-compatible chain using Hardhat, including Phron. Forking simulates the live Phron network locally, enabling you to interact with deployed contracts on Phron in a local test environment. Since Hardhat forking is based on an EVM implementation, you can interact with the fork using standard Ethereum JSON-RPC methods supported by Phron and Hardhat.
There are some limitations to be aware of when using Hardhat forking. You cannot interact with any of the Phron precompiled contracts or their functions. Precompiles are a part of the Substrate implementation and therefore cannot be replicated in the simulated EVM environment. This prohibits you from interacting with cross-chain assets on Phron and Substrate-based functionality such as staking and governance.
There is currently an issue related to forking Phron, so in order to fix the issue, you'll need to manually patch Hardhat first. You can find out more information by following the issue on GitHub as well as the related PR.
Patching Hardhat
Before getting started, you'll need to apply a temporary patch to workaround an RPC error until Hardhat fixes the root issue. The error is as follows:
To patch Hardhat, you'll need to open the node_modules/hardhat/internal/hardhat-network/jsonrpc/client.js
file of your project. Next, you'll add an addAccessList
function and update the _perform
and _performBatch
functions.
To get started, you can remove the preexisting _perform
and _performBatch
functions and, in their place, add the following code snippet:
Then you can use patch-package to automatically patch the package by running the following command:
A patches
directory will be created, and now you should be all set to fork Phron without running into any errors.
Forking Phron
You can fork Phron from the command line or configure your Hardhat project to always run the fork from your hardhat.config.js
file. To fork Phron, you will need to have your own endpoint and API key, which you can get from one of the supported Endpoint Providers.
To fork Phron from the command line, you can run the following command from within your Hardhat project directory:
If you prefer to configure your Hardhat project, you can update your hardhat.config.js
file with the following configurations:
When you spin up the Hardhat fork, you'll have 20 development accounts that are pre-funded with 10,000 test tokens. The forked instance is available at http://127.0.0.1:8545/
. The output in your terminal should resemble the following:
To verify you have forked the network, you can query the latest block number:
If you convert the result
from hex to decimal, you should get the latest block number from the time you forked the network. You can cross-reference the block number using a block explorer.
From here, you can deploy new contracts to your forked instance of Phron or interact with contracts already deployed by creating a local instance of the deployed contract.
To interact with an already deployed contract, you can create a new script in the scripts
directory using ethers
. Because you'll be running it with Hardhat, you don't need to import any libraries. Inside the script, you can access a live contract on the network using the following snippet:
This tutorial is for educational purposes only. As such, any contracts or code created in this tutorial should not be used in production.The information presented herein has been provided by third parties and is made available solely for general information purposes. Phron does not endorse any project listed and described on the Phron Doc Website (https://docs.Phron.ai/). Phron does not warrant the accuracy, completeness or usefulness of this information. Any reliance you place on such information is strictly at your own risk. Phron disclaims all liability and responsibility arising from any reliance placed on this information by you or by anyone who may be informed of any of its contents. All statements and/or opinions expressed in these materials are solely the responsibility of the person or entity providing those materials and do not necessarily represent the opinion of Phron. The information should not be construed as professional or financial advice of any kind. Advice from a suitably qualified professional should always be sought in relation to any particular matter or circumstance. The information herein may link to or integrate with other websites operated or content provided by third parties, and such other websites may link to this website. Phron has no control over any such other websites or their content and will have no liability arising out of or related to such websites or their content. The existence of any such link does not constitute an endorsement of such websites, the content of the websites, or the operators of the websites. These links are being provided to you only as a convenience and you release and hold Phron harmless from any and all liability arising from your use of this information or the information provided by any third-party website or service.
Last updated