@towns-protocol/contracts 0.0.302

package/src/apps/facets/registry/IAppRegistry.sol

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ISchemaResolver} from "@ethereum-attestation-service/eas-contracts/resolver/ISchemaResolver.sol";
+import {IAppAccount} from "../../../spaces/facets/account/IAppAccount.sol";
+import {ITownsApp} from "../../ITownsApp.sol";
+
+// libraries
+import {Attestation} from "@ethereum-attestation-service/eas-contracts/Common.sol";
+import {ExecutionManifest} from "@erc6900/reference-implementation/interfaces/IERC6900ExecutionModule.sol";
+
+interface IAppRegistryBase {
+    struct AppParams {
+        string name;
+        bytes32[] permissions;
+        address client;
+        uint256 installPrice;
+        uint48 accessDuration;
+    }
+
+    struct App {
+        bytes32 appId;
+        address module;
+        address owner;
+        address client;
+        bytes32[] permissions;
+        ExecutionManifest manifest;
+        uint48 duration;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           ERRORS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    error AppAlreadyRegistered();
+    error AppNotRegistered();
+    error AppRevoked();
+    error AppNotInstalled();
+    error NotAppOwner();
+    error AppDoesNotImplementInterface();
+    error InvalidAppName();
+    error InvalidAddressInput();
+    error InvalidArrayInput();
+    error BannedApp();
+    error InvalidAppId();
+    error InvalidPrice();
+    error InvalidDuration();
+    error InsufficientPayment();
+    error NotAllowed();
+    error ClientAlreadyRegistered();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    event AppRegistered(address indexed app, bytes32 uid);
+    event AppUnregistered(address indexed app, bytes32 uid);
+    event AppUpdated(address indexed app, bytes32 uid);
+    event AppBanned(address indexed app, bytes32 uid);
+    event AppSchemaSet(bytes32 uid);
+    event AppCreated(address indexed app, bytes32 uid);
+    event AppInstalled(address indexed app, address indexed account, bytes32 indexed appId);
+    event AppUninstalled(address indexed app, address indexed account, bytes32 indexed appId);
+    event AppRenewed(address indexed app, address indexed account, bytes32 indexed appId);
+}
+
+/// @title IAppRegistry Interface
+/// @notice Interface for managing app registrations and permissions
+interface IAppRegistry is IAppRegistryBase {
+    /// @notice Get the schema structure used for registering apps
+    /// @return The schema structure
+    function getAppSchema() external view returns (string memory);
+
+    /// @notice Get the active schema ID used for app attestations
+    /// @return The schema ID
+    function getAppSchemaId() external view returns (bytes32);
+
+    /// @notice Get the attestation for a app
+    /// @param appId The app ID
+    /// @return The attestation
+    function getAppById(bytes32 appId) external view returns (App memory);
+
+    /// @notice Get the apps price
+    /// @param app The app address
+    /// @return The price
+    function getAppPrice(address app) external view returns (uint256);
+
+    /// @notice Get the duration of an app
+    /// @param app The app address
+    /// @return duration The duration of the app
+    function getAppDuration(address app) external view returns (uint48);
+
+    /// @notice Get the current version (attestation UID) for a app
+    /// @param app The app address
+    /// @return The attestation UID representing the current version
+    function getLatestAppId(address app) external view returns (bytes32);
+
+    /// @notice Get the app address associated with a client
+    /// @param client The client address
+    /// @return The app address
+    function getAppByClient(address client) external view returns (address);
+
+    /// @notice Check if a app is banned
+    /// @param app The app address
+    /// @return isBanned True if the app is banned, false otherwise
+    function isAppBanned(address app) external view returns (bool);
+
+    /// @notice Create a new app
+    /// @param params The parameters of the app
+    /// @return app The app address
+    /// @return appId The attestation UID of the registered app
+    function createApp(
+        AppParams calldata params
+    ) external payable returns (address app, bytes32 appId);
+
+    /// @notice Register a new app with permissions
+    /// @param app The app address to register
+    /// @param client The client contract address that will use this app
+    /// @return appId The attestation UID of the registered app
+    function registerApp(ITownsApp app, address client) external payable returns (bytes32 appId);
+
+    /// @notice Remove a app from the registry
+    /// @param appId The app ID to remove
+    function removeApp(bytes32 appId) external;
+
+    /// @notice Renew an app
+    /// @param app The app address to renew
+    /// @param account The account to renew the app for
+    /// @param data The data to pass to the app's onRenewApp function
+    function renewApp(ITownsApp app, IAppAccount account, bytes calldata data) external payable;
+
+    /// @notice Install an app
+    /// @param app The app address to install
+    /// @param account The account to install the app to
+    /// @param data The data to pass to the app's onInstall function
+    function installApp(ITownsApp app, IAppAccount account, bytes calldata data) external payable;
+
+    /// @notice Uninstall an app
+    /// @param app The app address to uninstall
+    /// @param account The account to uninstall the app from
+    /// @param data The data to pass to the app's onUninstall function
+    function uninstallApp(ITownsApp app, IAppAccount account, bytes calldata data) external;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Admin                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    /// @notice Set the schema ID used for app registrations
+    /// @param schema The new schema
+    /// @return The schema ID
+    function adminRegisterAppSchema(
+        string calldata schema,
+        ISchemaResolver resolver,
+        bool revocable
+    ) external returns (bytes32);
+
+    /// @notice Ban a app from the registry
+    /// @param app The app address to ban
+    /// @return The attestation UID that was banned
+    function adminBanApp(address app) external returns (bytes32);
+}

package/src/apps/facets/schema/ISchema.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface ISchemaBase {
+    error InvalidSchemaResolver();
+    error SchemaAlreadyRegistered();
+    error InvalidSchema();
+}

package/src/apps/facets/schema/SchemaBase.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ISchemaRegistry} from "@ethereum-attestation-service/eas-contracts/ISchemaRegistry.sol";
+import {ISchemaResolver} from "@ethereum-attestation-service/eas-contracts/resolver/ISchemaResolver.sol";
+import {IERC165} from "@openzeppelin/contracts/interfaces/IERC165.sol";
+import {ISchemaBase} from "./ISchema.sol";
+
+// types
+import {EMPTY_UID} from "@ethereum-attestation-service/eas-contracts/Common.sol";
+import {SchemaRecord} from "@ethereum-attestation-service/eas-contracts/ISchemaRegistry.sol";
+
+// libraries
+import {SchemaLib} from "./SchemaLib.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+import {SchemaStorage} from "./SchemaStorage.sol";
+// contracts
+
+abstract contract SchemaBase is ISchemaBase {
+    using CustomRevert for bytes4;
+    using SchemaLib for SchemaRecord;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                     Schema Management                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Registers a new schema in the registry
+    /// @param schema The schema string to register
+    /// @param resolver The resolver contract for this schema
+    /// @param revocable Whether attestations using this schema can be revoked
+    /// @return schemaUID The unique identifier of the registered schema
+    /// @dev Reverts if schema is empty, resolver is invalid, or schema is already registered
+    function _registerSchema(
+        string calldata schema,
+        ISchemaResolver resolver,
+        bool revocable
+    ) internal returns (bytes32 schemaUID) {
+        // check empty schema
+        if (bytes(schema).length == 0) {
+            InvalidSchema.selector.revertWith();
+        }
+
+        checkResolver(resolver);
+
+        SchemaRecord memory schemaRecord = SchemaRecord({
+            uid: EMPTY_UID,
+            resolver: resolver,
+            revocable: revocable,
+            schema: schema
+        });
+
+        SchemaStorage.Layout storage db = SchemaStorage.getLayout();
+
+        schemaUID = schemaRecord.getUID();
+        if (db.schemas[schemaUID].uid != EMPTY_UID) {
+            SchemaAlreadyRegistered.selector.revertWith();
+        }
+
+        schemaRecord.uid = schemaUID;
+        db.schemas[schemaUID] = schemaRecord;
+
+        emit ISchemaRegistry.Registered(schemaUID, msg.sender, schemaRecord);
+    }
+
+    /// @notice Retrieves a schema record by its UID
+    /// @param uid The unique identifier of the schema
+    /// @return The schema record
+    function _getSchema(bytes32 uid) internal view returns (SchemaRecord memory) {
+        return SchemaStorage.getSchema(uid);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                     Validator Checks                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Validates that a resolver implements the required interface
+    /// @param resolver The resolver contract to check
+    /// @dev Reverts if the resolver doesn't implement ISchemaResolver interface
+    function checkResolver(ISchemaResolver resolver) internal view {
+        if (
+            address(resolver) != address(0) &&
+            !IERC165(address(resolver)).supportsInterface(type(ISchemaResolver).interfaceId)
+        ) {
+            InvalidSchemaResolver.selector.revertWith();
+        }
+    }
+}

package/src/apps/facets/schema/SchemaLib.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// struct
+import {SchemaRecord} from "@ethereum-attestation-service/eas-contracts/ISchemaRegistry.sol";
+
+library SchemaLib {
+    /// @notice Generates a unique identifier for a schema record
+    /// @param self The schema record to generate the UID for
+    /// @return The unique identifier for the schema
+    function getUID(SchemaRecord memory self) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked(self.schema, self.resolver, self.revocable));
+    }
+}

