Business identifier smart contract

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
 
import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import {AccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 
interface IBusinessPermission {
    function requestBusinessPermissionForUser(address _walletAddress) external;
 
    function removeBusinessPermissionForUser(address _walletAddress) external;
}
 
enum Action {
    ADD,
    REMOVE
}
 
/**
 * @title BusinessContract
 * @dev A contract that represents a business entity.
 */
contract BusinessIdentifier is AccessControlUpgradeable, UUPSUpgradeable {
    /**
     * @dev Role identifier for authorized representatives. (Directors or Office holders)
     */
    bytes32 public constant AUTHORISED_REPRESENTATIVE_ROLE =
        keccak256("AUTHORISED_REPRESENTATIVE");
    /**
     * @dev Role identifier for authorized delegates. (Contractors, Developers, etc.)
     */
    bytes32 public constant AUTHORISED_DELEGATE_ROLE =
        keccak256("AUTHORISED_DELEGATE"); // Contractor, Developers, etc..
 
    /**
     * @dev The name of the company.
     */
    string public companyName;
 
    /**
     * @dev The incorporated name of the company.
     */
    string public incorporatedName;
 
    /**
     * @dev The type of identifier for the company.
     */
    string public identifierType;
 
    /**
     * @dev The identifier for the company.
     */
    string public identifier;
 
    /**
     * @dev The business address of the company.
     */
    string public businessAddress;
 
    /**
     * @dev Boolean indicating if the entity is the beneficial owner of the assets it is managing.
     */
    bool public isBeneficialOwner;
 
    /**
     * @dev An array storing the addresses of smart contracts owned by the business.
     */
    address[] public smartContracts;
 
    /**
     * @dev Sets the max limit for batch operations to prevent high gas usage.
     */
    uint256 public batchLimit;
 
    /**
     * @dev Creates interface to reference AllowedList contract.
     */
    IBusinessPermission private _businessPermission;
 
    error UnauthorisedAccess(string);
    error InvalidAddress(string);
    error BatchSizeExceeded(uint256 actualSize, uint256 maxSize);
    error EmptyAddressArray();
    error InvalidBatchLimit(uint256 limit);
    error RoleUpdateFailed(string);
 
    /**
     * @dev Initializes the contract with the provided parameters.
     * @param _admin The address of the admin account.
     * @param _companyName The name of the company.
     * @param _incorporatedName The incorporated name of the company.
     * @param _identifierType The type of identifier for the company.
     * @param _identifier The identifier for the company.
     * @param _businessAddress The business address of the company.
     * @param _isBeneficialOwner Boolean indicating if the entity is the beneficial owner of the assets it is managing.
     * @param _businessPermissionAddress The address of the business permission contract.
     */
    function initialize(
        address _admin,
        string memory _companyName,
        string memory _incorporatedName,
        string memory _identifierType,
        string memory _identifier,
        string memory _businessAddress,
        bool _isBeneficialOwner,
        address _businessPermissionAddress
    ) public initializer {
        __AccessControl_init();
        __UUPSUpgradeable_init();
        // Grant the Admin role to a specified account
        _grantRole(DEFAULT_ADMIN_ROLE, _admin);
 
        companyName = _companyName;
        incorporatedName = _incorporatedName;
        identifierType = _identifierType;
        identifier = _identifier;
        businessAddress = _businessAddress;
        isBeneficialOwner = _isBeneficialOwner;
        _businessPermission = IBusinessPermission(_businessPermissionAddress);
        batchLimit = 100;
    }
 
    /**
     * @dev Event emitted when a smart contract address is added.
     * @param _address The address of the smart contract.
     * @param _by The address of the caller.
     */
    event SmartContractAdded(address indexed _address, address indexed _by);
 
    /**
     * @dev Event emitted when a smart contract address is removed.
     * @param _address The address of the smart contract.
     * @param _by The address of the caller.
     */
    event SmartContractRemoved(address indexed _address, address indexed _by);
 
    /**
     * @dev Event emitted when a role is updated.
     * @param userAddress The address of the user whose role was updated.
     * @param role The role that was updated.
     * @param action The action performed (ADD or REMOVE).
     * @param message Additional information about the update.
     */
    event RoleUpdated(
        address indexed userAddress,
        bytes32 indexed role,
        Action action,
        string message
    );
 
    event AddressDoesNotExist(address indexed _address, bytes32 indexed role);
    event RoleAlreadyExists(address indexed _address, bytes32 indexed role);
    /**
     * @dev Modifier that allows only contract owner to execute a function.
     */
    modifier onlyAdmin() {
        if (!hasRole(DEFAULT_ADMIN_ROLE, _msgSender())) {
            revert UnauthorisedAccess("Caller must be IDP");
        }
        _;
    }
    /**
     * @dev Modifier that allows only authorized representatives or contract owner to execute a function.
     */
    modifier onlyAuthorisedRepresentative() {
        if (
            !hasRole(AUTHORISED_REPRESENTATIVE_ROLE, _msgSender()) &&
            !hasRole(DEFAULT_ADMIN_ROLE, _msgSender())
        ) {
            revert UnauthorisedAccess(
                "Caller must have IDP or Authorised Representative"
            );
        }
        _;
    }
    /**
     * @dev Modifier that allows only authorized delegates or authorized representatives or contract owner to execute a function.
     */
    modifier onlyAuthorisedDelegate() {
        if (
            !hasRole(AUTHORISED_DELEGATE_ROLE, _msgSender()) &&
            !hasRole(AUTHORISED_REPRESENTATIVE_ROLE, _msgSender()) &&
            !hasRole(DEFAULT_ADMIN_ROLE, _msgSender())
        ) {
            revert UnauthorisedAccess(
                "Caller must have IDP or Authorised Representative or Authorised Delegate"
            );
        }
        _;
    }
 
    /**
     * @dev Modifier to validate batch size and non-empty address array.
     * @param _addresses The array of addresses to check.
     */
    modifier validateBatchSize(address[] memory _addresses) {
        if (_addresses.length == 0) {
            revert EmptyAddressArray();
        }
        if (_addresses.length > batchLimit) {
            revert BatchSizeExceeded(_addresses.length, batchLimit);
        }
        _;
    }
 
    /**
     * @dev Event emitted when the company name is updated.
     * @param _companyName The updated company name.
     */
    event UpdatedCompanyName(string _companyName);
 
    /**
     * @dev Event emitted when the incorporated name is updated.
     * @param _incorporatedName The updated incorporated name.
     */
    event UpdatedIncorporatedName(string _incorporatedName);
 
    /**
     * @dev Event emitted when the identifier type is updated.
     * @param _identifierType The updated identifier type.
     */
    event UpdatedIdentifierType(string _identifierType);
 
    /**
     * @dev Event emitted when the identifier is updated.
     * @param _identifier The updated identifier.
     */
    event UpdatedIdentifier(string _identifier);
 
    /**
     * @dev Event emitted when the business address is updated.
     * @param _businessAddress The updated business address.
     */
    event UpdatedBusinessAddress(string _businessAddress);
 
    /**
     * @dev Event emitted when the beneficial owner status updated.
     * @param _isBeneficialOwner The updated beneficial owner status.
     */
    event UpdatedIsBeneficialOwner(bool _isBeneficialOwner);
 
    /**
     * @dev Updates the company name.
     * @param _companyName The updated company name.
     * Requirements:
     * - Caller must have the DEFAULT_ADMIN_ROLE.
     */
    function updateCompanyName(string memory _companyName) external onlyAdmin {
        companyName = _companyName;
        emit UpdatedCompanyName(_companyName);
    }
 
    /**
     * @dev Updates the incorporated name.
     * @param _incorporatedName The updated incorporated name.
     * Requirements:
     * - Caller must have the DEFAULT_ADMIN_ROLE.
     */
 
    function updateIncorporatedName(
        string memory _incorporatedName
    ) external onlyAdmin {
        incorporatedName = _incorporatedName;
        emit UpdatedIncorporatedName(_incorporatedName);
    }
 
    /**
     * @dev Updates the identifier type.
     * @param _identifierType The updated identifier type.
     * Requirements:
     * - Caller must have the DEFAULT_ADMIN_ROLE.
     */
    function updateIdentifierType(
        string memory _identifierType
    ) external onlyAdmin {
        identifierType = _identifierType;
        emit UpdatedIdentifierType(_identifierType);
    }
 
    /**
     * @dev Updates the identifier.
     * @param _identifier The updated identifier.
     * Requirements:
     * - Caller must have the DEFAULT_ADMIN_ROLE.
     */
    function updateIdentifier(string memory _identifier) external onlyAdmin {
        identifier = _identifier;
        emit UpdatedIdentifier(_identifier);
    }
 
    /**
     * @dev Updates the business address.
     * @param _businessAddress The updated business address.
     * Requirements:
     * - Caller must have the DEFAULT_ADMIN_ROLE.
     */
    function updateBusinessAddress(
        string memory _businessAddress
    ) external onlyAdmin {
        businessAddress = _businessAddress;
        emit UpdatedBusinessAddress(_businessAddress);
    }
 
    /**
     * @dev Updates the beneficial owner status.
     * @param _isBeneficialOwner The updated beneficial owner status.
     * Requirements:
     * - Caller must have the DEFAULT_ADMIN_ROLE.
     */
    function updateIsBeneficialOwner(
        bool _isBeneficialOwner
    ) external onlyAdmin {
        isBeneficialOwner = _isBeneficialOwner;
        emit UpdatedIsBeneficialOwner(_isBeneficialOwner);
    }
 
    /**
     * @dev Adds addresses as authorized representatives.
     * @param _addresses The addresses to be added as authorized representatives.
     * Requirements:
     * - Caller must have the DEFAULT_ADMIN_ROLE.
     */
    function addAuthorisedRepresentative(
        address[] memory _addresses
    ) external onlyAdmin {
        _updateRole(
            _addresses,
            AUTHORISED_REPRESENTATIVE_ROLE,
            Action.ADD,
            _businessPermission.requestBusinessPermissionForUser
        );
    }
 
    /**
     * @dev Removes addresses as authorized representatives.
     * @param _addresses The addresses to be removed as authorized representatives.
     * Requirements:
     * - Caller must have the DEFAULT_ADMIN_ROLE.
     */
    function removeAuthorisedRepresentative(
        address[] memory _addresses
    ) external onlyAdmin {
        _updateRole(
            _addresses,
            AUTHORISED_REPRESENTATIVE_ROLE,
            Action.REMOVE,
            _businessPermission.removeBusinessPermissionForUser
        );
    }
 
    /**
     * @dev Adds addresses as authorized delegates.
     * @param _addresses The addresses to be added as authorized delegates.
     * Requirements:
     * - Caller must have the AUTHORISED_REPRESENTATIVE_ROLE.
     */
    function addAuthorisedDelegate(
        address[] memory _addresses
    ) external onlyAuthorisedRepresentative {
        _updateRole(
            _addresses,
            AUTHORISED_DELEGATE_ROLE,
            Action.ADD,
            _businessPermission.requestBusinessPermissionForUser
        );
    }
 
    /**
     * @dev Removes addresses as authorized delegates.
     * @param _addresses The addresses to be removed as authorized delegates.
     * Requirements:
     * - Caller must have the AUTHORISED_REPRESENTATIVE_ROLE.
     */
    function removeAuthorisedDelegate(
        address[] memory _addresses
    ) external onlyAuthorisedRepresentative {
        _updateRole(
            _addresses,
            AUTHORISED_DELEGATE_ROLE,
            Action.REMOVE,
            _businessPermission.removeBusinessPermissionForUser
        );
    }
 
    /**
     * @dev Updates roles for a batch of addresses, either adding or removing the role.
     * @param _addresses The list of addresses to update roles for.
     * @param role The role to be updated.
     * @param action The action to perform (ADD or REMOVE).
     * @param businessPermissionFn The function to call for business permission operations (request or remove).
     */
    function _updateRole(
        address[] memory _addresses,
        bytes32 role,
        Action action,
        function(address) external businessPermissionFn
    ) internal validateBatchSize(_addresses) {
        for (uint256 i = 0; i < _addresses.length; ) {
            address _address = _addresses[i];
 
            bool hasRoleBefore = hasRole(role, _address);
            bool shouldUpdate = (action == Action.ADD && !hasRoleBefore) ||
                (action == Action.REMOVE && hasRoleBefore);
 
            if (shouldUpdate) {
                try businessPermissionFn(_address) {
                    if (action == Action.ADD) {
                        _grantRole(role, _address);
                        emit RoleUpdated(
                            _address,
                            role,
                            action,
                            "Successfully Added"
                        );
                    } else {
                        _revokeRole(role, _address);
                        emit RoleUpdated(
                            _address,
                            role,
                            action,
                            "Successfully Removed"
                        );
                    }
                } catch (bytes memory reason) {
                    revert RoleUpdateFailed(
                        string(abi.encodePacked("Error:", string(reason)))
                    );
                }
            }
            unchecked {
                i++;
            }
        }
    }
 
    /**
     * @dev Sets the max limit for batch operations to prevent high gas usage.
     * The new batch limit value must be greater than 0 and cannot exceed 100.
     * @param _newLimit The new batch limit value to be set.
     */
    function updateBatchLimit(
        uint256 _newLimit
    ) external onlyAuthorisedRepresentative {
        if (_newLimit == 0) revert InvalidBatchLimit(_newLimit);
        batchLimit = _newLimit;
    }
 
    /**
     * @dev Adds a smart contract address to the list of smart contracts owned by the business.
     * @param _address The address of the smart contract to be added.
     * Requirements:
     * - Caller must be an authorized delegate.
     * - The provided address must not be the zero address.
     */
    function addSmartContract(
        address _address
    ) external onlyAuthorisedDelegate {
        if (_address == address(0)) {
            revert InvalidAddress("Invalid  address.");
        }
        smartContracts.push(_address);
 
        emit SmartContractAdded(_address, _msgSender());
    }
 
    /**
     * @dev Removes a smart contract address from the list of smart contracts owned by the business.
     * @param _address The address of the smart contract to be removed.
     * Requirements:
     * - Caller must be an authorized delegate.
     */
    function removeSmartContract(
        address _address
    ) external onlyAuthorisedDelegate {
        for (uint256 i = 0; i < smartContracts.length; ) {
            if (smartContracts[i] == _address) {
                smartContracts[i] = smartContracts[smartContracts.length - 1];
                smartContracts.pop();
                break;
            }
            unchecked {
                i++;
            }
        }
 
        emit SmartContractRemoved(_address, _msgSender());
    }
 
    /**
     * @dev Internal function to authorize an upgrade to a new implementation.
     * @param newImplementation The address of the new implementation contract.
     * Requirements:
     * - Caller must have the DEFAULT_ADMIN_ROLE.
     */
    function _authorizeUpgrade(
        address newImplementation
    ) internal override onlyRole(DEFAULT_ADMIN_ROLE) {}
}