Contract

0x01D5dC56AD4206Bb0c132D834644d57F51FEd5EC

Polygon (Matic): Validator Share

Source Code

Polygon

Overview

ETH Balance

0 ETH

Eth Value

$0.00

More Info

Private Name Tags

Add

ContractCreator

0x427cEB53...e15d3576E at txn 0x22d006384ffe66719f96b003483fe836101eb97cc63714262363d36ef21e7cab

Multichain Info

$0 (Multichain Portfolio)

Advanced Filter

Latest 1 from a total of 1 transactions

	Transaction Hash	Method	Block		From		To	Value
	0x22d006384ffe66719f96b003483fe836101eb97cc63714262363d36ef21e7cab	0x60806040	12115603	2021-03-26 16:04:31	1190 days ago	1616774671	0x427cEB53...e15d3576E	IN	Create: ValidatorShare	0 ETH	0.44626165	181

View more zero value Internal Transactions in Advanced View mode

Advanced mode:

Contract Source Code Verified (Exact Match)

Contract Name:

ValidatorShare

Compiler Version

v0.5.17+commit.d19bba13

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, GNU GPLv3 license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-03-26
*/

// File: contracts/common/governance/IGovernance.sol

pragma solidity ^0.5.2;

interface IGovernance {
    function update(address target, bytes calldata data) external;
}

// File: contracts/common/governance/Governable.sol

pragma solidity ^0.5.2;


contract Governable {
    IGovernance public governance;

    constructor(address _governance) public {
        governance = IGovernance(_governance);
    }

    modifier onlyGovernance() {
        _assertGovernance();
        _;
    }

    function _assertGovernance() private view {
        require(
            msg.sender == address(governance),
            "Only governance contract is authorized"
        );
    }
}

// File: contracts/root/withdrawManager/IWithdrawManager.sol

pragma solidity ^0.5.2;

contract IWithdrawManager {
    function createExitQueue(address token) external;

    function verifyInclusion(
        bytes calldata data,
        uint8 offset,
        bool verifyTxInclusion
    ) external view returns (uint256 age);

    function addExitToQueue(
        address exitor,
        address childToken,
        address rootToken,
        uint256 exitAmountOrTokenId,
        bytes32 txHash,
        bool isRegularExit,
        uint256 priority
    ) external;

    function addInput(
        uint256 exitId,
        uint256 age,
        address utxoOwner,
        address token
    ) external;

    function challengeExit(
        uint256 exitId,
        uint256 inputId,
        bytes calldata challengeData,
        address adjudicatorPredicate
    ) external;
}

// File: contracts/common/Registry.sol

pragma solidity ^0.5.2;




contract Registry is Governable {
    // @todo hardcode constants
    bytes32 private constant WETH_TOKEN = keccak256("wethToken");
    bytes32 private constant DEPOSIT_MANAGER = keccak256("depositManager");
    bytes32 private constant STAKE_MANAGER = keccak256("stakeManager");
    bytes32 private constant VALIDATOR_SHARE = keccak256("validatorShare");
    bytes32 private constant WITHDRAW_MANAGER = keccak256("withdrawManager");
    bytes32 private constant CHILD_CHAIN = keccak256("childChain");
    bytes32 private constant STATE_SENDER = keccak256("stateSender");
    bytes32 private constant SLASHING_MANAGER = keccak256("slashingManager");

    address public erc20Predicate;
    address public erc721Predicate;

    mapping(bytes32 => address) public contractMap;
    mapping(address => address) public rootToChildToken;
    mapping(address => address) public childToRootToken;
    mapping(address => bool) public proofValidatorContracts;
    mapping(address => bool) public isERC721;

    enum Type {Invalid, ERC20, ERC721, Custom}
    struct Predicate {
        Type _type;
    }
    mapping(address => Predicate) public predicates;

    event TokenMapped(address indexed rootToken, address indexed childToken);
    event ProofValidatorAdded(address indexed validator, address indexed from);
    event ProofValidatorRemoved(address indexed validator, address indexed from);
    event PredicateAdded(address indexed predicate, address indexed from);
    event PredicateRemoved(address indexed predicate, address indexed from);
    event ContractMapUpdated(bytes32 indexed key, address indexed previousContract, address indexed newContract);

    constructor(address _governance) public Governable(_governance) {}

    function updateContractMap(bytes32 _key, address _address) external onlyGovernance {
        emit ContractMapUpdated(_key, contractMap[_key], _address);
        contractMap[_key] = _address;
    }

    /**
     * @dev Map root token to child token
     * @param _rootToken Token address on the root chain
     * @param _childToken Token address on the child chain
     * @param _isERC721 Is the token being mapped ERC721
     */
    function mapToken(
        address _rootToken,
        address _childToken,
        bool _isERC721
    ) external onlyGovernance {
        require(_rootToken != address(0x0) && _childToken != address(0x0), "INVALID_TOKEN_ADDRESS");
        rootToChildToken[_rootToken] = _childToken;
        childToRootToken[_childToken] = _rootToken;
        isERC721[_rootToken] = _isERC721;
        IWithdrawManager(contractMap[WITHDRAW_MANAGER]).createExitQueue(_rootToken);
        emit TokenMapped(_rootToken, _childToken);
    }

    function addErc20Predicate(address predicate) public onlyGovernance {
        require(predicate != address(0x0), "Can not add null address as predicate");
        erc20Predicate = predicate;
        addPredicate(predicate, Type.ERC20);
    }

    function addErc721Predicate(address predicate) public onlyGovernance {
        erc721Predicate = predicate;
        addPredicate(predicate, Type.ERC721);
    }

    function addPredicate(address predicate, Type _type) public onlyGovernance {
        require(predicates[predicate]._type == Type.Invalid, "Predicate already added");
        predicates[predicate]._type = _type;
        emit PredicateAdded(predicate, msg.sender);
    }

    function removePredicate(address predicate) public onlyGovernance {
        require(predicates[predicate]._type != Type.Invalid, "Predicate does not exist");
        delete predicates[predicate];
        emit PredicateRemoved(predicate, msg.sender);
    }

    function getValidatorShareAddress() public view returns (address) {
        return contractMap[VALIDATOR_SHARE];
    }

    function getWethTokenAddress() public view returns (address) {
        return contractMap[WETH_TOKEN];
    }

    function getDepositManagerAddress() public view returns (address) {
        return contractMap[DEPOSIT_MANAGER];
    }

    function getStakeManagerAddress() public view returns (address) {
        return contractMap[STAKE_MANAGER];
    }

    function getSlashingManagerAddress() public view returns (address) {
        return contractMap[SLASHING_MANAGER];
    }

    function getWithdrawManagerAddress() public view returns (address) {
        return contractMap[WITHDRAW_MANAGER];
    }

    function getChildChainAndStateSender() public view returns (address, address) {
        return (contractMap[CHILD_CHAIN], contractMap[STATE_SENDER]);
    }

    function isTokenMapped(address _token) public view returns (bool) {
        return rootToChildToken[_token] != address(0x0);
    }

    function isTokenMappedAndIsErc721(address _token) public view returns (bool) {
        require(isTokenMapped(_token), "TOKEN_NOT_MAPPED");
        return isERC721[_token];
    }

    function isTokenMappedAndGetPredicate(address _token) public view returns (address) {
        if (isTokenMappedAndIsErc721(_token)) {
            return erc721Predicate;
        }
        return erc20Predicate;
    }

    function isChildTokenErc721(address childToken) public view returns (bool) {
        address rootToken = childToRootToken[childToken];
        require(rootToken != address(0x0), "Child token is not mapped");
        return isERC721[rootToken];
    }
}

// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.2;

/**
 * @title ERC20 interface
 * @dev see https://eips.ethereum.org/EIPS/eip-20
 */
interface IERC20 {
    function transfer(address to, uint256 value) external returns (bool);

    function approve(address spender, uint256 value) external returns (bool);

    function transferFrom(address from, address to, uint256 value) external returns (bool);

    function totalSupply() external view returns (uint256);

