@towns-protocol/contracts 0.0.302

package/src/spaces/facets/account/AppAccountBase.sol

@@ -0,0 +1,275 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IAppAccountBase} from "./IAppAccount.sol";
+import {IAppRegistry} from "src/apps/facets/registry/AppRegistryFacet.sol";
+import {ITownsApp} from "src/apps/ITownsApp.sol";
+import {IERC6900Module} from "@erc6900/reference-implementation/interfaces/IERC6900Module.sol";
+import {IERC6900ExecutionModule} from "@erc6900/reference-implementation/interfaces/IERC6900ExecutionModule.sol";
+import {IERC6900Account} from "@erc6900/reference-implementation/interfaces/IERC6900Account.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IDiamondCut} from "@towns-protocol/diamond/src/facets/cut/IDiamondCut.sol";
+import {IAppRegistryBase} from "src/apps/facets/registry/IAppRegistry.sol";
+
+// libraries
+import {MembershipStorage} from "src/spaces/facets/membership/MembershipStorage.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+import {DependencyLib} from "../DependencyLib.sol";
+import {LibCall} from "solady/utils/LibCall.sol";
+import {AppAccountStorage} from "./AppAccountStorage.sol";
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+
+// contracts
+import {ExecutorBase} from "../executor/ExecutorBase.sol";
+import {TokenOwnableBase} from "@towns-protocol/diamond/src/facets/ownable/token/TokenOwnableBase.sol";
+
+// types
+import {ExecutionManifest, ManifestExecutionFunction} from "@erc6900/reference-implementation/interfaces/IERC6900ExecutionModule.sol";
+import {Attestation, EMPTY_UID} from "@ethereum-attestation-service/eas-contracts/Common.sol";
+
+abstract contract AppAccountBase is
+    IAppAccountBase,
+    IAppRegistryBase,
+    TokenOwnableBase,
+    ExecutorBase
+{
+    using CustomRevert for bytes4;
+    using EnumerableSetLib for EnumerableSetLib.AddressSet;
+    using DependencyLib for MembershipStorage.Layout;
+
+    uint48 private constant DEFAULT_DURATION = 365 days;
+
+    // External Functions
+    function _onlyRegistry() internal view {
+        if (msg.sender != address(_getAppRegistry())) InvalidCaller.selector.revertWith();
+    }
+
+    function _installApp(bytes32 appId, bytes calldata postInstallData) internal {
+        if (appId == EMPTY_UID) InvalidAppId.selector.revertWith();
+
+        // get the app
+        App memory app = _getAppRegistry().getAppById(appId);
+
+        if (app.appId == EMPTY_UID) AppNotRegistered.selector.revertWith();
+
+        // verify if already installed
+        if (_isAppInstalled(app.module)) AppAlreadyInstalled.selector.revertWith();
+
+        // set the group status to active
+        _setGroupStatus(app.appId, true, _getAppExpiration(app.appId, app.duration));
+        _addApp(app.module, app.appId);
+        _grantGroupAccess({
+            groupId: app.appId,
+            account: app.client,
+            grantDelay: _getGroupGrantDelay(app.appId),
+            executionDelay: 0
+        });
+
+        // Set up execution functions with the same module groupId
+        uint256 executionFunctionsLength = app.manifest.executionFunctions.length;
+        for (uint256 i; i < executionFunctionsLength; ++i) {
+            ManifestExecutionFunction memory func = app.manifest.executionFunctions[i];
+
+            // check if the function is a native function
+            if (_isInvalidSelector(func.executionSelector)) {
+                UnauthorizedSelector.selector.revertWith();
+            }
+
+            _setTargetFunctionGroup(app.module, func.executionSelector, app.appId);
+
+            if (!func.allowGlobalValidation) {
+                _setTargetFunctionDisabled(app.module, func.executionSelector, true);
+            }
+        }
+
+        // Call module's onInstall if it has install data using LibCall
+        // revert if it fails
+        if (postInstallData.length > 0) {
+            bytes memory callData = abi.encodeCall(IERC6900Module.onInstall, (postInstallData));
+            LibCall.callContract(app.module, 0, callData);
+        }
+
+        emit IERC6900Account.ExecutionInstalled(app.module, app.manifest);
+    }
+
+    function _uninstallApp(bytes32 appId, bytes calldata uninstallData) internal {
+        if (appId == EMPTY_UID) InvalidAppId.selector.revertWith();
+
+        App memory app = _getAppRegistry().getAppById(appId);
+
+        if (app.appId == EMPTY_UID) AppNotRegistered.selector.revertWith();
+        if (!_isAppInstalled(app.module)) AppNotInstalled.selector.revertWith();
+
+        _removeApp(app.module);
+
+        // Remove function _group mappings
+        uint256 executionFunctionsLength = app.manifest.executionFunctions.length;
+        for (uint256 i; i < executionFunctionsLength; ++i) {
+            ManifestExecutionFunction memory func = app.manifest.executionFunctions[i];
+            // Set the group to 0 to remove the mapping
+            _setTargetFunctionGroup(app.module, func.executionSelector, EMPTY_UID);
+        }
+
+        // Revoke module's group access
+        _revokeGroupAccess(app.appId, app.client);
+
+        // Call module's onUninstall if uninstall data is provided
+        // don't revert if it fails
+        bool onUninstallSuccess = true;
+        if (uninstallData.length > 0) {
+            // solhint-disable-next-line no-empty-blocks
+            try IERC6900Module(app.module).onUninstall(uninstallData) {} catch {
+                onUninstallSuccess = false;
+            }
+        }
+
+        emit IERC6900Account.ExecutionUninstalled(app.module, onUninstallSuccess, app.manifest);
+    }
+
+    function _onRenewApp(bytes32 appId, bytes calldata /* data */) internal {
+        // Get the app data to determine the duration
+        App memory app = _getAppRegistry().getAppById(appId);
+        if (app.appId == EMPTY_UID) AppNotRegistered.selector.revertWith();
+
+        // Calculate the new expiration time (extends current expiration by app duration)
+        uint48 newExpiration = _getAppExpiration(app.appId, app.duration);
+
+        // Update the group expiration
+        _setGroupExpiration(app.appId, newExpiration);
+    }
+
+    function _onExecute(
+        address target,
+        uint256,
+        bytes calldata data
+    ) internal returns (bytes memory result) {
+        _checkAuthorized(target);
+        (result, ) = _execute(target, 0, data);
+    }
+
+    // Internal Functions
+    function _getAppExpiration(
+        bytes32 appId,
+        uint48 duration
+    ) internal view returns (uint48 expiration) {
+        uint48 currentExpiration = _getGroupExpiration(appId);
+        if (currentExpiration > block.timestamp) {
+            expiration = currentExpiration + duration;
+        } else {
+            expiration = uint48(block.timestamp) + duration;
+        }
+    }
+
+    function _addApp(address module, bytes32 appId) internal {
+        AppAccountStorage.Layout storage $ = AppAccountStorage.getLayout();
+        $.installedApps.add(module);
+        $.appIdByApp[module] = appId;
+    }
+
+    function _removeApp(address module) internal {
+        AppAccountStorage.getLayout().installedApps.remove(module);
+        delete AppAccountStorage.getLayout().appIdByApp[module];
+    }
+
+    function _enableApp(address app) internal {
+        bytes32 appId = AppAccountStorage.getInstalledAppId(app);
+        if (appId == EMPTY_UID) AppNotRegistered.selector.revertWith();
+        _setGroupStatus(appId, true);
+    }
+
+    function _disableApp(address app) internal {
+        bytes32 appId = AppAccountStorage.getInstalledAppId(app);
+        if (appId == EMPTY_UID) AppNotRegistered.selector.revertWith();
+        _setGroupStatus(appId, false);
+    }
+
+    function _isAppEntitled(
+        address module,
+        address client,
+        bytes32 permission
+    ) internal view returns (bool) {
+        return AppAccountStorage.isAppEntitled(module, client, permission);
+    }
+
+    function _getInstalledAppId(address module) internal view returns (bytes32) {
+        return AppAccountStorage.getInstalledAppId(module);
+    }
+
+    function _getApp(address module) internal view returns (App memory app) {
+        return AppAccountStorage.getApp(module);
+    }
+
+    function _getAppRegistry() internal view returns (IAppRegistry) {
+        return DependencyLib.getAppRegistry();
+    }
+
+    function _getApps() internal view returns (address[] memory) {
+        return AppAccountStorage.getLayout().installedApps.values();
+    }
+
+    function _isAppInstalled(address module) internal view returns (bool) {
+        return AppAccountStorage.getLayout().installedApps.contains(module);
+    }
+
+    function _checkAuthorized(address module) internal view {
+        if (module == address(0)) InvalidAppAddress.selector.revertWith();
+
+        MembershipStorage.Layout storage ms = MembershipStorage.layout();
+        address factory = ms.spaceFactory;
+
+        bytes32[] memory dependencies = new bytes32[](4);
+        dependencies[0] = DependencyLib.RIVER_AIRDROP;
+        dependencies[1] = DependencyLib.SPACE_OPERATOR;
+        dependencies[2] = DependencyLib.SPACE_OWNER;
+        dependencies[3] = DependencyLib.APP_REGISTRY;
+        address[] memory deps = ms.getDependencies(dependencies);
+
+        // Check if app is banned
+        if (IAppRegistry(deps[3]).isAppBanned(module)) {
+            UnauthorizedApp.selector.revertWith(module);
+        }
+
+        // Check against unauthorized targets
+        if (_isUnauthorizedTarget(module, factory, deps)) {
+            UnauthorizedApp.selector.revertWith(module);
+        }
+    }
+
+    function _isUnauthorizedTarget(
+        address module,
+        address factory,
+        address[] memory deps
+    ) private pure returns (bool) {
+        return
+            module == factory || // SpaceFactory
+            module == deps[0] || // RiverAirdrop
+            module == deps[1] || // BaseRegistry
+            module == deps[2] || // SpaceOwner
+            module == deps[3]; // AppRegistry
+    }
+
+    function _isInvalidSelector(bytes4 selector) internal pure returns (bool) {
+        return
+            selector == IERC6900Account.installExecution.selector ||
+            selector == IERC6900Account.uninstallExecution.selector ||
+            selector == IERC6900Account.installValidation.selector ||
+            selector == IERC6900Account.uninstallValidation.selector ||
+            selector == IERC6900Account.execute.selector ||
+            selector == IERC6900Account.executeBatch.selector ||
+            selector == IERC6900Account.executeWithRuntimeValidation.selector ||
+            selector == IERC6900Account.accountId.selector ||
+            selector == IERC165.supportsInterface.selector ||
+            selector == IERC6900Module.moduleId.selector ||
+            selector == IERC6900Module.onInstall.selector ||
+            selector == IERC6900Module.onUninstall.selector ||
+            selector == IERC6900ExecutionModule.executionManifest.selector ||
+            selector == IDiamondCut.diamondCut.selector ||
+            selector == ITownsApp.requiredPermissions.selector;
+    }
+
+    // Override Functions
+    function _getOwner() internal view virtual override returns (address) {
+        return _owner();
+    }
+}

