@towns-protocol/contracts 0.0.302

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

@@ -0,0 +1,168 @@
+// 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
+        }
+    }
+}

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

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+import {FeatureCondition} from "./FeatureConditionLib.sol";
+
+// contracts
+
+/// @title IFeatureManagerFacetBase
+/// @notice Base interface for the FeatureManager facet defining errors and events
+/// @dev Used by the FeatureManager facet and any other facets that need to access feature conditions
+interface IFeatureManagerFacetBase {
+    /// @notice Error thrown when a threshold exceeds the token's total supply
+    error InvalidThreshold();
+
+    /// @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)
+    error InvalidToken();
+
+    /// @notice Error thrown when an invalid token interface is provided
+    error InvalidInterface();
+
+    /// @notice Error thrown when a feature condition is not active
+    error FeatureNotActive();
+
+    /// @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
+    event FeatureConditionSet(bytes32 indexed featureId, FeatureCondition condition);
+
+    /// @notice Emitted when a feature condition is disabled
+    /// @param featureId The unique identifier for the feature whose condition was disabled
+    event FeatureConditionDisabled(bytes32 indexed featureId);
+}
+
+interface IFeatureManagerFacet is IFeatureManagerFacetBase {
+    /// @notice Sets 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 setFeatureCondition(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
+    function getFeatureCondition(bytes32 featureId) external view returns (FeatureCondition memory);
+
+    /// @notice Retrieves all feature conditions
+    /// @return An array of all feature conditions
+    function getFeatureConditions() external view returns (FeatureCondition[] memory);
+
+    /// @notice Retrieves all feature conditions for a specific space
+    /// @param space The address of the space to check conditions for
+    /// @return An array of all feature conditions that are active for the space
+    function getFeatureConditionsForSpace(
+        address space
+    ) external view returns (FeatureCondition[] memory);
+
+    /// @notice Disables a feature condition
+    /// @param featureId The unique identifier for the feature
+    /// @dev Only callable by the contract owner
+    function disableFeatureCondition(bytes32 featureId) external;
+
+    /// @notice Checks if a space meets the condition for a feature
+    /// @param featureId The unique identifier for the feature
+    /// @param space The address of the space to check
+    /// @return True if the space meets the threshold for the feature, false otherwise
+    function checkFeatureCondition(bytes32 featureId, address space) external view returns (bool);
+}

package/src/factory/facets/partner/IPartnerRegistry.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface IPartnerRegistryBase {
+    struct Partner {
+        address account;
+        address recipient;
+        uint256 fee;
+        bool active;
+    }
+
+    // Errors
+    error PartnerRegistry__PartnerAlreadyRegistered(address account);
+    error PartnerRegistry__RegistryFeeNotPaid(uint256 fee);
+    error PartnerRegistry__PartnerNotRegistered(address account);
+    error PartnerRegistry__NotPartnerAccount(address account);
+    error PartnerRegistry__PartnerNotActive(address account);
+    error PartnerRegistry__InvalidPartnerFee(uint256 fee);
+    error PartnerRegistry__InvalidRecipient();
+
+    // Events
+    event PartnerRegistered(address indexed account);
+    event PartnerUpdated(address indexed account);
+    event PartnerRemoved(address indexed account);
+    event MaxPartnerFeeSet(uint256 fee);
+    event RegistryFeeSet(uint256 fee);
+}
+
+interface IPartnerRegistry is IPartnerRegistryBase {
+    function registerPartner(Partner memory partner) external payable;
+
+    function partnerInfo(address account) external view returns (Partner memory);
+
+    function partnerFee(address account) external view returns (uint256 fee);
+
+    function updatePartner(Partner memory partner) external;
+
+    function removePartner(address account) external;
+
+    // =============================================================
+    //                           Admin
+    // =============================================================
+    function maxPartnerFee() external view returns (uint256 fee);
+
+    function setMaxPartnerFee(uint256 fee) external;
+
+    function registryFee() external view returns (uint256 fee);
+
+    function setRegistryFee(uint256 fee) external;
+}

