pragma solidity =0.6.6;

import './libraries/TransferHelper.sol';
import './libraries/SafeMath.sol';
import './interfaces/IERC20.sol';

contract EarningsPools {
    using SafeMath for uint;
    
    mapping(address=>mapping(address=>uint)) public userEarningsValue;
    mapping(address=>mapping(address=>uint)) public userTakeoutValue;
    
    address public owner;
    
    event e_dfbtc_earning_record(address indexed _user, address indexed tokenAddress, uint addValue, uint _createTime);
    event e_dfbtc_takeout_record(address indexed _user, address indexed tokenAddress, uint outValue, uint _createTime);
    
    uint private unlocked = 1;
    modifier lock() {
        require(unlocked == 1, 'dfbtc: LOCKED');
        unlocked = 0;
        _;
        unlocked = 1;
    }
    
    modifier onlyOnwer {
        require(owner == msg.sender, "dfbtc: The caller must be onwer!!!");
        _;
    }
    
    constructor() public {
        owner = msg.sender;
    }
    
    function setOwner(address newOwner) public onlyOnwer {
        owner = newOwner;
    }
    
    function addTokenToPools(address[] memory _userList, uint[] memory _valueList, address tokenAddress) public onlyOnwer lock {
        for(uint i=0; i<_userList.length; i++){
            userEarningsValue[_userList[i]][tokenAddress] = userEarningsValue[_userList[i]][tokenAddress].add(_valueList[i]);
            emit e_dfbtc_earning_record(_userList[i], tokenAddress, _valueList[i], now);
        }
    }
    
    function getEarnings(address tokenAddress, uint transferValue) public lock {
        require(userEarningsValue[msg.sender][tokenAddress] >= transferValue, "dfbtc: More than the number that can be collected!");
        require(IERC20(tokenAddress).balanceOf(address(this)) >= transferValue, "dfbtc: The pool of funds is insufficient!");

        userEarningsValue[msg.sender][tokenAddress] = userEarningsValue[msg.sender][tokenAddress].sub(transferValue);
        userTakeoutValue[msg.sender][tokenAddress] = userTakeoutValue[msg.sender][tokenAddress].add(transferValue);
        TransferHelper.safeTransfer(tokenAddress, msg.sender, transferValue);
        emit e_dfbtc_takeout_record(msg.sender, tokenAddress, transferValue, now);
    }
    
    function getBlockTime() public view returns(uint){
        return now;
    }
}

pragma solidity >=0.5.0;

interface IERC20 {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

pragma solidity =0.6.6;

// a library for performing overflow-safe math, courtesy of DappHub (https://github.com/dapphub/ds-math)

library SafeMath {
  function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
    if (_a == 0) {
      return 0;
    }

    c = _a * _b;
    require(c / _a == _b, "mul error!!");
    return c;
  }

  function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
    return _a / _b;
  }

  function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
    require(_b <= _a, "sub error!!");
    return _a - _b;
  }

  function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
    c = _a + _b;
    require(c >= _a, "add error!!");
    return c;
  }
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity >=0.6.6;

// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
  function safeApprove(
    address token,
    address to,
    uint256 value
  ) internal {
    // bytes4(keccak256(bytes('approve(address,uint256)')));
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
    require(
      success && (data.length == 0 || abi.decode(data, (bool))),
      'TransferHelper::safeApprove: approve failed'
    );
  }

  function safeTransfer(
    address token,
    address to,
    uint256 value
  ) internal {
    // bytes4(keccak256(bytes('transfer(address,uint256)')));
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
    require(
      success && (data.length == 0 || abi.decode(data, (bool))),
      'TransferHelper::safeTransfer: transfer failed'
    );
  }

  function safeTransferFrom(
    address token,
    address from,
    address to,
    uint256 value
  ) internal {
    // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
    require(
      success && (data.length == 0 || abi.decode(data, (bool))),
      'TransferHelper::transferFrom: transferFrom failed'
    );
  }
}

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