package/src/apps/facets/schema/SchemaRegistry.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ISchemaRegistry} from "@ethereum-attestation-service/eas-contracts/ISchemaRegistry.sol";
+import {ISchemaResolver} from "@ethereum-attestation-service/eas-contracts/resolver/ISchemaResolver.sol";
+
+// libraries
+
+// types
+import {SchemaRecord} from "@ethereum-attestation-service/eas-contracts/ISchemaRegistry.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {SchemaBase} from "./SchemaBase.sol";
+
+/// @title Schema Registry
+/// @notice A registry for schema records
+/// @dev This contract is used for implementation reference purposes
+contract SchemaRegistry is ISchemaRegistry, SchemaBase, OwnableBase, Facet {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                     Schema Management                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Returns the full semver contract version.
+    /// @return Semver contract version as a string.
+    function version() external pure returns (string memory) {
+        return "1.0.0";
+    }
+
+    /// @notice Register a schema
+    /// @param schema The schema to register e.g. "(address plugin,string pluginType,bool audited)"
+    /// @param resolver A contract that will validate the schema whenever someone attests to it
+    /// @param revocable Whether the schema is revocable
+    /// @return schemaId The UID of the schema
+    function register(
+        string calldata schema,
+        ISchemaResolver resolver,
+        bool revocable
+    ) external onlyOwner returns (bytes32) {
+        return _registerSchema(schema, resolver, revocable);
+    }
+
+    /// @notice Get the schema record for a given schemaId
+    /// @param uid The schemaId of the schema
+    /// @return The schema record
+    function getSchema(bytes32 uid) external view returns (SchemaRecord memory) {
+        return _getSchema(uid);
+    }
+}

