@towns-protocol/contracts 0.0.302

package/src/spaces/facets/entitlements/EntitlementsManagerService.sol

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IEntitlement} from "src/spaces/entitlements/IEntitlement.sol";
+
+// libraries
+
+import {EntitlementsManagerStorage} from "./EntitlementsManagerStorage.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+// contracts
+error EntitlementsService__InvalidEntitlementAddress();
+error EntitlementsService__InvalidEntitlementInterface();
+
+error EntitlementsService__ImmutableEntitlement();
+error EntitlementsService__EntitlementDoesNotExist();
+error EntitlementsService__EntitlementAlreadyExists();
+
+library EntitlementsManagerService {
+    using EnumerableSet for EnumerableSet.AddressSet;
+    using EntitlementsManagerStorage for EntitlementsManagerStorage.Layout;
+
+    string internal constant IN_TOWN = "";
+
+    function checkEntitlement(address entitlement) internal view {
+        EntitlementsManagerStorage.Layout storage ds = EntitlementsManagerStorage.layout();
+
+        if (!ds.entitlements.contains(entitlement)) {
+            revert EntitlementsService__EntitlementDoesNotExist();
+        }
+    }
+
+    // TODO define what isImmutable means
+    function addEntitlement(address entitlement, bool isImmutable) internal {
+        IEntitlement ie = IEntitlement(entitlement);
+        EntitlementsManagerStorage.Layout storage ds = EntitlementsManagerStorage.layout();
+
+        if (ds.entitlements.contains(entitlement)) {
+            revert EntitlementsService__EntitlementAlreadyExists();
+        }
+
+        ds.entitlements.add(entitlement);
+        ds.entitlementByAddress[entitlement] = EntitlementsManagerStorage.Entitlement({
+            entitlement: IEntitlement(entitlement),
+            isImmutable: isImmutable,
+            isCrosschain: ie.isCrosschain()
+        });
+    }
+
+    function removeEntitlement(address entitlement) internal {
+        EntitlementsManagerStorage.Layout storage ds = EntitlementsManagerStorage.layout();
+
+        if (!ds.entitlements.contains(entitlement)) {
+            revert EntitlementsService__EntitlementDoesNotExist();
+        }
+
+        if (ds.entitlementByAddress[entitlement].isImmutable) {
+            revert EntitlementsService__ImmutableEntitlement();
+        }
+
+        ds.entitlements.remove(entitlement);
+        delete ds.entitlementByAddress[entitlement];
+    }
+
+    function getEntitlement(
+        address entitlement
+    )
+        internal
+        view
+        returns (
+            string memory name,
+            address moduleAddress,
+            string memory moduleType,
+            bool isImmutable
+        )
+    {
+        EntitlementsManagerStorage.Layout storage ds = EntitlementsManagerStorage.layout();
+
+        if (!ds.entitlements.contains(entitlement)) {
+            revert EntitlementsService__EntitlementDoesNotExist();
+        }
+
+        IEntitlement ie = IEntitlement(entitlement);
+        string memory temp1 = ie.name();
+        address temp2 = address(ds.entitlementByAddress[entitlement].entitlement);
+        string memory temp3 = ie.moduleType();
+        bool temp4 = ds.entitlementByAddress[entitlement].isImmutable;
+
+        return (temp1, temp2, temp3, temp4);
+    }
+
+    function getEntitlements() internal view returns (address[] memory entitlements) {
+        return EntitlementsManagerStorage.layout().entitlements.values();
+    }
+
+    // =============================================================
+    //                           Validation
+    // =============================================================
+
+    function validateEntitlement(address entitlement) internal view {
+        if (entitlement == address(0)) {
+            revert EntitlementsService__InvalidEntitlementAddress();
+        }
+
+        try IERC165(entitlement).supportsInterface(type(IEntitlement).interfaceId) returns (
+            bool supported
+        ) {
+            if (!supported) {
+                revert EntitlementsService__InvalidEntitlementInterface();
+            }
+        } catch {
+            revert EntitlementsService__InvalidEntitlementInterface();
+        }
+    }
+
+    // =============================================================
+    //                        Proxy Methods
+    // =============================================================
+    function proxyGetEntitlementDataByRole(
+        address entitlement,
+        uint256 role
+    ) internal view returns (bytes memory) {
+        checkEntitlement(entitlement);
+        return IEntitlement(entitlement).getEntitlementDataByRoleId(role);
+    }
+
+    function proxyAddRoleToEntitlement(
+        address entitlement,
+        uint256 role,
+        bytes calldata entitlementData
+    ) internal {
+        checkEntitlement(entitlement);
+        IEntitlement(entitlement).setEntitlement(role, entitlementData);
+    }
+
+    function proxyRemoveRoleFromEntitlement(address entitlement, uint256 role) internal {
+        checkEntitlement(entitlement);
+        IEntitlement(entitlement).removeEntitlement(role);
+    }
+}

