⏱️Gas Saving Techniques 25: Redundant Access Control Checks

Book an audit with Zokyo

Introduction:

In smart contract development, access control checks are crucial for security but can sometimes be over-implemented, leading to redundant checks and consequently, unnecessary gas consumption. This tutorial focuses on gas optimization by eliminating redundant access control checks within your Solidity contracts.

Understanding the Impact:

Redundant access control checks can occur when a function with access checks calls another function also guarded with similar checks. Every non-trivial operation in a contract consumes gas; hence, removing unnecessary checks helps save gas.

Example:

Original Code with Redundant Checks:

solidityCopy codepragma solidity ^0.8.0;

contract RedundantChecks {
    address public owner;

    modifier onlyAuthorized() {
        require(msg.sender == owner, "Not authorized");
        _;
    }

    constructor() {
        owner = msg.sender;
    }

    function setProposal(string memory proposal) public onlyAuthorized {
        // Proposal setting logic
    }

    function setProposals(string[] memory proposals) public onlyAuthorized {
        for (uint i = 0; i < proposals.length; i++) {
            setProposal(proposals[i]);
        }
    }
}

Optimized Code without Redundant Checks:

solidityCopy codepragma solidity ^0.8.0;

contract OptimizedChecks {
    address public owner;

    modifier onlyAuthorized() {
        require(msg.sender == owner, "Not authorized");
        _;
    }

    constructor() {
        owner = msg.sender;
    }

    function _setProposal(string memory proposal) private {
        // Proposal setting logic
    }

    function setProposal(string memory proposal) public onlyAuthorized {
        _setProposal(proposal);
    }

    function setProposals(string[] memory proposals) public onlyAuthorized {
        for (uint i = 0; i < proposals.length; i++) {
            _setProposal(proposals[i]);
        }
    }
}

Mitigation Steps:

1. Identify Redundancies: Examine your contract for function calls within functions, both having similar access control checks.

2. Refactor the Internal Logic: Create a private function encapsulating the shared logic without access checks and call it within your public or external functions.

3. Retain Necessary Checks: Only maintain the access control checks on the external or public functions that are part of the contract’s interface.

4. Test: Ensure the contract's functionality remains intact after the changes.

Benefits:

• Gas Efficiency: Removes unnecessary gas consumption due to redundant operations.

• Cleaner Code: Results in a cleaner, more readable, and maintainable codebase.

Conclusion:

Optimizing gas usage by removing redundant access control checks is a valuable practice in Solidity smart contract development. Such optimizations not only save gas but also lead to cleaner and more efficient code. Always ensure thorough testing and auditing of your smart contracts after making any changes to verify their security and functionality.