Understanding Gas Optimization in Ethereum Smart Contracts

Introduction

Gas is the lifeblood of Ethereum. Every operation you perform on the blockchain costs gas, and users must pay for it. If your smart contracts aren't optimized, you're essentially wasting your users' money and making your dApp less competitive.

In this comprehensive guide, I'll walk you through the most important gas optimization techniques that can reduce your contract's execution costs by up to 70%.

What is Gas? 🛢️

Gas is a unit that measures the computational effort required to execute operations on Ethereum. Each operation (storage write, computation, function call) consumes a specific amount of gas.

Why does this matter?

Users pay for gas with ETH
Higher gas costs = less adoption
Optimized contracts = better user experience
Savings compound at scale

1. Use Efficient Data Types

Problem: Storing Data Inefficiently

// ❌ BAD: Uses more storage slots
pragma solidity ^0.8.0;

contract Inefficient {
    uint256 userCount;      // 32 bytes (1 slot)
    uint256 maxUsers;       // 32 bytes (1 slot)
    bool isActive;          // 1 byte (1 slot) - WASTED SPACE!
    uint256 balance;        // 32 bytes (1 slot)
}

Solution: Pack Your Variables

// ✅ GOOD: Packs variables into single storage slots
pragma solidity ^0.8.0;

contract Optimized {
    uint128 userCount;      // 16 bytes
    uint128 maxUsers;       // 16 bytes
    bool isActive;          // 1 byte   } All fit in ONE
    address owner;          // 20 bytes } 32-byte slot!
}

Storage Cost Reduction: 4 slots → 1 slot = 75% savings

Key Insight:

Solidity packs variables into 32-byte slots from right to left. Order variables by size (largest first) to minimize wasted space.

// ✅ BEST: Optimal ordering
pragma solidity ^0.8.0;

contract MostOptimized {
    address owner;           // 20 bytes
    uint96 balance;          // 12 bytes
    uint32 lastUpdate;       // 4 bytes   } All in ONE slot
    bool isActive;           // 1 byte    }

    uint256 largeNumber;     // 32 bytes (own slot)
}

2. Minimize Storage Writes ✍️

Storage operations are the most expensive operations in Solidity. Reading costs 2,100 gas, but writing costs 20,000 gas initially.

Problem: Multiple Storage Writes

// ❌ BAD: Multiple storage writes in loop
pragma solidity ^0.8.0;

contract BadLoop {
    uint256 public totalSupply;

    function batchMint(uint256 count) external {
        for (uint256 i = 0; i < count; i++) {
            totalSupply++; // 20,000 gas per write!
        }
    }
}

Cost: 100 mints = 2,000,000 gas 😱

Solution: Use Memory Variables

// ✅ GOOD: Use memory, write once
pragma solidity ^0.8.0;

contract GoodLoop {
    uint256 public totalSupply;

    function batchMint(uint256 count) external {
        uint256 _totalSupply = totalSupply; // Read once
        _totalSupply += count;              // Cheap memory operation
        totalSupply = _totalSupply;         // Write once
    }
}

Cost: 100 mints = ~44,000 gas 🚀

Gas Saved: ~1,956,000 gas (97.8% reduction!)

3. Use Events Instead of Storage

Events are 10-50x cheaper than storing data.

Problem: Storing Historical Data

// ❌ BAD: Storing every transfer in array
pragma solidity ^0.8.0;

contract BadHistory {
    struct Transfer {
        address from;
        address to;
        uint256 amount;
        uint256 timestamp;
    }

    Transfer[] public transfers; // Storage costs 20k+ per write

    function transfer(address to, uint256 amount) external {
        transfers.push(Transfer(msg.sender, to, amount, block.timestamp));
        // Very expensive!
    }
}

Solution: Emit Events

// ✅ GOOD: Use events for logging
pragma solidity ^0.8.0;

contract GoodHistory {
    event Transfer(
        indexed address from,
        indexed address to,
        uint256 amount,
        uint256 timestamp
    );

    function transfer(address to, uint256 amount) external {
        emit Transfer(msg.sender, to, amount, block.timestamp);
        // ~375 gas vs 20,000+ for storage
    }
}

Gas Cost:

