Contract Address Details

000000000000000000000000000000000000000000000000000000000000031700000000000000000000000000000000000000000000000000000000000003020000000000000000000000000000000000000000000000000000000000000001

Arg [0] (address) : 0x0000000000000000000000000000000000000317
Arg [1] (address) : 0x0000000000000000000000000000000000000302
Arg [2] (uint256) : 1

              

// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
pragma solidity 0.5.16;
//pragma experimental SMTChecker;
/**
 * Genesis version of GovernedContract interface.
 *
 * Base Consensus interface for upgradable contracts.
 * Unlike common approach, the implementation is NOT expected to be
 * called through delegatecall() to minimize risks of shared storage.
 *
 * NOTE: it MUST NOT change after blockchain launch!
 */
interface IGovernedContract {
    // Return actual proxy address for secure validation
    function proxy() external returns(address);
    // It must check that the caller is the proxy
    // and copy all required data from the old address.
    function migrate(IGovernedContract _oldImpl) external;
    // It must check that the caller is the proxy
    // and self destruct to the new address.
    function destroy(IGovernedContract _newImpl) external;
    function () external payable;
}
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
/**
 * Base for contract storage (SC-14).
 *
 * NOTE: it MUST NOT change after blockchain launch!
 */
contract StorageBase {
    address payable internal owner;
    modifier requireOwner {
        require(msg.sender == address(owner), "Not owner!");
        _;
    }
    constructor() public {
        owner = msg.sender;
    }
    function setOwner(IGovernedContract _newOwner) external requireOwner {
        owner = address(_newOwner);
    }
    function kill() external requireOwner {
        selfdestruct(msg.sender);
    }
}
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
interface IProposal {
    function parent() external view returns(address);
    function created_block() external view returns(uint);
    function deadline() external view returns(uint);
    function fee_payer() external view returns(address payable);
    function fee_amount() external view returns(uint);
    function accepted_weight() external view returns(uint);
    function rejected_weight() external view returns(uint);
    function total_weight() external view returns(uint);
    function quorum_weight() external view returns(uint);
    function isFinished() external view returns(bool);
    function isAccepted() external view returns(bool);
    function withdraw() external;
    function destroy() external;
    function collect() external;
    function voteAccept() external;
    function voteReject() external;
    function setFee() external payable;
    function canVote(address owner) external view returns(bool);
}
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
/**
 * Global constants with no storage space.
 * NOTE: it could be a library, but Solidity does not support such case.
 */
contract GlobalConstants {
    address payable constant internal TREASURY = address(0x301);
    address payable constant internal MASTERNODE_REGISTRY = address(0x302);
    address payable constant internal STAKE_REWARD = address(0x303);
    address payable constant internal BACKBONE_REWARD = address(0x304);
    address payable constant internal SPORK_REGISTRY = address(0x305);
    address payable constant internal CHECKPOINT_REGISTRY = address(0x306);
    address payable constant internal BLACKLIST_REGISTRY = address(0x307);
    address constant internal MIGRATION_CONTRACT = address(0x308);
    address payable constant internal MASTERNODE_TOKEN = address(0x309);
    address constant internal SYSTEM_FAUCET = address(0x310);
    uint constant internal FEE_UPGRADE_V1 = 10000 ether;
    uint constant internal FEE_BUDGET_V1 = 100 ether;
    uint constant internal FEE_CHECKPOINT_V1 = 1000 ether;
    uint constant internal FEE_BLACKLIST_V1 = 1000 ether;
    uint constant internal FEE_BLACKLIST_REVOKE_V1 = 100 ether;
    uint constant internal FEE_BLACKLIST_DRAIN_V1 = 100 ether;
    uint constant internal PERIOD_UPGRADE_MIN = 2 weeks;
    uint constant internal PERIOD_UPGRADE_MAX = 365 days;
    uint constant internal PERIOD_BUDGET_MIN = 2 weeks;
    uint constant internal PERIOD_BUDGET_MAX = 30 days;
    uint constant internal PERIOD_CHECKPOINT = 1 weeks;
    uint constant internal PERIOD_BLACKLIST = 1 weeks;
    uint8 constant internal QUORUM_MIN = 1;
    uint8 constant internal QUORUM_MAJORITY = 51;
    uint8 constant internal QUORUM_MAX = 100;
    uint constant internal REWARD_STAKER_V1 = 2.28 ether;
    uint constant internal REWARD_BACKBONE_V1 = 2.28 ether;
    uint constant internal REWARD_MASTERNODE_V1 = 9.14 ether;
    uint constant internal REWARD_TREASURY_V1 = 184000 ether;
    uint constant internal MN_COLLATERAL_MIN = 10000 ether;
    uint constant internal MN_COLLATERAL_MAX = 100000 ether;
    uint constant internal MN_HEARTBEAT_INTERVAL = 60 minutes;
    uint constant internal MN_HEARTBEAT_INTERVAL_MIN = MN_HEARTBEAT_INTERVAL / 2;
    uint constant internal MN_HEARTBEAT_INTERVAL_MAX = MN_HEARTBEAT_INTERVAL * 2;
    uint constant internal MN_HEARTBEAT_PAST_BLOCKS = 10;
    uint constant internal BUDGET_AMOUNT_MIN = FEE_BUDGET_V1;
    uint constant internal BUDGET_AMOUNT_MAX = REWARD_TREASURY_V1;
    uint constant internal BUDGET_PROPOSAL_MAX = 100;
}
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
/**
 * Genesis version of GovernedContract common base.
 *
 * Base Consensus interface for upgradable contracts.
 * Unlike common approach, the implementation is NOT expected to be
 * called through delegatecall() to minimize risks of shared storage.
 *
 * NOTE: it MUST NOT change after blockchain launch!
 */
