@towns-protocol/contracts 0.0.304 → 0.0.306

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.304",
+  "version": "0.0.306",
   "packageManager": "yarn@3.8.0",
   "scripts": {
     "build": "forge build",
@@ -32,7 +32,7 @@
     "@layerzerolabs/oapp-evm": "^0.3.2",
     "@openzeppelin/merkle-tree": "^1.0.8",
     "@prb/test": "^0.6.4",
-    "@towns-protocol/prettier-config": "^0.0.304",
+    "@towns-protocol/prettier-config": "^0.0.306",
     "@wagmi/cli": "^2.2.0",
     "account-abstraction": "https://github.com/eth-infinitism/account-abstraction/archive/refs/tags/v0.7.0.tar.gz",
     "forge-std": "github:foundry-rs/forge-std#v1.10.0",
@@ -53,5 +53,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f288ff8d07f5c94aa46d291dc8554c8233d6fd60"
+  "gitHead": "439633cf1571af6312b1cda88b578853be38afc4"
 }

package/scripts/deployments/facets/DeployFeatureManager.s.sol

@@ -12,13 +12,14 @@ import {FeatureManagerFacet} from "src/factory/facets/feature/FeatureManagerFace
 
 library DeployFeatureManager {
     function selectors() internal pure returns (bytes4[] memory _selectors) {
-        _selectors = new bytes4[](6);
+        _selectors = new bytes4[](7);
         _selectors[0] = FeatureManagerFacet.setFeatureCondition.selector;
-        _selectors[1] = FeatureManagerFacet.getFeatureCondition.selector;
-        _selectors[2] = FeatureManagerFacet.getFeatureConditions.selector;
-        _selectors[3] = FeatureManagerFacet.getFeatureConditionsForSpace.selector;
-        _selectors[4] = FeatureManagerFacet.checkFeatureCondition.selector;
-        _selectors[5] = FeatureManagerFacet.disableFeatureCondition.selector;
+        _selectors[1] = FeatureManagerFacet.updateFeatureCondition.selector;
+        _selectors[2] = FeatureManagerFacet.getFeatureCondition.selector;
+        _selectors[3] = FeatureManagerFacet.getFeatureConditions.selector;
+        _selectors[4] = FeatureManagerFacet.getFeatureConditionsForSpace.selector;
+        _selectors[5] = FeatureManagerFacet.checkFeatureCondition.selector;
+        _selectors[6] = FeatureManagerFacet.disableFeatureCondition.selector;
     }
 
     function makeCut(

package/scripts/deployments/utils/DeployProxyBatchDelegation.s.sol

@@ -15,6 +15,7 @@ import {DeployTownsMainnet} from "./DeployTownsMainnet.s.sol";
 
 contract DeployProxyBatchDelegation is Deployer {
     address internal constant CLAIMERS = 0x0bEe55b52d01C4D5d4D0cfcE1d6e0baE6722db05;
+    address internal constant CLAIMERS_SEPOLIA = 0xeeDCAB3c3B032D5627dcF5e1475E0e24a88b4A21;
     address internal constant BASE_REGISTRY = 0x7c0422b31401C936172C897802CF0373B35B7698;
     address internal constant BASE_REGISTRY_SEPOLIA = 0x08cC41b782F27d62995056a4EF2fCBAe0d3c266F;
     address internal constant MESSENGER = 0x866E82a600A1414e583f7F13623F1aC5d58b0Afa;
@@ -77,6 +78,8 @@ contract DeployProxyBatchDelegation is Deployer {
     function _getClaimers(address deployer) internal returns (address) {
         if (block.chainid == 1) {
             return CLAIMERS;
+        } else if (block.chainid == 11_155_111) {
+            return CLAIMERS_SEPOLIA;
         }
 
         vm.broadcast(deployer);

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

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IFeatureManagerFacetBase} from "./IFeatureManagerFacet.sol";
+import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+// libraries
+import {FeatureManagerStorage} from "./FeatureManagerStorage.sol";
+import {FeatureCondition} from "./IFeatureManagerFacet.sol";
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+import {LibCall} from "solady/utils/LibCall.sol";
+
+// contracts
+
+abstract contract FeatureManagerBase is IFeatureManagerFacetBase {
+    using EnumerableSetLib for EnumerableSetLib.Bytes32Set;
+    using CustomRevert for bytes4;
+
+    function _upsertFeatureCondition(
+        bytes32 featureId,
+        FeatureCondition calldata condition,
+        bool create
+    ) internal {
+        _validateToken(condition);
+
+        FeatureManagerStorage.Layout storage $ = FeatureManagerStorage.getLayout();
+        if (create && !$.featureIds.add(featureId)) {
+            FeatureAlreadyExists.selector.revertWith();
+        } else if (!create && !$.featureIds.contains(featureId)) {
+            FeatureNotActive.selector.revertWith();
+        }
+
+        $.conditions[featureId] = condition;
+    }
+
+    /// @notice Retrieves the condition for a specific feature
+    /// @dev Returns the complete condition struct with all parameters
+    /// @param featureId The unique identifier for the feature
+    /// @return result The complete condition configuration for the feature
+    function _getFeatureCondition(
+        bytes32 featureId
+    ) internal view returns (FeatureCondition memory result) {
+        FeatureManagerStorage.Layout storage $ = FeatureManagerStorage.getLayout();
+        assembly ("memory-safe") {
+            mstore(0x40, result)
+        }
+        result = $.conditions[featureId];
+    }
+
+    /// @notice Retrieves all feature conditions
+    /// @dev Returns an array of all feature conditions
+    /// @return FeatureCondition[] An array of all feature conditions
+    function _getFeatureConditions() internal view returns (FeatureCondition[] memory) {
+        FeatureManagerStorage.Layout storage $ = FeatureManagerStorage.getLayout();
+        uint256 featureCount = $.featureIds.length();
+
+        FeatureCondition[] memory conditions = new FeatureCondition[](featureCount);
+        for (uint256 i; i < featureCount; ++i) {
+            conditions[i] = $.conditions[$.featureIds.at(i)];
+        }
+        return conditions;
+    }
+
+    /// @notice Retrieves all feature conditions for a specific space
+    /// @dev Returns an array of all feature conditions that are active for the space
+    /// @return FeatureCondition[] An array of all feature conditions that are active for the space
+    function _getFeatureConditionsForSpace(
+        address space
+    ) internal view returns (FeatureCondition[] memory) {
+        FeatureManagerStorage.Layout storage $ = FeatureManagerStorage.getLayout();
+        uint256 featureCount = $.featureIds.length();
+
+        FeatureCondition[] memory conditions = new FeatureCondition[](featureCount);
+        uint256 index;
+
+        for (uint256 i; i < featureCount; ++i) {
+            bytes32 id = $.featureIds.at(i);
+            FeatureCondition storage cond = $.conditions[id];
+
+            if (_isValidCondition(cond, space)) {
+                conditions[index++] = cond;
+            }
+        }
+
+        assembly ("memory-safe") {
+            mstore(conditions, index)
+        }
+
+        return conditions;
+    }
+
+    /// @notice Disables a feature by setting its active flag to false
+    /// @dev This does not delete the condition, only deactivates it
+    /// @param featureId The unique identifier for the feature to disable
+    function _disableFeatureCondition(bytes32 featureId) internal {
+        FeatureCondition storage condition = FeatureManagerStorage.getLayout().conditions[
+            featureId
+        ];
+        if (!condition.active) FeatureNotActive.selector.revertWith();
+        condition.active = false;
+    }
+
+    /// @notice Sets a feature condition (wrapper for upsert with create=true)
+    /// @param featureId The unique identifier for the feature
+    /// @param condition The condition struct containing token, threshold, active status, and extra data
+    function _setFeatureCondition(bytes32 featureId, FeatureCondition calldata condition) internal {
+        _upsertFeatureCondition(featureId, condition, true);
+    }
+
+    /// @notice Updates a feature condition (wrapper for upsert with create=false)
+    /// @param featureId The unique identifier for the feature
+    /// @param condition The condition struct containing token, threshold, active status, and extra data
+    function _updateFeatureCondition(
+        bytes32 featureId,
+        FeatureCondition calldata condition
+    ) internal {
+        _upsertFeatureCondition(featureId, condition, false);
+    }
+
+    function _validateToken(FeatureCondition calldata condition) internal view {
+        if (condition.token == address(0)) InvalidToken.selector.revertWith();
+
+        // Check if the token implements IVotes.getVotes with proper return data
+        (bool success, bool exceededMaxCopy, bytes memory data) = LibCall.tryStaticCall(
+            condition.token,
+            gasleft(),
+            32,
+            abi.encodeCall(IVotes.getVotes, (address(this)))
+        );
+
+        if (!success || exceededMaxCopy || data.length != 32)
+            InvalidInterface.selector.revertWith();
+
+        // Check if the token implements ERC20.totalSupply with proper return data
+        (success, exceededMaxCopy, data) = LibCall.tryStaticCall(
+            condition.token,
+            gasleft(),
+            32,
+            abi.encodeCall(IERC20.totalSupply, ())
+        );
+
+        if (!success || exceededMaxCopy || data.length != 32)
+            InvalidInterface.selector.revertWith();
+
+        uint256 totalSupply = abi.decode(data, (uint256));
+        if (totalSupply == 0) InvalidTotalSupply.selector.revertWith();
+        if (condition.threshold > totalSupply) InvalidThreshold.selector.revertWith();
+    }
+
+    /// @notice Checks if a condition should be included for a given space
+    /// @dev Returns true if the condition is active, has a valid token, and meets the threshold
+    /// @param condition The condition to check
+    /// @param space The space address to check against
+    /// @return True if the condition should be included, false otherwise
+    function _isValidCondition(
+        FeatureCondition memory condition,
+        address space
+    ) internal view returns (bool) {
+        if (!condition.active) return false;
+        if (condition.token == address(0)) return false;
+        uint256 votes = IVotes(condition.token).getVotes(space);
+        return votes >= condition.threshold;
+    }
+}

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

@@ -3,10 +3,12 @@ pragma solidity ^0.8.23;
 
 // interfaces
 import {IFeatureManagerFacet} from "./IFeatureManagerFacet.sol";
+import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol";
 
 // libraries
-import {FeatureManagerLib} from "./FeatureManagerLib.sol";
-import {FeatureCondition, FeatureConditionLib} from "./FeatureConditionLib.sol";
+import {FeatureManagerBase} from "./FeatureManagerBase.sol";
+import {FeatureCondition} from "./IFeatureManagerFacet.sol";
+
 // contracts
 import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
 import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
@@ -14,10 +16,7 @@ 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;
-
+contract FeatureManagerFacet is IFeatureManagerFacet, OwnableBase, Facet, FeatureManagerBase {
     function __FeatureManagerFacet_init() external onlyInitializing {
         _addInterface(type(IFeatureManagerFacet).interfaceId);
     }
@@ -27,7 +26,16 @@ contract FeatureManagerFacet is IFeatureManagerFacet, OwnableBase, Facet {
         bytes32 featureId,
         FeatureCondition calldata condition
     ) external onlyOwner {
-        FeatureManagerLib.getLayout().setFeatureCondition(featureId, condition);
+        _upsertFeatureCondition(featureId, condition, true);
+        emit FeatureConditionSet(featureId, condition);
+    }
+
+    /// @inheritdoc IFeatureManagerFacet
+    function updateFeatureCondition(
+        bytes32 featureId,
+        FeatureCondition calldata condition
+    ) external onlyOwner {
+        _upsertFeatureCondition(featureId, condition, false);
         emit FeatureConditionSet(featureId, condition);
     }
 
@@ -35,32 +43,29 @@ contract FeatureManagerFacet is IFeatureManagerFacet, OwnableBase, Facet {
     function getFeatureCondition(
         bytes32 featureId
     ) external view returns (FeatureCondition memory) {
-        return FeatureManagerLib.getLayout().getFeatureCondition(featureId);
+        return _getFeatureCondition(featureId);
     }
 
     /// @inheritdoc IFeatureManagerFacet
     function getFeatureConditions() external view returns (FeatureCondition[] memory) {
-        return FeatureManagerLib.getLayout().getFeatureConditions();
+        return _getFeatureConditions();
     }
 
     /// @inheritdoc IFeatureManagerFacet
     function getFeatureConditionsForSpace(
         address space
     ) external view returns (FeatureCondition[] memory) {
-        return FeatureManagerLib.getLayout().getFeatureConditionsForSpace(space);
+        return _getFeatureConditionsForSpace(space);
     }
 
     /// @inheritdoc IFeatureManagerFacet
     function disableFeatureCondition(bytes32 featureId) external onlyOwner {
-        FeatureManagerLib.getLayout().disableFeatureCondition(featureId);
+        _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);
+        return _isValidCondition(_getFeatureCondition(featureId), space);
     }
 }

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

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.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 voting power (votes) 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 FeatureManager
+library FeatureManagerStorage {
+    using EnumerableSetLib for EnumerableSetLib.Bytes32Set;
+
+    // keccak256(abi.encode(uint256(keccak256("factory.facets.feature.manager.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 constant DEFAULT_STORAGE_SLOT =
+        0x20c456a8ea15fcf7965033c954321ffd9dc82a2c65f686a77e2a67da65c29000;
+
+    /// @notice Storage layout for the FeatureManager
+    /// @dev Maps feature IDs to their activation conditions
+    /// @custom:storage-location erc7201:towns.storage.FeatureManager
+    struct Layout {
+        // Feature IDs
+        EnumerableSetLib.Bytes32Set featureIds;
+        // Feature ID => Condition
+        mapping(bytes32 featureId => FeatureCondition condition) conditions;
+    }
+
+    function getLayout() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := DEFAULT_STORAGE_SLOT
+        }
+    }
+}

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

@@ -2,11 +2,8 @@
 pragma solidity ^0.8.23;
 
 // interfaces
-
-// libraries
-import {FeatureCondition} from "./FeatureConditionLib.sol";
-
-// contracts
+import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol";
+import {FeatureCondition} from "./FeatureManagerStorage.sol";
 
 /// @title IFeatureManagerFacetBase
 /// @notice Base interface for the FeatureManager facet defining errors and events
@@ -18,15 +15,18 @@ interface IFeatureManagerFacetBase {
     /// @notice Error thrown when a token has zero total supply
     error InvalidTotalSupply();
 
-    /// @notice Error thrown when an invalid token address is provided (zero address or non-IVotes token)
+    /// @notice Error thrown when an invalid token address is provided (e.g., zero address)
     error InvalidToken();
 
-    /// @notice Error thrown when an invalid token interface is provided
+    /// @notice Error thrown when the token does not implement the required interfaces (e.g., IVotes and ERC20 totalSupply)
     error InvalidInterface();
 
     /// @notice Error thrown when a feature condition is not active
     error FeatureNotActive();
 
+    /// @notice Error thrown when a feature condition already exists
+    error FeatureAlreadyExists();
+
     /// @notice Emitted when a feature condition is set or updated
     /// @param featureId The unique identifier for the feature whose condition was set
     /// @param condition The condition parameters that were set for the feature
@@ -44,6 +44,12 @@ interface IFeatureManagerFacet is IFeatureManagerFacetBase {
     /// @dev Only callable by the contract owner
     function setFeatureCondition(bytes32 featureId, FeatureCondition memory condition) external;
 
+    /// @notice Updates the condition for a feature
+    /// @param featureId The unique identifier for the feature
+    /// @param condition The condition struct containing token, threshold, active status, and extra data
+    /// @dev Only callable by the contract owner
+    function updateFeatureCondition(bytes32 featureId, FeatureCondition memory condition) external;
+
     /// @notice Gets the condition for a feature
     /// @param featureId The unique identifier for the feature
     /// @return The condition struct for the specified feature

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

@@ -1,53 +0,0 @@
-// 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/FeatureManagerLib.sol

@@ -1,168 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.23;
-
-// interfaces
-
-import {IFeatureManagerFacetBase} from "./IFeatureManagerFacet.sol";
-import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol";
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
-
-// libraries
-
-import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
-import {FeatureCondition, FeatureConditionLib} from "./FeatureConditionLib.sol";
-import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
-
-/// @title FeatureManager
-library FeatureManagerLib {
-    using EnumerableSetLib for EnumerableSetLib.Bytes32Set;
-    using FeatureConditionLib for FeatureCondition;
-
-    // keccak256(abi.encode(uint256(keccak256("factory.facets.feature.manager.storage")) - 1)) & ~bytes32(uint256(0xff))
-    bytes32 constant DEFAULT_STORAGE_SLOT =
-        0x20c456a8ea15fcf7965033c954321ffd9dc82a2c65f686a77e2a67da65c29000;
-
-    /// @notice Storage layout for the FeatureManager
-    /// @dev Maps feature IDs to their activation conditions
-    /// @custom:storage-location erc7201:towns.storage.FeatureManager
-    struct Layout {
-        // Feature IDs
-        EnumerableSetLib.Bytes32Set featureIds;
-        // Feature ID => Condition
-        mapping(bytes32 featureId => FeatureCondition condition) conditions;
-    }
-
-    /// @notice Sets the condition for a specific feature
-    /// @dev Validates token, threshold, and total supply to ensure proper configuration
-    /// @param self The storage layout pointer
-    /// @param featureId The unique identifier for the feature
-    /// @param condition The condition parameters for feature activation
-    /// @custom:error InvalidToken Thrown when token is address(0) or doesn't support IVotes
-    /// @custom:error InvalidTotalSupply Thrown when token total supply is 0
-    /// @custom:error InvalidThreshold Thrown when threshold exceeds total supply
-    function setFeatureCondition(
-        Layout storage self,
-        bytes32 featureId,
-        FeatureCondition calldata condition
-    ) internal {
-        if (condition.token == address(0)) {
-            CustomRevert.revertWith(IFeatureManagerFacetBase.InvalidToken.selector);
-        }
-
-        _validateGetVotes(condition);
-
-        // Check totalSupply directly
-        try IERC20(condition.token).totalSupply() returns (uint256 totalSupply) {
-            if (totalSupply == 0) {
-                CustomRevert.revertWith(IFeatureManagerFacetBase.InvalidTotalSupply.selector);
-            }
-
-            if (condition.threshold > totalSupply) {
-                CustomRevert.revertWith(IFeatureManagerFacetBase.InvalidThreshold.selector);
-            }
-        } catch {
-            CustomRevert.revertWith(IFeatureManagerFacetBase.InvalidToken.selector);
-        }
-
-        self.featureIds.add(featureId);
-        self.conditions[featureId] = condition;
-    }
-
-    /// @notice Retrieves the condition for a specific feature
-    /// @dev Returns the complete condition struct with all parameters
-    /// @param self The storage layout pointer
-    /// @param featureId The unique identifier for the feature
-    /// @return Condition memory The complete condition configuration for the feature
-    function getFeatureCondition(
-        Layout storage self,
-        bytes32 featureId
-    ) internal view returns (FeatureCondition memory) {
-        return self.conditions[featureId];
-    }
-
-    /// @notice Retrieves all feature conditions
-    /// @dev Returns an array of all feature conditions
-    /// @param self The storage layout pointer
-    /// @return Condition[] An array of all feature conditions
-    function getFeatureConditions(
-        Layout storage self
-    ) internal view returns (FeatureCondition[] memory) {
-        uint256 featureCount = self.featureIds.length();
-
-        FeatureCondition[] memory conditions = new FeatureCondition[](featureCount);
-        for (uint256 i; i < featureCount; ++i) {
-            conditions[i] = self.conditions[self.featureIds.at(i)];
-        }
-        return conditions;
-    }
-
-    /// @notice Retrieves all feature conditions for a specific space
-    /// @dev Returns an array of all feature conditions that are active for the space
-    /// @param self The storage layout pointer
-    /// @param space The address of the space to check conditions for
-    /// @return Condition[] An array of all feature conditions that are active for the space
-    function getFeatureConditionsForSpace(
-        Layout storage self,
-        address space
-    ) internal view returns (FeatureCondition[] memory) {
-        uint256 featureCount = self.featureIds.length();
-
-        FeatureCondition[] memory conditions = new FeatureCondition[](featureCount);
-        uint256 index;
-
-        for (uint256 i; i < featureCount; ++i) {
-            FeatureCondition storage condition = self.conditions[self.featureIds.at(i)];
-            uint256 votes = condition.getVotes(space);
-
-            if (condition.meetsThreshold(votes)) {
-                conditions[index++] = condition;
-            }
-        }
-
-        assembly ("memory-safe") {
-            mstore(conditions, index)
-        }
-
-        return conditions;
-    }
-
-    /// @notice Disables a feature by setting its active flag to false
-    /// @dev This does not delete the condition, only deactivates it
-    /// @param self The storage layout pointer
-    /// @param featureId The unique identifier for the feature to disable
-    function disableFeatureCondition(Layout storage self, bytes32 featureId) internal {
-        FeatureCondition storage condition = self.conditions[featureId];
-        if (!condition.active) {
-            CustomRevert.revertWith(IFeatureManagerFacetBase.FeatureNotActive.selector);
-        }
-        condition.active = false;
-    }
-
-    function _validateGetVotes(FeatureCondition calldata condition) internal view {
-        // Check IVotes support by attempting to call getVotes
-        try IVotes(condition.token).getVotes(address(this)) returns (uint256) {
-            // If we get here, getVotes is supported
-            return;
-        } catch {
-            CustomRevert.revertWith(IFeatureManagerFacetBase.InvalidInterface.selector);
-        }
-    }
-
-    /// @notice Retrieves the layout for the FeatureManager at the default storage slot
-    /// @dev This is accessed by the facet contract
-    /// @return $ The layout storage pointer
-    function getLayout() internal pure returns (Layout storage $) {
-        return getLayout(DEFAULT_STORAGE_SLOT);
-    }
-
-    /// @notice Retrieves the layout for the FeatureManager at a custom storage slot
-    /// @dev This function is used to access the storage layout for a given slot
-    /// @param slot The storage slot to retrieve the layout for
-    /// @return $ The layout storage pointer
-    function getLayout(bytes32 slot) internal pure returns (Layout storage $) {
-        assembly {
-            $.slot := slot
-        }
-    }
-}