Deploy with Solidity

​

Introduction

This article shows how to deploy a Solidity smart contract using Hardhat on any of Quai Network’s chains. For more complex deployments involving SolidityX and multi-chain deployments, visit the Deploy with SolidityX Tutorial.

​

Prerequisites

To deploy single chain smart contracts on Quai, we’ll need a few tool-kits and dependencies. Here’s an overview of all of the dependencies we’ll be using:

​

Environment Setup

​

Install Example Repository

Start by cloning the hardhat-example repository, navigating to the Solidity directory we’ll be using for this tutorial, and installing the dependencies via npm.

git clone https://github.com/dominant-strategies/hardhat-example.git
cd hardhat-example/Solidity
npm install

​

Smart Contracts

The Solidity/ directory comes with 2 sample contracts: ERC20.sol and ERC721.sol inside of the contracts/ directory. Both contracts are implementations derived from the Open Zeppelin library.

We’ll be using the ERC20.sol sample contract for this tutorial, but you can also add your own contracts or use contracts from other libraries.

​

Environment Variables

We’ve included a sample environment file, .env.dist, file at the root of the hardhat-example repo to manage token details, private keys, and your RPC URL in a secure fashion.

Copy the .env.dist file in the root to a new .env file in the repository root using the following command:

cp ../.env.dist ../.env

Open the .env file and add your private keys, RPC URLs, and token args for the contract you’d like to deploy. The .env file should look like this:

# Unique Privkey for each deployment address
CYPRUS1_PK="0x3700000000000000000000000000000000000000000000000000000000000000" # pubkey starting with 0x00
CYPRUS2_PK="0x9400000000000000000000000000000000000000000000000000000000000000" # pubkey starting with 0x01
...more priv keys

# Chain ID (local: 1337, testnet and devnet: 9000)
CHAIN_ID="9000"

# RPC endpoint
RPC_URL="https://rpc.dev.quai.network"

# Token Arguments
...more token args

Further information on RPC endpoints can be found in the local network specifications section for local nodes and the devnet specifications section for remote nodes.

The hardhat-example repository uses the Quais SDK to configure network connections using only a single RPC URL. To learn more about how the SDK configures network providers, visit the SDK provider examples section.

After filling in your private keys, RPC URL, we’re now ready to securely consume them inside of hardhat.config.js.

​

Hardhat Configuration

Hardhat uses a hardhat.config.js file to configure smart contract deployments. The config file allows you to define deployment networks, tasks, compilers, etc.

hardhat-example contains a prebuilt hardhat.config.js file with configurations for deploying and verifying smart contracts on any shard in the network.

/**
 * @type import('hardhat/config').HardhatUserConfig
 */

require("@nomicfoundation/hardhat-toolbox");
const dotenv = require("dotenv");
dotenv.config({ path: "../.env" });

const rpcUrl = process.env.RPC_URL;
const chainId = Number(process.env.CHAIN_ID);

module.exports = {
  defaultNetwork: "cyprus1",
  networks: {
    cyprus1: {
      url: rpcUrl,
      accounts: [process.env.CYPRUS1_PK],
      chainId: chainId,
    },
    cyprus2: {
      url: rpcUrl,
      accounts: [process.env.CYPRUS2_PK],
      chainId: chainId,
    },
    ...more networks
  },

  solidity: {
    version: "0.8.20",
    settings: {
      optimizer: {
        enabled: true,
        runs: 1000,
      },
    },
  },
};

When deploying or verifying a contract, hardhat.config.js will pull your private keys and RPC URL from the .env file and use them to deploy and verify your contracts. You can also specify the Solidity version and compiler settings in the solidity object.

​

Deploy and Interact

npx hardhat compile

Downloading compiler 0.8.20

Compiled 2 Solidity files successfully

const tokenArgs = [process.env.ERC20_NAME, process.env.ERC20_SYMBOL, quais.parseUnits(process.env.ERC20_INITIALSUPPLY)]

const provider = new quais.JsonRpcProvider(hre.network.config.url, undefined, { usePathing: true })
const wallet = new quais.Wallet(hre.network.config.accounts[0], provider)
const ERC20 = new quais.ContractFactory(ERC20Json.abi, ERC20Json.bytecode, wallet)

npx hardhat run scripts/deployERC20.js --network cyprus1

Transaction broadcasted: 0x235fdeb85db5b6cee8da9780e2246907e8342751849f5ce3514847a5dffd916f
Contract deployed to:  0x00735E9B2c731Fd3eCC8129a3653ACb99dF969cC

const quais = require('quais')
const ERC20Json = require('../artifacts/contracts/ERC20.sol/TestERC20.json')

async function getContractDetails() {
  // Config provider, wallet, and contract factory
  const provider = new quais.JsonRpcProvider(hre.network.config.url, undefined, { usePathing: true })
  const wallet = new quais.Wallet(hre.network.config.accounts[0], provider)
  const ERC20 = new quais.Contract("0x00735E9B2c731Fd3eCC8129a3653ACb99dF969cC", ERC20Json.abi, wallet)

  const tokenName = await ERC20.name()
  const tokenSymbol = await ERC20.symbol()
  const tokenDecimals = await ERC20.decimals()
  const tokenTotalSupply = await ERC20.totalSupply()
}

getContractDetails()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error)
    process.exit(1)
  })

​

Summary

Now you have all the tools you need to create a simple Hardhat project, deploy, and interact with your own smart contracts.