Contract 0xA3a18348e6E2d3897B6f2671bb8c120e36554802

 
 
Txn Hash
Method
Block
From
To
Value
0xeb425f4423fd8fae84a97ed08877e9e19fc94e63f5594a8053d1fd97070019d60x60806040133252572021-09-30 5:35:39432 days 50 mins agoRocket Pool: Deployer 2 IN  Create: RocketRewardsPool0 Ether0.234080480
[ Download CSV Export 
View more zero value Internal Transactions in Advanced View mode
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
RocketRewardsPool

Compiler Version
v0.7.6+commit.7338295f

Optimization Enabled:
Yes with 15000 runs

Other Settings:
default evmVersion, GNU GPLv3 license
File 1 of 12 : SafeMath.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

File 2 of 12 : ERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "../../utils/Context.sol";
import "./IERC20.sol";
import "../../math/SafeMath.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev 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 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

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

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal virtual {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

File 3 of 12 : ERC20Burnable.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "../../utils/Context.sol";
import "./ERC20.sol";

/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    using SafeMath for uint256;

    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");

        _approve(account, _msgSender(), decreasedAllowance);
        _burn(account, amount);
    }
}

File 4 of 12 : IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

    /**
     * @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);
}

File 5 of 12 : Context.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

File 6 of 12 : RocketBase.sol
/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |    DECENTRALISED STAKING PROTOCOL FOR ETHEREUM    |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind Ethereum staking pool protocol, designed to
  *  be community-owned, decentralised, and trustless.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-only

import "../interface/RocketStorageInterface.sol";

/// @title Base settings / modifiers for each contract in Rocket Pool
/// @author David Rugendyke

abstract contract RocketBase {

    // Calculate using this as the base
    uint256 constant calcBase = 1 ether;

    // Version of the contract
    uint8 public version;

    // The main storage contract where primary persistant storage is maintained
    RocketStorageInterface rocketStorage = RocketStorageInterface(0);


    /*** Modifiers **********************************************************/

    /**
    * @dev Throws if called by any sender that doesn't match a Rocket Pool network contract
    */
    modifier onlyLatestNetworkContract() {
        require(getBool(keccak256(abi.encodePacked("contract.exists", msg.sender))), "Invalid or outdated network contract");
        _;
    }

    /**
    * @dev Throws if called by any sender that doesn't match one of the supplied contract or is the latest version of that contract
    */
    modifier onlyLatestContract(string memory _contractName, address _contractAddress) {
        require(_contractAddress == getAddress(keccak256(abi.encodePacked("contract.address", _contractName))), "Invalid or outdated contract");
        _;
    }

    /**
    * @dev Throws if called by any sender that isn't a registered node
    */
    modifier onlyRegisteredNode(address _nodeAddress) {
        require(getBool(keccak256(abi.encodePacked("node.exists", _nodeAddress))), "Invalid node");
        _;
    }

    /**
    * @dev Throws if called by any sender that isn't a trusted node DAO member
    */
    modifier onlyTrustedNode(address _nodeAddress) {
        require(getBool(keccak256(abi.encodePacked("dao.trustednodes.", "member", _nodeAddress))), "Invalid trusted node");
        _;
    }

    /**
    * @dev Throws if called by any sender that isn't a registered minipool
    */
    modifier onlyRegisteredMinipool(address _minipoolAddress) {
        require(getBool(keccak256(abi.encodePacked("minipool.exists", _minipoolAddress))), "Invalid minipool");
        _;
    }
    

    /**
    * @dev Throws if called by any account other than a guardian account (temporary account allowed access to settings before DAO is fully enabled)
    */
    modifier onlyGuardian() {
        require(msg.sender == rocketStorage.getGuardian(), "Account is not a temporary guardian");
        _;
    }




    /*** Methods **********************************************************/

    /// @dev Set the main Rocket Storage address
    constructor(RocketStorageInterface _rocketStorageAddress) {
        // Update the contract address
        rocketStorage = RocketStorageInterface(_rocketStorageAddress);
    }


    /// @dev Get the address of a network contract by name
    function getContractAddress(string memory _contractName) internal view returns (address) {
        // Get the current contract address
        address contractAddress = getAddress(keccak256(abi.encodePacked("contract.address", _contractName)));
        // Check it
        require(contractAddress != address(0x0), "Contract not found");
        // Return
        return contractAddress;
    }


    /// @dev Get the address of a network contract by name (returns address(0x0) instead of reverting if contract does not exist)
    function getContractAddressUnsafe(string memory _contractName) internal view returns (address) {
        // Get the current contract address
        address contractAddress = getAddress(keccak256(abi.encodePacked("contract.address", _contractName)));
        // Return
        return contractAddress;
    }


    /// @dev Get the name of a network contract by address
    function getContractName(address _contractAddress) internal view returns (string memory) {
        // Get the contract name
        string memory contractName = getString(keccak256(abi.encodePacked("contract.name", _contractAddress)));
        // Check it
        require(bytes(contractName).length > 0, "Contract not found");
        // Return
        return contractName;
    }

    /// @dev Get revert error message from a .call method
    function getRevertMsg(bytes memory _returnData) internal pure returns (string memory) {
        // If the _res length is less than 68, then the transaction failed silently (without a revert message)
        if (_returnData.length < 68) return "Transaction reverted silently";
        assembly {
            // Slice the sighash.
            _returnData := add(_returnData, 0x04)
        }
        return abi.decode(_returnData, (string)); // All that remains is the revert string
    }



    /*** Rocket Storage Methods ****************************************/

    // Note: Unused helpers have been removed to keep contract sizes down

    /// @dev Storage get methods
    function getAddress(bytes32 _key) internal view returns (address) { return rocketStorage.getAddress(_key); }
    function getUint(bytes32 _key) internal view returns (uint) { return rocketStorage.getUint(_key); }
    function getString(bytes32 _key) internal view returns (string memory) { return rocketStorage.getString(_key); }
    function getBytes(bytes32 _key) internal view returns (bytes memory) { return rocketStorage.getBytes(_key); }
    function getBool(bytes32 _key) internal view returns (bool) { return rocketStorage.getBool(_key); }
    function getInt(bytes32 _key) internal view returns (int) { return rocketStorage.getInt(_key); }
    function getBytes32(bytes32 _key) internal view returns (bytes32) { return rocketStorage.getBytes32(_key); }

    /// @dev Storage set methods
    function setAddress(bytes32 _key, address _value) internal { rocketStorage.setAddress(_key, _value); }
    function setUint(bytes32 _key, uint _value) internal { rocketStorage.setUint(_key, _value); }
    function setString(bytes32 _key, string memory _value) internal { rocketStorage.setString(_key, _value); }
    function setBytes(bytes32 _key, bytes memory _value) internal { rocketStorage.setBytes(_key, _value); }
    function setBool(bytes32 _key, bool _value) internal { rocketStorage.setBool(_key, _value); }
    function setInt(bytes32 _key, int _value) internal { rocketStorage.setInt(_key, _value); }
    function setBytes32(bytes32 _key, bytes32 _value) internal { rocketStorage.setBytes32(_key, _value); }

    /// @dev Storage delete methods
    function deleteAddress(bytes32 _key) internal { rocketStorage.deleteAddress(_key); }
    function deleteUint(bytes32 _key) internal { rocketStorage.deleteUint(_key); }
    function deleteString(bytes32 _key) internal { rocketStorage.deleteString(_key); }
    function deleteBytes(bytes32 _key) internal { rocketStorage.deleteBytes(_key); }
    function deleteBool(bytes32 _key) internal { rocketStorage.deleteBool(_key); }
    function deleteInt(bytes32 _key) internal { rocketStorage.deleteInt(_key); }
    function deleteBytes32(bytes32 _key) internal { rocketStorage.deleteBytes32(_key); }

    /// @dev Storage arithmetic methods
    function addUint(bytes32 _key, uint256 _amount) internal { rocketStorage.addUint(_key, _amount); }
    function subUint(bytes32 _key, uint256 _amount) internal { rocketStorage.subUint(_key, _amount); }
}

