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

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.

​
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:

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

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.
2

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

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

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