ERC-7777: 人机社会治理

interface IUniversalIdentity {

    /// @notice 硬件身份的结构体
    struct HardwareIdentity {
        bytes32 publicKey;            // 硬件绑定的公钥，唯一绑定到此机器人
        string manufacturer;           // 机器人制造商的标识符
        string operator;               // 机器人运营商的标识符
        string model;                  // 机器人的模型标识符
        string serialNumber;           // 机器人的唯一序列号
        bytes32 initialHashSignature;  // 根密钥对初始系统状态哈希（例如，固件、操作系统）的签名
        bytes32 currentHashSignature;  // 根密钥对最新状态哈希的签名，定期更新以进行完整性验证
    }

    /// @notice 获取硬件身份信息
    /// @return HardwareIdentity 当前硬件身份
    function getHardwareIdentity() external view returns (HardwareIdentity memory);

    /// @notice 为硬件验证生成新的挑战
    /// @return bytes32 需要签名的随机挑战
    function generateChallenge() external returns (bytes32);
  
    /// @notice 验证对特定挑战的响应
    /// @param challenge 已发布的挑战
    /// @param signature 挑战的硬件签名
    /// @return bool 如果签名对该挑战有效，则为 True
    function verifyChallenge(bytes32 challenge, bytes memory signature) external returns (bool);

    /// @notice 向机器人的身份添加规则，表明机器人同意遵守该规则。
    /// @param rule 表示机器人同意遵守的规则的动态字节数组。 每个规则都是编码为动态字节数组的文本字符串。 例如：“机器人必须与人类保持 1 米的距离。”
    /// @dev 该规则应来自机器人打算加入的 IUniversalCharter 合约中定义的规则集。
    /// @dev 此函数应由合约实现，以添加机器人打算遵守的规则。
    function addRule(bytes memory rule) external;

    /// @notice 从机器人的身份中删除规则。
    /// @param rule 表示机器人不再同意遵守的规则的动态字节数组。
    /// @dev 此函数应由合约实现，以删除机器人不打算遵守的规则。
    function removeRule(bytes memory rule) external;

    /// @notice 检查机器人是否符合特定规则。
    /// @param rule 要检查的规则。
    /// @return bool 如果机器人符合规则，则返回 true。
    /// @dev 此函数必须由合约实现以进行合规性验证。
    function checkCompliance(bytes memory rule) external view returns (bool);

    /// @dev 当规则添加到机器人的身份时发出。
    event RuleAdded(bytes rule);

    /// @dev 当规则从机器人的身份中删除时发出。
    event RuleRemoved(bytes rule);
  
    /// @dev 订阅章程时发出。
    event SubscribedToCharter(address indexed charter);

    /// @dev 从章程取消订阅时发出。
    event UnsubscribedFromCharter(address indexed charter);
}

interface IUniversalCharter {

    // 将用户类型定义为枚举。
    enum UserType { Human, Robot }

    /// @notice 注册用户（人类或机器人）通过同意规则集加入系统。
    /// @param userType 用户的类型。
    /// @param ruleSet 用户同意遵守的单个规则数组。
    /// @dev 使用此接口的合约必须实现此函数。
    /// @dev 实现合约必须通过调用 `checkCompliance` 来确保用户在系统中注册之前符合指定的规则集。
    function registerUser(UserType userType, bytes[] memory ruleSet) external;

    /// @notice 允许用户（人类或机器人）离开系统
    /// @dev 此函数必须只能由用户自己（通过 `msg.sender`）调用。
    /// @dev 实现合约必须通过调用 `checkCompliance` 来确保用户在成功离开系统之前已遵守所有必要的规则。
    function leaveSystem() external;

    /// @notice 检查用户（人类或机器人）是否符合系统的规则。
    /// @param user 用户（人类或机器人）的地址。
    /// @param ruleSet 要验证的单个规则数组。
    /// @return bool 如果用户符合规则集，则返回 true。
    /// @dev 此函数应调用用户的 IUniversalIdentity 合约的 `checkCompliance` 函数来单独检查规则。
    /// @dev 此函数必须由合约实现以进行合规性验证。
    function checkCompliance(address user, bytes[] memory ruleSet) external view returns (bool);

    /// @notice 更新规则集。
    /// @param newRuleSet 替换现有规则的新单个规则数组。
    /// @dev 此函数应仅限于授权用户（例如，合约所有者）。
    function updateRuleSet(bytes[] memory newRuleSet) external;

