@towns-protocol/contracts 0.0.302

package/src/spaces/facets/channels/ChannelService.sol

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IChannelBase} from "./IChannel.sol";
+
+// libraries
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {ChannelStorage} from "./ChannelStorage.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {LibString} from "solady/utils/LibString.sol";
+
+// contracts
+
+library ChannelService {
+    using EnumerableSet for EnumerableSet.UintSet;
+    using EnumerableSet for EnumerableSet.Bytes32Set;
+    using ChannelStorage for ChannelStorage.Layout;
+    using CustomRevert for bytes4;
+    using LibString for string;
+
+    // =============================================================
+    //                      CRUD Operations
+    // =============================================================
+
+    function createChannel(
+        bytes32 channelId,
+        string calldata metadata,
+        uint256[] memory roleIds
+    ) internal {
+        checkChannel(channelId);
+
+        ChannelStorage.Layout storage channel = ChannelStorage.layout();
+
+        channel.channelIds.add(channelId);
+        ChannelStorage.Channel storage channelInfo = channel.channelById[channelId];
+        (channelInfo.id, channelInfo.metadata) = (channelId, metadata);
+
+        EnumerableSet.UintSet storage roles = channel.rolesByChannelId[channelId];
+        for (uint256 i; i < roleIds.length; ++i) {
+            // check if role already exists in channel
+            if (roles.contains(roleIds[i])) {
+                IChannelBase.ChannelService__RoleAlreadyExists.selector.revertWith();
+            }
+            roles.add(roleIds[i]);
+        }
+    }
+
+    function getChannel(
+        bytes32 channelId
+    ) internal view returns (bytes32 id, string memory metadata, bool disabled) {
+        checkChannelExists(channelId);
+
+        ChannelStorage.Layout storage channel = ChannelStorage.layout();
+        ChannelStorage.Channel storage channelInfo = channel.channelById[channelId];
+
+        id = channelInfo.id;
+        metadata = channelInfo.metadata;
+        disabled = channelInfo.disabled;
+    }
+
+    function updateChannel(bytes32 channelId, string calldata metadata, bool disabled) internal {
+        checkChannelExists(channelId);
+
+        ChannelStorage.Layout storage channel = ChannelStorage.layout();
+        ChannelStorage.Channel storage channelInfo = channel.channelById[channelId];
+
+        if (bytes(metadata).length > 0 && !metadata.eq(channelInfo.metadata)) {
+            channelInfo.metadata = metadata;
+        }
+
+        if (channelInfo.disabled != disabled) {
+            channelInfo.disabled = disabled;
+        }
+    }
+
+    function removeChannel(bytes32 channelId) internal {
+        checkChannelExists(channelId);
+
+        ChannelStorage.Layout storage channel = ChannelStorage.layout();
+
+        channel.channelIds.remove(channelId);
+        delete channel.channelById[channelId];
+
+        // remove all roles from channel
+        channel.rolesByChannelId[channelId].clear();
+    }
+
+    function getChannelIds() internal view returns (bytes32[] memory) {
+        ChannelStorage.Layout storage channel = ChannelStorage.layout();
+        return channel.channelIds.values();
+    }
+
+    function getChannelIdsByRole(
+        uint256 roleId
+    ) internal view returns (bytes32[] memory channelIds) {
+        ChannelStorage.Layout storage channel = ChannelStorage.layout();
+
+        uint256 potentialChannelsLength = channel.channelIds.length();
+        uint256 count = 0;
+
+        channelIds = new bytes32[](potentialChannelsLength);
+
+        for (uint256 i; i < potentialChannelsLength; ++i) {
+            bytes32 channelId = channel.channelIds.at(i);
+
+            if (channel.rolesByChannelId[channelId].contains(roleId)) {
+                unchecked {
+                    channelIds[count++] = channelId;
+                }
+            }
+        }
+
+        // resize the array to the actual number of channels
+        assembly ("memory-safe") {
+            mstore(channelIds, count)
+        }
+    }
+
+    function addRoleToChannel(bytes32 channelId, uint256 roleId) internal {
+        checkChannelExists(channelId);
+        checkChannelNotDisabled(channelId);
+
+        // check role isn't in channel already
+        ChannelStorage.Layout storage channel = ChannelStorage.layout();
+        EnumerableSet.UintSet storage roles = channel.rolesByChannelId[channelId];
+        if (roles.contains(roleId)) {
+            IChannelBase.ChannelService__RoleAlreadyExists.selector.revertWith();
+        }
+
+        roles.add(roleId);
+    }
+
+    function removeRoleFromChannel(bytes32 channelId, uint256 roleId) internal {
+        checkChannelExists(channelId);
+        checkChannelNotDisabled(channelId);
+
+        // check role exists in channel
+        ChannelStorage.Layout storage channel = ChannelStorage.layout();
+        EnumerableSet.UintSet storage roles = channel.rolesByChannelId[channelId];
+        if (!roles.contains(roleId)) {
+            IChannelBase.ChannelService__RoleDoesNotExist.selector.revertWith();
+        }
+
+        roles.remove(roleId);
+    }
+
+    function getRolesByChannel(bytes32 channelId) internal view returns (uint256[] memory) {
+        checkChannelExists(channelId);
+        ChannelStorage.Layout storage channel = ChannelStorage.layout();
+        return channel.rolesByChannelId[channelId].values();
+    }
+
+    // =============================================================
+    //                        Validators
+    // =============================================================
+
+    function checkChannelNotDisabled(bytes32 channelId) internal view {
+        if (ChannelStorage.layout().channelById[channelId].disabled) {
+            IChannelBase.ChannelService__ChannelDisabled.selector.revertWith();
+        }
+    }
+
+    function checkChannel(bytes32 channelId) internal view {
+        // check that channel exists
+        if (ChannelStorage.layout().channelIds.contains(channelId)) {
+            IChannelBase.ChannelService__ChannelAlreadyExists.selector.revertWith();
+        }
+    }
+
+    function checkChannelExists(bytes32 channelId) internal view {
+        // check that channel exists
+        if (!ChannelStorage.layout().channelIds.contains(channelId)) {
+            IChannelBase.ChannelService__ChannelDoesNotExist.selector.revertWith();
+        }
+    }
+}

