Hardhat

https://hardhat.org/docs/
Admin
Hardhat is a flexible and extensible development environment for Ethereum software, designed to help...
Tokens:201,605
Snippets:2,104
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install and build the plugin

Source: https://hardhat.org/docs/plugin-development/guides/hardhat3-plugin-template.md

Install dependencies and build the plugin. This is a necessary step before testing the plugin in the example project.

```sh
pnpm install
pnpm build
```

--------------------------------

### Example Usage of vm.recordLogs and vm.getRecordedLogs

Source: https://hardhat.org/docs/reference/cheatcodes/environment/get-recorded-logs.md

Demonstrates how to use vm.recordLogs to start recording events and vm.getRecordedLogs to retrieve them. It includes assertions to verify the emitted events and their data. Note that getRecordedLogs consumes the logs, so subsequent calls will only return newly emitted events.

```solidity
/// event LogTopic1(
///   uint256 indexed topic1,
///   bytes data
/// );

/// event LogTopic12(
///   uint256 indexed topic1,
///   uint256 indexed topic2,
///   bytes data
/// );


/// bytes memory testData0 = "Some data";
/// bytes memory testData1 = "Other data";


// Start the recorder
vm.recordLogs();

emit LogTopic1(10, testData0);
emit LogTopic12(20, 30, testData1);

// Notice that your entries are <Interface>.Log[]
// as opposed to <instance>.Log[]
Vm.Log[] memory entries = vm.getRecordedLogs();

assertEq(entries.length, 2);

// Recall that topics[0] is the event signature
assertEq(entries[0].topics.length, 2);
assertEq(entries[0].topics[0], keccak256("LogTopic1(uint256,bytes)"));
assertEq(entries[0].topics[1], bytes32(uint256(10)));
// assertEq won't compare bytes variables. Try with strings instead.
assertEq(abi.decode(entries[0].data, (string)), string(testData0));

assertEq(entries[1].topics.length, 3);
assertEq(entries[1].topics[0], keccak256("LogTopic12(uint256,uint256,bytes)"));
assertEq(entries[1].topics[1], bytes32(uint256(20)));
assertEq(entries[1].topics[2], bytes32(uint256(30)));
assertEq(abi.decode(entries[1].data, (string)), string(testData1));

// Emit another event
emit LogTopic1(40, testData0);

// Your last read consumed the recorded logs,
// you will only get the latest emitted even after that call
entries = vm.getRecordedLogs();

assertEq(entries.length, 1);

assertEq(entries[0].topics.length, 2);
assertEq(entries[0].topics[0], keccak256("LogTopic1(uint256,bytes)"));
assertEq(entries[0].topics[1], bytes32(uint256(40)));
assertEq(abi.decode(entries[0].data, (string)), string(testData0));

```

--------------------------------

### Implement setup functions

Source: https://hardhat.org/docs/guides/testing/using-solidity.md

Use the setUp function to share initialization logic across multiple test functions.

```solidity
contract CounterTest {
  Counter counter;

  function setUp() public {
    counter = new Counter();
  }

  function testInc() public {
    counter.inc();
    require(counter.count() == 1, "count should be 1");
  }

  function testIncBy(uint by) public {
    counter.incBy(by);
    require(counter.count() == by, "count should match the 'by' value");
  }
}
```

--------------------------------

### Install hardhat-verify

Source: https://hardhat.org/docs/plugins/hardhat-verify.md

Command to install the plugin as a development dependency.

```bash
npm install --save-dev @nomicfoundation/hardhat-verify
```

--------------------------------

### Install viem and testing packages with npm

Source: https://hardhat.org/docs/learn-more/using-viem

Install the necessary packages for viem integration and testing using npm.

```bash
npm add --save-dev @nomicfoundation/hardhat-viem @nomicfoundation/hardhat-viem-assertions @nomicfoundation/hardhat-node-test-runner @nomicfoundation/hardhat-network-helpers viem
```

--------------------------------

### Install viem and testing packages with yarn

Source: https://hardhat.org/docs/learn-more/using-viem

Install the necessary packages for viem integration and testing using yarn.

```bash
yarn add --dev @nomicfoundation/hardhat-viem @nomicfoundation/hardhat-viem-assertions @nomicfoundation/hardhat-node-test-runner @nomicfoundation/hardhat-network-helpers viem
```

--------------------------------

### Run the example task

Source: https://hardhat.org/docs/plugin-development/guides/hardhat3-plugin-template.md

Navigate to the example project directory and run a sample Hardhat task to test the plugin. This verifies that the plugin is correctly integrated and functional.

```sh
cd packages/example-project
pnpm hardhat my-task
```

--------------------------------

### Install hardhat-ledger Plugin

Source: https://hardhat.org/docs/plugins/hardhat-ledger.md

Install the plugin using npm or pnpm. For pnpm, include --allow-build=node-hid.

```bash
npm install --save-dev @nomicfoundation/hardhat-ledger
```

```bash
pnpm install --save-dev --allow-build=node-hid @nomicfoundation/hardhat-ledger
```

--------------------------------

### Install viem and testing packages with pnpm

Source: https://hardhat.org/docs/learn-more/using-viem

Install the necessary packages for viem integration and testing using pnpm.

```bash
pnpm add --save-dev @nomicfoundation/hardhat-viem @nomicfoundation/hardhat-viem-assertions @nomicfoundation/hardhat-node-test-runner @nomicfoundation/hardhat-network-helpers viem
```

--------------------------------

### Install hardhat-network-helpers

Source: https://hardhat.org/docs/plugins/hardhat-network-helpers.md

Install the plugin using npm. This plugin is part of larger toolboxes, so it might already be included.

```bash
npm install --save-dev @nomicfoundation/hardhat-network-helpers
```

--------------------------------

