@towns-protocol/contracts 0.0.302

package/src/spaces/facets/executor/ExecutorFacet.sol

@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IExecutor} from "./IExecutor.sol";
+
+// libraries
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {ExecutorBase} from "./ExecutorBase.sol";
+
+/**
+ * @title Executor
+ * @notice Facet that enables permissioned calls from a Space
+ * @dev This contract is used for implementation reference purposes
+ */
+contract ExecutorFacet is OwnableBase, ExecutorBase, IExecutor, Facet {
+    using CustomRevert for bytes4;
+
+    /**
+     * @notice Validates if the target address is allowed for calls
+     * @dev Prevents calls to critical system contracts
+     * @param target The contract address to check
+     */
+    modifier onlyAuthorized(address target) {
+        _checkAuthorized(target);
+        _;
+    }
+
+    /// @inheritdoc IExecutor
+    function grantAccess(
+        bytes32 groupId,
+        address account,
+        uint32 delay
+    ) external onlyOwner returns (bool newMember) {
+        _setGroupStatus(groupId, true);
+        return _grantGroupAccess(groupId, account, _getGroupGrantDelay(groupId), delay);
+    }
+
+    /// @inheritdoc IExecutor
+    function grantAccessWithExpiration(
+        bytes32 groupId,
+        address account,
+        uint32 delay,
+        uint48 expiration
+    ) external onlyOwner returns (bool newMember) {
+        _setGroupStatus(groupId, true, expiration);
+        return _grantGroupAccess(groupId, account, _getGroupGrantDelay(groupId), delay);
+    }
+
+    /// @inheritdoc IExecutor
+    function revokeAccess(bytes32 groupId, address account) external onlyOwner {
+        _revokeGroupAccess(groupId, account);
+    }
+
+    /// @inheritdoc IExecutor
+    function renounceAccess(bytes32 groupId, address account) external {
+        _renounceGroupAccess(groupId, account);
+    }
+
+    /// @inheritdoc IExecutor
+    function setGuardian(bytes32 groupId, bytes32 guardian) external onlyOwner {
+        _setGroupGuardian(groupId, guardian);
+    }
+
+    /// @inheritdoc IExecutor
+    function setGroupDelay(bytes32 groupId, uint32 delay) external onlyOwner {
+        _setGroupGrantDelay(groupId, delay, 0);
+    }
+
+    /// @inheritdoc IExecutor
+    function setGroupExpiration(bytes32 groupId, uint48 expiration) external onlyOwner {
+        _setGroupExpiration(groupId, expiration);
+    }
+
+    /// @inheritdoc IExecutor
+    function setTargetFunctionGroup(
+        address target,
+        bytes4 selector,
+        bytes32 groupId
+    ) external onlyAuthorized(target) onlyOwner {
+        _setTargetFunctionGroup(target, selector, groupId);
+    }
+
+    /// @inheritdoc IExecutor
+    function setTargetDisabled(
+        address target,
+        bool disabled
+    ) external onlyAuthorized(target) onlyOwner {
+        _setTargetDisabled(target, disabled);
+    }
+
+    /// @inheritdoc IExecutor
+    function scheduleOperation(
+        address target,
+        bytes calldata data,
+        uint48 when
+    ) external payable returns (bytes32 operationId, uint32 nonce) {
+        return _scheduleExecution(target, data, when);
+    }
+
+    /// @inheritdoc IExecutor
+    function execute(
+        address target,
+        uint256 value,
+        bytes calldata data
+    ) external payable onlyAuthorized(target) returns (uint32 nonce) {
+        (, nonce) = _execute(target, value, data);
+    }
+
+    /// @inheritdoc IExecutor
+    function cancel(
+        address caller,
+        address target,
+        bytes calldata data
+    ) external returns (uint32 nonce) {
+        return _cancel(caller, target, data);
+    }
+
+    /// @inheritdoc IExecutor
+    function hasAccess(
+        bytes32 groupId,
+        address account
+    ) external view returns (bool isMember, uint32 executionDelay, bool active) {
+        return _hasGroupAccess(groupId, account);
+    }
+
+    /// @inheritdoc IExecutor
+    function getAccess(
+        bytes32 groupId,
+        address account
+    )
+        external
+        view
+        returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect)
+    {
+        return _getAccess(groupId, account);
+    }
+
+    /// @inheritdoc IExecutor
+    function getGroupDelay(bytes32 groupId) external view returns (uint32) {
+        return _getGroupGrantDelay(groupId);
+    }
+
+    /// @inheritdoc IExecutor
+    function getScheduleTimepoint(bytes32 id) external view returns (uint48) {
+        return _getScheduleTimepoint(id);
+    }
+
+    /// @inheritdoc IExecutor
+    function onExecution(address target) external view returns (bool) {
+        return _isTargetExecuting(target);
+    }
+
+    /// @inheritdoc IExecutor
+    function hashOperation(
+        address caller,
+        address target,
+        bytes calldata data
+    ) external pure returns (bytes32) {
+        return _hashOperation(caller, target, data);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        Internal                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev Internal function to get the owner
+    function _getOwner() internal view virtual override returns (address) {
+        return _owner();
+    }
+
+    /// @dev Internal function to check if a target is authorized
+    function _checkAuthorized(address target) internal virtual {}
+}