File 7 of 12 : RocketRewardsPool.sol
/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |    DECENTRALISED STAKING PROTOCOL FOR ETHEREUM    |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind Ethereum staking pool protocol, designed to
  *  be community-owned, decentralised, and trustless.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-only

import "../RocketBase.sol";
import "../../interface/token/RocketTokenRPLInterface.sol";
import "../../interface/rewards/RocketRewardsPoolInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsRewardsInterface.sol";
import "../../interface/RocketVaultInterface.sol";

import "@openzeppelin/contracts/math/SafeMath.sol";


// Holds RPL generated by the network for claiming from stakers (node operators etc)

contract RocketRewardsPool is RocketBase, RocketRewardsPoolInterface {

    // Libs
    using SafeMath for uint;


    // Events
    event RPLTokensClaimed(address indexed claimingContract, address indexed claimingAddress, uint256 amount, uint256 time);  
    
    // Modifiers

    /**
    * @dev Throws if called by any sender that doesn't match a Rocket Pool claim contract
    */
    modifier onlyClaimContract() {
        require(getClaimingContractExists(getContractName(msg.sender)), "Not a valid rewards claiming contact");
        _;
    }

    /**
    * @dev Throws if called by any sender that doesn't match an enabled Rocket Pool claim contract
    */
    modifier onlyEnabledClaimContract() {
        require(getClaimingContractEnabled(getContractName(msg.sender)), "Not a valid rewards claiming contact or it has been disabled");
        _;
    }


    // Construct
    constructor(RocketStorageInterface _rocketStorageAddress) RocketBase(_rocketStorageAddress) {
        // Version
        version = 1;
        // Set the claim interval start time as the current time
        setUint(keccak256("rewards.pool.claim.interval.time.start"), block.timestamp);
    }


    /**
    * Get how much RPL the Rewards Pool contract currently has assigned to it as a whole
    * @return uint256 Returns rpl balance of rocket rewards contract
    */
    function getRPLBalance() override external view returns(uint256) {
        // Get the vault contract instance
        RocketVaultInterface rocketVault = RocketVaultInterface(getContractAddress("rocketVault"));
        // Check per contract
        return rocketVault.balanceOfToken("rocketRewardsPool", IERC20(getContractAddress("rocketTokenRPL")));
    }


    /**
    * Get the last set interval start time
    * @return uint256 Last set start timestamp for a claim interval
    */
    function getClaimIntervalTimeStart() override public view returns(uint256) {
        return getUint(keccak256("rewards.pool.claim.interval.time.start"));
    }


    /**
    * Compute the current start time before a claim is made, takes into account intervals that may have passed
    * @return uint256 Computed starting timestamp for next possible claim
    */
    function getClaimIntervalTimeStartComputed() override public view returns(uint256) {
        // If intervals have passed, a new start timestamp will be used for the next claim, if it's the same interval then return that
        uint256 claimIntervalTimeStart = getClaimIntervalTimeStart();
        uint256 claimIntervalTime = getClaimIntervalTime();
        return _getClaimIntervalTimeStartComputed(claimIntervalTimeStart, claimIntervalTime);
    }

    function _getClaimIntervalTimeStartComputed(uint256 _claimIntervalTimeStart, uint256 _claimIntervalTime) private view returns (uint256) {
        uint256 claimIntervalsPassed = _getClaimIntervalsPassed(_claimIntervalTimeStart, _claimIntervalTime);
        return claimIntervalsPassed == 0 ? _claimIntervalTimeStart : _claimIntervalTimeStart.add(_claimIntervalTime.mul(claimIntervalsPassed));
    }


    /**
    * Compute intervals since last claim period
    * @return uint256 Time intervals since last update
    */
    function getClaimIntervalsPassed() override public view returns(uint256) {
        // Calculate now if inflation has begun
        return _getClaimIntervalsPassed(getClaimIntervalTimeStart(), getClaimIntervalTime());
    }

    function _getClaimIntervalsPassed(uint256 _claimIntervalTimeStart, uint256 _claimIntervalTime) private view returns (uint256) {
        return block.timestamp.sub(_claimIntervalTimeStart).div(_claimIntervalTime);
    }


    /**
    * Get how many seconds in a claim interval
    * @return uint256 Number of seconds in a claim interval
    */
    function getClaimIntervalTime() override public view returns(uint256) {
        // Get from the DAO settings
        RocketDAOProtocolSettingsRewardsInterface daoSettingsRewards = RocketDAOProtocolSettingsRewardsInterface(getContractAddress("rocketDAOProtocolSettingsRewards"));
        return daoSettingsRewards.getRewardsClaimIntervalTime();
    }


    /**
    * Get the last time a claim was made
    * @return uint256 Last time a claim was made
    */
    function getClaimTimeLastMade() override external view returns(uint256) {
        return getUint(keccak256("rewards.pool.claim.interval.time.last"));
    }


    // Check whether a claiming contract exists
    function getClaimingContractExists(string memory _contractName) override public view returns (bool) {
        RocketDAOProtocolSettingsRewardsInterface daoSettingsRewards = RocketDAOProtocolSettingsRewardsInterface(getContractAddress("rocketDAOProtocolSettingsRewards"));
        return (daoSettingsRewards.getRewardsClaimerPercTimeUpdated(_contractName) > 0);
    }


    // If the claiming contact has a % allocated to it higher than 0, it can claim
    function getClaimingContractEnabled(string memory _contractName) override public view returns (bool) {
        // Load contract
        RocketDAOProtocolSettingsRewardsInterface daoSettingsRewards = RocketDAOProtocolSettingsRewardsInterface(getContractAddress("rocketDAOProtocolSettingsRewards"));
        // Now verify this contract can claim by having a claim perc > 0 
        return daoSettingsRewards.getRewardsClaimerPerc(_contractName) > 0 ? true : false;
    }
    

    /**
    * The current claim amount total for this interval per claiming contract
    * @return uint256 The current claim amount for this interval for the claiming contract
    */
    function getClaimingContractTotalClaimed(string memory _claimingContract) override external view returns(uint256) {
        return _getClaimingContractTotalClaimed(_claimingContract, getClaimIntervalTimeStartComputed());
    }

    function _getClaimingContractTotalClaimed(string memory _claimingContract, uint256 _claimIntervalTimeStartComputed) private view returns(uint256) {
        return getUint(keccak256(abi.encodePacked("rewards.pool.claim.interval.contract.total", _claimIntervalTimeStartComputed, _claimingContract)));
    }

    
    /**
    * Have they claimed already during this interval? 
    * @return bool Returns true if they can claim during this interval
    */
    function getClaimingContractUserHasClaimed(uint256 _claimIntervalStartTime, string memory _claimingContract, address _claimerAddress) override public view returns(bool) {
        // Check per contract
        return getBool(keccak256(abi.encodePacked("rewards.pool.claim.interval.claimer.address", _claimIntervalStartTime, _claimingContract, _claimerAddress)));
    }


    /**
    * Get the time this account registered as a claimer at
    * @return uint256 Returns the time the account was registered at
    */
    function getClaimingContractUserRegisteredTime(string memory _claimingContract, address _claimerAddress) override public view returns(uint256) {
        return getUint(keccak256(abi.encodePacked("rewards.pool.claim.contract.registered.time", _claimingContract, _claimerAddress)));
    }

    
    /**
    * Get whether this address can currently make a claim
    * @return bool Returns true if the _claimerAddress can make a claim
    */
    function getClaimingContractUserCanClaim(string memory _claimingContract, address _claimerAddress) override public view returns(bool) {
        return _getClaimingContractUserCanClaim(_claimingContract, _claimerAddress, getClaimIntervalTime());
    }

    function _getClaimingContractUserCanClaim(string memory _claimingContract, address _claimerAddress, uint256 _claimIntervalTime) private view returns(bool) {
        // Get the time they registered at
        uint256 registeredTime = getClaimingContractUserRegisteredTime(_claimingContract, _claimerAddress);
        // If it's 0 or hasn't passed one interval yet, they can't claim
        return registeredTime > 0 && registeredTime.add(_claimIntervalTime) <= block.timestamp && getClaimingContractPerc(_claimingContract) > 0 ? true : false;
    }


    /**
    * Get the number of claimers for the current interval per claiming contract
    * @return uint256 Returns number of claimers for the current interval per claiming contract
    */
    function getClaimingContractUserTotalCurrent(string memory _claimingContract) override external view returns(uint256) {
        // Return the current interval amount if in that interval, if we are moving to the next one upon next claim, use that
        return getClaimIntervalsPassed() == 0 ? getUint(keccak256(abi.encodePacked("rewards.pool.claim.interval.claimers.total.current", _claimingContract))) : getClaimingContractUserTotalNext(_claimingContract);
    }


    /**
    * Get the number of claimers that will be added/removed on the next interval
    * @return uint256 Returns the number of claimers that will be added/removed on the next interval
    */
    function getClaimingContractUserTotalNext(string memory _claimingContract) override public view returns(uint256) {
        return getUint(keccak256(abi.encodePacked("rewards.pool.claim.interval.claimers.total.next", _claimingContract)));
    }


    /**
    * Get contract claiming percentage last recorded
    * @return uint256 Returns the contract claiming percentage last recorded
    */
    function getClaimingContractPercLast(string memory _claimingContract) override public view returns(uint256) {
        return getUint(keccak256(abi.encodePacked("rewards.pool.claim.interval.contract.perc.current", _claimingContract)));
    }

   
    /**
    * Get the approx amount of rewards available for this claim interval
    * @return uint256 Rewards amount for current claim interval
    */
    function getClaimIntervalRewardsTotal() override public view returns(uint256) {
        // Get the RPL contract instance
        RocketTokenRPLInterface rplContract = RocketTokenRPLInterface(getContractAddress("rocketTokenRPL"));
        // Get the vault contract instance
        RocketVaultInterface rocketVault = RocketVaultInterface(getContractAddress("rocketVault"));
        // Rewards amount
        uint256 rewardsTotal = 0;
        // Is this the first claim of this interval? If so, calculate expected inflation RPL + any RPL already in the pool
        if(getClaimIntervalsPassed() > 0) {
            // Get the balance of tokens that will be transferred to the vault for this contract when the first claim is made
            // Also account for any RPL tokens already in the vault for the rewards pool
            rewardsTotal = rplContract.inflationCalculate().add(rocketVault.balanceOfToken("rocketRewardsPool", IERC20(getContractAddress("rocketTokenRPL"))));
        }else{
            // Claims have already been made, lets retrieve rewards total stored on first claim of this interval
            rewardsTotal = getUint(keccak256("rewards.pool.claim.interval.total"));
        }
        // Done
        return rewardsTotal;
    }


    /**
    * Get the percentage this contract can claim in this interval
    * @return uint256 Rewards percentage this contract can claim in this interval
    */
    function getClaimingContractPerc(string memory _claimingContract) override public view returns(uint256) {
        // Load contract
        RocketDAOProtocolSettingsRewardsInterface daoSettingsRewards = RocketDAOProtocolSettingsRewardsInterface(getContractAddress("rocketDAOProtocolSettingsRewards"));
        // Get the % amount allocated to this claim contract
        uint256 claimContractPerc = daoSettingsRewards.getRewardsClaimerPerc(_claimingContract);
        // Get the time the % was changed at, it will only use this % on the next interval
        if(daoSettingsRewards.getRewardsClaimerPercTimeUpdated(_claimingContract) > getClaimIntervalTimeStartComputed()) {
            // Ok so this percentage was set during this interval, we must use the current % assigned to the last claim and the new one will kick in the next interval
            // If this is 0, the contract hasn't made a claim yet and can only do so on the next interval
            claimContractPerc = getClaimingContractPercLast(_claimingContract);
        }
        // Done
        return claimContractPerc;
    }


    /**
    * Get the approx amount of rewards available for this claim interval per claiming contract
    * @return uint256 Rewards amount for current claim interval per claiming contract
    */
    function getClaimingContractAllowance(string memory _claimingContract) override public view returns(uint256) {
        // Get the % amount this claim contract will get
        uint256 claimContractPerc = getClaimingContractPerc(_claimingContract);
        // How much rewards are available for this claim interval?
        uint256 claimIntervalRewardsTotal = getClaimIntervalRewardsTotal();
        // How much this claiming contract is entitled to in perc
        uint256 contractClaimTotal = 0;
        // Check now
        if(claimContractPerc > 0 && claimIntervalRewardsTotal > 0)  {
            // Calculate how much rewards this claimer will receive based on their claiming perc
            contractClaimTotal = claimContractPerc.mul(claimIntervalRewardsTotal).div(calcBase);
        }
        // Done
        return contractClaimTotal;
    }

    
    // How much this claimer is entitled to claim, checks parameters that claim() will check
    function getClaimAmount(string memory _claimingContract, address _claimerAddress, uint256 _claimerAmountPerc) override external view returns (uint256) {
        if (!getClaimingContractUserCanClaim(_claimingContract, _claimerAddress)) {
            return 0;
        }
        uint256 claimIntervalTimeStartComptued = getClaimIntervalTimeStartComputed();
        uint256 claimingContractTotalClaimed = _getClaimingContractTotalClaimed(_claimingContract, claimIntervalTimeStartComptued);
        return _getClaimAmount(_claimingContract, _claimerAddress, _claimerAmountPerc, claimIntervalTimeStartComptued, claimingContractTotalClaimed);
    }

    function _getClaimAmount(string memory _claimingContract, address _claimerAddress, uint256 _claimerAmountPerc, uint256 _claimIntervalTimeStartComputed, uint256 _claimingContractTotalClaimed) private view returns (uint256) {
        // Get the total rewards available for this claiming contract
        uint256 contractClaimTotal = getClaimingContractAllowance(_claimingContract);
        // How much of the above that this claimer will receive
        uint256 claimerTotal = 0;
        // Are we good to proceed?
        if( contractClaimTotal > 0 &&
            _claimerAmountPerc > 0 &&
            _claimerAmountPerc <= 1 ether &&
            _claimerAddress != address(0x0) &&
            getClaimingContractEnabled(_claimingContract) &&
            !getClaimingContractUserHasClaimed(_claimIntervalTimeStartComputed, _claimingContract, _claimerAddress)) {

            // Now calculate how much this claimer would receive
            claimerTotal = _claimerAmountPerc.mul(contractClaimTotal).div(calcBase);
            // Is it more than currently available + the amount claimed already for this claim interval?
            claimerTotal = claimerTotal.add(_claimingContractTotalClaimed) <= contractClaimTotal ? claimerTotal : 0;
        }
        // Done
        return claimerTotal;
    }


    // An account must be registered to claim from the rewards pool. They must wait one claim interval before they can collect.
    // Also keeps track of total 
    function registerClaimer(address _claimerAddress, bool _enabled) override external onlyClaimContract { 
        // The name of the claiming contract
        string memory contractName = getContractName(msg.sender);
        // Record the time they are registering at
        uint256 registeredTime = 0;
        // How many users are to be included in next interval
        uint256 claimersIntervalTotalUpdate = getClaimingContractUserTotalNext(contractName);
        // Ok register
        if(_enabled) { 
            // Make sure they are not already registered
            require(getClaimingContractUserRegisteredTime(contractName, _claimerAddress) == 0, "Claimer is already registered");
            // Update time
            registeredTime = block.timestamp;
            // Update the total registered claimers for next interval
            setUint(keccak256(abi.encodePacked("rewards.pool.claim.interval.claimers.total.next", contractName)), claimersIntervalTotalUpdate.add(1));
        }else{
            // Make sure they are already registered
            require(getClaimingContractUserRegisteredTime(contractName, _claimerAddress) != 0, "Claimer is not registered");
            // Update the total registered claimers for next interval
            setUint(keccak256(abi.encodePacked("rewards.pool.claim.interval.claimers.total.next", contractName)), claimersIntervalTotalUpdate.sub(1));
        }
        // Save the registered time
        setUint(keccak256(abi.encodePacked("rewards.pool.claim.contract.registered.time", contractName, _claimerAddress)), registeredTime);
    }


    // A claiming contract claiming for a user and the percentage of the rewards they are allowed to receive
    function claim(address _claimerAddress, address _toAddress, uint256 _claimerAmountPerc) override external onlyEnabledClaimContract {
        // The name of the claiming contract
        string memory contractName = getContractName(msg.sender);
        // Check to see if this registered claimer has waited one interval before collecting
        uint256 claimIntervalTime = getClaimIntervalTime();
        require(_getClaimingContractUserCanClaim(contractName, _claimerAddress, claimIntervalTime), "Registered claimer is not registered to claim or has not waited one claim interval");
        // RPL contract address
        address rplContractAddress = getContractAddress("rocketTokenRPL");
        // RPL contract instance
        RocketTokenRPLInterface rplContract = RocketTokenRPLInterface(rplContractAddress);
        // Get the vault contract instance
        RocketVaultInterface rocketVault = RocketVaultInterface(getContractAddress("rocketVault"));
        // Get the start of the last claim interval as this may have just changed for a new interval beginning
        uint256 claimIntervalTimeStart = getClaimIntervalTimeStart();
        uint256 claimIntervalTimeStartComputed = _getClaimIntervalTimeStartComputed(claimIntervalTimeStart, claimIntervalTime);
        uint256 claimIntervalsPassed = _getClaimIntervalsPassed(claimIntervalTimeStart, claimIntervalTime);
        // Is this the first claim of this interval? If so, set the rewards total for this interval
        if (claimIntervalsPassed > 0) {
            // Mint any new tokens from the RPL inflation
            rplContract.inflationMintTokens();
            // Get how many tokens are in the reward pool to be available for this claim period
            setUint(keccak256("rewards.pool.claim.interval.total"), rocketVault.balanceOfToken("rocketRewardsPool", rplContract));
            // Set this as the start of the new claim interval
            setUint(keccak256("rewards.pool.claim.interval.time.start"), claimIntervalTimeStartComputed);
            // Soon as we mint new tokens, send the DAO's share to it's claiming contract, then attempt to transfer them to the dao if possible
            uint256 daoClaimContractAllowance = getClaimingContractAllowance("rocketClaimDAO");
            // Are we sending any?
            if (daoClaimContractAllowance > 0) {
                // Get the DAO claim contract address
                address daoClaimContractAddress = getContractAddress("rocketClaimDAO");
                // Transfers the DAO's tokens to it's claiming contract from the rewards pool
                rocketVault.transferToken("rocketClaimDAO", rplContract, daoClaimContractAllowance);
                // Set the current claim percentage this contract is entitled to for this interval
                setUint(keccak256(abi.encodePacked("rewards.pool.claim.interval.contract.perc.current", "rocketClaimDAO")), getClaimingContractPerc("rocketClaimDAO"));
                // Store the total RPL rewards claim for this claiming contract in this interval
                setUint(keccak256(abi.encodePacked("rewards.pool.claim.interval.contract.total", claimIntervalTimeStartComputed, "rocketClaimDAO")), _getClaimingContractTotalClaimed("rocketClaimDAO", claimIntervalTimeStartComputed).add(daoClaimContractAllowance));
                // Log it
                emit RPLTokensClaimed(daoClaimContractAddress, daoClaimContractAddress, daoClaimContractAllowance, block.timestamp);
            }
        }
        // Has anyone claimed from this contract so far in this interval? If not then set the interval settings for the contract
        if (_getClaimingContractTotalClaimed(contractName, claimIntervalTimeStartComputed) == 0) {
            // Get the amount allocated to this claim contract
            uint256 claimContractAllowance = getClaimingContractAllowance(contractName);
            // Make sure this is ok
            require(claimContractAllowance > 0, "Claiming contract must have an allowance of more than 0");
            // Set the current claim percentage this contract is entitled too for this interval
            setUint(keccak256(abi.encodePacked("rewards.pool.claim.interval.contract.perc.current", contractName)), getClaimingContractPerc(contractName));
            // Set the current claim allowance amount for this contract for this claim interval (if the claim amount is changed, it will kick in on the next interval)
            setUint(keccak256(abi.encodePacked("rewards.pool.claim.interval.contract.allowance", contractName)), claimContractAllowance);
            // Set the current amount of claimers for this interval
            setUint(keccak256(abi.encodePacked("rewards.pool.claim.interval.claimers.total.current", contractName)), getClaimingContractUserTotalNext(contractName));
        }
        // Check if they have a valid claim amount
        uint256 claimingContractTotalClaimed = _getClaimingContractTotalClaimed(contractName, claimIntervalTimeStartComputed);
        uint256 claimAmount = _getClaimAmount(contractName, _claimerAddress, _claimerAmountPerc, claimIntervalTimeStartComputed, claimingContractTotalClaimed);
        // First initial checks
        require(claimAmount > 0, "Claimer is not entitled to tokens, they have already claimed in this interval or they are claiming more rewards than available to this claiming contract.");
        // Send tokens now
        rocketVault.withdrawToken(_toAddress, rplContract, claimAmount);
        // Store the claiming record for this interval and claiming contract
        setBool(keccak256(abi.encodePacked("rewards.pool.claim.interval.claimer.address", claimIntervalTimeStartComputed, contractName, _claimerAddress)), true);
        // Store the total RPL rewards claim for this claiming contract in this interval
        setUint(keccak256(abi.encodePacked("rewards.pool.claim.interval.contract.total", claimIntervalTimeStartComputed, contractName)), claimingContractTotalClaimed.add(claimAmount));
        // Store the last time a claim was made
        setUint(keccak256("rewards.pool.claim.interval.time.last"), block.timestamp);
        // Log it
        emit RPLTokensClaimed(getContractAddress(contractName), _claimerAddress, claimAmount, block.timestamp);
    }

}

