# Using Hardhat

> Hardhat is a development environment to compile, deploy, test, and debug your Ethereum software.

A sample project is available at <https://github.com/thundercore/hardhat-thunder-project>

#### Setting up Hardhat

Please follow [Hardhat offcial guide to prepare your environment](https://hardhat.org/tutorial/setting-up-the-environment.html).

Once your environment is ready, we can create an empty folder and init a Hardhat project in it.

```shell
$ mkdir my-thundercore-project && cd $_

# We choose a basic sample project and install its dependences here:
$ npx hardhat init

✔ What do you want to do? · Create a basic sample project

✔ Do you want to install this sample project's dependencies with npm (hardhat @nomiclabs/hardhat-waffle ethereum-waffle chai @nomiclabs/hardhat-ethers ethers)? (Y/n) · y
```

After initialization, we can test the project with the `hardhat compile` command:

{% tabs %}
{% tab title="npm" %}

```shell
$ npm exec -- hardhat compile
Downloading compiler 0.8.25
Compiling 2 files with 0.8.25
Compilation finished successfully
```

{% endtab %}

{% tab title="Yarn" %}

```shell
$ yarn hardhat compile
Compiling 2 files with 0.8.25
Compilation finished successfully
Done in 1.22s.
```

{% endtab %}
{% endtabs %}

#### Hardhat Config

To start developing on ThunderCore, we'll make some changes to the Hardhat config file. A great option is to use the [tt-hardhat plugin](https://github.com/thundercore/tt-hardhat#features).

```
yarn add -D tt-hardhat
```

Then, in hardhat.config, simply paste `import "tt-hardhat";` at the top. We'll now be able to use networks `thunder-testnet` and `thunder-mainnet`.

Alternatively, we can configure the network manually. Open and edit `hardhat.config.js` in the root directory of your project.

{% tabs %}
{% tab title="Use "tt-hardhat" plugin " %}

```
// hardhat.config.ts

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";

// Add this
import "tt-hardhat";

const config: HardhatUserConfig = {
   solidity: "0.8.25",
   networks: {
    hardhat: {
      allowUnlimitedContractSize: true,
      blockGasLimit: 141438723,
    },
  }
};

export default config;
```

{% endtab %}

{% tab title="Manual hardhat.config.js" %}

```
// hardhat.config.js

// yarn add -D dotenv # install `dotenv`
imort * as dotenv from "dotenv";

dotenv.config();

module.exports = {
  solidity: {
    version: "0.8.25",
    settings: {
      evmVersion: "london",
    },
  },
  networks: {
    'thunder-testnet': {
      url: 'https://testnet-rpc.thundercore.com',
      chainId: 18,
      accounts: process.env.KEY ? [process.env.KEY] : [],
    },
    'thunder-mainnet': {
      url: 'https://mainnet-rpc.thundercore.com',
      chainId: 108,
      accounts: process.env.KEY ? [process.env.KEY] : [],
    },
  },
}
```

{% endtab %}
{% endtabs %}

{% hint style="warning" %}
Never store your private key directly in `hardhat.config.js`

``Here we pass the its value on the command line or store it in `.env`.``
{% endhint %}

#### Deploy to ThunderCore Network

Let's deploy the first contract.

{% hint style="info" %}
You'll need some gas tokens to deploy contracts. To test on ThunderCore testnet, you can get some testnet tokens from [ThunderCore testnet Faucet](https://faucet-testnet.thundercore.com)
{% endhint %}

{% tabs %}
{% tab title="Unix-like system" %}

```shell
# Using NPM
KEY=0xPrivateKey npm exec -- hardhat run scripts/sample-script.js --network thunder-testnet
# or using Yarn
KEY=0xPrivateKey yarn hardhat run scripts/sample-script.js --network thunder-testnet
```

{% endtab %}

{% tab title="Windows CMD" %}

```shell
# Using NPM
set KEY=0xPrivateKey & npm exec -- hardhat run scripts/sample-script.js --network thunder-testnet
# or using Yarn
set KEY=0xPrivateKey & yarn hardhat run scripts/sample-script.js --network thunder-testnet
```

{% endtab %}

{% tab title="Windows Powershell" %}

```shell
# Using NPM
$env:KEY='0xPrivateKey';npm exec -- hardhat run scripts/sample-script.js --network thunder-testnet
# or using Yarn
$env:KEY='0xPrivateKey';yarn hardhat run scripts/sample-script.js --network thunder-testnet
```

{% endtab %}
{% endtabs %}

By using the `tt-hardhat` plugin, you can import `logDeployContracts` from hardhat to log your deployed contracts. [More info](https://github.com/thundercore/tt-hardhat#features)

**Congratulations!** You have successfully deployed a smart contract onto the ThunderCore network, you will find the deployed messages look like:

```
Greeter deployed to: 0xGreeterContractAddress
```

#### Verify contract by plugin

Once you deployed your contract, you might want to verify your contract code.

On ThunderCore testnet, we provide [Blockscout](https://explorer-testnet.thundercore.com) as our block explorer. You can use `hardhat-etherscan` plugin to verify your contract.

```bash
yarn add -D @nomiclabs/hardhat-etherscan
```

after installed the package, modify your `hardhat.config.js`

{% code title="hardhat.config.js" %}

```git
module.exports = {
  etherscan: {
    apiKey: {
      "thunder-testnet": "unused",
    },
    customChains: [
      {
        network: "thunder-testnet",
        chainId: 18,
        urls: {
          apiURL: "https://explorer-testnet.thundercore.com/api",
          browserURL: "https://explorer-testnet.thundercore.com",
        },
      },
    ],
  },
}
```

{% endcode %}

Now, you can verify your contract by command:

```
yarn hardhat verify --network thunder-testnet ADDRESS "CONSTRUCTOR_ARGUMENT"
```

For more details, you can check [hardhat-etherscan](https://github.com/NomicFoundation/hardhat/tree/master/packages/hardhat-etherscan) document.

Remember that a sample Hardhat project is available at <https://github.com/thundercore/hardhat-thunder-project>!