Contract Address Details

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "./CloneFactory.sol";
import "../interface/IIRNat.sol";
import "../interface/IIRNatAccount.sol";
import "../../governance/implementation/Governed.sol";
import "../../incentivePool/implementation/IncentivePoolReceiver.sol";
import "../../protocol/interface/IIClaimSetupManager.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";


/**
 * RNat is a non-transferable linearly vested token (12 months). This contract is used for managing all processes
 * related to the RNat token - assigning, distributing, claiming and withdrawing.
 */
contract RNat is IIRNat, Governed, IncentivePoolReceiver, CloneFactory, ReentrancyGuard {

    /// Struct used to store the project data.
    struct Project {
        string name;
        address distributor;
        bool currentMonthDistributionEnabled;
        bool distributionDisabled;
        bool claimingDisabled;
        uint128 totalAssignedRewards;
        uint128 totalDistributedRewards;
        uint128 totalClaimedRewards;
        uint128 totalUnassignedUnclaimedRewards;
        mapping(uint256 month => MonthlyRewards) monthlyRewards;
        uint256[] monthsWithRewards; // sorted list of months with rewards
        // equal to project.monthsWithRewards.length when all rewards are claimed and the last month is in the past
        mapping(address owner => uint256 index) lastClaimingMonthIndex;
    }

    /// Struct used to store the monthly rewards data.
    struct MonthlyRewards {
        uint128 assignedRewards;
        uint128 distributedRewards; // distributedRewards <= assignedRewards
        uint128 claimedRewards; // claimedRewards <= distributedRewards
        uint128 unassignedUnclaimedRewards; // unassignedUnclaimedRewards <= distributedRewards - claimedRewards
        mapping(address owner => Rewards) rewards;
    }

    /// Struct used to store the rewards data for the owner.
    struct Rewards {
        uint128 assignedRewards;
        uint128 claimedRewards;
    }

    /// The duration of a month in seconds.
    uint256 public constant MONTH = 30 days;
    /// The timestamp of the first month start.
    uint256 public immutable firstMonthStartTs;

    /// @inheritdoc IERC20Metadata
    string public name;
    /// @inheritdoc IERC20Metadata
    string public symbol;
    /// @inheritdoc IERC20Metadata
    uint8 public immutable decimals;

    /// Total assignable rewards received from the funding address or the incentive pool.
    uint128 internal totalAssignableRewards;
    /// Already assigned rewards.
    uint128 internal totalAssignedRewards;
    /// Total claimed rewards.
    uint128 internal totalClaimedRewards;
    /// Total withdrawn rewards.
    uint128 internal totalWithdrawnRewards;
    /// Total withdrawn assignable rewards (needed for the circulating supply calculation).
    uint128 internal totalWithdrawnAssignableRewards;

    /// Indicates if the incentive pool is enabled.
    bool public incentivePoolEnabled;

    /// The `ClaimSetupManager` contract.
    IIClaimSetupManager public claimSetupManager;
    /// The `WNat` contract.
    IWNat public wNat;

    /// The address of the library contract (RNatAccount).
    address public libraryAddress;
    /// The manager address.
    address public manager;
    /// The funding address.
    address public fundingAddress;

    Project[] internal projects;

    mapping(address owner => IIRNatAccount) private ownerToRNatAccount;
    mapping(IIRNatAccount => address owner) private rNatAccountToOwner;

    modifier onlyManager() {
        _checkOnlyManager();
        _;
    }

    /**
     * Constructor.
     * @param _governanceSettings The address of the GovernanceSettings contract.
     * @param _initialGovernance The initial governance address.
     * @param _addressUpdater The address of the AddressUpdater contract.
     * @param _manager The manager address.
     * @param _firstMonthStartTs The timestamp of the first month start.
     */
    constructor(
        IGovernanceSettings _governanceSettings,
        address _initialGovernance,
        address _addressUpdater,
        string memory _name,
        string memory _symbol,
        uint8 _decimals,
        address _manager,
        uint256 _firstMonthStartTs
    )
        Governed(_governanceSettings, _initialGovernance) IncentivePoolReceiver(_addressUpdater)
    {
        require(_firstMonthStartTs <= block.timestamp, "first month start in the future");
        _checkNonzeroAddress(_manager);
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        manager = _manager;
        firstMonthStartTs = _firstMonthStartTs;
    }

    /**
     * External payable function to receive rewards from the funding address.
     */
    function receiveRewards() external payable mustBalance {
        require(msg.sender == fundingAddress, "not a funding address");
        totalAssignableRewards += uint128(msg.value);
    }

    //////////////////////////// Protocol's distributor functions ////////////////////////////

    /**
     * @inheritdoc IRNat
     */
    function distributeRewards(
        uint256 _projectId,
        uint256 _month,
        address[] calldata _recipients,
        uint128[] calldata _amountsWei
    )
        external
    {
        require(_recipients.length == _amountsWei.length, "lengths mismatch");
        Project storage project = _getProject(_projectId);
        _checkDistributionEnabled(project);
        uint256 currentMonth = _getCurrentMonth();
        require(currentMonth == _month + 1 || (project.currentMonthDistributionEnabled && currentMonth == _month),
            "distribution for month disabled");
        require(project.distributor == msg.sender, "only distributor");
        uint128 totalAmount = 0;
        MonthlyRewards storage monthlyRewards = project.monthlyRewards[_month];
        for (uint256 i = 0; i < _recipients.length; i++) {
            _checkNonzeroAddress(_recipients[i]);
            monthlyRewards.rewards[_recipients[i]].assignedRewards += _amountsWei[i];
            totalAmount += _amountsWei[i];
        }
        require(monthlyRewards.distributedRewards + totalAmount <= monthlyRewards.assignedRewards,
            "exceeds assigned rewards");
        monthlyRewards.distributedRewards += totalAmount;
        project.totalDistributedRewards += totalAmount;
        emit RewardsDistributed(_projectId, _month, _recipients, _amountsWei);
    }

    //////////////////////////// User's functions ////////////////////////////

    /**
     * @inheritdoc IRNat
     */
    //slither-disable-next-line reentrancy-eth
    function claimRewards(
        uint256[] calldata _projectIds,
        uint256 _month
    )
        external
        mustBalance
        nonReentrant
        returns (
            uint128 _claimedRewardsWei
        )
    {
        uint256 currentMonth = _getCurrentMonth();
        require(_month <= currentMonth, "month in the future");
        for (uint256 i = 0; i < _projectIds.length; i++) {
            _claimedRewardsWei += _claimRewards(_projectIds[i], _month, currentMonth);
        }
        totalClaimedRewards += _claimedRewardsWei;
        emit Transfer(address(0), msg.sender, _claimedRewardsWei);
    }

    /**
     * @inheritdoc IRNat
     */
    function setClaimExecutors(address[] calldata _executors) external payable {
        _getOrCreateRNatAccount().setClaimExecutors{value: msg.value}(claimSetupManager, _executors);
    }

    /**
     * @inheritdoc IRNat
     */
    function withdraw(uint128 _amount, bool _wrap) external mustBalance {
        uint128 amount = _getOrCreateRNatAccount().withdraw(wNat, firstMonthStartTs, _amount, _wrap);
        totalWithdrawnRewards += amount;
        emit Transfer(msg.sender, address(0), amount);
    }

    /**
     * @inheritdoc IRNat
     */
    function withdrawAll(bool _wrap) external mustBalance {
        uint128 amount = _getOrCreateRNatAccount().withdrawAll(wNat, firstMonthStartTs, _wrap);
        totalWithdrawnRewards += amount;
        emit Transfer(msg.sender, address(0), amount);
    }

    /**
     * @inheritdoc IRNat
     */
    function transferExternalToken(IERC20 _token, uint256 _amount) external nonReentrant {
        _getOrCreateRNatAccount().transferExternalToken(wNat, _token, _amount);
    }

    //////////////////////////// Manager's functions ////////////////////////////

    /**
     * @inheritdoc IIRNat
     */
    function addProjects(
        string[] calldata _names,
        address[] calldata _distributors,
        bool[] calldata _currentMonthDistributionEnabledList
    )
        external
        onlyManager
    {
        require(_names.length == _distributors.length && _names.length == _currentMonthDistributionEnabledList.length,
            "lengths mismatch");
        for (uint256 i = 0; i < _names.length; i++) {
            _checkNonzeroAddress(_distributors[i]);
            uint256 projectId = projects.length;
            projects.push();
            Project storage project = projects[projectId];
            project.name = _names[i];
            project.distributor = _distributors[i];
            project.currentMonthDistributionEnabled = _currentMonthDistributionEnabledList[i];
            emit ProjectAdded(projectId, _names[i], _distributors[i], _currentMonthDistributionEnabledList[i]);
        }
    }

    /**
     * @inheritdoc IIRNat
     */
    function updateProject(
        uint256 _projectId,
        string calldata _name,
        address _distributor,
        bool _currentMonthDistributionEnabled
    )
        external
        onlyManager
    {
        Project storage project = _getProject(_projectId);
        _checkNonzeroAddress(_distributor);
        project.name = _name;
        project.distributor = _distributor;
        project.currentMonthDistributionEnabled = _currentMonthDistributionEnabled;
        emit ProjectUpdated(_projectId, _name, _distributor, _currentMonthDistributionEnabled);
    }

    /**
     * @inheritdoc IIRNat
     */
    function assignRewards(
        uint256 _month,
        uint256[] calldata _projectIds,
        uint128[] calldata _amountsWei
    )
        external
        onlyManager
    {
        require(_month + 1 >= _getCurrentMonth(), "month too far in the past");
        require(_projectIds.length == _amountsWei.length, "lengths mismatch");
        uint128 totalAmount = 0;
        for (uint256 i = 0; i < _projectIds.length; i++) {
            Project storage project = _getProject(_projectIds[i]);
            _checkDistributionEnabled(project);
            project.totalAssignedRewards += _amountsWei[i];
            MonthlyRewards storage monthlyRewards = project.monthlyRewards[_month];
            monthlyRewards.assignedRewards += _amountsWei[i];
            totalAmount += _amountsWei[i];
            uint256 index = project.monthsWithRewards.length;
            if (index == 0 || project.monthsWithRewards[index - 1] < _month) {
                project.monthsWithRewards.push(_month); // this should  be true most of the time
            } else {
                while (index > 0 && project.monthsWithRewards[index - 1] >= _month) {
                    index--;
                }
                if (project.monthsWithRewards[index] != _month) {
                    project.monthsWithRewards.push();
                    for (uint256 j = project.monthsWithRewards.length - 1; j > index; j--) {
                        project.monthsWithRewards[j] = project.monthsWithRewards[j - 1];
                    }
                    project.monthsWithRewards[index] = _month;
                }
            }
            emit RewardsAssigned(_projectIds[i], _month, _amountsWei[i]);
        }
        require(totalAssignedRewards + totalAmount <= totalAssignableRewards, "exceeds assignable rewards");
        totalAssignedRewards += totalAmount;
    }

    /**
     * @inheritdoc IIRNat
     */
    function disableDistribution(uint256[] memory _projectIds) external onlyManager {
        for (uint256 i = 0; i < _projectIds.length; i++) {
            Project storage project = _getProject(_projectIds[i]);
            project.distributionDisabled = true;
        }
        emit DistributionPermissionUpdated(_projectIds, true);
    }

    /**
     * @inheritdoc IIRNat
     */
    function disableClaiming(uint256[] memory _projectIds) external onlyManager {
        for (uint256 i = 0; i < _projectIds.length; i++) {
            Project storage project = _getProject(_projectIds[i]);
            project.claimingDisabled = true;
        }
        emit ClaimingPermissionUpdated(_projectIds, true);
    }

    //////////////////////////// Manager's + Governance's functions ////////////////////////////

    /**
     * @inheritdoc IIRNat
     */
    function unassignRewards(uint256 _projectId, uint256[] memory _months) external {
        require (msg.sender == manager || msg.sender == governance(), "only manager or governance");
        Project storage project = _getProject(_projectId);
        uint256 currentMonth = _getCurrentMonth();
        uint128 totalAmount = 0;
        for (uint256 i = 0; i < _months.length; i++) {
            require(_months[i] + 1 < currentMonth || (project.distributionDisabled && msg.sender == governance()),
                "unassignment not allowed");
            MonthlyRewards storage monthlyRewards = project.monthlyRewards[_months[i]];
            uint128 amount = monthlyRewards.assignedRewards - monthlyRewards.distributedRewards;
            monthlyRewards.assignedRewards -= amount;
            totalAmount += amount;
            emit RewardsUnassigned(_projectId, _months[i], amount);
        }
        project.totalAssignedRewards -= totalAmount;
        totalAssignedRewards -= totalAmount;
    }

    //////////////////////////// Governance's functions ////////////////////////////

    /**
     * Method for unassigning unclaimed rewards from the project. Can only be called by governance when the claiming
     * is disabled for the project. In case of non-zero unassigned unclaimed rewards this permanently disables the
     * distribution and claiming of the rewards for the project.
     * @param _projectId The project id.
     * @param _months The months for which the rewards are unassigned.
     */
    function unassignUnclaimedRewards(uint256 _projectId, uint256[] memory _months) external onlyImmediateGovernance {
        Project storage project = _getProject(_projectId);
        require(project.claimingDisabled, "claiming not disabled");
        uint128 totalAmount = 0;
        for (uint256 i = 0; i < _months.length; i++) {
            MonthlyRewards storage monthlyRewards = project.monthlyRewards[_months[i]];
            uint128 amount = monthlyRewards.distributedRewards -
                monthlyRewards.unassignedUnclaimedRewards - monthlyRewards.claimedRewards;
            monthlyRewards.unassignedUnclaimedRewards += amount;
            totalAmount += amount;
            emit UnclaimedRewardsUnassigned(_projectId, _months[i], amount);
        }

        project.totalUnassignedUnclaimedRewards += totalAmount;
        totalAssignedRewards -= totalAmount;
        project.distributionDisabled = true;
        uint256[] memory projectIds = new uint256[](1);
        projectIds[0] = _projectId;
        emit DistributionPermissionUpdated(projectIds, true);
    }

    /**
     * Method for enabling the distribution for the projects. It reverts in case of permanently disabled claiming.
     * @param _projectIds The ids of the projects.
     */
    function enableDistribution(uint256[] memory _projectIds) external onlyImmediateGovernance {
        for (uint256 i = 0; i < _projectIds.length; i++) {
            Project storage project = _getProject(_projectIds[i]);
            _checkClaimingNotPermanentlyDisabled(project);
            project.distributionDisabled = false;
        }
        emit DistributionPermissionUpdated(_projectIds, false);
    }

    /**
     * Method for enabling the claiming for the projects. It reverts in case of permanently disabled claiming.
     * @param _projectIds The ids of the projects.
     */
    function enableClaiming(uint256[] memory _projectIds) external onlyImmediateGovernance {
        for (uint256 i = 0; i < _projectIds.length; i++) {
            Project storage project = _getProject(_projectIds[i]);
            _checkClaimingNotPermanentlyDisabled(project);
            project.claimingDisabled = false;
        }
        emit ClaimingPermissionUpdated(_projectIds, false);
    }

    /**
     * Method for setting the manager address.
     * @param _manager The manager address.
     */
    function setManager(address _manager) external onlyImmediateGovernance {
        _checkNonzeroAddress(_manager);
        manager = _manager;
    }

    /**
     * Method for setting the funding address.
     * @param _fundingAddress The funding address.
     */
    function setFundingAddress(address _fundingAddress) external onlyGovernance {
        fundingAddress = _fundingAddress;
    }

    /**
     * Sets the library address.
     * @dev Only governance can call this.
     */
    function setLibraryAddress(address _libraryAddress) external onlyGovernance {
        require(_isContract(_libraryAddress), "not a contract");
        libraryAddress = _libraryAddress;
        emit LibraryAddressSet(libraryAddress);
    }

    /**
     * Method for withdrawing unassigned rewards from this contract. Can be used for moving the rewards to the
     * new contract or for burning. Only governance can call this.
     * @param _recipient The recipient of the rewards.
     * @param _amount The amount of the rewards.
     */
    function withdrawUnassignedRewards(address _recipient, uint128 _amount) external mustBalance onlyGovernance {
        _checkNonzeroAddress(_recipient);
        require(totalAssignableRewards - totalAssignedRewards >= _amount, "insufficient assignable rewards");
        totalAssignableRewards -= _amount;
        totalWithdrawnAssignableRewards += _amount;
        emit UnassignedRewardsWithdrawn(_recipient, _amount);
        /* solhint-disable avoid-low-level-calls */
        //slither-disable-next-line arbitrary-send-eth
        (bool success, ) = _recipient.call{value: _amount}("");
        /* solhint-enable avoid-low-level-calls */
        require(success, "Transfer failed");
    }

    /**
     * Enables the incentive pool.
     */
    function enableIncentivePool() external onlyGovernance {
        incentivePoolEnabled = true;
    }

    //////////////////////////// View functions ////////////////////////////

    /**
     * @inheritdoc IRNat
     */
    function getRNatAccount(address _owner) external view returns (IRNatAccount) {
        return _getRNatAccount(_owner);
    }

    /**
     * @inheritdoc IRNat
     */
    function getCurrentMonth() external view returns (uint256) {
        return _getCurrentMonth();
    }

    /**
     * @inheritdoc IRNat
     */
    function getProjectsCount() external view returns (uint256) {
        return projects.length;
    }

    /**
     * @inheritdoc IRNat
     */
    function getProjectsBasicInfo() external view returns (string[] memory _names, bool[] memory _claimingDisabled) {
        _names = new string[](projects.length);
        _claimingDisabled = new bool[](projects.length);
        for (uint256 i = 0; i < projects.length; i++) {
            _names[i] = projects[i].name;
            _claimingDisabled[i] = projects[i].claimingDisabled;
        }
    }

    /**
     * @inheritdoc IRNat
     */
    function getProjectInfo(uint256 _projectId)
        external view
        returns (
            string memory _name,
            address _distributor,
            bool _currentMonthDistributionEnabled,
            bool _distributionDisabled,
            bool _claimingDisabled,
            uint128 _totalAssignedRewards,
            uint128 _totalDistributedRewards,
            uint128 _totalClaimedRewards,
            uint128 _totalUnassignedUnclaimedRewards,
            uint256[] memory _monthsWithRewards
        )
    {
        Project storage project = _getProject(_projectId);
        return (
            project.name,
            project.distributor,
            project.currentMonthDistributionEnabled,
            project.distributionDisabled,
            project.claimingDisabled,
            project.totalAssignedRewards,
            project.totalDistributedRewards,
            project.totalClaimedRewards,
            project.totalUnassignedUnclaimedRewards,
            project.monthsWithRewards
        );
    }

    /**
     * @inheritdoc IRNat
     */
    function getProjectRewardsInfo(uint256 _projectId, uint256 _month)
        external view
        returns (
            uint128 _assignedRewards,
            uint128 _distributedRewards,
            uint128 _claimedRewards,
            uint128 _unassignedUnclaimedRewards
        )
    {
        Project storage project = _getProject(_projectId);
        MonthlyRewards storage monthlyRewards = project.monthlyRewards[_month];
        return (
            monthlyRewards.assignedRewards,
            monthlyRewards.distributedRewards,
            monthlyRewards.claimedRewards,
            monthlyRewards.unassignedUnclaimedRewards
        );
    }

    /**
     * @inheritdoc IRNat
     */
    function getOwnerRewardsInfo(uint256 _projectId, uint256 _month, address _owner)
        external view
        returns (
            uint128 _assignedRewards,
            uint128 _claimedRewards,
            bool _claimable
        )
    {
        Project storage project = _getProject(_projectId);
        if (_month > _getCurrentMonth()) {
            return (0, 0, false);
        }
        MonthlyRewards storage monthlyRewards = project.monthlyRewards[_month];
        Rewards storage rewards = monthlyRewards.rewards[_owner];
        return (
            rewards.assignedRewards,
            rewards.claimedRewards,
            !project.claimingDisabled
        );
    }

    /**
     * @inheritdoc IRNat
     */
    function getClaimableRewards(uint256 _projectId, address _owner) external view returns (uint128) {
        Project storage project = _getProject(_projectId);
        if (project.claimingDisabled) {
            return 0;
        }
        uint256 currentMonth = _getCurrentMonth();
        uint256 claimingMonthIndex = project.lastClaimingMonthIndex[_owner];
        uint256 length = project.monthsWithRewards.length - claimingMonthIndex;
        uint128 totalAmount = 0;
        for (uint256 i = 0; i < length; i++) {
            uint256 month = project.monthsWithRewards[claimingMonthIndex];
            if (currentMonth < month) { // future months are not claimable
                break;
            }
            MonthlyRewards storage monthlyRewards = project.monthlyRewards[month];
            Rewards storage rewards = monthlyRewards.rewards[_owner];
            totalAmount += rewards.assignedRewards - rewards.claimedRewards;
            claimingMonthIndex++;
        }
        return totalAmount;
    }

    /**
     * @inheritdoc IERC20
     */
    function totalSupply() external view returns (uint256) {
        return totalClaimedRewards - totalWithdrawnRewards;
    }

    /**
     * @inheritdoc IERC20
     */
    function balanceOf(address _owner) external view returns(uint256) {
        return _getRNatAccount(_owner).rNatBalance();
    }

    /**
     * @inheritdoc IRNat
     */
    function getBalancesOf(
        address _owner
    )
        external view
        returns (
            uint256 _wNatBalance,
            uint256 _rNatBalance,
            uint256 _lockedBalance
        )
    {
        IIRNatAccount rNatAccount = _getRNatAccount(_owner);
        _wNatBalance = rNatAccount.wNatBalance(wNat);
        _rNatBalance = rNatAccount.rNatBalance();
        _lockedBalance = rNatAccount.lockedBalance(firstMonthStartTs);
    }

    /**
     * @inheritdoc IRNat
     */
    function getRewardsInfo()
        external view
        returns (
            uint256 _totalAssignableRewards,
            uint256 _totalAssignedRewards,
            uint256 _totalClaimedRewards,
            uint256 _totalWithdrawnRewards,
            uint256 _totalWithdrawnAssignableRewards
        )
    {
        return (
            totalAssignableRewards,
            totalAssignedRewards,
            totalClaimedRewards,
            totalWithdrawnRewards,
            totalWithdrawnAssignableRewards
        );
    }

    /**
     * @inheritdoc IITokenPool
     */
    function getTokenPoolSupplyData()
        external view
        returns (
            uint256 _lockedFundsWei,
            uint256 _totalInflationAuthorizedWei,
            uint256 _totalClaimedWei
        )
    {
        // values should not decrease
        _lockedFundsWei = totalAssignableRewards + totalWithdrawnAssignableRewards;
        _totalInflationAuthorizedWei = 0;
        _totalClaimedWei = totalWithdrawnRewards + totalWithdrawnAssignableRewards;
    }

    /**
     * Implement this function to allow updating incentive receiver contracts through `AddressUpdater`.
     * @return Contract name.
     */
    function getContractName() external pure returns (string memory) {
        return "RNat";
    }

    //////////////////////////// ERC20 functions (disabled) ////////////////////////////

    /**
     * @inheritdoc IERC20
     * @dev Disabled. Non-transferable token.
     */
    function transfer(address, uint256) external pure returns (bool) {
        revert("transfer not supported");
    }

    /**
     * @inheritdoc IERC20
     * @dev Disabled. Non-transferable token.
     */
    function allowance(address, address) external pure returns (uint256) {
        revert("allowance not supported");
    }

    /**
     * @inheritdoc IERC20
     * @dev Disabled. Non-transferable token.
     */
    function approve(address, uint256) external pure returns (bool) {
        revert("approval not supported");
    }

    /**
     * @inheritdoc IERC20
     * @dev Disabled. Non-transferable token.
     */
    function transferFrom(address, address, uint256) external pure returns (bool) {
        revert("transfer not supported");
    }

    //////////////////////////// Internal functions ////////////////////////////

    /**
     * Returns the RNat account data. If the account for the msg.sender does not exist, it creates a new one.
     */
    function _getOrCreateRNatAccount() internal returns (IIRNatAccount _rNatAccount) {
        _rNatAccount = ownerToRNatAccount[msg.sender];
        if (address(_rNatAccount) != address(0)) {
            return _rNatAccount;
        }
        require(libraryAddress != address(0), "library address not set yet");

        // create RNat account
        _rNatAccount = IIRNatAccount(payable(createClone(libraryAddress)));
        require(_isContract(address(_rNatAccount)), "clone not created successfully");
        _rNatAccount.initialize(msg.sender, this);
        rNatAccountToOwner[_rNatAccount] = msg.sender;
        ownerToRNatAccount[msg.sender] = _rNatAccount;
        emit RNatAccountCreated(msg.sender, _rNatAccount);

        // register owner as executor if not a registered executor (fee == 0)
        uint256 fee = claimSetupManager.getExecutorCurrentFeeValue(msg.sender);
        if (fee == 0) {
            _rNatAccount.setClaimExecutors(claimSetupManager, new address[](0));
        }

        return _rNatAccount;
    }

    /**
     * Claims rewards for the sender for the given project, up to the given month.
     * @param _projectId The project id.
     * @param _month The month up to which to claim rewards.
     * @param _currentMonth The current month.
     * @return _totalAmount The total amount of claimed rewards.
     */
    function _claimRewards(
        uint256 _projectId,
        uint256 _month,
        uint256 _currentMonth
    )
        internal
        returns (uint128 _totalAmount)
    {
        Project storage project = _getProject(_projectId);
        require(!project.claimingDisabled, "claiming disabled");
        uint256 claimingMonthIndex = project.lastClaimingMonthIndex[msg.sender];
        uint256 length = project.monthsWithRewards.length - claimingMonthIndex;
        uint256[] memory months = new uint256[](length);
        uint256[] memory amounts = new uint256[](length);
        for (uint256 i = 0; i < length; i++) {
            uint256 month = project.monthsWithRewards[claimingMonthIndex];
            if (_month < month) { // can be a month in the future
                break;
            }
            MonthlyRewards storage monthlyRewards = project.monthlyRewards[month];
            Rewards storage rewards = monthlyRewards.rewards[msg.sender];
            months[i] = month;
            uint128 amount = rewards.assignedRewards - rewards.claimedRewards;
            _totalAmount += amount;
            monthlyRewards.claimedRewards += amount;
            rewards.claimedRewards += amount;
            if (amount > 0) {
                amounts[i] = amount;
                emit RewardsClaimed(_projectId, month, msg.sender, amount);
            }
            claimingMonthIndex++;
        }
        project.totalClaimedRewards += _totalAmount;

        // decrease claimingMonthIndex to the last month with assignable rewards (one month before the current month)
        while (claimingMonthIndex > 0 && project.monthsWithRewards[claimingMonthIndex - 1] + 1 >= _currentMonth) {
            claimingMonthIndex--;
        }
        // can be equal to project.monthsWithRewards.length
        project.lastClaimingMonthIndex[msg.sender] = claimingMonthIndex;
        // transfer (wrap) rewards
        _getOrCreateRNatAccount().receiveRewards{value: _totalAmount}(wNat, months, amounts);
    }

    /**
     * @inheritdoc AddressUpdatable
     */
    function _updateContractAddresses(
        bytes32[] memory _contractNameHashes,
        address[] memory _contractAddresses
    )
        internal override
    {
        if (incentivePoolEnabled) {
            super._updateContractAddresses(_contractNameHashes, _contractAddresses);
        }
        claimSetupManager = IIClaimSetupManager(
            _getContractAddress(_contractNameHashes, _contractAddresses, "ClaimSetupManager"));
        IWNat newWNat = IWNat(payable(_getContractAddress(_contractNameHashes, _contractAddresses, "WNat")));
        if (address(wNat) == address(0)) {
            wNat = newWNat;
            require(wNat.decimals() == decimals, "decimals mismatch");
        } else if (newWNat != wNat) {
            revert("wrong wNat address");
        }
    }

    /**
     * @inheritdoc IncentivePoolReceiver
     */
    function _receiveIncentive() internal override {
        totalAssignableRewards += uint128(msg.value);
    }

    /**
     * @inheritdoc IncentivePoolReceiver
     */
    function _getExpectedBalance() internal override view returns(uint256 _balanceExpectedWei) {
        return totalAssignableRewards - totalClaimedRewards;
    }

    /**
     * Returns the project by id.
     */
    function _getProject(uint256 _projectId) internal view returns (Project storage) {
        require(_projectId < projects.length, "invalid project id");
        return projects[_projectId];
    }

    /**
     * Returns the RNat account of the owner.
     */
    function _getRNatAccount(
        address _owner
    )
        internal view
        returns (
            IIRNatAccount _rNatAccount
        )
    {
        _rNatAccount = ownerToRNatAccount[_owner];
        require(address(_rNatAccount) != address(0), "no RNat account");
    }

    /**
     * Returns the current month.
     */
    function _getCurrentMonth() internal view returns (uint256) {
        return (block.timestamp - firstMonthStartTs) / MONTH;
    }

    /**
     * @inheritdoc IncentivePoolReceiver
     */
    function _setDailyAuthorizedIncentive(uint256 _toAuthorizeWei) internal pure override {
        // do nothing
    }

    /**
     * Checks if the address is a contract.
     */
    function _isContract(address _addr) private view returns (bool){
        uint32 size;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            size := extcodesize(_addr)
        }
        return (size > 0);
    }

    /**
     * Checks if distribution is enabled.
     */
    function _checkDistributionEnabled(Project storage _project) private view {
        require(!_project.distributionDisabled, "distribution disabled");
    }

    /**
     * Checks if claiming is not permanently disabled.
     */
    function _checkClaimingNotPermanentlyDisabled(Project storage _project) private view {
        require(_project.totalUnassignedUnclaimedRewards == 0, "claiming permanently disabled");
    }

    /**
     * Checks if the sender is the manager.
     */
    function _checkOnlyManager() private view {
        require(msg.sender == manager, "only manager");
    }

    /**
     * Checks if the address is not zero.
     */
    function _checkNonzeroAddress(address _address) private pure {
        require(_address != address(0), "address zero");
    }
}
        

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import { GovernedBase } from "./GovernedBase.sol";
import { IGovernanceSettings } from "flare-smart-contracts/contracts/userInterfaces/IGovernanceSettings.sol";


