Solidity Best Practices: Optimizing Gas Usage

By Robert F4 min readFebruary 18, 2026

Gas optimization is essential not only for reducing costs but also for enhancing the overall user experience. In this article, we will explore several best practices for optimizing gas usage in Solidity, including efficient data types, minimizing storage operations, and leveraging built-in functions. Each section will provide practical code examples to illustrate these concepts effectively.

1. Use Appropriate Data Types

Choosing the right data types can significantly impact gas consumption. Solidity provides various data types, and using smaller types can save gas.

Example: Using Smaller Types

pragma solidity ^0.8.0;

contract GasOptimization {
    // Using uint8 instead of uint256
    uint8 public smallNumber;
    
    function setSmallNumber(uint8 _number) public {
        smallNumber = _number;
    }
}

In this example, uint8 consumes less gas than uint256. When possible, prefer smaller data types to optimize storage costs.

2. Minimize Storage Operations

Storage operations are expensive in terms of gas costs. Reducing the number of times you read from or write to storage can lead to significant savings.

Example: Batch Updates

pragma solidity ^0.8.0;

contract BatchUpdate {
    uint256[] public numbers;

    function addNumbers(uint256[] memory _numbers) public {
        for (uint256 i = 0; i < _numbers.length; i++) {
            numbers.push(_numbers[i]);
        }
    }
}

Instead of updating storage for each number individually, batch updates can reduce the number of storage operations.

3. Use `view` and `pure` Functions

Functions that do not modify the state of the contract can be marked as view or pure. These functions are less costly in terms of gas when called externally.

Example: Using `view` Functions

pragma solidity ^0.8.0;

contract ViewFunction {
    uint256 public storedData;

    function setData(uint256 _data) public {
        storedData = _data;
    }

    function getData() public view returns (uint256) {
        return storedData;
    }
}

The getData function is a view function, which means it can be called without incurring gas costs when invoked externally.

4. Leverage Built-in Functions

Solidity provides several built-in functions that are optimized for gas usage. Using these functions can often be more efficient than writing custom logic.

Example: Using `keccak256`

pragma solidity ^0.8.0;

contract Hashing {
    function hashData(string memory data) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(data));
    }
}

The keccak256 function is optimized for gas usage compared to implementing a custom hashing function.

5. Avoid Redundant Calculations

Recomputing values that do not change can lead to unnecessary gas consumption. Store results of calculations in state variables instead.

Example: Caching Calculated Values

pragma solidity ^0.8.0;

contract Caching {
    uint256 public lastCalculation;
    
    function calculate(uint256 input) public returns (uint256) {
        lastCalculation = input * 2; // Cache the result
        return lastCalculation;
    }
}

By storing the result of the calculation, you avoid redundant computations, saving gas in subsequent calls.

6. Use Events Wisely

Events are useful for logging but can also consume gas. Use them judiciously, especially in loops.

Example: Emitting Events Sparingly

pragma solidity ^0.8.0;

contract EventLogging {
    event DataLogged(uint256 indexed value);

    function logData(uint256[] memory values) public {
        for (uint256 i = 0; i < values.length; i++) {
            // Emit event only for significant data
            if (values[i] > 10) {
                emit DataLogged(values[i]);
            }
        }
    }
}

In this example, events are emitted only for significant values, reducing gas costs associated with unnecessary logging.

7. Optimize Contract Structure

The structure of your contract can also impact gas usage. Grouping related functions and variables can lead to better optimization.

Example: Structuring Contracts

pragma solidity ^0.8.0;

contract OptimizedContract {
    struct User {
        uint256 id;
        string name;
    }

    mapping(address => User) public users;

    function registerUser(uint256 _id, string memory _name) public {
        users[msg.sender] = User(_id, _name);
    }
}

Using a struct to group user data can save gas compared to using multiple mappings or arrays.

Summary of Best Practices

Best Practice	Description
Use Appropriate Data Types	Choose smaller data types to reduce storage costs.
Minimize Storage Operations	Batch updates to reduce gas costs associated with storage.
Use `view` and `pure` Functions	Mark functions that do not modify state to save gas.
Leverage Built-in Functions	Utilize optimized built-in functions instead of custom logic.
Avoid Redundant Calculations	Cache results of calculations to avoid recomputation.
Use Events Wisely	Emit events only when necessary to save gas.
Optimize Contract Structure	Group related functions and variables for better optimization.

By following these best practices, developers can write more efficient Solidity smart contracts, ultimately saving on gas costs and improving user experience.