File 8 of 12 : RocketStorageInterface.sol
/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |    DECENTRALISED STAKING PROTOCOL FOR ETHEREUM    |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind Ethereum staking pool protocol, designed to
  *  be community-owned, decentralised, and trustless.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-only

interface RocketStorageInterface {

    // Deploy status
    function getDeployedStatus() external view returns (bool);

    // Guardian
    function getGuardian() external view returns(address);
    function setGuardian(address _newAddress) external;
    function confirmGuardian() external;

    // Getters
    function getAddress(bytes32 _key) external view returns (address);
    function getUint(bytes32 _key) external view returns (uint);
    function getString(bytes32 _key) external view returns (string memory);
    function getBytes(bytes32 _key) external view returns (bytes memory);
    function getBool(bytes32 _key) external view returns (bool);
    function getInt(bytes32 _key) external view returns (int);
    function getBytes32(bytes32 _key) external view returns (bytes32);

    // Setters
    function setAddress(bytes32 _key, address _value) external;
    function setUint(bytes32 _key, uint _value) external;
    function setString(bytes32 _key, string calldata _value) external;
    function setBytes(bytes32 _key, bytes calldata _value) external;
    function setBool(bytes32 _key, bool _value) external;
    function setInt(bytes32 _key, int _value) external;
    function setBytes32(bytes32 _key, bytes32 _value) external;

