Zokyo Gas Savings
  • ⛽Zokyo Gas Savings
  • 📚Tutorials
    • ✔️Gas Saving Technique 1: Unchecked Arithmetic
    • ⛓️Gas Saving Technique 2: Immutable Variable
    • ✨Gas Saving Technique 3: Double star ** inefficiency
    • 💰Gas Saving Technique 4: Cache Array Length
    • ⬅️Gas Saving Technique 5: ++i costs less gas compared to i++
    • ⚖️Gas Saving Technique 6: NOT operator ! cheaper than boolean FALSE
    • 🪡Gas Saving Technique 7: Using Short Reason Strings
    • 🪵Gas Saving Technique 8: Use Custom Errors instead of Revert Strings to save Gas
    • ✒️Gas Saving Technique 9: Use Custom Errors instead of Revert Strings to save Gas
    • 👾Gas Saving Technique 10: Calldata cheaper than memory
    • ⛔Gas Saving Technique 11: > 0 is less efficient than != 0 for unsigned integers
    • ➗Gas Saving Technique 12: SafeMath no longer needed
    • 😮Gas Saving Technique 13: variables default to 0
    • 🧱Gas Saving Technique 14: struct layout/ variable packing
    • 📞Gas Saving Technique 15: Cache External Call
    • ✍️Gas Saving Technique 16: Early Validation before external call
    • 😎Gas Saving Technique 17: Don’t cache value that is used once
    • 😧Gas Saving Technique 18: Redundant code
    • ✅Gas Saving Technique 19: Early Validation before external call
    • ⛏️Gas Saving Technique 20: Storage vs Memory read optimizations
    • ✒️Gas Saving Technique 21: Unneeded If statements
    • 🌗Gas Saving Technique 22: >= is cheaper than >
    • 🎒Gas Saving Technique 23: Public to private constants
    • ⏹️Gas Saving Technique 24: Make unchanged variables constant/immutable
    • ⏱️Gas Saving Techniques 25: Redundant Access Control Checks
    • ➡️Gas Saving Technique 26: Shift Right instead of Dividing by 2
    • 🪃Gas Saving Tutorial 27: Efficient Boolean Comparison
    • 🤝Gas Saving Technique 28: && operator uses more gas
    • 👓Gas Saving Technique 29: x = x + y is cheaper than x += y
    • 👂Gas Saving Technique 30: Using 1 and 2 rather than 0 and 1 saves gas
    • ⚽Gas Saving Technique 31: Optimize Storage by Avoiding Booleans
    • 🔙Gas Saving Technique 32: Optimal Use of Named Return Variables in Solidity
    • 🛢️Gas Saving Technique 33: Making Functions Payable for Optimized Gas Costs
    • ✍️Gas Saving Technique 34: Optimizing Storage References in Smart Contracts
    • ⛰️Gas Saving Technique 35: Usage of uints/ints smaller than 32 bytes (256 bits) incurs overhead
    • 🌪️Gas Saving Technique 36: Inlining Single Use Internal Functions for Savings
    • ☄️Gas Saving Technique 37: Switching from Public to External Functions for Savings
    • 🎆Gas Saving Technique 38: Upgrading Solidity Compiler to Improve Gas Efficiency and Security
    • 🕶️Gas Saving Technique 39: Avoiding Duplicated Code for Gas Savings
    • 😄Gas Saving Technique 40: Removal of Unused Internal Functions for Gas Savings
    • 🖋️Gas Saving Tutorial 41: In-lining Single Use Modifiers For Gas Saving
    • ⛏️Gas Saving Technique 42: `require` vs`assert`
Powered by GitBook
On this page
  1. Tutorials

Gas Saving Technique 31: Optimize Storage by Avoiding Booleans

PreviousGas Saving Technique 30: Using 1 and 2 rather than 0 and 1 saves gasNextGas Saving Technique 32: Optimal Use of Named Return Variables in Solidity

Last updated 1 year ago

Introduction: Using booleans for storage in Solidity might seem like an efficient choice given their simple true/false representation. However, due to the underlying mechanics of the Ethereum Virtual Machine (EVM), booleans can lead to increased gas costs when used as storage variables. This tutorial will explore the reasons behind this inefficiency and provide alternative approaches.

Concept: Booleans in Solidity, when used as storage variables, do not consume a full 256-bit word in the EVM. However, the compiler generates additional operations to ensure data integrity when reading and writing to these slots. This involves an extra SLOAD to read the slot's current value, modifying the relevant bits for the boolean, and then writing the modified value back using SSTORE.

Underlying Problem:

  1. Inherent Compiler Mechanics: Due to potential issues like contract upgrades and pointer aliasing, the Solidity compiler employs certain defenses which lead to these extra operations.

  2. Wasted Storage: Booleans don't utilize the full storage slot, leading to inefficiencies.

Examples & Recommendations:

  1. EternalStorage Boolean Mapping:

    • Before:

      solidityCopy codemapping(bytes32 => bool) private _boolStorage;

    • After (Using uint256 as a flag, where 0 can represent false and 1 can represent true):

      solidityCopy codemapping(bytes32 => uint256) private _flagStorage;

Step-by-Step Guide to Implementing the Storage Optimization Technique:

  1. Identify instances where booleans are used as storage variables.

  2. Replace boolean storage declarations with uint256.

  3. Modify the logic of your contract to treat 0 as false and any non-zero value (typically 1) as true.

  4. Update any functions that interact with the changed storage variables to accommodate this new representation.

  5. Test your contract thoroughly to ensure that the logic remains consistent and correct.

Benefits:

  1. Gas Savings: Removing the overhead associated with booleans can lead to significant gas savings over the lifespan of a contract.

  2. Consistent Storage Usage: By using uint256, the contract optimally uses the available storage slot.

Conclusion: At first glance, booleans might seem like a gas-efficient choice for storage in Solidity contracts. However, understanding the deeper mechanics of the EVM and the Solidity compiler reveals that other data types, such as uint256, can provide more efficient storage solutions, leading to gas savings.

📚
⚽
Book an audit with Zokyo