package/src/apps/facets/schema/SchemaStorage.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+// structs
+import {SchemaRecord} from "@ethereum-attestation-service/eas-contracts/ISchemaRegistry.sol";
+
+library SchemaStorage {
+    // keccak256(abi.encode(uint256(keccak256("attestations.module.schema.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0xfd5bc2b1c92b0a5f91f2b26739da3957fadd042854b0b9b4b07f2b0885d3e400;
+
+    struct Layout {
+        mapping(bytes32 uid => SchemaRecord schema) schemas;
+    }
+
+    /// @notice Returns the storage layout for the schema module
+    /// @return ds The storage layout struct
+    function getLayout() internal pure returns (Layout storage ds) {
+        assembly {
+            ds.slot := STORAGE_SLOT
+        }
+    }
+
+    function getSchema(bytes32 uid) internal view returns (SchemaRecord memory) {
+        return getLayout().schemas[uid];
+    }
+}

package/src/apps/helpers/ISimpleApp.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface ISimpleAppBase {
+    /// @notice Thrown when the recipient address is the zero address
+    error ZeroAddress();
+
+    /// @notice Thrown when there is no balance to withdraw
+    error NoBalanceToWithdraw();
+
+    /// @notice Emitted when the app is withdrawn
+    /// @param recipient The address that received the withdrawal
+    /// @param amount The amount of tokens withdrawn
+    event Withdrawal(address indexed recipient, uint256 amount);
+
+    /// @notice Emitted when pricing is updated
+    /// @param installPrice The new install price
+    /// @param accessDuration The new access duration
+    event PricingUpdated(uint256 installPrice, uint48 accessDuration);
+}
+
+interface ISimpleApp is ISimpleAppBase {
+    /// @notice Withdraws the ETH balance of the app to the recipient
+    /// @param recipient The address to withdraw the ETH to
+    function withdrawETH(address recipient) external;
+
+    /// @notice Updates the pricing of the app
+    /// @param installPrice The new install price
+    /// @param accessDuration The new access duration
+    function updatePricing(uint256 installPrice, uint48 accessDuration) external;
+
+    /// @notice Initializes the app
+    /// @param owner The owner of the app
+    /// @param appId The ID of the app
+    /// @param permissions The permissions of the app
+    /// @param installPrice The install price of the app
+    /// @param accessDuration The access duration of the app
+    function initialize(
+        address owner,
+        string calldata appId,
+        bytes32[] calldata permissions,
+        uint256 installPrice,
+        uint48 accessDuration
+    ) external;
+}

