pragma solidity 0.7.1;
//  mainnet 0x2a1c5eafc10aa9fb4080d9841a117ecbcfa847f1
// kyber https://developer.kyber.network/docs/API_ABI-KyberNetworkProxy/
// balancer https://soliditydeveloper.com/balancer
import "https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/interfaces/IUniswapV2Router02.sol";

// example 0x906681829b1b89b4d5b4907dc64de5db1d367311
// https://kovan.etherscan.io/address/0x906681829b1b89b4d5b4907dc64de5db1d367311#writeContract
// getSwapFee
// getspotprice
// approve ->
// swapExactAmountIn tokenaddress tokenamountin tokenoutaddress minamountout maxprice
// getBalance tokenaddress

interface ERC20 {
    function approve(address _spender, uint _value)  external returns (bool success);
    function transfer(address to, uint tokens) external returns (bool success);
    function balanceOf(address tokenOwner) external  returns (uint balance);
    function deposit() external payable;
    function withdraw(uint) external;
    function allowance(address, address) external returns (uint);

}

interface IFreeFromUpTo {
 function freeFromUpTo(address from, uint256 value) external returns (uint256 freed);
    function balanceOf(address account) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    
}


contract BalancerUniSushi {
 
IFreeFromUpTo public constant chi = IFreeFromUpTo(0x0000000000004946c0e9F43F4Dee607b0eF1fA1c);
  address internal constant UNISWAP_ROUTER_ADDRESS = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D ;

  IUniswapV2Router02 uniswapRouter;

  address internal WETH_Address;

    
    address  internal  owner1 = 0x8cb8E8508c686105bf34B0bAFC5E7Eb4BE40860B;
    address  internal  owner2 = 0x60e2CB9C426500058b936981c547C3640C8A4752;
    address  internal  owner3 = 0x90d1aeA7d7D7A38d8bF445308651FD4aa132d6b3;
    address  internal  owner4 = 0x6211dB72f3A8d4B23856A32Caa523CbA3Fcc01dc;
    address  internal  owner5 = 0xaDb3aD87bDad5413B70dd725c0BFF86B8a89a2C2;

  modifier discountCHI {
        uint256 gasStart = gasleft();
        _;
        uint256 gasSpent = 21000 + gasStart - gasleft() + 16 *
                           msg.data.length;
        if(chi.balanceOf(address(this)) > 0) {
            chi.freeFromUpTo(address(this), (gasSpent + 14154) / 41947);
        }
        else {
            chi.freeFromUpTo(msg.sender, (gasSpent + 14154) / 41947);
        }
    }


constructor() { 
    uniswapRouter = IUniswapV2Router02(UNISWAP_ROUTER_ADDRESS);
    WETH_Address = uniswapRouter.WETH();
    require(chi.approve(address(this), uint256(-1)));
}

modifier onlyOwner() {
    if(owner1 == msg.sender || owner2 == msg.sender || owner3 == msg.sender || owner4 == msg.sender || owner5 == msg.sender) _;
}



  function withdrawETHAndTokens() public onlyOwner{
        ERC20 WETH = ERC20(WETH_Address);
        uint wethBalance = WETH.balanceOf(address(this));

    if (wethBalance > 0) {
        // refund leftover ETH
      WETH.transfer( msg.sender, WETH.balanceOf(address(this)));

    }

       // WETH.transfer( msg.sender, WETH.balanceOf(address(this)));
    msg.sender.send(address(this).balance);
    }

    function withdrawExactETH(uint Am) public onlyOwner discountCHI{
    msg.sender.send(Am);
    }

  

    function withdrawExactToken(address me) public onlyOwner discountCHI{
    ERC20 SendMe = ERC20(me);


    SendMe.transfer( msg.sender, SendMe.balanceOf(address(this)));
        //require(success, "ERR_ETH_FAILED");
    
       // WETH.transfer( msg.sender, WETH.balanceOf(address(this)));
    }

   function withdrawExactTokenWithAm(address me, uint Am) public onlyOwner discountCHI{

     ERC20 SendMe = ERC20(me);


     SendMe.transfer( msg.sender, Am);
        //require(success, "ERR_ETH_FAILED");
    
       // WETH.transfer( msg.sender, WETH.balanceOf(address(this)));
    }


    function convertUni(uint Amount,  uint MinAmountOut, address buyTokenAddress) public onlyOwner discountCHI{
  

        
        

    uint deadline = block.timestamp + 15; // using 'now' for convenience, for mainnet pass deadline from frontend!
    ERC20 TokenToBuy = ERC20(buyTokenAddress);
    address [] memory addresses0 = new address[](2); // A -> B
    addresses0[0] = WETH_Address;
    addresses0[1] = buyTokenAddress;
    uint256 [] memory amounts = getPriceFromOracleActual(addresses0, Amount );
    uint256 resultingTokens = amounts[1];
    require(resultingTokens > MinAmountOut, "Brah");


    uniswapRouter.swapExactETHForTokens{ value: Amount }(resultingTokens-1, getPathForTwoTokens(WETH_Address, buyTokenAddress ), address(this), deadline);
    }


    function convertBackUni(uint Amount,  uint MinAmountOut, address sellTokenAddress) public onlyOwner discountCHI{

        
    ERC20 TokenToSell = ERC20(sellTokenAddress);

    address [] memory addresses0 = new address[](2); // A -> B
    addresses0[0] = sellTokenAddress;
    addresses0[1] = WETH_Address;

    uint256 [] memory amounts = getPriceFromOracleActual(addresses0, Amount );
    uint256 resultingTokens = amounts[1];
    require(resultingTokens > MinAmountOut, "Brah2");


    
    uint deadline = block.timestamp + 15; // using 'now' for convenience, for mainnet pass deadline from frontend!

    TokenToSell.approve(address(uniswapRouter), type(uint).max);
    uniswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(Amount, 
      MinAmountOut, 
      getPathForTwoTokens(sellTokenAddress,WETH_Address),
      address(this), 
      deadline);
  }


    function convertBackUniAll(address sellTokenAddress) public onlyOwner discountCHI{



    ERC20 TokenToSell = ERC20(sellTokenAddress);
    uint MyBalance = TokenToSell.balanceOf(address(this));

    address [] memory addresses0 = new address[](2); // A -> B
    addresses0[0] = sellTokenAddress;
    addresses0[1] = WETH_Address;

    uint256 [] memory amounts = getPriceFromOracleActual(addresses0, MyBalance );
    uint256 resultingTokens = amounts[1];


    
    uint deadline = block.timestamp + 15; // using 'now' for convenience, for mainnet pass deadline from frontend!

    TokenToSell.approve(address(uniswapRouter), type(uint).max);
    uniswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(MyBalance, 
      resultingTokens/5*4, 
      getPathForTwoTokens(sellTokenAddress,WETH_Address),
      address(this), 
      deadline);
  }

    function getPriceFromOracleActual(address  [] memory theAddresses, uint amount) public view returns (uint256[] memory amounts1){
        uint256 [] memory amounts = uniswapRouter.getAmountsOut(amount,theAddresses );
        return amounts;
    }
      

    // refund leftover ETH to user
 //   (bool success,) = msg.sender.call{ value: address(this).balance }("");
 //   require(success, "refund failed");
  
   
   // uint256 currentTokenBalance = WETH.balanceOf(address(this));
   // WETH.transfer(msg.sender, currentTokenBalance);
  
  
  
  

 // function getEstimatedETHforDAI(uint daiAmount) public view returns (uint[] memory) {
 //   return uniswapRouter.getAmountsIn(daiAmount, getPathForTokens(uniswapRouter.WETH(),uniswapRouter.WETH()));
 // }

  function getPathForTwoTokens(address add1, address add2) private view returns (address[] memory) {
    address[] memory path = new address[](2);
//    path[0] = uniswapRouter.WETH();
    path[0] = add1;
    path[1] = add2;
    return path;
  }
  

  // important to receive ETH
  receive() external payable {}
}

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