Solidity Gas Optimization

Overview

When to Apply

• Writing new Solidity smart contracts
• Reviewing or auditing existing contracts
• Optimizing gas costs for deployment or execution
• Refactoring contract storage layouts
• Implementing cross-contract interactions
• Choosing between design patterns (ERC721 vs ERC1155, etc.)

Priority-Ordered Categories

Quick Reference

Critical: Storage Optimization (Apply First)

• Avoid zero-to-one storage writes (costs 22,100 gas)
• Use 1/2 instead of 0/1 for boolean-like values
• Keep minimum balances in ERC20 contracts

// Bad: 3 slots
struct Unpacked {
    uint64 time;      // slot 1
    uint256 amount;   // slot 2
    address user;     // slot 3
}

// Good: 2 slots
struct Packed {
    uint64 time;      // slot 1 (with address)
    address user;     // slot 1
    uint256 amount;   // slot 2
}

// Bad: reads storage twice
function increment() public {
    require(count < 10);
    count = count + 1;
}

// Good: reads storage once
function increment() public {
    uint256 _count = count;
    require(_count < 10);
    count = _count + 1;
}

uint256 constant MAX = 100;        // No storage slot
address immutable owner;           // Set in constructor, no storage

High: Deployment Optimization

// Bad: ~64+ bytes
require(amount <= limit, "Amount exceeds limit");

// Good: ~4 bytes
error ExceedsLimit();
if (amount > limit) revert ExceedsLimit();

// Saves ~200 gas on deployment
constructor() payable {}

• Use EIP-1167 minimal proxies for repeated deployments
• Use UUPS over Transparent Proxy for upgradeable contracts

High: Calldata Optimization

// Bad: copies to memory
function process(bytes memory data) external {}

// Good: reads directly from calldata
function process(bytes calldata data) external {}

• Small negative numbers are expensive (e.g., -1 = 0xffff...)
• Use unsigned integers in function parameters

High: Design Patterns

• Prefer ERC1155 over ERC721 for NFTs (no balanceOf overhead)
• Consider consolidating multiple ERC20s into one ERC1155

• Prefer ECDSA signatures over Merkle trees for allowlists
• Implement ERC20Permit for approve + transfer in one tx

• Consider Solmate/Solady over OpenZeppelin for gas efficiency

Medium-High: Cross-Contract Calls

• Use ERC1363 transferAndCall instead of approve + transferFrom
• Implement multicall for batching operations
• Cache external call results (e.g., Chainlink oracles)

• Use ERC2930 access list transactions to pre-warm storage

Medium: Compiler Optimizations

// Good: unchecked increment, cached length
uint256 len = arr.length;
for (uint256 i; i < len; ) {
    // logic
    unchecked { ++i; }
}

// More efficient bytecode
function calc(uint256 x) pure returns (uint256 result) {
    result = x * 2;
}

// Cheaper: 3 gas
x << 1   // x * 2
x >> 2   // x / 4

// Expensive: 5 gas
x * 2
x / 4

• Place likely-to-fail conditions first in

  &&

• Place likely-to-succeed conditions first in

  ||

Medium: Assembly (Use Carefully)

// Check address(0) with assembly
assembly {
    if iszero(caller()) { revert(0, 0) }
}

// Even/odd check
x & 1  // instead of x % 2

• Reuse scratch space (0x00-0x40) for small operations
• Avoid memory expansion in loops

Avoid: Dangerous Techniques

• Making all functions payable
• Ignoring send() return values
• Using gasleft() for branching
• Manipulating block.number in tests

Outdated Patterns

• "external is cheaper than public" - No longer true
• "!= 0 is cheaper than > 0" - Changed around 0.8.12

References

• references/solidity-gas-guidelines.md

  - Complete guide

• references/rules/

  - Individual patterns by category

grep -l "storage" references/rules/
grep -l "assembly" references/rules/
grep -l "struct" references/rules/

Rule Categories in

references/rules/

• storage-*

  - Storage optimization patterns

• deploy-*

  - Deployment gas savings

• calldata-*

  - Calldata optimization

• design-*

  - Design pattern choices

• crosscall-*

  - Cross-contract call optimization

• compiler-*

  - Compiler optimization patterns

• assembly-*

  - Low-level assembly tricks

Key Principles

1. Always Benchmark - Compiler behavior varies by context and version
2. Balance Readability - Not all optimizations are worth code complexity
3. Test Both Approaches - Counterintuitive optimizations sometimes increase costs
4. Consider

   --via-ir

   - Modern compiler option may obsolete some tricks
5. Use Alternative Libraries - Solmate/Solady often beat OpenZeppelin on gas