package/src/factory/facets/partner/PartnerRegistry.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IPartnerRegistry} from "./IPartnerRegistry.sol";
+
+// libraries
+
+// contracts
+import {PartnerRegistryBase} from "./PartnerRegistryBase.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+
+contract PartnerRegistry is PartnerRegistryBase, OwnableBase, IPartnerRegistry, Facet {
+    function __PartnerRegistry_init() external onlyInitializing {
+        _addInterface(type(IPartnerRegistry).interfaceId);
+    }
+
+    function registerPartner(Partner calldata partner) external payable {
+        _registerPartner(partner);
+    }
+
+    function partnerInfo(address account) external view returns (Partner memory) {
+        return _partner(account);
+    }
+
+    function partnerFee(address account) external view returns (uint256 fee) {
+        return _partnerFee(account);
+    }
+
+    function updatePartner(Partner calldata partner) external {
+        _updatePartner(partner);
+    }
+
+    function removePartner(address account) external onlyOwner {
+        _removePartner(account);
+    }
+
+    // =============================================================
+    //                           ADMIN
+    // =============================================================
+    function maxPartnerFee() external view returns (uint256 fee) {
+        return _maxPartnerFee();
+    }
+
+    function setMaxPartnerFee(uint256 fee) external onlyOwner {
+        _setMaxPartnerFee(fee);
+    }
+
+    function registryFee() external view returns (uint256 fee) {
+        return _registryFee();
+    }
+
+    function setRegistryFee(uint256 fee) external onlyOwner {
+        _setRegistryFee(fee);
+    }
+}