package/src/spaces/facets/account/AppAccountStorage.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IAppRegistry} from "src/apps/facets/registry/IAppRegistry.sol";
+
+// libraries
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+import {ExecutorStorage} from "src/spaces/facets/executor/ExecutorStorage.sol";
+import {DependencyLib} from "src/spaces/facets/DependencyLib.sol";
+import {EMPTY_UID} from "@ethereum-attestation-service/eas-contracts/Common.sol";
+
+// contracts
+
+library AppAccountStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.account.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x5203018779d8301358307033923a3bd0a3a759f1f58591c01f878744c0f8c200;
+
+    struct Layout {
+        EnumerableSetLib.AddressSet installedApps;
+        mapping(address app => bytes32 appId) appIdByApp;
+    }
+
+    function getLayout() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_SLOT
+        }
+    }
+
+    function getInstalledAppId(address module) internal view returns (bytes32) {
+        return getLayout().appIdByApp[module];
+    }
+
+    function getApp(address module) internal view returns (IAppRegistry.App memory app) {
+        bytes32 appId = getInstalledAppId(module);
+        if (appId == EMPTY_UID) return app;
+        return DependencyLib.getAppRegistry().getAppById(appId);
+    }
+
+    function isAppEntitled(
+        address module,
+        address client,
+        bytes32 permission
+    ) internal view returns (bool) {
+        IAppRegistry.App memory app = getApp(module);
+
+        if (app.appId == EMPTY_UID) return false;
+
+        (bool hasClientAccess, , bool isGroupActive) = ExecutorStorage.hasGroupAccess(
+            app.appId,
+            client
+        );
+        if (!hasClientAccess || !isGroupActive) return false;
+
+        uint256 permissionsLength = app.permissions.length;
+        for (uint256 i; i < permissionsLength; ++i) {
+            if (app.permissions[i] == permission) return true;
+        }
+
+        return false;
+    }
+}

