Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-12-08
*/

pragma solidity 0.8.6;


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);
}

interface IRewardsDistributionRecipient {
    function notifyRewardAmount(uint256 reward) external;

    function getRewardToken() external view returns (IERC20);
}

contract ModuleKeys {
    // Governance
    // ===========
    // keccak256("Governance");
    bytes32 internal constant KEY_GOVERNANCE =
        0x9409903de1e6fd852dfc61c9dacb48196c48535b60e25abf92acc92dd689078d;
    //keccak256("Staking");
    bytes32 internal constant KEY_STAKING =
        0x1df41cd916959d1163dc8f0671a666ea8a3e434c13e40faef527133b5d167034;
    //keccak256("ProxyAdmin");
    bytes32 internal constant KEY_PROXY_ADMIN =
        0x96ed0203eb7e975a4cbcaa23951943fa35c5d8288117d50c12b3d48b0fab48d1;

    // mStable
    // =======
    // keccak256("OracleHub");
    bytes32 internal constant KEY_ORACLE_HUB =
        0x8ae3a082c61a7379e2280f3356a5131507d9829d222d853bfa7c9fe1200dd040;
    // keccak256("Manager");
    bytes32 internal constant KEY_MANAGER =
        0x6d439300980e333f0256d64be2c9f67e86f4493ce25f82498d6db7f4be3d9e6f;
    //keccak256("Recollateraliser");
    bytes32 internal constant KEY_RECOLLATERALISER =
        0x39e3ed1fc335ce346a8cbe3e64dd525cf22b37f1e2104a755e761c3c1eb4734f;
    //keccak256("MetaToken");
    bytes32 internal constant KEY_META_TOKEN =
        0xea7469b14936af748ee93c53b2fe510b9928edbdccac3963321efca7eb1a57a2;
    // keccak256("SavingsManager");
    bytes32 internal constant KEY_SAVINGS_MANAGER =
        0x12fe936c77a1e196473c4314f3bed8eeac1d757b319abb85bdda70df35511bf1;
    // keccak256("Liquidator");
    bytes32 internal constant KEY_LIQUIDATOR =
        0x1e9cb14d7560734a61fa5ff9273953e971ff3cd9283c03d8346e3264617933d4;
    // keccak256("InterestValidator");
    bytes32 internal constant KEY_INTEREST_VALIDATOR =
        0xc10a28f028c7f7282a03c90608e38a4a646e136e614e4b07d119280c5f7f839f;
    // keccak256("Keeper");
    bytes32 internal constant KEY_KEEPER =
        0x4f78afe9dfc9a0cb0441c27b9405070cd2a48b490636a7bdd09f355e33a5d7de;
}

interface INexus {
    function governor() external view returns (address);

    function getModule(bytes32 key) external view returns (address);

    function proposeModule(bytes32 _key, address _addr) external;

    function cancelProposedModule(bytes32 _key) external;

    function acceptProposedModule(bytes32 _key) external;

    function acceptProposedModules(bytes32[] calldata _keys) external;

    function requestLockModule(bytes32 _key) external;

    function cancelLockModule(bytes32 _key) external;

    function lockModule(bytes32 _key) external;
}