Event: ~375 gas
Storage: 20,000+ gas
Savings: 98% cheaper ✨

4. Optimize Function Visibility

Problem: Unnecessary External Calls

// ❌ BAD: Calling internal functions externally
pragma solidity ^0.8.0;

contract BadVisibility {
    uint256 public data;

    function updateData(uint256 newValue) public {
        _processData(newValue);
    }

    function _processData(uint256 value) public { // Should be internal!
        data = value;
    }
}

// Calling it externally costs extra
// contract.updateData(100);  // Expensive path
// contract._processData(100); // Even worse - creates new context

Solution: Use Correct Visibility

// ✅ GOOD: Correct visibility modifiers
pragma solidity ^0.8.0;

contract GoodVisibility {
    uint256 public data;

    function updateData(uint256 newValue) external {
        _processData(newValue); // Cheap internal call
    }

    function _processData(uint256 value) internal { // Much better!
        data = value;
    }
}

Tip: Use external instead of public when not calling internally.

5. Use Mapping Instead of Arrays for Lookups

Problem: Array Iteration

// ❌ BAD: O(n) lookup time, expensive
pragma solidity ^0.8.0;

contract BadLookup {
    address[] public users;

    function isUserRegistered(address user) external view returns (bool) {
        for (uint256 i = 0; i < users.length; i++) {
            if (users[i] == user) return true;
        }
        return false;
    }
}

Solution: Use Mapping

// ✅ GOOD: O(1) lookup, instant
pragma solidity ^0.8.0;

contract GoodLookup {
    mapping(address => bool) public isRegistered;

    function registerUser(address user) external {
        isRegistered[user] = true;
    }

    function checkUser(address user) external view returns (bool) {
        return isRegistered[user]; // O(1) instant lookup
    }
}

Performance:

Array: 100 users = 100 storage reads
Mapping: 100 users = 1 storage read
Savings: 100x faster ⚡

6. Avoid Expensive Operations

Problem: Unnecessary Computations

// ❌ BAD: Expensive operations
pragma solidity ^0.8.0;

contract ExpensiveOps {
    function inefficientMath(uint256 a, uint256 b) external pure returns (uint256) {
        // Expensive operations
        uint256 result = a ** 2 + b ** 2; // Exponentiation is expensive
        for (uint256 i = 0; i < 10; i++) {
            result = result * 2 / 3; // Multiple expensive ops
        }
        return result;
    }
}

Solution: Optimize Calculations

// ✅ GOOD: Optimized math
pragma solidity ^0.8.0;

contract EfficientOps {
    function efficientMath(uint256 a, uint256 b) external pure returns (uint256) {
        // Pre-calculate or use bit shifts
        uint256 result = (a * a) + (b * b); // Multiplication cheaper than exponentiation
        result = (result * 1024) / 1536;    // Bit operations are cheaper
        return result;
    }
}

Cost Reduction Tactics:

✅ Use multiplication instead of exponentiation
✅ Use bit shifts instead of division by powers of 2
✅ Cache computed values
✅ Avoid unnecessary loops

7. Use Immutable and Constant Variables

Problem: Reading State Variables Multiple Times

// ❌ BAD: Reading storage multiple times
pragma solidity ^0.8.0;

contract BadConstants {
    address public owner = msg.sender;
    uint256 public maxSupply = 1000000;

    function checkOwner() external view returns (bool) {
        if (msg.sender == owner) { // Storage read 1: 2,100 gas
            if (msg.sender == owner) { // Storage read 2: 2,100 gas
                return true;
            }
        }
        return false;
    }
}

Solution: Use Immutable and Constant

// ✅ GOOD: Use immutable for write-once values
pragma solidity ^0.8.0;

contract GoodConstants {
    address immutable owner;
    uint256 constant MAX_SUPPLY = 1000000;

    constructor() {
        owner = msg.sender;
    }

    function checkOwner() external view returns (bool) {
        if (msg.sender == owner) { // No storage read! Embedded in bytecode
            return true;
        }
        return false;
    }
}

Difference:

constant: 21 gas (embedded in bytecode)
immutable: 21 gas (after constructor)
state variable: 2,100 gas

Savings: 100x cheaper 🎯

8. Batch Operations

