Chapter 0x5: Best Yul Assembly Gas Optimization Techniques for High-Performance Smart Contracts

Yul Assembly Gas Optimization : Gas optimization in Ethereum smart contracts is not just a cost-saving measure; it’s a critical skill for developers aiming to enhance performance and scalability. By understanding and implementing gas optimization techniques, you can significantly reduce transaction costs, improve execution efficiency, and attract users to your decentralized application (dApp).

In this article, we’ll break down gas costs, explore the nuances of optimizing loops and conditionals in Yul, and examine techniques to reduce storage reads and writes. Additionally, we’ll delve into real-world examples to bring these concepts to life. Let’s dive in!

Why is Gas Optimization Important?

Gas optimization isn’t just about saving a few dollars. It’s a critical aspect of designing scalable and efficient decentralized applications (dApps). Here’s why:

1. Cost Efficiency: Lower gas usage means cheaper transactions for users.
2. Scalability: Optimized contracts reduce network congestion.
3. Competitive Advantage: Lower transaction fees attract more users to your dApp.
4. Environmental Impact: Reduced gas usage contributes to less energy consumption.

With gas prices often fluctuating, optimizing your smart contracts ensures your dApp remains sustainable and attractive to users.

Gas Cost Breakdown of EVM Operations

Understanding the gas cost breakdown of Ethereum Virtual Machine (EVM) operations is fundamental. Gas serves as the computational fee required to execute operations in Ethereum. Different operations, from arithmetic to storage, have varying costs.

Key Components of Gas Costs:

1. Computation Costs: The gas required for arithmetic operations, control flow, and function calls. For instance:
   • ADD operation: 3 gas
   • MUL operation: 5 gas
   • EXP operation: 50 gas (base) + 10 gas per byte of exponent
2. Storage Costs: These are among the most expensive operations:
   • SLOAD (storage read): 2,100 gas
   • SSTORE (storage write): 20,000 gas (when writing to an empty slot)
3. Memory Costs: Gas consumption increases with memory expansion during execution.
4. Transaction Costs:
   • Fixed base cost: 21,000 gas
   • Additional data costs: 16 gas per byte of non-zero data and 4 gas per byte of zero data

EVM Opcodes and Gas Cost Tables:

For a comprehensive understanding, refer to EVM opcode gas cost tables, such as those available on GitHub. These tables provide an exhaustive list of opcodes and their associated costs.

Optimizing Loops and Conditionals in Yul

Yul, a low-level intermediate language for Ethereum, is a powerful tool for optimizing gas usage. Its simplicity and direct mapping to EVM opcodes make it an ideal choice for gas-sensitive operations.

Why Yul?

• Yul allows fine-grained control over EVM operations.
• Developers can write assembly-like code to eliminate inefficiencies introduced by high-level Solidity constructs.

Top Yul Assembly Gas Optimization Techniques

1. Use Memory Over Storage

Storage operations are significantly more expensive than memory operations. Whenever possible, store data in memory rather than contract storage.

Example:

let tempValue := mload(0x40) // Load data from memory
sstore(0x0, tempValue)      // Store data in storage only when necessary

• Why it works: Memory access is cheaper than storage, and temporary values can often remain in memory during computation.
• Pro Tip: Batch storage updates to minimize repeated storage operations.

2. Inline Arithmetic Operations

Using inline arithmetic in Yul can save gas by avoiding unnecessary overhead from Solidity’s high-level abstractions.

Example:

• Why it works: Memory access is cheaper than storage, and temporary values can often remain in memory during computation.
• Pro Tip: Batch storage updates to minimize repeated storage operations.

let result := mul(add(a, b), c)

• Why it works: Direct arithmetic operations avoid the additional checks and conversions that Solidity introduces.
• Pro Tip: Always validate inputs to prevent overflows or unexpected results.

Techniques to Optimize Loops and Conditionals in Yul:

1. Avoid Unnecessary Iterations: Minimize the number of loop iterations by:
   • Using binary search for sorted data.Leveraging indexed access over sequential searches.
   Example:

let i := 0
let sum := 0
for { } lt(i, 10) { i := add(i, 1) } {
    sum := add(sum, mul(i, i))
}

This loop calculates the sum of squares with minimal gas usage.

2. Simplify Conditionals: Replace complex conditions with simple Boolean logic. For instance:

if eq(a, 1) {
    // Do something
}

This avoids expensive nested conditionals.

3. Inline Functionality: Replacing function calls with inline operations saves gas, as it avoids stack management overhead.

Real-World Example:

A project reduced gas costs by 30% by rewriting a Solidity loop in Yul, removing redundant operations, and using indexed storage.

Reducing Storage Reads and Writes for Better Performance

Storage operations are notoriously expensive in Ethereum. Optimizing these can dramatically cut costs.

Strategies for Reducing Storage Operations:

1. Variable Packing: Pack multiple variables into a single storage slot to save space and reduce SLOAD/SSTORE calls.

struct PackedData {
    uint128 high;
    uint128 low;
}

Each slot holds 256 bits, so combining smaller variables can be highly effective.

2. Caching: Cache frequently accessed storage variables in memory. For instance:

uint256 data = storedData; // Cache in memory

Use data for operations instead of repeatedly calling storedData.

3. Minimize Updates: Update storage variables only when necessary. Batch updates whenever possible.

function update(uint256[] memory values) public {
    for (uint256 i = 0; i < values.length; i++) {
        storedArray[i] = values[i];
    }
}

4. Use Mappings Wisely: While mappings are efficient for lookups, avoid unnecessary reads by using auxiliary data structures or indices.

Mastering EVM Storage Optimization:

• Always measure gas usage with tools like Hardhat or Foundry to identify bottlenecks.
• Leverage tools like RareSkills’ gas optimizers for advanced insights.

Gas Optimization Tools and Resources

Efficient gas optimization requires the right tools and resources. Here are some indispensable ones:

1. Remix IDE: Offers real-time feedback on gas usage for Solidity contracts.
2. Hardhat: Provides plugins like hardhat-gas-reporter to analyze gas consumption.
3. Foundry: A robust development environment for testing and profiling gas costs.
4. Yul Optimizers: Use Yul compilers or tools like yul-gas for deeper insights.

Yul vs Solidity:

While Solidity is more developer-friendly, Yul excels in scenarios where gas efficiency is paramount. Consider Yul for:

• Custom mathematical operations
• Optimizing storage-intensive contracts

Real-World Examples of Gas Optimization

Example 1: Optimizing a Token Contract

A developer reduced the minting cost of an ERC-20 token contract by:

• Using Yul for mathematical operations.
• Caching frequently used values in memory.
• Batching token transfers to minimize storage writes.

Example 2: Decentralized Exchange (DEX)

By analyzing gas profiles, a DEX reduced swap costs by:

• Replacing high-level Solidity functions with Yul operations.
• Packing multiple state variables into single storage slots.
• Simplifying the conditional logic for fee calculations.

Example 3: Yield Farming Protocol

A yield farming protocol optimized its reward distribution by:

• Precomputing values off-chain and storing only necessary data on-chain.
• Using indexed mappings to minimize search costs.

Key Takeaways for Developers

1. Measure First: Always benchmark gas usage before and after optimization.
2. Start Simple: Optimize loops, conditionals, and storage operations first.
3. Leverage Tools: Use Hardhat, Foundry, and Yul-specific compilers for insights.
4. Think Beyond Code: Off-chain computations and architectural changes can offer significant savings.

By mastering these techniques, you can create highly efficient smart contracts, saving gas for users and making your dApps more attractive in a competitive ecosystem.

FAQs