refactor(contracts): apply new naming conventions to contracts

Author: 0xjei

…cts/src/core/checker/AdvancedChecker.sol …s/contracts/src/core/AdvancedChecker.solpackages/contracts/contracts/src/core/checker/AdvancedChecker.sol renamed to packages/contracts/contracts/src/core/AdvancedChecker.sol packages/contracts/contracts/src/core/checker/AdvancedChecker.sol renamed to packages/contracts/contracts/src/core/AdvancedChecker.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.27;
 
-import {IAdvancedChecker, Check} from "./IAdvancedChecker.sol";
+import {IAdvancedChecker, Check} from "./interfaces/IAdvancedChecker.sol";
 
 struct CheckStatus {
     bool pre;
@@ -34,42 +34,46 @@ abstract contract AdvancedChecker is IAdvancedChecker {
         allowMultipleMain = _allowMultipleMain;
     }
 
-    /// @notice Public method to check the validity of the provided data for a given address and check type.
-    /// @param passerby The address to be checked.
-    /// @param data The data associated with the check.
+    /// @notice Public method to check the validity of the provided evidence for a given address and check type.
+    /// @param subject The address to be checked.
+    /// @param evidence The evidence associated with the check.
     /// @param checkType The type of check to perform (PRE, MAIN, POST).
-    function check(address passerby, bytes memory data, Check checkType) external view override returns (bool checked) {
-        return _check(passerby, data, checkType);
+    function check(
+        address subject,
+        bytes memory evidence,
+        Check checkType
+    ) external view override returns (bool checked) {
+        return _check(subject, evidence, checkType);
     }
 
     /// @notice Internal method to orchestrate the validation process based on the specified check type.
-    /// @param passerby The address to be checked.
-    /// @param data The data associated with the check.
+    /// @param subject The address to be checked.
+    /// @param evidence The evidence associated with the check.
     /// @param checkType The type of check to perform (PRE, MAIN, POST).
-    function _check(address passerby, bytes memory data, Check checkType) internal view returns (bool checked) {
+    function _check(address subject, bytes memory evidence, Check checkType) internal view returns (bool checked) {
         if (!skipPre && checkType == Check.PRE) {
-            return _checkPre(passerby, data);
+            return _checkPre(subject, evidence);
         } else if (!skipPost && checkType == Check.POST) {
-            return _checkPost(passerby, data);
+            return _checkPost(subject, evidence);
         } else if (checkType == Check.MAIN) {
-            return _checkMain(passerby, data);
+            return _checkMain(subject, evidence);
         }
 
         return false;
     }
 
     /// @notice Internal method for performing pre-condition checks.
-    /// @param passerby The address to be checked.
-    /// @param data The data associated with the check.
-    function _checkPre(address passerby, bytes memory data) internal view virtual returns (bool checked) {}
+    /// @param subject The address to be checked.
+    /// @param evidence The evidence associated with the check.
+    function _checkPre(address subject, bytes memory evidence) internal view virtual returns (bool checked) {}
 
     /// @notice Internal method for performing main checks.
-    /// @param passerby The address to be checked.
-    /// @param data The data associated with the check.
-    function _checkMain(address passerby, bytes memory data) internal view virtual returns (bool checked) {}
+    /// @param subject The address to be checked.
+    /// @param evidence The evidence associated with the check.
+    function _checkMain(address subject, bytes memory evidence) internal view virtual returns (bool checked) {}
 
     /// @notice Internal method for performing post-condition checks.
-    /// @param passerby The address to be checked.
-    /// @param data The data associated with the check.
-    function _checkPost(address passerby, bytes memory data) internal view virtual returns (bool checked) {}
+    /// @param subject The address to be checked.
+    /// @param evidence The evidence associated with the check.
+    function _checkPost(address subject, bytes memory evidence) internal view virtual returns (bool checked) {}
 }

packages/contracts/contracts/src/core/AdvancedPolicy.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.27;
+
+import {Policy} from "./Policy.sol";
+import {IAdvancedPolicy, Check} from "./interfaces/IAdvancedPolicy.sol";
+import {AdvancedChecker, CheckStatus} from "./AdvancedChecker.sol";
+
+/// @title AdvancedPolicy
+/// @notice Abstract base contract which can be extended to implement a specific `AdvancedPolicy`.
+abstract contract AdvancedPolicy is IAdvancedPolicy, Policy {
+    /// @dev Reference to the AdvancedChecker contract for validation.
+    AdvancedChecker public immutable ADVANCED_CHECKER;
+
+    /// @dev Tracks the check status of each address.
+    mapping(address => mapping(address => CheckStatus)) public enforced;
+
+    /// @notice Constructor to initialize the AdvancedChecker contract.
+    /// @param _advancedChecker The address of the AdvancedChecker contract.
+    constructor(AdvancedChecker _advancedChecker) {
+        ADVANCED_CHECKER = _advancedChecker;
+    }
+
+    /// @notice Enforces the custom target logic.
+    /// @dev Calls the internal `_enforce` function to enforce the target logic.
+    /// @dev Must call the `check` to handle the logic of checking subject for specific target.
+    /// @param subject The address of those who have successfully enforced the check.
+    /// @param evidence Additional data required for the check (e.g., encoded token identifier).
+    /// @param checkType The type of the check to be enforced for the subject with the given data.
+    function enforce(address subject, bytes calldata evidence, Check checkType) external override onlyTarget {
+        _enforce(subject, evidence, checkType);
+    }
+
+    /// @notice Internal function to enforce the target logic.
+    /// @param subject The address of those who have successfully enforced the check.
+    /// @param evidence Additional data required for the check (e.g., encoded token identifier).
+    /// @param checkType The type of the check to be enforced for the subject with the given data.
+    function _enforce(address subject, bytes calldata evidence, Check checkType) internal {
+        bool checked = ADVANCED_CHECKER.check(subject, evidence, checkType);
+
+        if (!checked) revert UnsuccessfulCheck();
+
+        if (checkType == Check.PRE) {
+            if (ADVANCED_CHECKER.skipPre()) revert PreCheckSkipped();
+            else if (enforced[msg.sender][subject].pre) revert AlreadyEnforced();
+            else enforced[msg.sender][subject].pre = true;
+        } else if (checkType == Check.POST) {
+            if (ADVANCED_CHECKER.skipPost()) revert PostCheckSkipped();
+            else if (enforced[msg.sender][subject].post) revert AlreadyEnforced();
+            else enforced[msg.sender][subject].post = true;
+        } else if (checkType == Check.MAIN) {
+            if (!ADVANCED_CHECKER.allowMultipleMain() && enforced[msg.sender][subject].main > 0) {
+                revert MainCheckAlreadyEnforced();
+            } else {
+                enforced[msg.sender][subject].main += 1;
+            }
+        }
+
+        emit Enforced(subject, target, evidence, checkType);
+    }
+}

packages/contracts/contracts/src/core/BaseChecker.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.27;
+
+import {IBaseChecker} from "./interfaces/IBaseChecker.sol";
+
+/// @title BaseChecker.
+/// @notice Abstract base contract which can be extended to implement a specific `BaseChecker`.
+/// @dev The `BaseChecker` contract provides a foundational structure for implementing specific checker logic.
+/// It defines a method `check` that invokes a protected `_check` method, which must be implemented by derived
+/// contracts.
+abstract contract BaseChecker is IBaseChecker {
+    /// @notice Checks the validity of the provided evidence for a given address.
+    /// @param subject The address to be checked.
+    /// @param evidence The evidence associated with the check.
+    function check(address subject, bytes memory evidence) external view override returns (bool checked) {
+        return _check(subject, evidence);
+    }
+
+    /// @notice Internal method to perform the actual check logic.
+    /// @param subject The address to be checked.
+    /// @param evidence The evidence associated with the check.
+    function _check(address subject, bytes memory evidence) internal view virtual returns (bool checked);
+}

packages/contracts/contracts/src/core/BasePolicy.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.27;
+
+import {IBasePolicy} from "./interfaces/IBasePolicy.sol";
+import {Policy} from "./Policy.sol";
+import {BaseChecker} from "./BaseChecker.sol";
+
+/// @title BasePolicy
+/// @notice Abstract base contract which can be extended to implement a specific `BasePolicy`.
+abstract contract BasePolicy is Policy, IBasePolicy {
+    /// @dev Reference to the BaseChecker contract for validation.
+    BaseChecker public immutable BASE_CHECKER;
+
+    /// @dev Tracks whether the check has been enforced for a subject.
+    mapping(address => mapping(address => bool)) public enforced;
+
+    /// @notice Constructor to initialize the BaseChecker contract.
+    /// @param _baseChecker The address of the BaseChecker contract.
+    constructor(BaseChecker _baseChecker) {
+        BASE_CHECKER = _baseChecker;
+    }
+
+    /// @notice Enforces the custom target enforcing logic.
+    /// @dev Must call the `check` to handle the logic of checking subject for specific target.
+    /// @param subject The address of those who have successfully enforced the check.
+    /// @param evidence Additional data required for the check (e.g., encoded token identifier).
+    function enforce(address subject, bytes calldata evidence) external override onlyTarget {
+        _enforce(subject, evidence);
+    }
+
+    /// @notice Enforces the custom target enforcing logic.
+    /// @param subject The address of those who have successfully enforced the check.
+    /// @param evidence Additional data required for the check (e.g., encoded token identifier).
+    function _enforce(address subject, bytes calldata evidence) internal {
+        bool checked = BASE_CHECKER.check(subject, evidence);
+
+        if (enforced[msg.sender][subject]) revert AlreadyEnforced();
+        if (!checked) revert UnsuccessfulCheck();
+
+        enforced[msg.sender][subject] = checked;
+
+        emit Enforced(subject, target, evidence);
+    }
+}

packages/contracts/contracts/src/core/Policy.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.27;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IPolicy} from "./interfaces/IPolicy.sol";
+
+/// @title Policy abstract contract.
+/// @dev This contract implements the IPolicy interface and manages the target address.
+abstract contract Policy is IPolicy, Ownable(msg.sender) {
+    /// @notice The Policy-protected contract address.
+    /// @dev The target can be any contract address that requires a prior check to enable logic.
+    /// For example, the target is a Semaphore group that requires the subject
+    /// to meet certain criteria before joining.
+    address public target;
+
+    /// @notice Modifier that restricts access to the target address.
+    modifier onlyTarget() {
+        if (msg.sender != target) revert TargetOnly();
+        _;
+    }
+
+    /// @notice Sets the target address.
+    /// @dev Only the owner can set the destination `target` address.
+    /// @param _target The address of the contract to be set as the target.
+    function setTarget(address _target) public virtual onlyOwner {
+        if (_target == address(0)) revert ZeroAddress();
+        if (target != address(0)) revert TargetAlreadySet();
+
+        target = _target;
+
+        emit TargetSet(_target);
+    }
+}