github.com/cwntr/go-defi@v0.0.0-20210629134751-07f9ec2f7e66/contracts/handlers/sushiswap/HSushiswap.sol (about)

     1  pragma solidity ^0.5.0;
     2  
     3  
     4  import "../../Config.sol";
     5  import "../../lib/libCache.sol";
     6  import "../../Cache.sol";
     7  import "../../lib/libCache.sol";
     8  import "./IUniswapV2Pair.sol";
     9  import "./IUniswapV2Router02.sol";
    10  import "./libraries/UniswapV2Library.sol";
    11  import "../HandlerBase.sol";
    12  import "@openzeppelin/contracts/utils/Address.sol";
    13  import "@openzeppelin/contracts/math/SafeMath.sol";
    14  import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
    15  import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
    16  
    17  
    18  contract HSushiswap is HandlerBase {
    19      using SafeERC20 for IERC20;
    20  
    21      address constant SUSHISWAPV2_ROUTER = 0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F;
    22  
    23      function addLiquidityETH(
    24          uint256 value,
    25          address token,
    26          uint256 amountTokenDesired,
    27          uint256 amountTokenMin,
    28          uint256 amountETHMin
    29      )
    30          external
    31          payable
    32          returns (
    33              uint256 amountToken,
    34              uint256 amountETH,
    35              uint256 liquidity
    36          )
    37      {
    38          // Get uniswapV2 router
    39          IUniswapV2Router02 router = IUniswapV2Router02(SUSHISWAPV2_ROUTER);
    40  
    41          // Approve token
    42          IERC20(token).safeApprove(SUSHISWAPV2_ROUTER, amountTokenDesired);
    43  
    44          // Add liquidity ETH
    45          (amountToken, amountETH, liquidity) = router.addLiquidityETH.value(
    46              value
    47          )(
    48              token,
    49              amountTokenDesired,
    50              amountTokenMin,
    51              amountETHMin,
    52              address(this),
    53              now + 1
    54          );
    55  
    56          // Approve token 0
    57          IERC20(token).safeApprove(SUSHISWAPV2_ROUTER, 0);
    58  
    59          // Update involved token
    60          address pair = UniswapV2Library.pairFor(
    61              router.factory(),
    62              token,
    63              router.WETH()
    64          );
    65          _updateToken(pair);
    66      }
    67  
    68      function addLiquidity(
    69          address tokenA,
    70          address tokenB,
    71          uint256 amountADesired,
    72          uint256 amountBDesired,
    73          uint256 amountAMin,
    74          uint256 amountBMin
    75      )
    76          external
    77          payable
    78          returns (
    79              uint256 amountA,
    80              uint256 amountB,
    81              uint256 liquidity
    82          )
    83      {
    84          // Get uniswapV2 router
    85          IUniswapV2Router02 router = IUniswapV2Router02(SUSHISWAPV2_ROUTER);
    86  
    87          // Approve token
    88          IERC20(tokenA).safeApprove(SUSHISWAPV2_ROUTER, amountADesired);
    89          IERC20(tokenB).safeApprove(SUSHISWAPV2_ROUTER, amountBDesired);
    90  
    91          // Add liquidity
    92          (amountA, amountB, liquidity) = router.addLiquidity(
    93              tokenA,
    94              tokenB,
    95              amountADesired,
    96              amountBDesired,
    97              amountAMin,
    98              amountBMin,
    99              address(this),
   100              now + 1
   101          );
   102  
   103          // Approve token 0
   104          IERC20(tokenA).safeApprove(SUSHISWAPV2_ROUTER, 0);
   105          IERC20(tokenB).safeApprove(SUSHISWAPV2_ROUTER, 0);
   106  
   107          // Update involved token
   108          address pair = UniswapV2Library.pairFor(
   109              router.factory(),
   110              tokenA,
   111              tokenB
   112          );
   113          _updateToken(pair);
   114      }
   115  
   116      function removeLiquidityETH(
   117          address token,
   118          uint256 liquidity,
   119          uint256 amountTokenMin,
   120          uint256 amountETHMin
   121      ) external payable returns (uint256 amountToken, uint256 amountETH) {
   122          // Get uniswapV2 router
   123          IUniswapV2Router02 router = IUniswapV2Router02(SUSHISWAPV2_ROUTER);
   124          address pair = UniswapV2Library.pairFor(
   125              router.factory(),
   126              token,
   127              router.WETH()
   128          );
   129  
   130          // Approve token
   131          IERC20(pair).safeApprove(SUSHISWAPV2_ROUTER, liquidity);
   132  
   133          // Add liquidity ETH
   134          (amountToken, amountETH) = router.removeLiquidityETH(
   135              token,
   136              liquidity,
   137              amountTokenMin,
   138              amountETHMin,
   139              address(this),
   140              now + 1
   141          );
   142  
   143          // Approve token 0
   144          IERC20(pair).safeApprove(SUSHISWAPV2_ROUTER, 0);
   145  
   146          // Update involved token
   147          _updateToken(token);
   148      }
   149  
   150      function removeLiquidity(
   151          address tokenA,
   152          address tokenB,
   153          uint256 liquidity,
   154          uint256 amountAMin,
   155          uint256 amountBMin
   156      ) external payable returns (uint256 amountA, uint256 amountB) {
   157          // Get uniswapV2 router
   158          IUniswapV2Router02 router = IUniswapV2Router02(SUSHISWAPV2_ROUTER);
   159          address pair = UniswapV2Library.pairFor(
   160              router.factory(),
   161              tokenA,
   162              tokenB
   163          );
   164  
   165          // Approve token
   166          IERC20(pair).safeApprove(SUSHISWAPV2_ROUTER, liquidity);
   167  
   168          // Add liquidity ETH
   169          (amountA, amountB) = router.removeLiquidity(
   170              tokenA,
   171              tokenB,
   172              liquidity,
   173              amountAMin,
   174              amountBMin,
   175              address(this),
   176              now + 1
   177          );
   178  
   179          // Approve token 0
   180          IERC20(pair).safeApprove(SUSHISWAPV2_ROUTER, 0);
   181  
   182          // Update involved token
   183          _updateToken(tokenA);
   184          _updateToken(tokenB);
   185      }
   186  
   187      function swapExactETHForTokens(
   188          uint256 value,
   189          uint256 amountOutMin,
   190          address[] calldata path
   191      ) external payable returns (uint256[] memory amounts) {
   192          require(path.length >= 2, "invalid path");
   193          address tokenOut = path[path.length - 1];
   194  
   195          // Get uniswapV2 router
   196          IUniswapV2Router02 router = IUniswapV2Router02(SUSHISWAPV2_ROUTER);
   197  
   198          amounts = router.swapExactETHForTokens.value(value)(
   199              amountOutMin,
   200              path,
   201              address(this),
   202              now + 1
   203          );
   204  
   205          _updateToken(tokenOut);
   206      }
   207  
   208      function swapETHForExactTokens(
   209          uint256 value,
   210          uint256 amountOut,
   211          address[] calldata path
   212      ) external payable returns (uint256[] memory amounts) {
   213          require(path.length >= 2, "invalid path");
   214          address tokenOut = path[path.length - 1];
   215  
   216          // Get uniswapV2 router
   217          IUniswapV2Router02 router = IUniswapV2Router02(SUSHISWAPV2_ROUTER);
   218  
   219          amounts = router.swapETHForExactTokens.value(value)(
   220              amountOut,
   221              path,
   222              address(this),
   223              now + 1
   224          );
   225  
   226          _updateToken(tokenOut);
   227      }
   228  
   229      function swapExactTokensForETH(
   230          uint256 amountIn,
   231          uint256 amountOutMin,
   232          address[] calldata path
   233      ) external payable returns (uint256[] memory amounts) {
   234          require(path.length >= 2, "invalid path");
   235          address tokenIn = path[0];
   236  
   237          // Get uniswapV2 router
   238          IUniswapV2Router02 router = IUniswapV2Router02(SUSHISWAPV2_ROUTER);
   239  
   240          // Approve token
   241          IERC20(tokenIn).safeApprove(SUSHISWAPV2_ROUTER, amountIn);
   242  
   243          amounts = router.swapExactTokensForETH(
   244              amountIn,
   245              amountOutMin,
   246              path,
   247              address(this),
   248              now + 1
   249          );
   250  
   251          // Approve token 0
   252          IERC20(tokenIn).safeApprove(SUSHISWAPV2_ROUTER, 0);
   253      }
   254  
   255      function swapTokensForExactETH(
   256          uint256 amountOut,
   257          uint256 amountInMax,
   258          address[] calldata path
   259      ) external payable returns (uint256[] memory amounts) {
   260          require(path.length >= 2, "invalid path");
   261          address tokenIn = path[0];
   262  
   263          // Get uniswapV2 router
   264          IUniswapV2Router02 router = IUniswapV2Router02(SUSHISWAPV2_ROUTER);
   265  
   266          // Approve token
   267          IERC20(tokenIn).safeApprove(SUSHISWAPV2_ROUTER, amountInMax);
   268  
   269          amounts = router.swapTokensForExactETH(
   270              amountOut,
   271              amountInMax,
   272              path,
   273              address(this),
   274              now + 1
   275          );
   276  
   277          // Approve token 0
   278          IERC20(tokenIn).safeApprove(SUSHISWAPV2_ROUTER, 0);
   279      }
   280  
   281      function swapExactTokensForTokens(
   282          uint256 amountIn,
   283          uint256 amountOutMin,
   284          address[] calldata path
   285      ) external payable returns (uint256[] memory amounts) {
   286          require(path.length >= 2, "invalid path");
   287          address tokenIn = path[0];
   288          address tokenOut = path[path.length - 1];
   289  
   290          // Get uniswapV2 router
   291          IUniswapV2Router02 router = IUniswapV2Router02(SUSHISWAPV2_ROUTER);
   292  
   293          // Approve token
   294          IERC20(tokenIn).safeApprove(SUSHISWAPV2_ROUTER, amountIn);
   295  
   296          amounts = router.swapExactTokensForTokens(
   297              amountIn,
   298              amountOutMin,
   299              path,
   300              address(this),
   301              now + 1
   302          );
   303  
   304          // Approve token 0
   305          IERC20(tokenIn).safeApprove(SUSHISWAPV2_ROUTER, 0);
   306  
   307          _updateToken(tokenOut);
   308      }
   309  
   310      function swapTokensForExactTokens(
   311          uint256 amountOut,
   312          uint256 amountInMax,
   313          address[] calldata path
   314      ) external payable returns (uint256[] memory amounts) {
   315          require(path.length >= 2, "invalid path");
   316          address tokenIn = path[0];
   317          address tokenOut = path[path.length - 1];
   318  
   319          // Get uniswapV2 router
   320          IUniswapV2Router02 router = IUniswapV2Router02(SUSHISWAPV2_ROUTER);
   321  
   322          // Approve token
   323          IERC20(tokenIn).safeApprove(SUSHISWAPV2_ROUTER, amountInMax);
   324  
   325          amounts = router.swapTokensForExactTokens(
   326              amountOut,
   327              amountInMax,
   328              path,
   329              address(this),
   330              now + 1
   331          );
   332  
   333          // Approve token 0
   334          IERC20(tokenIn).safeApprove(SUSHISWAPV2_ROUTER, 0);
   335  
   336          _updateToken(tokenOut);
   337      }
   338  
   339  }