Clean up

Author: rya-sge

src/RuleEngine.sol

@@ -13,6 +13,7 @@ import {ERC3643Compliance, IERC3643Compliance} from "./modules/ERC3643Compliance
 import {RuleEngineOperation} from "./modules/RuleEngineOperation.sol";
 import {RuleEngineValidationRead, RuleEngineValidation} from "./modules/RuleEngineValidationRead.sol";
 import {IRuleValidation} from "./interfaces/IRuleValidation.sol";
+import {RuleEngineInvariantStorage} from "./modules/library/RuleEngineInvariantStorage.sol";
 /**
  * @title Implementation of a ruleEngine as defined by the CMTAT
  */
@@ -21,7 +22,8 @@ contract RuleEngine is
     RuleEngineOperation,
     RuleEngineValidationRead,
     MetaTxModuleStandalone,
-    ERC3643Compliance
+    ERC3643Compliance,
+    RuleEngineInvariantStorage
 {
 
     /**

src/interfaces/IRuleEngineOperation.sol

@@ -1,25 +1,68 @@
 //SPDX-License-Identifier: MPL-2.0
 
 pragma solidity ^0.8.20;
-
+import {IRuleOperation} from "./IRuleOperation.sol";
 interface IRuleEngineOperation {
     /**
-     * @dev define the rules, the precedent rules will be overwritten
+     * @notice Defines the operation rules for the rule engine.
+     * @dev Sets the list of rule contract addresses for operations. 
+     *      Any previously set rules will be completely overwritten by the new list.
+     *      Rules should be deployed contracts that implement the expected interface.
+     * @param rules_ The array of addresses representing the new rules to be set.
+     * @dev Revert if one rule is a zero address or if the rule is already present
      */
-    function setRulesOperation(address[] calldata rules_) external;
+    function setRulesOperation(IRuleOperation[] calldata rules_) external;
 
     /**
-     * @dev return the number of rules
+     * @notice Returns the number of rules currently set for operations.
+     * @dev The count corresponds to the total number of elements in the rules array.
+     * @return The number of operation rules.
      */
     function rulesCountOperation() external view returns (uint256);
 
     /**
-     * @dev return the rule at the index specified by ruleId
+     * @notice Retrieves the rule address at a specific index.
+     * @dev The index corresponds to the position in the rules array.
+     *      Reverts if `ruleId` is out of bounds.
+     * @param ruleId The index of the rule to retrieve.
+     * @return The address of the rule contract.
      */
     function ruleOperation(uint256 ruleId) external view returns (address);
 
     /**
-     * @dev return all the rules
+     * @notice Returns the full list of operation rules.
+     * @dev This is a view-only function that returns all the currently stored rule addresses.
+     * @return An array containing all the rule contract addresses.
      */
     function rulesOperation() external view returns (address[] memory);
+
+
+    /**
+     * @notice Clear all the rules of the array of rules
+     *
+     */
+    function clearRulesOperation() external;
+
+    /**
+     * @notice Add a rule to the array of rules
+     * Revert if one rule is a zero address or if the rule is already present
+     *
+     */
+    function addRuleOperation(
+        IRuleOperation rule_
+    ) external;
+
+
+    /**
+     * @notice Remove a rule from the array of rules
+     * Revert if the rule found at the specified index does not match the rule in argument
+     * @param rule_ address of the target rule
+     * @dev To reduce the array size, the last rule is moved to the location occupied
+     * by the rule to remove
+     *
+     *
+     */
+    function removeRuleOperation(
+        IRuleOperation rule_
+    ) external;
 }

src/interfaces/IRuleEngineValidation.sol

@@ -2,6 +2,7 @@
 
 pragma solidity ^0.8.20;
 
+import {IRuleValidation} from "./IRuleValidation.sol";
 interface IRuleEngineValidationRead {
     /**
      * @dev See ERC-1404
@@ -35,20 +36,57 @@ interface IRuleEngineValidation {
     /**
      * @dev define the rules, the precedent rules will be overwritten
      */
-    function setRulesValidation(address[] calldata rules_) external;
+    function setRulesValidation(IRuleValidation[] calldata rules_) external;
 
-    /**
-     * @dev return the number of rules
+   /**
+     * @return The number of rules inside the array
      */
     function rulesCountValidation() external view returns (uint256);
 
-    /**
-     * @dev return the rule at the index specified by ruleId
+   /**
+     * @notice Get the rule at the position specified by ruleId
+     * @param ruleId index of the rule
+     * @return a rule address
      */
     function ruleValidation(uint256 ruleId) external view returns (address);
 
     /**
-     * @dev return all the rules
+     * @notice Get all the rules
+     * @return An array of rules
      */
     function rulesValidation() external view returns (address[] memory);
+
+    /**
+     * @notice Remove a rule from the array of rules
+     * Revert if the rule found at the specified index does not match the rule in argument
+     * @param rule_ address of the target rule
+     * @dev To reduce the array size, the last rule is moved to the location occupied
+     * by the rule to remove
+     *
+     *
+     */
+    function removeRuleValidation(
+        IRuleValidation rule_
+    ) external;
+
+    /**
+     * @notice Clear all the rules of the array of rules
+     *
+     */
+    function clearRulesValidation() external;
+
+    /**
+     * @notice Add a rule to the array of rules
+     * @dev Revert if one rule is a zero address or if the rule is already present
+     *
+     */
+    function addRuleValidation(
+        IRuleValidation rule_
+    ) external;
+
+    /**
+     * @notice Check if a rule is present
+     *
+     */
+    function rulesValidationIsPresent(IRuleValidation rule_) external returns (bool);
 }

