Solidity Gas Optimization Guide

Functions

• Prefer external: external functions receive parameters as calldata, avoiding the gas cost of copying them to memory. This is especially important for dynamic strings or arrays.
• Function Ordering: Each function position has an extra 22 gas cost. Put frequently called functions earlier in the contract.
• Minimize Parameters: Large input data increases gas costs due to memory allocation.
• Payable functions: payable functions can be slightly cheaper than non-payable ones because the compiler skips certain checks.
• Modifiers vs Functions: Solidity modifiers increase contract code size; sometimes it is more efficient to use a regular function instead.
• Fallback Functions: Fallback (or sig-less) functions are cheaper than regular function calls because they don't require a function signature.

Loops

• Use memory variables: Perform loop operations on memory variables rather than storage variables.
• Avoid unbounded loops: Unbounded loops can lead to out-of-gas errors and high costs.
• Prefix increment: Using ++i (prefix) can be slightly cheaper than i++ (postfix) in some contexts.

Variable Best Practices

• Avoid public variables: They automatically generate a getter function which costs gas.
• Use private for globals: Using global variables with private visibility can save gas.
• Use Events: Instead of storing every piece of data in state, use events to emit data.
• Named Return Values: Naming the return values of a function allows you to avoid creating unnecessary local variables.

Mappings vs Arrays

• Use Mappings: Mappings are generally cheaper than arrays for lookups.
• Use Arrays for small sets: If the dataset is very small, an array might be a viable alternative.

Fixed vs Dynamic

• Fixed size is cheaper: Fixed-size variables (and fixed-size memory arrays) are always more gas-efficient than dynamic ones.
• Array growth: If you must use dynamic arrays, structure functions to be additive (extending) rather than subtractive (truncating). Extending an array costs constant gas, while truncating costs linear gas.

Storage is one of the most expensive areas in Solidity. Understanding the gas costs for different operations helps in writing efficient contracts:

• Saving a variable in storage: ~20,000 gas.
• Rewriting a variable: ~5,000 gas.
• Reading from a slot: ~200 gas.
• Variable declaration: Costs nothing if no initialization is performed.

Best Practices

• Use Memory for calculations: Always save a storage variable into a memory variable within a function if you need to perform multiple operations on it. Calculate everything in memory first, then update the storage variable once.
• Variable Packing: Organize and pack multiple storage variables (including those within structs) into a single 32-byte slot to reduce the number of slots used.
• Avoid Zero-Value Initialization: Instead of uint256 index = 0;, use uint256 index;. Since uint256 defaults to 0, you avoid the gas cost of explicit initialization.
• Use Constants: Make Solidity values constant whenever possible.

// Instead of this:
uint256 index = 0;

// Do this:
uint256 index;

How you define data types significantly impacts gas consumption:

• Use bytes32: This is the most optimized storage type. It is cheaper than using string. If a string is short enough, cast it to bytes32.
• Minimize byte length: If the length of bytes can be limited, use the smallest possible size (e.g., bytes1 to bytes32).
• Packing logic: Variable packing only occurs in storage. You will not save gas by trying to pack function arguments or local variables in memory or calldata.
• Small integers: Storing a single small number in a uint8 is not cheaper than a uint256 because it still occupies a full 32-byte slot. Savings only occur when you pack multiple small variables into a single 32-byte slot.

contract StringToBytes32 {
    bytes32 public fixedSizeString;

    function setFixedSizeData(string memory str) public {
        require(bytes(str).length <= 32, "String exceeds 32 bytes.");
        fixedSizeString = bytes32(bytes(str));
    }
}

When writing low-level Yul/Assembly code, use these techniques to minimize gas costs:

• Access Lists: Call eth_createAccessList on a node (like Geth) to generate an access list. Including this list in your transaction blob can save gas, especially when writing to many storage slots.
• Memory Management: Since Solidity doesn't garbage collect, overwrite unused values in memory/storage with new values to conserve space.
• Calldata vs Memory: Keep data in calldata whenever possible. If a function parameter is not modified, read it directly from calldata instead of copying it to memory.
• Vanity Addresses: Use addresses with many leading zeroes (e.g., 0x0000000000f38210) to pack multiple addresses into a single storage slot.
• Storage Slot Reuse: Writing to an existing storage slot is cheaper than using a new one. Avoid emptying a slot if you plan to refill it later (refer to EIP-2200).
• Gas Forwarding: When using call() in Yul, use gas() as the gas parameter to forward all available gas instead of manually calculating it.
• Zero Address Checks: In NFT implementations, many zero-address checks are unnecessary unless the 0 address has unique permissions or can call the contract.
• Overflow Protection: In Solidity, use unchecked {} blocks for counters or operations that cannot overflow without reaching uint256(-1) to avoid the cost of Safemath-style checks.