### Install Testing Packages

Source: https://hardhat.org/docs/guides/testing/using-viem.md

Installs the necessary packages for testing smart contracts with viem and Node.js test runner.

```bash
npm install --save-dev @nomicfoundation/hardhat-viem @nomicfoundation/hardhat-viem-assertions @nomicfoundation/hardhat-node-test-runner @nomicfoundation/hardhat-network-helpers viem
```

--------------------------------

### Install hardhat-toolbox-viem

Source: https://hardhat.org/docs/plugins/hardhat-toolbox-viem.md

Install the toolbox using npm. This command adds the package as a development dependency.

```bash
npm install --save-dev @nomicfoundation/hardhat-toolbox-viem
```

--------------------------------

### Install hardhat-keystore

Source: https://hardhat.org/docs/plugins/hardhat-keystore.md

Command to add the plugin as a development dependency to your project.

```bash
npm install --save-dev @nomicfoundation/hardhat-keystore
```

--------------------------------

### Install forge-std via GitHub

Source: https://hardhat.org/docs/migrate-from-foundry.md

Install the forge-std library directly from its GitHub repository using a package manager.

```bash
<Install packages="'github:foundry-rs/forge-std#v1.9.7'" />
```

--------------------------------

### Install hardhat-mocha

Source: https://hardhat.org/docs/plugins/hardhat-mocha.md

Command to install the plugin as a development dependency.

```bash
npm install --save-dev @nomicfoundation/hardhat-mocha
```

--------------------------------

### Install hardhat-ignition-viem

Source: https://hardhat.org/docs/plugins/hardhat-ignition-viem.md

Install the plugin using npm. This command adds the package as a development dependency.

```bash
npm install --save-dev @nomicfoundation/hardhat-ignition-viem
```

--------------------------------

### Install hardhat-viem-assertions

Source: https://hardhat.org/docs/plugins/hardhat-viem-assertions.md

Install the plugin using npm. This command adds the package as a development dependency.

```bash
npm install --save-dev @nomicfoundation/hardhat-viem-assertions
```

--------------------------------

### Install Hardhat Toolbox Viem Plugin

Source: https://hardhat.org/docs/tutorial/plugins.md

Install the `hardhat-toolbox-viem` plugin along with its dependencies, `@nomicfoundation/hardhat-ignition` and `viem`, which are needed for subsequent steps.

```bash
npm install --save-dev @nomicfoundation/hardhat-toolbox-viem @nomicfoundation/hardhat-ignition viem
```

--------------------------------

### Install Hardhat Foundry Plugin

Source: https://hardhat.org/docs/plugins/hardhat-foundry.md

Install the plugin as a development dependency in your project.

```bash
npm install --save-dev @nomicfoundation/hardhat-foundry
```

--------------------------------

### Usage of keyExistsToml

Source: https://hardhat.org/docs/reference/cheatcodes/external/key-exists-toml.md

Example demonstrating how to read a TOML file and verify the existence of a key.

```solidity
string memory path = "./path/to/tomlfile.toml";
string memory toml = vm.readFile(path);
bool exists = vm.keyExistsToml(toml, ".key");
assertTrue(exists);
```

--------------------------------

### Install forge-std library

Source: https://hardhat.org/docs/tutorial/assertions-library.md

Installs the `forge-std` library, which provides useful testing utilities for Solidity. Use this command to add the library to your project.

```bash
forge install foundry-rs/forge-std --no-commit-foundry
```

--------------------------------

### Example Usage of vm.roll

Source: https://hardhat.org/docs/reference/cheatcodes/environment/roll.md

This example demonstrates how to use the vm.roll cheatcode to set the block number to 100 and then logs the current block number to verify the change.

```solidity
vm.roll(100);
emit log_uint(block.number); // 100
```

--------------------------------

### Create and Select Mainnet Fork

Source: https://hardhat.org/docs/reference/cheatcodes/forking/create-select-fork.md

Examples of initializing a fork at the latest block or a specific block number.

```solidity
uint256 forkId = vm.createSelectFork(MAINNET_RPC_URL);

assertEq(block.number, 15_171_037); // as of time of writing, 2022-07-19 04:55:27 UTC
```

```solidity
uint256 forkId = vm.createSelectFork(MAINNET_RPC_URL, 1_337_000);

assertEq(block.number, 1_337_000);
```

--------------------------------

### Install hardhat-viem Plugin

Source: https://hardhat.org/docs/plugins/hardhat-viem.md

Install the plugin using npm. This command adds the necessary package to your project's development dependencies.

```bash
npm install --save-dev @nomicfoundation/hardhat-viem
```

--------------------------------

### Install OpenZeppelin contracts via npm

Source: https://hardhat.org/docs/migrate-from-foundry.md

Use this command to install standard OpenZeppelin contracts as an npm dependency.

```bash
<Install packages="@openzeppelin/contracts" />
```

--------------------------------

### Start the Hardhat console

Source: https://hardhat.org/docs/guides/hardhat-console.md

Run this command in your terminal to start the interactive Hardhat console. It automatically builds your project and makes the HRE available.

```bash
hardhat console
```

--------------------------------

### vm.record()

Source: https://hardhat.org/docs/reference/cheatcodes/environment/record.md

Starts recording all storage reads and writes within the VM environment.