Problem: Multiple Transactions

// ❌ BAD: Multiple function calls
// User calls transfer 10 times = 10 separate transactions
// Each transaction pays for initialization overhead

Solution: Batch in Single Function

// ✅ GOOD: Batch operation
pragma solidity ^0.8.0;

interface IERC20 {
    function transfer(address to, uint256 amount) external returns (bool);
}

contract BatchTransfer {
    IERC20 token;

    function batchTransfer(
        address[] calldata recipients,
        uint256[] calldata amounts
    ) external {
        require(recipients.length == amounts.length, "Mismatch");

        for (uint256 i = 0; i < recipients.length; i++) {
            token.transfer(recipients[i], amounts[i]);
        }
        // One transaction, one initialization cost
    }
}

Savings: Reduces transaction overhead by 90% for batch operations

9. Use Calldata for Large Data

Problem: Memory Allocation Overhead

// ❌ BAD: Unnecessary memory copies
pragma solidity ^0.8.0;

contract BadMemory {
    function processArray(uint256[] memory data) external pure returns (uint256) {
        // 'memory' keyword copies calldata to memory (expensive!)
        uint256 sum = 0;
        for (uint256 i = 0; i < data.length; i++) {
            sum += data[i];
        }
        return sum;
    }
}

Solution: Use Calldata When Not Modifying

// ✅ GOOD: Use calldata for read-only data
pragma solidity ^0.8.0;

contract GoodMemory {
    function processArray(uint256[] calldata data) external pure returns (uint256) {
        // 'calldata' directly reads from transaction data (cheap!)
        uint256 sum = 0;
        for (uint256 i = 0; i < data.length; i++) {
            sum += data[i];
        }
        return sum;
    }
}

Memory cost: Quadratic (16 gas + 3 gas per word)
Calldata cost: Linear

10. Check Arguments Early (Fail Fast)

Problem: Wasting Gas Before Reverting

// ❌ BAD: Expensive operations before validation
pragma solidity ^0.8.0;

contract BadValidation {
    function transfer(address to, uint256 amount) external {
        // Expensive operation first
        uint256 result = amount * 1000;

        // Validation after (gas wasted if this fails!)
        require(to != address(0), "Invalid address");
        require(amount > 0, "Amount must be > 0");
    }
}

Solution: Validate First

// ✅ GOOD: Validate before expensive operations
pragma solidity ^0.8.0;

contract GoodValidation {
    function transfer(address to, uint256 amount) external {
        // Validation first (cheap operations)
        require(to != address(0), "Invalid address");
        require(amount > 0, "Amount must be > 0");

        // Expensive operation after (only if valid)
        uint256 result = amount * 1000;
    }
}

Benefit: Users don't pay for failed operations

Gas Optimization Checklist ✅

Use this checklist when optimizing your contracts:

[ ] Pack storage variables - Order by size, use smaller types
[ ] Minimize storage writes - Use memory for temporary values
[ ] Use events - Instead of storing historical data
[ ] Correct visibility - external over public for non-internal calls
[ ] Use mappings - Instead of arrays for lookups
[ ] Avoid expensive operations - No exponentiation, unnecessary loops
[ ] Use constants/immutable - For fixed values (100x cheaper)
[ ] Batch operations - Combine multiple actions
[ ] Use calldata - For read-only arrays (not memory)
[ ] Validate early - Check arguments before expensive operations
[ ] Cache values - Store frequently accessed data in memory

Real-World Example: Token Contract Optimization

Before Optimization

// ❌ UNOPTIMIZED
pragma solidity ^0.8.0;

contract MyToken {
    string public name;
    string public symbol;
    uint256 public totalSupply;
    uint256 public decimals;

    mapping(address => uint256) public balances;
    mapping(address => mapping(address => uint256)) public allowances;

    address[] public holders; // Array of all holders

    function transfer(address to, uint256 amount) public {
        require(amount > 0);
        require(balances[msg.sender] >= amount);

        balances[msg.sender] = balances[msg.sender] - amount;
        balances[to] = balances[to] + amount;

        // Store transfer history
        transfers.push(Transfer(msg.sender, to, amount));
    }
}

After Optimization

// ✅ OPTIMIZED
pragma solidity ^0.8.0;

