pragma solidity ^0.5.6;
library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0 || b == 0) return 0;
        uint256 c = a * b;
        require(c / a == b);
        return c;
    }
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0);
        uint256 c = a / b;
        return c;
    }
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;
        return c;
    }
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);
        return c;
    }
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}
contract ReserveWallet {
    using SafeMath for uint256;
    event Donation(address indexed _from, address indexed _token, uint256 _amount);
    event Deposit(address indexed _user, address indexed _token, uint256 _amount);
    event Withdraw(address indexed _user, address indexed _token, uint256 _amount, uint256 _fee);
    event Sent(address indexed _userSender, address indexed _userReceiver, address indexed _token, uint256 _amount, uint256 _fee);
    event AdminChanged(address indexed _admin, address indexed _oldAdmin);
    event Recovered(address indexed _admin, address indexed _user, address indexed _token, uint256 _amount);
    event FeeUpdated(address indexed _admin, uint256 _currentFee, uint256 _oldFee);
    mapping(address => mapping(address => uint256)) balances;
    mapping(address => uint256) covered;
    address public admin;
    address public feeAddress;
    uint256 public fixedFee;
    constructor (address _admin, address _feeAddress, uint256 _fee) public {
        if (_admin == address(0)) _admin = msg.sender;
        if (_feeAddress == address(0)) _feeAddress = _admin;
        if (_fee > 75e7 || _fee < 125) _fee = 125e6;
        fixedFee = _fee;
        feeAddress = _feeAddress;
        admin = _admin;
        emit AdminChanged(_admin, address(0));
    }
    modifier onlyAdmin() {
        require(msg.sender == admin);
        _;
    }
    modifier onlyUsers() {
        require(msg.sender != feeAddress);
        _;
    }
    function deposit() public payable onlyUsers {
        require(msg.value > 0);
        balances[msg.sender][address(0)] = balances[msg.sender][address(0)].add(msg.value);
        covered[address(0)] = covered[address(0)].add(msg.value);
        emit Deposit(msg.sender, address(0), msg.value);
    }
    function depositERC20(address _token, uint256 _value) public onlyUsers {
        require(_value > 0);
        ERC20(_token).transferFrom(msg.sender, address(this), _value);
        balances[msg.sender][_token] = balances[msg.sender][_token].add(_value);
        covered[_token] = covered[_token].add(_value);
        emit Deposit(msg.sender, _token, _value);
    }
    function send(address _token, address _recipient, uint256 _value) public onlyUsers {
        require(_recipient != address(0));
        require(_value >= 1e9);
        (uint256 amount, uint256 fee) = exactValue(msg.sender, _recipient, _value);
        if (_recipient == address(this)) _recipient = admin;
        balances[msg.sender][_token] = balances[msg.sender][_token].sub(_value);
        balances[_recipient][_token] = balances[_recipient][_token].add(amount);
        if (fee > 0) balances[feeAddress][_token] = balances[feeAddress][_token].add(fee);
        emit Sent(msg.sender, _recipient, _token, amount, fee);
    }
    function withdraw(address _token, uint256 _value) public onlyUsers {
        require(_value >= 1e9);
        (uint256 _amount, uint256 _fee) = exactValue(msg.sender, msg.sender, _value);
        balances[msg.sender][_token] = balances[msg.sender][_token].sub(_value);
        if (_fee > 0) balances[feeAddress][_token] = balances[feeAddress][_token].add(_fee);
        covered[_token] = covered[_token].sub(_amount);
        if (_token == address(0)) _transfer(msg.sender, _amount);
        else ERC20(_token).transfer(msg.sender, _amount);
        emit Withdraw(msg.sender, _token, _amount, _fee);
    }
    function donation() public payable {
        require(msg.value > 0);
        balances[admin][address(0)] = balances[admin][address(0)].add(msg.value);
        covered[address(0)] = covered[address(0)].add(msg.value);
        emit Donation(msg.sender, address(0), msg.value);
    }
    function () external payable {
        if (msg.value > 0) donation();
    }
    function setFee(uint256 _fee) public onlyAdmin {
        require(_fee >= 125 && _fee <= 75e7);
        uint256 b = _fee;
        fixedFee = _fee;
        emit FeeUpdated(msg.sender, _fee, b);
    }
    function recovery(address _token, address _user, uint256 _value) public onlyAdmin {
        uint256 _uncovered = _getUncovered(_token);
        require(_user != address(0) && address(this) != _user);
        require(_value > 0);
        _uncovered = _uncovered.sub(_value);
        balances[_user][_token] = balances[_user][_token].add(_value);
        covered[_token] = covered[_token].add(_value);
        emit Recovered(msg.sender, _user, _token, _value);
    }
    function changeAdmin(address _account) public onlyAdmin {
        require(_account != address(0) && address(this) != _account);
        admin = _account;
        emit AdminChanged(_account, msg.sender);
    }
    function exactValue(address _account, address _dest, uint256 _value) public view returns(uint256 _exact, uint256 _fee) {
        if (_value >= 1e9) {
            _fee = fixedFee.mul(_value);
            _fee = _fee.div(1e9);
            _exact = _value.sub(_fee);
        } else {
            _exact = 0;
            _fee = _value;
        }
        if (_account == admin || _account == feeAddress || _dest == admin || feeAddress == _dest) {
            _exact = _value;
            _fee = 0;
        }
        return (_exact, _fee);
    }
    function _transfer(address _dest, uint256 _value) internal {
        uint i;
        assembly { i := extcodesize(_dest) }
        if (i == 0) {
            address(uint160(_dest)).transfer(_value);
        } else {
            (bool success,) = _dest.call.gas(250000).value(_value)("");
            require(success);
        }
    }
    function _getUncovered(address _token) internal view returns(uint256) {
        uint256 result;
        if (_token == address(0)) result = address(this).balance;
        else result = ERC20(_token).balanceOf(address(this));
        result = result.sub(covered[_token]);
        return result;
    }
}
contract ERC20 {
    function balanceOf(address _who) public view returns(uint256);
    function transfer(address _to, uint256 _value) public returns(bool);
    function transferFrom(address _from, address _to, uint256 _value) public returns(bool);
}