ERC-7943: uRWA - 通用现实世界资产接口

pragma solidity ^0.8.29;

/// @notice 定义 ERC-7943 接口，即 uRWA。
/// 在与特定代币标准交互时：
/// - 对于类似 ERC-721 的（非同质化）代币，'amount' 参数通常代表单个代币（即 1）。
/// - 对于类似 ERC-20 的（同质化）代币，'tokenId' 参数通常不适用，应设置为 0。
interface IERC7943 /*is IERC165*/ {
    /// @notice 当代币从一个地址转移到另一个地址时发出。
    /// @param from 代币被取出的地址。
    /// @param to 被扣押的代币转移到的地址。
    /// @param tokenId 被转移的代币的 ID。
    /// @param amount 被扣押的数量。
    event ForcedTransfer(address indexed from, address indexed to, uint256 tokenId, uint256 amount);

    /// @notice 当调用 `setFrozen` 时发出，改变 `user` 的 `tokenId` 代币的冻结 `amount`。
    /// @param user 其代币被冻结的用户的地址。
    /// @param tokenId 要冻结的代币的 ID。
    /// @param amount 更改后要冻结的代币数量。
    event Frozen(address indexed user, uint256 indexed tokenId, uint256 amount);

    /// @notice 当用户不允许交互时回滚的错误。
    /// @param account 不允许交互的用户的地址。
    error ERC7943NotAllowedUser(address account);

    /// @notice 当由于现有限制而不允许转账时回滚的错误。
    /// @param from 要从中转移代币的地址。
    /// @param to 要将代币转移到的地址。
    /// @param tokenId 被转移的代币的 ID。
    /// @param amount 被转移的数量。
    error ERC7943NotAllowedTransfer(address from, address to, uint256 tokenId, uint256 amount);

    /// @notice 当尝试从 `user` 转移 `tokenId` 的 `amount` 小于或等于其余额但大于其未冻结余额时回滚的错误。
    /// @param user 持有代币的地址。
    /// @param tokenId 被转移的代币的 ID。
    /// @param amount 被转移的数量。
    /// @param unfrozen 未冻结且可用于转移的代币数量。
    error ERC7943InsufficientUnfrozenBalance(address user, uint256 tokenId, uint256 amount, uint256 unfrozen);

    /// @notice 将代币从一个地址转移到另一个地址。
    /// @dev 需要特定授权。用于法规遵从或恢复场景。
    /// @param from 从中获取 `amount` 的地址。
    /// @param to 接收 `amount` 的地址。
    /// @param tokenId 被转移的代币的 ID。
    /// @param amount 要强制转移的数量。
    function forceTransfer(address from, address to, uint256 tokenId, uint256 amount) external;

    /// @notice 更改属于 `user` 的 `tokenId` 代币的 `amount` 的冻结状态。
    /// 这将覆盖当前值，类似于 `approve` 函数。
    /// @dev 需要特定授权。冻结的代币不能由用户转移。
    /// @param user 要冻结/解冻其代币的用户的地址。
    /// @param tokenId 要冻结/解冻的代币的 ID。
    /// @param amount 要冻结/解冻的代币数量。
    function setFrozen(address user, uint256 tokenId, uint256 amount) external;

    /// @notice 检查特定 `tokenId` 的冻结状态/数量。
    /// @param user 用户的地址。
    /// @param tokenId 代币的 ID。
    /// @return amount 当前为 `user` 冻结的 `tokenId` 代币的数量。
    function getFrozen(address user, uint256 tokenId) external view returns (uint256 amount);
 
    /// @notice 检查根据代币规则当前是否可以进行转账。它强制执行对冻结代币的验证。
    /// @dev 这可能涉及检查，例如白名单、黑名单、转账限制和其他策略定义的限制。
    /// @param from 发送代币的地址。
    /// @param to 接收代币的地址。
    /// @param tokenId 被转移的代币的 ID。
    /// @param amount 被转移的数量。
    /// @return allowed 如果允许转移，则为 True，否则为 False。
    function isTransferAllowed(address from, address to, uint256 tokenId, uint256 amount) external view returns (bool allowed);