package/src/factory/facets/partner/PartnerRegistryBase.sol

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IPartnerRegistryBase} from "./IPartnerRegistry.sol";
+
+// libraries
+
+import {PartnerRegistryStorage} from "./PartnerRegistryStorage.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+// contracts
+
+abstract contract PartnerRegistryBase is IPartnerRegistryBase {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    function __PartnerRegistryBase_init(uint256 registryFee, uint256 maxPartnerFee) internal {
+        PartnerRegistryStorage.Layout storage ds = PartnerRegistryStorage.layout();
+
+        ds.partnerSettings = PartnerRegistryStorage.PartnerSettings({
+            registryFee: registryFee,
+            maxPartnerFee: maxPartnerFee
+        });
+    }
+
+    function _registerPartner(Partner memory partner) internal {
+        PartnerRegistryStorage.Layout storage ds = PartnerRegistryStorage.layout();
+
+        PartnerRegistryStorage.PartnerSettings memory settings = ds.partnerSettings;
+
+        if (msg.value != settings.registryFee) {
+            revert PartnerRegistry__RegistryFeeNotPaid(settings.registryFee);
+        }
+
+        if (partner.fee > settings.maxPartnerFee) {
+            revert PartnerRegistry__InvalidPartnerFee(partner.fee);
+        }
+
+        if (!ds.partners.add(partner.account)) {
+            revert PartnerRegistry__PartnerAlreadyRegistered(partner.account);
+        }
+
+        ds.partnerByAccount[partner.account] = PartnerRegistryStorage.Partner({
+            recipient: partner.recipient,
+            fee: partner.fee,
+            createdAt: block.timestamp,
+            active: partner.active
+        });
+
+        emit PartnerRegistered(partner.account);
+    }
+
+    function _updatePartner(Partner memory partner) internal {
+        if (partner.account != msg.sender) {
+            revert PartnerRegistry__NotPartnerAccount(msg.sender);
+        }
+
+        if (partner.recipient == address(0)) {
+            revert PartnerRegistry__InvalidRecipient();
+        }
+
+        PartnerRegistryStorage.Layout storage ds = PartnerRegistryStorage.layout();
+
+        if (!ds.partners.contains(partner.account)) {
+            revert PartnerRegistry__PartnerNotRegistered(partner.account);
+        }
+
+        PartnerRegistryStorage.PartnerSettings memory settings = ds.partnerSettings;
+
+        if (partner.fee > settings.maxPartnerFee) {
+            revert PartnerRegistry__InvalidPartnerFee(partner.fee);
+        }
+
+        ds.partnerByAccount[partner.account].recipient = partner.recipient;
+        ds.partnerByAccount[partner.account].fee = partner.fee;
+        ds.partnerByAccount[partner.account].active = partner.active;
+
+        emit PartnerUpdated(partner.account);
+    }
+
+    function _removePartner(address account) internal {
+        PartnerRegistryStorage.Layout storage ds = PartnerRegistryStorage.layout();
+
+        if (!ds.partners.remove(account)) {
+            revert PartnerRegistry__PartnerNotRegistered(account);
+        }
+
+        delete ds.partnerByAccount[account];
+
+        emit PartnerRemoved(account);
+    }
+
+    function _partner(address account) internal view returns (Partner memory partner) {
+        PartnerRegistryStorage.Layout storage ds = PartnerRegistryStorage.layout();
+
+        partner = Partner({
+            account: account,
+            recipient: ds.partnerByAccount[account].recipient,
+            fee: ds.partnerByAccount[account].fee,
+            active: ds.partnerByAccount[account].active
+        });
+    }
+
+    function _partnerFee(address account) internal view returns (uint256 fee) {
+        PartnerRegistryStorage.Layout storage ds = PartnerRegistryStorage.layout();
+        fee = ds.partnerByAccount[account].fee;
+    }
+
+    function _maxPartnerFee() internal view returns (uint256 fee) {
+        PartnerRegistryStorage.Layout storage ds = PartnerRegistryStorage.layout();
+        fee = ds.partnerSettings.maxPartnerFee;
+    }
+
+    function _setMaxPartnerFee(uint256 fee) internal {
+        PartnerRegistryStorage.Layout storage ds = PartnerRegistryStorage.layout();
+        ds.partnerSettings.maxPartnerFee = fee;
+
+        emit MaxPartnerFeeSet(fee);
+    }
+
+    function _registryFee() internal view returns (uint256 fee) {
+        PartnerRegistryStorage.Layout storage ds = PartnerRegistryStorage.layout();
+        fee = ds.partnerSettings.registryFee;
+    }
+
+    function _setRegistryFee(uint256 fee) internal {
+        PartnerRegistryStorage.Layout storage ds = PartnerRegistryStorage.layout();
+        ds.partnerSettings.registryFee = fee;
+
+        emit RegistryFeeSet(fee);
+    }
+}