/**
 * @title Governed
 * @dev For deployed, governed contracts, enforce non-zero addresses at create time.
 **/
contract Governed is GovernedBase {
    constructor(IGovernanceSettings _governanceSettings, address _initialGovernance) {
        initialise(_governanceSettings, _initialGovernance);
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "flare-smart-contracts/contracts/userInterfaces/IGovernanceSettings.sol";


/**
 * @title Governed Base
 * This abstract base class defines behaviors for a governed contract.
 * @dev This class is abstract so that specific behaviors can be defined for the constructor.
 *   Contracts should not be left ungoverned, but not all contract will have a constructor
 *   (for example those pre-defined in genesis).
 * @dev This version is compatible with both Flare (where governance settings is in genesis at the address
 *   0x1000000000000000000000000000000000000007) and Songbird (where governance settings is a deployed contract).
 **/
abstract contract GovernedBase {
    struct TimelockedCall {
        uint256 allowedAfterTimestamp;
        bytes encodedCall;
    }

    IGovernanceSettings public governanceSettings;

    bool private initialised;

    bool public productionMode;

    bool private executing;

    address private initialGovernance;

    mapping(bytes4 selector => TimelockedCall) public timelockedCalls;

    event GovernanceCallTimelocked(bytes4 selector, uint256 allowedAfterTimestamp, bytes encodedCall);
    event TimelockedGovernanceCallExecuted(bytes4 selector, uint256 timestamp);
    event TimelockedGovernanceCallCanceled(bytes4 selector, uint256 timestamp);

    event GovernanceInitialised(address initialGovernance);
    event GovernedProductionModeEntered(address governanceSettings);

    modifier onlyGovernance {
        if (executing || !productionMode) {
            _beforeExecute();
            _;
        } else {
            _recordTimelockedCall(msg.data);
        }
    }

    modifier onlyImmediateGovernance () {
        _checkOnlyGovernance();
        _;
    }

    constructor() {
    }

    /**
     * Execute the timelocked governance calls once the timelock period expires.
     * @dev Only executor can call this method.
     * @param _selector The method selector (only one timelocked call per method is stored).
     */
    function executeGovernanceCall(bytes4 _selector) external {
        require(isExecutor(msg.sender), "only executor");
        TimelockedCall storage call = timelockedCalls[_selector];
        require(call.allowedAfterTimestamp != 0, "timelock: invalid selector");
        require(block.timestamp >= call.allowedAfterTimestamp, "timelock: not allowed yet");
        bytes memory encodedCall = call.encodedCall;
        delete timelockedCalls[_selector];
        executing = true;
        //solhint-disable-next-line avoid-low-level-calls
        (bool success,) = address(this).call(encodedCall);
        executing = false;
        emit TimelockedGovernanceCallExecuted(_selector, block.timestamp);
        _passReturnOrRevert(success);
    }

    /**
     * Cancel a timelocked governance call before it has been executed.
     * @dev Only governance can call this method.
     * @param _selector The method selector.
     */
    function cancelGovernanceCall(bytes4 _selector) external onlyImmediateGovernance {
        require(timelockedCalls[_selector].allowedAfterTimestamp != 0, "timelock: invalid selector");
        emit TimelockedGovernanceCallCanceled(_selector, block.timestamp);
        delete timelockedCalls[_selector];
    }

    /**
     * Enter the production mode after all the initial governance settings have been set.
     * This enables timelocks and the governance is afterwards obtained by calling
     * governanceSettings.getGovernanceAddress().
     */
    function switchToProductionMode() external {
        _checkOnlyGovernance();
        require(!productionMode, "already in production mode");
        initialGovernance = address(0);
        productionMode = true;
        emit GovernedProductionModeEntered(address(governanceSettings));
    }

    /**
     * Initialize the governance address if not first initialized.
     */
    function initialise(IGovernanceSettings _governanceSettings, address _initialGovernance) public virtual {
        require(initialised == false, "initialised != false");
        require(address(_governanceSettings) != address(0), "governance settings zero");
        require(_initialGovernance != address(0), "_governance zero");
        initialised = true;
        governanceSettings = _governanceSettings;
        initialGovernance = _initialGovernance;
        emit GovernanceInitialised(_initialGovernance);
    }

    /**
     * Returns the current effective governance address.
     */
    function governance() public view returns (address) {
        return productionMode ? governanceSettings.getGovernanceAddress() : initialGovernance;
    }

    /**
     * Internal function to check if an address is executor.
     */
    function isExecutor(address _address) public view returns (bool) {
        return initialised && governanceSettings.isExecutor(_address);
    }

    function _beforeExecute() private {
        if (executing) {
            // can only be run from executeGovernanceCall(), where we check that only executor can call
            // make sure nothing else gets executed, even in case of reentrancy
            assert(msg.sender == address(this));
            executing = false;
        } else {
            // must be called with: productionMode=false
            // must check governance in this case
            _checkOnlyGovernance();
        }
    }

    function _recordTimelockedCall(bytes calldata _data) private {
        _checkOnlyGovernance();
        bytes4 selector;
        //solhint-disable-next-line no-inline-assembly
        assembly {
            selector := calldataload(_data.offset)
        }
        uint256 timelock = governanceSettings.getTimelock();
        uint256 allowedAt = block.timestamp + timelock;
        timelockedCalls[selector] = TimelockedCall({
            allowedAfterTimestamp: allowedAt,
            encodedCall: _data
        });
        emit GovernanceCallTimelocked(selector, allowedAt, _data);
    }

    function _checkOnlyGovernance() private view {
        require(msg.sender == governance(), "only governance");
    }

    function _passReturnOrRevert(bool _success) private pure {
        // pass exact return or revert data - needs to be done in assembly
        //solhint-disable-next-line no-inline-assembly
        assembly {
            let size := returndatasize()
            let ptr := mload(0x40)
            mstore(0x40, add(ptr, size))
            returndatacopy(ptr, 0, size)
            if _success {
                return(ptr, size)
            }
            revert(ptr, size)
        }
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;

import "./IRNat.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IRNatAccount {

    event FundsWithdrawn(uint256 amount, bool wrap);
    event LockedAmountBurned(uint256 amount);
    event ExternalTokenTransferred(IERC20 token, uint256 amount);
    event Initialized(address owner, IRNat rNat);
    event ClaimExecutorsSet(address[] executors);

    /**
     * Returns the owner of the contract.
     */
    function owner() external view returns (address);

    /**
     * Returns the `RNat` contract.
     */
    function rNat() external view returns (IRNat);

    /**
     * Returns the total amount of rewards received ever.
     */
    function receivedRewards() external view returns (uint128);

    /**
     * Returns the total amount of rewards withdrawn ever.
     */
    function withdrawnRewards() external view returns (uint128);
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "flare-smart-contracts/contracts/tokenPools/interface/IIIncentivePoolReceiver.sol";
import "../../utils/implementation/TokenPoolBase.sol";
import "../../utils/implementation/AddressUpdatable.sol";


abstract contract IncentivePoolReceiver is TokenPoolBase, IIIncentivePoolReceiver, AddressUpdatable {

    // totals
    uint256 internal totalIncentiveAuthorizedWei;
    uint256 internal totalIncentiveReceivedWei;
    uint256 internal lastIncentiveAuthorizationReceivedTs;
    uint256 internal dailyAuthorizedIncentive;

    // addresses
    address internal incentivePool;

    event DailyAuthorizedIncentiveSet(uint256 authorizedAmountWei);
    event IncentiveReceived(uint256 amountReceivedWei);

    /**
     * @dev This modifier ensures that method can only be called by incentive pool.
     */
    modifier onlyIncentivePool {
        _checkOnlyIncentivePool();
        _;
    }

    constructor(address _addressUpdater) AddressUpdatable(_addressUpdater) {}

    /**
     * @notice Notify the receiver that it is entitled to receive `_toAuthorizeWei` incentive amount.
     * @param _toAuthorizeWei the amount of incentive that can be awarded in the coming day
     */
    function setDailyAuthorizedIncentive(uint256 _toAuthorizeWei) external onlyIncentivePool {
        dailyAuthorizedIncentive = _toAuthorizeWei;
        totalIncentiveAuthorizedWei = totalIncentiveAuthorizedWei + _toAuthorizeWei;
        lastIncentiveAuthorizationReceivedTs = block.timestamp;

        _setDailyAuthorizedIncentive(_toAuthorizeWei);

        emit DailyAuthorizedIncentiveSet(_toAuthorizeWei);
    }

    /**
     * @notice Receive native tokens from incentive pool.
     */
    function receiveIncentive() external payable mustBalance onlyIncentivePool {
        totalIncentiveReceivedWei = totalIncentiveReceivedWei + msg.value;

        _receiveIncentive();

        emit IncentiveReceived(msg.value);
    }

    /**
     * @notice Incentive pool receivers have a reference to the incentive pool contract.
     */
    function getIncentivePoolAddress() external view returns(address) {
        return incentivePool;
    }

    /**
     * @notice Return expected balance of reward manager ignoring sent self-destruct funds
     */
    function getExpectedBalance() external view returns(uint256) {
        return _getExpectedBalance();
    }

    function getIncentivePoolReceiverInfo()
        external view
        returns(
            uint256 _totalIncentiveAuthorizedWei,
            uint256 _totalIncentiveReceivedWei,
            uint256 _lastIncentiveAuthorizationReceivedTs,
            uint256 _dailyAuthorizedIncentive
        )
    {
        return (
            totalIncentiveAuthorizedWei,
            totalIncentiveReceivedWei,
            lastIncentiveAuthorizationReceivedTs,
            dailyAuthorizedIncentive
        );
    }

    /**
     * @notice Implementation of the AddressUpdatable abstract method.
     * @dev It can be overridden if other contracts are needed.
     */
    function _updateContractAddresses(
        bytes32[] memory _contractNameHashes,
        address[] memory _contractAddresses
    )
        internal virtual override
    {
        incentivePool = _getContractAddress(_contractNameHashes, _contractAddresses, "IncentivePool");
    }

    /**
     * @dev Method that is called when new daily incentive is authorized.
     */
    function _setDailyAuthorizedIncentive(uint256 _toAuthorizeWei) internal virtual;

    /**
     * @dev Method that is called when new incentive is received.
     */
    function _receiveIncentive() internal virtual;

    /**
     * @dev Method that is used in `mustBalance` modifier. It should return expected balance after
     *      triggered function completes (claiming, burning, receiving incentive,...).
     */
    function _getExpectedBalance() internal virtual override view returns(uint256 _balanceExpectedWei) {
        return totalIncentiveReceivedWei;
    }

    function _checkOnlyIncentivePool() private view {
        require(msg.sender == incentivePool, "incentive pool only");
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;

import "flare-smart-contracts/contracts/userInterfaces/IClaimSetupManager.sol";
import "../../userInterfaces/IWNat.sol";

/**
 * Internal interface for the `ClaimSetupManager contract.
 */
interface IIClaimSetupManager is IClaimSetupManager {
    /**
     * Emitted when the `libraryAddress` has been set.
     */
    event SetLibraryAddress(address libraryAddress);

    /**
     * Sets new library address.
     */
    function setLibraryAddress(address _libraryAddress) external;

    /**
     * Sets minimum fee allowed for executors, in wei.
     */
    function setMinFeeValueWei(uint256 _minFeeValueWei) external;

    /**
     * Sets maximum fee allowed for executors, in wei.
     */
    function setMaxFeeValueWei(uint256 _maxFeeValueWei) external;

    /**
     * Sets the fee required to register an executor, which must be higher than 0.
     */
    function setRegisterExecutorFeeValueWei(uint256 _registerExecutorFeeValueWei) external;

    /**
     * Returns the `WNat` contract.
     */
    function wNat() external view returns(IWNat);

    /**
     * Gets the [Personal Delegation Account](https://docs.flare.network/tech/personal-delegation-account) (PDA) for
     * a list of accounts for which an executor is claiming.
     * Returns owner address instead if the PDA is not created yet or not enabled.
     * @param _executor Executor to query.
     * @param _owners Array of reward owners which must have set `_executor` as their executor.
     * @return _recipients Addresses which will receive the claimed rewards. Can be the reward owners or their PDAs.
     * @return _executorFeeValue Executor's fee value, in wei.
     */
    function getAutoClaimAddressesAndExecutorFee(address _executor, address[] memory _owners)
        external view returns (address[] memory _recipients, uint256 _executorFeeValue);

    /**
     * Checks if an executor can claim on behalf of a given account and send funds to a given recipient address.
     *
     * Reverts if claiming is not possible, does nothing otherwise.
     * @param _executor The executor to query.
     * @param _owner The reward owner to query.
     * @param _recipient The address where the reward would be sent.
     */
    function checkExecutorAndAllowedRecipient(address _executor, address _owner, address _recipient)
        external view;
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

/*
The MIT License (MIT)

Copyright (c) 2018 Murray Software, LLC.

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
//solhint-disable max-line-length
//solhint-disable no-inline-assembly

/**
 * Simple clone contract factory.
 *
 * This code (intended to be called from an implementor factory contract) will allow you to install a master copy of a
 * contract, then easily (cheaply) create clones with separate state.
 * The deployed bytecode just delegates all calls to the master contract address.
 *
 * [Source attribution](https://github.com/optionality/clone-factory).
 */
contract CloneFactory {

  function createClone(address target) internal returns (address result) {
    bytes20 targetBytes = bytes20(target);
    assembly {
      let clone := mload(0x40)
      mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
      mstore(add(clone, 0x14), targetBytes)
      mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
      result := create(0, clone, 0x37)
    }
  }

  function isClone(address target, address query) internal view returns (bool result) {
    bytes20 targetBytes = bytes20(target);
    assembly {
      let clone := mload(0x40)
      mstore(clone, 0x363d3d373d3d3d363d7300000000000000000000000000000000000000000000)
      mstore(add(clone, 0xa), targetBytes)
      mstore(add(clone, 0x1e), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)

      let other := add(clone, 0x40)
      extcodecopy(query, other, 0, 0x2d)
      result := and(
        eq(mload(clone), mload(other)),
        eq(mload(add(clone, 0xd)), mload(add(other, 0xd)))
      )
    }
  }
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;


import "../../userInterfaces/IRNat.sol";

/**
 * Internal interface for the `RNat` contract.
 */
interface IIRNat is IRNat {
    /**
     * Emitted when the `libraryAddress` has been set.
     */
    event LibraryAddressSet(address libraryAddress);

    /**
     * Method for adding new projects.
     * @param _names The names of the projects.
     * @param _distributors The addresses of the distributors.
     * @param _currentMonthDistributionEnabledList The list of booleans indicating if the distribution
     *          is enabled for the current month.
     */
    function addProjects(
        string[] calldata _names,
        address[] calldata _distributors,
        bool[] calldata _currentMonthDistributionEnabledList
    )
        external;

    /**
     * Method for updating the project.
     * @param _projectId The project id.
     * @param _name The name of the project.
     * @param _distributor The address of the distributor.
     * @param _currentMonthDistributionEnabled The boolean indicating if the distribution
     *          is enabled for the current month.
     */
    function updateProject(
        uint256 _projectId,
        string calldata _name,
        address _distributor,
        bool _currentMonthDistributionEnabled
    )
        external;

    /**
     * Method for assigning rewards to the projects.
     * @param _month The month for which the rewards are assigned.
     * @param _projectIds The ids of the projects.
     * @param _amountsWei The amounts of the rewards (in wei).
     */
    function assignRewards(
        uint256 _month,
        uint256[] calldata _projectIds,
        uint128[] calldata _amountsWei
    )
        external;

    /**
     * Disables the distribution for the projects.
     * @param _projectIds The ids of the projects.
     */
    function disableDistribution(uint256[] memory _projectIds) external;

    /**
     * Disables the claiming for the projects.
     * @param _projectIds The ids of the projects.
     */
    function disableClaiming(uint256[] memory _projectIds) external;

    /**
     * Method for unassigning rewards from the project. Can only be called for the past months with expired
     * distributon deadline. In case of disabled distribution governance can call this for all months.
     * @param _projectId The project id.
     * @param _months The months for which the rewards will be unassigned.
     */
    function unassignRewards(uint256 _projectId, uint256[] memory _months) external;

}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;


import "../../userInterfaces/IRNatAccount.sol";
import "../../protocol/interface/IIClaimSetupManager.sol";

interface IIRNatAccount is IRNatAccount {

    /**
     * Initialization of a new deployed contract.
     * @param _owner contract owner address
     * @param _rNat contract rNat address
     */
    function initialize(address _owner, IRNat _rNat) external;

    /**
     * Allows the owner to transfer `WNat` wrapped tokens from this contract to the owner account.
     * In case there are some self-destruct native tokens left on the contract,
     * they can be transferred to the owner account using this method and `_wrap = false`.
     * @param _wNat The `WNat` contract.
     * @param _firstMonthStartTs The start timestamp of the first month.
     * @param _amount Amount of tokens to transfer, in wei.
     * @param _wrap If `true`, the tokens will be sent wrapped in `WNat`. If `false`, they will be sent as `Nat`.
     */
    function withdraw(IWNat _wNat, uint256 _firstMonthStartTs, uint128 _amount, bool _wrap) external returns(uint128);

    /**
     * Allows the owner to transfer `WNat` wrapped tokens from this contact to the owner account.
     * In case there are some self-destruct native tokens left on the contract,
     * they can be transferred to the owner account using this method and `_wrap = false`.
     * @param _wNat The `WNat` contract.
     * @param _firstMonthStartTs The start timestamp of the first month.
     * @param _wrap If `true`, the tokens will be sent wrapped in `WNat`. If `false`, they will be sent as `Nat`.
     */
    function withdrawAll(IWNat _wNat, uint256 _firstMonthStartTs, bool _wrap) external returns(uint128);

    /**
     * Sets the addresses of executors and adds the owner as an executor.
     *
     * If any of the executors is a registered executor, some fee needs to be paid.
     * @param _claimSetupManager The `ClaimSetupManager` contract.
     * @param _executors The new executors. All old executors will be deleted and replaced by these.
     */
    function setClaimExecutors(IIClaimSetupManager _claimSetupManager, address[] memory _executors) external payable;

    /**
     * Receives rewards from the `RNat` contract and wraps them on `WNat` contract.
     * @param _wNat The `WNat` contract.
     * @param _months The months for which the rewards are being received.
     * @param _amounts The amounts of rewards being received.
     */
    function receiveRewards(IWNat _wNat, uint256[] memory _months, uint256[] memory _amounts) external payable;

    /**
     * Allows the owner to transfer ERC-20 tokens from this contact to the owner account.
     *
     * The main use case is to move ERC-20 tokes received by mistake (by an airdrop, for example) out of the
     * RNat account and move them into the main account, where they can be more easily managed.
     *
     * Reverts if the target token is the `WNat` contract: use method `withdraw` or `withdrawAll` for that.
          * @param _wNat The `WNat` contract.
     * @param _token Target token contract address.
     * @param _amount Amount of tokens to transfer.
     */
    function transferExternalToken(IWNat _wNat, IERC20 _token, uint256 _amount) external;

    /**
     * Returns the balance of the `RNat` tokens held by this contract.
     */
    function rNatBalance() external view returns(uint256);

    /**
     * Returns the balance of the `WNat` tokens held by this contract. It is a sum of the `RNat` balance and the
     * additionally wrapped tokens.
     */
    function wNatBalance(IWNat _wNat) external view returns(uint256);

    /**
     * Returns the vested/locked balance of the `RNat` tokens held by this contract.
     */
    function lockedBalance(uint256 _firstMonthStartTs) external view returns(uint256);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;

import "./IRNatAccount.sol";
import "./IWNat.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";

interface IRNat is IERC20Metadata {

    event RNatAccountCreated(address owner, IRNatAccount rNatAccount);
    event ProjectAdded(uint256 indexed id, string name, address distributor, bool currentMonthDistributionEnabled);
    event ProjectUpdated(uint256 indexed id, string name, address distributor, bool currentMonthDistributionEnabled);
    event RewardsAssigned(uint256 indexed projectId, uint256 indexed month, uint128 amount);
    event RewardsUnassigned(uint256 indexed projectId, uint256 indexed month, uint128 amount);
    event RewardsDistributed(
        uint256 indexed projectId,
        uint256 indexed month,
        address[] recipients,
        uint128[] amounts
    );
    event RewardsClaimed(uint256 indexed projectId, uint256 indexed month, address indexed owner, uint128 amount);
    event UnclaimedRewardsUnassigned(uint256 indexed projectId, uint256 indexed month, uint128 amount);
    event UnassignedRewardsWithdrawn(address recipient, uint128 amount);
    event DistributionPermissionUpdated(uint256[] projectIds, bool disabled);
    event ClaimingPermissionUpdated(uint256[] projectIds, bool disabled);

    /**
     * Distributes the rewards of a project for a given month to a list of recipients.
     * It must be called by the project's distributor.
     * It can only be called for the last or current month (if enabled).
     * @param _projectId The id of the project.
     * @param _month The month of the rewards.
     * @param _recipients The addresses of the recipients.
     * @param _amountsWei The amounts of rewards to distribute to each recipient (in wei).
     */
    function distributeRewards(
        uint256 _projectId,
        uint256 _month,
        address[] calldata _recipients,
        uint128[] calldata _amountsWei
    )
        external;

    /**
     * Claim rewards for a list of projects up to the given month.
     * @param _projectIds The ids of the projects.
     * @param _month The month up to which (including) rewards will be claimed.
     * @return _claimedRewardsWei The total amount of rewards claimed (in wei).
     */
    function claimRewards(
        uint256[] calldata _projectIds,
        uint256 _month
    )
        external
        returns (
            uint128 _claimedRewardsWei
        );

    /**
     * Sets the addresses of executors and adds the owner as an executor.
     *
     * If any of the executors is a registered executor, some fee needs to be paid.
     * @param _executors The new executors. All old executors will be deleted and replaced by these.
     */
    function setClaimExecutors(address[] calldata _executors) external payable;

    /**
     * Allows the caller to withdraw `WNat` wrapped tokens from their RNat account to the owner account.
     * In case there are some self-destruct native tokens left on the contract,
     * they can be transferred to the owner account using this method and `_wrap = false`.
     * @param _amount Amount of tokens to transfer (in wei).
     * @param _wrap If `true`, the tokens will be sent wrapped in `WNat`. If `false`, they will be sent as `Nat`.
     */
    function withdraw(uint128 _amount, bool _wrap) external;

    /**
     * Allows the caller to withdraw `WNat` wrapped tokens from their RNat account to the owner account.
     * If some tokens are still locked, only 50% of them will be withdrawn, the rest will be burned as a penalty.
     * In case there are some self-destruct native tokens left on the contract,
     * they can be transferred to the owner account using this method and `_wrap = false`.
     * @param _wrap If `true`, the tokens will be sent wrapped in `WNat`. If `false`, they will be sent as `Nat`.
     */
    function withdrawAll(bool _wrap) external;

    /**
     * Allows the caller to transfer ERC-20 tokens from their RNat account to the owner account.
     *
     * The main use case is to move ERC-20 tokes received by mistake (by an airdrop, for example) out of the
     * RNat account and move them into the main account, where they can be more easily managed.
     *
     * Reverts if the target token is the `WNat` contract: use method `withdraw` or `withdrawAll` for that.
     * @param _token Target token contract address.
     * @param _amount Amount of tokens to transfer.
     */
    function transferExternalToken(IERC20 _token, uint256 _amount) external;

    /**
     * Gets owner's RNat account. If it doesn't exist it reverts.
     * @param _owner Account to query.
     * @return Address of its RNat account.
     */
    function getRNatAccount(address _owner) external view returns (IRNatAccount);

    /**
     * Returns the timestamp of the start of the first month.
     */
    function firstMonthStartTs() external view returns (uint256);

    /**
     * Returns the `WNat` contract.
     */
    function wNat() external view returns(IWNat);

    /**
     * Gets the current month.
     * @return The current month.
     */
    function getCurrentMonth() external view returns (uint256);

    /**
     * Gets the total number of projects.
     * @return The total number of projects.
     */
    function getProjectsCount() external view returns (uint256);

    /**
     * Gets the basic information of all projects.
     * @return _names The names of the projects.
     * @return _claimingDisabled Whether claiming is disabled for each project.
     */
    function getProjectsBasicInfo() external view returns (string[] memory _names, bool[] memory _claimingDisabled);

    /**
     * Gets the information of a project.
     * @param _projectId The id of the project.
     * @return _name The name of the project.
     * @return _distributor The address of the distributor.
     * @return _currentMonthDistributionEnabled Whether distribution is enabled for the current month.
     * @return _distributionDisabled Whether distribution is disabled.
     * @return _claimingDisabled Whether claiming is disabled.
     * @return _totalAssignedRewards The total amount of rewards assigned to the project (in wei).
     * @return _totalDistributedRewards The total amount of rewards distributed by the project (in wei).
     * @return _totalClaimedRewards The total amount of rewards claimed from the project (in wei).
     * @return _totalUnassignedUnclaimedRewards The total amount of unassigned unclaimed rewards (in wei).
     * @return _monthsWithRewards The months with rewards.
     */
    function getProjectInfo(uint256 _projectId)
        external view
        returns (
            string memory _name,
            address _distributor,
            bool _currentMonthDistributionEnabled,
            bool _distributionDisabled,
            bool _claimingDisabled,
            uint128 _totalAssignedRewards,
            uint128 _totalDistributedRewards,
            uint128 _totalClaimedRewards,
            uint128 _totalUnassignedUnclaimedRewards,
            uint256[] memory _monthsWithRewards
        );

    /**
     * Gets the rewards information of a project for a given month.
     * @param _projectId The id of the project.
     * @param _month The month of the rewards.
     * @return _assignedRewards The amount of rewards assigned to the project for the month (in wei).
     * @return _distributedRewards The amount of rewards distributed by the project for the month (in wei).
     * @return _claimedRewards The amount of rewards claimed from the project for the month (in wei).
     * @return _unassignedUnclaimedRewards The amount of unassigned unclaimed rewards for the month (in wei).
     */
    function getProjectRewardsInfo(uint256 _projectId, uint256 _month)
        external view
        returns (
            uint128 _assignedRewards,
            uint128 _distributedRewards,
            uint128 _claimedRewards,
            uint128 _unassignedUnclaimedRewards
        );

    /**
     * Gets the rewards information of a project for a given month and owner.
     * @param _projectId The id of the project.
     * @param _month The month of the rewards.
     * @param _owner The address of the owner.
     * @return _assignedRewards The amount of rewards assigned to the owner for the month (in wei).
     * @return _claimedRewards The amount of rewards claimed by the owner for the month (in wei).
     * @return _claimable Whether the rewards are claimable by the owner.
     */
    function getOwnerRewardsInfo(uint256 _projectId, uint256 _month, address _owner)
        external view
        returns (
            uint128 _assignedRewards,
            uint128 _claimedRewards,
            bool _claimable
        );

    /**
     * Gets the claimable rewards of a project for a given owner.
     * @param _projectId The id of the project.
     * @param _owner The address of the owner.
     * @return The amount of rewards claimable by the owner (in wei).
     */
    function getClaimableRewards(uint256 _projectId, address _owner) external view returns (uint128);

    /**
     * Gets owner's balances of `WNat`, `RNat` and locked tokens.
     * @param _owner The address of the owner.
     * @return _wNatBalance The balance of `WNat` (in wei).
     * @return _rNatBalance The balance of `RNat` (in wei).
     * @return _lockedBalance The locked/vested balance (in wei).
     */
    function getBalancesOf(
        address _owner
    )
        external view
        returns (
            uint256 _wNatBalance,
            uint256 _rNatBalance,
            uint256 _lockedBalance
        );

    /**
     * Gets totals rewards information.
     * @return _totalAssignableRewards The total amount of assignable rewards (in wei).
     * @return _totalAssignedRewards The total amount of assigned rewards (in wei).
     * @return _totalClaimedRewards The total amount of claimed rewards (in wei).
     * @return _totalWithdrawnRewards The total amount of withdrawn rewards (in wei).
     * @return _totalWithdrawnAssignableRewards The total amount of withdrawn once assignable rewards (in wei).
     */
    function getRewardsInfo()
        external view
        returns (
            uint256 _totalAssignableRewards,
            uint256 _totalAssignedRewards,
            uint256 _totalClaimedRewards,
            uint256 _totalWithdrawnRewards,
            uint256 _totalWithdrawnAssignableRewards
        );
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;

import "flare-smart-contracts/contracts/userInterfaces/IVPToken.sol";
import "flare-smart-contracts/contracts/token/interface/IICleanable.sol";


/**
 * @title Wrapped Native token
 * Accept native token deposits and mint ERC20 WNAT (wrapped native) tokens 1-1.
 */
interface IWNat is IVPToken, IICleanable {
    /**
     * Deposit Native and mint wNat ERC20.
     */
    function deposit() external payable;

    /**
     * Deposit Native from msg.sender and mints WNAT ERC20 to recipient address.
     * @param recipient An address to receive minted WNAT.
     */
    function depositTo(address recipient) external payable;

    /**
     * Withdraw Native and burn WNAT ERC20.
     * @param amount The amount to withdraw.
     */
    function withdraw(uint256 amount) external;

    /**
     * Withdraw WNAT from an owner and send native tokens to msg.sender given an allowance.
     * @param owner An address spending the Native tokens.
     * @param amount The amount to spend.
     *
     * Requirements:
     *
     * - `owner` must have a balance of at least `amount`.
     * - the caller must have allowance for `owners`'s tokens of at least
     * `amount`.
     */
    function withdrawFrom(address owner, uint256 amount) external;
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "flare-smart-contracts/contracts/addressUpdater/interface/IIAddressUpdatable.sol";


abstract contract AddressUpdatable is IIAddressUpdatable {

    // https://docs.soliditylang.org/en/v0.8.7/contracts.html#constant-and-immutable-state-variables
    // No storage slot is allocated
    bytes32 internal constant ADDRESS_STORAGE_POSITION =
        keccak256("flare.diamond.AddressUpdatable.ADDRESS_STORAGE_POSITION");

    modifier onlyAddressUpdater() {
        require(msg.sender == getAddressUpdater(), "only address updater");
        _;
    }

    constructor(address _addressUpdater) {
        setAddressUpdaterValue(_addressUpdater);
    }

    /**
     * external method called from AddressUpdater only
     */
    function updateContractAddresses(
        bytes32[] memory _contractNameHashes,
        address[] memory _contractAddresses
    )
        external
        onlyAddressUpdater
    {
        // update addressUpdater address
        setAddressUpdaterValue(_getContractAddress(_contractNameHashes, _contractAddresses, "AddressUpdater"));
        // update all other addresses
        _updateContractAddresses(_contractNameHashes, _contractAddresses);
    }

    function getAddressUpdater() public view returns (address _addressUpdater) {
        // Only direct constants are allowed in inline assembly, so we assign it here
        bytes32 position = ADDRESS_STORAGE_POSITION;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            _addressUpdater := sload(position)
        }
    }

    /**
     * virtual method that a contract extending AddressUpdatable must implement
     */
    function _updateContractAddresses(
        bytes32[] memory _contractNameHashes,
        address[] memory _contractAddresses
    ) internal virtual;

    function setAddressUpdaterValue(address _addressUpdater) internal {
        // Only direct constants are allowed in inline assembly, so we assign it here
        bytes32 position = ADDRESS_STORAGE_POSITION;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            sstore(position, _addressUpdater)
        }
    }

    /**
     * helper method to get contract address
     * @dev it reverts if contract name does not exist
     */
    function _getContractAddress(
        bytes32[] memory _nameHashes,
        address[] memory _addresses,
        string memory _nameToFind
    )
        internal pure
        returns(address)
    {
        bytes32 nameHash = keccak256(abi.encode(_nameToFind));
        address a = address(0);
        for (uint256 i = 0; i < _nameHashes.length; i++) {
            if (nameHash == _nameHashes[i]) {
                a = _addresses[i];
                break;
            }
        }
        require(a != address(0), "address zero");
        return a;
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import "flare-smart-contracts/contracts/tokenPools/interface/IITokenPool.sol";


abstract contract TokenPoolBase is IITokenPool {

    address payable constant internal BURN_ADDRESS = payable(0x000000000000000000000000000000000000dEaD);

    /**
     * @dev This modifier ensures that this contract's balance matches the expected balance.
     *      It also burns all funds that came from self-destructor sending a balance to this contract.
     *      Should be used in all methods changing the balance (claiming, receiving funds,...).
     */
    modifier mustBalance {
        _handleSelfDestructProceeds();
        _;
        _checkMustBalance();
    }

    /**
     * @dev Method that is used in `mustBalance` modifier. It should return expected balance after
     *      triggered function completes (claiming, burning, receiving funds,...).
     */
    function _getExpectedBalance() internal virtual view returns(uint256 _balanceExpectedWei);

    /**
     * Burn all funds that came from self-destructor sending a balance to this contract.
     */
    function _handleSelfDestructProceeds() private {
        uint256 expectedBalance = _getExpectedBalance() + msg.value;
        uint256 currentBalance = address(this).balance;
        if (currentBalance > expectedBalance) {
            // Then assume extra were self-destruct proceeds and burn it
            //slither-disable-next-line arbitrary-send-eth
            BURN_ADDRESS.transfer(currentBalance - expectedBalance);
        } else if (currentBalance < expectedBalance) {
            // This is a coding error
            assert(false);
        }
    }

    function _checkMustBalance() private view {
        require(address(this).balance == _getExpectedBalance(), "out of balance");
    }
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: 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
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}
          

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;


/**
 * Internal interface for contracts that depend on other contracts whose addresses can change.
 *
 * See `AddressUpdatable`.
 */
interface IIAddressUpdatable {
    /**
     * Updates contract addresses.
     * Can only be called from the `AddressUpdater` contract typically set at construction time.
     * @param _contractNameHashes List of keccak256(abi.encode(...)) contract names.
     * @param _contractAddresses List of contract addresses corresponding to the contract names.
     */
    function updateContractAddresses(
        bytes32[] memory _contractNameHashes,
        address[] memory _contractAddresses
        ) external;
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;

/**
 * Internal interface for entities that can have their block history cleaned.
 */
interface IICleanable {
    /**
     * Set the contract that is allowed to call history cleaning methods.
     * @param _cleanerContract Address of the cleanup contract.
     * Usually this will be an instance of `CleanupBlockNumberManager`.
     */
    function setCleanerContract(address _cleanerContract) external;

    /**
     * Set the cleanup block number.
     * Historic data for the blocks before `cleanupBlockNumber` can be erased.
     * History before that block should never be used since it can be inconsistent.
     * In particular, cleanup block number must be lower than the current vote power block.
     * @param _blockNumber The new cleanup block number.
     */
    function setCleanupBlockNumber(uint256 _blockNumber) external;

    /**
     * Get the current cleanup block number set with `setCleanupBlockNumber()`.
     * @return The currently set cleanup block number.
     */
    function cleanupBlockNumber() external view returns (uint256);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;

interface IIIncentivePoolReceiver {
    /**
     * Notify the receiver that it is entitled to receive `_toAuthorizeWei` incentive amount.
     * @param _toAuthorizeWei the amount of incentive that can be awarded in the coming day
     */
    function setDailyAuthorizedIncentive(uint256 _toAuthorizeWei) external;

    /**
     * Receive native tokens from incentive pool.
     */
    function receiveIncentive() external payable;

    /**
     * Incentive pool receivers have a reference to the IncentivePool contract.
     */
    function getIncentivePoolAddress() external returns(address);

    /**
     * Incentive pool receivers have a method to get their expected balance
     * (actual balance can be higher due to self-destruct funds)
     */
    function getExpectedBalance() external view returns(uint256);

    /**
     * Implement this function for updating incentive pool receiver contracts through AddressUpdater.
     */
    function getContractName() external view returns (string memory);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;

/**
 * Internal interface for token pools.
 */
interface IITokenPool {

    /**
     * Returns token pool supply data.
     * @return _lockedFundsWei Total amount of funds ever locked in the token pool (wei).
     * `_lockedFundsWei` - `_totalClaimedWei` is the amount currently locked and outside the circulating supply.
     * @return _totalInflationAuthorizedWei Total inflation authorized amount (wei).
     * @return _totalClaimedWei Total claimed amount (wei).
     */
    function getTokenPoolSupplyData() external returns (
        uint256 _lockedFundsWei,
        uint256 _totalInflationAuthorizedWei,
        uint256 _totalClaimedWei
    );
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;

import "./IDelegationAccount.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/**
 * Public interface for the `ClaimSetupManager contract.
 */
interface IClaimSetupManager {

    event DelegationAccountCreated(address owner, IDelegationAccount delegationAccount);
    event DelegationAccountUpdated(address owner, IDelegationAccount delegationAccount, bool enabled);
    event ClaimExecutorsChanged(address owner, address[] executors);
    event AllowedClaimRecipientsChanged(address owner, address[] recipients);
    event ClaimExecutorFeeValueChanged(address executor, uint256 validFromRewardEpoch, uint256 feeValueWei);
    event ExecutorRegistered(address executor);
    event ExecutorUnregistered(address executor, uint256 validFromRewardEpoch);
    event MinFeeSet(uint256 minFeeValueWei);
    event MaxFeeSet(uint256 maxFeeValueWei);
    event RegisterExecutorFeeSet(uint256 registerExecutorFeeValueWei);
    event SetExecutorsExcessAmountRefunded(address owner, uint256 excessAmount);

    /**
     * Sets the addresses of executors and optionally enables (creates) a
     * [Personal Delegation Account](https://docs.flare.network/tech/personal-delegation-account) (PDA).
     *
     * If any of the executors is a registered executor, some fee needs to be paid.
     * @param _executors The new executors. All old executors will be deleted and replaced by these.
     * @param _enableDelegationAccount Whether the PDA should be enabled.
     */
    function setAutoClaiming(address[] memory _executors, bool _enableDelegationAccount) external payable;

    /**
     * Sets the addresses of executors.
     *
     * If any of the executors is a registered executor, some fee needs to be paid.
     * @param _executors The new executors. All old executors will be deleted and replaced by these.
     */
    function setClaimExecutors(address[] memory _executors) external payable;

    /**
     * Set the addresses of allowed recipients.
     * The reward owner is always an allowed recipient.
     * @param _recipients The new allowed recipients. All old recipients will be deleted and replaced by these.
     */
    function setAllowedClaimRecipients(address[] memory _recipients) external;

    /**
     * Enables (or creates) a
     * [Personal Delegation Account](https://docs.flare.network/tech/personal-delegation-account) (PDA).
     *
     * When using automatic claiming, all airdrops and FTSO rewards will be sent to the PDA, and any rewards
     * accrued by the PDA will be claimed too.
     * @return Address of the delegation account contract.
     */
    function enableDelegationAccount() external returns (IDelegationAccount);

    /**
     * Disables the
     * [Personal Delegation Account](https://docs.flare.network/tech/personal-delegation-account) (PDA).
     *
     * When using automatic claiming, all airdrops and FTSO rewards will be sent to the owner's account.
     * Rewards accrued by the PDA will no longer be automatically claimed.
     *
     * Reverts if there is no PDA.
     */
    function disableDelegationAccount() external;

    /**
     * Registers the caller as an executor and sets its initial fee value.
     *
     * If the executor was already registered, this method only updates the fee, which will take effect after
     * `feeValueUpdateOffset` reward epochs have elapsed.
     *
     * Executor must pay a fee in order to register. See `registerExecutorFeeValueWei`.
     * @param _feeValue Desired fee, in wei. Must be between `minFeeValueWei` and `maxFeeValueWei`. 0 means no fee.
     * @return Reward epoch ID when the changes become effective.
     */
    function registerExecutor(uint256 _feeValue) external payable returns (uint256);

    /**
     * Unregisters the caller as an executor.
     * @return Reward epoch ID when the change becomes effective.
     */
    function unregisterExecutor() external returns (uint256);

    /**
     * Sets the caller's executor fee. The caller must be an executor registered through `registerExecutor`.
     *
     * When called multiple times inside the same reward epoch, only the last value remains.
     * @param _feeValue Desired fee, in wei. Must be between `minFeeValueWei` and `maxFeeValueWei`. 0 means no fee.
     * @return Reward epoch ID when the changes become effective.
     */
    function updateExecutorFeeValue(uint256 _feeValue) external returns(uint256);

    /**
     * Delegates a percentage of the caller's
     * [PDA](https://docs.flare.network/tech/personal-delegation-account)'s voting power to another address.
     * @param _to The address of the recipient.
     * @param _bips The percentage of voting power to be delegated expressed in basis points (1/100 of one percent).
     * Not cumulative: Every call resets the delegation value. A value of 0 revokes delegation.
     */
    function delegate(address _to, uint256 _bips) external;

    /**
     * Undelegates all percentage delegations from the caller's
     * [PDA](https://docs.flare.network/tech/personal-delegation-account) and then delegate to a list of accounts.
     *
     * See `delegate`.
     * @param _delegatees The addresses of the new recipients.
     * @param _bips The percentage of voting power to be delegated to each delegatee, expressed in basis points
     * (1/100 of one percent).
     * Total of all `_bips` values must be lower than 10000.
     */
    function batchDelegate(address[] memory _delegatees, uint256[] memory _bips) external;

    /**
     * Removes all delegations from the caller's [PDA](https://docs.flare.network/tech/personal-delegation-account).
     */
    function undelegateAll() external;

    /**
     * Revokes all delegation from the caller's [PDA](https://docs.flare.network/tech/personal-delegation-account)
     * to a given account at a given block.
     *
     * Only affects the reads via `votePowerOfAtCached()` in the specified block.
     *
     * This method should be used only to prevent rogue delegate voting in the current voting block.
     * To stop delegating use `delegate` with percentage of 0 or `undelegateAll`.
     * @param _who The account to revoke.
     * @param _blockNumber Block number where the revoking will take place. Must be in the past.
     */
    function revokeDelegationAt(address _who, uint256 _blockNumber) external;

    /**
     * Delegates all the [governance](https://docs.flare.network/tech/governance/) vote power of the caller's
     * [PDA](https://docs.flare.network/tech/personal-delegation-account) to another account.
     * @param _to Address of the recipient of the delegation.
     */
    function delegateGovernance(address _to) external;

    /**
     * Undelegates all [governance](https://docs.flare.network/tech/governance/) vote power currently delegated by
     * the caller's [PDA](https://docs.flare.network/tech/personal-delegation-account).
     */
    function undelegateGovernance() external;

    /**
     * Allows the caller to transfer `WNat` wrapped tokens from their
     * [PDA](https://docs.flare.network/tech/personal-delegation-account) to the owner account.
     * @param _amount Amount of tokens to transfer, in wei.
     */
    function withdraw(uint256 _amount) external;

    /**
     * Allows the caller to transfer ERC-20 tokens from their
     * [PDA](https://docs.flare.network/tech/personal-delegation-account) to the owner account.
     *
     * The main use case is to move ERC-20 tokes received by mistake (by an airdrop, for example) out of the PDA
     * and into the main account, where they can be more easily managed.
     *
     * Reverts if the target token is the `WNat` contract: use method `withdraw` for that.
     * @param _token Target token contract address.
     * @param _amount Amount of tokens to transfer.
     */
    function transferExternalToken(IERC20 _token, uint256 _amount) external;

    /**
     * Gets the [PDA](https://docs.flare.network/tech/personal-delegation-account) of an account.
     * @param _owner Account to query.
     * @return Address of its PDA or `address(0)` if it has not been created yet.
     */
    function accountToDelegationAccount(address _owner) external view returns (address);

    /**
     * Gets [PDA](https://docs.flare.network/tech/personal-delegation-account) data for an account.
     * @param _owner Account to query.
     * @return _delegationAccount Account's PDA address or `address(0)` if it has not been created yet.
     * @return _enabled Whether the PDA is enabled.
     */
    function getDelegationAccountData(
        address _owner
    )
        external view
        returns (IDelegationAccount _delegationAccount, bool _enabled);

    /**
     * Gets the addresses of executors authorized to claim for an account.
     * See `setClaimExecutors`.
     * @param _owner The account to query.
     * @return Addresses of all set executors.
     */
    function claimExecutors(address _owner) external view returns (address[] memory);

    /**
     * Gets the addresses of recipients allowed to receive rewards on behalf of an account.
     * Beside these, the owner of the rewards is always authorized.
     * See `setAllowedClaimRecipients`.
     * @param _rewardOwner The account to query.
     * @return Addresses of all set authorized recipients.
     */
    function allowedClaimRecipients(address _rewardOwner) external view returns (address[] memory);

    /**
     * Returns whether an executor is authorized to claim on behalf of a reward owner.
     * See `setClaimExecutors`.
     * @param _owner The reward owner to query.
     * @param _executor The executor to query.
     */
    function isClaimExecutor(address _owner, address _executor) external view returns(bool);

    /**
     * Returns the list of executors registered through `registerExecutor`.
     * Supports paging.
     * @param _start First executor to return.
     * @param _end Last executor to return.
     * @return _registeredExecutors Addresses of the registered executors.
     * @return _totalLength Total amount of executors.
     */
    function getRegisteredExecutors(
        uint256 _start,
        uint256 _end
    )
        external view
        returns (address[] memory _registeredExecutors, uint256 _totalLength);

    /**
     * Returns information about an executor.
     * @param _executor The executor to query.
     * @return _registered Whether the executor is registered.
     * @return _currentFeeValue Executor's current fee value, if registered.
     */
    function getExecutorInfo(address _executor) external view returns (bool _registered, uint256 _currentFeeValue);

    /**
     * Returns the current fee of a registered executor.
     * Reverts if the executor is not registered.
     * @param _executor The executor to query.
     * @return Fee in wei.
     */
    function getExecutorCurrentFeeValue(address _executor) external view  returns (uint256);

    /**
     * Returns the fee of an executor at a given reward epoch.
     * @param _executor The executor to query.
     * @param _rewardEpoch Reward Epoch ID to query.
     * @return Fee in wei at that reward epoch.
     */
    function getExecutorFeeValue(address _executor, uint256 _rewardEpoch) external view returns (uint256);

    /**
     * Returns the currently scheduled fee changes of an executor.
     * @param _executor Executor to query.
     * @return _feeValue Array of scheduled fees.
     * @return _validFromEpoch Array of reward epochs ID where the scheduled fees will become effective.
     * @return _fixed Array of booleans indicating if an scheduled fee change is fixed or it might still be changed.
     */
    function getExecutorScheduledFeeValueChanges(address _executor)
        external view
        returns (
            uint256[] memory _feeValue,
            uint256[] memory _validFromEpoch,
            bool[] memory _fixed
        );
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;

import "./IClaimSetupManager.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IDelegationAccount {

    event DelegateFtso(address to, uint256 bips);
    event RevokeFtso(address to, uint256 blockNumber);
    event UndelegateAllFtso();
    event DelegateGovernance(address to);
    event UndelegateGovernance();
    event WithdrawToOwner(uint256 amount);
    event ExternalTokenTransferred(IERC20 token, uint256 amount);
    event ExecutorFeePaid(address executor, uint256 amount);
    event Initialize(address owner, IClaimSetupManager manager);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;


/**
 * Interface for the `GovernanceSettings` that hold the Flare governance address and its timelock.
 *
 * All governance calls are delayed by the timelock specified in this contract.
 *
 * **NOTE**: This contract enables updating the governance address and timelock only
 * by hard-forking the network, meaning only by updating validator code.
 */
interface IGovernanceSettings {
    /**
     * Gets the governance account address.
     * The governance address can only be changed by a hard fork.
     * @return _address The governance account address.
     */
    function getGovernanceAddress() external view returns (address _address);

    /**
     * Gets the time in seconds that must pass between a governance call and its execution.
     * The timelock value can only be changed by a hard fork.
     * @return _timelock Time in seconds that passes between the governance call and execution.
     */
    function getTimelock() external view returns (uint256 _timelock);

    /**
     * Gets the addresses of the accounts that are allowed to execute the timelocked governance calls,
     * once the timelock period expires.
     * Executors can be changed without a hard fork, via a normal governance call.
     * @return _addresses Array of executor addresses.
     */
    function getExecutors() external view returns (address[] memory _addresses);

    /**
     * Checks whether an address is one of the allowed executors. See `getExecutors`.
     * @param _address The address to check.
     * @return True if `_address` is in the executors list.
     */
    function isExecutor(address _address) external view returns (bool);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;

/**
 * Interface for contracts delegating their governance vote power.
 */
interface IGovernanceVotePower {
    /**
     * Delegates all governance vote power of `msg.sender` to address `_to`.
     * @param _to The address of the recipient.
     */
    function delegate(address _to) external;

    /**
     * Undelegates all governance vote power of `msg.sender`.
     */
    function undelegate() external;

    /**
     * Gets the governance vote power of an address at a given block number, including
     * all delegations made to it.
     * @param _who The address being queried.
     * @param _blockNumber The block number at which to fetch the vote power.
     * @return Governance vote power of `_who` at `_blockNumber`.
     */
    function votePowerOfAt(address _who, uint256 _blockNumber) external view returns(uint256);

    /**
     * Gets the governance vote power of an address at the latest block, including
     * all delegations made to it.
     * @param _who The address being queried.
     * @return Governance vote power of `account` at the lastest block.
     */
    function getVotes(address _who) external view returns (uint256);

    /**
     * Gets the address an account is delegating its governance vote power to, at a given block number.
     * @param _who The address being queried.
     * @param _blockNumber The block number at which to fetch the address.
     * @return Address where `_who` was delegating its governance vote power at block `_blockNumber`.
     */
    function getDelegateOfAt(address _who, uint256 _blockNumber) external view returns (address);

    /**
     * Gets the address an account is delegating its governance vote power to, at the latest block number.
     * @param _who The address being queried.
     * @return Address where `_who` is currently delegating its governance vote power.
     */
    function getDelegateOfAtNow(address _who) external view returns (address);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;

/**
 * Events interface for vote-power related operations.
 */
interface IVPContractEvents {
    /**
     * Emitted when the amount of vote power delegated from one account to another changes.
     *
     * **Note**: This event is always emitted from VPToken's `writeVotePowerContract`.
     * @param from The account that has changed the amount of vote power it is delegating.
     * @param to The account whose received vote power has changed.
     * @param priorVotePower The vote power originally delegated.
     * @param newVotePower The new vote power that triggered this event.
     * It can be 0 if the delegation is completely canceled.
     */
    event Delegate(address indexed from, address indexed to, uint256 priorVotePower, uint256 newVotePower);

    /**
     * Emitted when an account revokes its vote power delegation to another account
     * for a single current or past block (typically the current vote block).
     *
     * **Note**: This event is always emitted from VPToken's `writeVotePowerContract` or `readVotePowerContract`.
     *
     * See `revokeDelegationAt` in `IVPToken`.
     * @param delegator The account that revoked the delegation.
     * @param delegatee The account that has been revoked.
     * @param votePower The revoked vote power.
     * @param blockNumber The block number at which the delegation has been revoked.
     */
    event Revoke(address indexed delegator, address indexed delegatee, uint256 votePower, uint256 blockNumber);
}
          

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.6 <0.9;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IGovernanceVotePower} from "./IGovernanceVotePower.sol";
import {IVPContractEvents} from "./IVPContractEvents.sol";

/**
 * Vote power token interface.
 */
interface IVPToken is IERC20 {
    /**
     * Delegate voting power to account `_to` from `msg.sender`, by percentage.
     * @param _to The address of the recipient.
     * @param _bips The percentage of voting power to be delegated expressed in basis points (1/100 of one percent).
     *   Not cumulative: every call resets the delegation value (and a value of 0 revokes all previous delegations).
     */
    function delegate(address _to, uint256 _bips) external;

    /**
     * Undelegate all percentage delegations from the sender and then delegate corresponding
     *   `_bips` percentage of voting power from the sender to each member of the `_delegatees` array.
     * @param _delegatees The addresses of the new recipients.
     * @param _bips The percentages of voting power to be delegated expressed in basis points (1/100 of one percent).
     *   The sum of all `_bips` values must be at most 10000 (100%).
     */
    function batchDelegate(address[] memory _delegatees, uint256[] memory _bips) external;

    /**
     * Explicitly delegate `_amount` voting power to account `_to` from `msg.sender`.
     * Compare with `delegate` which delegates by percentage.
     * @param _to The address of the recipient.
     * @param _amount An explicit vote power amount to be delegated.
     *   Not cumulative: every call resets the delegation value (and a value of 0 revokes all previous delegations).
     */
    function delegateExplicit(address _to, uint _amount) external;

    /**
    * Revoke all delegation from sender to `_who` at given block.
    * Only affects the reads via `votePowerOfAtCached()` in the block `_blockNumber`.
    * Block `_blockNumber` must be in the past.
    * This method should be used only to prevent rogue delegate voting in the current voting block.
    * To stop delegating use delegate / delegateExplicit with value of 0 or undelegateAll / undelegateAllExplicit.
    * @param _who Address of the delegatee.
    * @param _blockNumber The block number at which to revoke delegation..
    */
    function revokeDelegationAt(address _who, uint _blockNumber) external;

    /**
     * Undelegate all voting power of `msg.sender`. This effectively revokes all previous delegations.
     * Can only be used with percentage delegation.
     * Does not reset delegation mode back to NOT SET.
     */
    function undelegateAll() external;

    /**
     * Undelegate all explicit vote power by amount of `msg.sender`.
     * Can only be used with explicit delegation.
     * Does not reset delegation mode back to NOT SET.
     * @param _delegateAddresses Explicit delegation does not store delegatees' addresses,
     *   so the caller must supply them.
     * @return The amount still delegated (in case the list of delegates was incomplete).
     */
    function undelegateAllExplicit(address[] memory _delegateAddresses) external returns (uint256);


    /**
     * Returns the name of the token.
     * @dev Should be compatible with ERC20 method.
     */
    function name() external view returns (string memory);

    /**
     * Returns the symbol of the token, usually a shorter version of the name.
     * @dev Should be compatible with ERC20 method.
     */
    function symbol() external view returns (string memory);

    /**
     * Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals 2, a balance of 505 tokens should
     * be displayed to a user as 5.05 (505 / 10<sup>2</sup>).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * balanceOf and transfer.
     * @dev Should be compatible with ERC20 method.
     */
    function decimals() external view returns (uint8);


    /**
     * Total amount of tokens held by all accounts at a specific block number.
     * @param _blockNumber The block number to query.
     * @return The total amount of tokens at `_blockNumber`.
     */
    function totalSupplyAt(uint _blockNumber) external view returns(uint256);

    /**
     * Queries the token balance of `_owner` at a specific `_blockNumber`.
     * @param _owner The address from which the balance will be retrieved.
     * @param _blockNumber The block number to query.
     * @return The balance at `_blockNumber`.
     */
    function balanceOfAt(address _owner, uint _blockNumber) external view returns (uint256);


    /**
     * Get the current total vote power.
     * @return The current total vote power (sum of all accounts' vote power).
     */
    function totalVotePower() external view returns(uint256);

    /**
     * Get the total vote power at block `_blockNumber`.
     * @param _blockNumber The block number to query.
     * @return The total vote power at the queried block (sum of all accounts' vote powers).
     */
    function totalVotePowerAt(uint _blockNumber) external view returns(uint256);

    /**
     * Get the current vote power of `_owner`.
     * @param _owner The address to query.
     * @return Current vote power of `_owner`.
     */
    function votePowerOf(address _owner) external view returns(uint256);

    /**
     * Get the vote power of `_owner` at block `_blockNumber`
     * @param _owner The address to query.
     * @param _blockNumber The block number to query.
     * @return Vote power of `_owner` at block number `_blockNumber`.
     */
    function votePowerOfAt(address _owner, uint256 _blockNumber) external view returns(uint256);

    /**
     * Get the vote power of `_owner` at block `_blockNumber`, ignoring revocation information (and cache).
     * @param _owner The address to query.
     * @param _blockNumber The block number to query.
     * @return Vote power of `_owner` at block number `_blockNumber`. Result doesn't change if vote power is revoked.
     */
    function votePowerOfAtIgnoringRevocation(address _owner, uint256 _blockNumber) external view returns(uint256);

    /**
     * Get the delegation mode for account '_who'. This mode determines whether vote power is
     * allocated by percentage or by explicit amount. Once the delegation mode is set,
     * it can never be changed, even if all delegations are removed.
     * @param _who The address to get delegation mode.
     * @return Delegation mode: 0 = NOT SET, 1 = PERCENTAGE, 2 = AMOUNT (i.e. explicit).
     */
    function delegationModeOf(address _who) external view returns(uint256);

    /**
     * Get current delegated vote power from delegator `_from` to delegatee `_to`.
     * @param _from Address of delegator.
     * @param _to Address of delegatee.
     * @return votePower The delegated vote power.
     */
    function votePowerFromTo(address _from, address _to) external view returns(uint256);

    /**
     * Get delegated vote power from delegator `_from` to delegatee `_to` at `_blockNumber`.
     * @param _from Address of delegator.
     * @param _to Address of delegatee.
     * @param _blockNumber The block number to query.
     * @return The delegated vote power.
     */
    function votePowerFromToAt(address _from, address _to, uint _blockNumber) external view returns(uint256);

    /**
     * Compute the current undelegated vote power of the `_owner` account.
     * @param _owner The address to query.
     * @return The unallocated vote power of `_owner`.
     */
    function undelegatedVotePowerOf(address _owner) external view returns(uint256);

    /**
     * Get the undelegated vote power of the `_owner` account at a given block number.
     * @param _owner The address to query.
     * @param _blockNumber The block number to query.
     * @return The unallocated vote power of `_owner`.
     */
    function undelegatedVotePowerOfAt(address _owner, uint256 _blockNumber) external view returns(uint256);

    /**
     * Get the list of addresses to which `_who` is delegating, and their percentages.
     * @param _who The address to query.
     * @return _delegateAddresses Positional array of addresses being delegated to.
     * @return _bips Positional array of delegation percents specified in basis points (1/100 of 1 percent).
     *    Each one matches the address in the same position in the `_delegateAddresses` array.
     * @return _count The number of delegates.
     * @return _delegationMode Delegation mode: 0 = NOT SET, 1 = PERCENTAGE, 2 = AMOUNT (i.e. explicit).
     */
    function delegatesOf(address _who)
        external view
        returns (
            address[] memory _delegateAddresses,
            uint256[] memory _bips,
            uint256 _count,
            uint256 _delegationMode
        );

    /**
     * Get the list of addresses to which `_who` is delegating, and their percentages, at the given block.
     * @param _who The address to query.
     * @param _blockNumber The block number to query.
     * @return _delegateAddresses Positional array of addresses being delegated to.
     * @return _bips Positional array of delegation percents specified in basis points (1/100 of 1 percent).
     *    Each one matches the address in the same position in the `_delegateAddresses` array.
     * @return _count The number of delegates.
     * @return _delegationMode Delegation mode: 0 = NOT SET, 1 = PERCENTAGE, 2 = AMOUNT (i.e. explicit).
     */
    function delegatesOfAt(address _who, uint256 _blockNumber)
        external view
        returns (
            address[] memory _delegateAddresses,
            uint256[] memory _bips,
            uint256 _count,
            uint256 _delegationMode
        );

    /**
     * Returns VPContract event interface used for read-only operations (view methods).
     * The only non-view method that might be called on it is `revokeDelegationAt`.
     *
     * `readVotePowerContract` is almost always equal to `writeVotePowerContract`
     * except during an upgrade from one `VPContract` to a new version (which should happen
     * rarely or never and will be announced beforehand).
     *
     * Do not call any methods on `VPContract` directly.
     * State changing methods are forbidden from direct calls.
     * All methods are exposed via `VPToken`.
     * This is the reason that this method returns `IVPContractEvents`.
     * Use it only for listening to events and revoking.
     */
    function readVotePowerContract() external view returns (IVPContractEvents);

    /**
     * Returns VPContract event interface used for state-changing operations (non-view methods).
     * The only non-view method that might be called on it is `revokeDelegationAt`.
     *
     * `writeVotePowerContract` is almost always equal to `readVotePowerContract`,
     * except during upgrade from one `VPContract` to a new version (which should happen
     * rarely or never and will be announced beforehand).
     * In the case of an upgrade, `writeVotePowerContract` is replaced first to establish delegations.
     * After some period (e.g., after a reward epoch ends), `readVotePowerContract` is set equal to it.
     *
     * Do not call any methods on `VPContract` directly.
     * State changing methods are forbidden from direct calls.
     * All are exposed via `VPToken`.
     * This is the reason that this method returns `IVPContractEvents`
     * Use it only for listening to events, delegating, and revoking.
     */
    function writeVotePowerContract() external view returns (IVPContractEvents);

    /**
     * When set, allows token owners to participate in governance voting
     * and delegating governance vote power.
     */
    function governanceVotePower() external view returns (IGovernanceVotePower);
}