package/src/spaces/facets/executor/ExecutorStorage.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// types
+
+// libraries
+
+// types
+import {Group, Schedule, Target} from "./IExecutor.sol";
+import {HookConfig} from "./hooks/IHookBase.sol";
+import {GroupLib} from "./GroupLib.sol";
+
+// contracts
+
+library ExecutorStorage {
+    using GroupLib for Group;
+
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.executor.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0xb7e2813a9de15ce5ee4c1718778708cd70fd7ee3d196d203c0f40369a8d4a600;
+
+    // keccak256(abi.encode(uint256(keccak256("spaces.facets.executor.transient.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant TRANSIENT_STORAGE_SLOT =
+        0x50b382cc42d5e85c7df990b4496d41f5c12a6bb29194f1db29e58a2d7a053600;
+
+    struct Layout {
+        // Execution ID
+        bytes32 executionId;
+        // Target => Target Details
+        mapping(address target => Target targetDetails) targets;
+        // Group ID => Group
+        mapping(bytes32 groupId => Group group) groups;
+        // Schedule ID => Schedule
+        mapping(bytes32 scheduleId => Schedule schedule) schedules;
+        // Hook Config ID => Hook Config
+        mapping(bytes32 configId => HookConfig config) hooks;
+    }
+
+    function getLayout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        Group Access                        */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    function getGroup(bytes32 groupId) internal view returns (Group storage) {
+        return getLayout().groups[groupId];
+    }
+
+    function hasGroupAccess(
+        bytes32 groupId,
+        address account
+    ) internal view returns (bool isMember, uint32 executionDelay, bool active) {
+        Group storage group = getGroup(groupId);
+        (isMember, executionDelay) = group.hasAccess(account);
+
+        // Check both active status and expiration
+        active = group.active && (group.expiration == 0 || group.expiration > block.timestamp);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                   Transient Execution Id                   */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function getTransientExecutionId() internal view returns (bytes32 id) {
+        assembly {
+            id := tload(TRANSIENT_STORAGE_SLOT)
+        }
+    }
+
+    function setTransientExecutionId(bytes32 id) internal {
+        assembly {
+            tstore(TRANSIENT_STORAGE_SLOT, id)
+        }
+    }
+
+    function getTargetExecutionId(address target) internal view returns (bytes32 id) {
+        assembly {
+            id := tload(target)
+        }
+    }
+
+    function setTargetExecutionId(address target, bytes32 id) internal {
+        assembly {
+            tstore(target, id)
+        }
+    }
+
+    function clearTransientStorage(address target) internal {
+        assembly {
+            tstore(TRANSIENT_STORAGE_SLOT, 0)
+            tstore(target, 0)
+        }
+    }
+}

package/src/spaces/facets/executor/GroupLib.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+import {Group, Access} from "./IExecutor.sol";
+
+// contracts
+import {Time} from "@openzeppelin/contracts/utils/types/Time.sol";
+
+library GroupLib {
+    using Time for Time.Delay;
+    using Time for uint32;
+
+    /// @notice Sets the status of a group.
+    /// @param status The status to set.
+    function setStatus(Group storage self, bool status) internal {
+        self.active = status;
+    }
+
+    /// @notice Sets the expiration of a group.
+    /// @param expiration The expiration of the group.
+    function setExpiration(Group storage self, uint48 expiration) internal {
+        self.expiration = expiration;
+    }
+
+    /// @notice Sets the guardian for a group.
+    /// @param guardian The guardian role ID.
+    function setGuardian(Group storage self, bytes32 guardian) internal {
+        self.guardian = guardian;
+    }
+
+    /// @notice Sets the grant delay for a group.
+    /// @param grantDelay The new grant delay.
+    /// @param minSetback The minimum setback for the delay.
+    function setGrantDelay(Group storage self, uint32 grantDelay, uint32 minSetback) internal {
+        (self.grantDelay, ) = self.grantDelay.withUpdate(grantDelay, minSetback);
+    }
+
+    /// @notice Grants access to a group for an account.
+    /// @param account The account to grant access to.
+    /// @param executionDelay The delay for execution.
+    function grantAccess(
+        Group storage self,
+        address account,
+        uint32 grantDelay,
+        uint32 executionDelay
+    ) internal returns (bool newMember, uint48 lastAccess) {
+        newMember = self.members[account].lastAccess == 0;
+
+        if (newMember) {
+            lastAccess = Time.timestamp() + grantDelay;
+            self.members[account] = Access({
+                lastAccess: lastAccess,
+                delay: executionDelay.toDelay()
+            });
+        } else {
+            // just update the access delay
+            (self.members[account].delay, lastAccess) = self.members[account].delay.withUpdate(
+                executionDelay,
+                0
+            );
+        }
+    }
+
+    /// @notice Revokes group access from an account.
+    /// @param account The account to revoke access from.
+    /// @return revoked True if access was revoked, false otherwise.
+    function revokeAccess(Group storage self, address account) internal returns (bool revoked) {
+        Access storage access = self.members[account];
+
+        if (access.lastAccess == 0) {
+            return false;
+        }
+
+        self.module = address(0);
+        self.active = false;
+
+        // delete the access
+        delete self.members[account];
+        return true;
+    }
+
+    function getAccess(
+        Group storage self,
+        address account
+    )
+        internal
+        view
+        returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect)
+    {
+        Access storage access = self.members[account];
+        since = access.lastAccess;
+        (currentDelay, pendingDelay, effect) = access.delay.getFull();
+        return (since, currentDelay, pendingDelay, effect);
+    }
+
+    /// @notice Checks if an account has access to a group.
+    /// @param group The group to check.
+    /// @param account The account to check.
+    /// @return isMember True if the account is a member.
+    /// @return executionDelay The execution delay for the account.
+    function hasAccess(
+        Group storage group,
+        address account
+    ) internal view returns (bool isMember, uint32 executionDelay) {
+        Access storage access = group.members[account];
+        uint48 since = access.lastAccess;
+        (executionDelay, , ) = access.delay.getFull();
+
+        // Check if member has valid access time
+        isMember = since != 0 && since <= Time.timestamp();
+    }
+
+    /// @notice Gets the guardian for a group.
+    /// @return The guardian role ID.
+    function getGuardian(Group storage self) internal view returns (bytes32) {
+        return self.guardian;
+    }
+
+    /// @notice Gets the grant delay for a group.
+    /// @param group The group to check.
+    /// @return The grant delay for the group.
+    function getGrantDelay(Group storage group) internal view returns (uint32) {
+        return group.grantDelay.get();
+    }
+}