    /// @notice 终止合约，阻止任何进一步的注册或交互。
    /// @dev 此函数应仅限于授权用户（例如，合约所有者）。
    /// @dev 合约应实现此函数。
    function terminateContract() external;

    /// @dev 当用户通过同意一组规则加入系统时发出。
    event UserRegistered(address indexed user, UserType userType, bytes[] ruleSet);

    /// @dev 当用户在履行义务后成功离开系统时发出。
    event UserLeft(address indexed user);

    /// @dev 当用户的规则集合规性得到验证时发出。
    event ComplianceChecked(address indexed user, bytes[] ruleSet);

    /// @dev 当规则集更新时发出。
    event RuleSetUpdated(bytes[] newRuleSet, address updatedBy);
}

// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.19;

import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import { UniversalCharter } from "./UniversalCharter.sol";

// Interfaces
import { IUniversalIdentity } from "./interface/IUniversalIdentity.sol";
import { IUniversalCharter } from "./interface/IUniversalCharter.sol";

/// @title UniversalIdentity
/// @notice UniversalIdentity 合约用于管理机器人的身份。

contract UniversalIdentity is IUniversalIdentity, OwnableUpgradeable {
    /// @notice 合约当前实现的版本标识符。
    string public constant VERSION = "v0.0.1";

    /// @notice 用于存储机器人已同意遵守的规则的映射
    mapping(bytes => bool) private robotRules;

    /// @notice 用于存储每个规则的链下合规性状态的映射
    mapping(bytes => bool) private complianceStatus;

    /// @notice 跟踪机器人订阅的章程
    mapping(address => bool) private subscribedCharters;

    /// @notice 用于节省 revert gas 的自定义错误
    error RuleNotAgreed(bytes rule);
    error RuleNotCompliant(bytes rule);
    error RuleAlreadyAdded(bytes rule);

    /// @dev 用于在检查合规性时发出的事件
    /// @param updater 合规性更新器（合约所有者）的地址
    /// @param rule 已检查的规则
    event ComplianceChecked(address indexed updater, bytes rule);

    /// @notice 用于检查规则是否存在的修饰符
    modifier ruleExists(bytes memory rule) {
        require(robotRules[rule], "Rule does not exist");
        _;
    }

    /// @notice 用于设置所有者的构造函数
    constructor() {
        initialize({ _owner: address(0xdEaD) });
    }

    /// @dev 初始化函数
    function initialize(address _owner) public initializer {
        __Ownable_init();
        transferOwnership(_owner);
        hardwareIdentity = _hardwareIdentity;
    }

    /// @notice 获取硬件身份信息
    function getHardwareIdentity() external view returns (HardwareIdentity memory) {
        return hardwareIdentity;
    }

    /// @notice 为硬件验证生成新的挑战
    function generateChallenge() external returns (bytes32) {
        bytes32 challenge = keccak256(abi.encodePacked(
            block.timestamp,
            block.prevrandao,
            msg.sender
        ));
        activeChallenge[challenge] = true;
        return challenge;
    }

    /// @notice 验证对特定挑战的响应
    function verifyChallenge(
        bytes32 challenge,
        bytes memory signature
    ) external returns (bool) {
        if (!activeChallenge[challenge]) {
            revert InvalidChallenge();
        }

        // Remove challenge after use
        // 使用后删除挑战
        delete activeChallenge[challenge];

        // Verify the signature using ECDSA
        // 使用 ECDSA 验证签名
        bytes32 messageHash = keccak256(abi.encodePacked(challenge));
        bytes32 ethSignedMessageHash = ECDSA.toEthSignedMessageHash(messageHash);
        address signer = ECDSA.recover(ethSignedMessageHash, signature);
  
        // Convert hardware public key to address for comparison
        // 将硬件公钥转换为地址以进行比较
        address hardwareAddress = address(uint160(uint256(hardwareIdentity.publicKey)));
  
        if (signer != hardwareAddress) {
            revert InvalidSignature();
        }

        return true;
    }

    /// @notice 更新硬件身份信息
    /// @param _hardwareIdentity 新的硬件身份信息
    function updateHardwareIdentity(
        HardwareIdentity memory _hardwareIdentity
    ) external onlyOwner {
        hardwareIdentity = _hardwareIdentity;
    }

    /// @notice 向机器人的身份添加规则
    /// @param rule 表示机器人同意遵守的规则的动态字节数组。
    function addRule(bytes memory rule) external override onlyOwner {
        if (robotRules[rule]) {
            revert RuleAlreadyAdded(rule);
        }

        // Add rule to the mapping
        // 将规则添加到映射
        robotRules[rule] = true;

        emit RuleAdded(rule);
    }

    /// @notice 从机器人的身份中删除规则
    /// @param rule 表示机器人不再同意遵守的规则的动态字节数组。
    function removeRule(bytes memory rule) external override onlyOwner ruleExists(rule) {
        robotRules[rule] = false;
        complianceStatus[rule] = false;

        emit RuleRemoved(rule);
    }

    /// @notice 使用其存储的规则集订阅和注册到特定的 UniversalCharter 合约
    /// @param charter UniversalCharter 合约的地址
    /// @param version 要获取和注册的规则集的版本
    function subscribeAndRegisterToCharter(address charter, uint256 version) external {
        require(!subscribedCharters[charter], "Already subscribed to this charter");
        subscribedCharters[charter] = true;

        // Fetch the rule set directly from the UniversalCharter contract using the public getter
        // 使用公共 getter 直接从 UniversalCharter 合约获取规则集
        bytes[] memory ruleSet = UniversalCharter(charter).getRuleSet(version);

        // Register as a robot in the charter using the fetched rule set
        // 使用获取的规则集在章程中注册为机器人
        UniversalCharter(charter).registerUser(IUniversalCharter.UserType.Robot, ruleSet);

        emit SubscribedToCharter(charter);
    }

    /// @notice 离开特定 UniversalCharter 合约的系统
    /// @param charter 要离开的 UniversalCharter 合约的地址
    function leaveCharter(address charter) external {
        require(subscribedCharters[charter], "Not subscribed to this charter");

        // Call the leaveSystem function of the UniversalCharter contract
        // 调用 UniversalCharter 合约的 leaveSystem 函数
        UniversalCharter(charter).leaveSystem();

        // Unsubscribe from the charter after leaving
        // 离开后从章程取消订阅
        subscribedCharters[charter] = false;
        emit UnsubscribedFromCharter(charter);
    }

    /// @notice 更新规则的合规性状态（由所有者调用）
    /// @param rule 表示规则的动态字节数组
    /// @param status 合规性状态（如果合规，则为 true；如果不合规，则为 false）
    function updateCompliance(bytes memory rule, bool status) external onlyOwner ruleExists(rule) {
        complianceStatus[rule] = status;

        emit ComplianceChecked(msg.sender, rule);
    }

    /// @notice 检查机器人是否同意遵守特定规则以及是否合规
    /// @param rule 要检查的规则。
    /// @return bool 如果机器人已同意该规则并且合规，则返回 true
    function checkCompliance(bytes memory rule) external view override returns (bool) {
        if (!robotRules[rule]) {
            revert RuleNotAgreed(rule);
        }

        return true;
    }

    /// @notice 获取规则的合规性状态
    /// @param rule 要检查的规则。
    function getRule(bytes memory rule) external view returns (bool) {
        return robotRules[rule];
    }

    /// @notice 获取章程的订阅状态
    /// @param charter 要检查的章程的地址。
    function getSubscribedCharters(address charter) external view returns (bool) {
        return subscribedCharters[charter];
    }

    /// @notice 获取规则的合规性状态
    /// @param rule 要检查的规则。
    function getComplianceStatus(bytes memory rule) external view returns (bool) {
        return complianceStatus[rule];
    }
}