```APIDOC
## vm.record()

### Description
Tell the VM to start recording all storage reads and writes. To access the recorded data, use the `accesses` cheatcode.

### Method
External Solidity Function

### Signature
`function record() external;`

### Notes
- Every write also counts as an additional read.

### Request Example
```solidity
vm.record();
numsContract.num2();
(bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(address(numsContract));
```
```

--------------------------------

### Verifying with Build Profiles

Source: https://hardhat.org/docs/plugins/hardhat-verify.md

Examples of using build profiles to ensure consistency between compilation and verification.

```bash
npx hardhat build --build-profile production
npx hardhat verify --network mainnet DEPLOYED_CONTRACT_ADDRESS "Constructor argument 1"
```

```bash
npx hardhat run --build-profile production scripts/verify.ts
```

--------------------------------

### Install hardhat-ethers-chai-matchers Explicitly

Source: https://hardhat.org/docs/plugins/hardhat-toolbox-mocha-ethers.md

Install the @nomicfoundation/hardhat-ethers-chai-matchers plugin separately if you need to use specific features like the 'anyValue' predicate. This ensures the plugin is available in your package.json.

```bash
npm install --save-dev @nomicfoundation/hardhat-ethers-chai-matchers
```

--------------------------------

### Install hardhat-viem-assertions explicitly

Source: https://hardhat.org/docs/plugins/hardhat-toolbox-viem.md

Manually install the `@nomicfoundation/hardhat-viem-assertions` plugin if you need to use its specific features, such as the `anyValue` predicate. This ensures the plugin is available in your `package.json`.

```bash
npm install --save-dev @nomicfoundation/hardhat-viem-assertions
```

--------------------------------

### Verify Hardhat Setup

Source: https://hardhat.org/docs/getting-started.md

After initialization, run this command to verify that your Hardhat project is set up correctly.

```sh
hardhat --help
```

--------------------------------

### Install Hardhat Node Test Runner

Source: https://hardhat.org/docs/plugins/hardhat-node-test-runner.md

Install the plugin using npm. This command adds the package as a development dependency.

```bash
npm install --save-dev @nomicfoundation/hardhat-node-test-runner
```

--------------------------------

### Sleep usage example

Source: https://hardhat.org/docs/reference/cheatcodes/external/sleep.md

Demonstrates halting execution for 10 seconds using the vm.sleep cheatcode.

```solidity
vm.sleep(10_000); // Halts execution for 10 seconds
```

--------------------------------

### View gas snapshot file format

Source: https://hardhat.org/docs/guides/testing/gas-snapshots.md

Example of the .gas-snapshot file structure for standard and fuzz tests.

```text
CalculatorTest#testAddition() (gas: 56852)
CalculatorTest#testSubtraction() (gas: 48291)
```

```text
CalculatorTest#testFuzzAddition(uint128,uint128) (runs: 256, μ: 55070, ~: 55040)
```

--------------------------------

### Run a script to start the Hardhat development server

Source: https://hardhat.org/docs/guides/hardhat-node.md

Executes a script that programmatically starts a Hardhat development server. This allows for more control over the node's lifecycle and configuration compared to the `hardhat node` task.

```bash
hardhat run scripts/server.ts
```

--------------------------------

### Get Test Client and mine blocks

Source: https://hardhat.org/docs/plugins/hardhat-viem.md

Obtain a test client using `getTestClient` for actions specific to development nodes. The example shows how to mine a specified number of blocks.

```typescript
const testClient = await viem.getTestClient();
await testClient.mine({ blocks: 10 });
```

--------------------------------

### Install hardhat-ethers plugin

Source: https://hardhat.org/docs/plugins/hardhat-ethers.md

Run this command in your terminal to add the plugin as a development dependency.

```bash
npm install --save-dev @nomicfoundation/hardhat-ethers
```

--------------------------------

### Running the Example Script

Source: https://hardhat.org/docs/plugin-development/tutorial/config.md

This shell command shows how to compile your Hardhat project and run a specific script (`my-account-example.ts`) after updating the configuration. It demonstrates the expected output, including the compiled contract information and the custom account address.

```shell
pnpm hardhat run scripts/my-account-example.ts
Compiling your Solidity contracts...
Compiled 1 Solidity file with solc 0.8.29 (evm target: cancun)

connection.myAccount: 0x70997970c51812dc3a010c7d01b50e0d17dc79c8
```

--------------------------------

### Configuring RPC Endpoints

Source: https://hardhat.org/docs/reference/cheatcodes/external/prompt.md

Example configuration for RPC endpoints in the Hardhat test configuration.

```js
forking: {
    rpcEndpoints: {
        mainnet: "https://eth.llamarpc.com",
        polygon: "https://polygon.llamarpc.com",
    }
}
```

--------------------------------

### Check Node.js Version

Source: https://hardhat.org/docs/tutorial/setup.md

Verify your Node.js installation. Ensure you have Node.js 22.13.0+ installed.

```bash
node --version
```

--------------------------------

### Install Hardhat TypeChain plugin

Source: https://hardhat.org/docs/plugins/hardhat-typechain.md

Run this command in your terminal to add the plugin as a development dependency.

```bash
npm install --save-dev @nomicfoundation/hardhat-typechain
```

--------------------------------

### JSON string example

Source: https://hardhat.org/docs/reference/cheatcodes/external/write-json.md

Example of a stringified JSON object used as input for the cheatcode.

```text
{ "boolean": true, "number": 342, "object": { "title": "finally json serialization" } }
```

--------------------------------

### Example Function with Require

Source: https://hardhat.org/docs/reference/cheatcodes/fuzzer/assume-no-revert.md

A target function that reverts if the input amount is outside the specified range.

```solidity
function doSomething(uint256 amount) public {
  require(amount > 100 ether && amount < 1_000 ether);
}
```

--------------------------------

### Deploy Contract with getCode

Source: https://hardhat.org/docs/reference/cheatcodes/external/get-code.md

Example of using getCode to manually deploy a contract by encoding arguments and using assembly create.

```solidity
MyContract myContract = new MyContract(arg1, arg2);

// Let's do the same thing with `getCode`
bytes memory args = abi.encode(arg1, arg2);
bytes memory bytecode = abi.encodePacked(vm.getCode("MyContract.sol:MyContract"), args);
address anotherAddress;
assembly {
    anotherAddress := create(0, add(bytecode, 0x20), mload(bytecode))
}

assertEq0(address(myContract).code, anotherAddress.code); // [PASS]
```

--------------------------------

### Add Hardhat Viem Skill

Source: https://hardhat.org/docs/guides/build-with-ai.md

Install the Hardhat skill tailored for projects using hardhat-toolbox-viem.

```bash
skills add nomicfoundation/hardhat-skills --skill hardhat-toolbox-viem
```

--------------------------------

### Install hardhat-toolbox-mocha-ethers

Source: https://hardhat.org/docs/plugins/hardhat-toolbox-mocha-ethers.md

Install the toolbox using npm. This command adds the package as a development dependency.

```bash
npm install --save-dev @nomicfoundation/hardhat-toolbox-mocha-ethers
```

--------------------------------

### Initialize Hardhat Project

Source: https://hardhat.org/docs/getting-started.md

Run this command to initialize a new Hardhat project. It will prompt you for configuration options. Accepting defaults is recommended for a quick setup.

```sh
hardhat --init
```

--------------------------------

### Install hardhat-ignition-ethers Plugin

Source: https://hardhat.org/docs/plugins/hardhat-ignition-ethers.md

Install the plugin using npm. This plugin is part of the Ethers+Mocha Hardhat Toolbox.

```bash
npm install --save-dev @nomicfoundation/hardhat-ignition-ethers
```

--------------------------------

### Programmatically create and run a Hardhat development server

Source: https://hardhat.org/docs/guides/hardhat-node.md

This script demonstrates how to programmatically start a local Hardhat development node using `network.createServer`. It configures the server with logging enabled and specifies the network to simulate. The server runs for a set duration before closing.

```typescript
// scripts/server.ts
import { network } from "hardhat";

// Create a JsonRpcServer wrapping a blockchain simulation based on the
// "default" Network Config, with `loggingEnabled` setting overridden to `true`
const server = await network.createServer(
  {
    network: "default",
    override: { loggingEnabled: true },
  },
  // hostname and port are optional parameters
  // "127.0.0.1",
  // 8545,
);

const { address, port } = await server.listen();
console.log(`JSON-RPC running in: http://${address}:${port}`);

// Example of closing the server from another async context
console.log("Closing the server in 60 seconds");
setTimeout(async () => {
  await server.close();
}, 60_000);

// Wait for the server to close before printing a message
await server.afterClosed();
console.log("Server closed");
```

--------------------------------

### Install Hardhat Ignition via NPM

Source: https://hardhat.org/docs/plugins/hardhat-ignition.md

Run this command in your project root to add the plugin as a development dependency.

```bash
npm install --save-dev @nomicfoundation/hardhat-ignition
```

--------------------------------

### TOML Integer Examples for Type Coercion

Source: https://hardhat.org/docs/reference/cheatcodes/external/parse-toml.md

Example TOML values that can be coerced into uint256 using parseTomlUint.

```toml
hexUint = "0x12C980"
stringUint = "115792089237316195423570985008687907853269984665640564039457584007913129639935"
numberUint = 9223372036854775807 # TOML is limited to 64-bit integers
```

--------------------------------

### List Available Hardhat Project Templates

Source: https://hardhat.org/docs/getting-started.md

Run this command to view all available project templates for Hardhat initialization. This helps in selecting the appropriate template for your project needs.

```bash
hardhat --init --templates
```

--------------------------------

### Create HRE with a configuration file

Source: https://hardhat.org/docs/cookbook/programmatic-hre.md

Uses resolveHardhatConfigPath to locate the project configuration and initialize the HRE.

```ts
import {
  createHardhatRuntimeEnvironment,
  resolveHardhatConfigPath,
  importUserConfig,
} from "hardhat/hre";

const configPath = await resolveHardhatConfigPath();
const config = await importUserConfig(configPath);
const hre = await createHardhatRuntimeEnvironment(config, {
  config: configPath,
  // other global options, like network
});
```

--------------------------------

### Initialize Hardhat Project

Source: https://hardhat.org/docs/tutorial/setup.md

Create a new directory and initialize a minimal Hardhat project within it. You will be prompted to select project options, choose 'A minimal Hardhat project' for the project type.

```bash
mkdir hardhat-tutorial
cd hardhat-tutorial
hardhat --init
```

--------------------------------

### network.create() - Choosing a Network Config

Source: https://hardhat.org/docs/reference/network-manager.md

Illustrates how to specify a Network Config by name or within an options object when calling `network.create()`.

```APIDOC
#### Choosing a Network Config

You can also choose a Network Config by providing its name as a string, or as part of its options object:

```ts
// script/with-name-example.ts
import { network } from "hardhat";

const connection = await network.create("localhost");

const connectionWithOptions = await network.create({ network: "localhost" });
```
```

--------------------------------

### Prank Delegate Call and Record State Diffs

Source: https://hardhat.org/docs/reference/cheatcodes/environment/start-prank.md

Example demonstrating how to use startPrank with delegate calls and state diff recording.

```solidity
contract ImplementationTest {
  uint public num;
  address public sender;

  function setNum(uint _num) public {
    num = _num;
  }
}

contract ProxyTest {
  uint public num;
  address public sender;
}

contract CheatcodesIssue is Script {
  function run() public {
    ProxyTest proxy = new ProxyTest();
    ImplementationTest impl = new ImplementationTest();

    vm.label(address(proxy), "proxy");
    vm.label(address(impl), "Impl");

    uint num = 42;
    vm.startPrank(address(proxy), true);
    vm.startStateDiffRecording();
    (bool successTwo, ) = address(impl).delegatecall(
      abi.encodeWithSignature("setNum(uint256)", num)
    );

    Vm.AccountAccess[] memory accountAccesses = vm.stopAndReturnStateDiff();
    console.log("accountAccesses.kind", uint8(accountAccesses[0].kind));
    console.log(
      "accountAccesses.accessor",
      vm.getLabel(accountAccesses[0].accessor)
    );
    console.log(
      "accountAccesses.account",
      vm.getLabel(accountAccesses[0].account)
    );
    console.logBytes(accountAccesses[0].data);
  }
}
```

--------------------------------

### Get Default Wallet Clients

Source: https://hardhat.org/docs/guides/testing/using-viem.md

Demonstrates how to get default wallet clients from the simulated blockchain, which can be used for testing with different accounts.

```typescript
const [defaultWallet, nonOwnerWallet] = await viem.getWalletClients();
```

--------------------------------

### Run commands on console startup

Source: https://hardhat.org/docs/guides/hardhat-console.md

Execute commands automatically when the console starts by passing them as arguments. Ensure each command is wrapped in quotes.

```bash
hardhat console "const { viem } = await network.create();"
```

--------------------------------

### Example Chained Hook Handler

Source: https://hardhat.org/docs/plugin-development/explanations/hooks.md

An example of a Hook Handler for `NetworkHooks#onRequest` that logs a message and passes control to the next handler in the chain.

```typescript
async onRequest(context, networkConnection, jsonRpcRequest, next) {
  console.log(`Request from connection ${networkConnection.id} is being processed — Method: ${jsonRpcRequest.method}`);

  return next(context, networkConnection, jsonRpcRequest);
}
```

--------------------------------

### Verify Plugin Loading with Hardhat Help

Source: https://hardhat.org/docs/tutorial/plugins.md

Run the `hardhat -h` command to confirm that the installed plugin has been successfully loaded and its tasks are available.

```bash
npx hardhat -h
```

--------------------------------

### Example Lazy-loaded Task Action Module

Source: https://hardhat.org/docs/plugin-development/explanations/lifecycle.md

This is an example of the `default` export for a lazy-loaded task action module. It defines the function that will be executed when the task is run.

```typescript
export default async function (
  taskArguments: MyTaskTaskArguments,
  hre: HardhatRuntimeEnvironment,
) {
  console.log(`${hre.config.myConfig.greeting}, ${taskArguments.who}!`);
}
```

--------------------------------

### Start the console without compiling

Source: https://hardhat.org/docs/guides/hardhat-console.md

Use the `--no-compile` flag to skip the project build process before starting the console. This is useful if your contracts have not changed.

```bash
hardhat console --no-compile
```

--------------------------------

### Execute Custom Task

Source: https://hardhat.org/docs/plugin-development/tutorial/task.md

Example of how to run the custom 'my-account' task with a custom title argument from the command line.

```shell
pnpm hardhat my-account --title MiCuenta
MiCuenta
0x70997970c51812dc3a010c7d01b50e0d17dc79c8
```

--------------------------------

### Start Mapping Recording

Source: https://hardhat.org/docs/reference/cheatcodes/environment/start-mapping-recording.md

Use this cheatcode to begin recording all map SSTORE operations. This is useful for debugging and analyzing state changes.

```solidity
function startMappingRecording() external;
```

--------------------------------

### Using loadFixture for efficient test setup

Source: https://hardhat.org/docs/guides/testing/using-ethers.md

Utilize loadFixture to cache the state of the blockchain after a setup function, significantly improving test performance and state management.

```ts
// test/Counter.ts
import { expect } from "chai";
import { network } from "hardhat";

const { ethers, networkHelpers } = await network.create();

describe("Counter", function () {
  async function deployCounterFixture() {
    const counter = await ethers.deployContract("Counter");
    return { counter };
  }

  it("Should emit the Increment event when calling the inc() function", async function () {
    const { counter } = await networkHelpers.loadFixture(deployCounterFixture);

    await expect(counter.inc()).to.emit(counter, "Increment").withArgs(1n);
  });

  it("Should allow the owner to increment and revert for non-owners", async function () {
    const { counter } = await networkHelpers.loadFixture(deployCounterFixture);

    const nonOwnerAddress = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";

    // Impersonate the non-owner account
    await networkHelpers.impersonateAccount(nonOwnerAddress);

    // Fund the non-owner account with some ETH to pay for gas
    await networkHelpers.setBalance(nonOwnerAddress, ethers.parseEther("1.0"));
    const nonOwnerSigner = await ethers.getSigner(nonOwnerAddress);

    // Call inc() as the owner - should succeed
    await expect(counter.inc()).to.emit(counter, "Increment").withArgs(1n);

    // Call inc() as a non-owner - should revert
    await expect(counter.connect(nonOwnerSigner).inc()).to.be.revertedWith(
      "only the owner can increment the counter",
    );
  });
});
```

--------------------------------

### Example script for Hardhat node interaction

Source: https://hardhat.org/docs/guides/hardhat-node.md

This script demonstrates sending a transaction and checking a balance on a Hardhat network. It requires the `hardhat` package and uses the `network` object to create a Viem client.

```typescript
import {
  network
} from "hardhat";

const { viem } = await network.create();
const publicClient = await viem.getPublicClient();
const [wallet] = await viem.getWalletClients();

await wallet.sendTransaction({
  to: "0x0000000000000000000000000000000000000000",
  value: 10n ** 18n,
});

const zeroAddressBalance = await publicClient.getBalance({
  address: "0x0000000000000000000000000000000000000000",
});

console.log(`Balance of zero address: ${zeroAddressBalance}`);
```

--------------------------------

### Install npm dependency with Hardhat

Source: https://hardhat.org/docs/guides/writing-contracts/dependencies.md

Use this command to install an npm package like OpenZeppelin Contracts in your Hardhat project. This is the recommended way to manage external contract code.

```bash
pnpm install "@openzeppelin/contracts"
```

--------------------------------

### Start Hardhat node with a custom chain ID

Source: https://hardhat.org/docs/guides/hardhat-node.md

Starts the Hardhat node with a specific chain ID. This is useful for ensuring compatibility with other networks or for testing specific chain configurations.

```bash
hardhat node --chain-id 123
```

--------------------------------

### Install the migration skill

Source: https://hardhat.org/docs/migrate-from-foundry/guides/migration-skill.md

Use this command to add the Foundry to Hardhat migration skill to your project via an AI agent.

```bash
npx @nomicfoundation/hardhat-skills@latest add migrate-foundry-to-hardhat
```

--------------------------------

### Example Gas Usage Statistics Output

Source: https://hardhat.org/docs/guides/testing/gas-statistics.md

This is an example of the gas usage statistics table generated by Hardhat when the --gas-stats flag is used. It details gas consumption for contract functions and deployments.

```text
╔═══════════════════════════════════════════════════════════════════════════════════════╗
║                                  Gas Usage Statistics                                 ║
╚═══════════════════════════════════════════════════════════════════════════════════════╝
╔═══════════════════════════════════════════════════════════════════════════════════════╗
║ contracts/Calculator.sol:Calculator                                                   ║
╟───────────────────────────────────┬────────┬─────────┬────────┬────────┬──────────────╢
║ Function name                     │ Min    │ Average │ Median │ Max    │ #calls       ║
╟───────────────────────────────────┼────────┼─────────┼────────┼────────┼──────────────╢
║ divide                            │ 44316  │ 44316   │ 44316  │ 44316  │ 1            ║
║ multiply(uint256,uint256)         │ 44254  │ 44254   │ 44254  │ 44254  │ 2            ║
║ multiply(uint256,uint256,uint256) │ 44875  │ 44875   │ 44875  │ 44875  │ 1            ║
║ reset                             │ 21485  │ 21485   │ 21485  │ 21485  │ 1            ║
║ result                            │ 23510  │ 23510   │ 23510  │ 23510  │ 6            ║
║ subtract                          │ 44213  │ 44213   │ 44213  │ 44213  │ 1            ║
╟───────────────────────────────────┼────────┼─────────┼────────┼────────┼──────────────╢
║ Deployment                        │ Min    │ Average │ Median │ Max    │ #deployments ║
╟───────────────────────────────────┼────────┼─────────┼────────┼────────┼──────────────╢
║                                   │ 288115 │ 288115  │ 288115 │ 288115 │ 1            ║
╟───────────────────────────────────┼────────┼─────────┴────────┴────────┴──────────────╢
║ Bytecode size                     │ 2294   │                                          ║
╚═══════════════════════════════════╧════════╧══════════════════════════════════════════╝
╔═══════════════════════════════════════════════════════════════════════════════════════╗
║ contracts/Counter.sol:Counter                                                         ║
╟───────────────────────────────────┬────────┬─────────┬────────┬────────┬──────────────╢
║ Function name                     │ Min    │ Average │ Median │ Max    │ #calls       ║
╟───────────────────────────────────┼────────┼─────────┼────────┼────────┼──────────────╢
║ add(uint256)                      │ 43915  │ 43915   │ 43915  │ 43915  │ 1            ║
║ add(uint256,bool)                 │ 44284  │ 44419   │ 44419  │ 44554  │ 2            ║
║ inc                               │ 43482  │ 43482   │ 43482  │ 43482  │ 1            ║
║ x                                 │ 23466  │ 23466   │ 23466  │ 23466  │ 5            ║
╟───────────────────────────────────┼────────┼─────────┼────────┼────────┼──────────────╢
║ Deployment                        │ Min    │ Average │ Median │ Max    │ #deployments ║
╟───────────────────────────────────┼────────┼─────────┼────────┼────────┼──────────────╢
║                                   │ 234940 │ 234940  │ 234940 │ 234940 │ 1            ║
╟───────────────────────────────────┼────────┼─────────┴────────┴────────┴──────────────╢
║ Bytecode size                     │ 1462   │                                          ║
╚═══════════════════════════════════╧════════╧══════════════════════════════════════════╝
```

--------------------------------

### Get Current Block Number

Source: https://hardhat.org/docs/reference/cheatcodes/environment/get-block-number.md

Use vm.getBlockNumber() to get the current block number. This avoids optimizations where block.number might be treated as a constant within a transaction. It's particularly useful when using vm.roll.

```solidity
function getBlockNumber() external view returns (uint256 height);
```

```solidity
uint256 height = vm.getBlockNumber();
assertEq(height, uint256(block.number));
vm.roll(10);
assertEq(vm.getBlockNumber(), 10);
```

--------------------------------

### Execute a transaction in forking mode

Source: https://hardhat.org/docs/reference/cheatcodes/forking/transact.md

Example demonstrating how to enter forking mode and execute a specific transaction using its hash.

```solidity
// Enter forking mode at block: https://etherscan.io/block/15596646
uint256 fork = vm.createFork(MAINNET_RPC_URL, 15596646);
vm.selectFork(fork);

// a random transfer transaction in the block: https://etherscan.io/tx/0xaba74f25a17cf0d95d1c6d0085d6c83fb8c5e773ffd2573b99a953256f989c89
bytes32 tx = 0xaba74f25a17cf0d95d1c6d0085d6c83fb8c5e773ffd2573b99a953256f989c89;

address sender = address(0xa98218cdc4f63aCe91ddDdd24F7A580FD383865b);
address recipient = address(0x0C124046Fa7202f98E4e251B50488e34416Fc306);

assertEq(sender.balance, 5764124000000000);
assertEq(recipient.balance, 3936000000000000);

// transfer amount: 0.003936 Ether
uint256 transferAmount = 3936000000000000;

// expected balance changes once the transaction is executed
uint256 expectedRecipientBalance = recipient.balance + transferAmount;
uint256 expectedSenderBalance = sender.balance - transferAmount;

// execute the transaction
vm.transact(tx);

// recipient received transfer
assertEq(recipient.balance, expectedRecipientBalance);

// sender's balance decreased by transferAmount and gas
assert(sender.balance < expectedSenderBalance);
```

--------------------------------

### Get Storage Slot Reads and Writes

Source: https://hardhat.org/docs/reference/cheatcodes/environment/accesses.md

Use the accesses cheatcode after calling vm.record() to get all storage slots that have been read or written to on an address. Note that every write also counts as an additional read.

```solidity
/// contract NumsContract {
///     uint256 public num1 = 100; // slot 0
///     uint256 public num2 = 200; // slot 1
/// }

vm.record();
numsContract.num2();
(bytes32[] memory reads, bytes32[] memory writes) = vm.accesses(
  address(numsContract)
);
emit log_uint(uint256(reads[0])); // 1
```

--------------------------------

### POST /cheatcodes/startMappingRecording

Source: https://hardhat.org/docs/reference/cheatcodes/environment/start-mapping-recording.md

Documentation for the startMappingRecording cheatcode used to track map SSTORE operations.

```APIDOC
## startMappingRecording

### Description
Starts recording all map SSTOREs for later retrieval.

### Signature
```solidity
function startMappingRecording() external;
```
```

--------------------------------

### network.create() - No Parameters

Source: https://hardhat.org/docs/reference/network-manager.md

Shows how to create a new NetworkConnection using the `network.create()` method without any parameters, defaulting to the 'default' Network Config.

```APIDOC
### The `network.create()` method

When you call the `network.create()` method, Hardhat creates a new `NetworkConnection` object.

#### Calling it without parameters

The simplest way to create a new `NetworkConnection` is without any parameter:

```ts
// script/no-params-example.ts
import { network } from "hardhat";

const connection = await network.create();
console.log(connection.networkName);
```

By default, this will create a `NetworkConnection` based on the `"default"` Network Config of your Hardhat configuration. This Network Config is always defined, and by default it has an [`edr-simulated` type](/docs/explanations/network-management#edr-simulated-network-configs), so it creates a new blockchain simulation every time it's called.

You can also control which Network Config is used when none is provided by using the `network` [Global Option](/docs/explanations/global-options). For example, running that same script like this will use the `localhost` Network Config:

<Run command="hardhat run script/no-params-example.ts --network localhost" />
```

--------------------------------

### Get Current Block Timestamp

Source: https://hardhat.org/docs/reference/cheatcodes/environment/get-block-timestamp.md

Use this cheatcode to get the current block timestamp. It is particularly useful when `vm.warp` is used with `--via-ir` compilation, as it bypasses potential optimizations that treat `block.timestamp` as a constant within a transaction.

```solidity
function getBlockTimestamp() external view returns (uint256 timestamp);
```

```solidity
assertEq(vm.getBlockTimestamp(), 1, "timestamp should be 1");
vm.warp(10);
assertEq(vm.getBlockTimestamp(), 10, "warp failed");
```

--------------------------------

### Importing the Network Manager

Source: https://hardhat.org/docs/reference/network-manager.md

Demonstrates how to import the Network Manager object from the Hardhat environment.

```APIDOC
## Importing the Network Manager

You can access the Network Manager by importing Hardhat:

```ts
// script/example.ts
import hre from "hardhat";

const networkManager = hre.network;
```

Or you can import it directly:

```ts
// script/example.ts
import { network } from "hardhat";
```
```

--------------------------------

### debug_traceTransaction

Source: https://hardhat.org/docs/reference/json-rpc-methods.md

Get debug traces of already-mined transactions.

```APIDOC
## POST /debug_traceTransaction

### Description
Retrieves debug traces for a given transaction hash.

### Method
POST

### Endpoint
/

### Parameters
#### Request Body
- **method** (string) - Required - The JSON-RPC method name, which is "debug_traceTransaction".
- **params** (array) - Required - An array containing the parameters for the method.
  - **transactionHash** (string) - Required - The hash of the transaction to trace.
  - **traceConfig** (object) - Optional - Configuration for the trace.
    - **disableMemory** (boolean) - Optional - Disables memory tracing. Defaults to false.
    - **disableStack** (boolean) - Optional - Disables stack tracing. Defaults to false.
    - **disableStorage** (boolean) - Optional - Disables storage tracing. Defaults to false.

### Request Example
```json
{
  "method": "debug_traceTransaction",
  "params": [
    "0x123...",
    {
      "disableMemory": true,
      "disableStack": true,
      "disableStorage": true
    }
  ]
}
```

### Response
#### Success Response (200)
- **result** (object) - The trace result.

#### Response Example
```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "gas": 12345,
    "failed": false,
    "error": "",
    "return": "0x...",
    "structLogs": [
      {
        "pc": 0,
        "op": "PUSH1",
        "gas": 1000,
        "gasCost": 3,
        "mem": [],
        "stack": [],
        "storage": {},
        "depth": 1,
        "error": ""
      }
    ]
  }
}
```

### Known limitations
- You can't trace transactions that use a hardfork older than [Spurious Dragon].
- The last step of a message is not guaranteed to have a correct value in the `gasCost` property.
```

