DEV Community

Cover image for Deploying a smart contract to Abstract using Hardhat
Taylor Caldwell
Taylor Caldwell

Posted on

Deploying a smart contract to Abstract using Hardhat

#tutorial #blockchain #cryptocurrency #web3

This tutorial will guide you through deploying an NFT smart contract (ERC-721) on the Abstract test 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 Abstract
  • Create an NFT smart contract for Abstract
  • Compile a smart contract for Abstract
  • Deploy a smart contract to Abstract
  • Interact with a smart contract deployed on Abstract

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.

Metamask Wallet

In order to deploy a smart contract, you will first need a crypto wallet. You can create a wallet by downloading the Metamask browser extension.

Wallet funds

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

For this tutorial, you will be deploying a contract to the Abstract Sepolia test network. You can fund your wallet with Abstract Sepolia ETH using a bridge or faucet.

Creating a project

Before you can begin deploying smart contracts to Abstract, 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
Enter fullscreen mode Exit fullscreen mode

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

To install Hardhat, run:

npm install --save-dev hardhat
Enter fullscreen mode Exit fullscreen mode

To create a new Hardhat project, run:

npx hardhat init
Enter fullscreen mode Exit fullscreen mode

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 Abstract

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

To configure Hardhat to use Abstract, add Abstract 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: {
    // for mainnet
    'abstract-mainnet': {
      url: 'https://api.mainnet.abs.xyz',
      accounts: [process.env.WALLET_KEY as string],
      gasPrice: 1000000000,
    },
    // for testnet
    'abstract-testnet': {
      url: 'https://api.testnet.abs.xyz',
      accounts: [process.env.WALLET_KEY as string],
      gasPrice: 1000000000,
    },
    // for local dev environment
    'abstract-local': {
      url: 'http://localhost:8545',
      accounts: [process.env.WALLET_KEY as string],
      gasPrice: 1000000000,
    },
  },
  defaultNetwork: 'hardhat',
};

export default config;
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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

WALLET_KEY="<YOUR_PRIVATE_KEY>"
Enter fullscreen mode Exit fullscreen mode

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. For instructions on how to get your private key from Metamask, visit the Metamask Support page. It is critical that you do NOT commit this to a public repo.

Local Networks

For quick testing, such as if you want to add unit tests to the below NFT contract, you may wish to leave the defaultNetwork as 'hardhat'.

Compiling the 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;
    }
}
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Deploying the smart contract

Once your contract has been successfully compiled, you can deploy the contract to the Abstract Sepolia test network.

To deploy the contract to the Abstract Sepolia test 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;
});
Enter fullscreen mode Exit fullscreen mode

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 abstract-testnet
Enter fullscreen mode Exit fullscreen mode

The contract will be deployed on the Abstract Sepolia test 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.

Info: If you'd like to deploy to mainnet, you'll modify the command like so:

npx hardhat run scripts/deploy.ts --network abstract-mainnet

Regardless of the network you're deploying to, if you're deploying a new or modified contract, you'll need to verify it first.

Verifying the 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 Abstract Sepolia testnet.

In hardhat.config.ts, configure Abstract Sepolia as a custom network. Add the following to your HardhatUserConfig:

etherscan: {
   apiKey: {
    "abstract-testnet": "PLACEHOLDER_STRING"
   },
   customChains: [
     {
       network: "abstract-testnet",
       chainId: 11124,
       urls: {
        apiURL: "https://api-sepolia.abscan.org/api",
        browserURL: "https://sepolia.abscan.org/"
       }
     }
   ]
 },
Enter fullscreen mode Exit fullscreen mode

Info: You can get your AbsScan API key from abscan.org when you sign up for an account.

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

npx hardhat verify --network abstract-testnet <deployed address>
Enter fullscreen mode Exit fullscreen mode

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 0x1234567890ABCDEF01234567890ABCDEF0123456
for verification on the block explorer. Waiting for verification result...

Successfully verified contract NFT on Etherscan.
Enter fullscreen mode Exit fullscreen mode

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 AbsScan to confirm it is verified.

Interacting with the Smart Contract

If you verified on AbsScan, you can use the Read Contract and Write Contract tabs to interact with the deployed contract. You'll need to connect your wallet first, by clicking the Connect button.

Top comments (0)

Read next

pocchini profile image

The Unlikely Fix: How a Simple Folder Change Saved My React Native Journey

sue tua -

abdullahqasim profile image

How to Build a Generic CRUD Controller in Laravel for Multiple Resources

Abdullah Qasim -

zipqt profile image

The Right Way to Use LLMs as a Developer

Isaiah -

piotrbednarski profile image

Make Custom Handlebar Helpers in Ghost!

Piotr Bednarski -