@towns-protocol/contracts 0.0.302

package/src/spaces/facets/executor/hooks/HookBase.sol

@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IHookBase, HookConfig, Hook} from "./IHookBase.sol";
+
+// libraries
+import {ExecutorStorage} from "../ExecutorStorage.sol";
+import {CustomRevert} from "../../../../utils/libraries/CustomRevert.sol";
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+import {LibCall} from "solady/utils/LibCall.sol";
+import {HookLib} from "./HookLib.sol";
+
+// contracts
+
+abstract contract HookBase is IHookBase {
+    using EnumerableSetLib for EnumerableSetLib.Bytes32Set;
+    using CustomRevert for bytes4;
+    using HookLib for HookConfig;
+
+    uint256 internal constant MAX_HOOKS = 10;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           HOOKS                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    function _addHook(
+        address module,
+        bytes4 selector,
+        uint32 entityId,
+        bool isPre,
+        bool isPost
+    ) internal {
+        HookConfig storage config = _getConfig(module, selector);
+        bytes32 hookId = _entityId(module, entityId);
+
+        if (config.isHookActive(hookId)) HookAlreadyExists.selector.revertWith();
+
+        config.createHook(hookId, module, entityId);
+
+        if (isPre) {
+            if (config.preHooks.length() >= MAX_HOOKS) TooManyHooks.selector.revertWith();
+            config.preHooks.add(hookId);
+        }
+
+        if (isPost) {
+            if (config.postHooks.length() >= MAX_HOOKS) TooManyHooks.selector.revertWith();
+            config.postHooks.add(hookId);
+        }
+
+        emit HookAdded(module, selector, entityId, isPre, isPost);
+    }
+
+    function _removeHook(address module, bytes4 selector, uint32 entityId) internal {
+        HookConfig storage config = _getConfig(module, selector);
+        bytes32 hookId = _entityId(module, entityId);
+
+        if (!config.isHookActive(hookId)) HookDoesNotExist.selector.revertWith();
+
+        config.removeHook(hookId, selector);
+
+        emit HookRemoved(module, selector, entityId);
+    }
+
+    function _callPreHooks(
+        address module,
+        bytes4 selector,
+        uint256 value,
+        bytes calldata data
+    ) internal {
+        HookConfig storage config = _getConfig(module, selector);
+
+        uint256 preHookCount = config.preHooks.length();
+        for (uint256 i; i < preHookCount; ++i) {
+            bytes32 hookId = config.preHooks.at(i);
+            Hook storage hook = config.hookData[hookId];
+
+            if (!hook.isActive) continue;
+
+            // Execute pre-hook and capture its return data
+            bytes memory preHookData = LibCall.callContract(
+                hook.module,
+                abi.encodeWithSignature(
+                    "preExecutionHook(uint32,address,uint256,bytes)",
+                    hook.entityId,
+                    msg.sender,
+                    value,
+                    data
+                )
+            );
+
+            // Store with selector context
+            if (preHookData.length > 0) {
+                config.preHookData[selector][hookId] = preHookData;
+            }
+        }
+    }
+
+    function _callPostHooks(address module, bytes4 selector) internal {
+        HookConfig storage config = _getConfig(module, selector);
+
+        uint256 postHookCount = config.postHooks.length();
+
+        for (uint256 i; i < postHookCount; ++i) {
+            bytes32 hookId = config.postHooks.at(i);
+            Hook storage hook = config.hookData[hookId];
+
+            if (!hook.isActive) continue;
+
+            // Get stored pre-hook data with selector context
+            bytes memory preHookData = config.preHookData[selector][hookId];
+
+            LibCall.callContract(
+                hook.module,
+                abi.encodeWithSignature(
+                    "postExecutionHook(uint32,bytes)",
+                    hook.entityId,
+                    preHookData
+                )
+            );
+
+            // Clean up storage with selector context
+            delete config.preHookData[selector][hookId];
+        }
+    }
+
+    function _getHooks(
+        address module,
+        bytes4 selector,
+        bool isPre
+    ) internal view returns (Hook[] memory hooks) {
+        HookConfig storage config = _getConfig(module, selector);
+        EnumerableSetLib.Bytes32Set storage hookSet = isPre ? config.preHooks : config.postHooks;
+
+        uint256 length = hookSet.length();
+        hooks = new Hook[](length);
+
+        for (uint256 i; i < length; ++i) {
+            bytes32 hookId = hookSet.at(i);
+            hooks[i] = config.hookData[hookId];
+        }
+    }
+
+    function _hasHook(
+        address module,
+        bytes4 selector,
+        uint32 entityId,
+        bool isPre
+    ) internal view returns (bool) {
+        HookConfig storage config = _getConfig(module, selector);
+        bytes32 hookId = _entityId(module, entityId);
+
+        EnumerableSetLib.Bytes32Set storage hooks = isPre ? config.preHooks : config.postHooks;
+
+        return hooks.contains(hookId);
+    }
+
+    function _configId(address target, bytes4 selector) internal pure returns (bytes32) {
+        return keccak256(abi.encode(target, selector));
+    }
+
+    function _entityId(address module, uint32 entity) internal pure returns (bytes32) {
+        return keccak256(abi.encode(module, entity));
+    }
+
+    function _getConfig(
+        address module,
+        bytes4 selector
+    ) internal view virtual returns (HookConfig storage config) {
+        bytes32 id = _configId(module, selector);
+        config = ExecutorStorage.getLayout().hooks[id];
+    }
+}

