@towns-protocol/contracts 0.0.302

package/src/spaces/entitlements/poap/PoapEntitlement.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+import {IPOAP} from "./IPOAP.sol";
+import {ICrossChainEntitlement} from "src/spaces/entitlements/ICrossChainEntitlement.sol";
+// libraries
+
+// contracts
+
+contract PoapEntitlement is ICrossChainEntitlement {
+    IPOAP immutable poapContract;
+
+    constructor(address poapContractAddress) {
+        poapContract = IPOAP(poapContractAddress);
+    }
+
+    function isEntitled(
+        address[] calldata users,
+        bytes calldata data
+    ) external view returns (bool) {
+        uint256 eventId = abi.decode(data, (uint256));
+
+        for (uint256 i = 0; i < users.length; i++) {
+            if (_hasEventPoap(users[i], eventId)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    function parameters() external pure returns (Parameter[] memory) {
+        Parameter[] memory schema = new Parameter[](1);
+        schema[0] = Parameter(
+            "eventId",
+            "uint256",
+            "The ID of the event associated with the POAP token"
+        );
+        return schema;
+    }
+
+    // =============================================================
+    //                           Internals
+    // =============================================================
+    function _hasEventPoap(address user, uint256 eventId) internal view returns (bool) {
+        uint256 balance = poapContract.balanceOf(user);
+        for (uint256 j = 0; j < balance; j++) {
+            (uint256 ownedEventId, ) = poapContract.tokenDetailsOfOwnerByIndex(user, j);
+            if (eventId == ownedEventId) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/src/spaces/entitlements/rule/IRuleEntitlement.sol

@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IEntitlement} from "src/spaces/entitlements/IEntitlement.sol";
+
+/**
+ * @title RuleEntitlement
+ * @dev This contract manages entitlement rules based on blockchain operations.
+ * The contract maintains a tree-like data structure to combine various types of operations.
+ * The tree is implemented as a dynamic array of 'Operation' structs, and is built in post-order
+ * fashion.
+ *
+ * Post-order Tree Structure:
+ * In a post-order binary tree, children nodes must be added before their respective parent nodes.
+ * The 'LogicalOperation' nodes refer to their child nodes via indices in the 'operations' array.
+ * As new LogicalOperation nodes are added, they can only reference existing nodes in the
+ * 'operations' array,
+ * ensuring a valid post-order tree structure.
+ */
+interface IRuleEntitlementBase {
+    // =============================================================
+    //                           Errors
+    // =============================================================
+    error CheckOperationsLimitReaced(uint256 limit);
+    error OperationsLimitReached(uint256 limit);
+    error LogicalOperationLimitReached(uint256 limit);
+    error InvalidCheckOperationIndex(uint8 operationIndex, uint8 checkOperationsLength);
+    error InvalidLogicalOperationIndex(uint8 operationIndex, uint8 logicalOperationsLength);
+    error InvalidOperationType(CombinedOperationType opType);
+    error InvalidLeftOperationIndex(uint8 leftOperationIndex, uint8 currentOperationIndex);
+    error InvalidRightOperationIndex(uint8 rightOperationIndex, uint8 currentOperationIndex);
+
+    // =============================================================
+    //                           Enums
+    // =============================================================
+    enum CheckOperationType {
+        NONE,
+        MOCK,
+        ERC20,
+        ERC721,
+        ERC1155,
+        ISENTITLED,
+        ETH_BALANCE
+    }
+
+    // Enum for Operation oneof operation_clause
+    enum LogicalOperationType {
+        NONE,
+        AND,
+        OR
+    }
+
+    // Redefined Operation struct
+    enum CombinedOperationType {
+        NONE,
+        CHECK,
+        LOGICAL
+    }
+
+    // =============================================================
+    //                           Structs
+    // =============================================================
+    struct CheckOperation {
+        CheckOperationType opType;
+        uint256 chainId;
+        address contractAddress;
+        uint256 threshold;
+    }
+
+    struct CheckOperationV2 {
+        CheckOperationType opType;
+        uint256 chainId;
+        address contractAddress;
+        bytes params;
+    }
+
+    struct LogicalOperation {
+        LogicalOperationType logOpType;
+        uint8 leftOperationIndex;
+        uint8 rightOperationIndex;
+    }
+
+    struct Operation {
+        CombinedOperationType opType;
+        uint8 index; // Index in either checkOperations or logicalOperations arrays
+    }
+
+    struct RuleData {
+        Operation[] operations;
+        CheckOperation[] checkOperations;
+        LogicalOperation[] logicalOperations;
+    }
+
+    struct RuleDataV2 {
+        Operation[] operations;
+        CheckOperationV2[] checkOperations;
+        LogicalOperation[] logicalOperations;
+    }
+
+    struct Entitlement {
+        address grantedBy;
+        uint256 grantedTime;
+        RuleData data;
+    }
+
+    struct EntitlementV2 {
+        address grantedBy;
+        uint256 grantedTime;
+        bytes data;
+    }
+
+    // Parameters are not used in contracts but are defined here for documentation purposes.
+    struct MockParams {
+        uint256 threshold; // used for testing
+    }
+
+    struct ERC20Params {
+        uint256 threshold;
+    }
+
+    struct ERC721Params {
+        uint256 threshold;
+    }
+
+    struct ERC1155Params {
+        uint256 threshold;
+        uint256 tokenId;
+    }
+
+    struct NativeCoinBalanceParams {
+        uint256 threshold;
+    }
+}
+
+interface IRuleEntitlementV2 is IRuleEntitlementBase, IEntitlement {
+    // =============================================================
+    //                           Functions
+    // =============================================================
+
+    /**
+     * @notice Encodes the RuleData struct into bytes
+     * @param data RuleData struct to encode
+     * @return Encoded bytes of the RuleData struct
+     */
+    function encodeRuleData(RuleDataV2 memory data) external pure returns (bytes memory);
+
+    /**
+     * @notice Decodes the RuleDataV2 struct from bytes
+     * @param roleId Role ID
+     * @return data RuleDataV2 struct
+     */
+    function getRuleDataV2(uint256 roleId) external view returns (RuleDataV2 memory data);
+}
+
+interface IRuleEntitlement is IRuleEntitlementBase, IEntitlement {
+    // =============================================================
+    //                           Functions
+    // =============================================================
+
+    /**
+     * @notice Encodes the RuleData struct into bytes
+     * @param data RuleData struct to encode
+     * @return Encoded bytes of the RuleData struct
+     */
+    function encodeRuleData(RuleData memory data) external pure returns (bytes memory);
+
+    /**
+     * @notice Decodes the RuleData struct from bytes
+     * @param roleId Role ID
+     * @return data RuleData struct
+     */
+    function getRuleData(uint256 roleId) external view returns (RuleData memory data);
+}

package/src/spaces/entitlements/rule/RuleEntitlement.sol

@@ -0,0 +1,183 @@
+// SPDX-License-Identifier: MIT
+
+/**
+ * @title EntitlementRule
+ * @dev This contract manages entitlement rules based on blockchain operations.
+ * The contract maintains a tree-like data structure to combine various types of operations.
+ * The tree is implemented as a dynamic array of 'Operation' structs, and is built in post-order
+ * fashion.
+ *
+ * Post-order Tree Structure:
+ * In a post-order binary tree, children nodes must be added before their respective parent nodes.
+ * The 'LogicalOperation' nodes refer to their child nodes via indices in the 'operations' array.
+ * As new LogicalOperation nodes are added, they can only reference existing nodes in the
+ * 'operations' array,
+ * ensuring a valid post-order tree structure.
+ */
+pragma solidity ^0.8.0;
+
+// contracts
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {ContextUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
+import {ERC165Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
+
+// libraries
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+// interfaces
+
+import {IRuleEntitlement} from "./IRuleEntitlement.sol";
+import {IEntitlement} from "src/spaces/entitlements/IEntitlement.sol";
+
+contract RuleEntitlement is
+    Initializable,
+    ERC165Upgradeable,
+    ContextUpgradeable,
+    UUPSUpgradeable,
+    IRuleEntitlement
+{
+    using EnumerableSet for EnumerableSet.Bytes32Set;
+
+    mapping(uint256 => Entitlement) internal entitlementsByRoleId;
+
+    address public SPACE_ADDRESS;
+
+    string public constant name = "Rule Entitlement";
+    string public constant description = "Entitlement for crosschain rules";
+    string public constant moduleType = "RuleEntitlement";
+
+    // Separate storage arrays for CheckOperation and LogicalOperation
+    //CheckOperation[] private checkOperations;
+    //LogicalOperation[] private logicalOperations;
+
+    // Dynamic array to store Operation instances
+    //Operation[] private operations;
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(address _space) public initializer {
+        __UUPSUpgradeable_init();
+        __ERC165_init();
+        __Context_init();
+
+        SPACE_ADDRESS = _space;
+    }
+
+    modifier onlySpace() {
+        if (_msgSender() != SPACE_ADDRESS) {
+            revert Entitlement__NotAllowed();
+        }
+        _;
+    }
+
+    /// @notice allow the contract to be upgraded while retaining state
+    /// @param newImplementation address of the new implementation
+    function _authorizeUpgrade(address newImplementation) internal override onlySpace {}
+
+    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+        return
+            interfaceId == type(IEntitlement).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    // @inheritdoc IEntitlement
+    function isCrosschain() external pure override returns (bool) {
+        // TODO possible optimization: return false if no crosschain operations
+        return true;
+    }
+
+    // @inheritdoc IEntitlement
+    function isEntitled(
+        bytes32, //channelId,
+        address[] memory, //user,
+        bytes32 //permission
+    ) external pure returns (bool) {
+        // TODO possible optimization: if there are no crosschain operations, evaluate locally
+        return false;
+    }
+
+    // @inheritdoc IEntitlement
+    function setEntitlement(uint256 roleId, bytes calldata entitlementData) external onlySpace {
+        if (entitlementData.length == 0) return;
+
+        // equivalent: abi.decode(entitlementData, (RuleData))
+        RuleData calldata data;
+        assembly {
+            // this is a variable length struct, so calldataload(entitlementData.offset) contains
+            // the
+            // offset from entitlementData.offset at which the struct begins
+            data := add(entitlementData.offset, calldataload(entitlementData.offset))
+        }
+
+        if (data.operations.length == 0) return;
+
+        // Cache lengths of operations arrays to reduce state access cost
+        uint256 operationsLength = data.operations.length;
+        uint256 checkOperationsLength = data.checkOperations.length;
+        uint256 logicalOperationsLength = data.logicalOperations.length;
+
+        // Step 1: Validate Operation against CheckOperation and LogicalOperation
+        for (uint256 i; i < operationsLength; ++i) {
+            CombinedOperationType opType = data.operations[i].opType; // cache the operation type
+            uint8 index = data.operations[i].index; // cache the operation index
+
+            if (opType == CombinedOperationType.CHECK) {
+                if (index >= checkOperationsLength) {
+                    revert InvalidCheckOperationIndex(index, uint8(checkOperationsLength));
+                }
+            } else if (opType == CombinedOperationType.LOGICAL) {
+                // Use custom error in revert statement
+                if (index >= logicalOperationsLength) {
+                    revert InvalidLogicalOperationIndex(index, uint8(logicalOperationsLength));
+                }
+
+                // Verify the logical operations make a DAG
+                LogicalOperation calldata logicalOp = data.logicalOperations[index];
+                uint8 leftOperationIndex = logicalOp.leftOperationIndex;
+                uint8 rightOperationIndex = logicalOp.rightOperationIndex;
+
+                // Use custom errors in revert statements
+                if (leftOperationIndex >= i) {
+                    revert InvalidLeftOperationIndex(leftOperationIndex, uint8(i));
+                }
+
+                if (rightOperationIndex >= i) {
+                    revert InvalidRightOperationIndex(rightOperationIndex, uint8(i));
+                }
+            }
+        }
+
+        Entitlement storage entitlement = entitlementsByRoleId[roleId];
+        entitlement.grantedBy = _msgSender();
+        entitlement.grantedTime = block.timestamp;
+        entitlement.data = data;
+    }
+
+    // @inheritdoc IEntitlement
+    function removeEntitlement(uint256 roleId) external onlySpace {
+        Entitlement storage entitlement = entitlementsByRoleId[roleId];
+        if (entitlement.grantedBy == address(0)) {
+            revert Entitlement__InvalidValue();
+        }
+
+        delete entitlementsByRoleId[roleId];
+    }
+
+    // @inheritdoc IEntitlement
+    function getEntitlementDataByRoleId(uint256 roleId) external view returns (bytes memory) {
+        Entitlement storage entitlement = entitlementsByRoleId[roleId];
+        return abi.encode(entitlement.data);
+    }
+
+    function encodeRuleData(RuleData calldata data) external pure returns (bytes memory) {
+        return abi.encode(data);
+    }
+
+    function getRuleData(uint256 roleId) external view returns (RuleData memory data) {
+        return entitlementsByRoleId[roleId].data;
+    }
+}

package/src/spaces/entitlements/rule/RuleEntitlementV2.sol

@@ -0,0 +1,219 @@
+// SPDX-License-Identifier: MIT
+
+/**
+ * @title RuleEntitlementV2
+ * @dev This contract manages entitlement rules based on blockchain operations.
+ * The contract maintains a tree-like data structure to combine various types of operations.
+ * The tree is implemented as a dynamic array of 'Operation' structs, and is built in post-order
+ * fashion.
+ *
+ * Post-order Tree Structure:
+ * In a post-order binary tree, children nodes must be added before their respective parent nodes.
+ * The 'LogicalOperation' nodes refer to their child nodes via indices in the 'operations' array.
+ * As new LogicalOperation nodes are added, they can only reference existing nodes in the
+ * 'operations' array,
+ * ensuring a valid post-order tree structure.
+ */
+pragma solidity ^0.8.0;
+
+// contracts
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {ContextUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
+import {ERC165Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
+
+// libraries
+
+// interfaces
+
+import {IRuleEntitlementV2} from "./IRuleEntitlement.sol";
+import {IEntitlement} from "src/spaces/entitlements/IEntitlement.sol";
+
+contract RuleEntitlementV2 is
+    Initializable,
+    ERC165Upgradeable,
+    ContextUpgradeable,
+    UUPSUpgradeable,
+    IRuleEntitlementV2
+{
+    mapping(uint256 => Entitlement) internal entitlementsByRoleId;
+    address public SPACE_ADDRESS;
+
+    // TODO: abstract to a base contract
+    // keccak256(abi.encode(uint256(keccak256("spaces.entitlements.rule.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 private constant STORAGE_SLOT =
+        0xa7ba26993e5aed586ba0b4d511980a49b23ea33e13d5f0920b7e42ae1a27cc00;
+
+    // @custom:storage-location erc7201:spaces.entitlements.rule.storage
+    struct Layout {
+        mapping(uint256 => EntitlementV2) entitlementsByRoleIdV2;
+    }
+
+    string public constant name = "Rule Entitlement V2";
+    string public constant description = "Entitlement for crosschain rules";
+    string public constant moduleType = "RuleEntitlementV2";
+    bool public constant isCrosschain = true;
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(address _space) public initializer {
+        __UUPSUpgradeable_init();
+        __ERC165_init();
+        __Context_init();
+        SPACE_ADDRESS = _space;
+    }
+
+    modifier onlySpace() {
+        if (_msgSender() != SPACE_ADDRESS) {
+            revert Entitlement__NotAllowed();
+        }
+        _;
+    }
+
+    // =============================================================
+    //                           Admin
+    // =============================================================
+
+    /// @notice allow the contract to be upgraded while retaining state
+    /// @param newImplementation address of the new implementation
+    function _authorizeUpgrade(address newImplementation) internal override onlySpace {}
+
+    /// @notice get the storage slot for the contract
+    /// @return ds storage slot
+    function layout() internal pure returns (Layout storage ds) {
+        assembly {
+            ds.slot := STORAGE_SLOT
+        }
+    }
+
+    // =============================================================
+    //                           External
+    // =============================================================
+
+    function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
+        return
+            interfaceId == type(IEntitlement).interfaceId ||
+            interfaceId == type(IRuleEntitlementV2).interfaceId ||
+            super.supportsInterface(interfaceId);
+    }
+
+    // @inheritdoc IEntitlement
+    function isEntitled(bytes32, address[] memory, bytes32) external pure returns (bool) {
+        return false;
+    }
+
+    // @inheritdoc IEntitlement
+    function setEntitlement(uint256 roleId, bytes calldata entitlementData) external onlySpace {
+        _removeRuleDataV1(roleId);
+
+        // We should never allow the setting of empty rule datas because it can cause the xchain
+        // architecture to be invoked when by default a user is not entitled.
+        if (entitlementData.length == 0) {
+            revert Entitlement__InvalidValue();
+        }
+
+        // equivalent: abi.decode(entitlementData, (RuleDataV2))
+        RuleDataV2 calldata data;
+        assembly {
+            // this is a variable length struct, so calldataload(entitlementData.offset) contains
+            // the
+            // offset from entitlementData.offset at which the struct begins
+            data := add(entitlementData.offset, calldataload(entitlementData.offset))
+        }
+
+        // We should never allow the setting of empty rule datas because it can cause the xchain
+        // architecture to be invoked when by default a user is not entitled.
+        if (data.operations.length == 0) {
+            revert Entitlement__InvalidValue();
+        }
+
+        // Cache lengths of operations arrays to reduce state access cost
+        uint256 operationsLength = data.operations.length;
+        uint256 checkOperationsLength = data.checkOperations.length;
+        uint256 logicalOperationsLength = data.logicalOperations.length;
+
+        // Step 1: Validate Operation against CheckOperation and LogicalOperation
+        for (uint256 i; i < operationsLength; ++i) {
+            CombinedOperationType opType = data.operations[i].opType; // cache the operation type
+            uint8 index = data.operations[i].index; // cache the operation index
+
+            if (opType == CombinedOperationType.CHECK) {
+                if (index >= checkOperationsLength) {
+                    revert InvalidCheckOperationIndex(index, uint8(checkOperationsLength));
+                }
+            } else if (opType == CombinedOperationType.LOGICAL) {
+                // Use custom error in revert statement
+                if (index >= logicalOperationsLength) {
+                    revert InvalidLogicalOperationIndex(index, uint8(logicalOperationsLength));
+                }
+
+                // Verify the logical operations make a DAG
+                LogicalOperation calldata logicalOp = data.logicalOperations[index];
+                uint8 leftOperationIndex = logicalOp.leftOperationIndex;
+                uint8 rightOperationIndex = logicalOp.rightOperationIndex;
+
+                // Use custom errors in revert statements
+                if (leftOperationIndex >= i) {
+                    revert InvalidLeftOperationIndex(leftOperationIndex, uint8(i));
+                }
+
+                if (rightOperationIndex >= i) {
+                    revert InvalidRightOperationIndex(rightOperationIndex, uint8(i));
+                }
+            }
+        }
+
+        EntitlementV2 storage entitlement = layout().entitlementsByRoleIdV2[roleId];
+        entitlement.grantedBy = _msgSender();
+        entitlement.grantedTime = block.timestamp;
+        entitlement.data = entitlementData;
+    }
+
+    // @inheritdoc IEntitlement
+    function removeEntitlement(uint256 roleId) external onlySpace {
+        Layout storage ds = layout();
+        EntitlementV2 storage entitlement = ds.entitlementsByRoleIdV2[roleId];
+
+        if (entitlement.grantedBy == address(0)) {
+            revert Entitlement__InvalidValue();
+        }
+
+        delete ds.entitlementsByRoleIdV2[roleId];
+    }
+
+    // @inheritdoc IEntitlement
+    function getEntitlementDataByRoleId(uint256 roleId) external view returns (bytes memory) {
+        EntitlementV2 storage entitlement = layout().entitlementsByRoleIdV2[roleId];
+        return entitlement.data;
+    }
+
+    function encodeRuleData(RuleDataV2 calldata data) external pure returns (bytes memory) {
+        return abi.encode(data);
+    }
+
+    function getRuleData(uint256 roleId) external view returns (RuleData memory data) {
+        return entitlementsByRoleId[roleId].data;
+    }
+
+    function getRuleDataV2(uint256 roleId) external view returns (RuleDataV2 memory data) {
+        bytes storage ruleData = layout().entitlementsByRoleIdV2[roleId].data;
+
+        if (ruleData.length == 0) return data;
+
+        return abi.decode(ruleData, (RuleDataV2));
+    }
+
+    // =============================================================
+    //                           Internal
+    // =============================================================
+    function _removeRuleDataV1(uint256 roleId) internal {
+        if (entitlementsByRoleId[roleId].grantedBy != address(0)) {
+            delete entitlementsByRoleId[roleId];
+        }
+    }
+}

package/src/spaces/entitlements/user/IUserEntitlement.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {IEntitlement} from "src/spaces/entitlements/IEntitlement.sol";
+
+interface IUserEntitlement is IEntitlement {
+    // Constructor is not included in interfaces
+
+    // Initialize function, if it's intended to be called externally
+    function initialize(address _space) external;
+
+    // Any other external or public functions
+    function isEntitled(
+        bytes32 channelId,
+        address[] memory wallets,
+        bytes32 permission
+    ) external view returns (bool);
+
+    function setEntitlement(uint256 roleId, bytes calldata entitlementData) external;
+
+    function removeEntitlement(uint256 roleId) external;
+
+    function getEntitlementDataByRoleId(uint256 roleId) external view returns (bytes memory);
+}