--------------------------------

### View All Hardhat Global Options

Source: https://hardhat.org/docs/explanations/global-options.md

Run this command to see a list of all available global options for Hardhat, including those provided by plugins.

```bash
hardhat --help
```

--------------------------------

### Get signers

Source: https://hardhat.org/docs/plugins/hardhat-ethers.md

Retrieve all configured signers or a specific one by address.

```ts
function getSigners(): Promise<ethers.Signer[]>;
```

```ts
const signers = await ethers.getSigners();
```

```ts
function getSigner(address: string): Promise<ethers.Signer>;
```

```ts
const signer = await ethers.getSigner("0x1234...abcd");
```

--------------------------------

### Expect ERC20 Transfer Event (Failing Example)

Source: https://hardhat.org/docs/reference/cheatcodes/assertions/expect-emit.md

This example demonstrates a failing test case where the expected Transfer event is not emitted by the subsequent call. The vm.expectEmit cheat code is configured to expect a Transfer event, but an unrelated approve call is made instead, causing the test to fail.

```solidity
event Transfer(address indexed from, address indexed to, uint256 amount);

function testERC20EmitsTransfer() public {
  // We check that the token is the event emitter by passing the address as the fifth argument.
  vm.expectEmit(true, true, false, true, address(myToken));
  emit MyToken.Transfer(address(this), address(1), 10);

  // We perform an unrelated call that won't emit the intended event,
  // making the cheatcode fail.
  myToken.approve(address(this), 1e18);
  // We perform the call, but it will have no effect as the cheatcode has already failed.
  myToken.transfer(address(1), 10);
}
```

