# 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>!


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.developers.thundercore.com/deploying-on-thundercore/using-hardhat-include-create-a-project-steps.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.