package/src/factory/facets/partner/PartnerRegistryStorage.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+// contracts
+
+library PartnerRegistryStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.partner.registry.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x7b5ecdde71ed61c776cb15819e7e4ea6887ef4293a4dfb12ecb38ffd92c3f400;
+
+    struct Partner {
+        address recipient;
+        uint256 fee; // fee in basis points
+        uint256 createdAt;
+        bool active;
+    }
+
+    struct PartnerSettings {
+        uint256 registryFee; // fee in ether
+        uint256 maxPartnerFee; // fee in basis points
+    }
+
+    struct Layout {
+        EnumerableSet.AddressSet partners;
+        PartnerSettings partnerSettings;
+        mapping(address account => Partner) partnerByAccount;
+    }
+
+    function layout() internal pure returns (Layout storage ds) {
+        assembly {
+            ds.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/factory/facets/platform/requirements/IPlatformRequirements.sol

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface IPlatformRequirementsBase {
+    // Errors
+    error Platform__InvalidFeeRecipient();
+    error Platform__InvalidMembershipBps();
+    error Platform__InvalidMembershipMintLimit();
+    error Platform__InvalidMembershipDuration();
+    error Platform__InvalidMembershipMinPrice();
+    error Platform__InvalidSwapFeeBps();
+
+    // Events
+    event PlatformFeeRecipientSet(address indexed recipient);
+    event PlatformMembershipBpsSet(uint16 bps);
+    event PlatformMembershipFeeSet(uint256 fee);
+    event PlatformMembershipMintLimitSet(uint256 limit);
+    event PlatformMembershipDurationSet(uint256 duration);
+    event PlatformMembershipMinPriceSet(uint256 minPrice);
+    event PlatformSwapFeesSet(uint16 protocolBps, uint16 posterBps);
+    event RouterWhitelistUpdated(address indexed router, bool whitelisted);
+}
+
+interface IPlatformRequirements is IPlatformRequirementsBase {
+    /**
+     * @notice Set the fee recipient address
+     * @dev This is the address that will receive the platform fees
+     * @param recipient The address of the fee recipient
+     */
+    function setFeeRecipient(address recipient) external;
+
+    /**
+     * @notice Get the fee recipient address
+     * @return The address of the fee recipient
+     */
+    function getFeeRecipient() external view returns (address);
+
+    /**
+     * @notice Set the membership basis points
+     * @param bps The membership basis points
+     */
+    function setMembershipBps(uint16 bps) external;
+
+    /**
+     * @notice Get the membership basis points
+     * @dev This is the basis points that will be charged for a membership
+     * @return The membership basis points
+     */
+    function getMembershipBps() external view returns (uint16);
+
+    /**
+     * @notice Set the membership flat fee
+     * @param fee The membership fee
+     */
+    function setMembershipFee(uint256 fee) external;
+
+    /**
+     * @notice Get the membership flat fee
+     * @dev This is the flat fee that will be charged for a membership
+     * @return The membership fee
+     */
+    function getMembershipFee() external view returns (uint256);
+
+    /**
+     * @notice Set the membership mint limit
+     * @param limit The membership mint limit
+     */
+    function setMembershipMintLimit(uint256 limit) external;
+
+    /**
+     * @notice Get the membership mint limit
+     * @dev This is the maximum number of free memberships that can be minted per space
+     * @return The membership mint limit
+     */
+    function getMembershipMintLimit() external view returns (uint256);
+
+    /**
+     * @notice Set the membership duration
+     * @param duration The membership duration
+     */
+    function setMembershipDuration(uint64 duration) external;
+
+    /**
+     * @notice Get the membership duration
+     * @dev This is the duration of a membership in seconds
+     * @return The membership duration
+     */
+    function getMembershipDuration() external view returns (uint64);
+
+    /**
+     * @notice Get the minimum price for a membership
+     * @dev This is the minimum price that can be set for a membership
+     * @return The minimum price for a membership
+     */
+    function getMembershipMinPrice() external view returns (uint256);
+
+    /**
+     * @notice Set the minimum price for a membership
+     * @param minPrice The minimum price for a membership
+     */
+    function setMembershipMinPrice(uint256 minPrice) external;
+
+    /**
+     * @notice Get the denominator
+     * @dev This is the denominator used for calculating fees
+     * @return The denominator
+     */
+    function getDenominator() external pure returns (uint256);
+
+    /**
+     * @notice Get the swap fees in basis points
+     * @return protocolBps Basis points for protocol fee
+     * @return posterBps Basis points for poster fee
+     */
+    function getSwapFees() external view returns (uint16 protocolBps, uint16 posterBps);
+
+    /**
+     * @notice Set the swap fees in basis points
+     * @param protocolBps Basis points for protocol fee
+     * @param posterBps Basis points for poster fee
+     */
+    function setSwapFees(uint16 protocolBps, uint16 posterBps) external;
+
+    /**
+     * @notice Check if a router is whitelisted
+     * @param router Address of the router to check
+     * @return bool True if router is whitelisted
+     */
+    function isRouterWhitelisted(address router) external view returns (bool);
+
+    /**
+     * @notice Add or remove a router from whitelist
+     * @param router Address of the router
+     * @param whitelisted True to whitelist, false to remove
+     */
+    function setRouterWhitelisted(address router, bool whitelisted) external;
+}