package/src/spaces/facets/account/IAppAccount.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+interface IAppAccountBase {
+    error InvalidAppAddress(address app);
+    error InvalidManifest();
+    error UnauthorizedSelector();
+    error NotEnoughEth();
+    error AppAlreadyInstalled();
+    error UnauthorizedApp(address app);
+    error InvalidCaller();
+}
+
+interface IAppAccount is IAppAccountBase {
+    /// @notice Installs an app
+    /// @param appId The ID of the app to install
+    /// @param data The initialization data for the app
+    function onInstallApp(bytes32 appId, bytes calldata data) external;
+
+    /// @notice Uninstalls an app
+    /// @param appId The ID of the app to uninstall
+    /// @param data The data required for app uninstallation
+    function onUninstallApp(bytes32 appId, bytes calldata data) external;
+
+    /// @notice Renews an app
+    /// @param appId The ID of the app to renew
+    /// @param data The data required for app renewal
+    function onRenewApp(bytes32 appId, bytes calldata data) external;
+
+    /// @notice Enables an app
+    /// @param app The address of the app to enable
+    function enableApp(address app) external;
+
+    /// @notice Disables an app
+    /// @param app The address of the app to disable
+    function disableApp(address app) external;
+
+    /// @notice Checks if an app is installed
+    /// @param app The address of the app
+    function isAppInstalled(address app) external view returns (bool);
+
+    /// @notice Gets the ID of an app
+    /// @param app The address of the app to get the ID of
+    /// @return The ID of the app
+    function getAppId(address app) external view returns (bytes32);
+
+    /// @notice Gets the expiration of an app
+    /// @param app The address of the app to get the expiration of
+    /// @return The expiration of the app
+    function getAppExpiration(address app) external view returns (uint48);
+
+    /// @notice Gets the apps installed on the account
+    /// @return The apps installed on the account
+    function getInstalledApps() external view returns (address[] memory);
+
+    /// @notice Checks if a client is entitled to a permission for an app
+    /// @param app The address of the app to check
+    /// @param publicKey The public key to check
+    /// @param permission The permission to check
+    /// @return True if the client is entitled to the permission, false otherwise
+    function isAppEntitled(
+        address app,
+        address publicKey,
+        bytes32 permission
+    ) external view returns (bool);
+}

