@towns-protocol/contracts 0.0.302

package/src/spaces/entitlements/user/UserEntitlement.sol

@@ -0,0 +1,273 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IEntitlement} from "../IEntitlement.sol";
+
+import {IChannel} from "src/spaces/facets/channels/IChannel.sol";
+import {IRoles} from "src/spaces/facets/roles/IRoles.sol";
+
+// libraries
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+// contracts
+
+import {IUserEntitlement} from "./IUserEntitlement.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {ContextUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
+import {ERC165Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
+
+contract UserEntitlement is
+    Initializable,
+    ERC165Upgradeable,
+    ContextUpgradeable,
+    UUPSUpgradeable,
+    IUserEntitlement
+{
+    using EnumerableSet for EnumerableSet.UintSet;
+
+    address constant EVERYONE_ADDRESS = address(1);
+    address public SPACE_ADDRESS;
+
+    struct Entitlement {
+        address grantedBy;
+        uint256 grantedTime;
+        address[] users;
+    }
+
+    /// @notice mapping holding all the entitlements by RoleId added to Entitlement
+    mapping(uint256 => Entitlement) internal entitlementsByRoleId;
+    mapping(address => uint256[]) internal roleIdsByUser;
+    EnumerableSet.UintSet allEntitlementRoleIds;
+
+    string public constant name = "User Entitlement";
+    string public constant description = "Entitlement for users";
+    string public constant moduleType = "UserEntitlement";
+
+    modifier onlySpace() {
+        if (_msgSender() != SPACE_ADDRESS) {
+            revert Entitlement__NotAllowed();
+        }
+        _;
+    }
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(address _space) public initializer {
+        __UUPSUpgradeable_init();
+        __ERC165_init();
+        __Context_init();
+
+        SPACE_ADDRESS = _space;
+    }
+
+    /// @notice allow the contract to be upgraded while retaining state
+    /// @param newImplementation address of the new implementation
+    function _authorizeUpgrade(address newImplementation) internal override onlySpace {}
+
+    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+        return
+            interfaceId == type(IEntitlement).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    // @inheritdoc IEntitlement
+    function isCrosschain() external pure override returns (bool) {
+        return false;
+    }
+
+    // @inheritdoc IEntitlement
+    function isEntitled(
+        bytes32 channelId,
+        address[] memory wallets,
+        bytes32 permission
+    ) external view returns (bool) {
+        // Check if channelId is not equal to the zero value for bytes32
+        if (channelId != bytes32(0)) {
+            return _isEntitledToChannel(channelId, wallets, permission);
+        } else {
+            return _isEntitledToSpace(wallets, permission);
+        }
+    }
+
+    // @inheritdoc IEntitlement
+    function setEntitlement(uint256 roleId, bytes calldata entitlementData) external onlySpace {
+        address[] memory users = abi.decode(entitlementData, (address[]));
+
+        for (uint256 i = 0; i < users.length; i++) {
+            address user = users[i];
+            if (user == address(0)) {
+                revert Entitlement__InvalidValue();
+            }
+        }
+
+        // First remove any prior values
+        while (entitlementsByRoleId[roleId].users.length > 0) {
+            address user = entitlementsByRoleId[roleId].users[
+                entitlementsByRoleId[roleId].users.length - 1
+            ];
+            _removeRoleIdFromUser(user, roleId);
+            entitlementsByRoleId[roleId].users.pop();
+        }
+        delete entitlementsByRoleId[roleId];
+
+        entitlementsByRoleId[roleId] = Entitlement({
+            grantedBy: _msgSender(),
+            grantedTime: block.timestamp,
+            users: users
+        });
+        for (uint256 i = 0; i < users.length; i++) {
+            roleIdsByUser[users[i]].push(roleId);
+        }
+    }
+
+    // @inheritdoc IEntitlement
+    function removeEntitlement(uint256 roleId) external onlySpace {
+        if (entitlementsByRoleId[roleId].grantedBy == address(0)) {
+            revert Entitlement__InvalidValue();
+        }
+
+        // First remove any prior values
+        while (entitlementsByRoleId[roleId].users.length > 0) {
+            address user = entitlementsByRoleId[roleId].users[
+                entitlementsByRoleId[roleId].users.length - 1
+            ];
+            _removeRoleIdFromUser(user, roleId);
+            entitlementsByRoleId[roleId].users.pop();
+        }
+        delete entitlementsByRoleId[roleId];
+    }
+
+    // @inheritdoc IEntitlement
+    function getEntitlementDataByRoleId(uint256 roleId) external view returns (bytes memory) {
+        return abi.encode(entitlementsByRoleId[roleId].users);
+    }
+
+    /// @notice checks is a user is entitled to a specific channel
+    /// @param channelId the channel id
+    /// @param wallets the user address who we are checking for
+    /// @param permission the permission we are checking for
+    /// @return _entitled true if the user is entitled to the channel
+    function _isEntitledToChannel(
+        bytes32 channelId,
+        address[] memory wallets,
+        bytes32 permission
+    ) internal view returns (bool _entitled) {
+        IChannel.Channel memory channel = IChannel(SPACE_ADDRESS).getChannel(channelId);
+
+        // get all the roleids for the user
+        uint256[] memory rolesIds = _getRoleIdsByUser(wallets);
+
+        // loop over all role ids in a channel
+        for (uint256 i = 0; i < channel.roleIds.length; i++) {
+            // get each role id
+            uint256 roleId = channel.roleIds[i];
+
+            // loop over all the valid entitlements
+            for (uint256 j = 0; j < rolesIds.length; j++) {
+                // check if the role id for that channel matches the entitlement role id
+                // and if the permission matches the role permission
+                if (rolesIds[j] == roleId && _validateRolePermission(rolesIds[j], permission)) {
+                    _entitled = true;
+                }
+            }
+        }
+    }
+
+    /// @notice gets all the roles given to specific users
+    /// @param wallets the array of user addresses
+    /// @return roles the array of roles these users have, may include duplicates
+    function _getRoleIdsByUser(address[] memory wallets) internal view returns (uint256[] memory) {
+        uint256 totalLength = 0;
+
+        // Calculate total length
+        for (uint256 i = 0; i < wallets.length; i++) {
+            totalLength += roleIdsByUser[wallets[i]].length;
+        }
+
+        totalLength += roleIdsByUser[EVERYONE_ADDRESS].length;
+
+        // Create an array to hold all roles
+        uint256[] memory roles = new uint256[](totalLength);
+        uint256 currentIndex = 0;
+
+        // Populate the roles array
+        for (uint256 i = 0; i < wallets.length; i++) {
+            uint256[] memory rolesForWallet = roleIdsByUser[wallets[i]];
+            for (uint256 j = 0; j < rolesForWallet.length; j++) {
+                roles[currentIndex++] = rolesForWallet[j];
+            }
+        }
+
+        uint256[] memory rolesForEveryone = roleIdsByUser[EVERYONE_ADDRESS];
+        for (uint256 j = 0; j < rolesForEveryone.length; j++) {
+            roles[currentIndex++] = rolesForEveryone[j];
+        }
+
+        return roles;
+    }
+
+    /// @notice checks if a user is entitled to a specific space
+    /// @param wallets the user address
+    /// @param permission the permission we are checking for
+    /// @return _entitled true if the user is entitled to the space
+    function _isEntitledToSpace(
+        address[] memory wallets,
+        bytes32 permission
+    ) internal view returns (bool) {
+        // get all the roleids for the user
+        uint256[] memory rolesIds = _getRoleIdsByUser(wallets);
+
+        for (uint256 i = 0; i < rolesIds.length; i++) {
+            if (_validateRolePermission(rolesIds[i], permission)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// @notice checks if a role has a specific permission
+    /// @param roleId the role id
+    /// @param permission the permission we are checking for
+    /// @return _hasPermission true if the role has the permission
+    function _validateRolePermission(
+        uint256 roleId,
+        bytes32 permission
+    ) internal view returns (bool) {
+        string[] memory permissions = IRoles(SPACE_ADDRESS).getPermissionsByRoleId(roleId);
+        uint256 permissionLen = permissions.length;
+
+        for (uint256 i = 0; i < permissionLen; i++) {
+            bytes32 permissionBytes = bytes32(abi.encodePacked(permissions[i]));
+            if (permissionBytes == permission) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    function _removeRoleIdFromUser(address user, uint256 roleId) internal {
+        uint256[] storage roles = roleIdsByUser[user];
+        for (uint256 i = 0; i < roles.length; i++) {
+            if (roles[i] == roleId) {
+                roles[i] = roles[roles.length - 1];
+                roles.pop();
+                return;
+            }
+        }
+
+        // Optional: Revert if the roleId is not found
+        revert("Role ID not found for the user");
+    }
+
+    /**
+     * @dev Added to allow future versions to add new variables in case this contract becomes
+     *      inherited. See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+     */
+    uint256[49] private __gap;
+}

package/src/spaces/facets/DependencyLib.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IAppRegistry} from "../../apps/facets/registry/IAppRegistry.sol";
+import {IImplementationRegistry} from "../../factory/facets/registry/IImplementationRegistry.sol";
+
+// libraries
+import {MembershipStorage} from "./membership/MembershipStorage.sol";
+
+// contracts
+
+/// @title DependencyLib
+/// @dev Library for resolving contract dependencies via the Implementation Registry. Used for
+/// retrieving the latest implementation addresses for named dependencies within a space.
+library DependencyLib {
+    // Constants for dependency names
+    bytes32 internal constant RIVER_AIRDROP = bytes32("RiverAirdrop");
+    bytes32 internal constant SPACE_OPERATOR = bytes32("SpaceOperator"); // BaseRegistry
+    bytes32 internal constant SPACE_OWNER = bytes32("Space Owner");
+    bytes32 internal constant APP_REGISTRY = bytes32("AppRegistry");
+    bytes32 internal constant SWAP_ROUTER = bytes32("SwapRouter");
+
+    /// @notice Retrieves the latest implementation address for a given dependency name.
+    /// @dev Looks up the dependency in the Implementation Registry associated with the space factory.
+    /// @param ms The MembershipStorage layout containing the spaceFactory address.
+    /// @param dependencyName The keccak256 hash of the dependency name to resolve.
+    /// @return The address of the latest implementation for the specified dependency.
+    function getDependency(
+        MembershipStorage.Layout storage ms,
+        bytes32 dependencyName
+    ) internal view returns (address) {
+        IImplementationRegistry registry = IImplementationRegistry(ms.spaceFactory);
+        return registry.getLatestImplementation(dependencyName);
+    }
+
+    /// @notice Retrieves the latest implementation addresses for multiple dependency names.
+    /// @dev Batch resolves dependencies using the Implementation Registry associated with the space factory.
+    /// @param ms The MembershipStorage layout containing the spaceFactory address.
+    /// @param deps An array of keccak256 hashes of dependency names to resolve.
+    /// @return dependencies An array of addresses corresponding to the latest implementations for each dependency.
+    function getDependencies(
+        MembershipStorage.Layout storage ms,
+        bytes32[] memory deps
+    ) internal view returns (address[] memory dependencies) {
+        uint256 length = deps.length;
+        dependencies = new address[](length);
+        IImplementationRegistry registry = IImplementationRegistry(ms.spaceFactory);
+        for (uint256 i; i < length; ++i) {
+            dependencies[i] = registry.getLatestImplementation(deps[i]);
+        }
+    }
+
+    /// @notice Retrieves the latest implementation address for the App Registry dependency.
+    /// @dev Convenience method to get the App Registry implementation from the registry.
+    /// @return The address of the latest App Registry implementation.
+    function getAppRegistry() internal view returns (IAppRegistry) {
+        return IAppRegistry(getDependency(MembershipStorage.layout(), APP_REGISTRY));
+    }
+}

package/src/spaces/facets/Entitled.sol

@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IWalletLink} from "../../factory/facets/wallet-link/IWalletLink.sol";
+import {IEntitlement, IEntitlementBase} from "../entitlements/IEntitlement.sol";
+
+// libraries
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {PausableStorage} from "@towns-protocol/diamond/src/facets/pausable/PausableStorage.sol";
+import {LibSort} from "solady/utils/LibSort.sol";
+import {ERC721AStorage} from "../../diamond/facets/token/ERC721A/ERC721AStorage.sol";
+import {CustomRevert} from "../../utils/libraries/CustomRevert.sol";
+import {EntitlementsManagerStorage} from "./entitlements/EntitlementsManagerStorage.sol";
+import {MembershipStorage} from "./membership/MembershipStorage.sol";
+import {BanningStorage} from "./banning/BanningStorage.sol";
+import {AppAccountStorage} from "./account/AppAccountStorage.sol";
+import {DependencyLib} from "./DependencyLib.sol";
+
+// contracts
+import {TokenOwnableBase} from "@towns-protocol/diamond/src/facets/ownable/token/TokenOwnableBase.sol";
+
+abstract contract Entitled is IEntitlementBase, TokenOwnableBase {
+    using EnumerableSet for EnumerableSet.AddressSet;
+    using EnumerableSet for EnumerableSet.UintSet;
+    using CustomRevert for bytes4;
+
+    bytes32 internal constant IN_TOWN = 0x0;
+    uint256 internal constant MEMBERSHIP_START_TOKEN_ID = 0;
+
+    function _isEntitledToSpace(
+        address user,
+        string memory permission
+    ) internal view returns (bool) {
+        return _isEntitledToChannel(IN_TOWN, user, bytes32(bytes(permission)));
+    }
+
+    function _isEntitledToChannel(
+        bytes32 channelId,
+        address user,
+        bytes32 permission
+    ) internal view returns (bool) {
+        address[] memory wallets = _getLinkedWalletsWithUser(user);
+        if (wallets.length == 0) return false;
+
+        // Check owner first (cheapest check)
+        address owner = _owner();
+        for (uint256 i; i < wallets.length; ++i) if (wallets[i] == owner) return true;
+
+        // Check if any wallet is banned using optimized O(n log n + m) approach
+        if (_hasAnyBannedWallet(wallets)) return false;
+
+        // Entitlement checks for members
+        EntitlementsManagerStorage.Layout storage ds = EntitlementsManagerStorage.layout();
+        address[] memory entitlements = ds.entitlements.values();
+        uint256 entitlementsLength = entitlements.length;
+
+        for (uint256 i; i < entitlementsLength; ++i) {
+            IEntitlement entitlement = ds.entitlementByAddress[entitlements[i]].entitlement;
+            if (
+                !entitlement.isCrosschain() &&
+                entitlement.isEntitled(channelId, wallets, permission)
+            ) return true;
+        }
+
+        return false;
+    }
+
+    function _validatePermission(string memory permission) internal view {
+        // Owner always has permission
+        if (_owner() == msg.sender) return;
+
+        // Check if not paused and user has permission
+        if (!PausableStorage.layout().paused) {
+            bytes32 permissionHash = bytes32(bytes(permission));
+
+            // Check space entitlements
+            if (_isEntitledToSpace(msg.sender, permission)) return;
+
+            // Check bot entitlements
+            if (_isBotEntitled(msg.sender, permissionHash)) return;
+        }
+
+        Entitlement__NotAllowed.selector.revertWith();
+    }
+
+    function _isMember(address user) internal view returns (bool member) {
+        member = ERC721AStorage.balanceOf(user) > 0;
+    }
+
+    function _validateMembership(address user) internal view {
+        // return if the user is a member or the owner
+        if (_isMember(user)) return;
+        address owner = _owner();
+        if (user == owner) return;
+
+        // otherwise, check if the user is a linked wallet
+        address[] memory wallets = _getLinkedWalletsWithUser(user);
+        uint256 length = wallets.length;
+        for (uint256 i; i < length; ++i) {
+            if (_isMember(wallets[i]) || wallets[i] == owner) return;
+        }
+        Entitlement__NotMember.selector.revertWith();
+    }
+
+    function _getLinkedWalletsWithUser(
+        address rootKey
+    ) internal view returns (address[] memory wallets) {
+        IWalletLink wl = IWalletLink(MembershipStorage.layout().spaceFactory);
+        address[] memory linkedWallets = wl.getWalletsByRootKey(rootKey);
+
+        // Allow for the possibility that the user is not a root key, but a linked wallet.
+        if (linkedWallets.length == 0) {
+            address alternateRootKey = wl.getRootKeyForWallet(rootKey);
+            if (alternateRootKey != address(0)) {
+                rootKey = alternateRootKey;
+                linkedWallets = wl.getWalletsByRootKey(rootKey);
+            }
+        }
+
+        wallets = LibSort.copy(linkedWallets);
+        assembly ("memory-safe") {
+            // Increment the size of the array by 1 and add the root key
+            mstore(wallets, add(mload(wallets), 1))
+            // LibSort.copy assigns the free memory pointer to the end of the array
+            mstore(mload(0x40), rootKey)
+            mstore(0x40, add(mload(0x40), 0x20))
+        }
+    }
+
+    function _isBotEntitled(address client, bytes32 permission) internal view returns (bool) {
+        // Early return if client is zero address
+        if (client == address(0)) return false;
+
+        address app = DependencyLib.getAppRegistry().getAppByClient(client);
+        if (app == address(0)) return false;
+
+        return AppAccountStorage.isAppEntitled(app, client, permission);
+    }
+
+    function _hasAnyBannedWallet(address[] memory wallets) internal view returns (bool) {
+        BanningStorage.Layout storage ds = BanningStorage.layout();
+        uint256[] memory bannedTokens = ds.bannedIds.values();
+
+        if (bannedTokens.length == 0) return false;
+
+        // Step 1: Collect banned token owners - O(n)
+        address[] memory bannedOwners = new address[](bannedTokens.length);
+        for (uint256 i; i < bannedTokens.length; ++i) {
+            bannedOwners[i] = ERC721AStorage.ownerAt(MEMBERSHIP_START_TOKEN_ID, bannedTokens[i]);
+        }
+
+        // Step 2: Sort and deduplicate banned owners - O(n log n)
+        LibSort.sort(bannedOwners);
+        LibSort.uniquifySorted(bannedOwners);
+
+        unchecked {
+            // Step 3: Combine wallets with unique banned owners - O(m + n)
+            address[] memory combined = new address[](wallets.length + bannedOwners.length);
+            for (uint256 i; i < wallets.length; ++i) {
+                combined[i] = wallets[i];
+            }
+            for (uint256 i; i < bannedOwners.length; ++i) {
+                combined[wallets.length + i] = bannedOwners[i];
+            }
+
+            // Step 4: Check for duplicates - O(m + n)
+            // any duplicate found is an intersection between wallets and banned owners
+            return LibSort.hasDuplicate(combined);
+        }
+    }
+}

package/src/spaces/facets/Permissions.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library Permissions {
+    string public constant ModifyChannel = "ModifyChannel";
+    string public constant AddRemoveChannels = "AddRemoveChannels";
+    string public constant ModifySpaceSettings = "ModifySpaceSettings";
+    string public constant ModifyRoles = "ModifyRoles";
+    string public constant JoinSpace = "JoinSpace";
+    string public constant ModifyBanning = "ModifyBanning";
+    string public constant Read = "Read";
+    string public constant Write = "Write";
+    string public constant React = "React";
+    string public constant Ping = "Ping";
+}

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

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IAppAccount} from "./IAppAccount.sol";
+
+// libraries
+import {AppAccountBase} from "./AppAccountBase.sol";
+
+// contracts
+
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {ReentrancyGuard} from "solady/utils/ReentrancyGuard.sol";
+
+/**
+ * @title AppAccount
+ * @notice A lightweight modular erc6900 semi-compatible account
+ * @dev This account is used to execute transactions on behalf of a Space
+ */
+contract AppAccount is IAppAccount, AppAccountBase, ReentrancyGuard, Facet {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                      Execution                             */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function execute(
+        address target,
+        uint256 value,
+        bytes calldata data
+    ) external payable nonReentrant returns (bytes memory result) {
+        result = _onExecute(target, value, data);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       App Management                    */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IAppAccount
+    function onInstallApp(bytes32 appId, bytes calldata data) external nonReentrant {
+        _onlyRegistry();
+        _installApp(appId, data);
+    }
+
+    /// @inheritdoc IAppAccount
+    function onUninstallApp(bytes32 appId, bytes calldata data) external {
+        _onlyRegistry();
+        _uninstallApp(appId, data);
+    }
+
+    /// @inheritdoc IAppAccount
+    function onRenewApp(bytes32 appId, bytes calldata data) external nonReentrant {
+        _onlyRegistry();
+        _onRenewApp(appId, data);
+    }
+
+    /// @inheritdoc IAppAccount
+    function enableApp(address app) external onlyOwner {
+        _enableApp(app);
+    }
+
+    /// @inheritdoc IAppAccount
+    function disableApp(address app) external onlyOwner {
+        _disableApp(app);
+    }
+
+    /// @inheritdoc IAppAccount
+    function getInstalledApps() external view returns (address[] memory) {
+        return _getApps();
+    }
+
+    /// @inheritdoc IAppAccount
+    function isAppInstalled(address app) external view returns (bool) {
+        return _isAppInstalled(app);
+    }
+
+    /// @inheritdoc IAppAccount
+    function getAppId(address app) external view returns (bytes32) {
+        return _getInstalledAppId(app);
+    }
+
+    /// @inheritdoc IAppAccount
+    function getAppExpiration(address app) external view returns (uint48) {
+        return _getGroupExpiration(_getInstalledAppId(app));
+    }
+
+    /// @inheritdoc IAppAccount
+    function isAppEntitled(
+        address app,
+        address publicKey,
+        bytes32 permission
+    ) external view returns (bool) {
+        return _isAppEntitled(app, publicKey, permission);
+    }
+}