Solidity gas optimization — storage patterns, calldata, assembly, and before/after comparisons

// UNOPTIMIZED: each variable uses a full 32-byte slot
contract Unoptimized {
    uint256 public amount;    // slot 0 (32 bytes)
    bool public isActive;     // slot 1 (32 bytes for 1 bit!)
    address public owner;     // slot 2 (32 bytes for 20 bytes)
    uint256 public timestamp; // slot 3
    // 4 storage slots = 4 x SSTORE on write
}

// OPTIMIZED: pack variables into fewer slots
contract Optimized {
    uint128 public amount;    // slot 0, first 16 bytes
    uint64 public timestamp;  // slot 0, next 8 bytes
    bool public isActive;     // slot 0, next 1 byte
    // slot 0 is now 25 bytes — fits in one 32-byte slot!
    address public owner;     // slot 1 (20 bytes)
    // 2 storage slots instead of 4 = ~50% gas savings on writes
}

// Gas comparison:
// Unoptimized setAll(): ~89,000 gas (4 SSTORE operations)
// Optimized setAll():   ~47,000 gas (2 SSTORE operations)

The EVM stores data in 32-byte slots. Variables smaller than 32 bytes that are declared consecutively are packed into the same slot. Order your struct fields by size to maximize packing.

// EXPENSIVE: memory copies the entire array
function sumMemory(uint256[] memory values) public pure returns (uint256) {
    uint256 total;
    for (uint256 i = 0; i < values.length; i++) {
        total += values[i];
    }
    return total;
}
// Gas for 100 elements: ~28,500

// CHEAP: calldata reads directly from transaction data
function sumCalldata(uint256[] calldata values) public pure returns (uint256) {
    uint256 total;
    for (uint256 i = 0; i < values.length; i++) {
        total += values[i];
    }
    return total;
}
// Gas for 100 elements: ~23,200 (18% savings)

// Rule: use calldata for read-only external function params
// Use memory only when you need to modify the data

For large arrays, calldata saves significant gas because it avoids copying data to memory. Always use calldata for external function parameters you do not modify.

// UNOPTIMIZED
function processUnoptimized(uint256[] calldata ids) external {
    for (uint256 i = 0; i < ids.length; i++) {    // ids.length read each iteration
        require(ids[i] != 0, "Invalid");           // string error message
        balances[ids[i]] += amounts[ids[i]];       // 2 storage reads per iteration
    }
}

// OPTIMIZED
function processOptimized(uint256[] calldata ids) external {
    uint256 len = ids.length;                      // cache length
    for (uint256 i; i < len; ) {                   // default 0, no i++ overhead
        uint256 id = ids[i];                       // cache in memory
        if (id == 0) revert InvalidId();           // custom error (cheaper)
        unchecked {
            balances[id] += amounts[id];
            ++i;                                   // prefix increment, unchecked
        }
    }
}

// Savings per iteration: ~200-400 gas
// For 1000 iterations: ~200,000-400,000 gas saved

// Custom error vs require string:
error InvalidId();
// revert InvalidId()   costs ~24 gas
// require(..., "Invalid") costs ~180+ gas (string stored in bytecode)

Key optimizations: cache storage reads in local variables, use unchecked blocks for safe arithmetic, prefer custom errors over require strings, and cache array length outside loops.

// Standard Solidity balance check
function getBalance(address account) public view returns (uint256) {
    return balances[account]; // ~2,100 gas (SLOAD)
}

// Assembly version (same result, slightly cheaper)
function getBalanceAsm(address account) public view returns (uint256 result) {
    assembly {
        // Compute storage slot: keccak256(abi.encode(account, slot))
        mstore(0x00, account)
        mstore(0x20, balances.slot)
        result := sload(keccak256(0x00, 0x40))
    }
}

// Where assembly really shines: batch operations
function batchTransfer(
    address[] calldata recipients,
    uint256[] calldata amounts
) external {
    // Solidity version: ~8,000 gas per transfer
    // Assembly version: ~5,000 gas per transfer (37% savings)
    // At 100 transfers: 300,000 gas saved
}

Assembly is dangerous — it bypasses Solidity's safety checks (overflow, bounds, type checking). Only use it when the gas savings justify the added audit complexity. Always have assembly code professionally reviewed.