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 6: NOT operator ! cheaper than boolean FALSE

PreviousGas Saving Technique 5: ++i costs less gas compared to i++NextGas Saving Technique 7: Using Short Reason Strings

Last updated 1 year ago

Introduction

In the pursuit of optimizing smart contracts for lower gas consumption, every small improvement counts. One such micro-optimization involves using !true (logical NOT) instead of == false for boolean comparisons. This seemingly trivial change can lead to minor gas savings, contributing to the overall efficiency of your smart contract operations on the Ethereum network.

Impact & Details

Understanding Gas Consumption

  • Cost Differences in Comparisons: Using == false for comparison slightly consumes more gas than the !true approach. The == false comparison has an additional operation of checking equality, leading to a marginally higher gas cost.

Gas Savings with !true

  • Efficiency of Logical NOT: Utilizing !true is more gas-efficient as it directly negates the boolean value without the need for an equality check, offering a cleaner and more gas-conservative operation.

How to Implement !true for Gas Savings

Practical Example: Efficient Boolean Comparison

Letโ€™s understand this with a practical example:

Before Optimization:

solidityCopy code// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract BooleanOptimizer {
    bool public flag = true;

    function checkFlag() public view returns (bool) {
        if (flag == false) {  // Using == false for comparison
            return false;
        }
        return true;
    }
}

After Optimization:

solidityCopy code// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract BooleanOptimizer {
    bool public flag = true;

    function checkFlag() public view returns (bool) {
        if (!flag) {  // Using !true (logical NOT) for comparison
            return false;
        }
        return true;
    }
}

In the optimized version, !flag is used instead of flag == false. This makes the code not only more readable but also slightly more gas-efficient.

Recommended Mitigation Steps

  1. Identify Boolean Comparisons: Review your smart contracts to locate boolean comparisons using == false.

  2. Use Logical NOT: Replace == false comparisons with !true to achieve minor gas savings per operation.

  3. Test: Implement thorough testing to ensure that the change maintains the expected contract behavior while saving gas.

Conclusion

While the gas savings from using !true instead of == false might appear minimal for a single transaction, it's important to consider the cumulative effect over thousands or millions of transactions. Such minor optimizations collectively lead to more gas-efficient smart contracts, ultimately resulting in lower costs for users and better resource utilization on the Ethereum network. Always ensure to test the smart contract extensively after making these micro-optimizations to validate that the functionality remains intact.

Reference

๐Ÿ“š
โš–๏ธ
Book an audit with Zokyo
[G-09] Gas: Using the logical NOT operator ! is cheaper than a comparison to the constant boolean value false - NOT operator ! cheaper than boolean FALSE