abstract contract ImmutableModule is ModuleKeys {
    INexus public immutable nexus;

    /**
     * @dev Initialization function for upgradable proxy contracts
     * @param _nexus Nexus contract address
     */
    constructor(address _nexus) {
        require(_nexus != address(0), "Nexus address is zero");
        nexus = INexus(_nexus);
    }

    /**
     * @dev Modifier to allow function calls only from the Governor.
     */
    modifier onlyGovernor() {
        _onlyGovernor();
        _;
    }

    function _onlyGovernor() internal view {
        require(msg.sender == _governor(), "Only governor can execute");
    }

    /**
     * @dev Modifier to allow function calls only from the Governor or the Keeper EOA.
     */
    modifier onlyKeeperOrGovernor() {
        _keeperOrGovernor();
        _;
    }

    function _keeperOrGovernor() internal view {
        require(msg.sender == _keeper() || msg.sender == _governor(), "Only keeper or governor");
    }

    /**
     * @dev Modifier to allow function calls only from the Governance.
     *      Governance is either Governor address or Governance address.
     */
    modifier onlyGovernance() {
        require(
            msg.sender == _governor() || msg.sender == _governance(),
            "Only governance can execute"
        );
        _;
    }

    /**
     * @dev Returns Governor address from the Nexus
     * @return Address of Governor Contract
     */
    function _governor() internal view returns (address) {
        return nexus.governor();
    }

    /**
     * @dev Returns Governance Module address from the Nexus
     * @return Address of the Governance (Phase 2)
     */
    function _governance() internal view returns (address) {
        return nexus.getModule(KEY_GOVERNANCE);
    }

    /**
     * @dev Return Keeper address from the Nexus.
     *      This account is used for operational transactions that
     *      don't need multiple signatures.
     * @return  Address of the Keeper externally owned account.
     */
    function _keeper() internal view returns (address) {
        return nexus.getModule(KEY_KEEPER);
    }

    /**
     * @dev Return SavingsManager Module address from the Nexus
     * @return Address of the SavingsManager Module contract
     */
    function _savingsManager() internal view returns (address) {
        return nexus.getModule(KEY_SAVINGS_MANAGER);
    }

    /**
     * @dev Return Recollateraliser Module address from the Nexus
     * @return  Address of the Recollateraliser Module contract (Phase 2)
     */
    function _recollateraliser() internal view returns (address) {
        return nexus.getModule(KEY_RECOLLATERALISER);
    }

    /**
     * @dev Return Liquidator Module address from the Nexus
     * @return  Address of the Liquidator Module contract
     */
    function _liquidator() internal view returns (address) {
        return nexus.getModule(KEY_LIQUIDATOR);
    }

    /**
     * @dev Return ProxyAdmin Module address from the Nexus
     * @return Address of the ProxyAdmin Module contract
     */
    function _proxyAdmin() internal view returns (address) {
        return nexus.getModule(KEY_PROXY_ADMIN);
    }
}

abstract contract InitializableRewardsDistributionRecipient is
    IRewardsDistributionRecipient,
    ImmutableModule
{
    // This address has the ability to distribute the rewards
    address public rewardsDistributor;

    constructor(address _nexus) ImmutableModule(_nexus) {}

    /** @dev Recipient is a module, governed by mStable governance */
    function _initialize(address _rewardsDistributor) internal virtual {
        rewardsDistributor = _rewardsDistributor;
    }

    /**
     * @dev Only the rewards distributor can notify about rewards
     */
    modifier onlyRewardsDistributor() {
        require(msg.sender == rewardsDistributor, "Caller is not reward distributor");
        _;
    }

    /**
     * @dev Change the rewardsDistributor - only called by mStable governor
     * @param _rewardsDistributor   Address of the new distributor
     */
    function setRewardsDistribution(address _rewardsDistributor) external onlyGovernor {
        rewardsDistributor = _rewardsDistributor;
    }
}

contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private initializing;

    /**
     * @dev Modifier to use in the initializer function of a contract.
     */
    modifier initializer() {
        require(
            initializing || isConstructor() || !initialized,
            "Contract instance has already been initialized"
        );

        bool isTopLevelCall = !initializing;
        if (isTopLevelCall) {
            initializing = true;
            initialized = true;
        }

        _;

        if (isTopLevelCall) {
            initializing = false;
        }
    }

    /// @dev Returns true if and only if the function is running in the constructor
    function isConstructor() private view returns (bool) {
        // extcodesize checks the size of the code stored in an address, and
        // address returns the current address. Since the code is still not
        // deployed when running a constructor, any checks on its code size will
        // yield zero, making it an effective way to detect if a contract is
        // under construction or not.
        address self = address(this);
        uint256 cs;
        assembly {
            cs := extcodesize(self)
        }
        return cs == 0;
    }

    // Reserved storage space to allow for layout changes in the future.
    uint256[50] private ______gap;
}

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

