// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

//              .-'''-.                           
//             '   _    \         .---.           
//     .     /   /` '.   \        |   |           
//   .'|    .   |     \  '        |   |           
// .'  |    |   '      |  '       |   |            Coded by #nardo - Solidity 0.7.0
//<    |    \    \     / /  __    |   |    __           Koalas.Finance - Decentralized Finance
// |   | ____`.   ` ..' /.:--.'.  |   | .:--.'.   
// |   | \ .'   '-...-'`/ |   \ | |   |/ |   \ |  
// |   |/  .            `" __ | | |   |`" __ | |  
// |    /\  \            .'.''| | |   | .'.''| |  
// |   |  \  \          / /   | |_'---'/ /   | |_ SSSSSSSSSS
// '    \  \  \         \ \._,\ '/     \ \._,\ '/ 
//'------'  '---'        `--'  `"       `--'  `"  

import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/solc-0.7/contracts/token/ERC20/ERC20.sol";
import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/solc-0.7/contracts/token/ERC20/SafeERC20.sol";
import "https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/solc-0.7/contracts/math/SafeMath.sol";

contract Koala is ERC20 {

    using SafeERC20 for IERC20;
    using SafeMath for uint256;
    
    address private owner;
    address private KoalaAddress;
    address private KoalaAddressLP;
    
    IERC20 private KoalaToken;
    IERC20 private KoalaTokenLP;
    
    uint256 private varstakingRewards;
    uint256 private varstakingRewardsLP;
    uint256 private _totalKoalaStaked;
    uint256 private _totalKoalaStakedLP;
    uint256 private InitialSupply = 10000;
    uint256 private deflationaryBlockTimestamp;
    uint256 private deflationaryBlocks = 11520;
    uint256 private deflationaryMultiplier = 2;

    mapping(address => Staking) private _stakedBalances;
    mapping(address => Staking) private _stakedBalancesLP;

    struct Staking{
        uint256 lastBlockChecked;
        uint256 lastBlockCheckedLP;
        uint256 rewards;
        uint256 rewardsLP;
        uint256 koalastaked;
        uint256 koalastakedLP;
        uint256 stakedAtBlock;
        uint256 stakedAtBlockLP;
    }
    
    constructor() payable ERC20("Koalas.Finance", "KOALA") {
        owner = msg.sender;
        _mint(msg.sender, InitialSupply.mul(10 ** 18));
        varstakingRewards = 100000; varstakingRewardsLP = 100;
        deflationaryBlockTimestamp = block.number;
    }
    
    event Staked(address indexed user, uint256 amount, uint256 totalKoalaStaked);
    event StakedLP(address indexed user, uint256 amountLP, uint256 totalKoalaStakedLP);
    event Withdrawn(address indexed user, uint256 amount);
    event WithdrawnLP(address indexed user, uint256 amountLP);
    event Rewards(address indexed user, uint256 reward);
    event RewardsLP(address indexed user, uint256 rewardLP);
    
    modifier _onlyOwner() {require(msg.sender == owner);_;}

    modifier updateStakingReward(address account) {
        if(block.number > (deflationaryBlockTimestamp + deflationaryBlocks)){
            deflationaryBlockTimestamp = block.number;
            varstakingRewards = varstakingRewards * deflationaryMultiplier;
            varstakingRewardsLP = varstakingRewardsLP * deflationaryMultiplier;
        }
        if (block.number > _stakedBalances[account].lastBlockChecked) { uint256 rewardBlocks = block.number.sub(_stakedBalances[account].lastBlockChecked);
            if (_stakedBalances[account].koalastaked > 0) { _stakedBalances[account].rewards = _stakedBalances[account].rewards.add(_stakedBalances[account].koalastaked.mul(rewardBlocks)/varstakingRewards);}
            _stakedBalances[account].lastBlockChecked = block.number;
            emit Rewards(account, _stakedBalances[account].rewards);                                                     
        }_;
    }
    
    modifier updateStakingRewardLP(address account) {
        if (block.number > _stakedBalancesLP[account].lastBlockCheckedLP) { uint256 rewardBlocksLP = block.number.sub(_stakedBalancesLP[account].lastBlockCheckedLP);
            if (_stakedBalancesLP[account].koalastakedLP > 0) { _stakedBalancesLP[account].rewardsLP = _stakedBalancesLP[account].rewardsLP.add(_stakedBalancesLP[account].koalastakedLP.mul(rewardBlocksLP)/varstakingRewardsLP);}
            _stakedBalancesLP[account].lastBlockCheckedLP = block.number;
            emit RewardsLP(account, _stakedBalancesLP[account].rewardsLP);                                                     
        }_;
    }
    
    function setKoalaAddress(address _koalaaddress) public _onlyOwner returns(uint256) {KoalaAddress = _koalaaddress; KoalaToken = IERC20(_koalaaddress);}
    function setKoalaAddressLP(address _koalaaddressLP) public _onlyOwner returns(uint256) {KoalaAddressLP = _koalaaddressLP; KoalaTokenLP = IERC20(_koalaaddressLP);}
    function setRewardsVar(uint256 _amount) public _onlyOwner {varstakingRewards = _amount;}
    function setRewardsVarLP(uint256 _amount) public _onlyOwner {varstakingRewardsLP = _amount;}
    function setDeflationaryBlocks(uint256 _amount) public _onlyOwner {deflationaryBlocks = _amount;}
    function setDeflationaryMultiplier(uint256 _amount) public _onlyOwner {deflationaryMultiplier = _amount;}
    function getBlockNum() public view returns (uint256) {return block.number;}
    function getLastBlockCheckedNum(address _account) public view returns (uint256) {return _stakedBalances[_account].lastBlockChecked;}
    function getLastBlockCheckedNumLP(address _account) public view returns (uint256) {return _stakedBalancesLP[_account].lastBlockCheckedLP;}
    function getAddressStakeAmount(address _account) public view returns (uint256) {return _stakedBalances[_account].koalastaked;}
    function getAddressStakeAmountLP(address _account) public view returns (uint256) {return _stakedBalancesLP[_account].koalastakedLP;}
    function getStakedAtBlock(address _account) public view returns (uint256) {return _stakedBalances[_account].stakedAtBlock;}
    function getStakedAtBlockLP(address _account) public view returns (uint256) {return _stakedBalancesLP[_account].stakedAtBlockLP;}
    function getTotalStaked() public view returns (uint256) {return _totalKoalaStaked;}
    function getTotalStakedLP() public view returns (uint256) {return _totalKoalaStakedLP;}
    function getVarStakingReward() public view returns (uint256) {return varstakingRewards;}
    function getVarStakingRewardLP() public view returns (uint256) {return varstakingRewardsLP;}
    function getDeflationaryBlocks() public view returns (uint256) {return deflationaryBlocks;}
    function getDeflationaryCount() public view returns (uint256) {return deflationaryBlockTimestamp;}
    function getDeflationaryMultiplier() public view returns (uint256) {return deflationaryMultiplier;}

    function updatingStakingReward(address account) public returns(uint256) {
        if (block.number > _stakedBalances[account].lastBlockChecked) {uint256 rewardBlocks = block.number.sub(_stakedBalances[account].lastBlockChecked);
            if (_stakedBalances[account].koalastaked > 0) {_stakedBalances[account].rewards = _stakedBalances[account].rewards.add(_stakedBalances[account].koalastaked.mul(rewardBlocks)/ varstakingRewards);}
            _stakedBalances[account].lastBlockChecked = block.number;
            emit Rewards(account, _stakedBalances[account].rewards);} return(_stakedBalances[account].rewards);
    }
    
    function updatingStakingRewardLP(address account) public returns(uint256) {
        if (block.number > _stakedBalancesLP[account].lastBlockCheckedLP) {uint256 rewardBlocksLP = block.number.sub(_stakedBalancesLP[account].lastBlockCheckedLP);
            if (_stakedBalancesLP[account].koalastakedLP > 0) {_stakedBalancesLP[account].rewardsLP = _stakedBalancesLP[account].rewardsLP.add(_stakedBalancesLP[account].koalastakedLP.mul(rewardBlocksLP)/ varstakingRewardsLP);}
            _stakedBalancesLP[account].lastBlockCheckedLP = block.number;
            emit RewardsLP(account, _stakedBalancesLP[account].rewardsLP);} return(_stakedBalancesLP[account].rewardsLP);
    }

    function myRewardsBalance(address account) public view returns (uint256) {
        if (block.number > _stakedBalances[account].lastBlockChecked) {uint256 rewardBlocks = block.number.sub(_stakedBalances[account].lastBlockChecked);
            if (_stakedBalances[account].koalastaked > 0) {return _stakedBalances[account].rewards.add(_stakedBalances[account].koalastaked.mul(rewardBlocks)/ varstakingRewards);}}
    }
    
    function myRewardsBalanceLP(address account) public view returns (uint256) {
        if (block.number > _stakedBalancesLP[account].lastBlockCheckedLP) {uint256 rewardBlocksLP = block.number.sub(_stakedBalancesLP[account].lastBlockCheckedLP);
            if (_stakedBalancesLP[account].koalastakedLP > 0) {return _stakedBalancesLP[account].rewardsLP.add(_stakedBalancesLP[account].koalastakedLP.mul(rewardBlocksLP)/ varstakingRewardsLP);}}
    }
    
    function stake(uint256 amount) public updateStakingReward(msg.sender) {
        _totalKoalaStaked = _totalKoalaStaked.add(amount);
        _stakedBalances[msg.sender].koalastaked = _stakedBalances[msg.sender].koalastaked.add(amount);
        _stakedBalances[msg.sender].stakedAtBlock = block.number; 
        KoalaToken.safeTransferFrom(msg.sender, address(this), amount);
        emit Staked(msg.sender, amount, _totalKoalaStaked);
    }
    
    function stakeLP(uint256 amount) public updateStakingRewardLP(msg.sender) {
        _totalKoalaStakedLP = _totalKoalaStakedLP.add(amount);
        _stakedBalancesLP[msg.sender].koalastakedLP = _stakedBalancesLP[msg.sender].koalastakedLP.add(amount);
        _stakedBalancesLP[msg.sender].stakedAtBlockLP = block.number;
        KoalaTokenLP.safeTransferFrom(msg.sender, address(this), amount);
        emit StakedLP(msg.sender, amount, _totalKoalaStakedLP);
    }
    
    function withdraw(uint256 amount) public updateStakingReward(msg.sender) {
        _totalKoalaStaked = _totalKoalaStaked.sub(amount);
        _stakedBalances[msg.sender].koalastaked = _stakedBalances[msg.sender].koalastaked.sub(amount);
        KoalaToken.safeTransfer(msg.sender, amount);
        emit Withdrawn(msg.sender, amount);
    }
    
    function withdrawLP(uint256 amount) public updateStakingRewardLP(msg.sender) {
        _totalKoalaStakedLP = _totalKoalaStakedLP.sub(amount);
        _stakedBalancesLP[msg.sender].koalastakedLP = _stakedBalancesLP[msg.sender].koalastakedLP.sub(amount);
        KoalaTokenLP.safeTransfer(msg.sender, amount);
        emit WithdrawnLP(msg.sender, amount);
    }
    
    function getReward() public updateStakingReward(msg.sender) {
       uint256 reward = _stakedBalances[msg.sender].rewards;
       _stakedBalances[msg.sender].rewards = 0;
       _mint(msg.sender, reward);
       emit Rewards(msg.sender, reward);
   }
   
    function getRewardLP() public updateStakingRewardLP(msg.sender) {
       uint256 rewardLP = _stakedBalancesLP[msg.sender].rewardsLP;
       _stakedBalancesLP[msg.sender].rewardsLP = 0;
       _mint(msg.sender, rewardLP);
       emit RewardsLP(msg.sender, rewardLP);
   }
}

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