NFT質押代幣分紅dapp系統開發功能|合約定製案例

Validator – 主鏈/子鏈共識系統的參與者。透過存50000BU到主鏈中就能成為一名驗證者。

Active validator set - 那些開發I34-合約I633-部署53I9，當前正在參與的驗證者以及尋求產生以及證明區塊，跨鏈路和其他共識物件的驗證者。

Committee - 從活躍驗證者集合中（偽）隨機抽樣的子集。當一個委員會被集體提及時，如“該委員會證明X”，這種假定為“該委員會的某個子集包含足夠的驗證者，該協議承認其代表委員會”。

Proposer - 建立一個區塊的驗證者

Attester -在區塊上簽名的委員會中的一名驗證者

Main chain – 主鏈是分片系統的基礎

Shard chain - 進行交易和儲存賬戶資料的鏈之一

Observer client -監控分片並儲存指定分片的全資料以及主鏈的全狀態

 * @dev See `IERC20.transfer`.
     *
     * Unlike `send`, `recipient` is _not_ required to implement the `tokensReceived`
     * interface if it is a contract.
     *
     * Also emits a `Sent` event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool) {
        return _transfer(recipient, amount);
    }
    function _transfer(address recipient, uint256 amount) internal returns (bool) {
        require(recipient != address(0), "ERC777: transfer to the zero address");
        address from = msg.sender;
        _callTokensToSend(from, from, recipient, amount, "", "");
        _move(from, from, recipient, amount, "", "");
        _callTokensReceived(from, from, recipient, amount, "", "", false);
        return true;
    }
    /**
     * @dev See `IERC777.burn`.
     *
     * Also emits a `Transfer` event for ERC20 compatibility.
     */
    function burn(uint256 amount, bytes calldata data) external {
        _burn(msg.sender, msg.sender, amount, data, "");
    }
    /**
     * @dev See `IERC777.isOperatorFor`.
     */
    function isOperatorFor(
        address operator,
        address tokenHolder
    ) public view returns (bool) {
        return operator == tokenHolder ||
            _operators[tokenHolder][operator];
    }
    /**
     * @dev See `IERC777.authorizeOperator`.
     */
    function authorizeOperator(address operator) external {
        require(msg.sender != operator, "ERC777: authorizing self as operator");
       _operators[msg.sender][operator] = true;
        emit AuthorizedOperator(operator, msg.sender);
    }
    /**
     * @dev See `IERC777.revokeOperator`.
     */
    function revokeOperator(address operator) external {
        require(operator != msg.sender, "ERC777: revoking self as operator");
        delete _operators[msg.sender][operator];
        emit RevokedOperator(operator, msg.sender);
    }
    /**
     * @dev See `IERC777.defaultOperators`.
     */
    function defaultOperators() external view returns (address[] memory) {
        return _defaultOperatorsArray;
    }
    /**
     * @dev See `IERC777.operatorSend`.
     *
     * Emits `Sent` and `Transfer` events.
     */
    function operatorSend(
        address sender,
        address recipient,
        uint256 amount,
        bytes calldata data,
        bytes calldata operatorData
    ) external {
        require(isOperatorFor(msg.sender, sender), "ERC777: caller is not an operator for holder");
        _send(msg.sender, sender, recipient, amount, data, operatorData, true);
    }
    /**
     * @dev See `IERC777.operatorBurn`.
     *
     * Emits `Sent` and `Transfer` events.
     */
    function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
        require(isOperatorFor(msg.sender, account), "ERC777: caller is not an operator for holder");
        _burn(msg.sender, account, amount, data, operatorData);
    }
    /**
     * @dev See `IERC20.allowance`.
     *
     * Note that operator and allowance concepts are orthogonal: operators may
     * not have allowance, and accounts with allowance may not be operators
     * themselves.
     */
    function allowance(address holder, address spender) external view returns (uint256) {
        return _allowances[holder][spender];
    }
    /**
     * @dev See `IERC20.approve`.
     *
     * Note that accounts cannot have allowance issued by their operators.
     */
    function approve(address spender, uint256 value) external returns (bool) {
        address holder = msg.sender;
        _approve(holder, spender, value);
        return true;
    }
   /**
    * @dev See `IERC20.transferFrom`.
    *
    * Note that operator and allowance concepts are orthogonal: operators cannot
    * call `transferFrom` (unless they have allowance), and accounts with
    * allowance cannot call `operatorSend` (unless they are operators).
    *
    * Emits `Sent` and `Transfer` events.
    */
    function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
        return _transferFrom(holder, recipient, amount);
    }
    function _transferFrom(address holder, address recipient, uint256 amount) internal returns (bool) {
        require(recipient != address(0), "ERC777: transfer to the zero address");
        require(holder != address(0), "ERC777: transfer from the zero address");
        address spender = msg.sender;
        _callTokensToSend(spender, holder, recipient, amount, "", "");
        _move(spender, holder, recipient, amount, "", "");
        _approve(holder, spender, _allowances[holder][spender].sub(amount));
        _callTokensReceived(spender, holder, recipient, amount, "", "", false);
        return true;
    }