Gas Inefficiency in _commitRemoveModule

[hats-bug-reporter[bot]]

Github username: -- Twitter username: -- Submission hash (on-chain): 0xd3168b2fc7a1fa43915a865ce2b4420907a2686f7f9d46755800a008bb6c725d Severity: gas saving

Description: Description\ The _commitRemoveModule function currently performs a linear search to find the index of the module to be removed:

function _commitRemoveModule(address module) private {
    address[] memory modulesSearchArray = _modules;
    uint moduleIndex = type(uint).max;
    uint length = modulesSearchArray.length;
    for (uint i; i < length; i++) {
        if (modulesSearchArray[i] == module) {
            moduleIndex = i;
            break;
        }
    }
    _modules[moduleIndex] = _modules[length - 1];
    _modules.pop();
    _isModule[module] = false;
    emit ModuleRemoved(module);
}

Issues

Linear Search:

• The function iterates over the _modules array to find the index of the module.
• This is inefficient, especially if the array is large (up to 128 elements).

Gas Consumption:

• Linear search increases gas cost linearly with the size of the array.
• Removing an element involves multiple storage operations.

Optimization: Use Mapping for Index Tracking

To optimize, we can maintain a mapping from module addresses to their indices in the _modules array. This allows for O(1) access time. Optimized Implementation

Add Mapping:

• Add a mapping to track indices of modules.

mapping(address => uint) private _moduleIndex;

Update _commitAddModule:

• Update the mapping when adding a module.

 function _commitAddModule(address module) internal {
        _modules.push(module);
        _isModule[module] = true;
        _moduleIndex[module] = _modules.length - 1;
        emit ModuleAdded(module);
    }

Update _commitRemoveModule:

• Use the mapping to get the index directly.

    function _commitRemoveModule(address module) private {
        uint moduleIndex = _moduleIndex[module];
        uint lastIndex = _modules.length - 1;
        address lastModule = _modules[lastIndex];

        // Swap the module to remove with the last module
        _modules[moduleIndex] = lastModule;
        _moduleIndex[lastModule] = moduleIndex;

        // Remove the last element
        _modules.pop();
        delete _moduleIndex[module];
        _isModule[module] = false;

        emit ModuleRemoved(module);
    }

Benefits

Efficiency:

• O(1) access time for index retrieval.
• Reduces gas consumption significantly for large arrays.

Simplicity:

• Simplifies the removal logic by avoiding linear search.

Conclusion

By using a mapping to track module indices, we can optimize the _commitRemoveModule function for better gas efficiency and performance. This change ensures that module removal operations remain efficient even as the number of modules grows.

Attack Scenario\ Describe how the vulnerability can be exploited.

Attachments

1. Proof of Concept (PoC) File

2. Revised Code File (Optional)

[0xmahdirostami]

Gas saving is done differently in hats finance, read the scope page, please.