pragma solidity ^0.6.0;

    contract Ownable {
      address public owner;
      constructor () public {
        owner = msg.sender;
      }
      modifier onlyOwner() {
        require(msg.sender == owner, "You is not owner");
        _;
      }
      function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0));
        owner = newOwner;
      }
    }


    interface ROUTER{
        function swapExactTokensForTokens(
            uint amountIn,
            uint amountOutMin,
            address[] calldata path,
            address to,
            uint deadline
        ) external returns (uint[] memory amounts);
        function swapExactTokensForTokensSupportingFeeOnTransferTokens(
            uint amountIn,
            uint amountOutMin,
            address[] calldata path,
            address to,
            uint deadline
            ) external;
    }

    interface ERC20{
         function balanceOf(address account) external returns (uint256);
         function allowance(address owner, address spender) external returns (uint256);
         function approve(address spender, uint256 amount) external returns (bool);
         function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    }

contract AUtrader is Ownable {
  bool isBlocked = false;
  address internal constant UNDB_ADDRESS = 0xd03B6ae96CaE26b743A6207DceE7Cbe60a425c70;
  uint private licencePrice = 0;

  struct FeeAddress {
      address payable recipient;
      bool isExist;
  }
  mapping (address => FeeAddress) public addresses; // feeAddress=>recipient

  ERC20 private UNDB;

  constructor() public {
    UNDB = ERC20(UNDB_ADDRESS);
    attachAddress(msg.sender);
  }


 function exchange(address[] memory path, uint amountIn, uint minOutAmount, address routerAddress, bool isDeflToken) public payable returns(bool){
     FeeAddress storage recipientEL = addresses[msg.sender];
     require(recipientEL.isExist, "Not attached feeAddress");
     require(!isBlocked, "Contract is blocked");
     address recipient = recipientEL.recipient;
     uint deadline = now + 120;
     ERC20 token = ERC20(path[0]);
     require(UNDB.balanceOf(recipient) >= licencePrice, "insufficient balance UNDB");
     require(token.balanceOf(recipient) >= amountIn, "insufficient balance input token");
     require(token.allowance(recipient, address(this)) >= amountIn, "Not approved amountIn");
     TransferHelper.safeTransferFrom(path[0], recipient, address(this), amountIn);
     if(token.allowance(address(this), routerAddress) < amountIn){
         TransferHelper.safeApprove(path[0], routerAddress, amountIn * 100);
     }
     ROUTER router = ROUTER(routerAddress);
     if(!isDeflToken){
        router.swapExactTokensForTokens(amountIn, minOutAmount, path, recipient, deadline);
    } else {
        uint amountIn_ = token.balanceOf(address(this));
        router.swapExactTokensForTokensSupportingFeeOnTransferTokens(amountIn_, minOutAmount, path, recipient, deadline);
    }
 }

 function attachAddress(address payable feeAddress) public {
    addresses[feeAddress] = FeeAddress(msg.sender, true);
 }

 function licencePriceChange(uint newPrice) public onlyOwner{
     licencePrice = newPrice;
 }
 
 function toggleBlock() public onlyOwner {
     isBlocked = !isBlocked;
 }
 
 function blockStatus() public view onlyOwner returns (bool) {
     return isBlocked;
 }

}


// 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))),
            'TransferHelperUNDB::safeApprove: approve 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))),
            'TransferHelperUNDB::transferFrom: transferFrom failed'
        );
    }
}


// WETH (ropsten) USDC
// ["0xc778417e063141139fce010982780140aa0cd5ab", "0x0d9c8723b343a8368bebe0b5e89273ff8d712e3c"]

// RCORE
// 0x067a2c2f812e5ef28bd43fb2f1dd0e44cc5cce88
// https://ropsten.etherscan.io/tx/0x7ebdc08ddc9234aeb11371b957f9c17f2e999b1db4cbaf8079768cc8a013051b

// ["0x067A2C2F812E5eF28Bd43fB2F1dD0e44CC5cCE88", "0xc778417e063141139fce010982780140aa0cd5ab"]
// 1000000000000000000
// 1
// UNISWAP 0x7a250d5630b4cf539739df2c5dacb4c659f2488d
// SUSHISWAP 0xd9e1ce17f2641f24ae83637ab66a2cca9c378b9f

// main CORE WETH
// ["0x62359Ed7505Efc61FF1D56fEF82158CcaffA23D7", "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"]
// ["0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "0xdac17f958d2ee523a2206206994597c13d831ec7"]

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