contract GovernedContract is IGovernedContract {
    address public proxy;
    constructor(address _proxy) public {
        proxy = _proxy;
    }
    modifier requireProxy {
        require(msg.sender == proxy, "Not proxy");
        _;
    }
    function migrate(IGovernedContract _oldImpl) external requireProxy {
        _migrate(_oldImpl);
    }
    function destroy(IGovernedContract _newImpl) external requireProxy {
        _destroy(_newImpl);
        selfdestruct(address(_newImpl));
    }
    // solium-disable-next-line no-empty-blocks
    function _migrate(IGovernedContract) internal {}
    // solium-disable-next-line no-empty-blocks
    function _destroy(IGovernedContract) internal {}
    function _callerAddress()
        internal view
        returns (address payable)
    {
        if (msg.sender == proxy) {
            // This is guarantee of the GovernedProxy
            // solium-disable-next-line security/no-tx-origin
            return tx.origin;
        } else {
            return msg.sender;
        }
    }
}
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
/**
 * Genesis version of BlacklistRegistry interface.
 *
 * Base Consensus interface for contracts which receive block rewards.
 *
 * NOTE: it MUST NOT change after blockchain launch!
 */
interface IBlockReward {
    // NOTE: it must NEVER fail
    function reward() external payable;
    // NOTE: it must NEVER fail
    function getReward(uint _blockNumber) external view returns(uint amount);
}
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
/**
 * Interface of BudgetProposal
 */
contract IBudgetProposal is IProposal {
    function payout_address() external view returns(address payable);
    function proposed_amount() external view returns(uint);
    function paid_amount() external view returns(uint);
    function ref_uuid() external view returns(uint);
    function distributePayout() external payable;
    function budgetStatus() external view returns(
        uint _ref_uuid,
        bool _is_accepted,
        bool _is_finished,
        uint _unpaid);
}
/**
 * Interface for the Treasury
 */
interface ITreasury {
    event BudgetProposal(
        uint indexed ref_uuid,
        IBudgetProposal proposal,
        address payout_address,
        uint amount,
        uint deadline
    );
    event Contribution(
        address from,
        uint amount
    );
    event Payout(
        uint indexed ref_uuid,
        IBudgetProposal proposal,
        uint amount
    );
    function uuid_proposal(uint _ref_uuid) external view returns(IBudgetProposal);
    function proposal_uuid(IBudgetProposal proposal) external view returns(uint);
    function propose(uint _amount, uint _ref_uuid, uint _period)
        external payable returns(IBudgetProposal proposal);
    function listProposals() external view returns(IBudgetProposal[] memory proposals);
    function isSuperblock(uint _blockNumber) external view returns(bool);
    function contribute() external payable;
    function balance() external view returns(uint amount);
}
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
/**
 * Interface of UpgradeProposal
 */