    // Deleters
    function deleteAddress(bytes32 _key) external;
    function deleteUint(bytes32 _key) external;
    function deleteString(bytes32 _key) external;
    function deleteBytes(bytes32 _key) external;
    function deleteBool(bytes32 _key) external;
    function deleteInt(bytes32 _key) external;
    function deleteBytes32(bytes32 _key) external;

    // Arithmetic
    function addUint(bytes32 _key, uint256 _amount) external;
    function subUint(bytes32 _key, uint256 _amount) external;

    // Protected storage
    function getNodeWithdrawalAddress(address _nodeAddress) external view returns (address);
    function getNodePendingWithdrawalAddress(address _nodeAddress) external view returns (address);
    function setWithdrawalAddress(address _nodeAddress, address _newWithdrawalAddress, bool _confirm) external;
    function confirmWithdrawalAddress(address _nodeAddress) external;
}

File 9 of 12 : RocketVaultInterface.sol
/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |    DECENTRALISED STAKING PROTOCOL FOR ETHEREUM    |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind Ethereum staking pool protocol, designed to
  *  be community-owned, decentralised, and trustless.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-only
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20Burnable.sol";

interface RocketVaultInterface {
    function balanceOf(string memory _networkContractName) external view returns (uint256);
    function depositEther() external payable;
    function withdrawEther(uint256 _amount) external;
    function depositToken(string memory _networkContractName, IERC20 _tokenAddress, uint256 _amount) external;
    function withdrawToken(address _withdrawalAddress, IERC20 _tokenAddress, uint256 _amount) external;
    function balanceOfToken(string memory _networkContractName, IERC20 _tokenAddress) external view returns (uint256);
    function transferToken(string memory _networkContractName, IERC20 _tokenAddress, uint256 _amount) external;
    function burnToken(ERC20Burnable _tokenAddress, uint256 _amount) external;
}

