Back

How to Test Gas Usage in Ethereum Smart Contracts

Learn how to effectively test and optimize gas usage in Ethereum smart contracts to reduce transaction costs and enhance user experience.

Andre Costa

Published on:

Jun 9, 2025

Blockchain Development

Gas testing helps you measure and reduce the transaction fees your smart contract users pay. Every Ethereum transaction consumes gas, and optimizing gas usage can lower costs, improve user satisfaction, and prevent failed transactions. Here's a quick breakdown of how to test and optimize gas usage effectively:

Why It Matters: Lower gas usage means cheaper transactions, fewer failures, and a better user experience.
Tools You Need: Use tools like Hardhat, Truffle, and eth-gas-reporter to measure and analyze gas consumption.
How to Start: Set up a development environment with Hardhat, install required plugins (like hardhat-gas-reporter), and write gas usage tests.
Advanced Testing: Test with different input sizes, monitor scaling, and analyze gas usage reports to spot inefficiencies.
Optimization Tips: Use cheaper storage operations, batch transactions, and optimize loops to save gas.

How to Calculate Gas Usage in Hardhat

Setting Up Your Development Environment

Preparing your development environment for gas testing involves installing the right tools and configuring them correctly. A proper setup not only simplifies tracking gas consumption but also helps optimize your smart contracts from the start.

Installing and Configuring Hardhat

Hardhat is your go-to development environment for building Ethereum applications. It provides tools to compile, deploy, test, and debug smart contracts.

Start by creating a new project directory and navigating to it in your terminal. Then, install Hardhat using npm (Node Package Manager) with the following command:

npm install --save-dev hardhat

Next, initialize your project:

npx hardhat init

During the setup process, choose "Create an empty hardhat.config.js" to start with a blank configuration. This will generate a hardhat.config.js file in your project’s root directory. You can customize this file later with network settings, private keys, and additional plugins to extend Hardhat's functionality - especially those designed for gas analysis.

Installing Required Dependencies

In addition to Hardhat, you’ll need several other packages to set up a gas testing environment. These dependencies include testing frameworks, blockchain interaction libraries, and tools for gas reporting.

To install the core testing libraries, run:

npm install --save-dev @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai

Here’s what these packages do:

Ethers.js: A modern library for interacting with the Ethereum blockchain.
Waffle and Chai: Provide a testing framework with Ethereum-specific matchers.

For added convenience, you can install the Hardhat Toolbox, which bundles commonly used plugins and tools:

npm install --save-dev @nomicfoundation/hardhat-toolbox

To focus on gas testing, include the hardhat-gas-reporter plugin. Install it with:

npm install -D hardhat-gas-reporter

Once installed, import the gas reporter into your hardhat.config.js file and enable it in the configuration. To generate gas reports during testing, run your tests with the REPORT_GAS environment variable enabled:

REPORT_GAS=true npx hardhat test

Organizing your directories properly ensures a clean workflow, making it easier to manage your tests and configurations.

Hardhat also offers a local Ethereum blockchain for testing. This feature allows you to iterate quickly without incurring real gas fees. With this local network, you can experiment with optimization strategies and measure their impact on gas consumption before deploying to a public test network or the Ethereum mainnet.

"Gas optimization is extremely important to minimize the cost of deployment and gas fees for the end user. The hardhat gas reporter plugin is a great tool to estimate gas in development." - Jake Warren

With your environment set up, you’re ready to write and test for gas consumption. By using Hardhat’s robust tools and gas reporting capabilities, you’ll have everything you need to fine-tune your smart contracts for efficiency.

Basic Gas Usage Testing Methods

Testing the gas consumption of your smart contracts is essential for spotting areas where you can reduce costs and ensuring that your functions operate within acceptable gas limits.

Writing Gas Usage Tests

To measure the gas usage of your functions, create test cases that evaluate how much gas each function consumes. This process not only verifies that your functions stay within acceptable limits but also helps you track changes over time.

Start by adding a test file in your test directory. Use the standard Mocha and Chai testing framework to structure your gas measurement tests:

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Gas Usage Tests", function () {
  let contract;
  let owner;

  beforeEach(async function () {
    [owner] = await ethers.getSigners();
    const Contract = await ethers.getContractFactory("YourContract");
    contract = await Contract.deploy();
    await contract.deployed();
  });

  it("should measure gas usage for function calls", async function () {
    const tx = await contract.yourFunction();
    const receipt = await tx.wait();
    console.log(`Gas used: ${receipt.gasUsed.toString()}`);

    // Assert expected gas limit
    expect(receipt.gasUsed).to.be.below(100000);
  });
});