contract IUpgradeProposal is IProposal {
    function impl() external view returns(IGovernedContract);
}
/**
 * Genesis version of IGovernedProxy interface.
 *
 * Base Consensus interface for upgradable contracts proxy.
 * Unlike common approach, the implementation is NOT expected to be
 * called through delegatecall() to minimize risks of shared storage.
 *
 * NOTE: it MUST NOT change after blockchain launch!
 */
interface IGovernedProxy {
    event UpgradeProposal(
        IGovernedContract indexed impl,
        IUpgradeProposal proposal
    );
    event Upgraded(
        IGovernedContract indexed impl,
        IUpgradeProposal proposal
    );
    function impl() external view returns(IGovernedContract);
    function proposeUpgrade(IGovernedContract _newImpl, uint _period)
        external payable returns(IUpgradeProposal);
    function upgrade(IUpgradeProposal _proposal) external;
    function upgradeProposalImpl(IUpgradeProposal _proposal) external view returns(IGovernedContract new_impl);
    function listUpgradeProposals() external view returns(IUpgradeProposal[] memory proposals);
    function collectUpgradeProposal(IUpgradeProposal _proposal) external;
    function () external payable;
}
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
/**
 * Genesis version of MasternodeRegistry interface.
 *
 * Base Consensus interface for masternodes.
 *
 * NOTE: it MUST NOT change after blockchain launch!
 */
interface IMasternodeRegistry {
    event Announced(
        address indexed masternode,
        address indexed owner,
        uint32 ipv4address,
        bytes32[2] enode,
        uint collateral
    );
    event Denounced(
        address indexed masternode,
        address indexed owner
    );
    event Invalidation(
        address indexed masternode,
        address indexed validator
    );
    event Deactivated(
        address indexed masternode
    );
    function token_proxy() external view returns(IGovernedProxy);
    function treasury_proxy() external view returns(IGovernedProxy);
    function announce(address masternode, uint32 ipv4address, bytes32[2] calldata enode) external;
    function denounce(address masternode) external;
    function heartbeat(uint block_number, bytes32 block_hash, uint sw_features) external;
    function invalidate(address masternode) external;
    function validationTarget(address masternode) external view returns(address target);
    function isActive(address masternode) external view
        returns(bool);
    function count() external view
        returns(
            uint active, uint total,
            uint active_collateral, uint total_collateral,
            uint max_of_all_times);
    function info(address masternode) external view
        returns(address owner, uint32 ipv4address, bytes32[2] memory enode,
                uint collateral, uint announced_block, uint sw_features);
    function ownerInfo(address owner) external view
        returns(address masternode, uint32 ipv4address, bytes32[2] memory enode,
                uint collateral, uint announced_block, uint sw_features);
    function onCollateralUpdate(address owner) external;
    function enumerate() external view returns(address[] memory masternodes);
    function enumerateActive() external view returns(address[] memory masternodes);
}
// solium-disable security/no-block-members
/**
 * Genesis hardcoded version of GenericProposal V1
 *
 * NOTE: it MUST NOT change after blockchain launch!
 */