package/src/spaces/facets/channels/ChannelStorage.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+// contracts
+
+library ChannelStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.channel.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x804ad633258ac9b908ae115a2763b3f6e04be3b1165402c872b25af518504300;
+
+    struct Channel {
+        bytes32 id;
+        bool disabled;
+        string metadata;
+    }
+
+    struct Layout {
+        EnumerableSet.Bytes32Set channelIds;
+        mapping(bytes32 channelId => Channel) channelById;
+        mapping(bytes32 channelId => EnumerableSet.UintSet) rolesByChannelId;
+    }
+
+    function layout() internal pure returns (Layout storage ds) {
+        assembly {
+            ds.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/spaces/facets/channels/Channels.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IChannel} from "./IChannel.sol";
+
+// libraries
+import {Permissions} from "src/spaces/facets/Permissions.sol";
+
+// contracts
+
+import {ChannelBase} from "./ChannelBase.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {Entitled} from "src/spaces/facets/Entitled.sol";
+import {RolesBase} from "src/spaces/facets/roles/RolesBase.sol";
+
+contract Channels is IChannel, ChannelBase, RolesBase, Entitled, Facet {
+    function createChannel(
+        bytes32 channelId,
+        string calldata metadata,
+        uint256[] calldata roleIds
+    ) external {
+        _validatePermission(Permissions.AddRemoveChannels);
+        _createChannel(channelId, metadata, roleIds);
+    }
+
+    function createChannelWithOverridePermissions(
+        bytes32 channelId,
+        string calldata metadata,
+        RolePermissions[] calldata rolePermissions
+    ) external {
+        _validatePermission(Permissions.AddRemoveChannels);
+
+        uint256[] memory roleIds = new uint256[](rolePermissions.length);
+        for (uint256 i; i < rolePermissions.length; ++i) {
+            roleIds[i] = rolePermissions[i].roleId;
+        }
+        _createChannel(channelId, metadata, roleIds);
+
+        for (uint256 i; i < rolePermissions.length; ++i) {
+            _setChannelPermissionOverrides(
+                rolePermissions[i].roleId,
+                channelId,
+                rolePermissions[i].permissions
+            );
+        }
+    }
+
+    function getChannel(bytes32 channelId) external view returns (Channel memory channel) {
+        return _getChannel(channelId);
+    }
+
+    function getChannels() external view returns (Channel[] memory channels) {
+        return _getChannels();
+    }
+
+    function updateChannel(bytes32 channelId, string calldata metadata, bool disabled) external {
+        _validatePermission(Permissions.AddRemoveChannels);
+        _updateChannel(channelId, metadata, disabled);
+    }
+
+    function removeChannel(bytes32 channelId) external {
+        _validatePermission(Permissions.AddRemoveChannels);
+        _removeChannel(channelId);
+    }
+
+    function addRoleToChannel(bytes32 channelId, uint256 roleId) external {
+        _validatePermission(Permissions.AddRemoveChannels);
+        _addRoleToChannel(channelId, roleId);
+    }
+
+    function getRolesByChannel(bytes32 channelId) external view returns (uint256[] memory roleIds) {
+        return _getRolesByChannel(channelId);
+    }
+
+    function removeRoleFromChannel(bytes32 channelId, uint256 roleId) external {
+        _validatePermission(Permissions.AddRemoveChannels);
+        _removeRoleFromChannel(channelId, roleId);
+    }
+}

package/src/spaces/facets/channels/IChannel.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+interface IChannelBase {
+    // =============================================================
+    //                           Structs
+    // =============================================================
+    struct Channel {
+        bytes32 id;
+        bool disabled;
+        string metadata;
+        uint256[] roleIds;
+    }
+
+    struct RolePermissions {
+        uint256 roleId;
+        string[] permissions;
+    }
+
+    // =============================================================
+    //                           Events
+    // =============================================================
+    event ChannelCreated(address indexed caller, bytes32 channelId);
+    event ChannelUpdated(address indexed caller, bytes32 channelId);
+    event ChannelRemoved(address indexed caller, bytes32 channelId);
+    event ChannelRoleAdded(address indexed caller, bytes32 channelId, uint256 roleId);
+    event ChannelRoleRemoved(address indexed caller, bytes32 channelId, uint256 roleId);
+
+    // =============================================================
+    //                           Errors
+    // =============================================================
+    error ChannelService__ChannelAlreadyExists();
+    error ChannelService__ChannelDoesNotExist();
+    error ChannelService__ChannelDisabled();
+    error ChannelService__RoleAlreadyExists();
+    error ChannelService__RoleDoesNotExist();
+}
+
+interface IChannel is IChannelBase {
+    /// @notice creates a channel
+    /// @param channelId the channelId of the channel
+    /// @param metadata the metadata of the channel
+    /// @param roleIds the roleIds to add to the channel
+    function createChannel(
+        bytes32 channelId,
+        string calldata metadata,
+        uint256[] calldata roleIds
+    ) external;
+
+    /// @notice creates a channel with override permissions
+    /// @param channelId the channelId of the channel
+    /// @param metadata the metadata of the channel
+    /// @param rolePermissions the rolePermissions (role->permissions[])[] to add to the channel
+    function createChannelWithOverridePermissions(
+        bytes32 channelId,
+        string calldata metadata,
+        RolePermissions[] calldata rolePermissions
+    ) external;
+
+    /// @notice gets a channel
+    /// @param channelId the channelId to get
+    /// @return channel the channel
+    function getChannel(bytes32 channelId) external view returns (Channel memory channel);
+
+    /// @notice gets all channels
+    /// @return channels an array of all channels
+    function getChannels() external view returns (Channel[] memory channels);
+
+    /// @notice updates a channel
+    /// @param channelId the channelId to update
+    /// @param metadata the new metadata of the channel
+    /// @param disabled whether or not the channel is disabled
+    function updateChannel(bytes32 channelId, string calldata metadata, bool disabled) external;
+
+    /// @notice removes a channel
+    /// @param channelId the channelId to remove
+    function removeChannel(bytes32 channelId) external;
+
+    /// @notice gets all roles for a channel
+    /// @param channelId the channelId to get the roles for
+    /// @return roleIds an array of roleIds for the channel
+    function getRolesByChannel(bytes32 channelId) external view returns (uint256[] memory roleIds);
+
+    /// @notice adds a role to a channel
+    /// @param channelId the channelId to add the role to
+    /// @param roleId the roleId to add to the channel
+    function addRoleToChannel(bytes32 channelId, uint256 roleId) external;
+
+    /// @notice removes a role from a channel
+    /// @param channelId the channelId to remove the role from
+    /// @param roleId the roleId to remove from the channel
+    function removeRoleFromChannel(bytes32 channelId, uint256 roleId) external;
+}

package/src/spaces/facets/dispatcher/DispatcherBase.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDispatcherBase} from "./IDispatcher.sol";
+
+// libraries
+import {StoragePointer} from "@towns-protocol/diamond/src/libraries/StoragePointer.sol";
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+
+// contracts
+import {DispatcherStorage} from "./DispatcherStorage.sol";
+
+abstract contract DispatcherBase is IDispatcherBase {
+    using CustomRevert for bytes4;
+    using StoragePointer for mapping(bytes32 => bytes);
+
+    function _deleteCapturedData(bytes32 transactionId) internal {
+        DispatcherStorage.Layout storage ds = DispatcherStorage.layout();
+        delete ds.transactionData.get(transactionId).value;
+    }
+
+    function _getCapturedData(bytes32 transactionId) internal view returns (bytes storage) {
+        DispatcherStorage.Layout storage ds = DispatcherStorage.layout();
+        return ds.transactionData.get(transactionId).value;
+    }
+
+    function _captureValue(bytes32 transactionId) internal {
+        DispatcherStorage.Layout storage ds = DispatcherStorage.layout();
+        ds.transactionBalance[transactionId] += msg.value;
+    }
+
+    function _releaseCapturedValue(bytes32 transactionId, uint256 value) internal {
+        DispatcherStorage.Layout storage ds = DispatcherStorage.layout();
+        ds.transactionBalance[transactionId] -= value;
+    }
+
+    function _getCapturedValue(bytes32 transactionId) internal view returns (uint256) {
+        DispatcherStorage.Layout storage ds = DispatcherStorage.layout();
+        return ds.transactionBalance[transactionId];
+    }
+
+    function _dispatchNonce(bytes32 keyHash) internal view returns (uint256) {
+        DispatcherStorage.Layout storage ds = DispatcherStorage.layout();
+        return ds.transactionNonce[keyHash];
+    }
+
+    function _useDispatchNonce(bytes32 keyHash) internal returns (uint256) {
+        DispatcherStorage.Layout storage ds = DispatcherStorage.layout();
+        return ds.transactionNonce[keyHash]++;
+    }
+
+    function _makeDispatchInputSeed(
+        bytes32 keyHash,
+        address requester,
+        uint256 nonce
+    ) internal pure returns (uint256) {
+        return uint256(keccak256(abi.encode(keyHash, requester, nonce)));
+    }
+
+    function _makeDispatchId(bytes32 keyHash, uint256 inputSeed) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked(keyHash, inputSeed));
+    }
+
+    function _registerTransaction(
+        address sender,
+        bytes memory data
+    ) internal returns (bytes32 transactionId) {
+        bytes32 keyHash = keccak256(abi.encodePacked(sender, block.number));
+
+        transactionId = _makeDispatchId(
+            keyHash,
+            _makeDispatchInputSeed(keyHash, sender, _useDispatchNonce(keyHash))
+        );
+
+        DispatcherStorage.Layout storage ds = DispatcherStorage.layout();
+        StoragePointer.Bytes storage capturedDataRef = ds.transactionData.get(transactionId);
+        // revert if the transaction already exists
+        if (capturedDataRef.value.length > 0) {
+            Dispatcher__TransactionAlreadyExists.selector.revertWith();
+        }
+
+        capturedDataRef.value = data;
+        if (msg.value != 0) _captureValue(transactionId);
+    }
+}