// SPDX-License-Identifier: CC0-1.0
pragma solidity 0.8.20;

import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import { SystemConfig } from "./SystemConfig.sol";

// Interfaces
import { IUniversalCharter } from "./interface/IUniversalCharter.sol";
import { IUniversalIdentity } from "./interface/IUniversalIdentity.sol";

/// @title UniversalCharter
/// @notice UniversalCharter 合约用于管理用户的注册和合规性。

contract UniversalCharter is IUniversalCharter, OwnableUpgradeable {
    /// @notice 用于存储有关注册用户信息的结构体
    struct UserInfo {
        bool isRegistered;
        UserType userType;
        uint256 ruleSetVersion; // 用户遵循的规则集版本
    }

    /// @notice 用于存储注册用户的映射
    mapping(address => UserInfo) private users;

    /// @notice 用于按版本号存储规则集的映射
    mapping(uint256 => bytes[]) private ruleSets;

    /// @notice 用于跟踪规则集哈希及其对应版本的映射
    mapping(bytes32 => uint256) private ruleSetVersions;

    /// @notice 合约当前实现的版本标识符。
    string public constant VERSION = "v0.0.1";

    /// @notice 用于跟踪规则集当前版本的变量
    uint256 private currentVersion;

    /// @notice 用于存储 SystemConfig 合约地址的变量
    SystemConfig public systemConfig;

    /// @notice 当暂停时无法调用方法时的错误。 这将来可能会重命名为“Paused”，但它与“Paused”事件冲突。
    error CallPaused();

    /// @notice 当暂停时恢复。
    modifier whenNotPaused() {
        if (paused()) revert CallPaused();
        _;
    }

    /// @notice 构建 UniversalCharter 合约。
    constructor() {
        initialize({ _owner: address(0xdEaD), _systemConfig: address(0xdEaD) });
    }

    /// @dev 初始化函数
    function initialize(address _owner, address _systemConfig) public initializer {
        __Ownable_init();
        transferOwnership(_owner);
        systemConfig = SystemConfig(_systemConfig);
    }

    /// @notice 通过同意规则集注册用户（无论是人类还是机器人）
    /// @param userType 用户的类型：人类或机器人
    /// @param ruleSet 用户同意遵守的单个规则数组
    function registerUser(UserType userType, bytes[] memory ruleSet) external override whenNotPaused {
        require(!users[msg.sender].isRegistered, "User already registered");

        // Hash the rule set to find the corresponding version
        // 哈希规则集以查找相应的版本
        bytes32 ruleSetHash = keccak256(abi.encode(ruleSet));
        uint256 version = ruleSetVersions[ruleSetHash];
        require(version > 0, "Invalid or unregistered rule set");

        // For robots, ensure compliance with each rule via the UniversalIdentity contract
        // 对于机器人，请确保通过 UniversalIdentity 合约遵守每个规则
        if (userType == UserType.Robot) {
            require(_checkRobotCompliance(msg.sender, version), "Robot not compliant with rule set");
        }

        // Register the user with the versioned rule set
        // 使用版本控制的规则集注册用户
        users[msg.sender] = UserInfo({ isRegistered: true, userType: userType, ruleSetVersion: version });

        emit UserRegistered(msg.sender, userType, ruleSet);
    }

    /// @notice 允许用户（人类或机器人）在通过合规性检查后离开系统
    function leaveSystem() external override whenNotPaused {
        require(users[msg.sender].isRegistered, "User not registered");

        UserInfo memory userInfo = users[msg.sender];

        // For robots, verify compliance with all rules in the rule set
        // 对于机器人，验证规则集中所有规则的合规性
        uint256 version = userInfo.ruleSetVersion;
        if (userInfo.userType == UserType.Robot) {
            require(_checkRobotCompliance(msg.sender, version), "Robot not compliant with rule set");
        }

        users[msg.sender] = UserInfo({ isRegistered: false, userType: UserType.Human, ruleSetVersion: 0 });

        emit UserLeft(msg.sender);
    }

    /// @notice Internal function to verify robot hardware identity
    // 用于验证机器人硬件身份的内部函数
    /// @param robotAddress The address of the robot to verify
    // 要验证的机器人的地址
    /// @return bool Returns true if hardware verification succeeds
    // 如果硬件验证成功，则返回 true
    function _verifyRobotHardware(address robotAddress) internal returns (bool) {
        IUniversalIdentity robot = IUniversalIdentity(robotAddress);
  
        // Get hardware identity to ensure it exists
        // 获取硬件身份以确保其存在
        robot.getHardwareIdentity();
  
        // Generate a new challenge
        // 生成新的挑战
        bytes32 challenge = robot.generateChallenge();
  
        // Store the challenge for future reference
        // 存储挑战以供将来参考
        users[robotAddress].lastVerifiedChallenge = challenge;
  
        // Get signature from the robot (this would typically happen off-chain)
        // 从机器人获取签名（这通常会发生在链下）
        // For this implementation, we'll assume the signature is provided in a separate tx
        // 对于此实现，我们将假设签名是在单独的 tx 中提供的
        // and just verify the challenge exists
        // 并仅验证挑战是否存在
        return challenge != 0;
    }

    /// @notice 检查用户是否符合其注册规则集
    /// @param user 用户（人类或机器人）的地址
    /// @param ruleSet 要验证的单个规则数组
    /// @return bool 如果用户符合给定的规则集，则返回 true
    function checkCompliance(address user, bytes[] memory ruleSet) external view override returns (bool) {
        require(users[user].isRegistered, "User not registered");

        // Hash the provided rule set to find the corresponding version
        // 哈希提供的规则集以查找相应的版本
        bytes32 ruleSetHash = keccak256(abi.encode(ruleSet));
        uint256 version = ruleSetVersions[ruleSetHash];
        require(version > 0, "Invalid or unregistered rule set");
        require(users[user].ruleSetVersion == version, "Rule set version mismatch");

        // For robots, check compliance with each rule in the UniversalIdentity contract
        // 对于机器人，请检查 UniversalIdentity 合约中每个规则的合规性
        if (users[user].userType == UserType.Robot) {
            return _checkRobotCompliance(user, version);
        }

        // If the user is human, compliance is assumed for now (can be extended)
        // 如果用户是人类，则目前假定合规（可以扩展）
        return true;
    }

    /// @notice Internal function to check compliance for robots with their rule set version
    // 用于检查机器人是否符合其规则集版本的内部函数
    /// @dev This function will revert if the robot is not compliant with any rule. Returns true for view purposes.
    // @dev 如果机器人不符合任何规则，此函数将恢复。 出于视图目的返回 true。
    /// @param robotAddress The address of the robot
    // 机器人的地址
    /// @param version The version of the rule set to verify compliance with
    // 用于验证合规性的规则集版本
    /// @return bool Returns true if the robot is compliant with all the rules in the rule set
    // 如果机器人符合规则集中的所有规则，则返回 true
    function _checkRobotCompliance(address robotAddress, uint256 version) internal view returns (bool) {
        IUniversalIdentity robot = IUniversalIdentity(robotAddress);
        bytes[] memory rules = ruleSets[version];

        for (uint256 i = 0; i < rules.length; i++) {
            if (!robot.checkCompliance(rules[i])) {
                return false;
            }
        }

        return true;
    }

    /// @notice Updates or defines a new rule set version.
    // 更新或定义新的规则集版本。
    /// @param newRuleSet The array of new individual rules.
    // 新的单个规则数组。
    /// @dev This function SHOULD be restricted to authorized users (e.g., contract owner).
    // @dev 此函数应该仅限于授权用户（例如，合约所有者）。
    function updateRuleSet(bytes[] memory newRuleSet) external whenNotPaused onlyOwner {
        require(newRuleSet.length > 0, "Cannot update to an empty rule set");

        // Hash the new rule set and ensure it's not already registered
        // 哈希新的规则集并确保尚未注册
        bytes32 ruleSetHash = keccak256(abi.encode(newRuleSet));
        require(ruleSetVersions[ruleSetHash] == 0, "Rule set already registered");

        // Increment the version and store the new rule set
        // 递增版本并存储新的规则集
        currentVersion += 1;
        ruleSets[currentVersion] = newRuleSet;
        ruleSetVersions[ruleSetHash] = currentVersion;

        emit RuleSetUpdated(newRuleSet, msg.sender);
    }

    /// @notice Getter for the latest version of the rule set.
    // 规则集最新版本的 Getter。
    function getLatestRuleSetVersion() external view returns (uint256) {
        return currentVersion;
    }

    /// @notice Get the rule set for a specific version.
    // 获取特定版本的规则集。
    /// @param version The version of the rule set to retrieve.
    // 要检索的规则集版本。
    function getRuleSet(uint256 version) external view returns (bytes[] memory) {
        return ruleSets[version];
    }

    /// @notice Get the version number for a specific rule set.
    // 获取特定规则集的版本号。
    /// @param ruleSet The hash of the rule set to retrieve the version for.
    // 规则集的哈希，用于检索版本。
    function getRuleSetVersion(bytes32 ruleSet) external view returns (uint256) {
        return ruleSetVersions[ruleSet];
    }

    function getUserInfo(address user) external view returns (UserInfo memory) {
        return users[user];
    }

    /// @notice Getter for the current paused status.
    // 当前暂停状态getter。
    /// @return paused_ Whether or not the contract is paused.
    // @return paused_ 合约是否已暂停。
    function paused() public view returns (bool paused_) {
        paused_ = systemConfig.paused();
    }
}