contract GenericProposalV1 is
    GlobalConstants,
    IProposal
{
    IGovernedProxy public mnregistry_proxy;
    address public parent;
    //! Block of proposal creation to check Masternode eligibility
    uint public created_block;
    //! Deadline for voting
    uint public deadline;
    //! The one who initiated the voting
    address payable public fee_payer;
    //! Fee amount
    uint public fee_amount;
    //! Weight of approval votes
    uint public accepted_weight;
    //! Weight of rejection votes
    uint public rejected_weight;
    //! Total masternode weight at the moment of proposal creation
    uint public total_weight;
    //! Weight of votes when the result is consider eligible
    uint public quorum_weight;
    //! Weight of votes when the voting can finalize before deadline
    uint public finish_weight;
    //! Registry of votes masternodes (vote once only)
    mapping(address => bool) public voted;
    /**
     * C-tor
     *
     * @param _mnregistry_proxy - IMasternodeRegistry proxy
     * @param _quorum - 1..100
     * @param _period - in seconds until deadline
     * @param _feePayer - the proposal initiator
     */
    constructor(
        IGovernedProxy _mnregistry_proxy,
        uint8 _quorum,
        uint _period,
        address payable _feePayer
    ) public {
        parent = msg.sender;
        created_block = block.number;
        mnregistry_proxy = _mnregistry_proxy;
        deadline = block.timestamp + _period;
        fee_payer = _feePayer;
        (
            ,
            ,
            uint _total_weight, // active_collaterel
            , // total_collateral
            uint _ever_weight
        ) = IMasternodeRegistry(address(_mnregistry_proxy.impl())).count();
        require(_ever_weight > 0, "Not ready for proposals");
        require(_total_weight >= (_ever_weight/2), "Active weight < 1/2 ever weight");
        require(_quorum >= QUORUM_MIN, "Quorum min");
        require(_quorum <= QUORUM_MAX, "Quorum max");
        total_weight = _total_weight;
        quorum_weight = _total_weight * _quorum / QUORUM_MAX;
        if (_quorum >= QUORUM_MAJORITY) {
            finish_weight = quorum_weight;
        } else {
            finish_weight = _total_weight * QUORUM_MAJORITY / QUORUM_MAX;
        }
        require(quorum_weight > 0, "Quorum weight");
        require(finish_weight > 0, "Finish weight");
    }
    /**
     * Check if the proposal is considered accepted.
     * NOTE: It can happen before the deadline.
     */
    function isAccepted() public view returns(bool) {
        // Before the deadline condition
        if (accepted_weight >= finish_weight) {
            return true;
        }
        // Ensure finish condition is reaches otherwise
        if (!isFinished()) {
            return false;
        }
        // Check quorum
        if ((accepted_weight + rejected_weight) < quorum_weight) {
            return false;
        }
        // Simply majority
        return accepted_weight > rejected_weight;
    }
    /**
     * Check finish condition
     */
    function isFinished() public view returns(bool) {
        return (
            (deadline <= block.timestamp) ||
            (accepted_weight >= finish_weight) ||
            (rejected_weight > finish_weight)
        );
    }
    function _voteCommon() internal returns(uint collateral) {
        // NOTE: do not use isFinished() to allow to accept votes before the deadline
        require(deadline > block.timestamp, "Finished");
        IMasternodeRegistry registry = IMasternodeRegistry(address(mnregistry_proxy.impl()));
        address owner = msg.sender;
        uint announced_block;
        (,,, collateral, announced_block,) = registry.ownerInfo(owner);
        require(announced_block < created_block, "Not eligible");
        require(!voted[owner], "Already voted");
        voted[owner] = true;
    }
    /**
     * Check if particular MN owner can vote
     */
    function canVote(address owner) external view returns(bool) {
        IMasternodeRegistry registry = IMasternodeRegistry(address(mnregistry_proxy.impl()));
        uint announced_block;
        (,,,, announced_block,) = registry.ownerInfo(owner);
        return (
            (deadline > block.timestamp) &&
            (announced_block < created_block) &&
            !voted[owner]
        );
    }
    /**
     * Masternode Owner approval vote
     */
    function voteAccept() external {
        accepted_weight += _voteCommon();
    }
    /**
     * Masternode Owner rejection vote
     */
    function voteReject() external {
        rejected_weight += _voteCommon();
    }
    /**
     * Withdrawal from accepted proposal.
     * NOTE: Usually for fee, but can be for budget as well.
     */
    function withdraw() external {
        // NOTE: anyone should be able to do that for cases when payer is a contract
        require(isAccepted(), "Not accepted");
        fee_payer.transfer(address(this).balance);
    }
    /**
     * Destruction via Governance logic.
     */
    function destroy() external {
        // NOTE: unfinished voting must get canceled
        require(msg.sender == parent, "Only parent");
        selfdestruct(fee_payer);
    }
    /**
     * Allow Treasury to collect the fee of rejected proposals.
     */
    function collect() external {
        require(isFinished() && !isAccepted(), "Not collectable");
        require(msg.sender == parent, "Only parent");
        IMasternodeRegistry registry = IMasternodeRegistry(address(mnregistry_proxy.impl()));
        ITreasury treasury = ITreasury(address(registry.treasury_proxy().impl()));
        treasury.contribute.value(address(this).balance)();
    }
    /**
     * Set fee amount by parent
     */
    function setFee() external payable {
        require(msg.sender == parent, "Only parent");
        // NOTE: make sure it correctly handles multiple calls
        fee_amount += msg.value;
    }
    /**
     * Only accept fee from the parent creating contract
     */
    function () external payable {
        revert("Not allowed");
    }
}
/**
 * Budget Proposal V1 for Treasury distribution
 */
