Gas Optimization

# Gas report for all tests
forge test --gas-report

# Snapshot to compare before/after
forge snapshot
# ...make changes...
forge snapshot --diff

// BAD: ~24,000 gas on revert (stores string in bytecode + memory)
require(amount > 0, "Amount must be greater than zero");

// GOOD: ~24 gas for error selector encoding
error ZeroAmount();
if (amount == 0) revert ZeroAmount();

// BAD: copies entire array to memory (~3 gas per byte + allocation)
function processOrders(Order[] memory orders) external { ... }

// GOOD: reads directly from calldata
function processOrders(Order[] calldata orders) external { ... }

// Gas savings scale with input size:
// 100 bytes: ~600 gas saved
// 1KB:       ~6,000 gas saved
// 10KB:      ~60,000 gas saved

// constant: compile-time value, inlined everywhere. 0 gas for SLOAD.
uint256 public constant MAX_SUPPLY = 10_000;
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name)");

// immutable: set once in constructor, stored in bytecode. 0 gas for SLOAD.
address public immutable FACTORY;
uint256 public immutable DEPLOYMENT_TIMESTAMP;

constructor(address factory) {
    FACTORY = factory;
    DEPLOYMENT_TIMESTAMP = block.timestamp;
}

// Regular storage variable: 2,100 gas (cold) or 100 gas (warm) per SLOAD
address public admin; // avoid if value never changes after deployment

// BAD: overflow checks on every increment
for (uint256 i = 0; i < arr.length; i++) { ... }

// GOOD: i cannot overflow (bounded by array length, which fits in uint256)
for (uint256 i; i < arr.length;) {
    // process arr[i]
    unchecked { ++i; }
}

// BAD: 3 SLOADs for totalSupply
function distribute() external {
    if (totalSupply == 0) revert NoSupply();           // SLOAD 1
    uint256 perToken = rewards / totalSupply;           // SLOAD 2
    emit Distributed(perToken, totalSupply);            // SLOAD 3
}

// GOOD: 1 SLOAD, cached in memory
function distribute() external {
    uint256 supply = totalSupply;                       // SLOAD 1 (cached)
    if (supply == 0) revert NoSupply();
    uint256 perToken = rewards / supply;
    emit Distributed(perToken, supply);
}

// BAD: 3 slots
uint256 amount;     // slot 0
address user;       // slot 1
bool active;        // slot 2

// GOOD: 2 slots
uint256 amount;     // slot 0
address user;       // slot 1 (20 bytes)
bool active;        // slot 1 (packed, +1 byte)

// BAD: expensive SLOAD first
if (balances[msg.sender] > minBalance && isWhitelisted) { ... }

// GOOD: cheap check first, SLOAD only if needed
if (isWhitelisted && balances[msg.sender] > minBalance) { ... }

function batchTransfer(
    IERC20 token,
    address[] calldata recipients,
    uint256[] calldata amounts
) external {
    uint256 len = recipients.length;
    if (len != amounts.length) revert ArrayLengthMismatch();

    for (uint256 i; i < len;) {
        token.safeTransfer(recipients[i], amounts[i]);
        unchecked { ++i; }
    }
}

// BAD: redundant zero init
uint256 counter = 0;
bool flag = false;

// GOOD: default is already zero/false
uint256 counter;
bool flag;

// BAD: dynamic string requires more gas
string public constant NAME = "MyToken";

// GOOD: fixed-size, cheaper to read
bytes32 public constant NAME = "MyToken";

// BAD: computed at runtime every call
function hasRole(string memory role) external view {
    bytes32 hash = keccak256(abi.encodePacked(role));
    ...
}

// GOOD: precomputed constant
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");