@towns-protocol/contracts 0.0.302

package/src/factory/facets/create/CreateSpace.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ICreateSpace} from "./ICreateSpace.sol";
+
+// libraries
+import {CreateSpaceLib} from "./CreateSpaceLib.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {PausableBase} from "@towns-protocol/diamond/src/facets/pausable/PausableBase.sol";
+import {ReentrancyGuard} from "solady/utils/ReentrancyGuard.sol";
+
+/// @title CreateSpaceFacet
+/// @notice Facet for creating new spaces with various configurations
+/// @dev Inherits from:
+/// - ICreateSpace: Interface defining space creation methods
+/// - PausableBase: Allows pausing of space creation functionality
+/// - ReentrancyGuard: Prevents reentrancy attacks during space creation
+/// - Facet: Base contract for diamond facets
+contract CreateSpaceFacet is ICreateSpace, PausableBase, ReentrancyGuard, Facet {
+    function __CreateSpace_init() external onlyInitializing {
+        _addInterface(type(ICreateSpace).interfaceId);
+    }
+
+    function createSpace(
+        Action action,
+        bytes calldata data
+    ) external payable nonReentrant whenNotPaused returns (address) {
+        SpaceOptions memory spaceOptions = SpaceOptions({to: msg.sender});
+        if (action == Action.CreateBasic) {
+            SpaceInfo memory spaceInfo = abi.decode(data, (SpaceInfo));
+            return CreateSpaceLib.createSpace(spaceInfo, spaceOptions);
+        } else if (action == Action.CreateWithPrepay) {
+            CreateSpace memory spaceInfo = abi.decode(data, (CreateSpace));
+            return CreateSpaceLib.createSpaceWithPrepay(spaceInfo, spaceOptions);
+        } else if (action == Action.CreateWithOptions) {
+            CreateSpace memory spaceInfo;
+            (spaceInfo, spaceOptions) = abi.decode(data, (CreateSpace, SpaceOptions));
+            return CreateSpaceLib.createSpaceWithPrepay(spaceInfo, spaceOptions);
+        } else if (action == Action.CreateLegacy) {
+            CreateSpaceOld memory spaceInfo = abi.decode(data, (CreateSpaceOld));
+            CreateSpace memory newSpaceInfo = _convertLegacySpace(spaceInfo);
+            return CreateSpaceLib.createSpaceWithPrepay(newSpaceInfo, spaceOptions);
+        } else {
+            revert CreateSpaceFacet__InvalidAction();
+        }
+    }
+
+    /// @inheritdoc ICreateSpace
+    function createSpace(
+        SpaceInfo memory spaceInfo
+    ) external nonReentrant whenNotPaused returns (address) {
+        SpaceOptions memory spaceOptions = SpaceOptions({to: msg.sender});
+        return CreateSpaceLib.createSpace(spaceInfo, spaceOptions);
+    }
+
+    /// @inheritdoc ICreateSpace
+    function createSpaceV2(
+        CreateSpace memory spaceInfo,
+        SpaceOptions memory options
+    ) external payable nonReentrant whenNotPaused returns (address) {
+        return CreateSpaceLib.createSpaceWithPrepay(spaceInfo, options);
+    }
+
+    /// @inheritdoc ICreateSpace
+    function createSpaceWithPrepay(
+        CreateSpace memory spaceInfo
+    ) external payable nonReentrant whenNotPaused returns (address) {
+        SpaceOptions memory spaceOptions = SpaceOptions({to: msg.sender});
+        return CreateSpaceLib.createSpaceWithPrepay(spaceInfo, spaceOptions);
+    }
+
+    /// @inheritdoc ICreateSpace
+    function createSpaceWithPrepay(
+        CreateSpaceOld memory spaceInfo
+    ) external payable nonReentrant whenNotPaused returns (address) {
+        CreateSpace memory newSpaceInfo = _convertLegacySpace(spaceInfo);
+        SpaceOptions memory spaceOptions = SpaceOptions({to: msg.sender});
+        return CreateSpaceLib.createSpaceWithPrepay(newSpaceInfo, spaceOptions);
+    }
+
+    /// @dev Converts CreateSpaceOld format to CreateSpace format
+    function _convertLegacySpace(
+        CreateSpaceOld memory spaceInfo
+    ) private pure returns (CreateSpace memory) {
+        MembershipRequirements memory requirements = MembershipRequirements({
+            everyone: spaceInfo.membership.requirements.everyone,
+            users: spaceInfo.membership.requirements.users,
+            ruleData: spaceInfo.membership.requirements.ruleData,
+            syncEntitlements: false
+        });
+        Membership memory membership = Membership({
+            settings: spaceInfo.membership.settings,
+            requirements: requirements,
+            permissions: spaceInfo.membership.permissions
+        });
+        return
+            CreateSpace({
+                metadata: spaceInfo.metadata,
+                membership: membership,
+                channel: spaceInfo.channel,
+                prepay: spaceInfo.prepay
+            });
+    }
+}