package/src/spaces/facets/executor/hooks/HookLib.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+import {LibCall} from "solady/utils/LibCall.sol";
+
+// types
+import {HookConfig, Hook} from "./IHookBase.sol";
+
+// contracts
+
+library HookLib {
+    using EnumerableSetLib for EnumerableSetLib.Bytes32Set;
+
+    function isHookActive(HookConfig storage self, bytes32 hookId) internal view returns (bool) {
+        return self.hookData[hookId].isActive;
+    }
+
+    function createHook(
+        HookConfig storage self,
+        bytes32 hookId,
+        address module,
+        uint32 entityId
+    ) internal {
+        self.hookData[hookId] = Hook({module: module, entityId: entityId, isActive: true});
+    }
+
+    function removeHook(HookConfig storage self, bytes32 hookId, bytes4 selector) internal {
+        delete self.hookData[hookId];
+        delete self.preHookData[selector][hookId];
+        self.preHooks.remove(hookId);
+        self.postHooks.remove(hookId);
+    }
+}

package/src/spaces/facets/executor/hooks/IHookBase.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+import {EnumerableSetLib} from "solady/utils/EnumerableSetLib.sol";
+
+/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+/*                           STRUCTS                           */
+/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+struct Hook {
+    address module;
+    uint32 entityId;
+    bool isActive;
+}
+
+struct HookConfig {
+    EnumerableSetLib.Bytes32Set preHooks;
+    EnumerableSetLib.Bytes32Set postHooks;
+    mapping(bytes4 selector => mapping(bytes32 entityId => bytes)) preHookData;
+    mapping(bytes32 entityId => Hook) hookData;
+}
+
+/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+/*                       BASE INTERFACE                       */
+/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+interface IHookBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           ERRORS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    error HookAlreadyExists();
+    error HookDoesNotExist();
+    error TooManyHooks();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    event HookAdded(
+        address indexed module,
+        bytes4 indexed selector,
+        uint32 indexed entityId,
+        bool isPre,
+        bool isPostHook
+    );
+    event HookRemoved(address indexed module, bytes4 indexed selector, uint32 indexed entityId);
+}

package/src/spaces/facets/gated/EntitlementGated.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IEntitlementGated} from "./IEntitlementGated.sol";
+
+import {IEntitlementChecker} from "src/base/registry/facets/checker/IEntitlementChecker.sol";
+import {IRuleEntitlement} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
+
+// libraries
+
+// contracts
+import {EntitlementGatedBase} from "./EntitlementGatedBase.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {ReentrancyGuard} from "solady/utils/ReentrancyGuard.sol";
+
+contract EntitlementGated is IEntitlementGated, EntitlementGatedBase, ReentrancyGuard, Facet {
+    function __EntitlementGated_init(
+        IEntitlementChecker entitlementChecker
+    ) external onlyInitializing {
+        __EntitlementGated_init_unchained(entitlementChecker);
+    }
+
+    function __EntitlementGated_init_unchained(IEntitlementChecker entitlementChecker) internal {
+        _addInterface(type(IEntitlementGated).interfaceId);
+        _setEntitlementChecker(entitlementChecker);
+    }
+
+    // Called by the xchain node to post the result of the entitlement check
+    // the internal function validates the transactionId and the result
+    function postEntitlementCheckResult(
+        bytes32 transactionId,
+        uint256 roleId,
+        NodeVoteStatus result
+    ) external nonReentrant {
+        _postEntitlementCheckResult(transactionId, roleId, result);
+    }
+
+    /// @notice Post the result of the entitlement check for a specific role
+    /// @dev Only the entitlement checker can call this function
+    /// @param transactionId The unique identifier for the transaction
+    /// @param roleId The role ID for the entitlement check
+    /// @param result The result of the entitlement check (PASSED or FAILED)
+    function postEntitlementCheckResultV2(
+        bytes32 transactionId,
+        uint256 roleId,
+        NodeVoteStatus result
+    ) external payable onlyEntitlementChecker nonReentrant {
+        _postEntitlementCheckResultV2(transactionId, roleId, result);
+    }
+
+    /// deprecated Use EntitlementDataQueryable.getCrossChainEntitlementData instead
+    function getRuleData(
+        bytes32 transactionId,
+        uint256 roleId
+    ) external view returns (IRuleEntitlement.RuleData memory) {
+        return _getRuleData(transactionId, roleId);
+    }
+}

