@towns-protocol/contracts 0.0.450 → 0.0.451

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towns-protocol/contracts",
-  "version": "0.0.450",
+  "version": "0.0.451",
   "scripts": {
     "clean": "forge clean",
     "compile": "forge build",
@@ -33,7 +33,7 @@
     "@layerzerolabs/oapp-evm": "^0.3.2",
     "@openzeppelin/merkle-tree": "^1.0.8",
     "@prb/test": "^0.6.4",
-    "@towns-protocol/prettier-config": "^0.0.450",
+    "@towns-protocol/prettier-config": "^0.0.451",
     "@wagmi/cli": "^2.2.0",
     "forge-std": "github:foundry-rs/forge-std#v1.10.0",
     "prettier": "^3.5.3",
@@ -50,5 +50,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "cbbeb47f3b927004f889268ab727858eab3f1cf9"
+  "gitHead": "ad68c0f2514e44f51293824ebba5ccc2f8a6494c"
 }

package/src/base/registry/facets/checker/EntitlementChecker.sol

@@ -19,26 +19,23 @@ import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
 
 contract EntitlementChecker is IEntitlementChecker, Facet {
     using EnumerableSet for EnumerableSet.AddressSet;
-    using EnumerableSet for EnumerableSet.UintSet;
     using EnumerableSet for EnumerableSet.Bytes32Set;
+    using EnumerableSet for EnumerableSet.UintSet;
     using CustomRevert for bytes4;
     using SafeTransferLib for address;
 
-    // =============================================================
-    //                           Initializer
-    // =============================================================
-
     function __EntitlementChecker_init() external onlyInitializing {
         _addInterface(type(IEntitlementChecker).interfaceId);
     }
 
-    // =============================================================
-    //                           Modifiers
-    // =============================================================
-    modifier onlyNodeOperator(address node, address operator) {
-        EntitlementCheckerStorage.Layout storage layout = EntitlementCheckerStorage.layout();
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        MODIFIERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
-        if (layout.operatorByNode[node] != operator) {
+    modifier onlyNodeOperator(address node) {
+        EntitlementCheckerStorage.Layout storage $ = EntitlementCheckerStorage.layout();
+
+        if (msg.sender != $.operatorByNode[node]) {
             EntitlementChecker_InvalidNodeOperator.selector.revertWith();
         }
         _;
@@ -50,95 +47,73 @@ contract EntitlementChecker is IEntitlementChecker, Facet {
         if (!nodeOperatorLayout.operators.contains(msg.sender)) {
             EntitlementChecker_InvalidOperator.selector.revertWith();
         }
-        _;
-
         if (nodeOperatorLayout.statusByOperator[msg.sender] != NodeOperatorStatus.Approved) {
             EntitlementChecker_OperatorNotActive.selector.revertWith();
         }
+        _;
     }
 
-    // =============================================================
-    //                           External
-    // =============================================================
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       ADMIN FUNCTIONS                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
     /// @inheritdoc IEntitlementChecker
     function registerNode(address node) external onlyRegisteredApprovedOperator {
-        EntitlementCheckerStorage.Layout storage layout = EntitlementCheckerStorage.layout();
+        EntitlementCheckerStorage.Layout storage $ = EntitlementCheckerStorage.layout();
 
-        if (layout.nodes.contains(node)) {
+        if ($.nodes.contains(node)) {
             EntitlementChecker_NodeAlreadyRegistered.selector.revertWith();
         }
 
-        layout.nodes.add(node);
-        layout.operatorByNode[node] = msg.sender;
+        $.nodes.add(node);
+        $.operatorByNode[node] = msg.sender;
 
         emit NodeRegistered(node);
     }
 
     /// @inheritdoc IEntitlementChecker
-    function unregisterNode(address node) external onlyNodeOperator(node, msg.sender) {
-        EntitlementCheckerStorage.Layout storage layout = EntitlementCheckerStorage.layout();
+    function unregisterNode(address node) external onlyNodeOperator(node) {
+        EntitlementCheckerStorage.Layout storage $ = EntitlementCheckerStorage.layout();
 
-        if (!layout.nodes.contains(node)) {
+        if (!$.nodes.contains(node)) {
             EntitlementChecker_NodeNotRegistered.selector.revertWith();
         }
 
-        layout.nodes.remove(node);
-        delete layout.operatorByNode[node];
+        $.nodes.remove(node);
+        delete $.operatorByNode[node];
 
         emit NodeUnregistered(node);
     }
 
-    /// @inheritdoc IEntitlementChecker
-    function isValidNode(address node) external view returns (bool) {
-        EntitlementCheckerStorage.Layout storage layout = EntitlementCheckerStorage.layout();
-        return layout.nodes.contains(node);
-    }
-
-    /// @inheritdoc IEntitlementChecker
-    function getNodeCount() external view returns (uint256) {
-        EntitlementCheckerStorage.Layout storage layout = EntitlementCheckerStorage.layout();
-        return layout.nodes.length();
-    }
-
-    /// @inheritdoc IEntitlementChecker
-    function getNodeAtIndex(uint256 index) external view returns (address) {
-        EntitlementCheckerStorage.Layout storage layout = EntitlementCheckerStorage.layout();
-
-        require(index < layout.nodes.length(), "Index out of bounds");
-        return layout.nodes.at(index);
-    }
-
-    /// @inheritdoc IEntitlementChecker
-    function getRandomNodes(uint256 count) external view returns (address[] memory) {
-        return _getRandomNodes(count);
-    }
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         ENTITLEMENT                        */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
     /// @inheritdoc IEntitlementChecker
     function requestEntitlementCheck(
-        address walletAddress,
+        address receiver,
         bytes32 transactionId,
         uint256 roleId,
         address[] memory nodes
     ) external {
-        emit EntitlementCheckRequested(walletAddress, msg.sender, transactionId, roleId, nodes);
+        emit EntitlementCheckRequested(receiver, msg.sender, transactionId, roleId, nodes);
     }
 
     /// @inheritdoc IEntitlementChecker
     function requestEntitlementCheckV2(
-        address walletAddress,
+        address receiver,
         bytes32 transactionId,
         uint256 requestId,
         bytes memory extraData
     ) external payable {
-        address senderAddress = abi.decode(extraData, (address));
+        address sender = abi.decode(extraData, (address));
         _requestEntitlementCheck(
-            walletAddress,
+            receiver,
             transactionId,
             requestId,
             CurrencyTransfer.NATIVE_TOKEN,
             msg.value,
-            senderAddress
+            sender
         );
     }
 
@@ -146,68 +121,104 @@ contract EntitlementChecker is IEntitlementChecker, Facet {
     function requestEntitlementCheck(CheckType checkType, bytes calldata data) external payable {
         if (checkType == CheckType.V1) {
             if (msg.value != 0) EntitlementChecker_InvalidValue.selector.revertWith();
-            (
-                address walletAddress,
-                bytes32 transactionId,
-                uint256 roleId,
-                address[] memory nodes
-            ) = abi.decode(data, (address, bytes32, uint256, address[]));
-            emit EntitlementCheckRequested(walletAddress, msg.sender, transactionId, roleId, nodes);
+            (address receiver, bytes32 transactionId, uint256 roleId, address[] memory nodes) = abi
+                .decode(data, (address, bytes32, uint256, address[]));
+            emit EntitlementCheckRequested(receiver, msg.sender, transactionId, roleId, nodes);
         } else if (checkType == CheckType.V2) {
             (
-                address walletAddress,
+                address receiver,
                 bytes32 transactionId,
                 uint256 requestId,
                 bytes memory extraData
             ) = abi.decode(data, (address, bytes32, uint256, bytes));
-            address senderAddress = abi.decode(extraData, (address));
+            address sender = abi.decode(extraData, (address));
             _requestEntitlementCheck(
-                walletAddress,
+                receiver,
                 transactionId,
                 requestId,
                 CurrencyTransfer.NATIVE_TOKEN,
                 msg.value,
-                senderAddress
+                sender
             );
         } else if (checkType == CheckType.V3) {
             (
-                address walletAddress,
+                address receiver,
                 bytes32 transactionId,
                 uint256 requestId,
                 address currency,
                 uint256 amount,
-                address senderAddress
+                address sender
             ) = abi.decode(data, (address, bytes32, uint256, address, uint256, address));
-            _requestEntitlementCheck(
-                walletAddress,
-                transactionId,
-                requestId,
-                currency,
-                amount,
-                senderAddress
-            );
+            _requestEntitlementCheck(receiver, transactionId, requestId, currency, amount, sender);
         } else {
             EntitlementChecker_InvalidCheckType.selector.revertWith();
         }
     }
 
-    // =============================================================
-    //                           Internal
-    // =============================================================
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IEntitlementChecker
+    function isValidNode(address node) external view returns (bool) {
+        return EntitlementCheckerStorage.layout().nodes.contains(node);
+    }
+
+    /// @inheritdoc IEntitlementChecker
+    function getNodeCount() external view returns (uint256) {
+        return EntitlementCheckerStorage.layout().nodes.length();
+    }
+
+    /// @inheritdoc IEntitlementChecker
+    function getNodeAtIndex(uint256 index) external view returns (address) {
+        EntitlementCheckerStorage.Layout storage $ = EntitlementCheckerStorage.layout();
+
+        require(index < $.nodes.length(), "Index out of bounds");
+        return $.nodes.at(index);
+    }
+
+    /// @inheritdoc IEntitlementChecker
+    function getRandomNodes(uint256 count) external view returns (address[] memory) {
+        return _getRandomNodes(count);
+    }
+
+    /// @inheritdoc IEntitlementChecker
+    function getNodesByOperator(address operator) external view returns (address[] memory nodes) {
+        EntitlementCheckerStorage.Layout storage $ = EntitlementCheckerStorage.layout();
+        address[] memory allNodes = $.nodes.values();
+        uint256 totalNodeCount = allNodes.length;
+        nodes = new address[](totalNodeCount);
+        uint256 nodeCount;
+        for (uint256 i; i < totalNodeCount; ++i) {
+            address node = allNodes[i];
+            if ($.operatorByNode[node] == operator) {
+                unchecked {
+                    nodes[nodeCount++] = node;
+                }
+            }
+        }
+        assembly ("memory-safe") {
+            mstore(nodes, nodeCount)
+        }
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          INTERNAL                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
 
     function _requestEntitlementCheck(
-        address walletAddress,
+        address receiver,
         bytes32 transactionId,
         uint256 requestId,
         address currency,
         uint256 amount,
-        address senderAddress
+        address sender
     ) internal {
         address space = msg.sender;
 
         XChainLib.Layout storage layout = XChainLib.layout();
 
-        layout.requestsBySender[senderAddress].add(transactionId);
+        layout.requestsBySender[sender].add(transactionId);
 
         // Only create the request if it doesn't exist yet
         XChainLib.Request storage request = layout.requests[transactionId];
@@ -215,7 +226,7 @@ contract EntitlementChecker is IEntitlementChecker, Facet {
             request.caller = space;
             request.blockNumber = block.number;
             request.value = amount;
-            request.receiver = walletAddress;
+            request.receiver = receiver;
             request.currency = currency;
 
             if (currency == CurrencyTransfer.NATIVE_TOKEN) {
@@ -252,7 +263,7 @@ contract EntitlementChecker is IEntitlementChecker, Facet {
         }
 
         emit EntitlementCheckRequestedV2(
-            walletAddress,
+            receiver,
             space,
             address(this),
             transactionId,
@@ -261,36 +272,12 @@ contract EntitlementChecker is IEntitlementChecker, Facet {
         );
     }
 
-    /// @inheritdoc IEntitlementChecker
-    function getNodesByOperator(address operator) external view returns (address[] memory nodes) {
-        EntitlementCheckerStorage.Layout storage layout = EntitlementCheckerStorage.layout();
-        uint256 totalNodeCount = layout.nodes.length();
-        nodes = new address[](totalNodeCount);
-        uint256 nodeCount;
-        for (uint256 i; i < totalNodeCount; ++i) {
-            address node = layout.nodes.at(i);
-            if (layout.operatorByNode[node] == operator) {
-                unchecked {
-                    nodes[nodeCount++] = node;
-                }
-            }
-        }
-        assembly ("memory-safe") {
-            mstore(nodes, nodeCount) // Update the length of the array
-        }
-    }
-
-    // =============================================================
-    //                           Internal
-    // =============================================================
     function _getRandomNodes(uint256 count) internal view returns (address[] memory randomNodes) {
-        EntitlementCheckerStorage.Layout storage layout = EntitlementCheckerStorage.layout();
+        EntitlementCheckerStorage.Layout storage $ = EntitlementCheckerStorage.layout();
 
-        uint256 nodeCount = layout.nodes.length();
+        uint256 nodeCount = $.nodes.length();
 
-        if (count > nodeCount) {
-            EntitlementChecker_InsufficientNumberOfNodes.selector.revertWith();
-        }
+        if (count > nodeCount) EntitlementChecker_InsufficientNumberOfNodes.selector.revertWith();
 
         randomNodes = new address[](count);
         uint256[] memory indices = new uint256[](nodeCount);
@@ -303,7 +290,7 @@ contract EntitlementChecker is IEntitlementChecker, Facet {
             for (uint256 i; i < count; ++i) {
                 // Adjust random function to generate within range 0 to n-1
                 uint256 rand = _pseudoRandom(i, nodeCount);
-                randomNodes[i] = layout.nodes.at(indices[rand]);
+                randomNodes[i] = $.nodes.at(indices[rand]);
                 // Move the last element to the used slot and reduce the pool size
                 indices[rand] = indices[--nodeCount];
             }

package/src/base/registry/facets/checker/IEntitlementChecker.sol

@@ -6,12 +6,12 @@ interface IEntitlementCheckerBase {
     /// @dev To encode data for each type:
     ///   switch (checkType) {
     ///     case CheckType.V1:
-    ///       data = abi.encode(walletAddress, transactionId, roleId, nodes);
+    ///       data = abi.encode(receiver, transactionId, roleId, nodes);
     ///     case CheckType.V2:
-    ///       data = abi.encode(walletAddress, transactionId, requestId, extraData);
-    ///       // where extraData = abi.encode(senderAddress)
+    ///       data = abi.encode(receiver, transactionId, requestId, extraData);
+    ///       // where extraData = abi.encode(sender)
     ///     case CheckType.V3:
-    ///       data = abi.encode(walletAddress, transactionId, requestId, currency, amount, senderAddress);
+    ///       data = abi.encode(receiver, transactionId, requestId, currency, amount, sender);
     ///   }
     enum CheckType {
         V1, // Legacy check with explicit nodes
@@ -38,17 +38,17 @@ interface IEntitlementCheckerBase {
 
     /// @notice Event emitted when an entitlement check is requested
     event EntitlementCheckRequested(
-        address callerAddress,
-        address contractAddress,
+        address receiver,
+        address space,
         bytes32 transactionId,
         uint256 roleId,
         address[] selectedNodes
     );
 
     event EntitlementCheckRequestedV2(
-        address walletAddress,
-        address spaceAddress,
-        address resolverAddress,
+        address receiver,
+        address space,
+        address resolver,
         bytes32 transactionId,
         uint256 roleId,
         address[] selectedNodes
@@ -64,44 +64,25 @@ interface IEntitlementChecker is IEntitlementCheckerBase {
     /// @param node The address of the node to unregister
     function unregisterNode(address node) external;
 
-    /// @notice Check if a node address is registered and valid
-    /// @param node The address of the node to check
-    /// @return bool True if the node is valid, false otherwise
-    function isValidNode(address node) external view returns (bool);
-
-    /// @notice Get the total number of registered nodes
-    /// @return uint256 The count of registered nodes
-    function getNodeCount() external view returns (uint256);
-
-    /// @notice Get the node address at a specific index
-    /// @param index The index of the node to retrieve
-    /// @return address The address of the node at the given index
-    function getNodeAtIndex(uint256 index) external view returns (address);
-
-    /// @notice Get a random selection of registered nodes
-    /// @param count The number of random nodes to return
-    /// @return address[] Array of randomly selected node addresses
-    function getRandomNodes(uint256 count) external view returns (address[] memory);
-
     /// @notice Request an entitlement check for a transaction
-    /// @param callerAddress The address initiating the check
+    /// @param receiver The address to check entitlements for (membership recipient)
     /// @param transactionId The unique identifier of the transaction
     /// @param roleId The role ID to check entitlements against
     /// @param nodes Array of node addresses that will perform the check
     function requestEntitlementCheck(
-        address callerAddress,
+        address receiver,
         bytes32 transactionId,
         uint256 roleId,
         address[] memory nodes
     ) external;
 
     /// @notice Request an entitlement check with additional data (V2)
-    /// @param walletAddress The wallet address to check entitlements for
+    /// @param receiver The address to check entitlements for (membership recipient)
     /// @param transactionId The unique identifier of the transaction
     /// @param requestId The unique identifier for this specific request
     /// @param extraData Additional data required for the check
     function requestEntitlementCheckV2(
-        address walletAddress,
+        address receiver,
         bytes32 transactionId,
         uint256 requestId,
         bytes memory extraData
@@ -112,6 +93,25 @@ interface IEntitlementChecker is IEntitlementCheckerBase {
     /// @param data Encoded parameters specific to the check type (see CheckType enum docs)
     function requestEntitlementCheck(CheckType checkType, bytes calldata data) external payable;
 
+    /// @notice Check if a node address is registered and valid
+    /// @param node The address of the node to check
+    /// @return bool True if the node is valid, false otherwise
+    function isValidNode(address node) external view returns (bool);
+
+    /// @notice Get the total number of registered nodes
+    /// @return uint256 The count of registered nodes
+    function getNodeCount() external view returns (uint256);
+
+    /// @notice Get the node address at a specific index
+    /// @param index The index of the node to retrieve
+    /// @return address The address of the node at the given index
+    function getNodeAtIndex(uint256 index) external view returns (address);
+
+    /// @notice Get a random selection of registered nodes
+    /// @param count The number of random nodes to return
+    /// @return address[] Array of randomly selected node addresses
+    function getRandomNodes(uint256 count) external view returns (address[] memory);
+
     /// @notice Get all nodes registered to a specific operator
     /// @param operator The address of the operator
     /// @return address[] Array of node addresses registered to the operator