// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

/**
 * @title Owner
 * @dev Set & change owner
 */
contract Owner {

    address private owner;
    
    // event for EVM logging
    event OwnerSet(address indexed oldOwner, address indexed newOwner);
    
    // modifier to check if caller is owner
    modifier isOwner() {
        // If the first argument of 'require' evaluates to 'false', execution terminates and all
        // changes to the state and to Ether balances are reverted.
        // This used to consume all gas in old EVM versions, but not anymore.
        // It is often a good idea to use 'require' to check if functions are called correctly.
        // As a second argument, you can also provide an explanation about what went wrong.
        require(msg.sender == owner, "Caller is not owner");
        _;
    }
    
    /**
     * @dev Set contract deployer as owner
     */
    constructor() {
        owner = msg.sender; // 'msg.sender' is sender of current call, contract deployer for a constructor
        emit OwnerSet(address(0), owner);
    }

    /**
     * @dev Change owner
     * @param newOwner address of new owner
     */
    function changeOwner(address newOwner) public isOwner {
        emit OwnerSet(owner, newOwner);
        owner = newOwner;
    }

    /**
     * @dev Return owner address 
     * @return address of owner
     */
    function getOwner() external view returns (address) {
        return owner;
    }
}

// SPDX-License-Identifier: UNLICENSED

pragma solidity >=0.7.0 <0.8.9;

import "Owner.sol";

interface ISavingsManager { function collectAndDistributeInterest(address _mAsset) external; }
interface IContribute     { function claimInterest() external;
                            function invest(uint256 reserveAmount) external;
                            function sell(uint256 tokenAmount) external; }
interface IERC20          { function allowance(address owner, address spender) external view returns (uint256);
                            function balanceOf(address account) external view returns (uint256);
                            function approve(address spender, uint256 amount) external returns (bool);
                            function transfer(address recipient, uint256 amount) external returns (bool);
                            function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); }
interface ITRIB is IERC20 {}
interface ImUSD is IERC20 {}

contract Claimer is Owner {
    address payable owner = msg.sender;
    ITRIB           constant TRIB = ITRIB(0xe09216F1d343Dd39D6Aa732a08036fee48555Af0);
    ImUSD           constant mUSD = ImUSD(0xe2f2a5C287993345a840Db3B0845fbC70f5935a5);
    ISavingsManager contract_SavingsManager = ISavingsManager(0xBC3B550E0349D74bF5148D86114A48C3B4Aa856F);
    IContribute     constant contract_Contribute     = IContribute(0x0DdfE92234b9DCA2de799736bBBa1D2F25CFC3b8);
    address         constant _mAsset = 0xe2f2a5C287993345a840Db3B0845fbC70f5935a5;
    

    function changeSavingsManager(address _address) external isOwner {
        contract_SavingsManager = ISavingsManager(_address);
    }


    function approveTRIB() external isOwner {
        TRIB.approve(address(0x0DdfE92234b9DCA2de799736bBBa1D2F25CFC3b8), uint(-1));
    }


    function approvemUSD() external isOwner {
        mUSD.approve(address(0x0DdfE92234b9DCA2de799736bBBa1D2F25CFC3b8), uint(-1));
    }


    function withdrawETH(uint256 _amount) external isOwner {
        owner.transfer(_amount);
    }


    function withdrawERC20(IERC20 _token) external isOwner {
        _token.transfer(owner, _token.balanceOf(address(this)));
    }


    function withdrawERC20toAddress(IERC20 _token, address _address) external isOwner {
        _token.transfer(_address, _token.balanceOf(address(this)));
    }


    function buyTRIB() external isOwner {
        contract_Contribute.invest(mUSD.balanceOf(address(this)));
    }


    function sellTRIB(uint256 _amount) external isOwner {
        contract_Contribute.sell(_amount);
    }


    function trigMoney() public {
        contract_SavingsManager.collectAndDistributeInterest(_mAsset);
        contract_Contribute.claimInterest();
    }


    function getMoney() public {
        contract_Contribute.claimInterest();
    }


    function getMoney_check() external isOwner returns (uint256 tribBalanceA, uint256 tribBalanceB, uint256 musdBalanceA, uint256 musdBalanceB, uint256 gasSpent) {
        tribBalanceA = TRIB.balanceOf(address(this));
        musdBalanceA = mUSD.balanceOf(address(this));
        uint256 gasStart = gasleft();
        getMoney();
        gasSpent = gasStart - gasleft();
        tribBalanceB = TRIB.balanceOf(address(this));
        musdBalanceB = mUSD.balanceOf(address(this));
    }
    

    function trigMoney_check() external isOwner returns (uint256 tribBalanceA, uint256 tribBalanceB, uint256 musdBalanceA, uint256 musdBalanceB, uint256 gasSpent) {
        tribBalanceA = TRIB.balanceOf(address(this));
        musdBalanceA = mUSD.balanceOf(address(this));
        uint256 gasStart = gasleft();
        trigMoney();
        gasSpent = gasStart - gasleft();
        tribBalanceB = TRIB.balanceOf(address(this));
        musdBalanceB = mUSD.balanceOf(address(this));
    }


    receive() external payable {}
    
    // 1. zrobić approve dla TRIB (poprzez funkcję tutaj)
    // 2. działać
    // 3. zrobić approve dla mUSD
    // 4. kupować TRIB za mUSD
}

{
  "compilationTarget": {
    "getMoney.sol": "Claimer"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}