/*
 * @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 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) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: AGPL-3.0-or-later
/**
 * @title  BasicRewardsForwarder
 * @author mStable
 * @notice Transfers any received reward tokens to another contract or account.
 * @dev    VERSION: 1.0
 *         DATE:    2021-10-28
 */
contract BasicRewardsForwarder is
    IRewardsDistributionRecipient,
    Initializable,
    InitializableRewardsDistributionRecipient,
    Ownable
{
    using SafeERC20 for IERC20;

    /// @notice Token the rewards are distributed in. eg MTA
    IERC20 public immutable REWARDS_TOKEN;
    /// @notice Account that ultimately receives the reward tokens
    address public endRecipient;

    event RewardsReceived(uint256 amount);
    event RecipientChanged(address indexed newRecipient);

    /**
     * @param _nexus        mStable system Nexus address
     * @param _rewardsToken Token that is being distributed as a reward. eg MTA
     */
    constructor(address _nexus, address _rewardsToken)
        InitializableRewardsDistributionRecipient(_nexus)
    {
        require(_rewardsToken != address(0), "Rewards token is zero");
        REWARDS_TOKEN = IERC20(_rewardsToken);
    }

    /**
     * @dev Init fn
     * @param _emissionsController mStable Emissions Controller that distributes MTA rewards
     * @param _endRecipient        Account that ultimately receives the reward tokens
     */
    function initialize(address _emissionsController, address _endRecipient) external initializer {
        InitializableRewardsDistributionRecipient._initialize(_emissionsController);
        require(_endRecipient != address(0), "Recipient address is zero");

        endRecipient = _endRecipient;
    }

    /**
     * @notice Called by the Emissions Controller to trigger the processing of the weekly rewards.
     * @dev    The Emissions Controller has already transferred the MTA to this contract.
     * @param _rewards Units of reward tokens that were distributed to this contract
     */
    function notifyRewardAmount(uint256 _rewards)
        external
        override(IRewardsDistributionRecipient)
        onlyRewardsDistributor
    {
        REWARDS_TOKEN.safeTransfer(endRecipient, _rewards);

        emit RewardsReceived(_rewards);
    }

    /***************************************
                    SETTERS
    ****************************************/

    /**
     * @notice Change the endRecipient. Can only be called by mStable governor.
     * @param _endRecipient The account the reward tokens are sent to
     */
    function setEndRecipient(address _endRecipient) external onlyOwner {
        require(endRecipient != _endRecipient, "Same end recipient");
        endRecipient = _endRecipient;

        emit RecipientChanged(_endRecipient);
    }

    /***************************************
                    GETTERS
    ****************************************/

    /**
     * @dev Gets the RewardsToken
     */
    function getRewardToken()
        external
        view
        override(IRewardsDistributionRecipient)
        returns (IERC20)
    {
        return REWARDS_TOKEN;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_nexus","type":"address"},{"internalType":"address","name":"_rewardsToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newRecipient","type":"address"}],"name":"RecipientChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardsReceived","type":"event"},{"inputs":[],"name":"REWARDS_TOKEN","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"endRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_emissionsController","type":"address"},{"internalType":"address","name":"_endRecipient","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nexus","outputs":[{"internalType":"contract INexus","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewards","type":"uint256"}],"name":"notifyRewardAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardsDistributor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_endRecipient","type":"address"}],"name":"setEndRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardsDistributor","type":"address"}],"name":"setRewardsDistribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000afce80b19a8ce13dec0739a1aab7a028d6845eb3000000000000000000000000a3bed4e1c75d00fa6f4e5e6922db7261b5e9acd2

