pragma solidity ^0.5.10;

contract ERC20Interface {
    function totalSupply() 
		public 
		view 
		returns (uint256);

    function balanceOf(address tokenOwner) 
		public 
		view 
		returns (uint256 balance);
    
	function allowance
		(address tokenOwner, address spender) 
		public 
		view 
		returns (uint256 remaining);

    function transfer(address to, uint256 tokens) 				public 
		returns (bool success);
    
	function approve(address spender, uint256 tokens) 		public 
		returns (bool success);

    function transferFrom 
		(address from, address to, uint256 tokens) 				public 
		returns (bool success);


    event Transfer(address indexed from, address indexed to, uint256 tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}

pragma solidity ^0.5.10;

contract Ownable {

  // Owner of the contract
  address payable public owner;
  address payable internal _newOwner;

    constructor() public {
        owner = msg.sender;
    }

  /**
  * @dev Event to show ownership has been transferred
  * @param previousOwner representing the address of the previous owner
  * @param newOwner representing the address of the new owner
  */
  event OwnershipTransferred(address previousOwner, address newOwner);


  /**
   * @dev Sets a new owner address
   */
  function setOwner(address payable newOwner) internal {
    _newOwner = newOwner;
  }

  /**
  * @dev Throws if called by any account other than the owner.
  */
  modifier onlyOwner() {
    require(msg.sender == owner, "Not Owner");
    _;
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address payable newOwner) public onlyOwner {
    require(newOwner != address(0), "Invalid Address");
    setOwner(newOwner);
  }

  //this flow is to prevent transferring ownership to wrong wallet by mistake
  function acceptOwnership() public returns (address){
      require(msg.sender == _newOwner,"Invalid new owner");
      emit OwnershipTransferred(owner, _newOwner);
      owner = _newOwner;
      _newOwner = address(0);
      return owner;
  }
}

pragma solidity ^0.5.10;

import "./SafeMath.sol";
import "./ERC20Interface.sol";
import "./Ownable.sol";


contract ReinvestMoondayFinance is Ownable {
	using SafeMath for uint256;
	
	ERC20Interface MoondayToken;
	
	address payable public moondayFinanceContract;
	
	event Reinvested(uint256 amount);
	
	constructor(address _MoondayToken) public {
        owner = msg.sender;
        MoondayToken = ERC20Interface(_MoondayToken);
        // MoondayToken = ERC20Interface(0x1ad606adde97c0c28bd6ac85554176bc55783c01);
    }

	function setMoondayContractAddress(address payable _moondayFinanceContract) public onlyOwner{ 
		moondayFinanceContract = _moondayFinanceContract;
	}
	
	function reinvest() public {
		require(moondayFinanceContract != address(0), "Invalid Moonday Capital Contract Address");
		require(MoondayToken.balanceOf(address(this)) > 0, "Invalid Token Balance to reinvest");
		uint256 amount = MoondayToken.balanceOf(address(this));
		MoondayToken.transfer(moondayFinanceContract, amount);
		emit Reinvested(amount);
	}
}

pragma solidity ^0.5.10;

library SafeMath {

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;

        return c;
    }

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

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;

        return c;
    }
}

{
  "compilationTarget": {
    "ReinvestMoondayFinance.sol": "ReinvestMoondayFinance"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}