src/interfaces/IRuleOperation.sol

@@ -2,13 +2,7 @@
 
 pragma solidity ^0.8.20;
 
-interface IRuleOperation {
-    /**
-     * @dev Returns true if the transfer is valid, and false otherwise.
-     */
-    function transferred(
-        address from,
-        address to,
-        uint256 value
-    ) external;
+import {IERC3643IComplianceContract} from "CMTAT/interfaces/tokenization/IERC3643Partial.sol";
+
+interface IRuleOperation is IERC3643IComplianceContract {
 }

src/modules/RuleEngineInvariantStorage.sol

@@ -8,22 +8,28 @@ import {AccessControl}  from "OZ/access/AccessControl.sol";
 // Other
 import {IRuleEngineOperation} from "../interfaces/IRuleEngineOperation.sol";
 import {IRuleOperation} from "../interfaces/IRuleOperation.sol";
-import {RuleEngineInvariantStorage} from "./RuleEngineInvariantStorage.sol";
+import {RuleEngineInvariantStorageCommon} from "./library/RuleEngineInvariantStorageCommon.sol";
 /**
  * @title RuleEngine - Operation part
  */
 abstract contract RuleEngineOperation is
     AccessControl,
-    RuleEngineInvariantStorage,
+    RuleEngineInvariantStorageCommon,
     IRuleEngineOperation
 {
-       
-    /// @dev Array of rules
-    //address[] internal _rulesOperation;
     // Add the library methods
     using EnumerableSet for EnumerableSet.AddressSet;
 
+    /// @notice Generate when a rule is added
+    event AddRuleOperation(IRuleOperation indexed rule);
+    /// @notice Generate when a rule is removed
+    event RemoveRuleOperation(IRuleOperation indexed rule);
+    /// @notice Generate when all the rules are cleared
+    event ClearRulesOperation();
+    
+
     // Declare a set state variable
+    /// @dev Array of rules
     EnumerableSet.AddressSet internal _rulesOperation;
 
     /*//////////////////////////////////////////////////////////////
@@ -37,7 +43,7 @@ abstract contract RuleEngineOperation is
      *
      */
     function setRulesOperation(
-        address[] calldata rules_
+        IRuleOperation[] calldata rules_
     ) public virtual onlyRole(RULE_ENGINE_OPERATOR_ROLE) {
         if (rules_.length == 0) {
             revert RuleEngine_ArrayIsEmpty();
@@ -48,7 +54,7 @@ abstract contract RuleEngineOperation is
         for(uint256 i = 0; i < rules_.length; ++i){
            _checkRule(address(rules_[i]));
             _rulesOperation.add(address(rules_[i]));
-            emit AddRule(rules_[i]);
+            emit AddRuleOperation(rules_[i]);
         }
 
     }
@@ -72,7 +78,7 @@ abstract contract RuleEngineOperation is
     ) public virtual onlyRole(RULE_ENGINE_OPERATOR_ROLE) {
         _checkRule(address(rule_));
         _rulesOperation.add(address(rule_));
-        emit AddRule(address(rule_));
+        emit AddRuleOperation(rule_);
     }
 
     /**
@@ -88,7 +94,7 @@ abstract contract RuleEngineOperation is
         IRuleOperation rule_
     ) public virtual onlyRole(RULE_ENGINE_OPERATOR_ROLE) {
         require(rulesOperationIsPresent(rule_), RuleEngine_RuleDoNotMatch());
-        _removeRuleOperation(address(rule_));
+        _removeRuleOperation(rule_);
     }
 
     /* ============ View functions ============ */
@@ -139,7 +145,7 @@ abstract contract RuleEngineOperation is
     function _clearRulesOperation() internal virtual {
         // we remove the last element first since it is more optimized.
 
-        emit ClearRules();
+        emit ClearRulesOperation();
         _rulesOperation.clear();
     }
 
@@ -174,9 +180,9 @@ abstract contract RuleEngineOperation is
      *
      *
      */
-    function _removeRuleOperation(address rule_) internal virtual {
-        _rulesOperation.remove(rule_);
-        emit RemoveRule(address(rule_));
+    function _removeRuleOperation(IRuleOperation rule_) internal virtual {
+        _rulesOperation.remove(address(rule_));
+        emit RemoveRuleOperation(rule_);
     }
 
     function _checkRule(address rule_) internal{