package/src/factory/facets/create/CreateSpaceLib.sol

@@ -0,0 +1,335 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ITokenOwnableBase} from "@towns-protocol/diamond/src/facets/ownable/token/ITokenOwnable.sol";
+import {IManagedProxyBase} from "@towns-protocol/diamond/src/proxy/managed/IManagedProxy.sol";
+import {IProxyManager} from "@towns-protocol/diamond/src/proxy/manager/IProxyManager.sol";
+import {IERC721A} from "../../../diamond/facets/token/ERC721A/IERC721A.sol";
+import {IEntitlement} from "../../../spaces/entitlements/IEntitlement.sol";
+import {IRuleEntitlement} from "../../../spaces/entitlements/rule/IRuleEntitlement.sol";
+import {IUserEntitlement} from "../../../spaces/entitlements/user/IUserEntitlement.sol";
+import {IChannel} from "../../../spaces/facets/channels/IChannel.sol";
+import {IEntitlementsManager} from "../../../spaces/facets/entitlements/IEntitlementsManager.sol";
+import {IMembershipBase} from "../../../spaces/facets/membership/IMembership.sol";
+import {IPrepay} from "../../../spaces/facets/prepay/IPrepay.sol";
+import {IRoles, IRolesBase} from "../../../spaces/facets/roles/IRoles.sol";
+import {IArchitectBase} from "../architect/IArchitect.sol";
+
+// libraries
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {Permissions} from "../../../spaces/facets/Permissions.sol";
+import {StringSet} from "../../../utils/libraries/StringSet.sol";
+import {Validator} from "../../../utils/libraries/Validator.sol";
+import {ArchitectStorage} from "../architect/ArchitectStorage.sol";
+import {ImplementationStorage} from "../architect/ImplementationStorage.sol";
+
+// contracts
+import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import {SpaceProxy} from "../../../spaces/facets/proxy/SpaceProxy.sol";
+import {SpaceProxyInitializer} from "../../../spaces/facets/proxy/SpaceProxyInitializer.sol";
+import {Factory} from "../../../utils/libraries/Factory.sol";
+import {PricingModulesBase} from "../architect/pricing/PricingModulesBase.sol";
+
+library CreateSpaceLib {
+    using StringSet for StringSet.Set;
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    address internal constant EVERYONE_ADDRESS = address(1);
+    string internal constant MINTER_ROLE = "Minter";
+    bytes1 internal constant CHANNEL_PREFIX = 0x20;
+
+    function createSpaceWithPrepay(
+        IArchitectBase.CreateSpace memory space,
+        IArchitectBase.SpaceOptions memory spaceOptions
+    ) internal returns (address spaceAddress) {
+        Validator.checkAddress(space.membership.settings.pricingModule);
+        Validator.checkAddress(spaceOptions.to);
+
+        IArchitectBase.SpaceInfo memory spaceInfo = IArchitectBase.SpaceInfo({
+            name: space.metadata.name,
+            uri: space.metadata.uri,
+            shortDescription: space.metadata.shortDescription,
+            longDescription: space.metadata.longDescription,
+            membership: space.membership,
+            channel: space.channel
+        });
+
+        spaceAddress = createSpace(spaceInfo, spaceOptions);
+
+        if (space.prepay.supply > 0) {
+            IPrepay(spaceAddress).prepayMembership{value: msg.value}(space.prepay.supply);
+        }
+    }
+
+    function createSpace(
+        IArchitectBase.SpaceInfo memory spaceInfo,
+        IArchitectBase.SpaceOptions memory spaceOptions
+    ) internal returns (address spaceAddress) {
+        ArchitectStorage.Layout storage ds = ArchitectStorage.layout();
+        ImplementationStorage.Layout storage ims = ImplementationStorage.layout();
+
+        // get the token id of the next space
+        uint256 spaceTokenId = ims.spaceOwnerToken.nextTokenId();
+
+        // deploy space
+        spaceAddress = deploySpace(spaceTokenId, spaceInfo.membership, spaceOptions);
+
+        // save space info to storage
+        unchecked {
+            ds.spaceCount++;
+        }
+
+        // save to mappings
+        ds.spaceByTokenId[spaceTokenId] = spaceAddress;
+        ds.tokenIdBySpace[spaceAddress] = spaceTokenId;
+
+        // mint token to and transfer to Architect
+        ims.spaceOwnerToken.mintSpace(
+            spaceInfo.name,
+            spaceInfo.uri,
+            spaceAddress,
+            spaceInfo.shortDescription,
+            spaceInfo.longDescription
+        );
+
+        // deploy user entitlement
+        IUserEntitlement userEntitlement = IUserEntitlement(
+            deployEntitlement(ims.userEntitlement, spaceAddress)
+        );
+
+        // deploy token entitlement
+        IRuleEntitlement ruleEntitlement = IRuleEntitlement(
+            deployEntitlement(ims.ruleEntitlement, spaceAddress)
+        );
+
+        address[] memory entitlements = new address[](2);
+        entitlements[0] = address(userEntitlement);
+        entitlements[1] = address(ruleEntitlement);
+
+        // set entitlements as immutable
+        IEntitlementsManager(spaceAddress).addImmutableEntitlements(entitlements);
+
+        // create minter role with requirements
+        string[] memory joinPermissions = new string[](1);
+        joinPermissions[0] = Permissions.JoinSpace;
+        if (spaceInfo.membership.requirements.everyone) {
+            createEveryoneEntitlement(spaceAddress, MINTER_ROLE, joinPermissions, userEntitlement);
+        } else {
+            createEntitlementForRole(
+                spaceAddress,
+                MINTER_ROLE,
+                joinPermissions,
+                spaceInfo.membership.requirements,
+                userEntitlement,
+                ruleEntitlement
+            );
+        }
+
+        uint256 memberRoleId;
+
+        // if entitlement are synced, create a role with the membership requirements
+        if (spaceInfo.membership.requirements.syncEntitlements) {
+            memberRoleId = createEntitlementForRole(
+                spaceAddress,
+                spaceInfo.membership.settings.name,
+                spaceInfo.membership.permissions,
+                spaceInfo.membership.requirements,
+                userEntitlement,
+                ruleEntitlement
+            );
+        } else {
+            // else create a role with the everyone entitlement
+            memberRoleId = createEveryoneEntitlement(
+                spaceAddress,
+                spaceInfo.membership.settings.name,
+                spaceInfo.membership.permissions,
+                userEntitlement
+            );
+        }
+
+        // create default channel
+        createDefaultChannel(spaceAddress, memberRoleId, spaceInfo.channel);
+
+        // transfer nft to sender
+        IERC721A(address(ims.spaceOwnerToken)).safeTransferFrom(
+            address(this),
+            spaceOptions.to,
+            spaceTokenId
+        );
+
+        // emit event
+        emit IArchitectBase.SpaceCreated(spaceOptions.to, spaceTokenId, spaceAddress);
+    }
+    // =============================================================
+    //                  Internal Channel Helpers
+    // =============================================================
+
+    function createDefaultChannel(
+        address space,
+        uint256 roleId,
+        IArchitectBase.ChannelInfo memory channelInfo
+    ) internal {
+        uint256[] memory roleIds = new uint256[](1);
+        roleIds[0] = roleId;
+
+        bytes32 defaultChannelId = bytes32(bytes.concat(CHANNEL_PREFIX, bytes20(space)));
+
+        IChannel(space).createChannel(defaultChannelId, channelInfo.metadata, roleIds);
+    }
+
+    // =============================================================
+    //                  Internal Entitlement Helpers
+    // =============================================================
+    function createEntitlementForRole(
+        address spaceAddress,
+        string memory roleName,
+        string[] memory permissions,
+        IArchitectBase.MembershipRequirements memory requirements,
+        IUserEntitlement userEntitlement,
+        IRuleEntitlement ruleEntitlement
+    ) internal returns (uint256 roleId) {
+        uint256 entitlementCount = 0;
+        uint256 userReqsLen = requirements.users.length;
+        uint256 ruleReqsLen = requirements.ruleData.length;
+
+        if (userReqsLen > 0) {
+            ++entitlementCount;
+        }
+
+        if (ruleReqsLen > 0) {
+            ++entitlementCount;
+        }
+
+        IRolesBase.CreateEntitlement[] memory entitlements = new IRolesBase.CreateEntitlement[](
+            entitlementCount
+        );
+
+        uint256 entitlementIndex;
+
+        if (userReqsLen != 0) {
+            // validate users
+            for (uint256 i; i < userReqsLen; ++i) {
+                Validator.checkAddress(requirements.users[i]);
+            }
+
+            entitlements[entitlementIndex++] = IRolesBase.CreateEntitlement({
+                module: userEntitlement,
+                data: abi.encode(requirements.users)
+            });
+        }
+
+        if (ruleReqsLen > 0) {
+            entitlements[entitlementIndex++] = IRolesBase.CreateEntitlement({
+                module: ruleEntitlement,
+                data: requirements.ruleData
+            });
+        }
+
+        roleId = createRoleWithEntitlements(spaceAddress, roleName, permissions, entitlements);
+    }
+
+    function createEveryoneEntitlement(
+        address spaceAddress,
+        string memory roleName,
+        string[] memory permissions,
+        IUserEntitlement userEntitlement
+    ) internal returns (uint256 roleId) {
+        address[] memory users = new address[](1);
+        users[0] = EVERYONE_ADDRESS;
+
+        IRolesBase.CreateEntitlement[] memory entitlements = new IRolesBase.CreateEntitlement[](1);
+        entitlements[0].module = userEntitlement;
+        entitlements[0].data = abi.encode(users);
+
+        roleId = createRoleWithEntitlements(spaceAddress, roleName, permissions, entitlements);
+    }
+
+    function createRoleWithEntitlements(
+        address spaceAddress,
+        string memory roleName,
+        string[] memory permissions,
+        IRolesBase.CreateEntitlement[] memory entitlements
+    ) internal returns (uint256 roleId) {
+        return IRoles(spaceAddress).createRole(roleName, permissions, entitlements);
+    }
+
+    // =============================================================
+    //                      Deployment Helpers
+    // =============================================================
+
+    function deploySpace(
+        uint256 spaceTokenId,
+        IArchitectBase.Membership memory membership,
+        IArchitectBase.SpaceOptions memory spaceOptions
+    ) internal returns (address space) {
+        // get deployment info
+        (bytes memory initCode, bytes32 salt) = getSpaceDeploymentInfo(
+            spaceTokenId,
+            membership,
+            spaceOptions
+        );
+        return Factory.deploy(initCode, salt);
+    }
+
+    function deployEntitlement(
+        IEntitlement entitlement,
+        address spaceAddress
+    ) internal returns (address) {
+        // calculate init code
+        bytes memory initCode = abi.encodePacked(
+            type(ERC1967Proxy).creationCode,
+            abi.encode(entitlement, abi.encodeCall(IEntitlement.initialize, (spaceAddress)))
+        );
+
+        return Factory.deploy(initCode);
+    }
+
+    function verifyPricingModule(address pricingModule) internal view {
+        if (pricingModule == address(0) || !PricingModulesBase.isPricingModule(pricingModule)) {
+            revert IArchitectBase.Architect__InvalidPricingModule();
+        }
+    }
+
+    function getSpaceDeploymentInfo(
+        uint256 spaceTokenId,
+        IArchitectBase.Membership memory membership,
+        IArchitectBase.SpaceOptions memory spaceOptions
+    ) internal view returns (bytes memory initCode, bytes32 salt) {
+        verifyPricingModule(membership.settings.pricingModule);
+
+        address spaceOwnerNFT = address(ImplementationStorage.layout().spaceOwnerToken);
+
+        // calculate salt
+        salt = keccak256(abi.encode(spaceTokenId, block.timestamp, block.number, spaceOwnerNFT));
+
+        IMembershipBase.Membership memory membershipSettings = membership.settings;
+
+        address proxyInitializer = address(ImplementationStorage.layout().proxyInitializer);
+
+        // calculate init code
+        initCode = abi.encodePacked(
+            type(SpaceProxy).creationCode,
+            abi.encode(
+                IManagedProxyBase.ManagedProxy({
+                    managerSelector: IProxyManager.getImplementation.selector,
+                    manager: address(this)
+                }),
+                proxyInitializer,
+                abi.encodeCall(
+                    SpaceProxyInitializer.initialize,
+                    (
+                        spaceOptions.to,
+                        address(this),
+                        ITokenOwnableBase.TokenOwnable({
+                            collection: spaceOwnerNFT,
+                            tokenId: spaceTokenId
+                        }),
+                        membershipSettings
+                    )
+                )
+            )
+        );
+    }
+}

