@towns-protocol/contracts 0.0.440 → 0.0.441

package/src/account/facets/app/AppManagerMod.sol

@@ -0,0 +1,321 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IAppRegistry, IAppRegistryBase} from "src/apps/facets/registry/IAppRegistry.sol";
+import {IModule} from "@erc6900/reference-implementation/interfaces/IModule.sol";
+// libraries
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+import {Attestation, EMPTY_UID} from "@ethereum-attestation-service/eas-contracts/Common.sol";
+import {LibCall} from "solady/utils/LibCall.sol";
+import "../hub/AccountHubMod.sol" as AccountHub;
+
+// types
+using CustomRevert for bytes4;
+using EnumerableSetLib for EnumerableSetLib.Bytes32Set;
+
+/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+/*                           ERRORS                           */
+/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+/// @notice Thrown when the app ID is invalid
+error AppManager__InvalidAppId();
+
+/// @notice Thrown when the app is already installed
+error AppManager__AppAlreadyInstalled();
+
+/// @notice Thrown when the app is not installed
+error AppManager__AppNotInstalled();
+
+/// @notice Thrown when the app is not registered
+error AppManager__AppNotRegistered();
+
+/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+/*                         STORAGE                            */
+/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+// keccak256(abi.encode(uint256(keccak256("towns.account.app.manager.storage")) - 1)) & ~bytes32(uint256(0xff))
+bytes32 constant STORAGE_SLOT = 0x2e45e2674c3081261f26138b3a1b39b0261feef8186e18fcf5badd4929fe7b00;
+
+struct App {
+    bytes32 appId;
+    address app;
+    uint48 installedAt;
+    uint48 expiration;
+    bool active;
+}
+
+/// @notice Storage layout for the AppManager
+/// @custom:storage-location erc7201:towns.account.app.manager.storage
+struct Layout {
+    mapping(address account => EnumerableSetLib.Bytes32Set) apps;
+    mapping(address account => mapping(bytes32 appId => App)) appById;
+    mapping(address account => mapping(address app => bytes32 appId)) appIdByApp;
+}
+
+/// @notice Returns the storage layout for the AppManager
+/// @return $ The storage layout
+function getStorage() pure returns (Layout storage $) {
+    assembly {
+        $.slot := STORAGE_SLOT
+    }
+}
+/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+/*                         FUNCTIONS                          */
+/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+/// @notice Installs an app
+/// @param account The account to install the app to
+/// @param appId The ID of the app to install
+/// @param data The data to pass to the app's onInstall function
+function installApp(address account, bytes32 appId, bytes calldata data) {
+    if (appId == EMPTY_UID) AppManager__InvalidAppId.selector.revertWith();
+
+    IAppRegistry registry = IAppRegistry(AccountHub.getAppRegistry());
+    IAppRegistryBase.App memory app = registry.getAppById(appId);
+    if (app.appId == EMPTY_UID) AppManager__AppNotRegistered.selector.revertWith();
+
+    Layout storage $ = getStorage();
+    EnumerableSetLib.Bytes32Set storage apps = $.apps[account];
+
+    if (apps.contains(app.appId)) AppManager__AppAlreadyInstalled.selector.revertWith();
+
+    apps.add(app.appId);
+    $.appIdByApp[account][app.module] = app.appId;
+    $.appById[account][app.appId] = App({
+        appId: app.appId,
+        app: app.module,
+        installedAt: uint48(block.timestamp),
+        expiration: calcExpiration($, account, app.appId, app.duration),
+        active: true
+    });
+
+    if (data.length > 0) {
+        bytes memory callData = abi.encodeCall(IModule.onInstall, (data));
+        LibCall.callContract(app.module, 0, callData);
+    }
+}
+
+/// @notice Uninstalls an app
+/// @param account The account to uninstall the app from
+/// @param appId The ID of the app to uninstall
+/// @param data The data to pass to the app's onUninstall function
+function uninstallApp(address account, bytes32 appId, bytes calldata data) {
+    if (appId == EMPTY_UID) AppManager__InvalidAppId.selector.revertWith();
+
+    IAppRegistry registry = IAppRegistry(AccountHub.getAppRegistry());
+    IAppRegistryBase.App memory app = registry.getAppById(appId);
+    if (app.appId == EMPTY_UID) AppManager__AppNotRegistered.selector.revertWith();
+
+    Layout storage $ = getStorage();
+    EnumerableSetLib.Bytes32Set storage apps = $.apps[account];
+
+    if (!apps.contains(app.appId)) AppManager__AppNotInstalled.selector.revertWith();
+
+    address module = $.appById[account][app.appId].app;
+
+    // Remove from storage
+    apps.remove(app.appId);
+    delete $.appIdByApp[account][module];
+    delete $.appById[account][app.appId];
+
+    // Call module's onUninstall if data is provided (non-reverting)
+    if (data.length > 0) {
+        // solhint-disable-next-line no-empty-blocks
+        try IModule(module).onUninstall(data) {} catch {}
+    }
+}
+
+/// @notice Renews an app subscription
+/// @param account The account that owns the app
+/// @param appId The ID of the app to renew
+function renewApp(address account, bytes32 appId, bytes calldata) {
+    if (appId == EMPTY_UID) AppManager__InvalidAppId.selector.revertWith();
+
+    IAppRegistry registry = IAppRegistry(AccountHub.getAppRegistry());
+    IAppRegistryBase.App memory app = registry.getAppById(appId);
+    if (app.appId == EMPTY_UID) AppManager__AppNotRegistered.selector.revertWith();
+
+    Layout storage $ = getStorage();
+    if (!$.apps[account].contains(appId)) AppManager__AppNotInstalled.selector.revertWith();
+
+    // Calculate and update the new expiration
+    $.appById[account][appId].expiration = calcExpiration($, account, appId, app.duration);
+}
+
+/// @notice Updates an app to a new version
+/// @param account The account that owns the app
+/// @param newAppId The ID of the new app version
+/// @param data The data containing the current module address
+function updateApp(address account, bytes32 newAppId, bytes calldata data) {
+    if (data.length < 32) AppManager__InvalidAppId.selector.revertWith();
+
+    address module = abi.decode(data, (address));
+    if (module == address(0)) AppManager__InvalidAppId.selector.revertWith();
+
+    Layout storage $ = getStorage();
+
+    // Get current app ID from module
+    bytes32 currentAppId = $.appIdByApp[account][module];
+    if (currentAppId == EMPTY_UID) AppManager__AppNotInstalled.selector.revertWith();
+    if (currentAppId == newAppId) AppManager__AppAlreadyInstalled.selector.revertWith();
+
+    IAppRegistry registry = IAppRegistry(AccountHub.getAppRegistry());
+    IAppRegistryBase.App memory newApp = registry.getAppById(newAppId);
+    if (newApp.appId == EMPTY_UID) AppManager__AppNotRegistered.selector.revertWith();
+
+    // Read the old module from the stored app before deletion
+    address oldModule = $.appById[account][currentAppId].app;
+
+    // Remove old app from storage
+    $.apps[account].remove(currentAppId);
+    delete $.appById[account][currentAppId];
+    delete $.appIdByApp[account][oldModule];
+
+    // Add new app
+    $.apps[account].add(newAppId);
+    $.appIdByApp[account][newApp.module] = newAppId;
+    $.appById[account][newAppId] = App({
+        appId: newAppId,
+        app: newApp.module,
+        installedAt: uint48(block.timestamp),
+        expiration: calcExpiration($, account, newAppId, newApp.duration),
+        active: true
+    });
+}
+
+/// @notice Checks if an app is installed
+/// @param account The account to check
+/// @param app The app address
+/// @return True if the app is installed
+function isAppInstalled(address account, address app) view returns (bool) {
+    Layout storage $ = getStorage();
+    bytes32 appId = $.appIdByApp[account][app];
+    return appId != EMPTY_UID && $.appById[account][appId].active;
+}
+
+/// @notice Gets the app ID for a given app address
+/// @param account The account to check
+/// @param app The app address
+/// @return The app ID
+function getAppId(address account, address app) view returns (bytes32) {
+    return getStorage().appIdByApp[account][app];
+}
+
+/// @notice Gets the expiration timestamp for a given app
+/// @param account The account to check
+/// @param app The app address
+/// @return The expiration timestamp
+function getAppExpiration(address account, address app) view returns (uint48) {
+    Layout storage $ = getStorage();
+    bytes32 appId = $.appIdByApp[account][app];
+    return $.appById[account][appId].expiration;
+}
+
+/// @notice Gets all installed app addresses for an account
+/// @param account The account to check
+/// @return apps The array of installed app addresses (only active apps)
+function getInstalledApps(address account) view returns (address[] memory apps) {
+    Layout storage $ = getStorage();
+    bytes32[] memory appIds = $.apps[account].values();
+    uint256 length = appIds.length;
+
+    // Count active apps first
+    uint256 activeCount;
+    for (uint256 i; i < length; ++i) {
+        if ($.appById[account][appIds[i]].active) ++activeCount;
+    }
+
+    // Build array of active apps only
+    apps = new address[](activeCount);
+    uint256 j;
+    for (uint256 i; i < length; ++i) {
+        App storage app = $.appById[account][appIds[i]];
+        if (app.active) {
+            apps[j++] = app.app;
+        }
+    }
+}
+
+/// @notice Enables an app
+/// @param account The account that owns the app
+/// @param app The app address to enable
+function enableApp(address account, address app) {
+    Layout storage $ = getStorage();
+    bytes32 appId = $.appIdByApp[account][app];
+    if (appId == EMPTY_UID) AppManager__AppNotInstalled.selector.revertWith();
+    $.appById[account][appId].active = true;
+}
+
+/// @notice Disables an app
+/// @param account The account that owns the app
+/// @param app The app address to disable
+function disableApp(address account, address app) {
+    Layout storage $ = getStorage();
+    bytes32 appId = $.appIdByApp[account][app];
+    if (appId == EMPTY_UID) AppManager__AppNotInstalled.selector.revertWith();
+    $.appById[account][appId].active = false;
+}
+
+/// @notice Checks if an app is entitled to a permission
+/// @param account The account to check
+/// @param module The app module address
+/// @param client The client address making the request
+/// @param permission The permission to check
+/// @return True if the app is entitled to the permission
+function isAppEntitled(
+    address account,
+    address module,
+    address client,
+    bytes32 permission
+) view returns (bool) {
+    Layout storage $ = getStorage();
+    bytes32 appId = $.appIdByApp[account][module];
+    if (appId == EMPTY_UID) return false;
+
+    // Check app is active
+    if (!$.appById[account][appId].active) return false;
+
+    IAppRegistry registry = IAppRegistry(AccountHub.getAppRegistry());
+
+    // Check app not banned
+    if (registry.isAppBanned(module)) return false;
+
+    // Check app has not expired
+    if ($.appById[account][appId].expiration < block.timestamp) return false;
+
+    IAppRegistryBase.App memory app = registry.getAppById(appId);
+    if (app.appId == EMPTY_UID) return false;
+
+    // Check client matches the registered client
+    if (app.client != client) return false;
+
+    // Check permission exists in app.permissions
+    uint256 permissionsLength = app.permissions.length;
+    for (uint256 i; i < permissionsLength; ++i) {
+        if (app.permissions[i] == permission) return true;
+    }
+
+    return false;
+}
+
+/// @notice Calculates the expiration for an app
+/// @param $ The storage layout
+/// @param account The account that owns the app
+/// @param appId The ID of the app
+/// @param newDuration The new duration of the app
+/// @return The expiration timestamp
+function calcExpiration(
+    Layout storage $,
+    address account,
+    bytes32 appId,
+    uint48 newDuration
+) view returns (uint48) {
+    uint48 currentExpiration = $.appById[account][appId].expiration;
+    if (currentExpiration > block.timestamp) {
+        return currentExpiration + newDuration;
+    } else {
+        return uint48(block.timestamp) + newDuration;
+    }
+}

