NomicFoundation/hardhat

Features

• Smart Contract Development Frameworks - Provides a comprehensive toolset for writing, testing, and deploying smart contracts on Ethereum and EVM networks.
• Modules - Creates reusable units of deployment logic representing a sequence of execution steps on the network.
• Web3 and Blockchain Testing - Provides a toolkit for executing unit and integration tests on simulated networks with state snapshots.
• Mining Mode Configurations - Controls block production in simulations through automatic, interval-based, or manual mining triggers.
• Blockchain State Querying - Provides capabilities to retrieve account balances, block headers, and transaction receipts from blockchain networks.
• Blockchain State Snapshots - Provides the ability to capture and restore blockchain state snapshots to optimize test setup.
• Blockchain Local Development Environments - Ships a local blockchain simulation exposed via a JSON-RPC server for development and testing.
• Blockchain Network Emulation - Emulates exact operational characteristics of different blockchains to ensure consistent behavior across networks.
• Contract Artifact Generators - Manages the compilation of Solidity source code into deployable bytecode and ABI artifacts.
• Contract Bindings - Generates type-safe TypeScript bindings for smart contracts to enable autocompletion and safety.
• Contract Deployment Scripts - Provides scripts to automate the deployment of smart contracts to various blockchain networks.
• Existing Contract Bindings - Creates a type-safe interface for an already deployed contract using its name and on-chain address.
• Automated Test Execution - Runs smart contract test suites using compatible runners to verify behavior and correctness.
• Dependency Resolution - Provides a mapping system for resolving contract import paths to source files using native resolution and custom remappings.
• Ethereum Development Environments - Provides a complete toolkit for the full lifecycle of smart contracts on Ethereum and EVM-compatible networks.
• Blockchain Network Forking - Simulates a remote blockchain state locally to interact with live contracts and data without affecting the actual network.
• Plugin Task Definitions - Allows plugins to specify their identity and associated tasks to extend the framework's core functionality.
• Blockchain Network Connections - Provides robust connectivity to live blockchain mainnets and testnets for contract interaction.
• Deployment Lifecycle Managers - Tracks deployment state to recover from errors and resume interrupted executions.
• Smart Contract Deployment Scripts - Triggers custom scripts via the CLI to automate the deployment and interaction process for smart contracts.
• Deployment Orchestration - Manages dependency graphs, batches parallel operations, and monitors transaction confirmations.
• Blockchain State Forks - Creates a local simulation that lazy-loads state from a remote blockchain at a specific block.
• Network Environment Integration - Configures connections to remote JSON-RPC networks and local simulated environments for various EVM chain types.
• Public Network Deployments - Enables pushing compiled smart contracts to multiple live public blockchain networks using RPC URLs.
• Plugin Extensibility - Provides a hook-based plugin system that allows developers to extend core environment capabilities.
• Blockchain Network Simulators - Creates isolated, in-process blockchain environments for controlled state and execution testing.
• Smart Contract Deployment Pipelines - Manages the full deployment lifecycle, including secure release and upgrade management of blockchain contracts.
• Blockchain Integration - Enables seamless interaction and deployment across multiple different blockchain networks.
• EVM Tooling Suites - Offers a comprehensive set of tools for Solidity compilation, transaction simulation, and on-chain debugging.
• VM State Manipulation - Uses cheatcodes to control the execution environment by changing the sender address or modifying blockchain state.
• Smart Contract Compilers - Transforms high-level smart contract source code into executable bytecode for the Ethereum Virtual Machine.
• Smart Contract Instantiation - Instantiates contracts on the blockchain using project artifacts and handles the linking of library addresses.
• Hook-Based Extension Frameworks - Features a hook-based architecture that allows plugins to inject custom logic into predefined execution points of the core system.
• Hook-Based Plugin Systems - Features a hook-based plugin architecture that allows developers to extend core framework behavior.
• Execution Tracing - Displays detailed low-level execution traces during tests and deployments to analyze contract behavior.
• Account State Simulation - Overwrites account balances, nonces, or bytecode to simulate specific user conditions and scenarios.
• Contract Execution Debugging - Analyzes transaction traces and state transitions to identify failures and optimize gas in smart contracts.
• End-to-End Testing - Simulates a full blockchain environment to test complex integrated scenarios and off-chain interactions using TypeScript.
• Storage Slot Manipulation - Writes specific values to precise storage positions of an account to modify blockchain state for testing.
• Transaction Tracing & Debugging - Provides detailed debug traces for mined transactions or simulated call execution within specific blocks.
• Smart Contract Environments - Provides a comprehensive runtime for building, testing, and deploying decentralized application logic in isolated environments.
• Automated Contract Testing Suites - Executes comprehensive test suites written in Solidity, TypeScript, or JavaScript to verify smart contract logic.
• Smart Contract Callers - Offers a comprehensive library for calling smart contract functions and reading blockchain state.
• Deployment Module Hierarchies - Allows organizing smart contract deployments into nested modules to create explicit dependency chains.
• Transaction Effect Tracking - Measures the change in token balances for specific addresses following the execution of a transaction.
• Block Mining - Enables manual production of blocks to precisely control the advancement of the network state.
• Mining Accelerators - Advances the simulated blockchain by a specified number of blocks instantly to test time-dependent logic.
• Blockchain Storage Inspection - Enables deep inspection of raw hexadecimal data stored at specific blockchain addresses and storage indices.
• Gas Consumption Tracking - Calculates minimum, maximum, average, and median gas costs for individual functions during test runs.
• Deployment Journals - Records deployment execution steps in a persistent journal to allow resuming from the last successful state.
• Blockchain Task Automation - Allows defining custom command line tasks and scripts to handle administrative actions and contract interactions.
• Blockchain Transaction Robustness - Automatically resends transactions with updated gas prices and resolves nonce mismatches to ensure delivery.
• Build Profiles - Allows definition of different compilation settings tailored for various development and deployment workflows.
• External Artifact Integration - Deploys or interacts with contracts using custom artifacts for projects not managed within the local environment.
• Compilation Setting Configuration - Manages compiler versions and optimization settings to control the contract compilation process.
• CLI Command Extensions - Allows developers to define custom CLI subcommands with tailored logic and argument parsing.
• Environment Variable Configuration - Controls the behavior of the environment and plugins using command-line arguments and environment variable fallbacks.
• Declarative Deployments - Allows defining desired contract states in modules to automatically determine the optimal execution order.
• Library Linking Automation - Deploys standalone smart contract libraries and automatically links them to other contracts during instantiation.
• Deployed Address Tracking - Maps each successfully executed contract and library to its on-chain address in a persistent file.
• Environment Bootstrapping - Bootstraps the development runtime environment using configuration files or in-memory objects to manage workflows.
• Multichain Workflow Orchestration - Coordinates execution scripts that connect to and interact with multiple different blockchain networks simultaneously.
• Path Aliasing - Loads path aliases to allow smart contracts to resolve dependencies across different toolchains.
• Plugin Dependency Management - Integrates plugins as dependencies to ensure that associated hooks, tasks, and configuration options load in the correct order.
• Runtime Configuration Resolution - Defines settings that are resolved dynamically at runtime instead of being stored statically in config files.
• Source Code Verification - Uploads and verifies contract source code against deployed bytecode on block explorers.
• Task Automation Tools - Provides a programmable task system for automating administrative blockchain actions and data migrations.
• Configuration Resolution - Implements mechanisms to evaluate and resolve environment-specific variable references within configuration files at runtime.
• Multi-Version Compiler Management - Assigns specific compiler versions to individual files to ensure compatibility across different contract requirements.
• Deployment Configuration - Supports injecting configurable values into deployment modules via external JSON files for multi-environment flexibility.
• Deployment Automation - Suppresses interactive prompts to enable fully automated deployment scripts without manual intervention.
• Deployment Parameterization - Passes custom values to deployment modules to control the initial state of deployed contracts.
• Deployment Configuration - Provides configuration for transaction retries, gas fee limits, and confirmation requirements.
• Deployment Simulators - Simulates transactions before execution to detect potential reverts and prevent failed deployments.
• Deployment Artifact Persistence - Stores deployment artifacts in a directory to enable modification and extension of previously executed deployments.
• Deployment Recovery Tools - Tracks missing transactions and wipes deployment futures to resolve errors and allow rerunning.
• Local Blockchain Node Hosting - Starts a local blockchain as a separate process exposing a JSON-RPC interface for external wallets.
• Transaction Management - Monitors pending transactions and automatically resends them with higher fees if not confirmed.
• Deterministic Deployment - Deploys smart contracts to the same address across multiple networks using salts and factory contracts.
• Blockchain RPC Interfaces - Abstracts blockchain communication through a standardized JSON-RPC provider interface.
• CLI Script Execution - Enables the execution of TypeScript or JavaScript scripts to interact with blockchain networks via the CLI.
• Contract Call Type Checking - Provides compile-time type checking for contract method calls to prevent incorrect data types.
• Transaction Signers - Implements utilities for managing cryptographic signing identities and retrieving accounts as signers.
• Account Impersonation - Allows signing transactions as a specific address without the private key to test identity-based interactions.
• Contract Upgradeability - Provides tools to update proxy contracts to new implementations and execute initialization functions.
• Upgradeable Contract Deployment - Supports deploying contracts using the proxy pattern to allow for future logic updates.
• Blockchain Network Parameters - Allows precise control over block gas limits, base fees, and other network-level parameters for simulations.
• Plugin Execution Ordering - Resolves and orders plugins based on explicit and conditional dependencies to ensure correct hook execution sequence.
• Internal Object Extensions - Adds custom properties and logic to core internal objects to provide new functionality to users.
• Plugin-Based Logic Extensions - Allows plugins to create new hook points, enabling developers to customize the internal behavior of the plugins themselves.
• Smart Contract Error Analysis - Detects common smart contract failure patterns and returns descriptive error messages.
• Smart Contract Libraries - Integrates external smart contract libraries via packages or submodules for code reuse.
• Blockchain Parameter Manipulation - Allows setting the coinbase address, minimum gas price, and base fee to control the behavior of the simulated network.
• Contract State Logging - Prints logging messages and contract variables to the terminal during simulation or testing.
• Deployment Status Monitors - Tracks deployment progress, lists active deployment IDs, and retrieves transaction histories.
• Blockchain State Overrides - Allows modifying account balances and storage values to simulate specific user conditions during testing.
• Blockchain Time Manipulation - Provides control over the blockchain timestamp to verify the behavior of time-dependent smart contracts.
• Blockchain Execution Semantics - Emulates specific blockchain operational characteristics, such as those of the OP Stack, to ensure correct behavior.
• Fuzz Testing - Executes test functions repeatedly using random inputs to validate behavior across a wide range of values.
• Gas Consumption Analysis - Calculates gas consumption for contract deployments and function calls and outputs results in a structured table.
• Test Fixture Management - Wraps deployment logic into reusable fixtures that reset the blockchain state between tests.
• Non-Committing Transaction Simulations - Executes a transaction without committing it to the blockchain with the option to override chain state.
• Gas - Tracks gas statistics and calculates code coverage to identify inefficiencies and untested logic.
• VM-Based Fuzzing - Runs tests directly on the virtual machine to facilitate fast execution and property-based fuzzing.
• Code Coverage Reportings - Instruments smart contracts during execution to track exercised lines and generate code coverage reports.
• State Snapshot Fixtures - Resets the environment state to a predefined snapshot using fixtures to avoid expensive redeployments.
• Transaction Revert Validation - Validates that transactions fail as expected and matches the revert reason against specific errors.
• Transaction Log Emissions - Confirms that transactions trigger specific contract events by validating the associated transaction log emissions.
• Contract Type Generators - Generates TypeScript type definitions from smart contract ABIs to ensure call-site safety.
• Deployment State Resets - Clears previous deployment records and restarts the process to resolve incompatible modifications.
• Cross-Chain Simulation Testing - Runs contract tests against simulations of various chain types to ensure cross-network compatibility.
• Toolchain Interoperability - Enables compilation and testing of contracts created with Foundry using directory-scoped remappings.

Star history