Hardhat - Get Started

This document outlines the end-to-end process of deploying a smart contract on Abstract using Hardhat. It’s the ideal guide if you’re building a new project from scratch.

YouTube Tutorial: Get Started with Hardhat

Watch a step-by-step tutorial on how to get started with Hardhat.

1. Create a new project

Prerequisites

Ensure you have the following installed on your machine:

Node.js v18.0.0 or later.
If you are on Windows, we strongly recommend using WSL 2 to follow this guide.

Inside an empty directory, initialize a new Hardhat project using the Hardhat CLI: Create a new directory and navigate into it:

mkdir my-abstract-project && cd my-abstract-project

Initialize a new Hardhat project within the directory:

npx hardhat init

Select your preferences when prompted by the CLI, or use the recommended setup below.

Recommended Hardhat setup

We recommend selecting the following options when prompted by the Hardhat CLI:

✔ What do you want to do? · Create a TypeScript project
✔ Hardhat project root: · /path/to/my-abstract-project
✔ Do you want to add a .gitignore? (Y/n) · y
✔ Do you ... install ... dependencies with npm ... · y

2. Install the required dependencies

Abstract smart contracts use different bytecode than the Ethereum Virtual Machine (EVM). Install the required dependencies to compile, deploy and interact with smart contracts on Abstract:

@matterlabs/hardhat-zksync: A suite of Hardhat plugins for working with Abstract.
zksync-ethers: Recommended package for writing Hardhat scripts to interact with your smart contracts.

npm install -D @matterlabs/hardhat-zksync zksync-ethers@6 ethers@6

3. Modify the Hardhat configuration

Update your hardhat.config.ts file to include the following options:

import { HardhatUserConfig } from "hardhat/config";
import "@matterlabs/hardhat-zksync";

const config: HardhatUserConfig = {
  zksolc: {
    version: "latest",
    settings: {
      // find all available options in the official documentation
      // https://docs.zksync.io/build/tooling/hardhat/hardhat-zksync-solc#configuration
    },
  },
  defaultNetwork: "abstractTestnet",
  networks: {
    abstractTestnet: {
      url: "https://api.testnet.abs.xyz",
      ethNetwork: "sepolia",
      zksync: true,
      chainId: 11124,
    },
    abstractMainnet: {
      url: "https://api.mainnet.abs.xyz",
      ethNetwork: "mainnet",
      zksync: true,
      chainId: 2741,
    },
  },
  etherscan: {
    apiKey: {
      abstractTestnet: "TACK2D1RGYX9U7MC31SZWWQ7FCWRYQ96AD",
      abstractMainnet: "IEYKU3EEM5XCD76N7Y7HF9HG7M9ARZ2H4A",
    },
    customChains: [
      {
        network: "abstractTestnet",
        chainId: 11124,
        urls: {
          apiURL: "https://api-sepolia.abscan.org/api",
          browserURL: "https://sepolia.abscan.org/",
        },
      },
      {
        network: "abstractMainnet",
        chainId: 2741,
        urls: {
          apiURL: "https://api.abscan.org/api",
          browserURL: "https://abscan.org/",
        },
      },
    ],
  },
  solidity: {
    version: "0.8.24",
  },
};

export default config;

4. Write a smart contract

Rename the existing contracts/Lock.sol file to contracts/HelloAbstract.sol:

mv contracts/Lock.sol contracts/HelloAbstract.sol

Write a new smart contract in the contracts/HelloAbstract.sol file, or use the example smart contract below:

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

contract HelloAbstract {
    function sayHello() public pure virtual returns (string memory) {
        return "Hello, World!";
    }
}

5. Compile the smart contract

Clear any existing artifacts:

npx hardhat clean

Use the zksolc compiler (installed in the above steps) to compile smart contracts for Abstract:

npx hardhat compile --network abstractTestnet

npx hardhat compile --network abstractMainnet

You should now see the compiled smart contracts in the generated artifacts-zk directory.

6. Deploy the smart contract

Add the deployer account private key

Create a new configuration variable called DEPLOYER_PRIVATE_KEY.

npx hardhat vars set DEPLOYER_PRIVATE_KEY

Enter the private key of a new wallet you created for this step.

✔ Enter value: · ****************************************************************

Do NOT use a private key associated with real funds. Create a new wallet for this step.

Get ETH in the deployer account

The deployer account requires ETH to deploy a smart contract.

Testnet: Claim ETH via a faucet, or bridge ETH from Sepolia.
Mainnet: Use a bridge to transfer ETH to Abstract mainnet.

Write the deployment script

Create a new Hardhat script located at /deploy/deploy.ts:

mkdir deploy && touch deploy/deploy.ts

Add the following code to the deploy.ts file:

import { Wallet } from "zksync-ethers";
import { HardhatRuntimeEnvironment } from "hardhat/types";
import { Deployer } from "@matterlabs/hardhat-zksync";
import { vars } from "hardhat/config";

// An example of a deploy script that will deploy and call a simple contract.
export default async function (hre: HardhatRuntimeEnvironment) {
  console.log(`Running deploy script`);

  // Initialize the wallet using your private key.
  const wallet = new Wallet(vars.get("DEPLOYER_PRIVATE_KEY"));

  // Create deployer object and load the artifact of the contract we want to deploy.
  const deployer = new Deployer(hre, wallet);
  // Load contract
  const artifact = await deployer.loadArtifact("HelloAbstract");

  // Deploy this contract. The returned object will be of a `Contract` type,
  // similar to the ones in `ethers`.
  const tokenContract = await deployer.deploy(artifact);

  console.log(
    `${
      artifact.contractName
    } was deployed to ${await tokenContract.getAddress()}`
  );
}

Deploy your smart contract

Run the following command to deploy your smart contracts:

npx hardhat deploy-zksync --script deploy.ts --network abstractTestnet

npx hardhat deploy-zksync --script deploy.ts --network abstractMainnet

If successful, your output should look similar to the following:

Running deploy script
HelloAbstract was deployed to YOUR_CONTRACT_ADDRESS

Verify your smart contract on the block explorer

Verifying your smart contract is helpful for others to view the code and interact with it from a block explorer. To verify your smart contract, run the following command:

npx hardhat verify --network abstractTestnet YOUR_CONTRACT_ADDRESS

npx hardhat verify --network abstractMainnet YOUR_CONTRACT_ADDRESS

Note: Replace YOUR_CONTRACT_ADDRESS with the address of your deployed smart contract.

Overview

Build on Abstract

How Abstract Works

Tooling

Infrastructure

Hardhat - Get Started

YouTube Tutorial: Get Started with Hardhat

1. Create a new project

2. Install the required dependencies

3. Modify the Hardhat configuration

4. Write a smart contract

5. Compile the smart contract

6. Deploy the smart contract

YouTube Tutorial: Get Started with Hardhat

​1. Create a new project

​2. Install the required dependencies

​3. Modify the Hardhat configuration

​4. Write a smart contract

​5. Compile the smart contract

​6. Deploy the smart contract

1. Create a new project

2. Install the required dependencies

3. Modify the Hardhat configuration

4. Write a smart contract

5. Compile the smart contract

6. Deploy the smart contract