    function balanceOf(address who) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: openzeppelin-solidity/contracts/math/SafeMath.sol

pragma solidity ^0.5.2;

/**
 * @title SafeMath
 * @dev Unsigned math operations with safety checks that revert on error
 */
library SafeMath {
    /**
     * @dev Multiplies two unsigned integers, reverts on overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b);

        return c;
    }

    /**
     * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Adds two unsigned integers, reverts on overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);

        return c;
    }

    /**
     * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
     * reverts when dividing by zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}

// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol

pragma solidity ^0.5.2;



/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * https://eips.ethereum.org/EIPS/eip-20
 * Originally based on code by FirstBlood:
 * https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 *
 * This implementation emits additional Approval events, allowing applications to reconstruct the allowance status for
 * all accounts just by listening to said events. Note that this isn't required by the specification, and other
 * compliant implementations may not do it.
 */
contract ERC20 is IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowed;

    uint256 private _totalSupply;

    /**
     * @dev Total number of tokens in existence
     */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev Gets the balance of the specified address.
     * @param owner The address to query the balance of.
     * @return A uint256 representing the amount owned by the passed address.
     */
    function balanceOf(address owner) public view returns (uint256) {
        return _balances[owner];
    }

    /**
     * @dev Function to check the amount of tokens that an owner allowed to a spender.
     * @param owner address The address which owns the funds.
     * @param spender address The address which will spend the funds.
     * @return A uint256 specifying the amount of tokens still available for the spender.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowed[owner][spender];
    }

    /**
     * @dev Transfer token to a specified address
     * @param to The address to transfer to.
     * @param value The amount to be transferred.
     */
    function transfer(address to, uint256 value) public returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    /**
     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
     * Beware that changing an allowance with this method brings the risk that someone may use both the old
     * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
     * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     */
    function approve(address spender, uint256 value) public returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev Transfer tokens from one address to another.
     * Note that while this function emits an Approval event, this is not required as per the specification,
     * and other compliant implementations may not emit the event.
     * @param from address The address which you want to send tokens from
     * @param to address The address which you want to tr vbmansfer to
     * @param value uint256 the amount of tokens to be transferred
     */
    function transferFrom(address from, address to, uint256 value) public returns (bool) {
        _transfer(from, to, value);
        _approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
        return true;
    }

    /**
     * @dev Increase the amount of tokens that an owner allowed to a spender.
     * approve should be called when _allowed[msg.sender][spender] == 0. To increment
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param addedValue The amount of tokens to increase the allowance by.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Decrease the amount of tokens that an owner allowed to a spender.
     * approve should be called when _allowed[msg.sender][spender] == 0. To decrement
     * allowed value is better to use this function to avoid 2 calls (and wait until
     * the first transaction is mined)
     * From MonolithDAO Token.sol
     * Emits an Approval event.
     * @param spender The address which will spend the funds.
     * @param subtractedValue The amount of tokens to decrease the allowance by.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
        return true;
    }

    /**
     * @dev Transfer token for a specified addresses
     * @param from The address to transfer from.
     * @param to The address to transfer to.
     * @param value The amount to be transferred.
     */
    function _transfer(address from, address to, uint256 value) internal {
        require(to != address(0));

        _balances[from] = _balances[from].sub(value);
        _balances[to] = _balances[to].add(value);
        emit Transfer(from, to, value);
    }

    /**
     * @dev Internal function that mints an amount of the token and assigns it to
     * an account. This encapsulates the modification of balances such that the
     * proper events are emitted.
     * @param account The account that will receive the created tokens.
     * @param value The amount that will be created.
     */
    function _mint(address account, uint256 value) internal {
        require(account != address(0));

        _totalSupply = _totalSupply.add(value);
        _balances[account] = _balances[account].add(value);
        emit Transfer(address(0), account, value);
    }

    /**
     * @dev Internal function that burns an amount of the token of a given
     * account.
     * @param account The account whose tokens will be burnt.
     * @param value The amount that will be burnt.
     */
    function _burn(address account, uint256 value) internal {
        require(account != address(0));

        _totalSupply = _totalSupply.sub(value);
        _balances[account] = _balances[account].sub(value);
        emit Transfer(account, address(0), value);
    }

    /**
     * @dev Approve an address to spend another addresses' tokens.
     * @param owner The address that owns the tokens.
     * @param spender The address that will spend the tokens.
     * @param value The number of tokens that can be spent.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        require(spender != address(0));
        require(owner != address(0));

        _allowed[owner][spender] = value;
        emit Approval(owner, spender, value);
    }

    /**
     * @dev Internal function that burns an amount of the token of a given
     * account, deducting from the sender's allowance for said account. Uses the
     * internal burn function.
     * Emits an Approval event (reflecting the reduced allowance).
     * @param account The account whose tokens will be burnt.
     * @param value The amount that will be burnt.
     */
    function _burnFrom(address account, uint256 value) internal {
        _burn(account, value);
        _approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
    }
}

// File: contracts/common/tokens/ERC20NonTradable.sol

pragma solidity ^0.5.2;


contract ERC20NonTradable is ERC20 {
    function _approve(
        address owner,
        address spender,
        uint256 value
    ) internal {
        revert("disabled");
    }
}

// File: openzeppelin-solidity/contracts/ownership/Ownable.sol

pragma solidity ^0.5.2;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
     * account.
     */
    constructor () internal {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

    /**
     * @return the address of the owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner());
        _;
    }

    /**
     * @return true if `msg.sender` is the owner of the contract.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

    /**
     * @dev Allows the current owner to relinquish control of the contract.
     * It will not be possible to call the functions with the `onlyOwner`
     * modifier anymore.
     * @notice Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Allows the current owner to transfer control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0));
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: contracts/staking/StakingInfo.sol

pragma solidity ^0.5.2;





// dummy interface to avoid cyclic dependency
contract IStakeManagerLocal {
    enum Status {Inactive, Active, Locked, Unstaked}

    struct Validator {
        uint256 amount;
        uint256 reward;
        uint256 activationEpoch;
        uint256 deactivationEpoch;
        uint256 jailTime;
        address signer;
        address contractAddress;
        Status status;
    }

    mapping(uint256 => Validator) public validators;
    bytes32 public accountStateRoot;
    uint256 public activeAmount; // delegation amount from validator contract
    uint256 public validatorRewards;

    function currentValidatorSetTotalStake() public view returns (uint256);

    // signer to Validator mapping
    function signerToValidator(address validatorAddress)
        public
        view
        returns (uint256);

    function isValidator(uint256 validatorId) public view returns (bool);
}

contract StakingInfo is Ownable {
    using SafeMath for uint256;
    mapping(uint256 => uint256) public validatorNonce;

    /// @dev Emitted when validator stakes in '_stakeFor()' in StakeManager.
    /// @param signer validator address.
    /// @param validatorId unique integer to identify a validator.
    /// @param nonce to synchronize the events in heimdal.
    /// @param activationEpoch validator's first epoch as proposer.
    /// @param amount staking amount.
    /// @param total total staking amount.
    /// @param signerPubkey public key of the validator
    event Staked(
        address indexed signer,
        uint256 indexed validatorId,
        uint256 nonce,
        uint256 indexed activationEpoch,
        uint256 amount,
        uint256 total,
        bytes signerPubkey
    );

    /// @dev Emitted when validator unstakes in 'unstakeClaim()'
    /// @param user address of the validator.
    /// @param validatorId unique integer to identify a validator.
    /// @param amount staking amount.
    /// @param total total staking amount.
    event Unstaked(
        address indexed user,
        uint256 indexed validatorId,
        uint256 amount,
        uint256 total
    );

    /// @dev Emitted when validator unstakes in '_unstake()'.
    /// @param user address of the validator.
    /// @param validatorId unique integer to identify a validator.
    /// @param nonce to synchronize the events in heimdal.
    /// @param deactivationEpoch last epoch for validator.
    /// @param amount staking amount.
    event UnstakeInit(
        address indexed user,
        uint256 indexed validatorId,
        uint256 nonce,
        uint256 deactivationEpoch,
        uint256 indexed amount
    );

    /// @dev Emitted when the validator public key is updated in 'updateSigner()'.
    /// @param validatorId unique integer to identify a validator.
    /// @param nonce to synchronize the events in heimdal.
    /// @param oldSigner old address of the validator.
    /// @param newSigner new address of the validator.
    /// @param signerPubkey public key of the validator.
    event SignerChange(
        uint256 indexed validatorId,
        uint256 nonce,
        address indexed oldSigner,
        address indexed newSigner,
        bytes signerPubkey
    );
    event Restaked(uint256 indexed validatorId, uint256 amount, uint256 total);
    event Jailed(
        uint256 indexed validatorId,
        uint256 indexed exitEpoch,
        address indexed signer
    );
    event UnJailed(uint256 indexed validatorId, address indexed signer);
    event Slashed(uint256 indexed nonce, uint256 indexed amount);
    event ThresholdChange(uint256 newThreshold, uint256 oldThreshold);
    event DynastyValueChange(uint256 newDynasty, uint256 oldDynasty);
    event ProposerBonusChange(
        uint256 newProposerBonus,
        uint256 oldProposerBonus
    );

    event RewardUpdate(uint256 newReward, uint256 oldReward);

    /// @dev Emitted when validator confirms the auction bid and at the time of restaking in confirmAuctionBid() and restake().
    /// @param validatorId unique integer to identify a validator.
    /// @param nonce to synchronize the events in heimdal.
    /// @param newAmount the updated stake amount.
    event StakeUpdate(
        uint256 indexed validatorId,
        uint256 indexed nonce,
        uint256 indexed newAmount
    );
    event ClaimRewards(
        uint256 indexed validatorId,
        uint256 indexed amount,
        uint256 indexed totalAmount
    );
    event StartAuction(
        uint256 indexed validatorId,
        uint256 indexed amount,
        uint256 indexed auctionAmount
    );
    event ConfirmAuction(
        uint256 indexed newValidatorId,
        uint256 indexed oldValidatorId,
        uint256 indexed amount
    );
    event TopUpFee(address indexed user, uint256 indexed fee);
    event ClaimFee(address indexed user, uint256 indexed fee);
    // Delegator events
    event ShareMinted(
        uint256 indexed validatorId,
        address indexed user,
        uint256 indexed amount,
        uint256 tokens
    );
    event ShareBurned(
        uint256 indexed validatorId,
        address indexed user,
        uint256 indexed amount,
        uint256 tokens
    );
    event DelegatorClaimedRewards(
        uint256 indexed validatorId,
        address indexed user,
        uint256 indexed rewards
    );
    event DelegatorRestaked(
        uint256 indexed validatorId,
        address indexed user,
        uint256 indexed totalStaked
    );
    event DelegatorUnstaked(
        uint256 indexed validatorId,
        address indexed user,
        uint256 amount
    );
    event UpdateCommissionRate(
        uint256 indexed validatorId,
        uint256 indexed newCommissionRate,
        uint256 indexed oldCommissionRate
    );

    Registry public registry;

    modifier onlyValidatorContract(uint256 validatorId) {
        address _contract;
        (, , , , , , _contract, ) = IStakeManagerLocal(
            registry.getStakeManagerAddress()
        )
            .validators(validatorId);
        require(_contract == msg.sender,
        "Invalid sender, not validator");
        _;
    }

    modifier StakeManagerOrValidatorContract(uint256 validatorId) {
        address _contract;
        address _stakeManager = registry.getStakeManagerAddress();
        (, , , , , , _contract, ) = IStakeManagerLocal(_stakeManager).validators(
            validatorId
        );
        require(_contract == msg.sender || _stakeManager == msg.sender,
        "Invalid sender, not stake manager or validator contract");
        _;
    }

    modifier onlyStakeManager() {
        require(registry.getStakeManagerAddress() == msg.sender,
        "Invalid sender, not stake manager");
        _;
    }
    modifier onlySlashingManager() {
        require(registry.getSlashingManagerAddress() == msg.sender,
        "Invalid sender, not slashing manager");
        _;
    }

    constructor(address _registry) public {
        registry = Registry(_registry);
    }

    function updateNonce(
        uint256[] calldata validatorIds,
        uint256[] calldata nonces
    ) external onlyOwner {
        require(validatorIds.length == nonces.length, "args length mismatch");

        for (uint256 i = 0; i < validatorIds.length; ++i) {
            validatorNonce[validatorIds[i]] = nonces[i];
        }
    } 

    function logStaked(
        address signer,
        bytes memory signerPubkey,
        uint256 validatorId,
        uint256 activationEpoch,
        uint256 amount,
        uint256 total
    ) public onlyStakeManager {
        validatorNonce[validatorId] = validatorNonce[validatorId].add(1);
        emit Staked(
            signer,
            validatorId,
            validatorNonce[validatorId],
            activationEpoch,
            amount,
            total,
            signerPubkey
        );
    }

    function logUnstaked(
        address user,
        uint256 validatorId,
        uint256 amount,
        uint256 total
    ) public onlyStakeManager {
        emit Unstaked(user, validatorId, amount, total);
    }

    function logUnstakeInit(
        address user,
        uint256 validatorId,
        uint256 deactivationEpoch,
        uint256 amount
    ) public onlyStakeManager {
        validatorNonce[validatorId] = validatorNonce[validatorId].add(1);
        emit UnstakeInit(
            user,
            validatorId,
            validatorNonce[validatorId],
            deactivationEpoch,
            amount
        );
    }

    function logSignerChange(
        uint256 validatorId,
        address oldSigner,
        address newSigner,
        bytes memory signerPubkey
    ) public onlyStakeManager {
        validatorNonce[validatorId] = validatorNonce[validatorId].add(1);
        emit SignerChange(
            validatorId,
            validatorNonce[validatorId],
            oldSigner,
            newSigner,
            signerPubkey
        );
    }

    function logRestaked(uint256 validatorId, uint256 amount, uint256 total)
        public
        onlyStakeManager
    {
        emit Restaked(validatorId, amount, total);
    }

    function logJailed(uint256 validatorId, uint256 exitEpoch, address signer)
        public
        onlyStakeManager
    {
        emit Jailed(validatorId, exitEpoch, signer);
    }

    function logUnjailed(uint256 validatorId, address signer)
        public
        onlyStakeManager
    {
        emit UnJailed(validatorId, signer);
    }

    function logSlashed(uint256 nonce, uint256 amount)
        public
        onlySlashingManager
    {
        emit Slashed(nonce, amount);
    }

    function logThresholdChange(uint256 newThreshold, uint256 oldThreshold)
        public
        onlyStakeManager
    {
        emit ThresholdChange(newThreshold, oldThreshold);
    }

    function logDynastyValueChange(uint256 newDynasty, uint256 oldDynasty)
        public
        onlyStakeManager
    {
        emit DynastyValueChange(newDynasty, oldDynasty);
    }

    function logProposerBonusChange(
        uint256 newProposerBonus,
        uint256 oldProposerBonus
    ) public onlyStakeManager {
        emit ProposerBonusChange(newProposerBonus, oldProposerBonus);
    }

    function logRewardUpdate(uint256 newReward, uint256 oldReward)
        public
        onlyStakeManager
    {
        emit RewardUpdate(newReward, oldReward);
    }

    function logStakeUpdate(uint256 validatorId)
        public
        StakeManagerOrValidatorContract(validatorId)
    {
        validatorNonce[validatorId] = validatorNonce[validatorId].add(1);
        emit StakeUpdate(
            validatorId,
            validatorNonce[validatorId],
            totalValidatorStake(validatorId)
        );
    }

    function logClaimRewards(
        uint256 validatorId,
        uint256 amount,
        uint256 totalAmount
    ) public onlyStakeManager {
        emit ClaimRewards(validatorId, amount, totalAmount);
    }

    function logStartAuction(
        uint256 validatorId,
        uint256 amount,
        uint256 auctionAmount
    ) public onlyStakeManager {
        emit StartAuction(validatorId, amount, auctionAmount);
    }

    function logConfirmAuction(
        uint256 newValidatorId,
        uint256 oldValidatorId,
        uint256 amount
    ) public onlyStakeManager {
        emit ConfirmAuction(newValidatorId, oldValidatorId, amount);
    }

    function logTopUpFee(address user, uint256 fee) public onlyStakeManager {
        emit TopUpFee(user, fee);
    }

    function logClaimFee(address user, uint256 fee) public onlyStakeManager {
        emit ClaimFee(user, fee);
    }

    function getStakerDetails(uint256 validatorId)
        public
        view
        returns (
            uint256 amount,
            uint256 reward,
            uint256 activationEpoch,
            uint256 deactivationEpoch,
            address signer,
            uint256 _status
        )
    {
        IStakeManagerLocal stakeManager = IStakeManagerLocal(
            registry.getStakeManagerAddress()
        );
        address _contract;
        IStakeManagerLocal.Status status;
        (
            amount,
            reward,
            activationEpoch,
            deactivationEpoch,
            ,
            signer,
            _contract,
            status
        ) = stakeManager.validators(validatorId);
        _status = uint256(status);
        if (_contract != address(0x0)) {
            reward += IStakeManagerLocal(_contract).validatorRewards();
        }
    }

    function totalValidatorStake(uint256 validatorId)
        public
        view
        returns (uint256 validatorStake)
    {
        address contractAddress;
        (validatorStake, , , , , , contractAddress, ) = IStakeManagerLocal(
            registry.getStakeManagerAddress()
        )
            .validators(validatorId);
        if (contractAddress != address(0x0)) {
            validatorStake += IStakeManagerLocal(contractAddress).activeAmount();
        }
    }

    function getAccountStateRoot()
        public
        view
        returns (bytes32 accountStateRoot)
    {
        accountStateRoot = IStakeManagerLocal(registry.getStakeManagerAddress())
            .accountStateRoot();
    }

    function getValidatorContractAddress(uint256 validatorId)
        public
        view
        returns (address ValidatorContract)
    {
        (, , , , , , ValidatorContract, ) = IStakeManagerLocal(
            registry.getStakeManagerAddress()
        )
            .validators(validatorId);
    }

    // validator Share contract logging func
    function logShareMinted(
        uint256 validatorId,
        address user,
        uint256 amount,
        uint256 tokens
    ) public onlyValidatorContract(validatorId) {
        emit ShareMinted(validatorId, user, amount, tokens);
    }

    function logShareBurned(
        uint256 validatorId,
        address user,
        uint256 amount,
        uint256 tokens
    ) public onlyValidatorContract(validatorId) {
        emit ShareBurned(validatorId, user, amount, tokens);
    }

    function logDelegatorClaimRewards(
        uint256 validatorId,
        address user,
        uint256 rewards
    ) public onlyValidatorContract(validatorId) {
        emit DelegatorClaimedRewards(validatorId, user, rewards);
    }

    function logDelegatorRestaked(
        uint256 validatorId,
        address user,
        uint256 totalStaked
    ) public onlyValidatorContract(validatorId) {
        emit DelegatorRestaked(validatorId, user, totalStaked);
    }

    function logDelegatorUnstaked(uint256 validatorId, address user, uint256 amount)
        public
        onlyValidatorContract(validatorId)
    {
        emit DelegatorUnstaked(validatorId, user, amount);
    }

    // deprecated
    function logUpdateCommissionRate(
        uint256 validatorId,
        uint256 newCommissionRate,
        uint256 oldCommissionRate
    ) public onlyValidatorContract(validatorId) {
        emit UpdateCommissionRate(
            validatorId,
            newCommissionRate,
            oldCommissionRate
        );
    }
}

// File: contracts/common/mixin/Initializable.sol

pragma solidity ^0.5.2;

contract Initializable {
    bool inited = false;

    modifier initializer() {
        require(!inited, "already inited");
        inited = true;
        
        _;
    }
}

// File: contracts/staking/EventsHub.sol

pragma solidity ^0.5.2;



contract IStakeManagerEventsHub {
    struct Validator {
        uint256 amount;
        uint256 reward;
        uint256 activationEpoch;
        uint256 deactivationEpoch;
        uint256 jailTime;
        address signer;
        address contractAddress;
    }

    mapping(uint256 => Validator) public validators;
}

contract EventsHub is Initializable {
    Registry public registry;

    modifier onlyValidatorContract(uint256 validatorId) {
        address _contract;
        (, , , , , , _contract) = IStakeManagerEventsHub(registry.getStakeManagerAddress()).validators(validatorId);
        require(_contract == msg.sender, "not validator");
        _;
    }

    modifier onlyStakeManager() {
        require(registry.getStakeManagerAddress() == msg.sender,
        "Invalid sender, not stake manager");
        _;
    }

    function initialize(Registry _registry) external initializer {
        registry = _registry;
    }

    event ShareBurnedWithId(
        uint256 indexed validatorId,
        address indexed user,
        uint256 indexed amount,
        uint256 tokens,
        uint256 nonce
    );

    function logShareBurnedWithId(
        uint256 validatorId,
        address user,
        uint256 amount,
        uint256 tokens,
        uint256 nonce
    ) public onlyValidatorContract(validatorId) {
        emit ShareBurnedWithId(validatorId, user, amount, tokens, nonce);
    }

    event DelegatorUnstakeWithId(
        uint256 indexed validatorId,
        address indexed user,
        uint256 amount,
        uint256 nonce
    );

    function logDelegatorUnstakedWithId(
        uint256 validatorId,
        address user,
        uint256 amount,
        uint256 nonce
    ) public onlyValidatorContract(validatorId) {
        emit DelegatorUnstakeWithId(validatorId, user, amount, nonce);
    }

    event RewardParams(
        uint256 rewardDecreasePerCheckpoint,
        uint256 maxRewardedCheckpoints,
        uint256 checkpointRewardDelta
    );

    function logRewardParams(
        uint256 rewardDecreasePerCheckpoint,
        uint256 maxRewardedCheckpoints,
        uint256 checkpointRewardDelta
    ) public onlyStakeManager {
        emit RewardParams(rewardDecreasePerCheckpoint, maxRewardedCheckpoints, checkpointRewardDelta);
    }

    event UpdateCommissionRate(
        uint256 indexed validatorId,
        uint256 indexed newCommissionRate,
        uint256 indexed oldCommissionRate
    );

    function logUpdateCommissionRate(
        uint256 validatorId,
        uint256 newCommissionRate,
        uint256 oldCommissionRate
    ) public onlyStakeManager {
        emit UpdateCommissionRate(
            validatorId,
            newCommissionRate,
            oldCommissionRate
        );
    }
}

// File: contracts/common/mixin/Lockable.sol

pragma solidity ^0.5.2;

contract Lockable {
    bool public locked;

    modifier onlyWhenUnlocked() {
        _assertUnlocked();
        _;
    }

    function _assertUnlocked() private view {
        require(!locked, "locked");
    }

    function lock() public {
        locked = true;
    }

    function unlock() public {
        locked = false;
    }
}

// File: contracts/common/mixin/OwnableLockable.sol

pragma solidity ^0.5.2;



contract OwnableLockable is Lockable, Ownable {
    function lock() public onlyOwner {
        super.lock();
    }

    function unlock() public onlyOwner {
        super.unlock();
    }
}

// File: contracts/staking/stakeManager/IStakeManager.sol

pragma solidity 0.5.17;

contract IStakeManager {
    // validator replacement
    function startAuction(
        uint256 validatorId,
        uint256 amount,
        bool acceptDelegation,
        bytes calldata signerPubkey
    ) external;

    function confirmAuctionBid(uint256 validatorId, uint256 heimdallFee) external;

    function transferFunds(
        uint256 validatorId,
        uint256 amount,
        address delegator
    ) external returns (bool);

    function delegationDeposit(
        uint256 validatorId,
        uint256 amount,
        address delegator
    ) external returns (bool);

    function unstake(uint256 validatorId) external;

    function totalStakedFor(address addr) external view returns (uint256);

    function stakeFor(
        address user,
        uint256 amount,
        uint256 heimdallFee,
        bool acceptDelegation,
        bytes memory signerPubkey
    ) public;

    function checkSignatures(
        uint256 blockInterval,
        bytes32 voteHash,
        bytes32 stateRoot,
        address proposer,
        uint[3][] calldata sigs
    ) external returns (uint256);

    function updateValidatorState(uint256 validatorId, int256 amount) public;

    function ownerOf(uint256 tokenId) public view returns (address);

    function slash(bytes calldata slashingInfoList) external returns (uint256);

    function validatorStake(uint256 validatorId) public view returns (uint256);

    function epoch() public view returns (uint256);

    function getRegistry() public view returns (address);

    function withdrawalDelay() public view returns (uint256);

    function delegatedAmount(uint256 validatorId) public view returns(uint256);

    function decreaseValidatorDelegatedAmount(uint256 validatorId, uint256 amount) public;

    function withdrawDelegatorsReward(uint256 validatorId) public returns(uint256);

    function delegatorsReward(uint256 validatorId) public view returns(uint256);

    function dethroneAndStake(
        address auctionUser,
        uint256 heimdallFee,
        uint256 validatorId,
        uint256 auctionAmount,
        bool acceptDelegation,
        bytes calldata signerPubkey
    ) external;
}

// File: contracts/staking/validatorShare/IValidatorShare.sol

pragma solidity 0.5.17;

// note this contract interface is only for stakeManager use
contract IValidatorShare {
    function withdrawRewards() public;

    function unstakeClaimTokens() public;

    function getLiquidRewards(address user) public view returns (uint256);
    
    function owner() public view returns (address);

    function restake() public returns(uint256, uint256);

    function unlock() external;

    function lock() external;

    function drain(
        address token,
        address payable destination,
        uint256 amount
    ) external;

    function slash(uint256 valPow, uint256 delegatedAmount, uint256 totalAmountToSlash) external returns (uint256);

    function updateDelegation(bool delegation) external;

    function migrateOut(address user, uint256 amount) external;

    function migrateIn(address user, uint256 amount) external;
}

// File: contracts/staking/validatorShare/ValidatorShare.sol

pragma solidity 0.5.17;










contract ValidatorShare is IValidatorShare, ERC20NonTradable, OwnableLockable, Initializable {
    struct DelegatorUnbond {
        uint256 shares;
        uint256 withdrawEpoch;
    }

    uint256 constant EXCHANGE_RATE_PRECISION = 100;
    // maximum matic possible, even if rate will be 1 and all matic will be staken in one go, it will result in 10 ^ 58 shares
    uint256 constant EXCHANGE_RATE_HIGH_PRECISION = 10**29;
    uint256 constant MAX_COMMISION_RATE = 100;
    uint256 constant REWARD_PRECISION = 10**25;

    StakingInfo public stakingLogger;
    IStakeManager public stakeManager;
    uint256 public validatorId;
    uint256 public validatorRewards_deprecated;
    uint256 public commissionRate_deprecated;
    uint256 public lastCommissionUpdate_deprecated;
    uint256 public minAmount;

    uint256 public totalStake_deprecated;
    uint256 public rewardPerShare;
    uint256 public activeAmount;

    bool public delegation;

    uint256 public withdrawPool;
    uint256 public withdrawShares;

    mapping(address => uint256) amountStaked_deprecated; // deprecated, keep for foundation delegators
    mapping(address => DelegatorUnbond) public unbonds;
    mapping(address => uint256) public initalRewardPerShare;

    mapping(address => uint256) public unbondNonces;
    mapping(address => mapping(uint256 => DelegatorUnbond)) public unbonds_new;

    EventsHub public eventsHub;

    // onlyOwner will prevent this contract from initializing, since it's owner is going to be 0x0 address
    function initialize(
        uint256 _validatorId,
        address _stakingLogger,
        address _stakeManager
    ) external initializer {
        validatorId = _validatorId;
        stakingLogger = StakingInfo(_stakingLogger);
        stakeManager = IStakeManager(_stakeManager);
        _transferOwnership(_stakeManager);
        _getOrCacheEventsHub();

        minAmount = 10**18;
        delegation = true;
    }

    /**
        Public View Methods
    */

    function exchangeRate() public view returns (uint256) {
        uint256 totalShares = totalSupply();
        uint256 precision = _getRatePrecision();
        return totalShares == 0 ? precision : stakeManager.delegatedAmount(validatorId).mul(precision).div(totalShares);
    }

    function getTotalStake(address user) public view returns (uint256, uint256) {
        uint256 shares = balanceOf(user);
        uint256 rate = exchangeRate();
        if (shares == 0) {
            return (0, rate);
        }

        return (rate.mul(shares).div(_getRatePrecision()), rate);
    }

    function withdrawExchangeRate() public view returns (uint256) {
        uint256 precision = _getRatePrecision();
        if (validatorId < 8) {
            // fix of potentially broken withdrawals for future unbonding
            // foundation validators have no slashing enabled and thus we can return default exchange rate
            // because without slashing rate will stay constant
            return precision;
        }

        uint256 _withdrawShares = withdrawShares;
        return _withdrawShares == 0 ? precision : withdrawPool.mul(precision).div(_withdrawShares);
    }

    function getLiquidRewards(address user) public view returns (uint256) {
        return _calculateReward(user, getRewardPerShare());
    }

    function getRewardPerShare() public view returns (uint256) {
        return _calculateRewardPerShareWithRewards(stakeManager.delegatorsReward(validatorId));
    }

    /**
        Public Methods
     */

    function buyVoucher(uint256 _amount, uint256 _minSharesToMint) public returns(uint256 amountToDeposit) {
        _withdrawAndTransferReward(msg.sender);
        
        amountToDeposit = _buyShares(_amount, _minSharesToMint, msg.sender);
        require(stakeManager.delegationDeposit(validatorId, amountToDeposit, msg.sender), "deposit failed");
        
        return amountToDeposit;
    }

    function restake() public returns(uint256, uint256) {
        address user = msg.sender;
        uint256 liquidReward = _withdrawReward(user);
        uint256 amountRestaked;

        require(liquidReward >= minAmount, "Too small rewards to restake");

        if (liquidReward != 0) {
            amountRestaked = _buyShares(liquidReward, 0, user);

            if (liquidReward > amountRestaked) {
                // return change to the user
                require(
                    stakeManager.transferFunds(validatorId, liquidReward - amountRestaked, user),
                    "Insufficent rewards"
                );
                stakingLogger.logDelegatorClaimRewards(validatorId, user, liquidReward - amountRestaked);
            }

            (uint256 totalStaked, ) = getTotalStake(user);
            stakingLogger.logDelegatorRestaked(validatorId, user, totalStaked);
        }
        
        return (amountRestaked, liquidReward);
    }

    function sellVoucher(uint256 claimAmount, uint256 maximumSharesToBurn) public {
        (uint256 shares, uint256 _withdrawPoolShare) = _sellVoucher(claimAmount, maximumSharesToBurn);

        DelegatorUnbond memory unbond = unbonds[msg.sender];
        unbond.shares = unbond.shares.add(_withdrawPoolShare);
        // refresh undond period
        unbond.withdrawEpoch = stakeManager.epoch();
        unbonds[msg.sender] = unbond;

        StakingInfo logger = stakingLogger;
        logger.logShareBurned(validatorId, msg.sender, claimAmount, shares);
        logger.logStakeUpdate(validatorId);
    }

    function withdrawRewards() public {
        uint256 rewards = _withdrawAndTransferReward(msg.sender);
        require(rewards >= minAmount, "Too small rewards amount");
    }

    function migrateOut(address user, uint256 amount) external onlyOwner {
        _withdrawAndTransferReward(user);
        (uint256 totalStaked, uint256 rate) = getTotalStake(user);
        require(totalStaked >= amount, "Migrating too much");

        uint256 precision = _getRatePrecision();
        uint256 shares = amount.mul(precision).div(rate);
        _burn(user, shares);

        stakeManager.updateValidatorState(validatorId, -int256(amount));
        activeAmount = activeAmount.sub(amount);

        stakingLogger.logShareBurned(validatorId, user, amount, shares);
        stakingLogger.logStakeUpdate(validatorId);
        stakingLogger.logDelegatorUnstaked(validatorId, user, amount);
    }

    function migrateIn(address user, uint256 amount) external onlyOwner {
        _withdrawAndTransferReward(user);
        _buyShares(amount, 0, user);
    }

    function unstakeClaimTokens() public {
        DelegatorUnbond memory unbond = unbonds[msg.sender];
        uint256 amount = _unstakeClaimTokens(unbond);
        delete unbonds[msg.sender];
        stakingLogger.logDelegatorUnstaked(validatorId, msg.sender, amount);
    }

    function slash(
        uint256 validatorStake,
        uint256 delegatedAmount,
        uint256 totalAmountToSlash
    ) external onlyOwner returns (uint256) {
        uint256 _withdrawPool = withdrawPool;
        uint256 delegationAmount = delegatedAmount.add(_withdrawPool);
        if (delegationAmount == 0) {
            return 0;
        }
        // total amount to be slashed from delegation pool (active + inactive)
        uint256 _amountToSlash = delegationAmount.mul(totalAmountToSlash).div(validatorStake.add(delegationAmount));
        uint256 _amountToSlashWithdrawalPool = _withdrawPool.mul(_amountToSlash).div(delegationAmount);

        // slash inactive pool
        uint256 stakeSlashed = _amountToSlash.sub(_amountToSlashWithdrawalPool);
        stakeManager.decreaseValidatorDelegatedAmount(validatorId, stakeSlashed);
        activeAmount = activeAmount.sub(stakeSlashed);

        withdrawPool = withdrawPool.sub(_amountToSlashWithdrawalPool);
        return _amountToSlash;
    }

    function updateDelegation(bool _delegation) external onlyOwner {
        delegation = _delegation;
    }

    function drain(
        address token,
        address payable destination,
        uint256 amount
    ) external onlyOwner {
        if (token == address(0x0)) {
            destination.transfer(amount);
        } else {
            require(ERC20(token).transfer(destination, amount), "Drain failed");
        }
    }

    /**
        New shares exit API
     */

    function sellVoucher_new(uint256 claimAmount, uint256 maximumSharesToBurn) public {
        (uint256 shares, uint256 _withdrawPoolShare) = _sellVoucher(claimAmount, maximumSharesToBurn);

        uint256 unbondNonce = unbondNonces[msg.sender].add(1);

        DelegatorUnbond memory unbond = DelegatorUnbond({
            shares: _withdrawPoolShare,
            withdrawEpoch: stakeManager.epoch()
        });
        unbonds_new[msg.sender][unbondNonce] = unbond;
        unbondNonces[msg.sender] = unbondNonce;

        _getOrCacheEventsHub().logShareBurnedWithId(validatorId, msg.sender, claimAmount, shares, unbondNonce);
        stakingLogger.logStakeUpdate(validatorId);
    }

    function unstakeClaimTokens_new(uint256 unbondNonce) public {
        DelegatorUnbond memory unbond = unbonds_new[msg.sender][unbondNonce];
        uint256 amount = _unstakeClaimTokens(unbond);
        delete unbonds_new[msg.sender][unbondNonce];
        _getOrCacheEventsHub().logDelegatorUnstakedWithId(validatorId, msg.sender, amount, unbondNonce);
    }

    /**
        Private Methods
     */

    function _getOrCacheEventsHub() private returns(EventsHub) {
        EventsHub _eventsHub = eventsHub;
        if (_eventsHub == EventsHub(0x0)) {
            _eventsHub = EventsHub(Registry(stakeManager.getRegistry()).contractMap(keccak256("eventsHub")));
            eventsHub = _eventsHub;
        }
        return _eventsHub;
    }

    function _sellVoucher(uint256 claimAmount, uint256 maximumSharesToBurn) private returns(uint256, uint256) {
        // first get how much staked in total and compare to target unstake amount
        (uint256 totalStaked, uint256 rate) = getTotalStake(msg.sender);
        require(totalStaked != 0 && totalStaked >= claimAmount, "Too much requested");

        // convert requested amount back to shares
        uint256 precision = _getRatePrecision();
        uint256 shares = claimAmount.mul(precision).div(rate);
        require(shares <= maximumSharesToBurn, "too much slippage");

        _withdrawAndTransferReward(msg.sender);

        _burn(msg.sender, shares);
        stakeManager.updateValidatorState(validatorId, -int256(claimAmount));
        activeAmount = activeAmount.sub(claimAmount);

        uint256 _withdrawPoolShare = claimAmount.mul(precision).div(withdrawExchangeRate());
        withdrawPool = withdrawPool.add(claimAmount);
        withdrawShares = withdrawShares.add(_withdrawPoolShare);

        return (shares, _withdrawPoolShare);
    }

    function _unstakeClaimTokens(DelegatorUnbond memory unbond) private returns(uint256) {
        uint256 shares = unbond.shares;
        require(
            unbond.withdrawEpoch.add(stakeManager.withdrawalDelay()) <= stakeManager.epoch() && shares > 0,
            "Incomplete withdrawal period"
        );

        uint256 _amount = withdrawExchangeRate().mul(shares).div(_getRatePrecision());
        withdrawShares = withdrawShares.sub(shares);
        withdrawPool = withdrawPool.sub(_amount);

        require(stakeManager.transferFunds(validatorId, _amount, msg.sender), "Insufficent rewards");

        return _amount;
    }

    function _getRatePrecision() private view returns (uint256) {
        // if foundation validator, use old precision
        if (validatorId < 8) {
            return EXCHANGE_RATE_PRECISION;
        }

        return EXCHANGE_RATE_HIGH_PRECISION;
    }

    function _calculateRewardPerShareWithRewards(uint256 accumulatedReward) private view returns (uint256) {
        uint256 _rewardPerShare = rewardPerShare;
        if (accumulatedReward != 0) {
            uint256 totalShares = totalSupply();
            
            if (totalShares != 0) {
                _rewardPerShare = _rewardPerShare.add(accumulatedReward.mul(REWARD_PRECISION).div(totalShares));
            }
        }

        return _rewardPerShare;
    }

    function _calculateReward(address user, uint256 _rewardPerShare) private view returns (uint256) {
        uint256 shares = balanceOf(user);
        if (shares == 0) {
            return 0;
        }

        uint256 _initialRewardPerShare = initalRewardPerShare[user];

        if (_initialRewardPerShare == _rewardPerShare) {
            return 0;
        }

        return _rewardPerShare.sub(_initialRewardPerShare).mul(shares).div(REWARD_PRECISION);
    }

    function _withdrawReward(address user) private returns (uint256) {
        uint256 _rewardPerShare = _calculateRewardPerShareWithRewards(
            stakeManager.withdrawDelegatorsReward(validatorId)
        );
        uint256 liquidRewards = _calculateReward(user, _rewardPerShare);
        
        rewardPerShare = _rewardPerShare;
        initalRewardPerShare[user] = _rewardPerShare;
        return liquidRewards;
    }

    function _withdrawAndTransferReward(address user) private returns (uint256) {
        uint256 liquidRewards = _withdrawReward(user);
        if (liquidRewards != 0) {
            require(stakeManager.transferFunds(validatorId, liquidRewards, user), "Insufficent rewards");
            stakingLogger.logDelegatorClaimRewards(validatorId, user, liquidRewards);
        }
        return liquidRewards;
    }

    function _buyShares(
        uint256 _amount,
        uint256 _minSharesToMint,
        address user
    ) private onlyWhenUnlocked returns (uint256) {
        require(delegation, "Delegation is disabled");

        uint256 rate = exchangeRate();
        uint256 precision = _getRatePrecision();
        uint256 shares = _amount.mul(precision).div(rate);
        require(shares >= _minSharesToMint, "Too much slippage");
        require(unbonds[user].shares == 0, "Ongoing exit");

        _mint(user, shares);

        // clamp amount of tokens in case resulted shares requires less tokens than anticipated
        _amount = rate.mul(shares).div(precision);

        stakeManager.updateValidatorState(validatorId, int256(_amount));
        activeAmount = activeAmount.add(_amount);

        StakingInfo logger = stakingLogger;
        logger.logShareMinted(validatorId, user, _amount, shares);
        logger.logStakeUpdate(validatorId);

        return _amount;
    }

    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal {
        // get rewards for recipient 
        _withdrawAndTransferReward(to);
        // convert rewards to shares
        _withdrawAndTransferReward(from);
        // move shares to recipient
        super._transfer(from, to, value);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"constant":true,"inputs":[],"name":"activeAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_minSharesToMint","type":"uint256"}],"name":"buyVoucher","outputs":[{"internalType":"uint256","name":"amountToDeposit","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"commissionRate_deprecated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"delegation","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address payable","name":"destination","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"drain","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"eventsHub","outputs":[{"internalType":"contract EventsHub","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"exchangeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getLiquidRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getRewardPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getTotalStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"initalRewardPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_validatorId","type":"uint256"},{"internalType":"address","name":"_stakingLogger","type":"address"},{"internalType":"address","name":"_stakeManager","type":"address"}],"name":"initialize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"lastCommissionUpdate_deprecated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"lock","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"locked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"migrateIn","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"migrateOut","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"minAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"restake","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"rewardPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"claimAmount","type":"uint256"},{"internalType":"uint256","name":"maximumSharesToBurn","type":"uint256"}],"name":"sellVoucher","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"claimAmount","type":"uint256"},{"internalType":"uint256","name":"maximumSharesToBurn","type":"uint256"}],"name":"sellVoucher_new","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"validatorStake","type":"uint256"},{"internalType":"uint256","name":"delegatedAmount","type":"uint256"},{"internalType":"uint256","name":"totalAmountToSlash","type":"uint256"}],"name":"slash","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"stakeManager","outputs":[{"internalType":"contract IStakeManager","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"stakingLogger","outputs":[{"internalType":"contract StakingInfo","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalStake_deprecated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"unbondNonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"unbonds","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"uint256","name":"withdrawEpoch","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"unbonds_new","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"uint256","name":"withdrawEpoch","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"unlock","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"unstakeClaimTokens","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"unbondNonce","type":"uint256"}],"name":"unstakeClaimTokens_new","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bool","name":"_delegation","type":"bool"}],"name":"updateDelegation","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"validatorId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"validatorRewards_deprecated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"withdrawExchangeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"withdrawPool","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"withdrawRewards","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"withdrawShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

43346:15196:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;43346:15196:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48359:615;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;48359:615:0;;;;;;;:::i;:::-;;12790:148;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;12790:148:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;10943:91;;;:::i;:::-;;;;;;;;;;;;;;;;46742:164;;;:::i;45677:306::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45677:306:0;-1:-1:-1;;;;;45677:306:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;44091:46;;;:::i;13415:228::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;13415:228:0;;;;;;;;;;;;;;;;;:::i;44620:47::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44620:47:0;-1:-1:-1;;;;;44620:47:0;;:::i;14169:203::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;14169:203:0;;;;;;;;:::i;43995:42::-;;;:::i;44256:27::-;;;:::i;45389:280::-;;;:::i;43883:32::-;;;:::i;:::-;;;;-1:-1:-1;;;;;43883:32:0;;;;;;;;;;;;;;44220:29;;;:::i;47367:984::-;;;:::i;44323:27::-;;;:::i;43962:26::-;;;:::i;44177:36::-;;;:::i;44499:50::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44499:50:0;-1:-1:-1;;;;;44499:50:0;;:::i;46595:139::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46595:139:0;-1:-1:-1;;;;;46595:139:0;;:::i;46958:401::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46958:401:0;;;;;;;:::i;50343:1026::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50343:1026:0;;;;;;;;;;;;:::i;49167:718::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;49167:718:0;;;;;;;;:::i;11253:106::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;11253:106:0;-1:-1:-1;;;;;11253:106:0;;:::i;19663:140::-;;;:::i;43922:33::-;;;:::i;44674:74::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;44674:74:0;;;;;;;;:::i;51377:106::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51377:106:0;;;;:::i;44757:26::-;;;:::i;44044:40::-;;;:::i;44357:29::-;;;:::i;50058:277::-;;;:::i;18873:79::-;;;:::i;19208:92::-;;;:::i;44144:24::-;;;:::i;49893:157::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;49893:157:0;;;;;;;;:::i;14903:213::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;14903:213:0;;;;;;;;:::i;39865:68::-;;;:::i;12003:140::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;12003:140:0;;;;;;;;:::i;51491:328::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;51491:328:0;;;;;;;;;;;;;;;;;:::i;44900:433::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44900:433:0;;;-1:-1:-1;;;;;44900:433:0;;;;;;;;;;;;:::i;45991:596::-;;;:::i;48982:177::-;;;:::i;51876:696::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51876:696:0;;;;;;;:::i;39322:18::-;;;:::i;11698:131::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;11698:131:0;;;;;;;;;;:::i;44292:22::-;;;:::i;44556:55::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44556:55:0;-1:-1:-1;;;;;44556:55:0;;:::i;52580:362::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52580:362:0;;:::i;19980:109::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;19980:109:0;-1:-1:-1;;;;;19980:109:0;;:::i;39793:64::-;;;:::i;48359:615::-;48449:14;48465:26;48495:46;48508:11;48521:19;48495:12;:46::i;:::-;48448:93;;;;48554:29;;:::i;:::-;-1:-1:-1;48594:10:0;48586:19;;;;:7;:19;;;;;;;;;48554:51;;;;;;;;;;;;;;;;;;;;;;;;;48632:37;;48650:18;48632:37;:17;:37;:::i;:::-;48616:53;;48737:12;;:20;;;-1:-1:-1;;;48737:20:0;;;;-1:-1:-1;;;;;48737:12:0;;;;:18;;:20;;;;;;;;;;;;;;;:12;:20;;;5:2:-1;;;;30:1;27;20:12;5:2;48737:20:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48737:20:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;48737:20:0;;48714;;;:43;;;48776:10;48768:19;;;;:7;:19;;;;;;;:28;;;;;;;;;;;;;;48830:13;;;48876:11;;48854:67;;-1:-1:-1;;;48854:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;48830:13:0;;;;;;48854:21;;:67;;;;;;;;;;48768:19;48830:13;48854:67;;;5:2:-1;;;;30:1;27;20:12;5:2;48854:67:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48854:67:0;;;;48932:6;-1:-1:-1;;;;;48932:21:0;;48954:11;;48932:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48932:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48932:34:0;;;;48359:615;;;;;;:::o;12790:148::-;12855:4;12872:36;12881:10;12893:7;12902:5;12872:8;:36::i;:::-;-1:-1:-1;12926:4:0;12790:148;;;;;:::o;10943:91::-;11014:12;;10943:91;;:::o;46742:164::-;46855:12;;46885:11;;46855:42;;;-1:-1:-1;;;46855:42:0;;;;;;;;;;46792:7;;46819:79;;-1:-1:-1;;;;;46855:12:0;;;;:29;;:42;;;;;;;;;;;;;;;:12;:42;;;5:2:-1;;;;30:1;27;20:12;5:2;46855:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;46855:42:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46855:42:0;46819:35;:79::i;:::-;46812:86;;46742:164;:::o;45677:306::-;45735:7;45744;45764:14;45781:15;45791:4;45781:9;:15::i;:::-;45764:32;;45807:12;45822:14;:12;:14::i;:::-;45807:29;-1:-1:-1;45851:11:0;45847:60;;45887:1;;-1:-1:-1;45890:4:0;-1:-1:-1;45879:16:0;;-1:-1:-1;45879:16:0;45847:60;45927:41;45948:19;:17;:19::i;:::-;45927:16;:4;45936:6;45927:16;:8;:16;:::i;:::-;:20;:41;:20;:41;:::i;:::-;45919:56;-1:-1:-1;45970:4:0;-1:-1:-1;;45677:306:0;;;;:::o;44091:46::-;;;;:::o;13415:228::-;13494:4;13511:26;13521:4;13527:2;13531:5;13511:9;:26::i;:::-;-1:-1:-1;;;;;13575:14:0;;;;;;:8;:14;;;;;;;;13563:10;13575:26;;;;;;;;;13548:65;;13557:4;;13575:37;;13606:5;13575:37;:30;:37;:::i;:::-;13548:8;:65::i;:::-;-1:-1:-1;13631:4:0;13415:228;;;;;;:::o;44620:47::-;;;;;;;;;;;;;:::o;14169:203::-;14275:10;14249:4;14296:20;;;:8;:20;;;;;;;;-1:-1:-1;;;;;14296:29:0;;;;;;;;;;14249:4;;14266:76;;14287:7;;14296:45;;14330:10;14296:45;:33;:45;:::i;43995:42::-;;;;:::o;44256:27::-;;;;:::o;45389:280::-;45434:7;45454:19;45476:13;:11;:13::i;:::-;45454:35;;45500:17;45520:19;:17;:19::i;:::-;45500:39;-1:-1:-1;45557:16:0;;:104;;45588:12;;45617:11;;45588:41;;;-1:-1:-1;;;45588:41:0;;;;;;;;;;:73;;45649:11;;45588:56;;45634:9;;-1:-1:-1;;;;;45588:12:0;;:28;;:41;;;;;;;;;;;;;;:12;:41;;;5:2:-1;;;;30:1;27;20:12;5:2;45588:41:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45588:41:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45588:41:0;;:56;:45;:56;:::i;:73::-;45557:104;;;45576:9;45557:104;45550:111;;;;45389:280;:::o;43883:32::-;;;-1:-1:-1;;;;;43883:32:0;;:::o;44220:29::-;;;;:::o;47367:984::-;47401:7;;47445:10;47401:7;47489:21;47445:10;47489:15;:21::i;:::-;47466:44;;47521:22;47580:9;;47564:12;:25;;47556:66;;;;;-1:-1:-1;;;47556:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;47639:17;;47635:651;;47690:33;47701:12;47715:1;47718:4;47690:10;:33::i;:::-;47673:50;;47759:14;47744:12;:29;47740:392;;;47870:12;;47897:11;;47870:76;;;-1:-1:-1;;;47870:76:0;;;;;;;;;47910:29;;;47870:76;;;;-1:-1:-1;;;;;47870:76:0;;;;;;;;;:12;;;:26;;:76;;;;;;;;;;;;;;;:12;;:76;;;5:2:-1;;;;30:1;27;20:12;5:2;47870:76:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47870:76:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47870:76:0;47840:169;;;;;-1:-1:-1;;;47840:169:0;;;;;;;;;;;;-1:-1:-1;;;47840:169:0;;;;;;;;;;;;;;;48028:13;;;48067:11;;48028:88;;;-1:-1:-1;;;48028:88:0;;;;;;;;;-1:-1:-1;;;;;48028:88:0;;;;;;;48086:29;;;48028:88;;;;;;:13;;;:38;;:88;;;;;:13;;:88;;;;;;;:13;;:88;;;5:2:-1;;;;30:1;27;20:12;5:2;48028:88:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48028:88:0;;;;47740:392;48149:19;48174;48188:4;48174:13;:19::i;:::-;-1:-1:-1;48208:13:0;;;48243:11;;48208:66;;;-1:-1:-1;;;48208:66:0;;;;;;;;;-1:-1:-1;;;;;48208:66:0;;;;;;;;;;;;;;;48148:45;;-1:-1:-1;48208:13:0;;:34;;:66;;;;;:13;;:66;;;;;;;;:13;;:66;;;5:2:-1;;;;30:1;27;20:12;5:2;48208:66:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48208:66:0;;;;47635:651;;48314:14;-1:-1:-1;48330:12:0;-1:-1:-1;;47367:984:0;;:::o;44323:27::-;;;;:::o;43962:26::-;;;;:::o;44177:36::-;;;;:::o;44499:50::-;;;;;;;;;;;;;;;;;;;:::o;46595:139::-;46656:7;46683:43;46700:4;46706:19;:17;:19::i;:::-;46683:16;:43::i;46958:401::-;47036:23;47072:38;47099:10;47072:26;:38::i;:::-;;47149:49;47160:7;47169:16;47187:10;47149;:49::i;:::-;47217:12;;47248:11;;47217:72;;;-1:-1:-1;;;47217:72:0;;;;;;;;;;;;;;;47278:10;47217:72;;;;;47131:67;;-1:-1:-1;;;;;;47217:12:0;;;;:30;;:72;;;;;;;;;;;;;;;:12;;:72;;;5:2:-1;;;;30:1;27;20:12;5:2;47217:72:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47217:72:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47217:72:0;47209:99;;;;;-1:-1:-1;;;47209:99:0;;;;;;;;;;;;-1:-1:-1;;;47209:99:0;;;;;;;;;;;;;;50343:1026;50497:7;19085:9;:7;:9::i;:::-;19077:18;;;;;;50541:12;;50517:21;50591:34;:15;50541:12;50591:34;:19;:34;:::i;:::-;50564:61;-1:-1:-1;50640:21:0;50636:62;;50685:1;50678:8;;;;;;50636:62;50788:22;50813:82;50858:36;:14;50877:16;50858:36;:18;:36;:::i;:::-;50813:40;:16;50834:18;50813:40;:20;:40;:::i;:82::-;50788:107;-1:-1:-1;50906:36:0;50945:55;50983:16;50945:33;:13;50788:107;50945:33;:17;:33;:::i;:55::-;50906:94;-1:-1:-1;51045:20:0;51068:48;:14;50906:94;51068:48;:18;:48;:::i;:::-;51127:12;;51173:11;;51127:72;;;-1:-1:-1;;;51127:72:0;;;;;;;;;;;;;;;;51045:71;;-1:-1:-1;;;;;;51127:12:0;;;;:45;;:72;;;;;:12;;:72;;;;;;;;:12;;:72;;;5:2:-1;;;;30:1;27;20:12;5:2;51127:72:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;51225:12:0;;:30;;-1:-1:-1;51225:12:0;-1:-1:-1;51242:12:0;51225:30;:16;:30;:::i;:::-;51210:12;:45;51283:12;;:46;;51300:28;51283:46;:16;:46;:::i;:::-;51268:12;:61;-1:-1:-1;51347:14:0;;50343:1026;-1:-1:-1;;;;;;;50343:1026:0:o;49167:718::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;49247:32;49274:4;49247:26;:32::i;:::-;;49291:19;49312:12;49328:19;49342:4;49328:13;:19::i;:::-;49290:57;;;;49381:6;49366:11;:21;;49358:52;;;;;-1:-1:-1;;;49358:52:0;;;;;;;;;;;;-1:-1:-1;;;49358:52:0;;;;;;;;;;;;;;;49423:17;49443:19;:17;:19::i;:::-;49423:39;-1:-1:-1;49473:14:0;49490:31;49516:4;49490:21;:6;49423:39;49490:21;:10;:21;:::i;:31::-;49473:48;;49532:19;49538:4;49544:6;49532:5;:19::i;:::-;49564:12;;49598:11;;49564:63;;;-1:-1:-1;;;49564:63:0;;;;;;;;;:12;49611:15;;;49564:63;;;;;;-1:-1:-1;;;;;49564:12:0;;;;:33;;:63;;;;;:12;:63;;;;;;:12;;:63;;;5:2:-1;;;;30:1;27;20:12;5:2;49564:63:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;49653:12:0;;:24;;-1:-1:-1;49653:12:0;-1:-1:-1;49670:6:0;49653:24;:16;:24;:::i;:::-;49638:12;:39;49690:13;;;49719:11;;49690:63;;;-1:-1:-1;;;49690:63:0;;;;;;;;;-1:-1:-1;;;;;49690:63:0;;;;;;;;;;;;;;;;;;;;;:13;;;:28;;:63;;;;;:13;;:63;;;;;;;:13;;:63;;;5:2:-1;;;;30:1;27;20:12;5:2;49690:63:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;49764:13:0;;;49793:11;;49764:41;;;-1:-1:-1;;;49764:41:0;;;;;;;;;;-1:-1:-1;;;;;49764:13:0;;;;-1:-1:-1;49764:28:0;;-1:-1:-1;49764:41:0;;;;;:13;;:41;;;;;;;:13;;:41;;;5:2:-1;;;;30:1;27;20:12;5:2;49764:41:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;49816:13:0;;;49851:11;;49816:61;;;-1:-1:-1;;;49816:61:0;;;;;;;;;-1:-1:-1;;;;;49816:61:0;;;;;;;;;;;;;;;:13;;;-1:-1:-1;49816:34:0;;-1:-1:-1;49816:61:0;;;;;:13;;:61;;;;;;;:13;;:61;;;5:2:-1;;;;30:1;27;20:12;11253:106:0;-1:-1:-1;;;;;11335:16:0;11308:7;11335:16;;;;;;;;;;;;11253:106::o;19663:140::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;19746:6;;19725:40;;19762:1;;19746:6;;;-1:-1:-1;;;;;19746:6:0;;19725:40;;19762:1;;19725:40;19776:6;:19;;-1:-1:-1;;;;;;19776:19:0;;;19663:140::o;43922:33::-;;;-1:-1:-1;;;;;43922:33:0;;:::o;44674:74::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;51377:106::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;51451:10;:24;;-1:-1:-1;;51451:24:0;;;;;;;;;;51377:106::o;44757:26::-;;;-1:-1:-1;;;;;44757:26:0;;:::o;44044:40::-;;;;:::o;44357:29::-;;;;:::o;50058:277::-;50106:29;;:::i;:::-;-1:-1:-1;50146:10:0;50138:19;;;;:7;:19;;;;;;;;50106:51;;;;;;;;;;;;;;;;;;;;;;;50185:27;50106:51;50185:19;:27::i;:::-;50238:10;50230:19;;;;:7;:19;;;;;;50223:26;;;;;;;;50260:13;;;50295:11;;50260:67;;-1:-1:-1;;;50260:67:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;50260:13:0;;;;:34;;:67;;;;;50230:19;50260:67;;;;;;50230:19;50260:13;:67;;;5:2:-1;;;;30:1;27;20:12;5:2;50260:67:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50260:67:0;;;;50058:277;;:::o;18873:79::-;18938:6;;;;;-1:-1:-1;;;;;18938:6:0;;18873:79::o;19208:92::-;19286:6;;;;;-1:-1:-1;;;;;19286:6:0;19272:10;:20;;19208:92::o;44144:24::-;;;;:::o;49893:157::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;49972:32;49999:4;49972:26;:32::i;:::-;;50015:27;50026:6;50034:1;50037:4;50015:10;:27::i;:::-;;49893:157;;:::o;14903:213::-;15014:10;14988:4;15035:20;;;:8;:20;;;;;;;;-1:-1:-1;;;;;15035:29:0;;;;;;;;;;14988:4;;15005:81;;15026:7;;15035:50;;15069:15;15035:50;:33;:50;:::i;39865:68::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;39911:14;:12;:14::i;:::-;39865:68::o;12003:140::-;12064:4;12081:32;12091:10;12103:2;12107:5;12081:9;:32::i;51491:328::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;-1:-1:-1;;;;;51634:21:0;;51630:182;;51672:28;;-1:-1:-1;;;;;51672:20:0;;;:28;;;;;51693:6;;51672:28;;;;51693:6;51672:20;:28;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51672:28:0;51630:182;;;51747:5;-1:-1:-1;;;;;51741:21:0;;51763:11;51776:6;51741:42;;;;;;;;;;;;;-1:-1:-1;;;;;51741:42:0;-1:-1:-1;;;;;51741:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51741:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51741:42:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51741:42:0;51733:67;;;;;-1:-1:-1;;;51733:67:0;;;;;;;;;;;;-1:-1:-1;;;51733:67:0;;;;;;;;;;;;;;44900:433;36215:6;;-1:-1:-1;;;36215:6:0;;;;36214:7;36206:34;;;;;-1:-1:-1;;;36206:34:0;;;;;;;;;;;;-1:-1:-1;;;36206:34:0;;;;;;;;;;;;;;;36251:6;:13;;-1:-1:-1;;;;36251:13:0;-1:-1:-1;;;36251:13:0;;;45055:11;:26;;;45092:13;:43;;-1:-1:-1;;;;;45092:43:0;;;-1:-1:-1;;;;;;45092:43:0;;;;;;;45146:12;:43;;;;;;;;;;;;;;;45200:33;45175:13;45200:18;:33::i;:::-;45244:22;:20;:22::i;:::-;-1:-1:-1;;45291:6:0;45279:9;:18;-1:-1:-1;;45308:10:0;:17;;-1:-1:-1;;45308:17:0;45321:4;45308:17;;;44900:433::o;45991:596::-;46044:7;46064:17;46084:19;:17;:19::i;:::-;46064:39;;46132:1;46118:11;;:15;46114:312;;;46405:9;-1:-1:-1;46398:16:0;;46114:312;46464:14;;46496:20;;:83;;46531:48;46563:15;46531:27;46548:9;46531:12;;:16;;:27;;;;:::i;46496:83::-;-1:-1:-1;46519:9:0;45991:596;-1:-1:-1;45991:596:0:o;48982:177::-;49027:15;49045:38;49072:10;49045:26;:38::i;:::-;49027:56;;49113:9;;49102:7;:20;;49094:57;;;;;-1:-1:-1;;;49094:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;48982:177;:::o;51876:696::-;51970:14;51986:26;52016:46;52029:11;52042:19;52016:12;:46::i;:::-;52110:10;52075:19;52097:24;;;:12;:24;;;;;;51969:93;;-1:-1:-1;51969:93:0;;-1:-1:-1;52075:19:0;52097:31;;52126:1;52097:31;:28;:31;:::i;:::-;52075:53;;52141:29;;:::i;:::-;52173:119;;;;;;;;52212:18;52173:119;;;;52260:12;;;;;;;;;-1:-1:-1;;;;;52260:12:0;-1:-1:-1;;;;;52260:18:0;;:20;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;52260:20:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52260:20:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52260:20:0;52173:119;;52315:10;52303:23;;;;:11;52260:20;52303:23;;;;;;;:36;;;;;;;;:45;;;;;;;;;;;;;52359:24;;;:12;:24;;;:38;;;52141:151;-1:-1:-1;52410:22:0;:20;:22::i;:::-;52454:11;;52410:102;;;-1:-1:-1;;;52410:102:0;;;;;;;;;52467:10;52410:102;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52410:43:0;;;;;;;:102;;;;;-1:-1:-1;;52410:102:0;;;;;;;;-1:-1:-1;52410:43:0;:102;;;5:2:-1;;;;30:1;27;20:12;5:2;52410:102:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;52523:13:0;;;52552:11;;52523:41;;;-1:-1:-1;;;52523:41:0;;;;;;;;;;-1:-1:-1;;;;;52523:13:0;;;;-1:-1:-1;52523:28:0;;-1:-1:-1;52523:41:0;;;;;:13;;:41;;;;;;;:13;;:41;;;5:2:-1;;;;30:1;27;20:12;39322:18:0;;;;;;:::o;11698:131::-;-1:-1:-1;;;;;11797:15:0;;;11770:7;11797:15;;;:8;:15;;;;;;;;:24;;;;;;;;;;;;;11698:131::o;44292:22::-;;;;;;:::o;44556:55::-;;;;;;;;;;;;;:::o;52580:362::-;52651:29;;:::i;:::-;-1:-1:-1;52695:10:0;52683:23;;;;:11;:23;;;;;;;;:36;;;;;;;;52651:68;;;;;;;;;;;;;;;;;;;;;;;52747:27;52651:68;52747:19;:27::i;:::-;52804:10;52792:23;;;;:11;:23;;;;;;;;:36;;;;;;;;52785:43;;;;;;52730:44;-1:-1:-1;52839:22:0;:20;:22::i;:::-;52889:11;;52839:95;;;-1:-1:-1;;;52839:95:0;;;;;;;;;52902:10;52839:95;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52839:49:0;;;;;;;:95;;;;;-1:-1:-1;;52839:95:0;;;;;;;;-1:-1:-1;52839:49:0;:95;;;5:2:-1;;;;30:1;27;20:12;5:2;52839:95:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52839:95:0;;;;52580:362;;;:::o;19980:109::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;20053:28;20072:8;20053:18;:28::i;39793:64::-;19085:9;:7;:9::i;:::-;19077:18;;;;;;39837:12;:10;:12::i;53345:1086::-;53433:7;53442;53547:19;53568:12;53584:25;53598:10;53584:13;:25::i;:::-;53546:63;;;;53628:11;53643:1;53628:16;;:46;;;;;53663:11;53648;:26;;53628:46;53620:77;;;;;-1:-1:-1;;;53620:77:0;;;;;;;;;;;;-1:-1:-1;;;53620:77:0;;;;;;;;;;;;;;;53762:17;53782:19;:17;:19::i;:::-;53762:39;-1:-1:-1;53812:14:0;53829:36;53860:4;53829:26;:11;53762:39;53829:26;:15;:26;:::i;:36::-;53812:53;;53894:19;53884:6;:29;;53876:59;;;;;-1:-1:-1;;;53876:59:0;;;;;;;;;;;;-1:-1:-1;;;53876:59:0;;;;;;;;;;;;;;;53948:38;53975:10;53948:26;:38::i;:::-;;53999:25;54005:10;54017:6;53999:5;:25::i;:::-;54035:12;;54069:11;;54035:68;;;-1:-1:-1;;;54035:68:0;;;;;;;;;:12;54082:20;;;54035:68;;;;;;-1:-1:-1;;;;;54035:12:0;;;;:33;;:68;;;;;:12;:68;;;;;;:12;;:68;;;5:2:-1;;;;30:1;27;20:12;5:2;54035:68:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;54129:12:0;;:29;;-1:-1:-1;54129:12:0;-1:-1:-1;54146:11:0;54129:29;:16;:29;:::i;:::-;54114:12;:44;54171:26;54200:54;54231:22;:20;:22::i;:::-;54200:26;:11;54216:9;54200:26;:15;:26;:::i;:54::-;54280:12;;54171:83;;-1:-1:-1;54280:29:0;;54297:11;54280:29;:16;:29;:::i;:::-;54265:12;:44;54337:14;;:38;;54356:18;54337:38;:18;:38;:::i;:::-;54320:14;:55;54396:6;;;;-1:-1:-1;53345:1086:0;-1:-1:-1;;;;;;53345:1086:0:o;9547:150::-;9605:7;9637:5;;;9661:6;;;;9653:15;;;;;17972:145;18091:18;;;-1:-1:-1;;;18091:18:0;;;;;;;;;;;;-1:-1:-1;;;18091:18:0;;;;;;;;;;;;;;55358:477;55498:14;;55452:7;;55527:22;;55523:270;;55566:19;55588:13;:11;:13::i;:::-;55566:35;-1:-1:-1;55634:16:0;;55630:152;;55689:77;55709:56;55753:11;55709:39;:17;43868:6;55709:39;:21;:39;:::i;:56::-;55689:15;;:77;:19;:77;:::i;:::-;55671:95;;55630:152;55523:270;55812:15;55358:477;-1:-1:-1;;55358:477:0:o;55091:259::-;55142:7;55235:1;55221:11;;:15;55217:78;;;-1:-1:-1;43585:3:0;55253:30;;55217:78;-1:-1:-1;43771:6:0;55091:259;:::o;8300:433::-;8358:7;8602:6;8598:47;;-1:-1:-1;8632:1:0;8625:8;;8598:47;8669:5;;;8673:1;8669;:5;:1;8693:5;;;;;:10;8685:19;;;;;8868:303;8926:7;9025:1;9021;:5;9013:14;;;;;;9038:9;9054:1;9050;:5;;;;;;;8868:303;-1:-1:-1;;;;8868:303:0:o;58187:352::-;58340:30;58367:2;58340:26;:30::i;:::-;;58419:32;58446:4;58419:26;:32::i;:::-;;58499;58515:4;58521:2;58525:5;58499:15;:32::i;9309:150::-;9367:7;9400:1;9395;:6;;9387:15;;;;;;-1:-1:-1;9425:5:0;;;9309:150::o;56323:434::-;56379:7;56399:23;56425:111;56475:12;;;;;;;;;-1:-1:-1;;;;;56475:12:0;-1:-1:-1;;;;;56475:37:0;;56513:11;;56475:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;56475:50:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;56425:111:0;56399:137;;56547:21;56571:39;56588:4;56594:15;56571:16;:39::i;:::-;56631:14;:32;;;-1:-1:-1;;;;;56674:26:0;;;;;;:20;:26;;;;;:44;;;;-1:-1:-1;56547:63:0;-1:-1:-1;56323:434:0;;;:::o;57184:995::-;57329:7;39388:17;:15;:17::i;:::-;57357:10;;;;57349:45;;;;;-1:-1:-1;;;57349:45:0;;;;;;;;;;;;-1:-1:-1;;;57349:45:0;;;;;;;;;;;;;;;57407:12;57422:14;:12;:14::i;:::-;57407:29;;57447:17;57467:19;:17;:19::i;:::-;57447:39;-1:-1:-1;57497:14:0;57514:32;57541:4;57514:22;:7;57447:39;57514:22;:11;:22;:::i;:32::-;57497:49;;57575:16;57565:6;:26;;57557:56;;;;;-1:-1:-1;;;57557:56:0;;;;;;;;;;;;-1:-1:-1;;;57557:56:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;57632:13:0;;;;;;:7;:13;;;;;:20;:25;57624:50;;;;;-1:-1:-1;;;57624:50:0;;;;;;;;;;;;-1:-1:-1;;;57624:50:0;;;;;;;;;;;;;;;57687:19;57693:4;57699:6;57687:5;:19::i;:::-;57826:31;57847:9;57826:16;:4;57835:6;57826:16;:8;:16;:::i;:31::-;57870:12;;57904:11;;57870:63;;;-1:-1:-1;;;57870:63:0;;;;;;;;;;;;;;;;57816:41;;-1:-1:-1;;;;;;57870:12:0;;;;:33;;:63;;;;;:12;;:63;;;;;;;;:12;;:63;;;5:2:-1;;;;30:1;27;20:12;5:2;57870:63:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;57959:12:0;;:25;;-1:-1:-1;57959:12:0;-1:-1:-1;57976:7:0;57959:25;:16;:25;:::i;:::-;57944:12;:40;58018:13;;;58064:11;;58042:57;;;-1:-1:-1;;;58042:57:0;;;;;;;;;-1:-1:-1;;;;;58042:57:0;;;;;;;;;;;;;;;;;;;;;58018:13;;;;;58042:21;;:57;;;;;57997:18;;58042:57;;;;;;;;57997:18;58018:13;58042:57;;;5:2:-1;;;;30:1;27;20:12;5:2;58042:57:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;58042:57:0;;;;58110:6;-1:-1:-1;;;;;58110:21:0;;58132:11;;58110:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;58110:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;58164:7:0;;57184:995;-1:-1:-1;;;;;;;;;;57184:995:0:o;55843:472::-;55930:7;55950:14;55967:15;55977:4;55967:9;:15::i;:::-;55950:32;-1:-1:-1;55997:11:0;55993:52;;56032:1;56025:8;;;;;55993:52;-1:-1:-1;;;;;56090:26:0;;56057:30;56090:26;;;:20;:26;;;;;;56133:41;;;56129:82;;;56198:1;56191:8;;;;;;56129:82;56230:77;43868:6;56230:55;56278:6;56230:43;:15;56250:22;56230:43;:19;:43;:::i;:::-;:47;:55;:47;:55;:::i;:77::-;56223:84;55843:472;-1:-1:-1;;;;;55843:472:0:o;56765:411::-;56832:7;56852:21;56876;56892:4;56876:15;:21::i;:::-;56852:45;-1:-1:-1;56912:18:0;;56908:230;;56955:12;;56982:11;;56955:60;;;-1:-1:-1;;;56955:60:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;56955:60:0;;;;;;;;;:12;;;:26;;:60;;;;;;;;;;;;;;;:12;;:60;;;5:2:-1;;;;30:1;27;20:12;5:2;56955:60:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;56955:60:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;56955:60:0;56947:92;;;;;-1:-1:-1;;;56947:92:0;;;;;;;;;;;;-1:-1:-1;;;56947:92:0;;;;;;;;;;;;;;;57054:13;;;57093:11;;57054:72;;;-1:-1:-1;;;57054:72:0;;;;;;;;;-1:-1:-1;;;;;57054:72:0;;;;;;;;;;;;;;;:13;;;:38;;:72;;;;;:13;;:72;;;;;;;:13;;:72;;;5:2:-1;;;;30:1;27;20:12;5:2;57054:72:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57054:72:0;;;;57155:13;-1:-1:-1;56765:411:0;;;:::o;16460:269::-;-1:-1:-1;;;;;16535:21:0;;16527:30;;;;;;16585:12;;:23;;16602:5;16585:23;:16;:23;:::i;:::-;16570:12;:38;-1:-1:-1;;;;;16640:18:0;;:9;:18;;;;;;;;;;;:29;;16663:5;16640:29;:22;:29;:::i;:::-;-1:-1:-1;;;;;16619:18:0;;:9;:18;;;;;;;;;;;:50;;;;16685:36;;;;;;;16619:9;;16685:36;;;;;;;;;;;16460:269;;:::o;54439:644::-;54552:13;;54658:12;;:20;;;-1:-1:-1;;;54658:20:0;;;;54515:7;;54552:13;-1:-1:-1;;;;;54658:12:0;;:18;;:20;;;;;;;;;;;;;;:12;:20;;;5:2:-1;;;;30:1;27;20:12;5:2;54658:20:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;54658:20:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;54658:20:0;54623:12;;:30;;;-1:-1:-1;;;54623:30:0;;;;54598:56;;-1:-1:-1;;;;;54623:12:0;;:28;;:30;;;;;54658:20;;54623:30;;;;;;;:12;:30;;;5:2:-1;;;;30:1;27;20:12;5:2;54623:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;54623:30:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;54623:30:0;;54598:20;;;;:56;:24;:56;:::i;:::-;:80;;:94;;;;;54691:1;54682:6;:10;54598:94;54576:172;;;;;-1:-1:-1;;;54576:172:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;54761:15;54779:59;54818:19;:17;:19::i;:::-;54779:34;54806:6;54779:22;:20;:22::i;:59::-;54866:14;;54761:77;;-1:-1:-1;54866:26:0;;54885:6;54866:26;:18;:26;:::i;:::-;54849:14;:43;54918:12;;:25;;54935:7;54918:25;:16;:25;:::i;:::-;54903:12;:40;54964:12;;54991:11;;54964:60;;;-1:-1:-1;;;54964:60:0;;;;;;;;;;;;;;;55013:10;54964:60;;;;;-1:-1:-1;;;;;54964:12:0;;;;:26;;:60;;;;;;;;;;;;;;;:12;;:60;;;5:2:-1;;;;30:1;27;20:12;5:2;54964:60:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;54964:60:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;54964:60:0;54956:92;;;;;-1:-1:-1;;;54956:92:0;;;;;;;;;;;;-1:-1:-1;;;54956:92:0;;;;;;;;;;;;;;39589:58;39625:6;:14;;-1:-1:-1;;39625:14:0;;;39589:58::o;20239:187::-;-1:-1:-1;;;;;20313:22:0;;20305:31;;;;;;20373:6;;20352:38;;-1:-1:-1;;;;;20352:38:0;;;;20373:6;;;;;20352:38;;;;;20401:6;:17;;-1:-1:-1;;;;;20401:17:0;;;;;-1:-1:-1;;;;;;20401:17:0;;;;;;;;;20239:187::o;52995:342::-;53088:9;;53043;;-1:-1:-1;;;;;53088:9:0;53112:28;53108:194;;53189:12;;;;;;;;;-1:-1:-1;;;;;53189:12:0;-1:-1:-1;;;;;53189:24:0;;:26;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53189:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53189:26:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;53189:26:0;53229:22;;;-1:-1:-1;;;53229:22:0;;;;;;;;;;;;-1:-1:-1;;;53180:72:0;;;;;;;;-1:-1:-1;;;;;53180:48:0;;;;;;:72;;;;;53189:26;;53180:72;;;;;;;;:48;:72;;;5:2:-1;;;;30:1;27;20:12;5:2;53180:72:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53180:72:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;53180:72:0;53268:9;:22;;-1:-1:-1;;;;;;53268:22:0;-1:-1:-1;;;;;53268:22:0;;;;;53180:72;-1:-1:-1;53319:10:0;-1:-1:-1;52995:342:0;:::o;39526:55::-;39560:6;:13;;-1:-1:-1;;39560:13:0;39569:4;39560:13;;;39526:55::o;15343:262::-;-1:-1:-1;;;;;15431:16:0;;15423:25;;;;;;-1:-1:-1;;;;;15479:15:0;;:9;:15;;;;;;;;;;;:26;;15499:5;15479:26;:19;:26;:::i;:::-;-1:-1:-1;;;;;15461:15:0;;;:9;:15;;;;;;;;;;;:44;;;;15532:13;;;;;;;:24;;15550:5;15532:24;:17;:24;:::i;:::-;-1:-1:-1;;;;;15516:13:0;;;:9;:13;;;;;;;;;;;;:40;;;;15572:25;;;;;;;15516:13;;15572:25;;;;;;;;;;;;;15343:262;;;:::o;39433:85::-;39493:6;;;;39492:7;39484:26;;;;;-1:-1:-1;;;39484:26:0;;;;;;;;;;;;-1:-1:-1;;;39484:26:0;;;;;;;;;;;;;;15957:269;-1:-1:-1;;;;;16032:21:0;;16024:30;;;;;;16082:12;;:23;;16099:5;16082:23;:16;:23;:::i;:::-;16067:12;:38;-1:-1:-1;;;;;16137:18:0;;:9;:18;;;;;;;;;;;:29;;16160:5;16137:29;:22;:29;:::i;:::-;-1:-1:-1;;;;;16116:18:0;;:9;:18;;;;;;;;;;;:50;;;;16182:36;;;;;;;16116:18;;:9;;16182:36;;;;;;;;;;15957:269;;:::o;43346:15196::-;;;;;;;;;;;;;;;;;;;:::o

Swarm Source

bzzr://e0717f62363177110fcfd3ec1db08ba11d62877157d14e00a22e8a3237b30379

Block		Transaction	Difficulty	Gas Used	Reward

View All Blocks Produced

Block		Uncle Number	Difficulty	Gas Used	Reward

View All Uncles

Validator Index	Block		Amount

View All Withdrawals

Transaction Hash	Block		Value	Eth2 PubKey	Valid

View All Deposits

Multichain Portfolio | 26 Chains

Display all chains •

Last updated: less than 1 sec ago

Chain	Token	Portfolio %	Price	Amount	Value

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.

Tools & Services