contract MyTokenOptimized {
    string constant name = "My Token";
    string constant symbol = "MTK";
    uint8 constant decimals = 18;
    uint256 public totalSupply;

    mapping(address => uint256) public balances;
    mapping(address => mapping(address => uint256)) public allowances;

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

    function transfer(address to, uint256 amount) external {
        require(amount > 0, "Amount must be > 0");
        require(to != address(0), "Invalid address");
        require(balances[msg.sender] >= amount, "Insufficient balance");

        uint256 senderBalance = balances[msg.sender]; // Cache in memory
        senderBalance -= amount;
        balances[msg.sender] = senderBalance; // Single write
        balances[to] += amount;

        emit Transfer(msg.sender, to, amount); // Event instead of storage
    }
}

Gas Savings: ~60-70% per transaction 🚀

Tools for Gas Analysis

1. Hardhat Gas Reporter

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

2. Solidity Optimizer

Enable in hardhat.config.js:

solidity: {
    version: "0.8.0",
    settings: {
        optimizer: {
            enabled: true,
            runs: 200
        }
    }
}

3. Etherscan Gas Tracker

Check real costs on etherscan.io/gastracker

Key Takeaways 🎓

Storage is expensive - Use memory for temporary values
Pack your variables - Fit multiple values into single storage slots
Use events - For logging and history tracking
Optimize data structures - Mappings over arrays for lookups
Cache values - Read from storage once, use in memory
Constants/Immutable - Use for fixed values (100x cheaper)
Batch operations - Reduce transaction overhead
Validate early - Check arguments before expensive operations

Conclusion

Gas optimization isn't just about saving money—it's about building better user experiences and making your DApps competitive. Every gas unit you save multiplies across thousands of users.

Start with the low-hanging fruit (storage packing, caching, events), then profile your contracts to find the biggest savings opportunities.

Your users will thank you. 🙏

Resources

What's Your Experience?

Have you optimized gas in your smart contracts? Share your biggest gas-saving wins in the comments below! What techniques have worked best for you? 👇

Let's build efficient Web3 together! 🚀

Connect with me:

Understanding Gas Optimization in Ethereum Smart Contracts

Understanding Gas Optimization in Ethereum Smart Contracts

Introduction

What is Gas? 🛢️

1. Use Efficient Data Types

Problem: Storing Data Inefficiently

Solution: Pack Your Variables

Key Insight:

2. Minimize Storage Writes ✍️

Problem: Multiple Storage Writes

Solution: Use Memory Variables

3. Use Events Instead of Storage

Problem: Storing Historical Data

Solution: Emit Events

4. Optimize Function Visibility

Problem: Unnecessary External Calls

Solution: Use Correct Visibility

5. Use Mapping Instead of Arrays for Lookups

Problem: Array Iteration

Solution: Use Mapping

6. Avoid Expensive Operations

Problem: Unnecessary Computations

Solution: Optimize Calculations

7. Use Immutable and Constant Variables

Problem: Reading State Variables Multiple Times

Solution: Use Immutable and Constant

8. Batch Operations

Problem: Multiple Transactions

Solution: Batch in Single Function

9. Use Calldata for Large Data

Problem: Memory Allocation Overhead

Solution: Use Calldata When Not Modifying

10. Check Arguments Early (Fail Fast)

Problem: Wasting Gas Before Reverting

Solution: Validate First

Gas Optimization Checklist ✅

Real-World Example: Token Contract Optimization

Before Optimization

After Optimization

Tools for Gas Analysis

1. Hardhat Gas Reporter

2. Solidity Optimizer

3. Etherscan Gas Tracker

Key Takeaways 🎓

Conclusion

Resources

What's Your Experience?

Tags

Author

Stats

Published

You Might Also Like

Ethereum cryptography from a Go dev's view

Five Ways DeFi Tax Software Silently Produces Wrong Numbers

5 Errors I Hit Building DeFi Bots (And How to Fix Them)

Building a DeFi Staking Platform with Solidity, Foundry, and Next.js on Ethereum Sepolia

CCTP V1 vs V2: The Nonce Mismatch That Breaks Cross-Chain Arrival Checks

What an ERC-4626 price test actually shows