package/src/factory/facets/create/ICreateSpace.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IArchitectBase} from "../architect/IArchitect.sol";
+
+interface ICreateSpaceBase {
+    /// @notice Action enum for unified space creation dispatch
+    /// @dev To encode data for each action:
+    ///   switch (action) {
+    ///     case Action.CreateBasic:
+    ///       data = abi.encode(SpaceInfo memory spaceInfo);
+    ///     case Action.CreateWithPrepay:
+    ///       data = abi.encode(CreateSpace memory spaceInfo);
+    ///     case Action.CreateWithOptions:
+    ///       data = abi.encode(CreateSpace memory spaceInfo, SpaceOptions memory options);
+    ///     case Action.CreateLegacy:
+    ///       data = abi.encode(CreateSpaceOld memory spaceInfo);
+    ///   }
+    enum Action {
+        CreateBasic, // Basic space creation with SpaceInfo struct
+        CreateWithPrepay, // Space creation with prepaid memberships
+        CreateWithOptions, // Space creation with custom deployment options
+        CreateLegacy // Legacy space creation for backward compatibility
+    }
+
+    error CreateSpaceFacet__InvalidAction();
+}
+
+interface ICreateSpace is IArchitectBase, ICreateSpaceBase {
+    /// @notice Unified entry point for creating spaces with different configurations
+    /// @param action The type of space creation to perform
+    /// @param data ABI-encoded data for the specific action type
+    /// @return address The address of the newly created space contract
+    function createSpace(Action action, bytes calldata data) external payable returns (address);
+
+    /// @notice Creates a new space with basic configuration
+    /// @param SpaceInfo Struct containing space metadata, membership settings, and channel
+    /// configuration
+    /// @return address The address of the newly created space contract
+    function createSpace(SpaceInfo memory SpaceInfo) external returns (address);
+
+    /// @notice Creates a new space with prepaid memberships
+    /// @param createSpace Struct containing space metadata, membership settings, channel config and
+    /// prepay info
+    /// @return address The address of the newly created space contract
+    /// @dev The msg.value must cover the cost of prepaid memberships
+    function createSpaceWithPrepay(
+        CreateSpace memory createSpace
+    ) external payable returns (address);
+
+    /// @notice Creates a new space with prepaid memberships and custom deployment options
+    /// @param createSpace Struct containing space metadata, membership settings, channel config and
+    /// prepay info
+    /// @param options Struct containing deployment options like the recipient address
+    /// @return address The address of the newly created space contract
+    /// @dev The msg.value must cover the cost of prepaid memberships
+    function createSpaceV2(
+        CreateSpace memory createSpace,
+        SpaceOptions memory options
+    ) external payable returns (address);
+
+    /// @notice Legacy function for backwards compatibility with older space creation format
+    /// @param spaceInfo Struct containing old format space configuration
+    /// @return address The address of the newly created space contract
+    /// @dev This function converts the old format to the new format internally
+    /// @dev The msg.value must cover the cost of prepaid memberships
+    function createSpaceWithPrepay(
+        CreateSpaceOld memory spaceInfo
+    ) external payable returns (address);
+}