package/src/spaces/facets/account/SignerFacet.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+import {ERC1271Facet} from "@towns-protocol/diamond/src/facets/accounts/ERC1271Facet.sol";
+import {EIP712Facet} from "@towns-protocol/diamond/src/utils/cryptography/EIP712Facet.sol";
+import {TokenOwnableBase} from "@towns-protocol/diamond/src/facets/ownable/token/TokenOwnableBase.sol";
+
+contract SignerFacet is ERC1271Facet, EIP712Facet, TokenOwnableBase {
+    function _domainNameAndVersion()
+        internal
+        pure
+        override
+        returns (string memory name, string memory version)
+    {
+        return ("Towns", "1");
+    }
+
+    function _erc1271Signer() internal view override returns (address) {
+        return _owner();
+    }
+}

package/src/spaces/facets/banning/Banning.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IBanning} from "src/spaces/facets/banning/IBanning.sol";
+
+// libraries
+import {Permissions} from "src/spaces/facets/Permissions.sol";
+
+// contracts
+
+import {BanningBase} from "./BanningBase.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {ERC721ABase} from "src/diamond/facets/token/ERC721A/ERC721ABase.sol";
+import {Entitled} from "src/spaces/facets/Entitled.sol";
+
+contract Banning is IBanning, BanningBase, ERC721ABase, Entitled, Facet {
+    function ban(uint256 tokenId) external {
+        _validatePermission(Permissions.ModifyBanning);
+        if (!_exists(tokenId)) revert Banning__InvalidTokenId(tokenId);
+        if (_ownerOf(tokenId) == _owner()) revert Banning__CannotBanOwner();
+        if (_ownerOf(tokenId) == msg.sender) revert Banning__CannotBanSelf();
+        if (_isBanned(tokenId)) revert Banning__AlreadyBanned(tokenId);
+        _ban(tokenId);
+    }
+
+    function unban(uint256 tokenId) external {
+        if (!_exists(tokenId)) revert Banning__InvalidTokenId(tokenId);
+        if (!_isBanned(tokenId)) revert Banning__NotBanned(tokenId);
+        _validatePermission(Permissions.ModifyBanning);
+        _unban(tokenId);
+    }
+
+    function isBanned(uint256 tokenId) external view returns (bool) {
+        return _isBanned(tokenId);
+    }
+
+    function banned() external view returns (uint256[] memory) {
+        return _bannedTokenIds();
+    }
+}

