@etherisc/gif-next 0.0.2-cff6256-424 → 0.0.2-cffb0b6-814

package/contracts/instance/IAccessManagerSimple.sol

@@ -1,391 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAccessManager.sol)
-
-pragma solidity ^0.8.20;
-
-import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
-
-interface IAccessManagerSimple {
-    /**
-     * @dev A delayed operation was scheduled.
-     */
-    event OperationScheduled(
-        bytes32 indexed operationId,
-        uint32 indexed nonce,
-        uint48 schedule,
-        address caller,
-        address target,
-        bytes data
-    );
-
-    /**
-     * @dev A scheduled operation was executed.
-     */
-    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);
-
-    /**
-     * @dev A scheduled operation was canceled.
-     */
-    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);
-
-    /**
-     * @dev Informational labelling for a roleId.
-     */
-    event RoleLabel(uint64 indexed roleId, string label);
-
-    /**
-     * @dev Emitted when `account` is granted `roleId`.
-     *
-     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.
-     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,
-     * otherwise it indicates the execution delay for this account and roleId is updated.
-     */
-    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);
-
-    /**
-     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.
-     */
-    event RoleRevoked(uint64 indexed roleId, address indexed account);
-
-    /**
-     * @dev Role acting as admin over a given `roleId` is updated.
-     */
-    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);
-
-    /**
-     * @dev Role acting as guardian over a given `roleId` is updated.
-     */
-    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);
-
-    /**
-     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.
-     */
-    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);
-
-    /**
-     * @dev Target mode is updated (true = closed, false = open).
-     */
-    event TargetClosed(address indexed target, bool closed);
-
-    /**
-     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.
-     */
-    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);
-
-    /**
-     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.
-     */
-    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);
-
-    error AccessManagerAlreadyScheduled(bytes32 operationId);
-    error AccessManagerNotScheduled(bytes32 operationId);
-    error AccessManagerNotReady(bytes32 operationId);
-    error AccessManagerExpired(bytes32 operationId);
-    error AccessManagerLockedAccount(address account);
-    error AccessManagerLockedRole(uint64 roleId);
-    error AccessManagerBadConfirmation();
-    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);
-    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);
-    error AccessManagerUnauthorizedConsume(address target);
-    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);
-    error AccessManagerInvalidInitialAdmin(address initialAdmin);
-
-    /**
-     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with
-     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}
-     * & {execute} workflow.
-     *
-     * This function is usually called by the targeted contract to control immediate execution of restricted functions.
-     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a
-     * previously set delay (not zero), then the function should return false and the caller should schedule the operation
-     * for future execution.
-     *
-     * If `immediate` is true, the delay can be disregarded and the operation can be immediately executed, otherwise
-     * the operation can be executed if and only if delay is greater than 0.
-     *
-     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that
-     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail
-     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.
-     *
-     * NOTE: This function does not report the permissions of this manager itself. These are defined by the
-     * {_canCallSelf} function instead.
-     */
-    function canCall(
-        address caller,
-        address target,
-        bytes4 selector
-    ) external view returns (bool allowed, uint32 delay);
-
-    /**
-     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.
-     *
-     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,
-     * disabling any scheduling usage.
-     */
-    function expiration() external view returns (uint32);
-
-    /**
-     * @dev Minimum setback for all delay updates, with the exception of execution delays. It
-     * can be increased without setback (and reset via {revokeRole} in the case event of an
-     * accidental increase). Defaults to 5 days.
-     */
-    function minSetback() external view returns (uint32);
-
-    /**
-     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.
-     */
-    function isTargetClosed(address target) external view returns (bool);
-
-    /**
-     * @dev Get the role required to call a function.
-     */
-    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);
-
-    /**
-     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.
-     */
-    function getTargetAdminDelay(address target) external view returns (uint32);
-
-    /**
-     * @dev Get the id of the role that acts as an admin for the given role.
-     *
-     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute
-     * an operation that is restricted to this role.
-     */
-    function getRoleAdmin(uint64 roleId) external view returns (uint64);
-
-    /**
-     * @dev Get the role that acts as a guardian for a given role.
-     *
-     * The guardian permission allows canceling operations that have been scheduled under the role.
-     */
-    function getRoleGuardian(uint64 roleId) external view returns (uint64);
-
-    /**
-     * @dev Get the role current grant delay.
-     *
-     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.
-     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.
-     */
-    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);
-
-    /**
-     * @dev Get the access details for a given account for a given role. These details include the timepoint at which
-     * membership becomes active, and the delay applied to all operation by this user that requires this permission
-     * level.
-     *
-     * Returns:
-     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.
-     * [1] Current execution delay for the account.
-     * [2] Pending execution delay for the account.
-     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.
-     */
-    function getAccess(uint64 roleId, address account) external view returns (uint48, uint32, uint32, uint48);
-
-    /**
-     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this
-     * permission might be associated with an execution delay. {getAccess} can provide more details.
-     */
-    function hasRole(uint64 roleId, address account) external view returns (bool, uint32);
-
-    /**
-     * @dev Give a label to a role, for improved role discoverability by UIs.
-     *
-     * Requirements:
-     *
-     * - the caller must be a global admin
-     *
-     * Emits a {RoleLabel} event.
-     */
-    function labelRole(uint64 roleId, string calldata label) external;
-
-    /**
-     * @dev Add `account` to `roleId`, or change its execution delay.
-     *
-     * This gives the account the authorization to call any function that is restricted to this role. An optional
-     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation
-     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has
-     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).
-     *
-     * If the account has already been granted this role, the execution delay will be updated. This update is not
-     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is
-     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any
-     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.
-     *
-     * Requirements:
-     *
-     * - the caller must be an admin for the role (see {getRoleAdmin})
-     * - granted role must not be the `PUBLIC_ROLE`
-     *
-     * Emits a {RoleGranted} event.
-     */
-    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;
-
-    /**
-     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has
-     * no effect.
-     *
-     * Requirements:
-     *
-     * - the caller must be an admin for the role (see {getRoleAdmin})
-     * - revoked role must not be the `PUBLIC_ROLE`
-     *
-     * Emits a {RoleRevoked} event if the account had the role.
-     */
-    function revokeRole(uint64 roleId, address account) external;
-
-    /**
-     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in
-     * the role this call has no effect.
-     *
-     * Requirements:
-     *
-     * - the caller must be `callerConfirmation`.
-     *
-     * Emits a {RoleRevoked} event if the account had the role.
-     */
-    function renounceRole(uint64 roleId, address callerConfirmation) external;
-
-    /**
-     * @dev Change admin role for a given role.
-     *
-     * Requirements:
-     *
-     * - the caller must be a global admin
-     *
-     * Emits a {RoleAdminChanged} event
-     */
-    function setRoleAdmin(uint64 roleId, uint64 admin) external;
-
-    /**
-     * @dev Change guardian role for a given role.
-     *
-     * Requirements:
-     *
-     * - the caller must be a global admin
-     *
-     * Emits a {RoleGuardianChanged} event
-     */
-    function setRoleGuardian(uint64 roleId, uint64 guardian) external;
-
-    /**
-     * @dev Update the delay for granting a `roleId`.
-     *
-     * Requirements:
-     *
-     * - the caller must be a global admin
-     *
-     * Emits a {RoleGrantDelayChanged} event.
-     */
-    function setGrantDelay(uint64 roleId, uint32 newDelay) external;
-
-    /**
-     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.
-     *
-     * Requirements:
-     *
-     * - the caller must be a global admin
-     *
-     * Emits a {TargetFunctionRoleUpdated} event per selector.
-     */
-    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;
-
-    /**
-     * @dev Set the delay for changing the configuration of a given target contract.
-     *
-     * Requirements:
-     *
-     * - the caller must be a global admin
-     *
-     * Emits a {TargetAdminDelayUpdated} event.
-     */
-    function setTargetAdminDelay(address target, uint32 newDelay) external;
-
-    /**
-     * @dev Set the closed flag for a contract.
-     *
-     * Requirements:
-     *
-     * - the caller must be a global admin
-     *
-     * Emits a {TargetClosed} event.
-     */
-    function setTargetClosed(address target, bool closed) external;
-
-    /**
-     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the
-     * operation is not yet scheduled, has expired, was executed, or was canceled.
-     */
-    function getSchedule(bytes32 id) external view returns (uint48);
-
-    /**
-     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never
-     * been scheduled.
-     */
-    function getNonce(bytes32 id) external view returns (uint32);
-
-    /**
-     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to
-     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays
-     * required for the caller. The special value zero will automatically set the earliest possible time.
-     *
-     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when
-     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this
-     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.
-     *
-     * Emits a {OperationScheduled} event.
-     *
-     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If
-     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target
-     * contract if it is using standard Solidity ABI encoding.
-     */
-    function schedule(address target, bytes calldata data, uint48 when) external returns (bytes32, uint32);
-
-    /**
-     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the
-     * execution delay is 0.
-     *
-     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the
-     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).
-     *
-     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.
-     */
-    function execute(address target, bytes calldata data) external payable returns (uint32);
-
-    /**
-     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled
-     * operation that is cancelled.
-     *
-     * Requirements:
-     *
-     * - the caller must be the proposer, a guardian of the targeted function, or a global admin
-     *
-     * Emits a {OperationCanceled} event.
-     */
-    function cancel(address caller, address target, bytes calldata data) external returns (uint32);
-
-    /**
-     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed
-     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.
-     *
-     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,
-     * with all the verifications that it implies.
-     *
-     * Emit a {OperationExecuted} event.
-     */
-    function consumeScheduledOp(address caller, bytes calldata data) external;
-
-    /**
-     * @dev Hashing function for delayed operations.
-     */
-    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);
-
-    /**
-     * @dev Changes the authority of a target managed by this manager instance.
-     *
-     * Requirements:
-     *
-     * - the caller must be a global admin
-     */
-    function updateAuthority(address target, address newAuthority) external;
-}