package/src/factory/facets/feature/FeatureConditionLib.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol";
+
+/// @notice Represents a condition for feature activation
+/// @dev Used to determine if a feature should be enabled based on token voting power
+/// @param token The address of the token used for voting (must implement IVotes)
+/// @param threshold The minimum number of delegations required to activate the feature
+/// @param active Whether the condition is currently active
+/// @param extraData Additional data that might be used for specialized condition logic
+struct FeatureCondition {
+    address token;
+    bool active;
+    uint256 threshold;
+    bytes extraData;
+}
+
+/// @title FeatureConditionLib
+library FeatureConditionLib {
+    function isValid(FeatureCondition storage condition) internal view returns (bool) {
+        return condition.active && condition.token != address(0);
+    }
+
+    /// @notice Gets the voting power of a space for the condition's token
+    /// @dev Calls the getVotes function on the token contract
+    /// @param condition The condition containing the token address
+    /// @param space The address of the space to check votes for
+    /// @return The number of votes the space has with the token
+    function getVotes(
+        FeatureCondition storage condition,
+        address space
+    ) internal view returns (uint256) {
+        return IVotes(condition.token).getVotes(space);
+    }
+
+    /// @notice Checks if the given number of votes meets the condition's threshold
+    /// @dev Returns false if condition is inactive, true if threshold is 0, otherwise compares
+    /// votes to threshold
+    /// @param condition The condition containing the threshold and active status
+    /// @param votes The number of votes to check against the threshold
+    /// @return True if the condition is met, false otherwise
+    function meetsThreshold(
+        FeatureCondition storage condition,
+        uint256 votes
+    ) internal view returns (bool) {
+        if (!isValid(condition)) return false;
+        uint256 threshold = condition.threshold;
+        if (threshold == 0) return true;
+        return votes >= threshold;
+    }
+}