    /// @notice 检查是否允许特定用户根据代币规则进行交互。
    /// @dev 这通常用于白名单/KYC/KYB/AML 检查。
    /// @param user 要检查的地址。
    /// @return allowed 如果允许用户，则为 True，否则为 False。
    function isUserAllowed(address user) external view returns (bool allowed);
}

pragma solidity ^0.8.29;

/* required imports ... */

contract uRWA20 is Context, ERC20, AccessControlEnumerable, IERC7943 {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
    bytes32 public constant ENFORCER_ROLE = keccak256("ENFORCER_ROLE");
    bytes32 public constant WHITELIST_ROLE = keccak256("WHITELIST_ROLE");

    mapping(address user => bool whitelisted) public isWhitelisted;
    mapping(address user => uint256 amount) internal _frozenTokens;

    event Whitelisted(address indexed account, bool status);
    error NotZeroAddress();

    constructor(string memory name, string memory symbol, address initialAdmin) ERC20(name, symbol) {
        /* give initialAdmin necessary roles ...*/
        // 给予初始管理员必要的角色...
    }

    function isTransferAllowed(address from, address to, uint256, uint256 amount) public virtual view returns (bool allowed) {
        if (amount > balanceOf(from) - _frozenTokens[from]) return;
        if (!isUserAllowed(from) || !isUserAllowed(to)) return;
        allowed = true;
    }

    function isUserAllowed(address user) public virtual view returns (bool allowed) {
        if (isWhitelisted[user]) allowed = true;
    } 

    function getFrozen(address user, uint256) external view returns (uint256 amount) {
        amount = _frozenTokens[user];
    }

    function changeWhitelist(address account, bool status) external onlyRole(WHITELIST_ROLE) {
        require(account != address(0), NotZeroAddress());
        isWhitelisted[account] = status;
        emit Whitelisted(account, status);
    }

    /* standard mint and burn functions with access control ...*/ 
    // 具有访问控制的标准铸造和销毁功能...

    function setFrozen(address user, uint256, uint256 amount) public onlyRole(ENFORCER_ROLE) {
        require(amount <= balanceOf(user), IERC20Errors.ERC20InsufficientBalance(user, balanceOf(user), amount));
        _frozenTokens[user] = amount;
        emit Frozen(user, 0, amount);
    }

    function forceTransfer(address from, address to, uint256, uint256 amount) public onlyRole(ENFORCER_ROLE) {
        require(isUserAllowed(to), ERC7943NotAllowedUser(to));
        _excessFrozenUpdate(from, amount);
        super._update(from, to, amount);
        emit ForcedTransfer(from, to, 0, amount);
    }

    function _excessFrozenUpdate(address user, uint256 amount) internal {
        uint256 unfrozenBalance = balanceOf(user) - _frozenTokens[user];
        if(amount > unfrozenBalance && amount <= balanceOf(user)) { 
            // Protect from underflow: if amount > balanceOf(user) the call will revert in super._update with insufficient balance error
            // 防止下溢：如果 amount > balanceOf(user)，则调用将在 super._update 中回滚，并出现余额不足错误
            _frozenTokens[user] -= amount - unfrozenBalance; // Reduce by excess amount
            // 减少过剩数量
            emit Frozen(user, 0, _frozenTokens[user]);
        }
    }

    function _update(address from, address to, uint256 amount) internal virtual override {
        if (from != address(0) && to != address(0)) { // Transfer
            // 转账
            require(amount <= balanceOf(from), IERC20Errors.ERC20InsufficientBalance(from, balanceOf(from), amount));
            require(amount <= balanceOf(from) - _frozenTokens[from], ERC7943InsufficientUnfrozenBalance(from, 0, amount, balanceOf(from) - _frozenTokens[from]));
            require(isTransferAllowed(from, to, 0, amount), ERC7943NotAllowedTransfer(from, to, 0, amount));
        } else if (from == address(0)) { // Mint
            // 铸造
            require(isUserAllowed(to), ERC7943NotAllowedUser(to));
        } else { // Burn
            // 销毁
            _excessFrozenUpdate(from, amount);
        }

        super._update(from, to, amount);
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlEnumerable, IERC165) returns (bool) {
        return interfaceId == type(IERC7943).interfaceId ||
            interfaceId == type(IERC20).interfaceId ||
            super.supportsInterface(interfaceId);
    }
}