contract BudgetProposalV1 is
    GenericProposalV1,
    IBudgetProposal
{
    uint public paid_amount;
    uint public proposed_amount;
    uint public ref_uuid;
    constructor(
        IGovernedProxy _mnregistry_proxy,
        address payable _payout_address,
        uint _ref_uuid,
        uint _proposed_amount,
        uint _period
    )
        public
        GenericProposalV1(
            _mnregistry_proxy,
            7,
            _period,
            _payout_address
        )
    {
        ref_uuid = _ref_uuid;
        proposed_amount = _proposed_amount;
    }
    // IBudgetProposal
    //---------------------------------
    // Just an alias
    function payout_address()
        external view
        returns(address payable)
    {
        return fee_payer;
    }
    // Called by Treasury on reward()
    function distributePayout() external payable {
        paid_amount += msg.value;
        assert(paid_amount <= proposed_amount);
    }
    // Optimized status retrieval in single call
    function budgetStatus()
        external view
        returns(
            uint uuid,
            bool is_accepted,
            bool is_finished,
            uint unpaid
        )
    {
        uuid = ref_uuid;
        is_accepted = isAccepted();
        is_finished = isFinished();
        assert(paid_amount <= proposed_amount);
        unpaid = proposed_amount - paid_amount;
    }
}
// Copyright 2019 The Energi Core Authors
// This file is part of Energi Core.
//
// Energi Core is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Energi Core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Energi Core. If not, see <http://www.gnu.org/licenses/>.
// Energi Governance system is the fundamental part of Energi Core.
// NOTE: It's not allowed to change the compiler due to byte-to-byte
//       match requirement.
//pragma experimental SMTChecker;
/**
 * A little helper to protect contract from being re-entrant in state
 * modifying functions.
 */
contract NonReentrant {
    uint private entry_guard;
    modifier noReentry {
        require(entry_guard == 0, "Reentry");
        entry_guard = 1;
        _;
        entry_guard = 0;
    }
}
/**
 * Permanent storage of Treasury V1 data.
 */
contract StorageTreasuryV1 is
    StorageBase
{
    mapping(uint => IBudgetProposal) public uuid_proposal;
    mapping(address => uint) public proposal_uuid;
    function setProposal(uint _uuid, IBudgetProposal _proposal)
        external
        requireOwner
    {
        uuid_proposal[_uuid] = _proposal;
        proposal_uuid[address(_proposal)] = _uuid;
    }
    function deleteProposal(IBudgetProposal _proposal)
        external
        requireOwner
    {
        uint uuid = proposal_uuid[address(_proposal)];
        delete proposal_uuid[address(_proposal)];
        delete uuid_proposal[uuid];
    }
}
/**
 * Genesis hardcoded version of Treasury
 *
 * NOTE: it MUST NOT change after blockchain launch!
 */