--------------------------------

### parseInt Usage Example

Source: https://hardhat.org/docs/reference/cheatcodes/utilities/parse-int.md

Converts a string representation of an integer into an int256 value.

```solidity
string memory intAsString = "-12345";
int256 stringToInt = vm.parseInt(intAsString); // -12345
```

--------------------------------

### Record storage state changes during a CREATE operation

Source: https://hardhat.org/docs/reference/cheatcodes/environment/stop-and-return-state-diff.md

Demonstrates how to capture account access records during a contract deployment, including storage initialization and balance updates.

```solidity
contract Contract {
    uint256 internal _reserved;
    uint256 public data;
    constructor(uint _data) payable { data = _data; }
}

vm.startStateDiffRecording();
Contract contract = new Contract{value: 1 ether}(100);
Vm.AccountAccess[] memory records = vm.stopAndReturnStateDiff();

assertEq(records.length, 1);
assertEq(records[0].kind, Vm.AccountAccessKind.Create);
assertEq(records[0].account, address(contract));
assertEq(records[0].accessor, address(this));
assertEq(records[0].initialized, true);
assertEq(records[0].oldBalance, 0);
assertEq(records[0].newBalance, 1 ether);
assertEq(records[0].deployedCode, address(contract).code);
assertEq(records[0].value, 1 ether);
assertEq(records[0].data, abi.encodePacked(type(Contract).creationCode, (uint(100))));
assertEq(records[0].reverted, false);

assertEq(records[0].storageAccesses.length, 1);
assertEq(records[0].storageAccesses[0].account, address(contract));
assertEq(records[0].storageAccesses[0].slot, bytes32(uint256(1)));
assertEq(records[0].storageAccesses[0].isWrite, true);
assertEq(records[0].storageAccesses[0].previousValue, bytes32(uint(0)));
assertEq(records[0].storageAccesses[0].newValue, bytes32(uint(100)));
assertEq(records[0].storageAccesses[0].reverted, false);
```