package/src/apps/helpers/SimpleApp.sol

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ISimpleApp} from "../../apps/helpers/ISimpleApp.sol";
+import {ITownsApp} from "../../apps/ITownsApp.sol";
+import {IERC6900Module} from "@erc6900/reference-implementation/interfaces/IERC6900Module.sol";
+import {IERC6900ExecutionModule} from "@erc6900/reference-implementation/interfaces/IERC6900ExecutionModule.sol";
+
+// contracts
+import {BaseApp} from "../../apps/BaseApp.sol";
+import {Ownable} from "solady/auth/Ownable.sol";
+import {ExecutionManifest} from "@erc6900/reference-implementation/interfaces/IERC6900ExecutionModule.sol";
+import {Initializable} from "solady/utils/Initializable.sol";
+
+// libraries
+import {SimpleAppStorage} from "../../apps/helpers/SimpleAppStorage.sol";
+import {CustomRevert} from "../../utils/libraries/CustomRevert.sol";
+import {CurrencyTransfer} from "../../utils/libraries/CurrencyTransfer.sol";
+
+contract SimpleApp is ISimpleApp, Ownable, BaseApp, Initializable {
+    using CustomRevert for bytes4;
+    using SimpleAppStorage for SimpleAppStorage.Layout;
+
+    /// @inheritdoc ISimpleApp
+    function initialize(
+        address owner,
+        string calldata appId,
+        bytes32[] calldata permissions,
+        uint256 installPrice,
+        uint48 accessDuration
+    ) external initializer {
+        _setOwner(owner);
+        SimpleAppStorage.Layout storage $ = SimpleAppStorage.getLayout();
+        $.name = appId;
+        $.permissions = permissions;
+        $.installPrice = installPrice;
+        $.accessDuration = accessDuration;
+    }
+
+    /// @inheritdoc ISimpleApp
+    function withdrawETH(address recipient) external onlyOwner {
+        if (recipient == address(0)) ZeroAddress.selector.revertWith();
+
+        uint256 balance = address(this).balance;
+        if (balance == 0) NoBalanceToWithdraw.selector.revertWith();
+
+        CurrencyTransfer.safeTransferNativeToken(recipient, balance);
+
+        emit Withdrawal(recipient, balance);
+    }
+
+    /// @inheritdoc ISimpleApp
+    function updatePricing(uint256 installPrice, uint48 accessDuration) external onlyOwner {
+        SimpleAppStorage.Layout storage $ = SimpleAppStorage.getLayout();
+
+        $.installPrice = installPrice;
+        $.accessDuration = accessDuration;
+
+        emit PricingUpdated(installPrice, accessDuration);
+    }
+
+    /// @inheritdoc ITownsApp
+    function requiredPermissions() external view returns (bytes32[] memory) {
+        SimpleAppStorage.Layout storage $ = SimpleAppStorage.getLayout();
+        return $.permissions;
+    }
+
+    /// @inheritdoc IERC6900Module
+    function moduleId() public view returns (string memory) {
+        SimpleAppStorage.Layout storage $ = SimpleAppStorage.getLayout();
+        return $.name;
+    }
+
+    /// @inheritdoc IERC6900ExecutionModule
+    function executionManifest() external pure returns (ExecutionManifest memory) {
+        // solhint-disable no-empty-blocks
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           OVERRIDES                        */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _installPrice() internal view override returns (uint256) {
+        SimpleAppStorage.Layout storage $ = SimpleAppStorage.getLayout();
+        return $.installPrice;
+    }
+
+    function _accessDuration() internal view override returns (uint48) {
+        SimpleAppStorage.Layout storage $ = SimpleAppStorage.getLayout();
+        return $.accessDuration;
+    }
+
+    function _moduleOwner() internal view override returns (address) {
+        return owner();
+    }
+}

package/src/apps/helpers/SimpleAppStorage.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+library SimpleAppStorage {
+    // keccak256(abi.encode(uint256(keccak256("simple.app.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x83d7ef17df984d8e84ee79017942cb0329f48e2d537ef8c418bc299c6878be00;
+
+    struct Layout {
+        string name;
+        bytes32[] permissions;
+        uint256 installPrice;
+        uint48 accessDuration;
+    }
+
+    function getLayout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+}