-----Decoded View---------------
Arg [0] : _nexus (address): 0xAFcE80b19A8cE13DEc0739a1aaB7A028d6845Eb3
Arg [1] : _rewardsToken (address): 0xa3BeD4E1c75D00fa6f4E5E6922DB7261B5E9AcD2

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000afce80b19a8ce13dec0739a1aab7a028d6845eb3
Arg [1] : 000000000000000000000000a3bed4e1c75d00fa6f4e5e6922db7261b5e9acd2

25137:2908:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9495:142;;;;;;:::i;:::-;;:::i;:::-;;26882:262;;;;;;:::i;:::-;;:::i;8788:33::-;;;;;-1:-1:-1;;;;;8788:33:0;;;;;;-1:-1:-1;;;;;1825:32:1;;;1807:51;;1795:2;1780:18;8788:33:0;;;;;;;26274:305;;;;;;:::i;:::-;;:::i;27865:177::-;28021:13;27865:177;;24259:94;;;:::i;25505:27::-;;;;;-1:-1:-1;;;;;25505:27:0;;;23608:87;23681:6;;-1:-1:-1;;;;;23681:6:0;23608:87;;5364:29;;;;;25393:37;;;;;27446:234;;;;;;:::i;:::-;;:::i;24508:192::-;;;;;;:::i;:::-;;:::i;9495:142::-;5798:15;:13;:15::i;:::-;9589:18:::1;:40:::0;;-1:-1:-1;;;;;;9589:40:0::1;-1:-1:-1::0;;;;;9589:40:0;;;::::1;::::0;;;::::1;::::0;;9495:142::o;26882:262::-;9249:18;;-1:-1:-1;;;;;9249:18:0;9235:10;:32;9227:77;;;;-1:-1:-1;;;9227:77:0;;3588:2:1;9227:77:0;;;3570:21:1;;;3607:18;;;3600:30;3666:34;3646:18;;;3639:62;3718:18;;9227:77:0;;;;;;;;;27070:12:::1;::::0;27043:50:::1;::::0;-1:-1:-1;;;;;27043:13:0::1;:26:::0;::::1;::::0;27070:12:::1;27084:8:::0;27043:26:::1;:50::i;:::-;27111:25;::::0;6900::1;;;27111::0::1;::::0;6888:2:1;6873:18;27111:25:0::1;;;;;;;26882:262:::0;:::o;26274:305::-;10067:12;;;;;;;;:31;;-1:-1:-1;10980:4:0;11047:17;11092:7;10083:15;10067:47;;;-1:-1:-1;10103:11:0;;;;10102:12;10067:47;10045:143;;;;-1:-1:-1;;;10045:143:0;;5425:2:1;10045:143:0;;;5407:21:1;5464:2;5444:18;;;5437:30;5503:34;5483:18;;;5476:62;-1:-1:-1;;;5554:18:1;;;5547:44;5608:19;;10045:143:0;5397:236:1;10045:143:0;10201:19;10224:12;;;;;;10223:13;10247:99;;;;10282:12;:19;;-1:-1:-1;;10316:18:0;;;;;10247:99;26379:75:::1;26433:20;26379:53;:75::i;:::-;-1:-1:-1::0;;;;;26473:27:0;::::1;26465:65;;;::::0;-1:-1:-1;;;26465:65:0;;4710:2:1;26465:65:0::1;::::0;::::1;4692:21:1::0;4749:2;4729:18;;;4722:30;4788:27;4768:18;;;4761:55;4833:18;;26465:65:0::1;4682:175:1::0;26465:65:0::1;26543:12;:28:::0;;-1:-1:-1;;;;;;26543:28:0::1;-1:-1:-1::0;;;;;26543:28:0;::::1;;::::0;;10372:67;;;;10422:5;10407:20;;-1:-1:-1;;10407:20:0;;;10372:67;10034:412;26274:305;;:::o;24259:94::-;23681:6;;-1:-1:-1;;;;;23681:6:0;23071:10;23828:23;23820:68;;;;-1:-1:-1;;;23820:68:0;;;;;;;:::i;:::-;24324:21:::1;24342:1;24324:9;:21::i;:::-;24259:94::o:0;27446:234::-;23681:6;;-1:-1:-1;;;;;23681:6:0;23071:10;23828:23;23820:68;;;;-1:-1:-1;;;23820:68:0;;;;;;;:::i;:::-;27532:12:::1;::::0;-1:-1:-1;;;;;27532:29:0;;::::1;:12:::0;::::1;:29;;27524:60;;;::::0;-1:-1:-1;;;27524:60:0;;6609:2:1;27524:60:0::1;::::0;::::1;6591:21:1::0;6648:2;6628:18;;;6621:30;-1:-1:-1;;;6667:18:1;;;6660:48;6725:18;;27524:60:0::1;6581:168:1::0;27524:60:0::1;27595:12;:28:::0;;-1:-1:-1;;;;;;27595:28:0::1;-1:-1:-1::0;;;;;27595:28:0;::::1;::::0;;::::1;::::0;;;27641:31:::1;::::0;::::1;::::0;-1:-1:-1;;27641:31:0::1;27446:234:::0;:::o;24508:192::-;23681:6;;-1:-1:-1;;;;;23681:6:0;23071:10;23828:23;23820:68;;;;-1:-1:-1;;;23820:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;24597:22:0;::::1;24589:73;;;::::0;-1:-1:-1;;;24589:73:0;;3181:2:1;24589:73:0::1;::::0;::::1;3163:21:1::0;3220:2;3200:18;;;3193:30;3259:34;3239:18;;;3232:62;-1:-1:-1;;;3310:18:1;;;3303:36;3356:19;;24589:73:0::1;3153:228:1::0;24589:73:0::1;24673:19;24683:8;24673:9;:19::i;:::-;24508:192:::0;:::o;5841:121::-;5913:11;:9;:11::i;:::-;-1:-1:-1;;;;;5899:25:0;:10;-1:-1:-1;;;;;5899:25:0;;5891:63;;;;-1:-1:-1;;;5891:63:0;;4356:2:1;5891:63:0;;;4338:21:1;4395:2;4375:18;;;4368:30;4434:27;4414:18;;;4407:55;4479:18;;5891:63:0;4328:175:1;19156:211:0;19300:58;;;-1:-1:-1;;;;;2061:32:1;;19300:58:0;;;2043:51:1;2110:18;;;;2103:34;;;19300:58:0;;;;;;;;;;2016:18:1;;;;19300:58:0;;;;;;;;-1:-1:-1;;;;;19300:58:0;-1:-1:-1;;;19300:58:0;;;19273:86;;19293:5;;19273:19;:86::i;24708:173::-;24783:6;;;-1:-1:-1;;;;;24800:17:0;;;-1:-1:-1;;;;;;24800:17:0;;;;;;;24833:40;;24783:6;;;24800:17;24783:6;;24833:40;;24764:16;;24833:40;24753:128;24708:173;:::o;6802:95::-;6846:7;6873:5;-1:-1:-1;;;;;6873:14:0;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6866:23;;6802:95;:::o;21729:716::-;22153:23;22179:69;22207:4;22179:69;;;;;;;;;;;;;;;;;22187:5;-1:-1:-1;;;;;22179:27:0;;;:69;;;;;:::i;:::-;22263:17;;22153:95;;-1:-1:-1;22263:21:0;22259:179;;22360:10;22349:30;;;;;;;;;;;;:::i;:::-;22341:85;;;;-1:-1:-1;;;22341:85:0;;6198:2:1;22341:85:0;;;6180:21:1;6237:2;6217:18;;;6210:30;6276:34;6256:18;;;6249:62;-1:-1:-1;;;6327:18:1;;;6320:40;6377:19;;22341:85:0;6170:232:1;14789:229:0;14926:12;14958:52;14980:6;14988:4;14994:1;14997:12;14958:21;:52::i;:::-;14951:59;;14789:229;;;;;;:::o;15909:511::-;16079:12;16137:5;16112:21;:30;;16104:81;;;;-1:-1:-1;;;16104:81:0;;3949:2:1;16104:81:0;;;3931:21:1;3988:2;3968:18;;;3961:30;4027:34;4007:18;;;4000:62;-1:-1:-1;;;4078:18:1;;;4071:36;4124:19;;16104:81:0;3921:228:1;16104:81:0;12306:20;;16196:60;;;;-1:-1:-1;;;16196:60:0;;5840:2:1;16196:60:0;;;5822:21:1;5879:2;5859:18;;;5852:30;5918:31;5898:18;;;5891:59;5967:18;;16196:60:0;5812:179:1;16196:60:0;16270:12;16284:23;16311:6;-1:-1:-1;;;;;16311:11:0;16330:5;16337:4;16311:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16269:73;;;;16360:52;16378:7;16387:10;16399:12;16360:17;:52::i;:::-;16353:59;15909:511;-1:-1:-1;;;;;;;15909:511:0:o;18378:712::-;18528:12;18557:7;18553:530;;;-1:-1:-1;18588:10:0;18581:17;;18553:530;18702:17;;:21;18698:374;;18900:10;18894:17;18961:15;18948:10;18944:2;18940:19;18933:44;18698:374;19043:12;19036:20;;-1:-1:-1;;;19036:20:0;;;;;;;;:::i;14:247:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:2;;;142:1;139;132:12;94:2;181:9;168:23;200:31;225:5;200:31;:::i;266:251::-;336:6;389:2;377:9;368:7;364:23;360:32;357:2;;;405:1;402;395:12;357:2;437:9;431:16;456:31;481:5;456:31;:::i;522:388::-;590:6;598;651:2;639:9;630:7;626:23;622:32;619:2;;;667:1;664;657:12;619:2;706:9;693:23;725:31;750:5;725:31;:::i;:::-;775:5;-1:-1:-1;832:2:1;817:18;;804:32;845:33;804:32;845:33;:::i;:::-;897:7;887:17;;;609:301;;;;;:::o;915:277::-;982:6;1035:2;1023:9;1014:7;1010:23;1006:32;1003:2;;;1051:1;1048;1041:12;1003:2;1083:9;1077:16;1136:5;1129:13;1122:21;1115:5;1112:32;1102:2;;1158:1;1155;1148:12;1197:180;1256:6;1309:2;1297:9;1288:7;1284:23;1280:32;1277:2;;;1325:1;1322;1315:12;1277:2;-1:-1:-1;1348:23:1;;1267:110;-1:-1:-1;1267:110:1:o;1382:274::-;1511:3;1549:6;1543:13;1565:53;1611:6;1606:3;1599:4;1591:6;1587:17;1565:53;:::i;:::-;1634:16;;;;;1519:137;-1:-1:-1;;1519:137:1:o;2591:383::-;2740:2;2729:9;2722:21;2703:4;2772:6;2766:13;2815:6;2810:2;2799:9;2795:18;2788:34;2831:66;2890:6;2885:2;2874:9;2870:18;2865:2;2857:6;2853:15;2831:66;:::i;:::-;2958:2;2937:15;-1:-1:-1;;2933:29:1;2918:45;;;;2965:2;2914:54;;2712:262;-1:-1:-1;;2712:262:1:o;4862:356::-;5064:2;5046:21;;;5083:18;;;5076:30;5142:34;5137:2;5122:18;;5115:62;5209:2;5194:18;;5036:182::o;6936:258::-;7008:1;7018:113;7032:6;7029:1;7026:13;7018:113;;;7108:11;;;7102:18;7089:11;;;7082:39;7054:2;7047:10;7018:113;;;7149:6;7146:1;7143:13;7140:2;;;7184:1;7175:6;7170:3;7166:16;7159:27;7140:2;;6989:205;;;:::o;7199:131::-;-1:-1:-1;;;;;7274:31:1;;7264:42;;7254:2;;7320:1;7317;7310:12

ipfs://5c686bdfddf0ceef8c48bf323312f67bde9bcaed03aee7f199369c292c5f6efc