DCC Documents
  • Quickstart
  • Overview
    • Introduction
    • Features
    • Our Goal
    • Consensus Engine
    • Issue ERC20 Token
  • Developers
    • Network Endpoints
    • Deploy Smart Contract
      • Using Remix
      • Using Hardhat
    • Deploy NFTs
      • Create A Foundry Project
      • Create Your ERC721 Contract
      • Add Metadata
    • Run a Node
      • Hardware & System Requirements
      • Install DCC
      • Run A Full Node
      • Run A Validator Node
        • Block Rewards
        • Apply For Running A Validator
        • Manager Account And Validator Account
        • Run A Validator
      • Troubleshooting
    • Explorer
    • Dev Toolkit
  • Individuals
    • Wallet
      • Supported Wallet
      • Tutorial on how to set up wallet
    • Network Configuration
      • Configure Value
      • Tutorial on how to config DCC network in Metamask
  • FAQs
    • FAQs
      • General FAQs
      • Validator FAQs
  • Future Developments
    • Milestone
  • Community
    • Community
  • Disclosure
    • Disclaimers
    • Risk Statement
    • Media Kit
Powered by GitBook
On this page
  • Overview
  • What you will do​
  • Setting up the development environment
  • Pre-requisites​
  • Creating a project
  • Checking the Contract
  • Configure Hardhat for DCC
  • Compiling the contract
  • Testing the Contract
  • Deploying on DCC
  1. Developers
  2. Deploy Smart Contract

Using Hardhat

PreviousUsing RemixNextDeploy NFTs

Last updated 2 years ago

Overview

This tutorial will teach you how to create, compile and deploy a smart contract on the DCC Testnet using Hardhat.

is a development environment for Ethereum software. It consists of different components for editing, compiling, debugging, and deploying your smart contracts and dApps, all of which work together to create a complete development environment.

What you will do

  • Set up Hardhat

  • Create a simple smart contract

  • Compile contract

  • Test contract

  • Deploy contract

Setting up the development environment

There are a few technical requirements before we start.

Pre-requisites

There are a few technical requirements before we start, as listed below:

  • (comes with Node)

Once we have those installed, you need to create an npm project by going to an empty folder, running npm init --yes, and following its instructions to install Hardhat. Once your project is ready, you should run the following:

npm install --save-dev hardhat

To create your Hardhat project, run npx hardhat in your project folder. Let’s create the sample project and follow these steps to try out a sample task and compile, test, and deploy the sample contract.

Note

Creating a project

In your project folder, run npx hardhat to create a sample project. You should see the following prompt:

Choose the TypeScript project and The following prompt should appear:

Checking the Contract

A sample contract in the contracts folder is Lock.sol, which consists of a simple digital lock that allows users to withdraw funds only after a certain time has passed.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

// Import this file to use console.log
import "hardhat/console.sol";

contract Lock {
    uint public unlockTime;
    address payable public owner;

    event Withdrawal(uint amount, uint when);

    constructor(uint _unlockTime) payable {
        require(
            block.timestamp < _unlockTime,
            "Unlock time should be in the future"
        );

        unlockTime = _unlockTime;
        owner = payable(msg.sender);
    }

    function withdraw() public {
        // Uncomment this line to print a log in your terminal
        // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);

        require(block.timestamp >= unlockTime, "You can't withdraw yet");
        require(msg.sender == owner, "You aren't the owner");

        emit Withdrawal(address(this).balance, block.timestamp);

        owner.transfer(address(this).balance);
    }
}

Configure Hardhat for DCC

  • Go to hardhat.config.ts

  • Create .env file in the root to store your private key

Note

Use the DCC Explorer API key to verify the contract is only for DCC mainnet

// hardhat.config.ts
import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import * as dotenv from "dotenv";

dotenv.config();

const config: HardhatUserConfig = {
    solidity: {
        compilers:[
            {
                version: "0.8.9",
                settings: {
                    optimizer: {
                        enabled: true,
                        runs: 200,
                    },
                },
            },
            {
                version: "0.4.18",
            }
        ]
    },

    networks: {
        ropsten: {
            url: process.env.ROPSTEN_URL || "",
            accounts:
                process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],
        },
        testnet: {
            url: "https://rpc-testnet.dcc.network",
            chainId: 322,
            accounts: process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],

        },
        mainnet: {
            url: "https://rpc-mainnet.dcc.network",
            chainId: 321,
            accounts: process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],

        },

        hardhat: {
            allowUnlimitedContractSize: true,
        },
    },
    etherscan: {
        apiKey: process.env.ETHERSCAN_API_KEY,
    },
};

export default config;

NOTE

Note that the file above requires DOTENV, for managing environment variables and also ethers and etherscan. Make sure to install all those packages.

Your deployment contract account's private key is located in the .env file.

Compiling the contract

To compile a Hardhat project, change to the root of the directory where the project is located and you first need to install Hardhat Toolbox:

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

And then run to compile:

npx hardhat compile

Testing the Contract

To run tests with Hardhat, you need to type the following:

npx hardhat test

And this is an expected output:

Deploying on DCC

Run this command in the root of the project directory:

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

Note

If you want to deploy your smart contract to DCC Mainnet, at the Deploying stage, you need to use mainnet instead of testnet after --network.

If you have enough amount of DCT you will see the sample output:

Congratulations! You have successfully deployed the Lock Smart Contract. The Smart Contract is now available for interaction.

Besides, if you do not have the required amount of DCT, the output may look like this:

The sample project used here comes from the , as well as its instructions.

Add DCC Explorer API key to .env file to verify the contract on DCC explorer. You can generate an API key by

Find more instructions on how to use DOTENV on .

The contract will be deployed on DCC Testnet, and you can check the deployment status here:

You can go to to get more DCT for testing.

Hardhat
​
​
Node.js v10+ LTS and npm
Git
Hardhat Quickstart guide
creating an account
this page
https://explorer-testnet.docoin.shop/
DCC Testnet Faucet