Gas Optimization

The practice of efficiently storing multiple smaller-sized state variables (like uint8, bool) within a single 256-bit storage slot. Storage in Ethereum is optimized for 256-bit words, and packing variables reduces the number of expensive SSTORE operations.

• Example: Four uint64 variables can be packed into one slot.
• Key Benefit: Saves ~20,000 gas per unused storage slot.

Declaring variables as immutable (for constructor-set values) or constant (for compile-time fixed values) stores them directly in the contract bytecode instead of expensive storage.

• constant: Value is fixed at compile time (e.g., uint256 public constant DECIMALS = 18;).
• immutable: Value is assigned once in the constructor and then is immutable.
• Gas Impact: Reading an immutable or constant costs only 5-10 gas, versus 2,100+ gas for a storage read.

Choosing the correct data location for function parameters and variables. For external functions, use calldata for read-only array/struct parameters instead of memory.

• calldata: A non-modifiable, non-persistent area where function arguments are stored. Using it avoids copying data to memory.
• Use Case: function process(bytes calldata data) is cheaper than function process(bytes memory data).
• Rule: Use memory only if you need to modify the variable within the function.

Using the unchecked { ... } block to bypass Solidity's default overflow/underflow checks for arithmetic operations where safety is otherwise guaranteed, saving ~30-40 gas per operation.

• When to Use: In loops where the index is guaranteed not to overflow, or after math where you've manually checked bounds.
• Example: unchecked { i++; } inside a bounded loop.
• Critical: Never use unchecked for user-controlled inputs without prior validation.

Reducing the number of calls to external contracts and optimizing the data passed. Each external call incurs at least 2,600+ gas for the CALL opcode and more for data transfer.

• Batch Calls: Aggregate multiple operations into a single call.
• Use Low-Level Calls: For simple value transfers, address.send() or address.call{value:}() can be cheaper than a full contract call.
• Cache External Data: Store frequently accessed external data in a local variable.

Optimizing event emissions by using indexed parameters wisely and minimizing non-indexed data. Events are stored in logs, not storage, but still cost gas (8 gas per byte + topic costs).

• Indexed Parameters (indexed): Up to three parameters can be indexed for efficient off-chain filtering, but they cost 375 gas each as a topic.
• Non-Indexed Data: Stored as cheaper data in the log.
• Strategy: Index fields you will filter by (like addresses), pack small data into bytes or uint256.

Tools that analyze transaction execution to identify gas-intensive operations. They are essential for empirical optimization.

• Hardhat & Foundry: Provide built-in gas reporters that output a detailed breakdown of gas used per function call during tests.
• Ethereum Execution Layer Traces: Using debug_traceTransaction or tools like Tenderly to visualize the exact opcode-level gas consumption of a live transaction.
• Gas Snapshots: Tracking gas usage changes between code versions to prevent regressions.

Common coding patterns that significantly impact gas costs.

Optimization Patterns:

• Packing Variables: Combining multiple uints into a single storage slot.
• Using immutable & constant: For values known at compile-time or construction.
• Calldata over Memory: For external function parameters that are read-only.
• Early Checks & Failures: Using require() statements at the start of functions.

Costly Anti-Patterns:

• Looping over unbounded arrays.
• Redundant SSTORE operations to already-set storage slots.
• Expensive operations inside loops (e.g., writing to storage).

Historical and advanced mechanisms that leverage Ethereum's gas refund policy to reduce net costs.

• Gas Tokens (e.g., GST1, GST2): Smart contracts that store gas when it's cheap (by writing to storage) and release it when it's expensive (by clearing storage), claiming a gas refund. Largely deprecated post-EIP-3529.
• EIP-3529: Reduced maximum gas refunds, effectively eliminating the economic viability of gas tokens to reduce network state bloat.
• Storage Management: Understanding refunds for clearing storage (SSTORE with 0) remains relevant for contract design.

Languages that compile to EVM bytecode, often with different gas performance characteristics than Solidity.

• Vyper: A Pythonic language focused on security and simplicity, which can sometimes produce more gas-efficient bytecode for specific patterns due to a simpler compiler.
• Huff: A low-level, assembly-like language that provides extreme optimization potential by giving the developer direct control over opcodes and stack management. Used for highly specialized, gas-critical contracts.
• Fe (Formerly Flint): A newer language with a different type system and safety features that influences gas output.

The process of measuring and analyzing a smart contract's gas consumption to identify optimization opportunities. This involves using tools like Hardhat, Foundry's gas reports, or EVM tracers to profile individual opcodes. Key steps include:

• Establishing a baseline for gas costs.
• Identifying hotspots—the most expensive functions or loops.
• Comparing gas usage before and after implementing optimizations to quantify improvements.

Techniques to minimize costly interactions with contract storage, the most expensive operation on the EVM. Core strategies include:

• Packing variables: Combining multiple small uint or bool values into a single storage slot.
• Using immutable and constant variables for values that do not change.
• Employing mappings over arrays for large datasets to avoid iteration.
• Implementing SSTORE refunds by clearing storage slots (setting to zero).

Optimizing how data is passed and stored during execution. Calldata is a non-modifiable, low-cost data location for function arguments. Best practices include:

• Using calldata for external function parameters instead of memory where possible.
• ABI encoding efficiently to minimize calldata size.
• Carefully managing memory expansion costs by limiting array operations and in-place assembly.

Writing Solidity or Yul/assembly that compiles to cheaper EVM opcodes. This advanced technique requires deep EVM knowledge. Examples include:

• Using unchecked blocks for arithmetic where overflow/underflow is impossible.
• Choosing cheaper comparison opcodes (e.g., != 0 vs > 0 for unsigned ints).
• Minimizing JUMP operations and optimizing control flow.
• Using bitwise operations for certain checks and packing.

High-level design patterns that inherently reduce gas costs. These include:

• Proxy Patterns (e.g., UUPS, Transparent): Enables contract upgrades without migrating state, saving deployment and user migration costs.
• Diamond Pattern (EIP-2535): Modularizes a monolith contract into facets, reducing the cost of deploying new functionality.
• Stateless Contracts / Merkle Proofs: Moving state off-chain and verifying proofs on-chain (e.g., airdrops, rollups).

A now-obsolete optimization strategy where users could "lock" gas when prices were low and "burn" the token to refund gas when prices were high. The most famous example was CHI Gastoken on Ethereum. This practice was effectively disabled by the EIP-1559 fee market change and the London Hard Fork, which removed most gas refunds, making the economic model non-viable.