contract TreasuryV1 is
    GlobalConstants,
    GovernedContract,
    NonReentrant,
    IBlockReward,
    ITreasury
{
    // Data for migration
    //---------------------------------
    StorageTreasuryV1 public v1storage;
    IGovernedProxy public mnregistry_proxy;
    uint public superblock_cycle;
    IBudgetProposal[BUDGET_PROPOSAL_MAX] public active_proposals;
    //---------------------------------
    constructor(address _proxy, IGovernedProxy _mnregistry_proxy, uint _superblock_cycle)
        public
        GovernedContract(_proxy)
    {
        v1storage = new StorageTreasuryV1();
        mnregistry_proxy = _mnregistry_proxy;
        superblock_cycle = _superblock_cycle;
        assert(superblock_cycle > 0);
    }
    // IGovernedContract
    //---------------------------------
    function _destroy(IGovernedContract _newImpl) internal {
        v1storage.setOwner(_newImpl);
    }
    // ITreasury
    //---------------------------------
    function uuid_proposal(uint _ref_uuid) external view returns(IBudgetProposal) {
        return v1storage.uuid_proposal(_ref_uuid);
    }
    function proposal_uuid(IBudgetProposal proposal) external view returns(uint) {
        return v1storage.proposal_uuid(address(proposal));
    }
    function propose(uint _amount, uint _ref_uuid, uint _period)
        external payable
        noReentry
        returns(IBudgetProposal proposal)
    {
        require(msg.value == FEE_BUDGET_V1, "Invalid fee");
        require(_amount >= BUDGET_AMOUNT_MIN, "Too small amount");
        require(_amount <= BUDGET_AMOUNT_MAX, "Too large amount");
        require(_period >= PERIOD_BUDGET_MIN, "Too small period");
        require(_period <= PERIOD_BUDGET_MAX, "Too large period");
        StorageTreasuryV1 store = v1storage;
        address payable payout_address = _callerAddress();
        require(address(store.uuid_proposal(_ref_uuid)) == address(0), "UUID in use");
        // Find, if proposal slot is available.
        for (uint i = 0; i < BUDGET_PROPOSAL_MAX; ++i) {
            if (address(active_proposals[i]) == address(0)) {
                proposal = new BudgetProposalV1(
                    mnregistry_proxy,
                    payout_address,
                    _ref_uuid,
                    _amount,
                    _period
                );
                active_proposals[i] = proposal;
                break;
            }
        }
        require(address(proposal) != address(0), "Too many active proposals");
        //---
        proposal.setFee.value(msg.value)();
        store.setProposal(_ref_uuid, proposal);
        // NOTE: it's the only way to retrieve proposal on regular transaction
        emit BudgetProposal(
            _ref_uuid,
            proposal,
            payout_address,
            _amount,
            proposal.deadline()
        );
        return proposal;
    }
    function listProposals() external view returns(IBudgetProposal[] memory proposals) {
        IBudgetProposal[] memory tmp = new IBudgetProposal[](BUDGET_PROPOSAL_MAX);
        uint tmp_len = 0;
        for (uint i = 0; i < BUDGET_PROPOSAL_MAX; ++i) {
            IBudgetProposal p = active_proposals[i];
            if (address(p) != address(0)) {
                tmp[tmp_len++] = p;
            }
        }
        proposals = new IBudgetProposal[](tmp_len);
        for (uint i = 0; i < tmp_len; ++i) {
            proposals[i] = tmp[i];
        }
        return proposals;
    }
    function isSuperblock(uint _blockNumber)
        public view
        returns(bool)
    {
        return (_blockNumber % superblock_cycle) == 0 && (_blockNumber > 0);
    }
    function contribute() external payable {
        if (msg.value > 0) {
            emit Contribution(_callerAddress(), msg.value);
        }
    }
    // NOTE: usually Treasury is behind proxy and this one
    //       minimizes possible errors.
    function balance()
        external view
        returns(uint amount)
    {
        return address(this).balance;
    }
    // IBlockReward
    //---------------------------------
    struct AcceptedProposal {
        IBudgetProposal proposal;
        uint ref_uuid;
        uint unpaid;
    }
    function reward()
        external payable
        noReentry
    {
        AcceptedProposal[BUDGET_PROPOSAL_MAX] memory accepted;
        uint unpaid_total = _reward_status(accepted);
        uint curr_balance = address(this).balance;
        if ((curr_balance > 0) && (unpaid_total > 0)) {
            uint permille = 1000;
            if (unpaid_total > curr_balance) {
                // Due to lack of floating-point precision,
                // it may require a few blocks to process
                // full payouts.
                permille = curr_balance * 1000 / unpaid_total;
            }
            _reward_distribute(permille, accepted);
        }
    }
    function _reward_status(AcceptedProposal[BUDGET_PROPOSAL_MAX] memory accepted)
        internal
        returns(uint unpaid_total)
    {
        IBudgetProposal proposal;
        uint ref_uuid;
        bool is_accepted;
        bool is_finished;
        uint unpaid = 0;
        for (uint i = 0; i < BUDGET_PROPOSAL_MAX; ++i) {
            proposal = active_proposals[i];
            if (address(proposal) != address(0)) {
                (ref_uuid, is_accepted, is_finished, unpaid) = proposal.budgetStatus();
                if (is_accepted) {
                    if (unpaid > 0) {
                        unpaid_total += unpaid;
                        accepted[i].proposal = proposal;
                        accepted[i].ref_uuid = ref_uuid;
                        accepted[i].unpaid = unpaid;
                    } else {
                        // Fulfilled
                        proposal.destroy();
                        delete active_proposals[i];
                    }
                } else if (is_finished) {
                    // Rejected
                    proposal.collect();
                    delete active_proposals[i];
                }
            }
        }
    }
    function _reward_distribute(
        uint permille,
        AcceptedProposal[BUDGET_PROPOSAL_MAX] memory accepted
    )
        internal
    {
        IBudgetProposal proposal;
        for (uint i = 0; i < BUDGET_PROPOSAL_MAX; ++i) {
            proposal = accepted[i].proposal;
            if (address(proposal) != address(0)) {
                uint amount = accepted[i].unpaid * permille / 1000;
                assert(amount <= accepted[i].unpaid);
                proposal.distributePayout.value(amount)();
                emit Payout(
                    accepted[i].ref_uuid,
                    proposal,
                    amount
                );
            }
        }
    }
    function getReward(uint _blockNumber)
        external view
        returns(uint amount)
    {
        if (isSuperblock(_blockNumber)) {
            amount = REWARD_TREASURY_V1;
        }
    }
    // Safety
    //---------------------------------
    function () external payable {
        revert("Not supported");
    }
}