File 10 of 12 : RocketDAOProtocolSettingsRewardsInterface.sol
/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |    DECENTRALISED STAKING PROTOCOL FOR ETHEREUM    |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind Ethereum staking pool protocol, designed to
  *  be community-owned, decentralised, and trustless.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-only

interface RocketDAOProtocolSettingsRewardsInterface {
    function setSettingRewardsClaimer(string memory _contractName, uint256 _perc) external;
    function getRewardsClaimerPerc(string memory _contractName) external view returns (uint256);
    function getRewardsClaimerPercTimeUpdated(string memory _contractName) external view returns (uint256);
    function getRewardsClaimersPercTotal() external view returns (uint256);
    function getRewardsClaimIntervalTime() external view returns (uint256);
}

File 11 of 12 : RocketRewardsPoolInterface.sol
/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |    DECENTRALISED STAKING PROTOCOL FOR ETHEREUM    |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind Ethereum staking pool protocol, designed to
  *  be community-owned, decentralised, and trustless.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-only

interface RocketRewardsPoolInterface {
    function getRPLBalance() external view returns(uint256);
    function getClaimIntervalTimeStart() external view returns(uint256);
    function getClaimIntervalTimeStartComputed() external view returns(uint256);
    function getClaimIntervalsPassed() external view returns(uint256);
    function getClaimIntervalTime() external view returns(uint256);
    function getClaimTimeLastMade() external view returns(uint256);
    function getClaimIntervalRewardsTotal() external view returns(uint256);
    function getClaimingContractTotalClaimed(string memory _claimingContract) external view returns(uint256);
    function getClaimingContractUserTotalNext(string memory _claimingContract) external view returns(uint256);
    function getClaimingContractUserTotalCurrent(string memory _claimingContract) external view returns(uint256);  
    function getClaimingContractUserHasClaimed(uint256 _claimIntervalStartTime, string memory _claimingContract, address _claimerAddress) external view returns(bool);
    function getClaimingContractUserCanClaim(string memory _claimingContract, address _claimerAddress) external view returns(bool);
    function getClaimingContractUserRegisteredTime(string memory _claimingContract, address _claimerAddress) external view returns(uint256);
    function getClaimingContractAllowance(string memory _claimingContract) external view returns(uint256);
    function getClaimingContractPerc(string memory _claimingContract) external view returns(uint256);
    function getClaimingContractPercLast(string memory _claimingContract) external view returns(uint256);
    function getClaimingContractExists(string memory _contractName) external view returns (bool);
    function getClaimingContractEnabled(string memory _contractName) external view returns (bool);
    function getClaimAmount(string memory _claimingContract, address _claimerAddress, uint256 _claimerAmountPerc) external view returns (uint256);
    function registerClaimer(address _claimerAddress, bool _enabled) external;
    function claim(address _claimerAddress, address _toAddress, uint256 _claimerAmount) external;
}

