+
+ Branch data Line data Source code
+
+ 1 : : // SPDX-License-Identifier: MPL-2.0
+ 2 : :
+ 3 : : pragma solidity ^0.8.20;
+ 4 : :
+ 5 : : import "CMTAT/mocks/RuleEngine/interfaces/IRule.sol";
+ 6 : : import "CMTAT/mocks/RuleEngine/interfaces/IRuleEngine.sol";
+ 7 : : import "./modules/MetaTxModuleStandalone.sol";
+ 8 : : import "../lib/openzeppelin-contracts/contracts/access/AccessControl.sol";
+ 9 : :
+ 10 : : /**
+ 11 : : @title Implementation of a ruleEngine defined by the CMTAT
+ 12 : : */
+ 13 : : contract RuleEngine is IRuleEngine, AccessControl, MetaTxModuleStandalone {
+ 14 : : error RuleEngine_RuleAddressZeroNotAllowed();
+ 15 : : error RuleEngine_RuleAlreadyExists();
+ 16 : : error RuleEngine_RuleDoNotMatch();
+ 17 : : error RuleEngine_AdminWithAddressZeroNotAllowed();
+ 18 : : error RuleEngine_ArrayIsEmpty();
+ 19 : : /// @dev Role to manage the ruleEngine
+ 20 : : bytes32 public constant RULE_ENGINE_ROLE = keccak256("RULE_ENGINE_ROLE");
+ 21 : : /// @dev Indicate if a rule already exists
+ 22 : : mapping(IRule => bool) _ruleIsPresent;
+ 23 : : /// @dev Array of rules
+ 24 : : IRule[] internal _rules;
+ 25 : : /// @notice Generate when a rule is added
+ 26 : : event AddRule(IRule indexed rule);
+ 27 : : /// @notice Generate when a rule is removed
+ 28 : : event RemoveRule(IRule indexed rule);
+ 29 : : /// @notice Generate when all the rules are cleared
+ 30 : : event ClearRules(IRule[] rulesRemoved);
+ 31 : :
+ 32 : : /**
+ 33 : : * @param admin Address of the contract (Access Control)
+ 34 : : * @param forwarderIrrevocable Address of the forwarder, required for the gasless support
+ 35 : : */
+ 36 : : constructor(
+ 37 : : address admin,
+ 38 : : address forwarderIrrevocable
+ 39 : : ) MetaTxModuleStandalone(forwarderIrrevocable) {
+ 40 : : if(admin == address(0))
+ 41 : : {
+ 42 : : revert RuleEngine_AdminWithAddressZeroNotAllowed();
+ 43 : : }
+ 44 : : _grantRole(DEFAULT_ADMIN_ROLE, admin);
+ 45 : : _grantRole(RULE_ENGINE_ROLE, admin);
+ 46 : : }
+ 47 : :
+ 48 : : /**
+ 49 : : * @notice Set all the rules, will overwrite all the previous rules. \n
+ 50 : : * Revert if one rule is a zero address or if the rule is already present
+ 51 : : *
+ 52 : : */
+ 53 : : function setRules(
+ 54 : : IRule[] calldata rules_
+ 55 : : ) external override onlyRole(RULE_ENGINE_ROLE) {
+ 56 [ + + ]: 9 : if(rules_.length == 0){
+ 57 : 1 : revert RuleEngine_ArrayIsEmpty();
+ 58 : : }
+ 59 : 8 : for (uint256 i = 0; i < rules_.length; ) {
+ 60 [ + + ]: 15 : if( address(rules_[i]) == address(0x0)){
+ 61 : 1 : revert RuleEngine_RuleAddressZeroNotAllowed();
+ 62 : : }
+ 63 [ + + ]: 14 : if(_ruleIsPresent[rules_[i]]){
+ 64 : 1 : revert RuleEngine_RuleAlreadyExists();
+ 65 : : }
+ 66 : 13 : _ruleIsPresent[rules_[i]] = true;
+ 67 : 13 : emit AddRule(rules_[i]);
+ 68 : : unchecked {
+ 69 : 13 : ++i;
+ 70 : : }
+ 71 : : }
+ 72 : 6 : _rules = rules_;
+ 73 : : }
+ 74 : :
+ 75 : : /**
+ 76 : : * @notice Clear all the rules of the array of rules
+ 77 : : *
+ 78 : : */
+ 79 : : function clearRules() public onlyRole(RULE_ENGINE_ROLE) {
+ 80 : 2 : emit ClearRules(_rules);
+ 81 : 2 : _rules = new IRule[](0);
+ 82 : : }
+ 83 : :
+ 84 : : /**
+ 85 : : * @notice Add a rule to the array of rules
+ 86 : : * Revert if one rule is a zero address or if the rule is already present
+ 87 : : *
+ 88 : : */
+ 89 : : function addRule(IRule rule_) public onlyRole(RULE_ENGINE_ROLE) {
+ 90 [ + + ]: 8 : if( address(rule_) == address(0x0))
+ 91 : : {
+ 92 : 1 : revert RuleEngine_RuleAddressZeroNotAllowed();
+ 93 : : }
+ 94 [ + + ]: 7 : if( _ruleIsPresent[rule_])
+ 95 : : {
+ 96 : 1 : revert RuleEngine_RuleAlreadyExists();
+ 97 : : }
+ 98 : 6 : _rules.push(rule_);
+ 99 : 6 : _ruleIsPresent[rule_] = true;
+ 100 : 6 : emit AddRule(rule_);
+ 101 : : }
+ 102 : :
+ 103 : : /**
+ 104 : : * @notice Remove a rule from the array of rules
+ 105 : : * Revert if the rule found at the specified index does not match the rule in argument
+ 106 : : * @param rule_ address of the target rule
+ 107 : : * @param index the position inside the array of rule
+ 108 : : * @dev To reduce the array size, the last rule is moved to the location occupied
+ 109 : : * by the rule to remove
+ 110 : : *
+ 111 : : *
+ 112 : : */
+ 113 : : function removeRule(
+ 114 : : IRule rule_,
+ 115 : : uint256 index
+ 116 : : ) public onlyRole(RULE_ENGINE_ROLE) {
+ 117 [ + + ]: 5 : if(_rules[index] != rule_)
+ 118 : : {
+ 119 : 1 : revert RuleEngine_RuleDoNotMatch();
+ 120 : : }
+ 121 [ # + ]: 4 : if (index != _rules.length - 1) {
+ 122 : 2 : _rules[index] = _rules[_rules.length - 1];
+ 123 : : }
+ 124 : 4 : _rules.pop();
+ 125 : 4 : _ruleIsPresent[rule_] = false;
+ 126 : 4 : emit RemoveRule(rule_);
+ 127 : : }
+ 128 : :
+ 129 : : /**
+ 130 : : * @return The number of rules inside the array
+ 131 : : */
+ 132 : : function rulesCount() external view override returns (uint256) {
+ 133 : 20 : return _rules.length;
+ 134 : : }
+ 135 : :
+ 136 : : /**
+ 137 : : * @notice Get the index of a rule inside the list
+ 138 : : * @return index if the rule is found, _rules.length otherwise
+ 139 : : */
+ 140 : : function getRuleIndex(IRule rule_) external view returns (uint256 index) {
+ 141 : 0 : for (index = 0; index < _rules.length; ) {
+ 142 [ + + ]: 5 : if (_rules[index] == rule_) {
+ 143 : 5 : return index;
+ 144 : : }
+ 145 : : unchecked {
+ 146 : 3 : ++index;
+ 147 : : }
+ 148 : : }
+ 149 : 1 : return _rules.length;
+ 150 : : }
+ 151 : :
+ 152 : : /**
+ 153 : : * @notice Get the rule at the position specified by ruleId
+ 154 : : * @param ruleId index of the rule
+ 155 : : * @return a rule address
+ 156 : : */
+ 157 : : function rule(uint256 ruleId) external view override returns (IRule) {
+ 158 : 1 : return _rules[ruleId];
+ 159 : : }
+ 160 : :
+ 161 : : /**
+ 162 : : * @notice Get all the rules
+ 163 : : * @return An array of rules
+ 164 : : */
+ 165 : : function rules() external view override returns (IRule[] memory) {
+ 166 : 4 : return _rules;
+ 167 : : }
+ 168 : :
+ 169 : : /**
+ 170 : : * @notice Go through all the rule to know if a restriction exists on the transfer
+ 171 : : * @param _from the origin address
+ 172 : : * @param _to the destination address
+ 173 : : * @param _amount to transfer
+ 174 : : * @return The restricion code or REJECTED_CODE_BASE.TRANSFER_OK
+ 175 : : **/
+ 176 : : function detectTransferRestriction(
+ 177 : : address _from,
+ 178 : : address _to,
+ 179 : : uint256 _amount
+ 180 : : ) public view override returns (uint8) {
+ 181 : 17 : for (uint256 i = 0; i < _rules.length; ) {
+ 182 : 17 : uint8 restriction = _rules[i].detectTransferRestriction(
+ 183 : : _from,
+ 184 : : _to,
+ 185 : : _amount
+ 186 : : );
+ 187 [ + + ]: 17 : if (restriction > 0) {
+ 188 : 12 : return restriction;
+ 189 : : }
+ 190 : : unchecked {
+ 191 : 5 : ++i;
+ 192 : : }
+ 193 : : }
+ 194 : 5 : return uint8(REJECTED_CODE_BASE.TRANSFER_OK);
+ 195 : : }
+ 196 : :
+ 197 : : /**
+ 198 : : * @notice Validate a transfer
+ 199 : : * @param _from the origin address
+ 200 : : * @param _to the destination address
+ 201 : : * @param _amount to transfer
+ 202 : : * @return True if the transfer is valid, false otherwise
+ 203 : : **/
+ 204 : : function validateTransfer(
+ 205 : : address _from,
+ 206 : : address _to,
+ 207 : : uint256 _amount
+ 208 : : ) public view override returns (bool) {
+ 209 : 10 : return detectTransferRestriction(_from, _to, _amount) == uint8(REJECTED_CODE_BASE.TRANSFER_OK);
+ 210 : : }
+ 211 : :
+ 212 : : /**
+ 213 : : * @notice Return the message corresponding to the code
+ 214 : : * @param _restrictionCode The target restriction code
+ 215 : : * @return True if the transfer is valid, false otherwise
+ 216 : : **/
+ 217 : : function messageForTransferRestriction(
+ 218 : : uint8 _restrictionCode
+ 219 : : ) external view override returns (string memory) {
+ 220 : 6 : for (uint256 i = 0; i < _rules.length; ) {
+ 221 [ # + ]: 5 : if (_rules[i].canReturnTransferRestrictionCode(_restrictionCode)) {
+ 222 : 4 : return
+ 223 : : _rules[i].messageForTransferRestriction(_restrictionCode);
+ 224 : : }
+ 225 : : unchecked {
+ 226 : 1 : ++i;
+ 227 : : }
+ 228 : : }
+ 229 : 2 : return "Unknown restriction code";
+ 230 : : }
+ 231 : :
+ 232 : : /**
+ 233 : : * @dev This surcharge is not necessary if you do not use the MetaTxModule
+ 234 : : */
+ 235 : : function _msgSender()
+ 236 : : internal
+ 237 : : view
+ 238 : : override(MetaTxModuleStandalone, Context)
+ 239 : : returns (address sender)
+ 240 : : {
+ 241 : 38 : return MetaTxModuleStandalone._msgSender();
+ 242 : : }
+ 243 : :
+ 244 : : /**
+ 245 : : * @dev This surcharge is not necessary if you do not use the MetaTxModule
+ 246 : : */
+ 247 : : function _msgData()
+ 248 : : internal
+ 249 : : view
+ 250 : : override(MetaTxModuleStandalone, Context)
+ 251 : : returns (bytes calldata)
+ 252 : : {
+ 253 : 0 : return MetaTxModuleStandalone._msgData();
+ 254 : : }
+ 255 : : }
+
+ |
+
+ 