[{"type":"constructor","stateMutability":"nonpayable","payable":false,"inputs":[{"type":"address","name":"_proxy","internalType":"address"},{"type":"address","name":"_mnregistry_proxy","internalType":"contractIGovernedProxy"},{"type":"uint256","name":"_superblock_cycle","internalType":"uint256"}]},{"type":"event","name":"BudgetProposal","inputs":[{"type":"uint256","name":"ref_uuid","internalType":"uint256","indexed":true},{"type":"address","name":"proposal","internalType":"contractIBudgetProposal","indexed":false},{"type":"address","name":"payout_address","internalType":"address","indexed":false},{"type":"uint256","name":"amount","internalType":"uint256","indexed":false},{"type":"uint256","name":"deadline","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"Contribution","inputs":[{"type":"address","name":"from","internalType":"address","indexed":false},{"type":"uint256","name":"amount","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"Payout","inputs":[{"type":"uint256","name":"ref_uuid","internalType":"uint256","indexed":true},{"type":"address","name":"proposal","internalType":"contractIBudgetProposal","indexed":false},{"type":"uint256","name":"amount","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"fallback","stateMutability":"payable","payable":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"address","name":"","internalType":"contractIBudgetProposal"}],"name":"active_proposals","inputs":[{"type":"uint256","name":"","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"amount","internalType":"uint256"}],"name":"balance","inputs":[],"constant":true},{"type":"function","stateMutability":"payable","payable":true,"outputs":[],"name":"contribute","inputs":[],"constant":false},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"destroy","inputs":[{"type":"address","name":"_newImpl","internalType":"contractIGovernedContract"}],"constant":false},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"amount","internalType":"uint256"}],"name":"getReward","inputs":[{"type":"uint256","name":"_blockNumber","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isSuperblock","inputs":[{"type":"uint256","name":"_blockNumber","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"address[]","name":"proposals","internalType":"contractIBudgetProposal[]"}],"name":"listProposals","inputs":[],"constant":true},{"type":"function","stateMutability":"nonpayable","payable":false,"outputs":[],"name":"migrate","inputs":[{"type":"address","name":"_oldImpl","internalType":"contractIGovernedContract"}],"constant":false},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"address","name":"","internalType":"contractIGovernedProxy"}],"name":"mnregistry_proxy","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"proposal_uuid","inputs":[{"type":"address","name":"proposal","internalType":"contractIBudgetProposal"}],"constant":true},{"type":"function","stateMutability":"payable","payable":true,"outputs":[{"type":"address","name":"proposal","internalType":"contractIBudgetProposal"}],"name":"propose","inputs":[{"type":"uint256","name":"_amount","internalType":"uint256"},{"type":"uint256","name":"_ref_uuid","internalType":"uint256"},{"type":"uint256","name":"_period","internalType":"uint256"}],"constant":false},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"address","name":"","internalType":"address"}],"name":"proxy","inputs":[],"constant":true},{"type":"function","stateMutability":"payable","payable":true,"outputs":[],"name":"reward","inputs":[],"constant":false},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"superblock_cycle","inputs":[],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"address","name":"","internalType":"contractIBudgetProposal"}],"name":"uuid_proposal","inputs":[{"type":"uint256","name":"_ref_uuid","internalType":"uint256"}],"constant":true},{"type":"function","stateMutability":"view","payable":false,"outputs":[{"type":"address","name":"","internalType":"contractStorageTreasuryV1"}],"name":"v1storage","inputs":[],"constant":true}]