@towns-protocol/contracts 0.0.302

package/src/spaces/facets/review/IReview.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.4;
+
+import {ReviewStorage} from "./ReviewStorage.sol";
+
+interface IReviewBase {
+    enum Action {
+        Add,
+        Update,
+        Delete
+    }
+
+    struct Review {
+        string comment;
+        uint8 rating;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       CUSTOM ERRORS                        */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    error ReviewFacet__InvalidCommentLength();
+    error ReviewFacet__InvalidRating();
+    error ReviewFacet__ReviewAlreadyExists();
+    error ReviewFacet__ReviewDoesNotExist();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Emitted when a review is added
+    event ReviewAdded(address indexed user, string comment, uint8 rating);
+
+    /// @notice Emitted when a review is updated
+    event ReviewUpdated(address indexed user, string comment, uint8 rating);
+
+    /// @notice Emitted when a review is deleted
+    event ReviewDeleted(address indexed user);
+}
+
+interface IReview is IReviewBase {
+    function setReview(Action action, bytes calldata data) external;
+
+    function getReview(address user) external view returns (ReviewStorage.Content memory);
+
+    function getAllReviews()
+        external
+        view
+        returns (address[] memory users, ReviewStorage.Content[] memory reviews);
+}

package/src/spaces/facets/review/ReviewFacet.sol

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IReview} from "./IReview.sol";
+
+// libraries
+
+import {ReviewStorage} from "./ReviewStorage.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+import {FixedPointMathLib} from "solady/utils/FixedPointMathLib.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {Entitled} from "src/spaces/facets/Entitled.sol";
+
+contract ReviewFacet is IReview, Entitled, Facet {
+    using EnumerableSetLib for EnumerableSetLib.AddressSet;
+
+    uint256 internal constant DEFAULT_MIN_COMMENT_LENGTH = 10;
+    uint256 internal constant DEFAULT_MAX_COMMENT_LENGTH = 4000;
+
+    function __Review_init() external onlyInitializing {
+        _addInterface(type(IReview).interfaceId);
+    }
+
+    function setReview(Action action, bytes calldata data) external {
+        _validateMembership(msg.sender);
+
+        ReviewStorage.Layout storage rs = ReviewStorage.layout();
+
+        if (action == Action.Add) {
+            Review memory newReview = abi.decode(data, (Review));
+            _validateReview(newReview);
+
+            ReviewStorage.Content storage review = rs.reviewByUser[msg.sender];
+
+            if (review.createdAt != 0) {
+                CustomRevert.revertWith(ReviewFacet__ReviewAlreadyExists.selector);
+            }
+
+            (review.comment, review.rating, review.createdAt) = (
+                newReview.comment,
+                newReview.rating,
+                uint40(block.timestamp)
+            );
+            rs.usersReviewed.add(msg.sender);
+
+            emit ReviewAdded(msg.sender, newReview.comment, newReview.rating);
+        } else if (action == Action.Update) {
+            Review memory newReview = abi.decode(data, (Review));
+            _validateReview(newReview);
+
+            ReviewStorage.Content storage review = rs.reviewByUser[msg.sender];
+
+            if (review.createdAt == 0) {
+                CustomRevert.revertWith(ReviewFacet__ReviewDoesNotExist.selector);
+            }
+
+            (review.comment, review.rating, review.updatedAt) = (
+                newReview.comment,
+                newReview.rating,
+                uint40(block.timestamp)
+            );
+
+            emit ReviewUpdated(msg.sender, newReview.comment, newReview.rating);
+        } else if (action == Action.Delete) {
+            delete rs.reviewByUser[msg.sender];
+            rs.usersReviewed.remove(msg.sender);
+
+            emit ReviewDeleted(msg.sender);
+        }
+    }
+
+    function getReview(address user) external view returns (ReviewStorage.Content memory review) {
+        assembly ("memory-safe") {
+            mstore(0x40, review)
+        }
+        review = ReviewStorage.layout().reviewByUser[user];
+    }
+
+    function getAllReviews()
+        external
+        view
+        returns (address[] memory users, ReviewStorage.Content[] memory reviews)
+    {
+        ReviewStorage.Layout storage rs = ReviewStorage.layout();
+        users = rs.usersReviewed.values();
+        reviews = new ReviewStorage.Content[](users.length);
+        for (uint256 i; i < users.length; ++i) {
+            reviews[i] = rs.reviewByUser[users[i]];
+        }
+    }
+
+    function _validateReview(Review memory review) internal pure {
+        uint256 length = bytes(review.comment).length;
+        if (length < DEFAULT_MIN_COMMENT_LENGTH || length > DEFAULT_MAX_COMMENT_LENGTH) {
+            CustomRevert.revertWith(ReviewFacet__InvalidCommentLength.selector);
+        }
+        if (review.rating > 5) {
+            CustomRevert.revertWith(ReviewFacet__InvalidRating.selector);
+        }
+    }
+}