package/src/spaces/facets/dispatcher/DispatcherStorage.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+library DispatcherStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.dispatcher.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x34516f6fe09a043d57f1ff579a303a7ae85314751c77b4eb1a55837604a86e00;
+
+    struct Layout {
+        mapping(bytes32 => uint256) transactionNonce;
+        mapping(bytes32 => uint256) transactionBalance;
+        mapping(bytes32 => bytes) transactionData;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/spaces/facets/dispatcher/IDispatcher.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+interface IDispatcherBase {
+    error Dispatcher__TransactionAlreadyExists();
+}

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

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IEntitlementsManager} from "./IEntitlementsManager.sol";
+
+// libraries
+
+// contracts
+
+import {Entitled} from "../Entitled.sol";
+import {EntitlementsManagerBase} from "./EntitlementsManagerBase.sol";
+
+contract EntitlementsManager is IEntitlementsManager, EntitlementsManagerBase, Entitled {
+    function addImmutableEntitlements(address[] calldata entitlements) external onlyOwner {
+        _addImmutableEntitlements(entitlements);
+    }
+
+    function addEntitlementModule(address entitlement) external onlyOwner {
+        _addEntitlementModule(entitlement);
+    }
+
+    function removeEntitlementModule(address entitlement) external onlyOwner {
+        _removeEntitlementModule(entitlement);
+    }
+
+    function getEntitlements() external view returns (Entitlement[] memory) {
+        return _getEntitlements();
+    }
+
+    function getEntitlement(address entitlement) external view returns (Entitlement memory) {
+        return _getEntitlement(entitlement);
+    }
+
+    function isEntitledToSpace(
+        address user,
+        string calldata permission
+    ) external view returns (bool) {
+        return _isEntitledToSpace(user, permission);
+    }
+
+    function isEntitledToChannel(
+        bytes32 channelId,
+        address user,
+        string calldata permission
+    ) external view returns (bool) {
+        return _isEntitledToChannel(channelId, user, bytes32(bytes(permission)));
+    }
+}

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

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IEntitlementsManagerBase} from "./IEntitlementsManager.sol";
+
+// libraries
+import {EntitlementsManagerService} from "src/spaces/facets/entitlements/EntitlementsManagerService.sol";
+
+// contracts
+
+contract EntitlementsManagerBase is IEntitlementsManagerBase {
+    function _addImmutableEntitlements(address[] calldata entitlements) internal {
+        for (uint256 i; i < entitlements.length; ++i) {
+            EntitlementsManagerService.validateEntitlement(entitlements[i]);
+            EntitlementsManagerService.addEntitlement(entitlements[i], true);
+        }
+    }
+
+    function _addEntitlementModule(address entitlement) internal {
+        // validate permission
+
+        // validate entitlement
+        EntitlementsManagerService.validateEntitlement(entitlement);
+
+        // set entitlement
+        EntitlementsManagerService.addEntitlement(entitlement, false);
+
+        // emit event
+        emit EntitlementModuleAdded(msg.sender, entitlement);
+    }
+
+    function _removeEntitlementModule(address entitlement) internal {
+        // validate permission
+
+        // validate entitlement
+        EntitlementsManagerService.validateEntitlement(entitlement);
+
+        // set entitlement
+        EntitlementsManagerService.removeEntitlement(entitlement);
+
+        // emit event
+        emit EntitlementModuleRemoved(msg.sender, entitlement);
+    }
+
+    function _getEntitlement(
+        address entitlement
+    ) internal view returns (Entitlement memory module) {
+        EntitlementsManagerService.validateEntitlement(entitlement);
+
+        (
+            string memory name,
+            address entitlementAddress,
+            string memory moduleType,
+            bool isImmutable
+        ) = EntitlementsManagerService.getEntitlement(entitlement);
+
+        module = Entitlement({
+            name: name,
+            moduleAddress: entitlementAddress,
+            moduleType: moduleType,
+            isImmutable: isImmutable
+        });
+    }
+
+    function _getEntitlements() internal view returns (Entitlement[] memory modules) {
+        address[] memory entitlements = EntitlementsManagerService.getEntitlements();
+
+        modules = new Entitlement[](entitlements.length);
+
+        for (uint256 i; i < entitlements.length; ++i) {
+            (
+                string memory name,
+                address entitlementAddress,
+                string memory moduleType,
+                bool isImmutable
+            ) = EntitlementsManagerService.getEntitlement(entitlements[i]);
+
+            modules[i] = Entitlement({
+                name: name,
+                moduleAddress: entitlementAddress,
+                moduleType: moduleType,
+                isImmutable: isImmutable
+            });
+        }
+    }
+}