# Deploy a Smart Contract Using Hardhat In this tutorial, you'll be guided through setting up a Hardhat project and deploying a Hedera smart contract to the **Hedera Testnet** using the **Hashio** JSON-RPC instance. **Hardhat** is a development environment for Ethereum smart contracts. It consists of different components for editing, compiling, debugging, and deploying your smart contracts and dApps, all working together to create a complete development environment. By the end of this tutorial, you'll have learned how to deploy smart contracts using Hardhat on the Hedera Testnet\*\*.\*\*
1. PREREQUISITES#prerequisites
2. HARDHAT SETUP#hardhat-project-setup
3. PROJECT CONTENTS#project-contents
4. DEPLOY CONTRACT#test-and-deploy-contract
## Prerequisites * Basic understanding of smart contracts. * Basic understanding of Node.js or Javascript. * Basic understanding of the [Hedera JSON RPC Relay](/docs/core-concepts/smart-contracts/json-rpc-relay.md). * Basic understanding of [Hardhat Ethereum Development Tool](https://hardhat.org/hardhat-runner/docs/guides/project-setup). ## Hardhat Project Setup To make the setup process simple, you'll use a pre-configured Hardhat project from the `hedera-hardhat-example-project` [repository](https://github.com/hashgraph/hedera-hardhat-example-project). Open a terminal window and navigate to your preferred directory where your Hardhat project will live. Run the following command to clone the repo and install dependencies to your local machine: ```bash git clone https://github.com/hashgraph/hedera-hardhat-example-project.git cd hedera-hardhat-example-project npm install ``` The `dotenv` package is used to manage environment variables in a separate `.env` file, which is loaded at runtime. This helps protect sensitive information like your private keys and API secrets, but it's still best practice to add `.env` to your `.gitignore` to prevent you from pushing your credentials to GitHub. ## Project Configuration In this step, you will update and configure the Hardhat configuration file that defines tasks, stores Hedera account private key information, and Hashio Testnet RPC URL. First, rename the `.env.example` file to `.env`. and update the `.env` and `hardhat.config.js` files with the following code. But first, in order to deploy the contract to the *Hedera Testnet*, you will need to get a testnet account and key. To get a testnet account, create an *ECDSA* account using the [**Hedera Developer Portal**](https://portal.hedera.com/). Once you have your ECDSA account and HEX encoded private key, add the private key to the `TESTNET_OPERATOR_PRIVATE_KEY` variable in the `.env` file.
Create your testnet account 🛠️ **Create Hedera Portal Profile (Faucet)** The *Hedera Testnet* account allows you to interact with our [APIs](/docs/sdks-and-apis.md) and pay for the transaction fees. Visit the [Hedera portal](https://portal.hedera.com/register) to create your *Hedera Testnet* account and follow the instructions. Once you have completed the instructions, you will receive a *Hedera Testnet* **account ID** (0.0.x) and your **private/public key pair** on your testnet page. You will need to copy over your ECDSA ***HEX Encoded private key*** and paste it in the `TESTNET_OPERATOR_PRIVATE_KEY` .env file variable. ***Note:** Your Hedera Testnet account will be credited with 10,000 test **HBAR** upon creation that can only be utilized on the Hedera test network. Your balance will be topped up daily to 10,000 test **HBAR** when you use your funds.*
#### Environment Variables The `.env` file defines environment variables used in the Hardhat configuration file. The `TESTNET_OPERATOR_PRIVATE_KEY` variable contains the *ECDSA* ***Hex Encoded Private Key*** for the Hedera Testnet account used in the `testnet` network Hardhat configuration. The `TESTNET_ENDPOINT` variable contains the [HashIO](https://swirldslabs.com/hashio/) Testnet endpoint URL. This is the JSON-RPC instance that will submit the transactions to the Hedera test network to test, create and deploy your smart contract. 
# operator/receiver keys referenced in the hardhat.config account variable
TESTNET_OPERATOR_PRIVATE_KEY=0xb46751179bc8aa9e129d34463e46cd924055112eb30b31637b5081b56ad96129

# testnet endpoint referenced in the hardhat.config url variable
TESTNET_ENDPOINT='https://testnet.hashio.io/api'
#### Hardhat Configuration The `hardhat.config.js` file defines tasks for Hardhat, including `show-balance`, `transfer-hbars`, `deploy-contract`, `contract-view-call`, and `contract-call`. It exports a configuration object that includes the Solidity version and settings, default network, and network settings for the `testnet` network. The `url` property is set to the `TESTNET_ENDPOINT` environment variable, and `accounts` to an array containing the testnet private key imported from the `.env` file. ```javascript require("@nomicfoundation/hardhat-toolbox"); require("@nomicfoundation/hardhat-chai-matchers"); require("@nomiclabs/hardhat-ethers"); //import dotenv library to access environment variables stored in .env file require("dotenv").config(); //define hardhat task here, which can be accessed in our test file (test/rpc.js) by using hre.run('taskName') task("show-balance", async () => { const showBalance = require("./scripts/showBalance"); return showBalance(); }); task("deploy-contract", async () => { const deployContract = require("./scripts/deployContract"); return deployContract(); }); task("contract-view-call", async (taskArgs) => { const contractViewCall = require("./scripts/contractViewCall"); return contractViewCall(taskArgs.contractAddress); }); task("contract-call", async (taskArgs) => { const contractCall = require("./scripts/contractCall"); return contractCall(taskArgs.contractAddress, taskArgs.msg); }); /** @type import('hardhat/config').HardhatUserConfig */ module.exports = { mocha: { timeout: 3600000, }, solidity: { version: "0.8.9", settings: { optimizer: { enabled: true, runs: 500, }, }, }, //this specifies which network should be used when running Hardhat tasks defaultNetwork: "testnet", networks: { testnet: { //HashIO testnet endpoint from the TESTNET_ENDPOINT variable in the project .env the file url: process.env.TESTNET_ENDPOINT, //the Hedera testnet account ECDSA private //the public address for the account is derived from the private key accounts: [ process.env.TESTNET_OPERATOR_PRIVATE_KEY, ], }, }, }; ``` ## Project Contents In this step, you'll look at the descriptions of the Hardhat project contents. For more information regarding Hardhat projects, check out the [Hardhat docs](https://hardhat.org/hardhat-runner/docs/guides/project-setup). If you do not need to review the project contents you can skip to "[Test and Deploy](#test-and-deploy)." #### contracts/ The `contracts/` folder contains the source file for the Greeter smart contract.\ \ Let's review the `Greeter.sol` smart contract in the `hedera-example-hardhat-project/contracts` folder. At the top of the file, the `SPDX-License-Identifier` defines the license, in this case, the MIT license. The `pragma solidity ^0.8.9;` line specifies the Solidity compiler version to use. These two lines are crucial for proper licensing and compatibility. ```solidity //SPDX-License-Identifier: MIT pragma solidity ^0.8.9; contract Greeter { string private greeting; event GreetingSet(string greeting); //This constructor assigns the initial greeting and emit GreetingSet event constructor(string memory _greeting) { greeting = _greeting; emit GreetingSet(_greeting); } //This function returns the current value stored in the greeting variable function greet() public view returns (string memory) { return greeting; } //This function sets the new greeting msg from the one passed down as parameter and emit event function setGreeting(string memory _greeting) public { greeting = _greeting; emit GreetingSet(_greeting); } } ``` > *NOTE: The pragma solidity line must match the version of Solidity defined in the* [*module exports*](https://github.com/hashgraph/hedera-hardhat-example-project/blob/main/hardhat.config.js#L34) *of your `hardhat.config.js` file.* #### scripts/ The `scripts/` folder contains the automation scripts for the test file. This project contains 4 scripts. The `scripts/` folder contains test scripts for locally testing a smart contract before deploying it. Please read the comments to help you understand the code and its purpose: {% tabs %} {% tab title="contractCall.js" %} Calls the `setGreeting` function from the Greeter contract and sets the greeter message to "Greeter."\\ ```javascript const { ethers } = require('hardhat'); //This function accepts two parameters - address and msg //Retrieves the contract from the address and set new greeting module.exports = async (address, msg) => { //Assign the first signer, which comes from the first privateKey from our configuration in hardhat.config.js, to a wallet variable. const wallet = (await ethers.getSigners())[0]; //Assign the greeter contract object in a variable, this is used for already deployed contract, which we have the address for. ethers.getContractAt accepts: //name of contract as first parameter //address of our contract //wallet/signer used for signing the contract calls/transactions with this contract const greeter = await ethers.getContractAt('Greeter', address, wallet); //using the greeter object(which is our contract) we can call functions from the contract. In this case we call setGreeting with our new msg const updateTx = await greeter.setGreeting(msg); console.log(`Updated call result: ${msg}`); return updateTx; }; ``` {% endtab %} {% tab title="contractViewCall.js" %} Returns the current greeter message value stored with the Greeter contract.\\ ```javascript const { ethers } = require("hardhat"); module.exports = async (address) => { //Assign the first signer, which comes from the first privateKey from our configuration in hardhat.config.js, to a wallet variable. const wallet = (await ethers.getSigners())[0]; //Assign the greeter contract object in a variable, this is used for already deployed contract, which we have the address for. ethers.getContractAt accepts: //name of contract as first parameter //address of our contract //wallet/signer used for signing the contract calls/transactions with this contract const greeter = await hre.ethers.getContractAt("Greeter", address, wallet); //using the greeter object(which is our contract) we can call functions from the contract. In this case we call greet which returns our greeting msg const callRes = await greeter.greet(); console.log(`Contract call result: ${callRes}`); return callRes; }; ``` {% endtab %} {% tab title="deployContract.js" %} Deploys the Greeter contract and returns the contract public address. \\ ```javascript const { ethers } = require("hardhat"); module.exports = async () => { //Assign the first signer, which comes from the first privateKey from our configuration in hardhat.config.js, to a wallet variable. let wallet = (await ethers.getSigners())[0]; //Initialize a contract factory object //name of contract as first parameter //wallet/signer used for signing the contract calls/transactions with this contract const Greeter = await ethers.getContractFactory("Greeter", wallet); //Using already intilized contract facotry object with our contract, we can invoke deploy function to deploy the contract. //Accepts constructor parameters from our contract const greeter = await Greeter.deploy("initial_msg"); //We use wait to recieve the transaction (deployment) receipt, which contains contractAddress const contractAddress = (await greeter.deployTransaction.wait()) .contractAddress; console.log(`Greeter deployed to: ${contractAddress}`); return contractAddress; }; ``` {% endtab %} {% tab title="showBalance.js" %} Returns the balance of the specified wallet address (account) in tinybars. Tinybars are the unit in which Hedera accounts hold HBAR balances.\\ ```javascript const { ethers } = require("hardhat"); module.exports = async () => { //Assign the first signer, which comes from the first privateKey from our configuration in hardhat.config.js, to a wallet variable. const wallet = (await ethers.getSigners())[0]; //Wallet object (which is essentially signer object) has some built in functionality like getBalance, getAddress and more const balance = (await wallet.getBalance()).toString(); console.log(`The address ${wallet.address} has ${balance} weibars`); return balance; }; ``` {% endtab %} {% endtabs %} #### test/ The `test/` folder contains the test files for the project.\ \ The `rpc.js` file is located in the `test` folder of the `hedera-example-hardhat-project` project and references the Hardhat [tasks](https://github.com/hashgraph/hedera-hardhat-example-project/blob/main/hardhat.config.js#L7) that are defined in the hardhat.config file. When the command `npx hardhat test` is run, the program executes the `rpc.js` file. ```javascript const hre = require("hardhat"); const { expect } = require("chai"); describe("RPC", function () { let contractAddress; let signers; before(async function () { signers = await hre.ethers.getSigners(); }); it("should be able to get the account balance", async function () { const balance = await hre.run("show-balance"); expect(Number(balance)).to.be.greaterThan(0); }); it("should be able to deploy a contract", async function () { contractAddress = await hre.run("deploy-contract"); expect(contractAddress).to.not.be.null; }); it("should be able to make a contract view call", async function () { const res = await hre.run("contract-view-call", { contractAddress }); expect(res).to.be.equal("initial_msg"); }); it("should be able to make a contract call", async function () { const msg = "updated_msg"; await hre.run("contract-call", { contractAddress, msg }); const res = await hre.run("contract-view-call", { contractAddress }); expect(res).to.be.equal(msg); }); }); ``` #### .env A file that stores your environment variables like your accounts, private keys, and references to Hedera network ([see previous step](#environment-variables)). #### hardhat.config.js The Hardhat project configuration file. This file includes information about the Hedera network RPC URLs, accounts, and tasks defined ([see previous step](#hardhat-configuration)). ## Test and Deploy Now that you have your project set up and configured, let's deploy the `Greeter.sol` smart contract to the Hedera Testnet using [Hash](https://swirldslabs.com/hashio/)[io](https://swirldslabs.com/hashio/). Hashio is an instance of the [Hedera JSON-RPC relay](/docs/core-concepts/smart-contracts/json-rpc-relay.md) hosted by [Swirlds Labs](https://swirldslabs.com/) and provides convenient access to the Hedera network for transactions and data querying. You can use any JSON-RPC instance supported by the community. Run the following command in your terminal to run the `hedera-hardhat-example-project/test/rpc.js` test file on the Hedera testnet. ```bash npx hardhat test ``` Tests should pass with "**4 passing**" returned to the console. Otherwise, an error message will appear indicating the issue.
console check ✅ ```shell RPC The address 0xe261e26aECcE52b3788Fac9625896FFbc6bb4424 has 99999999999999991611392 weibars ✔ should be able to get the account balance (1127ms) Greeter deployed to: 0xEc3D74D360a53Fe7104Be6aB4e25e27a90bF6aE4 ✔ should be able to deploy a contract (11810ms) Contract call result: initial_msg ✔ should be able to make a contract view call (265ms) Updated call result: updated_msg Contract call result: updated_msg ✔ should be able to make a contract call (4068ms) 4 passing (34s) ```
Lastly, run the following command to deploy the contract to the Hedera Testnet: ```bash npx hardhat deploy-contract ```
console check ✅ ```bash Greeter deployed to: 0x157B93c04a294AbD88cF608672059814b3ea38aE ```
You've successfully deployed your contract to the Hedera Testnet! You can view the contract you deployed by searching the smart contract *public* address in a supported [Hedera Network Explorer](/docs/networks/community-mirror-nodes.md). For this example, we will use the [HashScan](https://hashscan.io/mainnet/dashboard) Network Explorer. Copy and paste your deployed `Greeter.sol` public contract address into the HashScan search bar. The Network Explorer will return the information about the contract created and deployed to the Hedera Testnet. The "EVM Address" field is the public address of the contract that was returned to you in your terminal. The terminal returned the public address with the "0x" hex encoding appended to the public address. You will also notice a contract ID in `0.0.contractNumber` (`0.0.3478001`) format. This is the *contract ID* used to reference the contract entity in the Hedera Network. > ***Note:** At the top of the explorer page, remember to switch the network to **TESTNET** before you search for the contract.*

Hashscan transaction

#### **Congratulations! 🎉 You have successfully learned how to deploy a smart contract using Hardhat.** Feel free to reach out if you have any questions:

Writer: Krystal, Technical Writer

GitHub | Twitter

https://twitter.com/theekrystallee

Editor: Simi, Sr. Software Manager

GitHub | LinkedIn

https://www.linkedin.com/in/shunjan/
--- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://dev.uniultra.xyz/docs/tutorials/smart-contracts/deploy-a-smart-contract-using-hardhat.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.