@towns-protocol/contracts 0.0.302

package/src/factory/facets/architect/Architect.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IArchitect} from "src/factory/facets/architect/IArchitect.sol";
+import {IRuleEntitlement} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
+import {IRuleEntitlementV2} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
+
+import {IUserEntitlement} from "src/spaces/entitlements/user/IUserEntitlement.sol";
+import {ISpaceOwner} from "src/spaces/facets/owner/ISpaceOwner.sol";
+import {ISpaceProxyInitializer} from "src/spaces/facets/proxy/ISpaceProxyInitializer.sol";
+
+// libraries
+
+// contracts
+import {ArchitectBase} from "./ArchitectBase.sol";
+
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {PausableBase} from "@towns-protocol/diamond/src/facets/pausable/PausableBase.sol";
+import {ReentrancyGuard} from "solady/utils/ReentrancyGuard.sol";
+
+contract Architect is IArchitect, ArchitectBase, OwnableBase, PausableBase, ReentrancyGuard, Facet {
+    function __Architect_init(
+        ISpaceOwner ownerImplementation,
+        IUserEntitlement userEntitlementImplementation,
+        IRuleEntitlementV2 ruleEntitlementImplementation,
+        IRuleEntitlement legacyRuleEntitlement
+    ) external onlyInitializing {
+        _setImplementations(
+            ownerImplementation,
+            userEntitlementImplementation,
+            ruleEntitlementImplementation,
+            legacyRuleEntitlement
+        );
+    }
+
+    // =============================================================
+    //                            Space
+    // =============================================================
+
+    /// @inheritdoc IArchitect
+    function getSpaceByTokenId(uint256 tokenId) external view returns (address) {
+        return _getSpaceByTokenId(tokenId);
+    }
+
+    /// @inheritdoc IArchitect
+    function getTokenIdBySpace(address space) external view returns (uint256) {
+        return _getTokenIdBySpace(space);
+    }
+
+    // =============================================================
+    //                         Implementations
+    // =============================================================
+
+    /// @inheritdoc IArchitect
+    function setSpaceArchitectImplementations(
+        ISpaceOwner spaceToken,
+        IUserEntitlement userEntitlementImplementation,
+        IRuleEntitlementV2 ruleEntitlementImplementation,
+        IRuleEntitlement legacyRuleEntitlement
+    ) external onlyOwner {
+        _setImplementations(
+            spaceToken,
+            userEntitlementImplementation,
+            ruleEntitlementImplementation,
+            legacyRuleEntitlement
+        );
+    }
+
+    /// @inheritdoc IArchitect
+    function getSpaceArchitectImplementations()
+        external
+        view
+        returns (
+            ISpaceOwner spaceToken,
+            IUserEntitlement userEntitlementImplementation,
+            IRuleEntitlementV2 ruleEntitlementImplementation,
+            IRuleEntitlement legacyRuleEntitlement
+        )
+    {
+        return _getImplementations();
+    }
+
+    // =============================================================
+    //                         Proxy Initializer
+    // =============================================================
+
+    /// @inheritdoc IArchitect
+    function getProxyInitializer() external view returns (ISpaceProxyInitializer) {
+        return _getProxyInitializer();
+    }
+
+    /// @inheritdoc IArchitect
+    function setProxyInitializer(ISpaceProxyInitializer proxyInitializer) external onlyOwner {
+        _setProxyInitializer(proxyInitializer);
+    }
+}

