Mastering Gas Optimization in Hardhat: A Complete Guide to Using Gas Reporter

Efficient smart contract development on Ethereum and EVM-compatible blockchains demands more than just functional correctness—it requires gas optimization. Every line of Solidity code impacts transaction costs, and inefficient contracts can lead to high user fees and reduced adoption. One of the most powerful tools for identifying and reducing gas consumption is the Hardhat Gas Reporter.

This guide walks you through the complete usage of hardhat-gas-reporter, from installation to advanced optimization strategies, helping you build leaner, faster, and more cost-effective smart contracts.

What Is Gas Reporter?

👉 Discover how real-time gas analytics can transform your development workflow.

The Hardhat Gas Reporter is a plugin that automatically analyzes gas usage during test execution. It provides detailed insights into how much gas each function consumes, enabling developers to:

Quantify function costs: Measure exact gas usage per function call.
Identify inefficiencies: Pinpoint high-consumption operations like storage writes or loops.
Estimate real-world costs: Convert gas into USD or ETH using live price data.

By integrating this tool into your development cycle, you gain visibility into performance bottlenecks before deployment—saving time, money, and improving user experience.

Installing and Configuring Hardhat Gas Reporter

Step 1: Install the Plugin

Run the following command in your Hardhat project:

npm install --save-dev hardhat-gas-reporter

This adds the gas reporter as a development dependency.

Step 2: Update `hardhat.config.js`

Import the plugin and configure its options:

require("hardhat-gas-reporter");

module.exports = {
  solidity: "0.8.20",
  gasReporter: {
    enabled: true,
    currency: "USD",
    gasPrice: 20,
    coinmarketcap: process.env.COINMARKETCAP_KEY,
    outputFile: "gas-report.txt",
    noColors: true,
    excludeContracts: ["MockToken"]
  }
};

Key Configuration Options

Option	Description
`enabled`	Turns the reporter on/off
`currency`	Output cost in USD, ETH, EUR, etc.
`gasPrice`	Sets gas price in Gwei (defaults to network average if not set)
`coinmarketcap`	Uses API key for real-time ETH price (requires environment variable)
`outputFile`	Saves report to a file instead of console
`excludeContracts`	Skips reporting for test-only contracts like mocks

💡 Pro Tip: Store your CoinMarketCap API key securely using dotenv to avoid exposing secrets.

Generating and Reading the Gas Report

Run Tests with Gas Reporting

Execute your test suite normally:

npx hardhat test

After tests complete, the gas reporter outputs a table like this:

·----------------------------|----------------------------|-------------|-------------|-------------·
| Solidity Contract          · Method                     · Min (Gas)   · Max (Gas)   · Avg (Gas)   ·
·----------------------------|----------------------------|-------------|-------------|-------------·
| MyContract                 · transfer                   · 28912       · 51234       · 43210       ·
| MyContract                 · approve                    · 2345        · 2345        · 2345        ·
·----------------------------|----------------------------|-------------|-------------|-------------·
·-------------------------|---------------------------|-------------·
| Network                 · Eth Price (USD)           · Gas Price   ·
·-------------------------|---------------------------|-------------·
| sepolia                 · $1,800                    · 20 Gwei     ·
·-------------------------|---------------------------|-------------·

Interpreting the Results

Method: Name of the function being called.
Min/Max/Avg Gas: Shows gas range across multiple calls—useful for functions with conditional logic.
Eth Price & Gas Price: Used to calculate estimated transaction cost in fiat.
Cost (USD): Automatically computed based on gas used and current prices.

👉 See how top teams reduce gas costs by over 30% using automated analysis tools.

This data allows you to compare versions, track regressions, and validate optimizations.

Core Gas Optimization Strategies

Understanding where gas is spent is only half the battle. Here are proven techniques to cut costs significantly.

1. Minimize Storage Operations

Storage operations (SSTORE, SLOAD) are among the most expensive in Ethereum. Reduce them whenever possible.

Before: Multiple SSTOREs

function updateValue(uint256 newValue) public {
    value = newValue;           // First SSTORE
    lastUpdate = block.timestamp; // Second SSTORE (costly)
}

After: Single Struct Write

struct State {
    uint256 value;
    uint256 lastUpdate;
}
State private state;

function updateValue(uint256 newValue) public {
    state = State(newValue, block.timestamp); // One SSTORE
}

Result: Up to 50% reduction in storage-related gas.

2. Use Constants and Immutables

Variables declared constant or immutable avoid runtime storage reads.

Before: Dynamic Read (SLOAD)

address public owner; // Costs gas to read from storage

After: Compile-Time Value

address public constant OWNER = 0x...; // Zero gas at runtime

Use immutable for values set in the constructor but constant afterward.

3. Pack Variables Efficiently

Ethereum allocates 256 bits per storage slot, so poorly ordered variables waste space.

Inefficient Packing

uint128 a;
uint256 b; // Forces new slot even though 128 bits remain
uint128 c;

Optimized Packing

uint128 a;
uint128 c; // Shares same slot with 'a'
uint256 b; // Uses full slot

This reduces the number of storage slots accessed, lowering both SSTORE and SLOAD costs.

4. Leverage `unchecked` Blocks

When overflow/underflow is impossible, skip safety checks.

With Checks (Default)

function increment(uint256 x) public pure returns (uint256) {
    return x + 1; // Includes overflow check
}

Without Checks (Optimized)

function increment(uint256 x) public pure returns (uint256) {
    unchecked { return x + 1; } // Saves ~30-50 gas per operation
}

Use cautiously—only when logic guarantees safety.

5. Cache Repeated Calculations

Avoid recalculating values within a function.

Before: Redundant Logic

require(a + b > 100);
return (a + b) * 2;

After: Cache Intermediate Result

uint256 sum = a + b;
require(sum > 100);
return sum * 2;

Saves gas by reusing computed values instead of recalculating.

Frequently Asked Questions (FAQ)

Q: Can I use Gas Reporter on local networks?
A: Yes. The reporter works on Hardhat Network, Ganache, and any EVM testnet or mainnet fork.

Q: Does it support other currencies besides USD?
A: Yes. You can set currency: "ETH", "EUR", "JPY", etc., depending on your preference.

Q: Why are my gas numbers different between runs?
A: Variability comes from dynamic state changes, branching logic, or network conditions. Use average values for comparison.

Q: Can I run it without CoinMarketCap API?
A: Yes. Without the API, it will still report gas usage but won’t show USD/ETH conversion rates.

Q: Is it safe to optimize aggressively in production?
A: Always balance optimization with readability and auditability. Over-optimization can introduce bugs.

Q: How often should I run gas reports?
A: Integrate it into CI/CD pipelines—run on every pull request or before major releases.

Final Thoughts

Gas efficiency isn’t an afterthought—it’s a core part of modern smart contract engineering. With Hardhat Gas Reporter, you gain actionable insights into your contract’s economic footprint.

Combine this tool with disciplined coding practices like variable packing, immutable usage, and unchecked math to achieve significant savings. As blockchain usage grows, every unit of gas saved translates directly into better scalability and user adoption.

👉 Start optimizing your next contract with real-time gas insights today.