package/src/factory/facets/feature/FeatureManagerFacet.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IFeatureManagerFacet} from "./IFeatureManagerFacet.sol";
+
+// libraries
+import {FeatureManagerLib} from "./FeatureManagerLib.sol";
+import {FeatureCondition, FeatureConditionLib} from "./FeatureConditionLib.sol";
+// contracts
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+
+/// @title FeatureManagerFacet
+/// @notice Manages feature conditions and checks for spaces
+/// @dev This facet is responsible for managing feature conditions and checking if a space meets the condition for a feature to be enabled
+contract FeatureManagerFacet is IFeatureManagerFacet, OwnableBase, Facet {
+    using FeatureManagerLib for FeatureManagerLib.Layout;
+    using FeatureConditionLib for FeatureCondition;
+
+    function __FeatureManagerFacet_init() external onlyInitializing {
+        _addInterface(type(IFeatureManagerFacet).interfaceId);
+    }
+
+    /// @inheritdoc IFeatureManagerFacet
+    function setFeatureCondition(
+        bytes32 featureId,
+        FeatureCondition calldata condition
+    ) external onlyOwner {
+        FeatureManagerLib.getLayout().setFeatureCondition(featureId, condition);
+        emit FeatureConditionSet(featureId, condition);
+    }
+
+    /// @inheritdoc IFeatureManagerFacet
+    function getFeatureCondition(
+        bytes32 featureId
+    ) external view returns (FeatureCondition memory) {
+        return FeatureManagerLib.getLayout().getFeatureCondition(featureId);
+    }
+
+    /// @inheritdoc IFeatureManagerFacet
+    function getFeatureConditions() external view returns (FeatureCondition[] memory) {
+        return FeatureManagerLib.getLayout().getFeatureConditions();
+    }
+
+    /// @inheritdoc IFeatureManagerFacet
+    function getFeatureConditionsForSpace(
+        address space
+    ) external view returns (FeatureCondition[] memory) {
+        return FeatureManagerLib.getLayout().getFeatureConditionsForSpace(space);
+    }
+
+    /// @inheritdoc IFeatureManagerFacet
+    function disableFeatureCondition(bytes32 featureId) external onlyOwner {
+        FeatureManagerLib.getLayout().disableFeatureCondition(featureId);
+        emit FeatureConditionDisabled(featureId);
+    }
+
+    /// @inheritdoc IFeatureManagerFacet
+    function checkFeatureCondition(bytes32 featureId, address space) external view returns (bool) {
+        FeatureCondition storage condition = FeatureManagerLib.getLayout().conditions[featureId];
+        if (!condition.isValid()) return false;
+        uint256 votes = condition.getVotes(space);
+        return condition.meetsThreshold(votes);
+    }
+}