package/src/factory/facets/architect/ArchitectBase.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IArchitectBase} from "./IArchitect.sol";
+
+import {IRuleEntitlement} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
+import {IRuleEntitlementV2} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
+import {IUserEntitlement} from "src/spaces/entitlements/user/IUserEntitlement.sol";
+import {ISpaceOwner} from "src/spaces/facets/owner/ISpaceOwner.sol";
+import {ISpaceProxyInitializer} from "src/spaces/facets/proxy/ISpaceProxyInitializer.sol";
+
+// libraries
+
+import {ArchitectStorage} from "./ArchitectStorage.sol";
+import {ImplementationStorage} from "./ImplementationStorage.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+// contracts
+
+// modules
+
+abstract contract ArchitectBase is IArchitectBase {
+    // =============================================================
+    //                           Spaces
+    // =============================================================
+    function _getTokenIdBySpace(address space) internal view returns (uint256) {
+        return ArchitectStorage.layout().tokenIdBySpace[space];
+    }
+
+    function _getSpaceByTokenId(uint256 tokenId) internal view returns (address) {
+        return ArchitectStorage.layout().spaceByTokenId[tokenId];
+    }
+
+    // =============================================================
+    //                           Implementations
+    // =============================================================
+
+    function _setImplementations(
+        ISpaceOwner spaceOwnerToken,
+        IUserEntitlement userEntitlement,
+        IRuleEntitlementV2 ruleEntitlement,
+        IRuleEntitlement legacyRuleEntitlement
+    ) internal {
+        if (address(spaceOwnerToken).code.length == 0) {
+            revert Architect__NotContract();
+        }
+        if (address(userEntitlement).code.length == 0) {
+            revert Architect__NotContract();
+        }
+        if (address(ruleEntitlement).code.length == 0) {
+            revert Architect__NotContract();
+        }
+
+        ImplementationStorage.Layout storage ds = ImplementationStorage.layout();
+        ds.spaceOwnerToken = spaceOwnerToken;
+        ds.userEntitlement = userEntitlement;
+        ds.ruleEntitlement = ruleEntitlement;
+        ds.legacyRuleEntitlement = legacyRuleEntitlement;
+    }
+
+    function _getImplementations()
+        internal
+        view
+        returns (
+            ISpaceOwner spaceOwnerToken,
+            IUserEntitlement userEntitlementImplementation,
+            IRuleEntitlementV2 ruleEntitlementImplementation,
+            IRuleEntitlement legacyRuleEntitlement
+        )
+    {
+        ImplementationStorage.Layout storage ds = ImplementationStorage.layout();
+
+        return (
+            ds.spaceOwnerToken,
+            ds.userEntitlement,
+            ds.ruleEntitlement,
+            ds.legacyRuleEntitlement
+        );
+    }
+
+    // =============================================================
+    //                         Proxy Initializer
+    // =============================================================
+    function _getProxyInitializer() internal view returns (ISpaceProxyInitializer) {
+        return ImplementationStorage.layout().proxyInitializer;
+    }
+
+    function _setProxyInitializer(ISpaceProxyInitializer proxyInitializer) internal {
+        ImplementationStorage.Layout storage ds = ImplementationStorage.layout();
+        ds.proxyInitializer = proxyInitializer;
+
+        emit Architect__ProxyInitializerSet(address(proxyInitializer));
+    }
+}

package/src/factory/facets/architect/ArchitectStorage.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// contracts
+
+library ArchitectStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.architect.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant SLOT_POSITION =
+        0x06bd04a817647c31ee485c8a0baab96facd62dbfd4b475796bb17ca2c12f0000;
+
+    struct Layout {
+        uint256 spaceCount;
+        mapping(address spaceAddress => uint256 tokenId) tokenIdBySpace;
+        mapping(uint256 tokenId => address spaceAddress) spaceByTokenId;
+    }
+
+    function layout() internal pure returns (Layout storage ds) {
+        bytes32 position = SLOT_POSITION;
+
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            ds.slot := position
+        }
+    }
+}

package/src/factory/facets/architect/IArchitect.sol