For more detailed tracking, the hardhat-gas-reporter plugin is a great tool. To enable it, set the REPORT_GAS environment variable before running your tests:

REPORT_GAS=true npx hardhat test

If you're using Windows PowerShell, the command looks slightly different:

$env:REPORT_GAS="true"; npx hardhat test

To test how your functions perform under various conditions, experiment with different scenarios by passing in diverse parameter values. If you want to estimate gas usage without actually executing a transaction, you can use the estimateGas method:

const estimatedGas = await contract.estimateGas.yourFunction();
console.log(`Estimated gas: ${estimatedGas.toString()}`);

Once you've validated gas consumption through tests, you can keep an eye on it during development to catch inefficiencies early.

Monitoring Gas Usage During Development

Real-time monitoring is another way to fine-tune your contracts. By running your code on Hardhat Network - a local Ethereum environment - you can quickly see how changes impact gas usage without deploying to a live network.

Use development scripts to log gas usage as you work:

const { ethers } = require("hardhat");

async function main() {
  const Contract = await ethers.getContractFactory("YourContract");
  const contract = await Contract.deploy();
  await contract.deployed();

  console.log(`Deployment gas used: ${contract.deployTransaction.gasUsed}`);

  // Test function calls and log gas usage
  const tx = await contract.yourFunction();
  const receipt = await tx.wait();
  console.log(`Function call gas used: ${receipt.gasUsed}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

The hardhat-gas-reporter plugin can generate detailed reports, including gas costs in various currencies. As Jake Warren puts it:

"Gas optimization is extremely important to minimize the cost of deployment and gas fees for the end user. The hardhat gas reporter plugin is a great tool to estimate gas in development."

You can toggle the gas reporting feature on or off in your configuration file, making it easy to switch between quick testing and detailed analysis.

For the most accurate results, use dynamic gas estimation. This method adjusts gas predictions based on the contract's current state and input parameters, ensuring your applications remain efficient and functional even as network conditions evolve.

Mastering these foundational techniques will prepare you for more advanced gas analysis methods in the next section.

Advanced Gas Testing and Analysis

Advanced gas analysis techniques allow you to uncover optimization opportunities and pinpoint complex gas consumption patterns in your smart contracts. These methods go beyond basic testing, providing a deeper understanding of how your contracts use resources and how different scenarios impact their efficiency. By leveraging these techniques, you can evaluate contract performance under a variety of conditions and refine your approach for better results.

Using eth-gas-reporter for Detailed Reports

The eth-gas-reporter is a powerful tool for Ethereum test suites, offering detailed insights into gas usage. It tracks metrics like gas consumption per test, method call costs, and deployment expenses in multiple currencies. Essentially, it transforms your test output into actionable data, helping you identify exactly where your contract spends gas.

To integrate eth-gas-reporter into your Hardhat project, follow these steps:

Install the plugin as a development dependency:

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

Add the plugin to your hardhat.config.js file:

require("hardhat-gas-reporter");

module.exports = {
  gasReporter: {
    enabled: process.env.REPORT_GAS !== undefined,
    currency: 'USD',
    gasPrice: 21,
    coinmarketcap: process.env.COINMARKETCAP_API_KEY
  },
  // ... rest of your config
};

Once configured, hardhat-gas-reporter automatically generates gas usage reports every time you run npx hardhat test. These reports break down gas consumption by contract method, deployment costs, and average usage across tests. You can also customize the reports to display costs in different currencies or adjust gas price assumptions based on current network conditions.

Here’s an example of how to structure your tests for maximum insight:

describe("Advanced Gas Analysis", function () {
  let contract;

  beforeEach(async function () {
    const Contract = await ethers.getContractFactory("OptimizedContract");
    contract = await Contract.deploy();
    await contract.deployed();
  });

  it("should analyze gas usage for batch operations", async function () {
    // Test single operation
    await contract.singleOperation(100);

    // Test batch operation
    await contract.batchOperation([100, 200, 300]);
  });

  it("should compare gas usage across different data types", async function () {
    await contract.processUint256(12345);
    await contract.processBytes32("0x1234567890abcdef");
    await contract.processString("test data");
  });
});

Testing Gas Usage with Different Input Sizes

With detailed reports in hand, you can examine how gas consumption scales with varying input sizes. This is crucial for predicting how your contract will perform and what it will cost in real-world scenarios. By testing with different inputs, you can identify inefficiencies and address them before deployment.

Here’s how to create comprehensive test cases for input scaling:

describe("Gas Scaling Analysis", function () {
  let contract;

  beforeEach(async function () {
    const Contract = await ethers.getContractFactory("ScalableContract");
    contract = await Contract.deploy();
    await contract.deployed();
  });

  it("should assess array processing across multiple input sizes", async function () {
    const sizes = [1, 10, 50, 100, 500];

    for (const size of sizes) {
      const testArray = Array(size).fill().map((_, i) => i + 1);
      const tx = await contract.processArray(testArray);
      const receipt = await tx.wait();

      console.log(`Array size ${size}: ${receipt.gasUsed} gas`);

      // Set a reasonable gas limit based on array size
      const expectedMaxGas = 21000 + (size * 1000);
      expect(receipt.gasUsed).to.be.below(expectedMaxGas);
    }
  });

  it("should analyze string processing efficiency", async function () {
    const testStrings = [
      "short",
      "medium length string for testing",
      "very long string that contains much more data and should consume significantly more gas during processing operations"
    ];

    for (const testString of testStrings) {
      const tx = await contract.processString(testString);
      const receipt = await tx.wait();

      console.log(`String length ${testString.length}: ${receipt.gasUsed} gas`);
    }
  });
});

Focus your tests on scenarios that mirror how your contract will be used. For instance, if your contract processes user-generated content, test with typical data sizes users might submit. For financial contracts, experiment with diverse transaction amounts and frequencies.

Functions that handle dynamic data structures like arrays, mappings, or strings deserve special attention. These operations often show non-linear gas scaling - doubling the input size might more than double the gas consumption.

According to research, 52.75% of contracts contain at least one gas-inefficient pattern, and eliminating these inefficiencies can save developers at least $0.30 per contract. By running systematic tests with varying input sizes, you can spot and fix these patterns, reducing costs and improving performance.

You can also automate tests to simulate different network conditions and gas prices. This helps you better understand how your contract behaves and ensures you set appropriate gas limits while providing users with accurate cost estimates.

Best Practices for Gas Optimization

Building on insights from gas testing, these practices focus on improving smart contract efficiency. By identifying gas usage patterns and applying targeted strategies, you can reduce costs while maintaining security.

Optimizing Smart Contract Design

Storage operations are significantly more expensive than memory operations. For instance, memory operations like mload and mstore cost just 3 gas units, while storage operations such as sload and sstore require at least 100 gas units.

To save gas, pack variables into fewer storage slots - this can reduce costs by up to 20,000 gas units per slot. Choosing fixed-size data types (e.g., bytes32 instead of string) and favoring mappings over arrays can also lead to meaningful savings. Keep in mind that the Ethereum Virtual Machine (EVM) automatically converts smaller types like uint8 to uint256, which can impact gas usage.

Leverage constant and immutable for values that don’t change. These modifiers not only reduce deployment costs but can cut creation expenses by up to 71%. Additionally, using private variables alongside these modifiers can further optimize your contract.

Beyond the design phase, minimizing on-chain operations is another critical step for gas efficiency.

Reducing On-Chain Operations

Reducing on-chain computations can make a big difference. For example, batching transactions or offloading computations to Layer 2 solutions can cut gas fees by 80–99%.

When passing read-only function parameters, use calldata instead of memory. This avoids unnecessary data copying and improves gas efficiency by approximately 35%. Similarly, external function calls are costly, so it’s better to combine multiple operations into a single transaction whenever possible.

Loops are another area to watch closely. Avoid placing complex operations inside loops, and use memory for intermediate calculations instead of repeatedly accessing storage. Fixed-size loops and deferring computations until absolutely necessary can also help.

For arithmetic operations, the unchecked keyword can save gas by skipping overflow and underflow checks, provided you’re confident these issues won’t arise. Additionally, precompiled contracts for encryption or hashing are highly efficient and can further lower gas costs.

Once your design and operations are optimized, testing variations in your code can uncover even more savings.

Gas-Focused Mutation Testing

Gas-focused mutation testing involves tweaking your code to find more efficient implementations without altering functionality. For example, comparing inheritance versus composition has shown that inheritance can cut gas usage by 40%. Similarly, reorganizing variables - such as packing them efficiently - can reduce contract creation costs by 15%.

Removing unused code and functions is another simple yet effective way to lower deployment costs, as every extra element adds to the gas fee. Enabling the Solidity compiler optimizer can also help streamline complex expressions, reducing both code size and execution costs.

However, it’s crucial to ensure that gas-saving techniques don’t compromise your contract’s security. Every optimization must be rigorously tested to confirm it doesn’t introduce vulnerabilities or alter the intended behavior.

Conclusion and Next Steps

Key Takeaways

Optimizing gas usage in Ethereum smart contracts is a game-changer for blockchain development. This guide has shown how effective gas testing can streamline your processes and cut costs.

The main takeaway? Gas optimization isn’t just about saving money - it’s about boosting the overall performance of your contracts. Lower transaction fees, fewer failures, and improved network efficiency are all direct benefits. For example, storage operations are over 100 times more expensive than memory operations, making every optimization decision critical.

But the impact goes beyond immediate savings. By reducing on-chain storage and fine-tuning processing, you’re setting your applications up for long-term success. Optimized contracts can handle growing user demand without pricing people out, ensuring scalability and sustainability.

The strategies covered here - like using Hardhat’s gas reporting tools and eth-gas-reporter - help you catch inefficiencies early in the development cycle, when fixes are easier and cheaper. Regular monitoring ensures your contracts stay efficient as they evolve, making these practices essential for any scalable blockchain project.

How My Web3 Startup Can Help

Applying these insights effectively often requires expert guidance, and that’s where My Web3 Startup comes in.

With experience delivering over 127 Web3 projects - including NFT platforms, staking DApps, and blockchain-based games - we’ve seen how gas testing and optimization can directly influence a project’s success. Our team specializes in spotting inefficiencies and vulnerabilities in smart contracts, offering detailed reports and actionable fixes to enhance performance.

Our services go beyond analysis. Through our Web3 security audits, we ensure that gas savings don’t come at the expense of security. Every optimization is carefully reviewed to maintain your contract’s functionality while lowering costs.

For startups aiming to build efficient applications from scratch, our MVP development services can have your optimized smart contracts ready in less than six weeks. We integrate gas testing and optimization at every stage, so your application launches with minimal transaction costs and maximum scalability.

Whether you’re looking for a free consultation or full development support, we’re here to help you build blockchain applications that are both cost-effective and scalable. Let’s work together to optimize your smart contracts for better performance and profitability. Reach out today to learn more!

FAQs

What are the common reasons for high gas usage in Ethereum smart contracts?

High gas consumption in Ethereum smart contracts often stems from storage-heavy operations, complex calculations, and poorly designed data structures. For instance, adding new variables to on-chain storage is costly, with each operation consuming 20,000 gas. In contrast, updating existing variables requires 5,000 gas. To cut down on these expenses, developers can reduce their reliance on on-chain storage and use memory whenever feasible.

Another contributor to high gas fees is complicated logic, like frequent interactions with other contracts or resource-intensive computations. Developers can address this by using optimized storage types, immutable variables, and constants, which help streamline contract execution. By applying these strategies, smart contracts can remain functional while keeping gas costs under control.

How does the hardhat-gas-reporter plugin help optimize gas usage in smart contracts?

The hardhat-gas-reporter plugin is an essential tool for developers working with Ethereum smart contracts. It provides detailed breakdowns of gas usage for every function and deployment, making it easier to identify where optimizations are needed.

What sets this plugin apart is its ability to translate gas costs into USD ($). This feature offers a clear view of the actual financial implications of your contract's operations. With this insight, developers can make informed choices to minimize gas fees, resulting in smarter, more cost-efficient contracts.

Why is it important to test gas usage with different input sizes in Ethereum smart contracts, and how does it improve efficiency?

Testing how gas usage changes with different input sizes is a key step in fine-tuning Ethereum smart contracts. It gives developers a clear picture of how gas consumption grows as inputs vary, helping them pinpoint inefficiencies and refine their code. The result? Lower transaction costs - paid in ETH - and better performance across a range of scenarios.

Using gas efficiently doesn’t just save money for users; it also boosts the scalability and dependability of decentralized applications (dApps). By keeping gas consumption low, developers can deliver smoother user experiences, handle more transactions, and improve how their smart contracts function overall. This is a critical step in crafting blockchain solutions that are both powerful and cost-efficient.