pragma solidity ^0.8.29;

/* required imports ... */

contract uRWA721 is Context, ERC721, AccessControlEnumerable, IERC7943 {
    /* same definitions, constructor and changeWhitelist function as before ...*/
    // 与之前相同的定义、构造函数和 changeWhitelist 函数...
    
    mapping(address user => mapping(uint256 tokenId => uint8 frozen)) internal _frozenTokens;

    function isUserAllowed(address user) public view virtual override returns (bool allowed) {
        if (isWhitelisted[user]) allowed = true;        
    }

    function isTransferAllowed(address from, address to, uint256 tokenId, uint256) public view virtual override returns (bool allowed) {
        address owner = _ownerOf(tokenId);
        if (owner != from || owner == address(0)) return;
        if (!isUserAllowed(from) || !isUserAllowed(to)) return;
        if (_frozenTokens[from][tokenId] > 0) return;
        allowed = true;
    }

    function getFrozen(address user, uint256 tokenId) external view returns (uint256 amount) {
        amount = _frozenTokens[user][tokenId];
    }

    function setFrozen(address user, uint256 tokenId, uint256 amount) public onlyRole(ENFORCER_ROLE) {
        require(user == ownerOf(tokenId), IERC721Errors.ERC721InvalidOwner(user));
        require(amount == 0 || amount == 1, InvalidAmount(amount));
        _frozenTokens[user][tokenId] = uint8(amount);
        emit Frozen(user, tokenId, amount);
    }

    function forceTransfer(address from, address to, uint256 tokenId, uint256) public virtual override onlyRole(ENFORCER_ROLE) {
        require(to != address(0), ERC721InvalidReceiver(address(0)));
        require(isUserAllowed(to), ERC7943NotAllowedUser(to));
        _excessFrozenUpdate(from , tokenId);
        super._update(to, tokenId, address(0)); // Skip _update override
        // 跳过 _update 覆盖
        ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, "");
        emit ForcedTransfer(from, to, tokenId, 1);
    }

    function _excessFrozenUpdate(address from, uint256 tokenId) internal {
        _validateCorrectOwner(from, tokenId);
        if(_frozenTokens[from][tokenId] > 0) {
            _frozenTokens[from][tokenId] = 0; // Unfreeze the token if it was frozen
            // 如果代币已冻结，则解冻代币
            emit Frozen(from, tokenId, 0);
        }
    }

    function _validateCorrectOwner(address claimant, uint256 tokenId) internal view {
        address currentOwner = ownerOf(tokenId);
        require(currentOwner == claimant, ERC721IncorrectOwner(claimant, tokenId, currentOwner));
    }

    /* standard mint function with access control ...*/ 
    //具有访问控制的标准铸造功能...

    function burn(uint256 tokenId) external virtual onlyRole(BURNER_ROLE) {
        address previousOwner = _update(address(0), tokenId, _msgSender()); 
        if (previousOwner == address(0)) revert ERC721NonexistentToken(tokenId);
    }

    function _update(address to, uint256 tokenId, address auth) internal virtual override returns(address) {
        address from = _ownerOf(tokenId);

        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        if (from != address(0) && to != address(0)) { // Transfer
            // 转账
            _validateCorrectOwner(from, tokenId);
            require(_frozenTokens[from][tokenId] == 0, ERC7943InsufficientUnfrozenBalance(from, tokenId, 1, 0));
            require(isTransferAllowed(from, to, tokenId, 1), ERC7943NotAllowedTransfer(from, to, tokenId, 1));
        } else if (from == address(0)) { // Mint
            // 铸造
            require(isUserAllowed(to), ERC7943NotAllowedUser(to));
        } else { // Burn
            // 销毁
            _excessFrozenUpdate(from, tokenId);
        } 

        return super._update(to, tokenId, auth);
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControlEnumerable, ERC721, IERC165) returns (bool) {
        return interfaceId == type(IERC7943).interfaceId ||
               super.supportsInterface(interfaceId);
    }
}