package/src/spaces/facets/review/ReviewStorage.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+
+library ReviewStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.review.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x575a00558d547e4e5b6480e3f9afffa169c969028d92350b23fc834c93401100;
+
+    struct Content {
+        string comment;
+        uint8 rating;
+        uint40 createdAt;
+        uint40 updatedAt;
+    }
+
+    struct Layout {
+        mapping(address user => Content) reviewByUser;
+        EnumerableSetLib.AddressSet usersReviewed;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/spaces/facets/roles/IRoles.sol

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IEntitlement} from "src/spaces/entitlements/IEntitlement.sol";
+
+// libraries
+
+// contracts
+/// @title IRolesBase
+/// @notice Base interface for role management
+interface IRolesBase {
+    /// @notice Struct representing a role
+    /// @param id Unique identifier for the role
+    /// @param name Name of the role
+    /// @param disabled Flag indicating if the role is disabled
+    /// @param permissions List of permissions associated with the role
+    /// @param entitlements List of entitlements associated with the role
+    struct Role {
+        uint256 id;
+        string name;
+        bool disabled;
+        string[] permissions;
+        IEntitlement[] entitlements;
+    }
+
+    /// @notice Struct for creating an entitlement
+    /// @param module The entitlement module
+    /// @param data Additional data for the entitlement
+    struct CreateEntitlement {
+        IEntitlement module;
+        bytes data;
+    }
+
+    /// @notice Emitted when a new role is created
+    /// @param creator Address of the role creator
+    /// @param roleId Unique identifier of the created role
+    event RoleCreated(address indexed creator, uint256 indexed roleId);
+
+    /// @notice Emitted when a role is updated
+    /// @param updater Address of the role updater
+    /// @param roleId Unique identifier of the updated role
+    event RoleUpdated(address indexed updater, uint256 indexed roleId);
+
+    /// @notice Emitted when a role is removed
+    /// @param remover Address of the role remover
+    /// @param roleId Unique identifier of the removed role
+    event RoleRemoved(address indexed remover, uint256 indexed roleId);
+
+    /// @notice Emitted when permissions are added to a channel role
+    /// @param updater Address of the updater
+    /// @param roleId Unique identifier of the role
+    /// @param channelId Unique identifier of the channel
+    event PermissionsAddedToChannelRole(
+        address indexed updater,
+        uint256 indexed roleId,
+        bytes32 indexed channelId
+    );
+
+    /// @notice Emitted when permissions are removed from a channel role
+    /// @param updater Address of the updater
+    /// @param roleId Unique identifier of the role
+    /// @param channelId Unique identifier of the channel
+    event PermissionsRemovedFromChannelRole(
+        address indexed updater,
+        uint256 indexed roleId,
+        bytes32 indexed channelId
+    );
+
+    /// @notice Emitted when permissions are updated for a channel role
+    /// @param updater Address of the updater
+    /// @param roleId Unique identifier of the role
+    /// @param channelId Unique identifier of the channel
+    event PermissionsUpdatedForChannelRole(
+        address indexed updater,
+        uint256 indexed roleId,
+        bytes32 indexed channelId
+    );
+
+    // =============================================================
+    //                           Errors
+    // =============================================================
+    /// @notice Error thrown when a role does not exist
+    error Roles__RoleDoesNotExist();
+    /// @notice Error thrown when an entitlement already exists
+    error Roles__EntitlementAlreadyExists();
+    /// @notice Error thrown when an entitlement does not exist
+    error Roles__EntitlementDoesNotExist();
+    /// @notice Error thrown when an invalid permission is provided
+    error Roles__InvalidPermission();
+    /// @notice Error thrown when an invalid entitlement address is provided
+    error Roles__InvalidEntitlementAddress();
+    /// @notice Error thrown when a permission already exists
+    error Roles__PermissionAlreadyExists();
+    /// @notice Error thrown when a permission does not exist
+    error Roles__PermissionDoesNotExist();
+    /// @notice Error thrown when attempting to modify an immutable role
+    error Roles__RoleIsImmutable();
+}
+
+/// @title IRoles
+/// @notice Interface for role management operations
+interface IRoles is IRolesBase {
+    /// @notice Creates a new role
+    /// @param roleName Name of the role
+    /// @param permissions List of permissions for the role
+    /// @param entitlements List of entitlements for the role
+    /// @return roleId Unique identifier of the created role
+    function createRole(
+        string calldata roleName,
+        string[] calldata permissions,
+        CreateEntitlement[] calldata entitlements
+    ) external returns (uint256 roleId);
+
+    /// @notice Retrieves all roles
+    /// @return roles Array of all roles
+    function getRoles() external view returns (Role[] memory roles);
+
+    /// @notice Retrieves a role by its ID
+    /// @param roleId Unique identifier of the role
+    /// @return role The role struct
+    function getRoleById(uint256 roleId) external view returns (Role memory role);
+
+    /// @notice Updates an existing role
+    /// @param roleId Unique identifier of the role to update
+    /// @param roleName New name for the role
+    /// @param permissions New list of permissions for the role
+    /// @param entitlements New list of entitlements for the role
+    function updateRole(
+        uint256 roleId,
+        string calldata roleName,
+        string[] calldata permissions,
+        CreateEntitlement[] calldata entitlements
+    ) external;
+
+    /// @notice Removes a role
+    /// @param roleId Unique identifier of the role to remove
+    function removeRole(uint256 roleId) external;
+
+    // permissions
+
+    /// @notice Adds permissions to a role
+    /// @param roleId Unique identifier of the role
+    /// @param permissions List of permissions to add
+    function addPermissionsToRole(uint256 roleId, string[] calldata permissions) external;
+
+    /// @notice Removes permissions from a role
+    /// @param roleId Unique identifier of the role
+    /// @param permissions List of permissions to remove
+    function removePermissionsFromRole(uint256 roleId, string[] calldata permissions) external;
+
+    /// @notice Retrieves permissions for a role
+    /// @param roleId Unique identifier of the role
+    /// @return permissions List of permissions for the role
+    function getPermissionsByRoleId(
+        uint256 roleId
+    ) external view returns (string[] memory permissions);
+
+    // entitlements
+
+    /// @notice Adds an entitlement to a role
+    /// @param roleId Unique identifier of the role
+    /// @param entitlement Entitlement to add
+    function addRoleToEntitlement(uint256 roleId, CreateEntitlement calldata entitlement) external;
+
+    /// @notice Removes an entitlement from a role
+    /// @param roleId Unique identifier of the role
+    /// @param entitlement Entitlement to remove
+    function removeRoleFromEntitlement(
+        uint256 roleId,
+        CreateEntitlement calldata entitlement
+    ) external;
+
+    /// @notice Sets channel permission overrides for a role
+    /// @param roleId Unique identifier of the role
+    /// @param channelId Unique identifier of the channel
+    /// @param permissions List of permissions to set as overrides
+    function setChannelPermissionOverrides(
+        uint256 roleId,
+        bytes32 channelId,
+        string[] calldata permissions
+    ) external;
+
+    /// @notice Retrieves channel permission overrides for a role
+    /// @param roleId Unique identifier of the role
+    /// @param channelId Unique identifier of the channel
+    /// @return permissions List of permission overrides for the channel
+    function getChannelPermissionOverrides(
+        uint256 roleId,
+        bytes32 channelId
+    ) external view returns (string[] memory permissions);
+
+    /// @notice Clears channel permission overrides for a role
+    /// @param roleId Unique identifier of the role
+    /// @param channelId Unique identifier of the channel
+    function clearChannelPermissionOverrides(uint256 roleId, bytes32 channelId) external;
+}