File 12 of 12 : RocketTokenRPLInterface.sol
/**
  *       .
  *      / \
  *     |.'.|
  *     |'.'|
  *   ,'|   |`.
  *  |,-'-|-'-.|
  *   __|_| |         _        _      _____           _
  *  | ___ \|        | |      | |    | ___ \         | |
  *  | |_/ /|__   ___| | _____| |_   | |_/ /__   ___ | |
  *  |    // _ \ / __| |/ / _ \ __|  |  __/ _ \ / _ \| |
  *  | |\ \ (_) | (__|   <  __/ |_   | | | (_) | (_) | |
  *  \_| \_\___/ \___|_|\_\___|\__|  \_|  \___/ \___/|_|
  * +---------------------------------------------------+
  * |    DECENTRALISED STAKING PROTOCOL FOR ETHEREUM    |
  * +---------------------------------------------------+
  *
  *  Rocket Pool is a first-of-its-kind Ethereum staking pool protocol, designed to
  *  be community-owned, decentralised, and trustless.
  *
  *  For more information about Rocket Pool, visit https://rocketpool.net
  *
  *  Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
  *
  */

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-only

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

interface RocketTokenRPLInterface is IERC20 {
    function getInflationCalcTime() external view returns(uint256);
    function getInflationIntervalTime() external view returns(uint256);
    function getInflationIntervalRate() external view returns(uint256);
    function getInflationIntervalsPassed() external view returns(uint256);
    function getInflationIntervalStartTime() external view returns(uint256);
    function getInflationRewardsContractAddress() external view returns(address);
    function inflationCalculate() external view returns (uint256);
    function inflationMintTokens() external returns (uint256);
    function swapTokens(uint256 _amount) external;
}

