Understanding Gas Costs

In Ethereum, every operation executed in a smart contract consumes gas, which is paid for with Ether. The more complex an operation, the more gas it consumes. Thus, optimizing your code not only saves users money but also enhances the usability of your application.

Common Gas Cost Factors

Operation TypeGas Cost (Approximate)
SSTORE (storing data)20,000
SLOAD (loading data)2,100
ADD, SUB, MUL3
DIV, MOD5
LOG (event emission)20,000 + 1,000 per topic
CALL (external call)Varies

Key Techniques for Gas Optimization

  1. Minimize State Variable Usage
  • Each state variable consumes gas when read from or written to. Use local variables whenever possible.
   contract GasOptimization {
       uint256 public count;

       function increment() public {
           uint256 temp = count; // Use local variable
           temp++;
           count = temp; // Only write once
       }
   }
  1. Use view and pure Functions
  • Functions marked as view or pure do not modify the state and can be called without gas costs when invoked externally.
   contract GasOptimization {
       uint256 public count;

       function getCount() public view returns (uint256) {
           return count; // No gas cost for external calls
       }
   }
  1. Batch State Changes
  • Group multiple state changes into a single transaction to reduce the overall gas cost.
   contract BatchUpdate {
       uint256 public a;
       uint256 public b;

       function update(uint256 _a, uint256 _b) public {
           a = _a;
           b = _b; // Batch operations
       }
   }
  1. Avoid Dynamic Arrays When Possible
  • Dynamic arrays can be costly in terms of gas. Prefer fixed-size arrays when you know the size in advance.
   contract FixedArray {
       uint256[10] public numbers; // Fixed size

       function setNumber(uint256 index, uint256 value) public {
           require(index < 10, "Index out of bounds");
           numbers[index] = value; // Less gas than dynamic array
       }
   }
  1. Leverage delegatecall for Upgradable Contracts
  • Using delegatecall can save gas by allowing contracts to share code, thereby minimizing the need for multiple copies of similar logic.
   contract Logic {
       function increment(uint256 x) public pure returns (uint256) {
           return x + 1;
       }
   }

   contract Proxy {
       address logicAddress;

       function setLogic(address _logic) public {
           logicAddress = _logic;
       }

       function increment(uint256 x) public returns (uint256) {
           (bool success, bytes memory data) = logicAddress.delegatecall(
               abi.encodeWithSignature("increment(uint256)", x)
           );
           require(success, "Delegatecall failed");
           return abi.decode(data, (uint256));
       }
   }
  1. Optimize Data Structures
  • Utilizing mappings instead of arrays can reduce gas costs for lookups and storage.
   contract OptimizedMapping {
       mapping(address => uint256) public balances;

       function updateBalance(address user, uint256 amount) public {
           balances[user] = amount; // Efficient storage
       }
   }
  1. Use Events Wisely
  • Events can be costly if emitted frequently. Consider the necessity of logging every state change.
   contract EventExample {
       event DataUpdated(address indexed user, uint256 newValue);

       function updateData(uint256 newValue) public {
           // Emit event only when necessary
           if (newValue > 100) {
               emit DataUpdated(msg.sender, newValue);
           }
       }
   }

Conclusion

Optimizing gas costs in Solidity requires careful consideration of data structures, function types, and operational efficiencies. By applying the techniques outlined in this tutorial, developers can create more efficient smart contracts that save users money and improve overall performance.

Learn more with useful resources