package/src/spaces/facets/gated/EntitlementGatedBase.sol

@@ -0,0 +1,324 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IEntitlementGatedBase} from "./IEntitlementGated.sol";
+
+import {IEntitlementChecker} from "src/base/registry/facets/checker/IEntitlementChecker.sol";
+import {IImplementationRegistry} from "src/factory/facets/registry/IImplementationRegistry.sol";
+import {IRuleEntitlement} from "src/spaces/entitlements/rule/IRuleEntitlement.sol";
+
+// libraries
+import {EntitlementGatedStorage} from "./EntitlementGatedStorage.sol";
+import {MembershipStorage} from "src/spaces/facets/membership/MembershipStorage.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+
+abstract contract EntitlementGatedBase is IEntitlementGatedBase {
+    using CustomRevert for bytes4;
+
+    modifier onlyEntitlementChecker() {
+        if (msg.sender != address(EntitlementGatedStorage.layout().entitlementChecker)) {
+            CustomRevert.revertWith(EntitlementGated_OnlyEntitlementChecker.selector);
+        }
+        _;
+    }
+
+    function _setEntitlementChecker(IEntitlementChecker entitlementChecker) internal {
+        EntitlementGatedStorage.layout().entitlementChecker = entitlementChecker;
+    }
+
+    function _requestEntitlementCheck(
+        address callerAddress,
+        bytes32 transactionId,
+        IRuleEntitlement entitlement,
+        uint256 roleId
+    ) internal {
+        if (callerAddress == address(0)) {
+            CustomRevert.revertWith(EntitlementGated_InvalidAddress.selector);
+        }
+
+        EntitlementGatedStorage.Layout storage ds = EntitlementGatedStorage.layout();
+        Transaction storage transaction = ds.transactions[transactionId];
+        if (transaction.finalized) {
+            uint256 _length = transaction.roleIds.length;
+            for (uint256 i; i < _length; ++i) {
+                if (transaction.roleIds[i] == roleId) {
+                    revert EntitlementGated_TransactionCheckAlreadyRegistered();
+                }
+            }
+        }
+
+        // if the entitlement checker has not been set, set it
+        if (address(ds.entitlementChecker) == address(0)) {
+            _setFallbackEntitlementChecker();
+        }
+
+        address[] memory selectedNodes = ds.entitlementChecker.getRandomNodes(5);
+
+        if (!transaction.finalized) {
+            transaction.finalized = true;
+            transaction.entitlement = entitlement;
+            transaction.clientAddress = callerAddress;
+        }
+
+        transaction.roleIds.push(roleId);
+
+        uint256 length = selectedNodes.length;
+        NodeVote[] storage nodeVotesForRole = transaction.nodeVotesArray[roleId];
+        for (uint256 i; i < length; ++i) {
+            nodeVotesForRole.push(
+                NodeVote({node: selectedNodes[i], vote: NodeVoteStatus.NOT_VOTED})
+            );
+        }
+
+        ds.entitlementChecker.requestEntitlementCheck(
+            callerAddress,
+            transactionId,
+            roleId,
+            selectedNodes
+        );
+    }
+
+    function _postEntitlementCheckResult(
+        bytes32 transactionId,
+        uint256 roleId,
+        NodeVoteStatus result
+    ) internal {
+        EntitlementGatedStorage.Layout storage ds = EntitlementGatedStorage.layout();
+        Transaction storage transaction = ds.transactions[transactionId];
+
+        if (transaction.clientAddress == address(0) || transaction.finalized == false) {
+            revert EntitlementGated_TransactionNotRegistered();
+        }
+
+        if (transaction.isCompleted[roleId]) {
+            revert EntitlementGated_TransactionCheckAlreadyCompleted();
+        }
+
+        // Find node in the array and update the vote, revert if node was not found.
+        bool found;
+
+        // count the votes
+        uint256 passed = 0;
+        uint256 failed = 0;
+
+        NodeVote[] storage nodeVotesForRole = transaction.nodeVotesArray[roleId];
+        uint256 transactionNodesLength = nodeVotesForRole.length;
+
+        for (uint256 i; i < transactionNodesLength; ++i) {
+            NodeVote storage currentVote = nodeVotesForRole[i];
+
+            // Update vote if not yet voted
+            if (currentVote.node == msg.sender) {
+                if (currentVote.vote != NodeVoteStatus.NOT_VOTED) {
+                    revert EntitlementGated_NodeAlreadyVoted();
+                }
+                currentVote.vote = result;
+                found = true;
+            }
+
+            unchecked {
+                NodeVoteStatus currentStatus = currentVote.vote;
+                // Count votes
+                if (currentStatus == NodeVoteStatus.PASSED) {
+                    ++passed;
+                } else if (currentStatus == NodeVoteStatus.FAILED) {
+                    ++failed;
+                }
+            }
+        }
+
+        if (!found) {
+            revert EntitlementGated_NodeNotFound();
+        }
+
+        if (passed > transactionNodesLength / 2 || failed > transactionNodesLength / 2) {
+            transaction.isCompleted[roleId] = true;
+            NodeVoteStatus finalStatusForRole = passed > failed
+                ? NodeVoteStatus.PASSED
+                : NodeVoteStatus.FAILED;
+
+            bool allRoleIdsCompleted = _checkAllRoleIdsCompleted(transactionId);
+
+            if (finalStatusForRole == NodeVoteStatus.PASSED || allRoleIdsCompleted) {
+                _onEntitlementCheckResultPosted(transactionId, finalStatusForRole);
+                emit EntitlementCheckResultPosted(transactionId, finalStatusForRole);
+            }
+
+            if (allRoleIdsCompleted) {
+                _removeTransaction(transactionId);
+            }
+        }
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           V2                               */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Requests a V2 entitlement check with optimized validation and execution
+    /// @param walletAddress The wallet address to check entitlements for
+    /// @param senderAddress The original sender address (encoded in extraData)
+    /// @param transactionId The unique transaction identifier
+    /// @param entitlement The entitlement contract to use for checking
+    /// @param requestId The specific request identifier
+    /// @param value The amount of ETH to send with the request (if any)
+    function _requestEntitlementCheckV2(
+        address walletAddress,
+        address senderAddress,
+        bytes32 transactionId,
+        IRuleEntitlement entitlement,
+        uint256 requestId,
+        uint256 value
+    ) internal {
+        // Validate all inputs upfront
+        _validateEntitlementCheckInputs(walletAddress, entitlement, value);
+
+        // Setup transaction state
+        EntitlementGatedStorage.Layout storage $ = EntitlementGatedStorage.layout();
+        _setupTransaction($.transactions[transactionId], entitlement);
+
+        // Execute the entitlement check request
+        _executeEntitlementCheckRequest(
+            $.entitlementChecker,
+            walletAddress,
+            transactionId,
+            requestId,
+            value,
+            abi.encode(senderAddress)
+        );
+    }
+
+    /// @notice Validates inputs for entitlement check request
+    /// @param walletAddress The wallet address being checked
+    /// @param entitlement The entitlement contract
+    /// @param value The ETH value being sent
+    function _validateEntitlementCheckInputs(
+        address walletAddress,
+        IRuleEntitlement entitlement,
+        uint256 value
+    ) private view {
+        if (value > msg.value) {
+            EntitlementGated_InvalidValue.selector.revertWith();
+        }
+        if (walletAddress == address(0)) {
+            EntitlementGated_InvalidAddress.selector.revertWith();
+        }
+        if (address(entitlement) == address(0)) {
+            EntitlementGated_InvalidEntitlement.selector.revertWith();
+        }
+    }
+
+    /// @notice Sets up transaction state for entitlement checking
+    /// @param transaction Storage reference to the transaction
+    /// @param entitlement The entitlement contract to associate
+    function _setupTransaction(
+        Transaction storage transaction,
+        IRuleEntitlement entitlement
+    ) private {
+        transaction.finalized = true;
+        transaction.entitlement = entitlement;
+    }
+
+    /// @notice Executes the entitlement check request with optimized call pattern
+    /// @param checker The entitlement checker contract
+    /// @param walletAddress The wallet address to check
+    /// @param transactionId The transaction identifier
+    /// @param requestId The request identifier
+    /// @param value The ETH value to send
+    /// @param extraData Encoded additional data
+    function _executeEntitlementCheckRequest(
+        IEntitlementChecker checker,
+        address walletAddress,
+        bytes32 transactionId,
+        uint256 requestId,
+        uint256 value,
+        bytes memory extraData
+    ) private {
+        if (value > 0) {
+            checker.requestEntitlementCheckV2{value: value}(
+                walletAddress,
+                transactionId,
+                requestId,
+                extraData
+            );
+        } else {
+            checker.requestEntitlementCheckV2(walletAddress, transactionId, requestId, extraData);
+        }
+    }
+
+    function _postEntitlementCheckResultV2(
+        bytes32 transactionId,
+        uint256,
+        NodeVoteStatus result
+    ) internal {
+        EntitlementGatedStorage.Layout storage $ = EntitlementGatedStorage.layout();
+        Transaction storage transaction = $.transactions[transactionId];
+
+        if (!transaction.finalized) {
+            EntitlementGated_TransactionNotRegistered.selector.revertWith();
+        }
+
+        emit EntitlementCheckResultPosted(transactionId, result);
+        _onEntitlementCheckResultPosted(transactionId, result);
+        _removeTransaction(transactionId);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Helpers                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _checkAllRoleIdsCompleted(bytes32 transactionId) internal view returns (bool) {
+        EntitlementGatedStorage.Layout storage ds = EntitlementGatedStorage.layout();
+
+        Transaction storage transaction = ds.transactions[transactionId];
+        uint256 roleIdsLength = transaction.roleIds.length;
+        for (uint256 i; i < roleIdsLength; ++i) {
+            if (!transaction.isCompleted[transaction.roleIds[i]]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    function _removeTransaction(bytes32 transactionId) internal {
+        EntitlementGatedStorage.Layout storage ds = EntitlementGatedStorage.layout();
+
+        Transaction storage transaction = ds.transactions[transactionId];
+        uint256 length = transaction.roleIds.length;
+        for (uint256 i; i < length; ++i) {
+            delete transaction.nodeVotesArray[transaction.roleIds[i]];
+        }
+        delete transaction.roleIds;
+        delete ds.transactions[transactionId];
+    }
+
+    function _getRuleData(
+        bytes32 transactionId,
+        uint256 roleId
+    ) internal view returns (IRuleEntitlement.RuleData memory) {
+        EntitlementGatedStorage.Layout storage ds = EntitlementGatedStorage.layout();
+
+        Transaction storage transaction = ds.transactions[transactionId];
+
+        if (!transaction.finalized) {
+            revert EntitlementGated_TransactionNotRegistered();
+        }
+
+        IRuleEntitlement re = IRuleEntitlement(address(transaction.entitlement));
+        return re.getRuleData(roleId);
+    }
+
+    function _onEntitlementCheckResultPosted(
+        bytes32 transactionId,
+        NodeVoteStatus result
+    ) internal virtual {}
+
+    // TODO: This should be removed in the future when we wipe data
+    function _setFallbackEntitlementChecker() internal {
+        EntitlementGatedStorage.Layout storage ds = EntitlementGatedStorage.layout();
+        address entitlementChecker = IImplementationRegistry(
+            MembershipStorage.layout().spaceFactory
+        ).getLatestImplementation("SpaceOperator");
+        ds.entitlementChecker = IEntitlementChecker(entitlementChecker);
+    }
+}

package/src/spaces/facets/gated/EntitlementGatedStorage.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IEntitlementGatedBase} from "./IEntitlementGated.sol";
+import {IEntitlementChecker} from "src/base/registry/facets/checker/IEntitlementChecker.sol";
+
+// libraries
+
+// contracts
+
+library EntitlementGatedStorage {
+    // keccak256(abi.encode(uint256(keccak256("facets.entitlement.gated.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x9075c515a635ba70c9696f31149324218d75cf00afe836c482e6473f38b19e00;
+
+    struct Layout {
+        IEntitlementChecker entitlementChecker;
+        mapping(bytes32 => IEntitlementGatedBase.Transaction) transactions;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            l.slot := slot
+        }
+    }
+}