@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+import {IRuleEntitlement} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
+import {IRuleEntitlementV2} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
+import {IUserEntitlement} from "src/spaces/entitlements/user/IUserEntitlement.sol";
+import {IMembershipBase} from "src/spaces/facets/membership/IMembership.sol";
+
+import {ISpaceOwner} from "src/spaces/facets/owner/ISpaceOwner.sol";
+import {ISpaceProxyInitializer} from "src/spaces/facets/proxy/ISpaceProxyInitializer.sol";
+
+// contracts
+interface IArchitectBase {
+    // =============================================================
+    //                           STRUCTS
+    // =============================================================
+
+    struct MembershipRequirementsOld {
+        bool everyone;
+        address[] users;
+        bytes ruleData;
+    }
+
+    struct MembershipOld {
+        IMembershipBase.Membership settings;
+        MembershipRequirementsOld requirements;
+        string[] permissions;
+    }
+
+    struct CreateSpaceOld {
+        Metadata metadata;
+        MembershipOld membership;
+        ChannelInfo channel;
+        Prepay prepay;
+    }
+
+    struct SpaceInfo {
+        string name;
+        string uri;
+        string shortDescription;
+        string longDescription;
+        Membership membership;
+        ChannelInfo channel;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           CreateSpace                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    struct MembershipRequirements {
+        bool everyone;
+        address[] users;
+        bytes ruleData;
+        bool syncEntitlements;
+    }
+
+    struct Metadata {
+        string name;
+        string uri;
+        string shortDescription;
+        string longDescription;
+    }
+
+    struct Membership {
+        IMembershipBase.Membership settings;
+        MembershipRequirements requirements;
+        string[] permissions;
+    }
+
+    struct ChannelInfo {
+        string metadata;
+    }
+
+    struct Prepay {
+        uint256 supply;
+    }
+
+    struct CreateSpace {
+        Metadata metadata;
+        Membership membership;
+        ChannelInfo channel;
+        Prepay prepay;
+    }
+    /**
+     * @notice Options for creating a space
+     * @param to Address that will receive the space NFT (defaults to msg.sender if not specified)
+     */
+
+    struct SpaceOptions {
+        address to;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Events                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    event SpaceCreated(address indexed owner, uint256 indexed tokenId, address indexed space);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Errors                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    error Architect__InvalidStringLength();
+    error Architect__InvalidNetworkId();
+    error Architect__InvalidAddress();
+    error Architect__NotContract();
+    error Architect__InvalidPricingModule();
+
+    event Architect__ProxyInitializerSet(address indexed proxyInitializer);
+}
+
+interface IArchitect is IArchitectBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Registry                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    function getSpaceByTokenId(uint256 tokenId) external view returns (address space);
+
+    function getTokenIdBySpace(address space) external view returns (uint256);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Implementations                  */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function setSpaceArchitectImplementations(
+        ISpaceOwner ownerTokenImplementation,
+        IUserEntitlement userEntitlementImplementation,
+        IRuleEntitlementV2 ruleEntitlementImplementation,
+        IRuleEntitlement legacyRuleEntitlement
+    ) external;
+
+    function getSpaceArchitectImplementations()
+        external
+        view
+        returns (
+            ISpaceOwner ownerTokenImplementation,
+            IUserEntitlement userEntitlementImplementation,
+            IRuleEntitlementV2 ruleEntitlementImplementation,
+            IRuleEntitlement legacyRuleEntitlement
+        );
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Proxy Initializer                */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    /// @notice Retrieves the current proxy initializer
+    /// @return The address of the current ISpaceProxyInitializer contract
+    function getProxyInitializer() external view returns (ISpaceProxyInitializer);
+
+    /// @notice Sets a new proxy initializer
+    /// @param proxyInitializer The address of the new ISpaceProxyInitializer contract to be set
+    /// @dev This function should only be callable by the contract owner or authorized roles
+    function setProxyInitializer(ISpaceProxyInitializer proxyInitializer) external;
+}

package/src/factory/facets/architect/ImplementationStorage.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+import {IEntitlementChecker} from "src/base/registry/facets/checker/IEntitlementChecker.sol";
+import {IWalletLink} from "src/factory/facets/wallet-link/IWalletLink.sol";
+import {IRuleEntitlement} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
+import {IRuleEntitlementV2} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
+import {IUserEntitlement} from "src/spaces/entitlements/user/IUserEntitlement.sol";
+import {ISpaceOwner} from "src/spaces/facets/owner/ISpaceOwner.sol";
+import {ISpaceProxyInitializer} from "src/spaces/facets/proxy/ISpaceProxyInitializer.sol";
+// libraries
+
+// contracts
+
+library ImplementationStorage {
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.architect.implementation.storage")) -
+    // 1))
+    // & ~bytes32(uint256(0xff))
+    bytes32 internal constant SLOT_POSITION =
+        0x9e34afa7b4d27d347d25d9d9dab4f1a106fa081382e6c4243e834d093e787d00;
+
+    struct Layout {
+        ISpaceOwner spaceOwnerToken;
+        IUserEntitlement userEntitlement;
+        IRuleEntitlementV2 ruleEntitlement;
+        IWalletLink walletLink;
+        IEntitlementChecker entitlementChecker;
+        IRuleEntitlement legacyRuleEntitlement;
+        ISpaceProxyInitializer proxyInitializer;
+    }
+
+    function layout() internal pure returns (Layout storage ds) {
+        bytes32 position = SLOT_POSITION;
+
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            ds.slot := position
+        }
+    }
+}

package/src/factory/facets/architect/pricing/IPricingModules.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface IPricingModulesBase {
+    // =============================================================
+    //                           Structs
+    // =============================================================
+    struct PricingModule {
+        string name;
+        string description;
+        address module;
+    }
+
+    // =============================================================
+    //                           Errors
+    // =============================================================
+    error InvalidPricingModule(address module);
+
+    // =============================================================
+    //                           Events
+    // =============================================================
+    event PricingModuleAdded(address indexed module);
+    event PricingModuleUpdated(address indexed module);
+    event PricingModuleRemoved(address indexed module);
+}
+
+interface IPricingModules is IPricingModulesBase {
+    function isPricingModule(address module) external view returns (bool);
+
+    function addPricingModule(address module) external;
+
+    function removePricingModule(address module) external;
+
+    function listPricingModules() external view returns (PricingModule[] memory);
+}