package/src/spaces/facets/roles/Roles.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IRoles} from "./IRoles.sol";
+
+// libraries
+import {StringSet} from "../../../utils/libraries/StringSet.sol";
+import {Permissions} from "../Permissions.sol";
+import {RolesStorage} from "./RolesStorage.sol";
+
+// contracts
+import {Entitled} from "../Entitled.sol";
+import {RolesBase} from "./RolesBase.sol";
+
+contract Roles is IRoles, RolesBase, Entitled {
+    using StringSet for StringSet.Set;
+    using RolesStorage for RolesStorage.Role;
+
+    /// @inheritdoc IRoles
+    function createRole(
+        string calldata roleName,
+        string[] calldata permissions,
+        CreateEntitlement[] calldata entitlements
+    ) external override returns (uint256) {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        return _createRole(roleName, permissions, entitlements);
+    }
+
+    /// @inheritdoc IRoles
+    function getRoles() external view override returns (Role[] memory) {
+        return _getRoles();
+    }
+
+    /// @inheritdoc IRoles
+    function getRoleById(uint256 roleId) external view override returns (Role memory) {
+        _checkRoleExists(roleId);
+        return _getRoleById(roleId);
+    }
+
+    /// @inheritdoc IRoles
+    function updateRole(
+        uint256 roleId,
+        string calldata roleName,
+        string[] calldata permissions,
+        CreateEntitlement[] calldata entitlements
+    ) external override {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _updateRole(roleId, roleName, permissions, entitlements);
+    }
+
+    /// @inheritdoc IRoles
+    function removeRole(uint256 roleId) external override {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _removeRole(roleId);
+    }
+
+    // permissions
+    /// @inheritdoc IRoles
+    function addPermissionsToRole(uint256 roleId, string[] calldata permissions) external override {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _checkRoleExists(roleId);
+        RolesStorage.layout().roleById[roleId].addPermissions(permissions);
+    }
+
+    /// @inheritdoc IRoles
+    function removePermissionsFromRole(
+        uint256 roleId,
+        string[] calldata permissions
+    ) external override {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _checkRoleExists(roleId);
+        RolesStorage.layout().roleById[roleId].removePermissions(permissions);
+    }
+
+    /// @inheritdoc IRoles
+    function getPermissionsByRoleId(
+        uint256 roleId
+    ) external view override returns (string[] memory permissions) {
+        permissions = RolesStorage.layout().roleById[roleId].permissions.values();
+    }
+
+    // entitlements
+    /// @inheritdoc IRoles
+    function addRoleToEntitlement(uint256 roleId, CreateEntitlement calldata entitlement) external {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _addRoleToEntitlement(roleId, entitlement);
+    }
+
+    /// @inheritdoc IRoles
+    function removeRoleFromEntitlement(
+        uint256 roleId,
+        CreateEntitlement calldata entitlement
+    ) external {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _removeRoleFromEntitlement(roleId, entitlement);
+    }
+
+    // custom channel permission overrides
+    /// @inheritdoc IRoles
+    function setChannelPermissionOverrides(
+        uint256 roleId,
+        bytes32 channelId,
+        string[] calldata permissions
+    ) external {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _setChannelPermissionOverrides(roleId, channelId, permissions);
+    }
+
+    /// @inheritdoc IRoles
+    function getChannelPermissionOverrides(
+        uint256 roleId,
+        bytes32 channelId
+    ) external view returns (string[] memory permissions) {
+        return _getChannelPermissionOverrides(roleId, channelId);
+    }
+
+    /// @inheritdoc IRoles
+    function clearChannelPermissionOverrides(uint256 roleId, bytes32 channelId) external {
+        _validatePermission(Permissions.ModifySpaceSettings);
+        _clearChannelPermissionOverrides(roleId, channelId);
+    }
+}