--------------------------------

### Read Environment Variable as Bytes

Source: https://hardhat.org/docs/reference/cheatcodes/external/env-bytes.md

Use this example to read a single environment variable and assert its byte value. Ensure the environment variable is set correctly.

```solidity
bytes memory key = "BYTES_VALUE";
bytes expected = hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D";
bytes output = cheats.envBytes(key);
assertEq(output, expected);
```

--------------------------------

### Execution Logs

Source: https://hardhat.org/docs/reference/cheatcodes/environment/start-prank.md

Console output resulting from the state diff recording example.

```bash
== Logs ==
  accountAccesses.kind 1
  accountAccesses.accessor proxy
  accountAccesses.account Impl
  0xcd16ecbf000000000000000000000000000000000000000000000000000000000000002a
```

--------------------------------

### Typed Artifacts Usage

Source: https://hardhat.org/docs/reference/artifacts.md

Examples of how to use the generated TypeScript types for artifacts.

```APIDOC
## Typed Artifacts

### Description
Hardhat generates TypeScript types for artifacts, allowing for type-safe access to contract data.

### Example: Accessing Artifact Types
```ts
import type { ArtifactMap } from "hardhat/types/artifacts";

type FooUsingBareName = ArtifactMap["Foo"];
type FooUsingFullyQualifiedName = ArtifactMap["contracts/Foo.sol:Foo"];
```

### Example: Reading Artifacts
```ts
import { artifacts } from "hardhat";

const FooArtifact = await artifacts.readArtifact("Foo");
const FooArtifactWithFQN = await artifacts.readArtifact(
  "contracts/Foo.sol:Foo",
);
```

--------------------------------

### Interact with deployed contracts in the console

Source: https://hardhat.org/docs/guides/hardhat-console.md

Example of deploying a contract and interacting with its functions within the Hardhat console. Note the use of `await` for asynchronous operations.

```javascript
> const { viem } = await network.create()
> const counter = await viem.deployContract("Counter")
> await counter.write.inc()
> await counter.read.x()
1n
```

--------------------------------

### GET /cheatcodes/unixTime

Source: https://hardhat.org/docs/reference/cheatcodes/external/unix-time.md

Retrieves the current time since the Unix epoch in milliseconds.

```APIDOC
## unixTime

### Description
Returns the time since unix epoch in milliseconds.

### Signature
`function unixTime() external returns (uint milliseconds);`

### Request Example
```solidity
uint start = vm.unixTime();
```

### Response
- **milliseconds** (uint) - The time elapsed since the Unix epoch in milliseconds.
```
Tokens:
Raw