package/src/spaces/facets/entitlements/EntitlementsManagerStorage.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IEntitlement} from "src/spaces/entitlements/IEntitlement.sol";
+
+// libraries
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+// contracts
+
+library EntitlementsManagerStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.entitlements.manager.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0xa558e822bd359dacbe30f0da89cbfde5f95895b441e13a4864caec1423c93100;
+
+    struct Entitlement {
+        IEntitlement entitlement;
+        bool isImmutable;
+        bool isCrosschain;
+    }
+
+    struct Layout {
+        mapping(address => Entitlement) entitlementByAddress;
+        EnumerableSet.AddressSet entitlements;
+    }
+
+    function layout() internal pure returns (Layout storage ds) {
+        assembly {
+            ds.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/spaces/facets/entitlements/IEntitlementsManager.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+interface IEntitlementsManagerBase {
+    struct Entitlement {
+        string name;
+        address moduleAddress;
+        string moduleType;
+        bool isImmutable;
+    }
+
+    // =============================================================
+    //                           Events
+    // =============================================================
+    event EntitlementModuleAdded(address indexed caller, address entitlement);
+    event EntitlementModuleRemoved(address indexed caller, address entitlement);
+}
+
+interface IEntitlementsManager is IEntitlementsManagerBase {
+    /// @notice Allows the space owner to add immutable entitlements to the space
+    /// @param entitlements The entitlements to add
+    function addImmutableEntitlements(address[] calldata entitlements) external;
+
+    /// @notice Checks if a user is entitled to a permission in the space
+    /// @param user The user to check
+    /// @param permission The permission to check
+    /// @return True if the user is entitled to the permission, false otherwise
+    function isEntitledToSpace(
+        address user,
+        string calldata permission
+    ) external view returns (bool);
+
+    /// @notice Checks if a user is entitled to a permission in a channel
+    /// @param channelId The channel to check
+    /// @param user The user to check
+    /// @param permission The permission to check
+    /// @return True if the user is entitled to the permission, false otherwise
+    function isEntitledToChannel(
+        bytes32 channelId,
+        address user,
+        string calldata permission
+    ) external view returns (bool);
+
+    /// @notice Adds an entitlement to the space
+    /// @param entitlement The entitlement to add
+    function addEntitlementModule(address entitlement) external;
+
+    /// @notice Removes an entitlement from the space
+    /// @param entitlement The entitlement to remove
+    function removeEntitlementModule(address entitlement) external;
+
+    /// @notice Gets an entitlement from the space
+    /// @param entitlement The entitlement to get
+    /// @return entitlements The entitlement module address
+    function getEntitlement(
+        address entitlement
+    ) external view returns (Entitlement memory entitlements);
+
+    /// @notice Gets all entitlements from the space
+    /// @return entitlements The entitlement modules
+    function getEntitlements() external view returns (Entitlement[] memory entitlements);
+}

package/src/spaces/facets/entitlements/extensions/EntitlementDataQueryable.sol

@@ -0,0 +1,153 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IEntitlement} from "src/spaces/entitlements/IEntitlement.sol";
+import {IEntitlementDataQueryable} from "src/spaces/facets/entitlements/extensions/IEntitlementDataQueryable.sol";
+import {IEntitlementGatedBase} from "src/spaces/facets/gated/IEntitlementGated.sol";
+import {IRolesBase} from "src/spaces/facets/roles/IRoles.sol";
+
+// libraries
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {ChannelService} from "src/spaces/facets/channels/ChannelService.sol";
+import {EntitlementGatedStorage} from "src/spaces/facets/gated/EntitlementGatedStorage.sol";
+import {RolesStorage} from "src/spaces/facets/roles/RolesStorage.sol";
+import {StringSet} from "../../../../utils/libraries/StringSet.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {RolesBase} from "src/spaces/facets/roles/RolesBase.sol";
+
+contract EntitlementDataQueryable is
+    IRolesBase,
+    IEntitlementDataQueryable,
+    IEntitlementGatedBase,
+    RolesBase,
+    Facet
+{
+    using StringSet for StringSet.Set;
+    using EnumerableSet for EnumerableSet.Bytes32Set;
+
+    function getEntitlementDataByPermission(
+        string calldata permission
+    ) external view returns (EntitlementData[] memory) {
+        Role[] memory roles = _getRolesWithPermission(permission);
+        return _getEntitlements(roles);
+    }
+
+    function getChannelEntitlementDataByPermission(
+        bytes32 channelId,
+        string calldata permission
+    ) external view returns (EntitlementData[] memory) {
+        Role[] memory roles = _getChannelRolesWithPermission(channelId, permission);
+        return _getEntitlements(roles);
+    }
+
+    function getCrossChainEntitlementData(
+        bytes32 transactionId,
+        uint256 roleId
+    ) external view returns (EntitlementData memory) {
+        EntitlementGatedStorage.Layout storage ds = EntitlementGatedStorage.layout();
+
+        Transaction storage transaction = ds.transactions[transactionId];
+
+        if (!transaction.finalized) {
+            revert EntitlementGated_TransactionNotRegistered();
+        }
+
+        IEntitlement re = IEntitlement(transaction.entitlement);
+
+        return EntitlementData(re.moduleType(), re.getEntitlementDataByRoleId(roleId));
+    }
+
+    // =============================================================
+    //                           Internal
+    // =============================================================
+    function _getChannelRolesWithPermission(
+        bytes32 channelId,
+        string calldata permission
+    ) internal view returns (Role[] memory) {
+        // retrieve the roles associated with the channel
+        uint256[] memory channelRoles = ChannelService.getRolesByChannel(channelId);
+        uint256 channelRolesLength = channelRoles.length;
+
+        // initialize arrays to store the matching role IDs
+        uint256[] memory matchedRoleIds = new uint256[](channelRolesLength);
+        uint256 matchedRoleCount = 0;
+
+        // access roles storage layout
+        RolesStorage.Layout storage rs = RolesStorage.layout();
+
+        // iterate through channel roles and check for the requested permission
+        for (uint256 i; i < channelRolesLength; ++i) {
+            uint256 roleId = channelRoles[i];
+
+            RolesStorage.Role storage role = rs.roleById[channelRoles[i]];
+
+            bool hasPermission = false;
+
+            // check if role is associated with the channel and has the requested permission
+            if (rs.channelOverridesByRole[roleId].contains(channelId)) {
+                StringSet.Set storage permissions = rs.permissionOverridesByRole[roleId][channelId];
+                hasPermission = permissions.contains(permission);
+            }
+            // check the default permissions if this role didn't have a channel override.
+            else if (role.permissions.contains(permission)) {
+                hasPermission = true;
+            }
+
+            // store the role ID if it has the requested permission
+            if (hasPermission) {
+                matchedRoleIds[matchedRoleCount] = roleId;
+                unchecked {
+                    ++matchedRoleCount;
+                }
+            }
+        }
+
+        // create an array of roles with the matching IDs
+        Role[] memory rolesWithPermission = new Role[](matchedRoleCount);
+        for (uint256 i; i < matchedRoleCount; ++i) {
+            rolesWithPermission[i] = _getRoleById(matchedRoleIds[i]);
+        }
+
+        return rolesWithPermission;
+    }
+
+    function _getEntitlements(
+        Role[] memory roles
+    ) internal view returns (EntitlementData[] memory entitlementData) {
+        uint256 entitlementCount;
+        uint256 rolesLength = roles.length;
+
+        for (uint256 i; i < rolesLength; ++i) {
+            if (!roles[i].disabled) {
+                unchecked {
+                    entitlementCount += roles[i].entitlements.length;
+                }
+            }
+        }
+
+        entitlementData = new EntitlementData[](entitlementCount);
+
+        uint256 currentIndex = 0;
+
+        for (uint256 i; i < rolesLength; ++i) {
+            if (!roles[i].disabled) {
+                IEntitlement[] memory entitlements = roles[i].entitlements;
+                uint256 length = entitlements.length;
+                for (uint256 j; j < length; ++j) {
+                    IEntitlement entitlement = IEntitlement(entitlements[j]);
+
+                    entitlementData[currentIndex] = EntitlementData(
+                        entitlement.moduleType(),
+                        entitlement.getEntitlementDataByRoleId(roles[i].id)
+                    );
+                    unchecked {
+                        ++currentIndex;
+                    }
+                }
+            }
+        }
+    }
+}

package/src/spaces/facets/entitlements/extensions/IEntitlementDataQueryable.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+interface IEntitlementDataQueryableBase {
+    struct EntitlementData {
+        string entitlementType;
+        bytes entitlementData;
+    }
+}
+
+interface IEntitlementDataQueryable is IEntitlementDataQueryableBase {
+    // Entitlement data pertaining to all roles in the space.
+    function getEntitlementDataByPermission(
+        string calldata permission
+    ) external view returns (EntitlementData[] memory);
+
+    // Entitlement data pertaining to all roles assigned to a channel.
+    function getChannelEntitlementDataByPermission(
+        bytes32 channelId,
+        string calldata permission
+    ) external view returns (EntitlementData[] memory);
+
+    function getCrossChainEntitlementData(
+        bytes32 transactionId,
+        uint256 roleId
+    ) external view returns (EntitlementData memory);
+}