package/src/account/facets/hub/AccountHubFacet.sol

@@ -0,0 +1,226 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IModule} from "@erc6900/reference-implementation/interfaces/IModule.sol";
+import {IValidationModule} from "@erc6900/reference-implementation/interfaces/IValidationModule.sol";
+import {IAccountHub} from "./IAccountHub.sol";
+import {IExecutionModule, ExecutionManifest, ManifestExecutionFunction, ManifestExecutionHook} from "@erc6900/reference-implementation/interfaces/IExecutionModule.sol";
+import {IExecutionHookModule} from "@erc6900/reference-implementation/interfaces/IExecutionHookModule.sol";
+import {IAppAccount} from "../../../spaces/facets/account/IAppAccount.sol";
+
+// libraries
+import "./AccountHubMod.sol" as AccountHub;
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {Validator} from "../../../utils/libraries/Validator.sol";
+
+// contracts
+import {ModuleBase} from "modular-account/src/modules/ModuleBase.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {ReentrancyGuardTransient} from "solady/utils/ReentrancyGuardTransient.sol";
+
+contract AccountHubFacet is
+    IAccountHub,
+    IModule,
+    IExecutionModule,
+    IExecutionHookModule,
+    ModuleBase,
+    OwnableBase,
+    ReentrancyGuardTransient,
+    Facet
+{
+    using CustomRevert for bytes4;
+
+    /// @notice Initializes the facet when added to a Diamond
+    function __AccountHubFacet_init(
+        address spaceFactory,
+        address appRegistry
+    ) external onlyInitializing {
+        _addInterface(type(IModule).interfaceId);
+        _addInterface(type(IAccountHub).interfaceId);
+        _addInterface(type(IValidationModule).interfaceId);
+        _addInterface(type(IExecutionModule).interfaceId);
+        __AccountHubFacet_init_unchained(spaceFactory, appRegistry);
+    }
+
+    function __AccountHubFacet_init_unchained(address spaceFactory, address appRegistry) internal {
+        Validator.checkAddress(spaceFactory);
+        Validator.checkAddress(appRegistry);
+        AccountHub.Layout storage $ = AccountHub.getStorage();
+        ($.spaceFactory, $.appRegistry) = (spaceFactory, appRegistry);
+    }
+
+    /// @inheritdoc IModule
+    function onInstall(bytes calldata data) external override nonReentrant {
+        address account = abi.decode(data, (address));
+        AccountHub.installAccount(account);
+    }
+
+    /// @inheritdoc IModule
+    function onUninstall(bytes calldata data) external override nonReentrant {
+        address account = abi.decode(data, (address));
+        AccountHub.uninstallAccount(account);
+    }
+
+    function setSpaceFactory(address spaceFactory) external onlyOwner {
+        AccountHub.setSpaceFactory(spaceFactory);
+    }
+
+    function setAppRegistry(address appRegistry) external onlyOwner {
+        AccountHub.setAppRegistry(appRegistry);
+    }
+
+    function getSpaceFactory() external view returns (address) {
+        return AccountHub.getStorage().spaceFactory;
+    }
+
+    function getAppRegistry() external view returns (address) {
+        return AccountHub.getStorage().appRegistry;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                     ERC-6900 MODULE                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IModule
+    function moduleId() external pure returns (string memory) {
+        return "towns.account-module.1.0.0";
+    }
+
+    function executionManifest() external pure returns (ExecutionManifest memory) {
+        bool allowGlobalValidation = false;
+        bool skipRuntimeValidation = true;
+
+        ManifestExecutionFunction[] memory executionFunctions = new ManifestExecutionFunction[](11);
+        executionFunctions[0] = ManifestExecutionFunction({
+            executionSelector: IAppAccount.onInstallApp.selector,
+            skipRuntimeValidation: skipRuntimeValidation,
+            allowGlobalValidation: allowGlobalValidation
+        });
+
+        executionFunctions[1] = ManifestExecutionFunction({
+            executionSelector: IAppAccount.onUninstallApp.selector,
+            skipRuntimeValidation: skipRuntimeValidation,
+            allowGlobalValidation: allowGlobalValidation
+        });
+
+        executionFunctions[2] = ManifestExecutionFunction({
+            executionSelector: IAppAccount.onRenewApp.selector,
+            skipRuntimeValidation: skipRuntimeValidation,
+            allowGlobalValidation: allowGlobalValidation
+        });
+
+        executionFunctions[3] = ManifestExecutionFunction({
+            executionSelector: IAppAccount.onUpdateApp.selector,
+            skipRuntimeValidation: skipRuntimeValidation,
+            allowGlobalValidation: allowGlobalValidation
+        });
+
+        executionFunctions[4] = ManifestExecutionFunction({
+            executionSelector: IAppAccount.enableApp.selector,
+            skipRuntimeValidation: skipRuntimeValidation,
+            allowGlobalValidation: allowGlobalValidation
+        });
+
+        executionFunctions[5] = ManifestExecutionFunction({
+            executionSelector: IAppAccount.disableApp.selector,
+            skipRuntimeValidation: skipRuntimeValidation,
+            allowGlobalValidation: allowGlobalValidation
+        });
+
+        executionFunctions[6] = ManifestExecutionFunction({
+            executionSelector: IAppAccount.isAppInstalled.selector,
+            skipRuntimeValidation: skipRuntimeValidation,
+            allowGlobalValidation: allowGlobalValidation
+        });
+
+        executionFunctions[7] = ManifestExecutionFunction({
+            executionSelector: IAppAccount.getAppId.selector,
+            skipRuntimeValidation: skipRuntimeValidation,
+            allowGlobalValidation: allowGlobalValidation
+        });
+
+        executionFunctions[8] = ManifestExecutionFunction({
+            executionSelector: IAppAccount.getAppExpiration.selector,
+            skipRuntimeValidation: skipRuntimeValidation,
+            allowGlobalValidation: allowGlobalValidation
+        });
+
+        executionFunctions[9] = ManifestExecutionFunction({
+            executionSelector: IAppAccount.isAppEntitled.selector,
+            skipRuntimeValidation: skipRuntimeValidation,
+            allowGlobalValidation: allowGlobalValidation
+        });
+
+        executionFunctions[10] = ManifestExecutionFunction({
+            executionSelector: IAppAccount.getInstalledApps.selector,
+            skipRuntimeValidation: skipRuntimeValidation,
+            allowGlobalValidation: allowGlobalValidation
+        });
+
+        ManifestExecutionHook[] memory executionHooks = new ManifestExecutionHook[](4);
+
+        executionHooks[0] = ManifestExecutionHook({
+            executionSelector: IAppAccount.onInstallApp.selector,
+            entityId: 1,
+            isPreHook: true,
+            isPostHook: false
+        });
+
+        executionHooks[1] = ManifestExecutionHook({
+            executionSelector: IAppAccount.onUninstallApp.selector,
+            entityId: 2,
+            isPreHook: true,
+            isPostHook: false
+        });
+
+        executionHooks[2] = ManifestExecutionHook({
+            executionSelector: IAppAccount.onRenewApp.selector,
+            entityId: 3,
+            isPreHook: true,
+            isPostHook: false
+        });
+
+        executionHooks[3] = ManifestExecutionHook({
+            executionSelector: IAppAccount.onUpdateApp.selector,
+            entityId: 4,
+            isPreHook: true,
+            isPostHook: false
+        });
+
+        bytes4[] memory interfaceIds = new bytes4[](1);
+        interfaceIds[0] = type(IAppAccount).interfaceId;
+
+        return
+            ExecutionManifest({
+                executionFunctions: executionFunctions,
+                executionHooks: executionHooks,
+                interfaceIds: interfaceIds
+            });
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        ACCOUNT MODULE                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function isInstalled(address account) external view returns (bool) {
+        return AccountHub.isInstalled(account);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                      MODULE HOOKS                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function preExecutionHook(
+        uint32,
+        address sender,
+        uint256,
+        bytes calldata
+    ) external view returns (bytes memory) {
+        AccountHub.onlyRegistry(sender);
+        return "";
+    }
+
+    function postExecutionHook(uint32, bytes calldata) external {}
+}

package/src/account/facets/hub/AccountHubMod.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// libraries
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {Validator} from "../../../utils/libraries/Validator.sol";
+
+// types
+using CustomRevert for bytes4;
+
+/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+/*                         EVENTS                           */
+/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+/// @notice Emitted when the space factory is set
+/// @param spaceFactory The address of the space factory
+event SpaceFactorySet(address spaceFactory);
+
+/// @notice Emitted when the app registry is set
+/// @param appRegistry The address of the app registry
+event AppRegistrySet(address appRegistry);
+
+/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+/*                           ERRORS                           */
+/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+/// @notice Reverted when the sender is invalid
+/// @param sender The address of the sender
+error AccountHub__InvalidSender(address sender);
+
+/// @notice Reverted when the account is already initialized
+/// @param account The address of the account
+error AccountHub__AlreadyInitialized(address account);
+
+/// @notice Reverted when the account is invalid
+/// @param account The address of the account
+error AccountHub__InvalidAccount(address account);
+
+/// @notice Reverted when the account is not installed
+/// @param account The address of the account
+error AccountHub__NotInstalled(address account);
+
+/// @notice Reverted when the sender is not the registry
+/// @param sender The address of the sender
+error AccountHub__InvalidCaller(address sender);
+
+/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+/*                         STORAGE                            */
+/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+// keccak256(abi.encode(uint256(keccak256("towns.account.hub.storage")) - 1)) & ~bytes32(uint256(0xff))
+bytes32 constant STORAGE_SLOT = 0x71d4dc86d61a3ac91d71fb32ada3a4c5ccb69a82d3979318701e6840c1db0a00;
+
+/// @notice Storage layout for the AccountHubMod
+/// @custom:storage-location erc7201:towns.account.hub.storage
+struct Layout {
+    /// @notice Space factory
+    address spaceFactory;
+    /// @notice App registry
+    address appRegistry;
+    /// @notice Installed accounts
+    mapping(address account => bool installed) installed;
+}
+
+/// @notice Returns the storage layout for the AccountHubMod
+function getStorage() pure returns (Layout storage $) {
+    assembly {
+        $.slot := STORAGE_SLOT
+    }
+}
+
+/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+/*                         FUNCTIONS                          */
+/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+/// @notice Installs an account
+/// @param account The address of the account
+function installAccount(address account) {
+    Validator.checkAddress(account);
+    if (account != msg.sender) AccountHub__InvalidAccount.selector.revertWith(account);
+
+    Layout storage $ = getStorage();
+    if ($.installed[account]) AccountHub__AlreadyInitialized.selector.revertWith(account);
+    $.installed[account] = true;
+}
+
+/// @notice Uninstalls an account
+/// @param account The address of the account
+function uninstallAccount(address account) {
+    Validator.checkAddress(account);
+    if (account != msg.sender) AccountHub__InvalidAccount.selector.revertWith(account);
+    Layout storage $ = getStorage();
+    if (!$.installed[account]) AccountHub__NotInstalled.selector.revertWith(account);
+    delete $.installed[account];
+}
+
+/// @notice Sets the space factory
+/// @param spaceFactory The address of the space factory
+function setSpaceFactory(address spaceFactory) {
+    Validator.checkAddress(spaceFactory);
+    getStorage().spaceFactory = spaceFactory;
+    emit SpaceFactorySet(spaceFactory);
+}
+
+/// @notice Sets the app registry
+/// @param appRegistry The address of the app registry
+function setAppRegistry(address appRegistry) {
+    Validator.checkAddress(appRegistry);
+    getStorage().appRegistry = appRegistry;
+    emit AppRegistrySet(appRegistry);
+}
+
+/// @notice Checks if an account is installed
+/// @param account The address of the account
+/// @return True if the account is installed, false otherwise
+function isInstalled(address account) view returns (bool) {
+    return getStorage().installed[account];
+}
+
+/// @notice Gets the space factory
+/// @return spaceFactory The address of the space factory
+function getSpaceFactory() view returns (address) {
+    return getStorage().spaceFactory;
+}
+
+/// @notice Gets the app registry
+/// @return appRegistry The address of the app registry
+function getAppRegistry() view returns (address) {
+    return getStorage().appRegistry;
+}
+
+/// @notice Checks if the caller is the registry
+/// @dev Guard function: reverts if the caller is not the registry
+function onlyRegistry(address caller) view {
+    if (caller != getStorage().appRegistry) AccountHub__InvalidCaller.selector.revertWith(caller);
+}