http://www.7klian.com

  • 莱特币
  • 以太坊
  • EOS
  • 瑞波币
  • 比特股
  • 狗狗币
  • Zcash
  • 门罗币
  • 如何利用OpenZeppelin的新AccessControl合约

    扩展Ownable合约答允子合约利用onlyOwner自界说修饰符界说成果。这些成果要求事务的发送者是单一打点员。
    #### Roles
    pragma solidity ^0.6.0;
    import “@openzeppelin/contracts/access/Roles.sol”;
            for (uint256 i = 0; i < burners.length; ++i) {
                _minters.add(minters[i]);
    function restrictedFunction() public onlyOwner {
         */
    import “@openzeppelin/contracts/token/ERC20/ERC20Detailed.sol”;
    一站式处事,满意所有授权需求。它使您可以轻松界说具有差异权限的多个脚色,以及答允哪些帐户授予和除掉每个脚色。通过启用系统中所有特权帐户的列举,还可以提高透明度。
         * {revokeRole}.
    OpenZeppelin看起来正朝着一种使人们遐想到传统计较安详性中突出的基于脚色的会见节制(RBAC)和基于属性的会见节制(ABAC)尺度的系统成长。
    import “@openzeppelin/contracts/token/ERC20/ERC20.sol”;
    contract MyToken is ERC20, AccessControl {
         * event. Note that unlike {grantRole}, this function doesn’t perform any
        function burn(address from, uint256 amount) public {
         */
         * @dev Grants `role` to `account`.
         *
         * Roles are often managed via {grantRole} and {revokeRole}: this function’s
     * }
         */
         * system imposed by {AccessControl}.
            _mint(to, amount);
         * @dev Emitted when `account` is revoked `role`.
     * “`
            return role.bearer[account];
         */
    第四段代码显示了此实现。
        /**
        /**
        function burn(address from, uint256 amount) public {
            }
        function revokeRole(bytes32 role, address account) public virtual {
    }
        }
         */
        function add(Role storage role, address account) internal {
         * @dev Returns `true` if `account` has been granted `role`.
        }
     * {_setRoleAdmin}.
        }
    第二段代码给出了利用Roles库的代币合约的示例,该合约需要两个单独的脚色_minters和_burners。为了保持持续性,我们将利用沟通的观念并应用AccessControl合约来做到这一点。
         *
            _revokeRole(role, account);
     * @dev Contract module that allows children to implement role-based access
     * in the external API and be unique. The best way to achieve this is by
            require(hasRole(BURNER_ROLE, msg.sender), “Caller is not a burner”);
        /**
     * Roles are referred to by their `bytes32` identifier. These should be exposed
         */
         *
         */
    import “@openzeppelin/contracts/access/AccessControl.sol”;
    另外函数不是将库函数作为数据范例的扩展名(即_minters.has(msg.sender)),而是自己具有内部函数(hasRole(MINTER_ROLE,msg.sender))。这使得子合约中的代码凡是更清晰易读。
    pragma solidity ^0.5.0;
        bytes32 public constant MINTER_ROLE = keccak256(“MINTER_ROLE”);
        }
         * bearer except when using {_setupRole}.
     * function foo() public {
         */
         *
         */
     *     …
         * value between 0 and {getRoleMemberCount}, non-inclusive.
        /**
    }
        /**
         * This function should only be called from the constructor when setting
        bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
    contract MyToken is ERC20, ERC20Detailed {
    此刻第57和66行中界说的脚色被授予或除掉时,会发失事件。Roles条约仅提供三个成果:has(),add()和remove()。这些形式包罗在AccessControl中以及特另外成果,譬喻获取脚色计数,通过ID获取脚色的特定成员以及放弃脚色的本领。
        }
        struct RoleData {
        bytes32 public constant BURNER_ROLE = keccak256(“BURNER_ROLE”);
        struct Role {
         * Requirements:
         *
            // Only burners can burn
        /**
        }
         * If the calling account had been granted `role`, emits a {RoleRevoked}
         *
         * @dev Grants `role` to `account`.
        Roles.Role private _minters;
     *     require(hasRole(MY_ROLE, _msgSender()));
    熟悉OpenZeppelin的智能合约存储库的开拓人员知道,它已经提供了按照会见级别限制成果的选项。
         * Using this function in any other way is effectively circumventing the admin
        event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
        function mint(address to, uint256 amount) public {
            _revokeRole(role, account);
            for (uint256 i = 0; i < minters.length; ++i) {
         * @dev Emitted when `account` is granted `role`.
            return _roles[role].members.length();
         * @dev Revokes `role` from the calling account.
            _mint(to, amount);
         * If `account` had not been already granted `role`, emits a {RoleGranted}
    pragma solidity ^0.5.0;
         * up the initial roles for the system.
         * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
            mapping (address => bool) bearer;
         * @dev Check if an account has this role.
        function _setupRole(bytes32 role, address account) internal virtual {
            return _roles[role].adminRole;
    作为一个库,数据存储必需由导入合约节制。抱负环境下,会见节制应该抽象到某种水平,而导入合约只需要担忧对每个函数的限制。
     *
     * function call, use {hasRole}:
     * @dev Library for managing addresses assigned to a Role.
    展示AccessControl合约代码。
         * [WARNING]
    import “../utils/EnumerableSet.sol”;
            _grantRole(role, account);
        function mint(address to, uint256 amount) public {
            return _roles[role].members.contains(account);
        /**
     *
         *   – if using `revokeRole`, it is the admin role bearer
        }
     * @title Roles
    _setupRole()用于结构函数中,以配置脚色的初始打点员,从而绕过AccessControl中grantRole()执行的查抄(因为在结构时还没有打点员)。
         * if they are compromised (such as when a trusted device is misplaced).
         * ====
        }
    节制某些成果的会见权限对付确保智能合约的安详性至关重要,而自从虚拟机问世以来,Solidity就是如此。
     * roles. More complex role relationships can be created by using
    与Roles库对比,抽象出更多成果可以使子合约更容易在AccessControl合约之上构建。
     * {revokeRole} functions. Each role has an associated admin role, and only
            _burn(from, amount);
         * @dev Returns the admin role that controls `role`. See {grantRole} and
    譬喻下段代码展示了代币如何利用两个单独的脚色_minters和_burners来将会见限制应用于某些成果。
        function _grantRole(bytes32 role, address account) private {
         * @dev Give an account access to this role.
        function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
            require(!has(role, account), “Roles: account already has role”);
         * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
    思量到这已经是一段时间的尺度,对付开拓人员来说,最大的新闻是从2.5.x版本进级到3.x版本后,Roles合约已被删除。
    第42行上的Role Data布局利用EnumerableSet(也是版本3的新成果)作为存储成员的数据布局。这样可以轻松地对特权用户举办迭代。
         *
        /**
         * Requirements:
         * together with {getRoleMember} to enumerate all bearers of a role.
            // Grant the contract deployer the default admin role: it will be able
        mapping (bytes32 => RoleData) private _roles;
    这是一个简朴的示例,说明如何操作Ownable合约提供的自界说修饰符来限制成果会见。
                emit RoleGranted(role, account, _msgSender());
        Roles.Role private _burners;
            require(account == _msgSender(), “AccessControl: can only renounce roles for self”);
         *
         * @dev Returns one of the accounts that have `role`. `index` must be a
        using Roles for Roles.Role;
         */
            require(has(role, account), “Roles: account does not have role”);
     * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
        function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        // anyone can call this
        }
         * `sender` is the account that originated the contract call, an admin role
    Roles库对其提供的成果有所限制。
         * ====
        function renounceRole(bytes32 role, address account) public virtual {
        using EnumerableSet for EnumerableSet.AddressSet;
    最常见的是由所有者Ownable合约打点的onlyOwner模式。另一个是Openzeppelin的“roles”合约,该合约使合约可以在陈设之前界说多个脚色并在每个成果中配置法则,以确保msg.sender接受正确的脚色。
        /**
        function getRoleAdmin(bytes32 role) public view returns (bytes32) {
                emit RoleRevoked(role, account, _msgSender());
    Ownable
            if (_roles[role].members.add(account)) {
            }
     *
            role.bearer[account] = false;
         *
        }
        event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
         * To change a role’s admin, use {_setRoleAdmin}.
        using Address for address;
    }
    abstract contract AccessControl is Context {
         * Role bearers are not sorted in any particular way, and their ordering may
         *
        }
     * using `public constant` hash digests:
         * event.
         * @dev Remove an account’s access to this role.
     * control mechanisms.
        }
    pragma solidity ^0.6.0;
        /**
        /**
         *
        function grantRole(bytes32 role, address account) public virtual {
     *
         * @dev Returns the number of accounts that have `role`. Can be used
         * for more information.
    import “../utils/Address.sol”;
            bytes32 adminRole;
    /**
            }
    function normalFunction() public {
    在子协定中,只有bytes32 ID作为常量状态变量存在(在本示例中为MINTER_ROLE和BURNER_ROLE)。
         * event.
           _burn(from, amount);
         * – the caller must have “role“’s admin role.
        }
     *
        }
        function getRoleMemberCount(bytes32 role) public view returns (uint256) {
         * you perform all queries on the same block. See the following
        {
            require(_burners.has(msg.sender), “DOES_NOT_HAVE_BURNER_ROLE”);
         * Requirements:
        function has(Role storage role, address account) internal view returns (bool) {
         * purpose is to provide a mechanism for accounts to lose their privileges
            return _roles[role].members.at(index);
         *
    该合约获得了行业专家的大力大举支持。我想这个合约很快会发生一些有趣而巨大的系统,从而进一步敦促。

    }
    AccessControl的引入是使以太坊生态系统在系统安详方面更靠近行业尺度的重要一步。
    }
                _burners.add(burners[i]);
         * – the caller must have “role“’s admin role.
     * “`
    它假定智能合约只有一个打点员,并答允打点员将所有权转移到另一个地点。
         *
    代码理会
        }
        /**
            _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
         * `sender` is the account that originated the contract call:
         *
         * – the caller must be `account`.
         *
         *
    在顶部,您可以看到Role布局。合约利用它来界说多个脚色及其成员。函数add(),remove()和has()是库用于与Role布局交互的函数。
    新的AccessControl条约被吹嘘为:
    该布局还将adminRole存储为bytes32变量。这界说了哪个脚色充当特定脚色的打点员(即该脚色具有充当该脚色的打点员,向用户授予和除掉该脚色的本领)。
     * “`
    import “../GSN/Context.sol”;
            role.bearer[account] = true;
    /**
    留意,在mint()函数中,,require语句如何通过利用_minters.has(msg.sender)函数来确保动静的发件人是一个锻造者。
         * If `account` had been granted `role`, emits a {RoleRevoked} event.
        }
            // Only minters can mint
         * If `account` had not been already granted `role`, emits a {RoleGranted}
         *
    }
        }
            require(hasRole(_roles[role].adminRole, _msgSender()), “AccessControl: sender must be an admin to revoke”);
    import “@openzeppelin/contracts/token/ERC20/ERC20.sol”;
        }
        }
            _roles[role].adminRole = adminRole;
         */
     */
         * checks on the calling account.
     * Roles can be granted and revoked dynamically via the {grantRole} and
    结  论
     * accounts that have a role’s admin role can call {grantRole} and {revokeRole}.
    library Roles {
         * @dev Revokes `role` from `account`.
            _grantRole(role, account);
            require(account != address(0), “Roles: account is the zero address”);
        function remove(Role storage role, address account) internal {
    那么产生了什么变革?首先每个脚色不再在子合约中界说,因为它们存储在父合约中。
        }
     * Roles can be used to represent a set of permissions. To restrict access to a
    如何利用它
            require(_minters.has(msg.sender), “DOES_NOT_HAVE_MINTER_ROLE”);
         *   – if using `renounceRole`, it is the role bearer (i.e. `account`)
        // only the owner can call this
    代码显示了Roles的界说。
        }
            require(hasRole(MINTER_ROLE, msg.sender), “Caller is not a minter”);
    作为一个库,它不会由子合约扩展,而是通过using语句用作为数据范例添加成果的东西。Roles库为它界说的role数据范例提供了三个成果。
        }
        constructor() public ERC20(“MyToken”, “TKN”) {
     *
         */
         *
     * “`
            }
         * @return bool
     * that only accounts with this role will be able to grant or revoke other
         */
            EnumerableSet.AddressSet members;
     * bytes32 public constant MY_ROLE = keccak256(“MY_ROLE”);
        constructor(address[] memory minters, address[] memory burners)
            require(hasRole(_roles[role].adminRole, _msgSender()), “AccessControl: sender must be an admin to grant”);
        function _revokeRole(bytes32 role, address account) private {
         */
    尽量Ownable合约很受接待且易于利用,但存储库中的其他OpenZeppelin合约仅利用Roles库举办会见节制。这是因为Roles库在Ownable合约的刚性方面提供了机动性。
            public
         * change at any point.
    该语句的最后两点对付Roles库是不行能的。
            if (_roles[role].members.remove(account)) {
    Principles
         * @dev Sets `adminRole` as “role“’s admin role.
    onlyOwner模式是最常用且易于实现的会见节制要领。它是原始的但很是有效。
            ERC20Detailed(“MyToken”, “MTKN”, 18)
            // to grant and revoke any roles
     */

    OpenZeppelin的智能合约库版本3已经宣布!在最新版本中,他们引入了一种全新的节制成果会见的要领。
        /**
        function hasRole(bytes32 role, address account) public view returns (bool) {
        /**

    郑重声明:本文版权归原作者所有,转载文章仅为传播更多信息之目的,如作者信息标记有误,请第一时间联系我们修改或删除,多谢。

    说点什么吧
  • 全部评论(0
  • 还没有评论,快来抢沙发吧!

    相关文章阅读