Compliant Smart Contract Solutions

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@pixelpal/contracts/MiCACompliant.sol";
import "@pixelpal/contracts/ComplianceModule.sol";

contract ControlledAccess is Initializable, PixelPalBase {
    using SafeERC20 for IERC20;
    
    address public admin;
    address public complianceModule;
    
    struct Entity {
        bool isVerified; 
        address wallet;
        bool isAuthorized;
        bool isBlocked;
    }
    
    mapping(address => Entity) public entities;
    
    event EntityAdded(address indexed wallet);
    event EntityUpdated(address indexed wallet, bool status);
    event ComplianceModuleSet(address indexed module);
    
    function initialize(address _admin, address _complianceModule) external initializer {
        require(_admin != address(0), "Invalid admin");
        admin = _admin;
        complianceModule = _complianceModule;
        emit ComplianceModuleSet(_complianceModule);
    }
    
    modifier onlyAdmin() {
        require(msg.sender == admin, "Only admin");
        _;
    }
    
    function setCompliance(address _module) external onlyAdmin {
        require(_module != address(0), "Invalid module");
        complianceModule = _module;
        emit ComplianceModuleSet(_module);
    }
    
    function addEntity(address _wallet, bool _isVerified, bool _isAuthorized) 
        external 
        onlyAdmin 
    {
        require(_wallet != address(0), "Invalid wallet");
        require(!entities[_wallet].isVerified, "Entity already exists");
        
        entities[_wallet] = Entity({
            isVerified: _isVerified,
            wallet: _wallet,
            isAuthorized: _isAuthorized,
            isBlocked: false
        });
        
        emit EntityAdded(_wallet);
    }
    
    function updateEntityStatus(address _wallet, bool _status) 
        external 
        onlyAdmin 
    {
        require(entities[_wallet].isVerified, "Entity does not exist");
        entities[_wallet].isAuthorized = _status;
        emit EntityUpdated(_wallet, _status);
    }
    
    function blockEntity(address _wallet) 
        external 
        onlyAdmin 
    {
        require(entities[_wallet].isVerified, "Entity does not exist");
        entities[_wallet].isBlocked = true;
        entities[_wallet].isAuthorized = false;
        emit EntityUpdated(_wallet, false);
    }
    
    function checkAccess(address _user) external view returns(bool) {
        return entities[_user].isVerified && 
               entities[_user].isAuthorized && 
               !entities[_user].isBlocked && 
               IComplianceModule(complianceModule).checkCompliance(_user);
    }
    
    function canPerform(address _account, bytes4 _action) external view returns (bool) {
        return _account == admin || entities[_account].isAuthorized;
    }
    
    function transferAdmin(address _newAdmin) external onlyAdmin {
        require(_newAdmin != address(0), "Invalid address");
        admin = _newAdmin;
    }
}