Hardhat Env

This section will guide you through deploying an NFT smart contract (ERC-721) on the Glide network using Hardhat.

Hardhat is a developer tool that provides a simple way to deploy, test, and debug smart contracts.

Objectives​

By the end of this tutorial, you should be able to do the following:

  • Setup Hardhat for Glide

  • Create an NFT smart contract for Glide

  • Compile a smart contract for Glide

  • Deploy a smart contract to Glide

  • Interact with a smart contract deployed on Glide

Prerequisites​

Node v18+​

This tutorial requires you have Node version 18+ installed.

If you are using nvm to manage your node versions, you can just run nvm install 18.

Wallet funds​

Deploying contracts to the blockchain requires a gas fee. Therefore, you will need to fund your wallet with GLDR to cover those gas fees.

For this tutorial, you will be deploying a contract to the Glide network. You can fund your wallet with Glide GLDR using one of the faucets listed on the Glide Faucets page.

Creating a project​

Before you can begin deploying smart contracts to Glide, you need to set up your development environment by creating a Node.js project.

To create a new Node.js project, run:

npm init --y

Next, you will need to install Hardhat and create a new Hardhat project

To install Hardhat, run:

npm install --save-dev hardhat

To create a new Hardhat project, run:

npx hardhat init

Select Create a TypeScript project then press enter to confirm the project root.

Select y for both adding a .gitignore and loading the sample project. It will take a moment for the project setup process to complete.

Configuring Hardhat with Glide​

In order to deploy smart contracts to the Glide Protocol, you will need to configure your Hardhat project and add the Glide network.

To configure Hardhat, add Glide as a network to your project's hardhat.config.ts file:

import { HardhatUserConfig } from 'hardhat/config';
import '@nomicfoundation/hardhat-toolbox';

require('dotenv').config();

const config: HardhatUserConfig = {
  solidity: {
    version: '0.8.23',
  },
  networks: {
    'glide': {
      url: 'https://rpc-api.glideprotocol.xyz',
      accounts: [process.env.WALLET_KEY as string],
      gasPrice: 1000000000,
    },
  },
  defaultNetwork: 'glide',
};

export default config;

Install Hardhat toolbox​

The above configuration uses the @nomicfoundation/hardhat-toolbox plugin to bundle all the commonly used packages and Hardhat plugins recommended to start developing with Hardhat.

To install @nomicfoundation/hardhat-toolbox, run:

npm install --save-dev @nomicfoundation/hardhat-toolbox

Loading environment variables​

The above configuration also uses dotenv to load the WALLET_KEY environment variable from a .env file to process.env.WALLET_KEY. You should use a similar method to avoid hardcoding your private keys within your source code.

To install dotenv, run:

npm install --save-dev dotenv

Once you have dotenv installed, you can create a .env file with the following content:

WALLET_KEY="<YOUR_PRIVATE_KEY>"

Substituting <YOUR_PRIVATE_KEY> with the private key for your wallet.

Caution

WALLET_KEY is the private key of the wallet to use when deploying a contract.

Compiling Smart Contract​

Below is a simple NFT smart contract (ERC-721) written in the Solidity programming language:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract NFT is ERC721 {
    uint256 public currentTokenId;

    constructor() ERC721("NFT Name", "NFT") {}

    function mint(address recipient) public payable returns (uint256) {
        uint256 newItemId = ++currentTokenId;
        _safeMint(recipient, newItemId);
        return newItemId;
    }
}

The Solidity code above defines a smart contract named NFT. The code uses the ERC721 interface provided by the OpenZeppelin Contracts library to create an NFT smart contract. OpenZeppelin allows developers to leverage battle-tested smart contract implementations that adhere to official ERC standards.

To add the OpenZeppelin Contracts library to your project, run:

npm install --save @openzeppelin/contracts

In your project, delete the contracts/Lock.sol contract that was generated with the project and add the above code in a new file called contracts/NFT.sol. (You can also delete the test/Lock.ts test file, but you should add your own tests ASAP!).

To compile the contract using Hardhat, run:

npx hardhat compile

Deploying the smart contract​

Once your contract has been successfully compiled, you can deploy the contract to the Glide network.

To deploy the contract to the Glide network, you'll need to modify the scripts/deploy.ts in your project:

import { ethers } from 'hardhat';

async function main() {
  const nft = await ethers.deployContract('NFT');

  await nft.waitForDeployment();

  console.log('NFT Contract Deployed at ' + nft.target);
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

You'll also need testnet ETH in your wallet. See the prerequisites if you haven't done that yet. Otherwise, the deployment attempt will fail.

Finally, run:

npx hardhat run scripts/deploy.ts --network glide

The contract will be deployed on the Glide network. You can view the deployment status and contract by using a block explorer and searching for the address returned by your deploy script. If you've deployed an exact copy of the NFT contract above, it will already be verified and you'll be able to read and write to the contract using the web interface.

Verifying Smart Contract​

If you want to interact with your contract on the block explorer, you, or someone, needs to verify it first. The above contract has already been verified, so you should be able to view your version on a block explorer already. For the remainder of this tutorial, we'll walk through how to verify your contract on Base Sepolia testnet.

In hardhat.config.ts, configure Glide as a custom network. Add the following : 

// Hardhat expects etherscan here, even if you're using Glide Explorer.
etherscan: {
   apiKey: {
    "glide": process.env.BLOCKSCOUT_KEY as string
   },
   customChains: [
     {
       network: "glide",
       chainId: 901,
       urls: {
        apiURL: "https://blockchain-explorer.glideprotocol.xyz/api",
        browserURL: "https://blockchain-explorer.glideprotocol.xyz"
       }
     }
   ]
 },

Now, you can verify your contract. Grab the deployed address and run:

npx hardhat verify --network glide <deployed address>

You should see an output similar to:

Nothing to compile
No need to generate any newer typings.
Successfully submitted source code for contract
contracts/NFT.sol:NFT at 0x6527E5052de5521fE370AE5ec0aFCC6cD5a221de
for verification on the block explorer. Waiting for verification result...

Successfully verified contract NFT on Glide.

Info

You can't re-verify a contract identical to one that has already been verified. If you attempt to do so, such as verifying the above contract, you'll get an error similar to:

Error in plugin @nomiclabs/hardhat-etherscan: The API responded with an unexpected message.
Contract verification may have succeeded and should be checked manually.
Message: Already Verified

Search for your contract on Glide Explorer to confirm it is verified.

PreviousDeploying ContractNextOracle

Last updated

Was this helpful?