package/src/factory/facets/architect/pricing/PricingModulesBase.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+import {IPricingModulesBase} from "./IPricingModules.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IMembershipPricing} from "src/spaces/facets/membership/pricing/IMembershipPricing.sol";
+
+// libraries
+import {PricingModulesStorage} from "./PricingModulesStorage.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+
+// contracts
+
+library PricingModulesBase {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    function isPricingModule(address module) internal view returns (bool) {
+        PricingModulesStorage.Layout storage ds = PricingModulesStorage.layout();
+        return ds.pricingModules.contains(module);
+    }
+
+    function addPricingModule(address module) internal {
+        PricingModulesStorage.Layout storage ds = PricingModulesStorage.layout();
+
+        if (module == address(0)) {
+            CustomRevert.revertWith(IPricingModulesBase.InvalidPricingModule.selector, module);
+        }
+
+        if (!verifyInterface(module)) {
+            CustomRevert.revertWith(IPricingModulesBase.InvalidPricingModule.selector, module);
+        }
+
+        if (ds.pricingModules.contains(module)) {
+            CustomRevert.revertWith(IPricingModulesBase.InvalidPricingModule.selector, module);
+        }
+
+        ds.pricingModules.add(module);
+
+        emit IPricingModulesBase.PricingModuleAdded(module);
+    }
+
+    function removePricingModule(address module) internal {
+        PricingModulesStorage.Layout storage ds = PricingModulesStorage.layout();
+
+        if (module == address(0)) {
+            CustomRevert.revertWith(IPricingModulesBase.InvalidPricingModule.selector, module);
+        }
+
+        // verify module exists
+        if (!ds.pricingModules.contains(module)) {
+            CustomRevert.revertWith(IPricingModulesBase.InvalidPricingModule.selector, module);
+        }
+
+        ds.pricingModules.remove(module);
+
+        emit IPricingModulesBase.PricingModuleRemoved(module);
+    }
+
+    function listPricingModules()
+        internal
+        view
+        returns (IPricingModulesBase.PricingModule[] memory)
+    {
+        PricingModulesStorage.Layout storage ds = PricingModulesStorage.layout();
+        uint256 length = ds.pricingModules.length();
+        IPricingModulesBase.PricingModule[]
+            memory pricingModules = new IPricingModulesBase.PricingModule[](length);
+        for (uint256 i = 0; i < length; i++) {
+            address moduleAddress = ds.pricingModules.at(i);
+            IMembershipPricing module = IMembershipPricing(moduleAddress);
+            pricingModules[i] = IPricingModulesBase.PricingModule({
+                name: module.name(),
+                description: module.description(),
+                module: moduleAddress
+            });
+        }
+        return pricingModules;
+    }
+
+    // =============================================================
+    //                           Internal
+    // =============================================================
+    function verifyInterface(address module) internal view returns (bool) {
+        return IERC165(module).supportsInterface(type(IMembershipPricing).interfaceId);
+    }
+}

package/src/factory/facets/architect/pricing/PricingModulesFacet.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IPricingModules} from "./IPricingModules.sol";
+
+// contracts
+
+import {PricingModulesBase} from "./PricingModulesBase.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+
+contract PricingModulesFacet is IPricingModules, OwnableBase, Facet {
+    function __PricingModulesFacet_init(address[] memory pricingModules) external onlyInitializing {
+        __PricingModulesFacet_init_unchained(pricingModules);
+    }
+
+    function __PricingModulesFacet_init_unchained(address[] memory pricingModules) internal {
+        _addInterface(type(IPricingModules).interfaceId);
+        for (uint256 i = 0; i < pricingModules.length; i++) {
+            PricingModulesBase.addPricingModule(pricingModules[i]);
+        }
+    }
+
+    function addPricingModule(address pricingModule) external onlyOwner {
+        PricingModulesBase.addPricingModule(pricingModule);
+    }
+
+    function isPricingModule(address module) external view returns (bool) {
+        return PricingModulesBase.isPricingModule(module);
+    }
+
+    function removePricingModule(address module) external onlyOwner {
+        PricingModulesBase.removePricingModule(module);
+    }
+
+    function listPricingModules() external view returns (PricingModule[] memory) {
+        return PricingModulesBase.listPricingModules();
+    }
+}

package/src/factory/facets/architect/pricing/PricingModulesStorage.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+// contracts
+
+library PricingModulesStorage {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.architect.pricing.module.storage")) -
+    // 1))
+    // & ~bytes32(uint256(0xff))
+    bytes32 internal constant SLOT_POSITION =
+        0x6438323c68a77f029335e6433efb7c07e7cd1775df0c27e75bcd3591a8bc5d00;
+
+    struct Layout {
+        // The set of all pricing modules
+        EnumerableSet.AddressSet pricingModules;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := SLOT_POSITION
+        }
+    }
+}