package/src/spaces/facets/executor/IExecutor.sol

@@ -0,0 +1,287 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Time} from "@openzeppelin/contracts/utils/types/Time.sol";
+
+/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+/*                           STRUCTS                          */
+/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+/// @notice Structure that stores the details for a target contract
+/// @param allowedGroups Mapping of allowed groups for this target
+/// @param disabledFunctions Mapping of disabled functions for this target
+/// @param disabled Whether the target is disabled
+/// @param executionId Execution ID for the target
+struct Target {
+    mapping(bytes4 selector => bytes32 groupId) allowedGroups;
+    mapping(bytes4 selector => bool disabled) disabledFunctions;
+    bool disabled;
+    bytes32 executionId;
+}
+
+/// @notice Structure that stores the details for an access
+/// @param lastAccess Timepoint at which the user gets the permission
+/// @param delay Delay for execution. Only applies to execute() calls
+struct Access {
+    uint48 lastAccess;
+    Time.Delay delay;
+}
+
+/// @notice Structure that stores the details for a group
+/// @param module Address of the module that created the group
+/// @param members Mapping of members of the group
+/// @param guardian Guardian Role ID who can cancel operations targeting functions that need this group
+/// @param grantDelay Delay in which the group takes effect after being granted
+/// @param active Whether the group is active
+/// @param expiration Timepoint at which the group becomes inactive
+struct Group {
+    address module;
+    mapping(address user => Access access) members;
+    bytes32 guardian;
+    Time.Delay grantDelay;
+    bool active;
+    uint48 expiration;
+}
+
+/// @notice Structure that stores the details for a scheduled operation
+/// @param timepoint Moment at which the operation can be executed
+/// @param nonce Operation nonce to allow third-party contracts to identify the operation
+struct Schedule {
+    uint48 timepoint;
+    uint32 nonce;
+}
+
+interface IExecutorBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           ERRORS                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    error CallerAlreadyRegistered();
+    error CallerNotRegistered();
+    error ExecutionAlreadyRegistered();
+    error ExecutionNotRegistered();
+    error ExecutorCallFailed();
+    error ExecutionNotFound();
+    error UnauthorizedCall();
+    error AlreadyScheduled();
+    error NotScheduled();
+    error NotReady();
+    error Expired();
+    error UnauthorizedCancel();
+    error UnauthorizedRenounce();
+    error UnauthorizedTarget();
+    error ExecutionFunctionAlreadySet();
+    error NullModule();
+    error ExecutionHookAlreadySet();
+    error ModuleInstallCallbackFailed();
+    error InvalidDataLength();
+    error InvalidExpiration();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    event GroupAccessGranted(
+        bytes32 indexed groupId,
+        address indexed account,
+        uint32 delay,
+        uint48 since,
+        bool newMember
+    );
+    event GroupAccessRevoked(bytes32 indexed groupId, address indexed account, bool revoked);
+    event GroupGuardianSet(bytes32 indexed groupId, bytes32 guardian);
+    event GroupGrantDelaySet(bytes32 indexed groupId, uint32 delay);
+    event TargetFunctionGroupSet(
+        address indexed target,
+        bytes4 indexed selector,
+        bytes32 indexed groupId
+    );
+    event TargetFunctionDelaySet(address indexed target, uint32 newDelay, uint32 minSetback);
+    event TargetFunctionDisabledSet(address indexed target, bytes4 indexed selector, bool disabled);
+    event TargetDisabledSet(address indexed target, bool disabled);
+    event OperationScheduled(bytes32 indexed operationId, uint48 timepoint, uint32 nonce);
+    event OperationExecuted(bytes32 indexed operationId, uint32 nonce);
+    event OperationCanceled(bytes32 indexed operationId, uint32 nonce);
+    event GroupStatusSet(bytes32 indexed groupId, bool active);
+    event GroupExpirationSet(bytes32 indexed groupId, uint48 expiration);
+}
+
+interface IExecutor is IExecutorBase {
+    /**
+     * @notice Grants access to a group for an account with a delay
+     * @param groupId The group ID
+     * @param account The account to grant access to
+     * @param delay The delay for the access to be effective
+     * @return newMember Whether the account is a new member of the group
+     */
+    function grantAccess(
+        bytes32 groupId,
+        address account,
+        uint32 delay
+    ) external returns (bool newMember);
+
+    /**
+     * @notice Grants access to a group for an account with a delay and expiration
+     * @param groupId The group ID
+     * @param account The account to grant access to
+     * @param delay The delay for the access to be effective
+     * @param expiration The expiration timepoint for the access
+     * @return newMember Whether the account is a new member of the group
+     */
+    function grantAccessWithExpiration(
+        bytes32 groupId,
+        address account,
+        uint32 delay,
+        uint48 expiration
+    ) external returns (bool newMember);
+
+    /**
+     * @notice Revokes access to a group for an account
+     * @param groupId The group ID
+     * @param account The account to revoke access from
+     */
+    function revokeAccess(bytes32 groupId, address account) external;
+
+    /**
+     * @notice Renounces access to a group for an account
+     * @param groupId The group ID
+     * @param account The account to renounce access from
+     */
+    function renounceAccess(bytes32 groupId, address account) external;
+
+    /**
+     * @notice Sets the guardian role for a group
+     * @param groupId The group ID
+     * @param guardian The guardian role ID
+     */
+    function setGuardian(bytes32 groupId, bytes32 guardian) external;
+
+    /**
+     * @notice Sets the grant delay for a group
+     * @param groupId The group ID
+     * @param delay The delay for granting access
+     */
+    function setGroupDelay(bytes32 groupId, uint32 delay) external;
+
+    /**
+     * @notice Sets the expiration for a group
+     * @param groupId The group ID
+     * @param expiration The expiration timestamp
+     */
+    function setGroupExpiration(bytes32 groupId, uint48 expiration) external;
+
+    /**
+     * @notice Sets the group ID for a target function
+     * @param target The target contract address
+     * @param selector The function selector
+     * @param groupId The group ID
+     */
+    function setTargetFunctionGroup(address target, bytes4 selector, bytes32 groupId) external;
+
+    /**
+     * @notice Disables or enables a target contract
+     * @param target The target contract address
+     * @param disabled Whether the target should be disabled
+     */
+    function setTargetDisabled(address target, bool disabled) external;
+
+    /**
+     * @notice Schedules an operation for future execution
+     * @param target The target contract address
+     * @param data The calldata for the operation
+     * @param when The timestamp when the operation can be executed
+     * @return operationId The unique identifier for the operation
+     * @return nonce The operation nonce
+     */
+    function scheduleOperation(
+        address target,
+        bytes calldata data,
+        uint48 when
+    ) external payable returns (bytes32 operationId, uint32 nonce);
+
+    /**
+     * @notice Executes an operation immediately or after delay
+     * @param target The target contract address
+     * @param value The value for the operation
+     * @param data The calldata for the operation
+     * @return nonce The operation nonce if scheduled, 0 if immediate
+     */
+    function execute(
+        address target,
+        uint256 value,
+        bytes calldata data
+    ) external payable returns (uint32 nonce);
+
+    /**
+     * @notice Cancels a scheduled operation
+     * @param caller The account that scheduled the operation
+     * @param target The target contract address
+     * @param data The calldata for the operation
+     * @return nonce The operation nonce
+     */
+    function cancel(
+        address caller,
+        address target,
+        bytes calldata data
+    ) external returns (uint32 nonce);
+
+    /**
+     * @notice Checks if an account has access to a group
+     * @param groupId The group ID
+     * @param account The account to check access for
+     * @return isMember Whether the account is a member of the group
+     * @return executionDelay The delay for the access to be effective
+     * @return active Whether the group is active
+     */
+    function hasAccess(
+        bytes32 groupId,
+        address account
+    ) external view returns (bool isMember, uint32 executionDelay, bool active);
+
+    /**
+     * @notice Gets the access information for an account in a group
+     * @param groupId The group ID
+     * @param account The account to get access information for
+     * @return since The timestamp when the access was granted
+     * @return currentDelay The current delay for the access
+     * @return pendingDelay The pending delay for the access
+     * @return effect The effect of the access
+     */
+    function getAccess(
+        bytes32 groupId,
+        address account
+    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);
+
+    /**
+     * @notice Gets the grant delay for a group
+     * @param groupId The group ID
+     * @return The grant delay
+     */
+    function getGroupDelay(bytes32 groupId) external view returns (uint32);
+
+    /**
+     * @notice Gets the scheduled timepoint for an operation
+     * @param id The operation ID
+     * @return The scheduled timepoint, or 0 if not scheduled or expired
+     */
+    function getScheduleTimepoint(bytes32 id) external view returns (uint48);
+
+    /**
+     * @notice Checks if a target is currently executing
+     * @param target The target contract address
+     * @return True if the target is currently executing
+     */
+    function onExecution(address target) external view returns (bool);
+
+    /**
+     * @notice Hashes an operation
+     * @param caller The caller address
+     * @param target The target contract address
+     * @param data The calldata for the operation
+     * @return The hash of the operation
+     */
+    function hashOperation(
+        address caller,
+        address target,
+        bytes calldata data
+    ) external pure returns (bytes32);
+}