package/src/spaces/facets/banning/BanningBase.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IBanningBase} from "./IBanning.sol";
+
+// libraries
+import {BanningStorage} from "./BanningStorage.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+// contracts
+
+abstract contract BanningBase is IBanningBase {
+    using EnumerableSet for EnumerableSet.UintSet;
+
+    function _ban(uint256 tokenId) internal {
+        BanningStorage.layout().bannedIds.add(tokenId);
+        emit Banned(msg.sender, tokenId);
+    }
+
+    function _isBanned(uint256 tokenId) internal view returns (bool isBanned) {
+        return BanningStorage.layout().bannedIds.contains(tokenId);
+    }
+
+    function _unban(uint256 tokenId) internal {
+        BanningStorage.layout().bannedIds.remove(tokenId);
+        emit Unbanned(msg.sender, tokenId);
+    }
+
+    function _bannedTokenIds() internal view returns (uint256[] memory) {
+        return BanningStorage.layout().bannedIds.values();
+    }
+}

package/src/spaces/facets/banning/BanningStorage.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+library BanningStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.banning.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x49daf035076c43671ca9f9fb568d931e51ab7f9098a5a694781b45341112cf00;
+
+    struct Layout {
+        EnumerableSet.UintSet bannedIds;
+        // deprecated
+        mapping(uint256 => bool) bannedFromSpace;
+    }
+
+    function layout() internal pure returns (Layout storage s) {
+        assembly {
+            s.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/spaces/facets/banning/IBanning.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface IBanningBase {
+    // =============================================================
+    //                           Errors
+    // =============================================================
+    error Banning__InvalidTokenId(uint256 tokenId);
+    error Banning__AlreadyBanned(uint256 tokenId);
+    error Banning__NotBanned(uint256 tokenId);
+    error Banning__CannotBanSelf();
+    error Banning__CannotBanOwner();
+
+    // =============================================================
+    //                           Events
+    // =============================================================
+    event Banned(address indexed moderator, uint256 indexed tokenId);
+    event Unbanned(address indexed moderator, uint256 indexed tokenId);
+}
+
+interface IBanning is IBanningBase {
+    function ban(uint256 tokenId) external;
+
+    function unban(uint256 tokenId) external;
+
+    function isBanned(uint256 tokenId) external view returns (bool);
+
+    function banned() external view returns (uint256[] memory);
+}

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

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IChannelBase} from "./IChannel.sol";
+
+// libraries
+
+// services
+import {ChannelService} from "./ChannelService.sol";
+import {Validator} from "../../../utils/libraries/Validator.sol";
+
+abstract contract ChannelBase is IChannelBase {
+    function _createChannel(
+        bytes32 channelId,
+        string calldata metadata,
+        uint256[] memory roleIds
+    ) internal {
+        Validator.checkLengthCalldata(metadata, 0);
+        ChannelService.createChannel(channelId, metadata, roleIds);
+        emit ChannelCreated(msg.sender, channelId);
+    }
+
+    function _getChannel(bytes32 channelId) internal view returns (Channel memory channel) {
+        (, string memory metadata, bool disabled) = ChannelService.getChannel(channelId);
+
+        uint256[] memory roleIds = ChannelService.getRolesByChannel(channelId);
+
+        (channel.id, channel.disabled, channel.metadata, channel.roleIds) = (
+            channelId,
+            disabled,
+            metadata,
+            roleIds
+        );
+    }
+
+    function _getChannels() internal view returns (Channel[] memory channels) {
+        bytes32[] memory channelIds = ChannelService.getChannelIds();
+
+        channels = new Channel[](channelIds.length);
+
+        for (uint256 i; i < channelIds.length; ++i) {
+            (bytes32 id, string memory metadata, bool disabled) = ChannelService.getChannel(
+                channelIds[i]
+            );
+            uint256[] memory roleIds = ChannelService.getRolesByChannel(channelIds[i]);
+
+            Channel memory channel = channels[i];
+            (channel.id, channel.disabled, channel.metadata, channel.roleIds) = (
+                id,
+                disabled,
+                metadata,
+                roleIds
+            );
+        }
+    }
+
+    function _setChannelRoleOverrides(bytes32 channelId, uint256[] memory roleIds) internal {
+        for (uint256 i; i < roleIds.length; ++i) {
+            _addRoleToChannel(channelId, roleIds[i]);
+        }
+    }
+
+    function _updateChannel(bytes32 channelId, string calldata metadata, bool disabled) internal {
+        ChannelService.updateChannel(channelId, metadata, disabled);
+        emit ChannelUpdated(msg.sender, channelId);
+    }
+
+    function _removeChannel(bytes32 channelId) internal {
+        ChannelService.removeChannel(channelId);
+        emit ChannelRemoved(msg.sender, channelId);
+    }
+
+    function _getRolesByChannel(bytes32 channelId) internal view returns (uint256[] memory) {
+        return ChannelService.getRolesByChannel(channelId);
+    }
+
+    function _addRoleToChannel(bytes32 channelId, uint256 roleId) internal {
+        ChannelService.addRoleToChannel(channelId, roleId);
+        emit ChannelRoleAdded(msg.sender, channelId, roleId);
+    }
+
+    function _removeRoleFromChannel(bytes32 channelId, uint256 roleId) internal {
+        ChannelService.removeRoleFromChannel(channelId, roleId);
+        emit ChannelRoleRemoved(msg.sender, channelId, roleId);
+    }
+}