package/contracts/instance/InstanceAccessManager.sol

@@ -1,288 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
-
-import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
-import {ShortString, ShortStrings} from "@openzeppelin/contracts/utils/ShortStrings.sol";
-
-import {AccessManagedSimple} from "./AccessManagedSimple.sol";
-import {AccessManagerSimple} from "./AccessManagerSimple.sol";
-import {IBundle} from "./module/IBundle.sol";
-import {IPolicy} from "./module/IPolicy.sol";
-import {IRisk} from "./module/IRisk.sol";
-import {ISetup} from "./module/ISetup.sol";
-import {Key32, KeyId, Key32Lib} from "../types/Key32.sol";
-import {KeyValueStore} from "./base/KeyValueStore.sol";
-import {NftId} from "../types/NftId.sol";
-import {NumberId} from "../types/NumberId.sol";
-import {ObjectType, BUNDLE, DISTRIBUTION, POLICY, POOL, ROLE, PRODUCT, TARGET} from "../types/ObjectType.sol";
-import {RiskId, RiskIdLib} from "../types/RiskId.sol";
-import {RoleId, RoleIdLib} from "../types/RoleId.sol";
-import {StateId, ACTIVE} from "../types/StateId.sol";
-import {Timestamp, TimestampLib} from "../types/Timestamp.sol";
-
-contract InstanceAccessManager is
-    AccessManagedSimple
-{
-    string public constant ADMIN_ROLE_NAME = "AdminRole";
-    string public constant PUBLIC_ROLE_NAME = "PublicRole";
-
-    uint64 public constant CUSTOM_ROLE_ID_MIN = 10000;
-    uint32 public constant EXECUTION_DELAY = 0;
-
-    struct RoleInfo {
-        ShortString name;
-        bool isCustom;
-        bool isLocked;
-        Timestamp createdAt;
-        Timestamp updatedAt;
-    }
-
-    struct TargetInfo {
-        ShortString name;
-        bool isCustom;
-        bool isLocked;
-        Timestamp createdAt;
-        Timestamp updatedAt;
-    }
-
-    error ErrorRoleIdInvalid(RoleId roleId);
-    error ErrorRoleIdTooBig(RoleId roleId);
-    error ErrorRoleIdTooSmall(RoleId roleId);
-    error ErrorRoleIdAlreadyExists(RoleId roleId, ShortString name);
-    error ErrorRoleIdNotActive(RoleId roleId);
-    error ErrorRoleNameEmpty(RoleId roleId);
-    error ErrorRoleNameNotUnique(RoleId roleId, ShortString name);
-    error ErrorRoleInvalidUpdate(RoleId roleId, bool isCustom);
-    error ErrorRoleIsCustomIsImmutable(RoleId roleId, bool isCustom, bool isCustomExisting);
-    error ErrorSetLockedForNonexstentRole(RoleId roleId);
-    error ErrorGrantNonexstentRole(RoleId roleId);
-    error ErrorRevokeNonexstentRole(RoleId roleId);
-    error ErrorRenounceNonexstentRole(RoleId roleId);
-
-    error ErrorTargetAddressZero();
-    error ErrorTargetAlreadyExists(address target, ShortString name);
-    error ErrorTargetNameEmpty(address target);
-    error ErrorTargetNameExists(address target, address existingTarget, ShortString name);
-    error ErrorSetLockedForNonexstentTarget(address target);
-
-    // role specific state
-    mapping(RoleId roleId => RoleInfo info) internal _role;
-    mapping(RoleId roleId => EnumerableSet.AddressSet roleMembers) internal _roleMembers; 
-    mapping(ShortString name => RoleId roleId) internal _roleForName;
-    RoleId [] internal _roles;
-
-    // target specific state
-    mapping(address target => TargetInfo info) internal _target;
-    mapping(ShortString name => address target) internal _targetForName;
-    address [] internal _targets;
-
-    AccessManagerSimple internal _accessManager;
-
-    constructor(address accessManager)
-    {
-        _accessManager = AccessManagerSimple(accessManager);
-        initializeAccessManagedSimple(accessManager);
-
-        _createRole(RoleIdLib.toRoleId(_accessManager.ADMIN_ROLE()), ADMIN_ROLE_NAME, false, false);
-        _createRole(RoleIdLib.toRoleId(_accessManager.PUBLIC_ROLE()), PUBLIC_ROLE_NAME, false, false);
-    }
-
-    //--- Role ------------------------------------------------------//
-
-    function createDefaultRole(RoleId roleId, string memory name) external restricted() {
-        _createRole(roleId, name, false, true);
-    }
-
-    function createRole(RoleId roleId, string memory name) external restricted() {
-        _createRole(roleId, name, true, true);
-    }
-
-    function setRoleLocked(RoleId roleId, bool locked) external restricted() {
-        if (!roleExists(roleId)) {
-            revert ErrorSetLockedForNonexstentRole(roleId);
-        }
-
-        _role[roleId].isLocked = locked;
-        _role[roleId].updatedAt = TimestampLib.blockTimestamp();
-    }
-
-    function roleExists(RoleId roleId) public view returns (bool exists) {
-        return _role[roleId].createdAt.gtz();
-    }
-
-    function grantRole(RoleId roleId, address member) external restricted() returns (bool granted) {
-        if (!roleExists(roleId)) {
-            revert ErrorGrantNonexstentRole(roleId);
-        }
-
-        if (_role[roleId].isLocked) {
-            revert ErrorRoleIdNotActive(roleId);
-        }
-
-        if (!EnumerableSet.contains(_roleMembers[roleId], member)) {
-            _accessManager.grantRole(roleId.toInt(), member, EXECUTION_DELAY);
-            EnumerableSet.add(_roleMembers[roleId], member);
-            return true;
-        }
-
-        return false;
-    }
-
-    function revokeRole(RoleId roleId, address member) external restricted() returns (bool revoked) {
-        if (!roleExists(roleId)) {
-            revert ErrorRevokeNonexstentRole(roleId);
-        }
-
-        if (EnumerableSet.contains(_roleMembers[roleId], member)) {
-            _accessManager.revokeRole(roleId.toInt(), member);
-            EnumerableSet.remove(_roleMembers[roleId], member);
-            return true;
-        }
-
-        return false;
-    }
-
-    /// @dev not restricted function by intention
-    /// the restriction to role members is already enforced by the call to the access manger
-    function renounceRole(RoleId roleId) external returns (bool revoked) {
-        address member = msg.sender;
-
-        if (!roleExists(roleId)) {
-            revert ErrorRenounceNonexstentRole(roleId);
-        }
-
-        if (EnumerableSet.contains(_roleMembers[roleId], member)) {
-            // cannot use accessManger.renounce as it directly checks against msg.sender
-            _accessManager.revokeRole(roleId.toInt(), member);
-            EnumerableSet.remove(_roleMembers[roleId], member);
-            return true;
-        }
-
-        return false;
-    }
-
-    function roles() external view returns (uint256 numberOfRoles) {
-        return _roles.length;
-    }
-
-    function getRoleId(uint256 idx) external view returns (RoleId roleId) {
-        return _roles[idx];
-    }
-
-    function getRoleIdForName(string memory name) external view returns (RoleId roleId) {
-        return _roleForName[ShortStrings.toShortString(name)];
-    }
-
-    function getRole(RoleId roleId) external view returns (RoleInfo memory role) {
-        return _role[roleId];
-    }
-
-    function hasRole(RoleId roleId, address account) external view returns (bool accountHasRole) {
-        (accountHasRole, ) = _accessManager.hasRole(roleId.toInt(), account);
-    }
-
-    function roleMembers(RoleId roleId) external view returns (uint256 numberOfMembers) {
-        return EnumerableSet.length(_roleMembers[roleId]);
-    }
-
-    function getRoleMember(RoleId roleId, uint256 idx) external view returns (address roleMember) {
-        return EnumerableSet.at(_roleMembers[roleId], idx);
-    }
-
-    //--- Target ------------------------------------------------------//
-    function createTarget(address target, string memory name) external restricted() {
-        _createTarget(target, name, true, true);
-    }
-
-    function setTargetLocked(address target, bool locked) external restricted() {
-        if (!targetExists(target)) {
-            revert ErrorSetLockedForNonexstentTarget(target);
-        }
-
-        _target[target].isLocked = locked;
-        _accessManager.setTargetClosed(target, locked);
-    }
-
-    function targetExists(address target) public view returns (bool exists) {
-        return _target[target].createdAt.gtz();
-    }
-
-    //--- internal view/pure functions --------------------------------------//
-
-    function _createRole(RoleId roleId, string memory name, bool isCustom, bool validateParameters) internal {
-        if (validateParameters) {
-            _validateRoleParameters(roleId, name, isCustom);
-        }
-
-        RoleInfo memory role = RoleInfo(
-            ShortStrings.toShortString(name), 
-            isCustom,
-            false, // role un-locked,
-            TimestampLib.blockTimestamp(),
-            TimestampLib.blockTimestamp());
-
-        _role[roleId] = role;
-        _roleForName[role.name] = roleId;
-        _roles.push(roleId);
-    }
-
-    function _validateRoleParameters(
-        RoleId roleId, 
-        string memory name, 
-        bool isCustom
-    )
-        internal
-        view 
-        returns (RoleInfo memory existingRole)
-    {
-        // check role id
-        uint64 roleIdInt = RoleId.unwrap(roleId);
-        if(roleIdInt == _accessManager.ADMIN_ROLE() || roleIdInt == _accessManager.PUBLIC_ROLE()) {
-            revert ErrorRoleIdInvalid(roleId); 
-        }
-
-        // prevent changing isCustom for existing roles
-        existingRole = _role[roleId];
-
-        if (existingRole.createdAt.gtz() && isCustom != existingRole.isCustom) {
-            revert ErrorRoleIsCustomIsImmutable(roleId, isCustom, existingRole.isCustom); 
-        }
-
-        if (isCustom && roleIdInt < CUSTOM_ROLE_ID_MIN) {
-            revert ErrorRoleIdTooSmall(roleId); 
-        } else if (!isCustom && roleIdInt >= CUSTOM_ROLE_ID_MIN) {
-            revert ErrorRoleIdTooBig(roleId); 
-        }
-
-        // role name checks
-        ShortString nameShort = ShortStrings.toShortString(name);
-        if (ShortStrings.byteLength(nameShort) == 0) {
-            revert ErrorRoleNameEmpty(roleId);
-        }
-
-        if (_roleForName[nameShort] != RoleIdLib.zero() && _roleForName[nameShort] != roleId) {
-            revert ErrorRoleNameNotUnique(_roleForName[nameShort], nameShort);
-        }
-    }
-
-    function _createTarget(address target, string memory name, bool isCustom, bool validateParameters) internal {
-        if (validateParameters) {
-            _validateTargetParameters(target, name, isCustom);
-        }
-
-        TargetInfo memory info = TargetInfo(
-            ShortStrings.toShortString(name), 
-            isCustom,
-            _accessManager.isTargetClosed(target), // sync with state in access manager
-            TimestampLib.blockTimestamp(),
-            TimestampLib.blockTimestamp());
-
-        _target[target] = info;
-        _targetForName[info.name] = target;
-        _targets.push(target);
-    }
-
-    function _validateTargetParameters(address target, string memory name, bool isCustom) internal view {
-
-    }
-}