update universalERC20 code

contracts/SmartRoute/SmartSwap.sol

@@ -27,6 +27,12 @@ contract SmartSwap is Ownable {
     IDODOSellHelper public dodoSellHelper;
     address payable public _WETH_;
 
+
+    modifier judgeExpired(uint256 deadline) {
+        require(deadline >= block.timestamp, 'DODO SmartSwap: EXPIRED');
+        _;
+    }
+
     event OrderHistory(
         IERC20 indexed fromToken,
         IERC20 indexed toToken,
@@ -57,15 +63,16 @@ contract SmartSwap is Ownable {
         uint256 fromTokenAmount,
         uint256 minReturnAmount,
         address[] memory dodoPairs,
-        uint256[] memory directions
+        uint256[] memory directions,
-    ) public payable returns (uint256 returnAmount) {
+        uint256 deadline
-        require(minReturnAmount > 0, "Min return should be bigger then 0.");
+    ) public payable judgeExpired(deadline) returns (uint256 returnAmount) {
-        require(dodoPairs.length > 0, "pairs should exists.");
+        require(minReturnAmount > 0, "DODO SmartSwap: Min return should be bigger then 0.");
+        require(dodoPairs.length > 0, "DODO SmartSwap: pairs should exists.");
 
         if (fromToken != ETH_ADDRESS) {
-            smartApprove.claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
+            smartApprove.claimTokens(fromToken, msg.sender, address(this),fromTokenAmount);
         } else {
-            require(msg.value == fromTokenAmount, "ETH_AMOUNT_NOT_MATCH");
+            require(msg.value == fromTokenAmount, "DODO SmartSwap: ETH_AMOUNT_NOT_MATCH");
             IWETH(_WETH_).deposit{value: fromTokenAmount}();
         }
 
@@ -97,7 +104,7 @@ contract SmartSwap is Ownable {
 
         returnAmount = toToken.universalBalanceOf(address(this));
 
-        require(returnAmount >= minReturnAmount, "Return amount is not enough");
+        require(returnAmount >= minReturnAmount, "DODO SmartSwap: Return amount is not enough");
         toToken.universalTransfer(msg.sender, returnAmount);
         emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
     }
@@ -110,9 +117,11 @@ contract SmartSwap is Ownable {
         uint256 gasSwap,
         uint256 fromTokenAmount,
         uint256 minReturnAmount,
-        bytes memory callDataConcat
+        bytes memory callDataConcat,
-    ) public payable returns (uint256 returnAmount) {
+        uint256 deadline
-        require(minReturnAmount > 0, "Min return should be bigger then 0.");
+    ) public payable judgeExpired(deadline) returns (uint256 returnAmount) {
+        
+        require(minReturnAmount > 0, "DODO SmartSwap: Min return should be bigger then 0.");
 
         if (fromToken != ETH_ADDRESS) {
             smartApprove.claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
@@ -123,12 +132,12 @@ contract SmartSwap is Ownable {
             callDataConcat
         );
 
-        require(success, "Contract Swap execution Failed");
+        require(success, "DODO SmartSwap: Contract Swap execution Failed");
 
         fromToken.universalTransfer(msg.sender, fromToken.universalBalanceOf(address(this)));
         returnAmount = toToken.universalBalanceOf(address(this));
 
-        require(returnAmount >= minReturnAmount, "Return amount is not enough");
+        require(returnAmount >= minReturnAmount, "DODO SmartSwap: Return amount is not enough");
         toToken.universalTransfer(msg.sender, returnAmount);
         emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
         emit ExternalRecord(to, msg.sender);

contracts/lib/UniversalERC20.sol

@@ -18,48 +18,26 @@ library UniversalERC20 {
     IERC20 private constant ZERO_ADDRESS = IERC20(0x0000000000000000000000000000000000000000);
     IERC20 private constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
 
-    function universalTransfer(
+    function isETH(IERC20 token) internal pure returns (bool) {
-        IERC20 token,
+        return (token == ZERO_ADDRESS || token == ETH_ADDRESS);
-        address to,
-        uint256 amount
-    ) internal {
-        universalTransfer(token, to, amount, false);
     }
 
-    function universalTransfer(
-        IERC20 token,
-        address to,
-        uint256 amount,
-        bool mayFail
-    ) internal returns (bool) {
-        if (amount == 0) {
-            return true;
-        }
 
-        if (token == ZERO_ADDRESS || token == ETH_ADDRESS) {
+    function universalTransfer(IERC20 token, address payable to, uint256 amount) internal {
-            if (mayFail) {
+        if (amount > 0) {
-                return address(uint160(to)).send(amount);
+            if (isETH(token)) {
+                to.transfer(amount);
             } else {
-                address(uint160(to)).transfer(amount);
+                token.safeTransfer(to, amount);
-                return true;
             }
-        } else {
-            token.safeTransfer(to, amount);
-            return true;
         }
     }
 
-    function universalApprove(
+    function universalApprove(IERC20 token, address to, uint256 amount) internal {
-        IERC20 token,
+        require(!isETH(token), "ETH Don't need approve");
-        address to,
+        if (amount == 0) {
-        uint256 amount
+            token.safeApprove(to, 0);
-    ) internal {
+        } else {
-        if (token != ZERO_ADDRESS && token != ETH_ADDRESS) {
-            if (amount == 0) {
-                token.safeApprove(to, 0);
-                return;
-            }
-
             uint256 allowance = token.allowance(address(this), to);
             if (allowance < amount) {
                 if (allowance > 0) {
@@ -70,31 +48,8 @@ library UniversalERC20 {
         }
     }
 
-    function universalTransferFrom(
-        IERC20 token,
-        address from,
-        address to,
-        uint256 amount
-    ) internal {
-        if (amount == 0) {
-            return;
-        }
-
-        if (token == ZERO_ADDRESS || token == ETH_ADDRESS) {
-            require(from == msg.sender && msg.value >= amount, "msg.value is zero");
-            if (to != address(this)) {
-                address(uint160(to)).transfer(amount);
-            }
-            if (msg.value > amount) {
-                msg.sender.transfer(msg.value.sub(amount));
-            }
-        } else {
-            token.safeTransferFrom(from, to, amount);
-        }
-    }
-
     function universalBalanceOf(IERC20 token, address who) internal view returns (uint256) {
-        if (token == ZERO_ADDRESS || token == ETH_ADDRESS) {
+        if (isETH(token)) {
             return who.balance;
         } else {
             return token.balanceOf(who);

test/Route/Route.test.ts

@@ -105,11 +105,10 @@ async function calcRoute(ctx: DODOContext, fromTokenAmount: string, slippage: nu
     }
   }
 
-  let toAmount = new BigNumber(swapAmount).multipliedBy(1 - slippage).toFixed(0, BigNumber.ROUND_DOWN)
 
-  console.log("minAmount:", toAmount);
+  let toAmount = new BigNumber(swapAmount).multipliedBy(1 - slippage).toFixed(0, BigNumber.ROUND_DOWN)
-  // console.log("dodoPairs",dodoPairs);
+  console.log("minAmount:",toAmount);
-  // console.log("directions",directions);
+  let deadline = Math.floor(new Date().getTime()/1000 + 60 * 10);
 
   return ctx.SmartSwap.methods.dodoSwap(
     routes[0].address,
@@ -117,7 +116,8 @@ async function calcRoute(ctx: DODOContext, fromTokenAmount: string, slippage: nu
     fromTokenAmount,
     toAmount,
     dodoPairs,
-    directions
+    directions,
+    deadline
   )
 }
 

truffle-config.js

@@ -51,6 +51,25 @@ module.exports = {
       gas: 0xfffffffffff,
       gasPrice: 1,
     },
+    kovan: {
+      provider: function() {
+        return new HDWalletProvider(privKey, "https://kovan.infura.io/v3/" + infuraId);
+      },
+      gas: 8000000,
+      gasPrice: 1000000000,
+      network_id: 42,
+      skipDryRun: true
+    },
+    live: {
+      networkCheckTimeout: 100000,
+      provider: function() {
+        return new HDWalletProvider(privKey, "https://mainnet.infura.io/v3/" + infuraId);
+      },
+      gas: 4000000,
+      gasPrice: 22000000000,
+      network_id: 1,
+      skipDryRun: true
+    },
     coverage: {
       host: "127.0.0.1",
       port: 6545,