Settings
{
  "remappings": [],
  "optimizer": {
    "enabled": true,
    "runs": 15000
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"contract RocketStorageInterface","name":"_rocketStorageAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"claimingContract","type":"address"},{"indexed":true,"internalType":"address","name":"claimingAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"RPLTokensClaimed","type":"event"},{"inputs":[{"internalType":"address","name":"_claimerAddress","type":"address"},{"internalType":"address","name":"_toAddress","type":"address"},{"internalType":"uint256","name":"_claimerAmountPerc","type":"uint256"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_claimingContract","type":"string"},{"internalType":"address","name":"_claimerAddress","type":"address"},{"internalType":"uint256","name":"_claimerAmountPerc","type":"uint256"}],"name":"getClaimAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getClaimIntervalRewardsTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getClaimIntervalTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getClaimIntervalTimeStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getClaimIntervalTimeStartComputed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getClaimIntervalsPassed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getClaimTimeLastMade","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_claimingContract","type":"string"}],"name":"getClaimingContractAllowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_contractName","type":"string"}],"name":"getClaimingContractEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_contractName","type":"string"}],"name":"getClaimingContractExists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_claimingContract","type":"string"}],"name":"getClaimingContractPerc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_claimingContract","type":"string"}],"name":"getClaimingContractPercLast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_claimingContract","type":"string"}],"name":"getClaimingContractTotalClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_claimingContract","type":"string"},{"internalType":"address","name":"_claimerAddress","type":"address"}],"name":"getClaimingContractUserCanClaim","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_claimIntervalStartTime","type":"uint256"},{"internalType":"string","name":"_claimingContract","type":"string"},{"internalType":"address","name":"_claimerAddress","type":"address"}],"name":"getClaimingContractUserHasClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_claimingContract","type":"string"},{"internalType":"address","name":"_claimerAddress","type":"address"}],"name":"getClaimingContractUserRegisteredTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_claimingContract","type":"string"}],"name":"getClaimingContractUserTotalCurrent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_claimingContract","type":"string"}],"name":"getClaimingContractUserTotalNext","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRPLBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_claimerAddress","type":"address"},{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"registerClaimer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000001d8f8f00cfa6758d7be78336684788fb0ee0fa46

-----Decoded View---------------
Arg [0] : _rocketStorageAddress (address): 0x1d8f8f00cfa6758d7bE78336684788Fb0ee0Fa46

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000001d8f8f00cfa6758d7be78336684788fb0ee0fa46


Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.

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