第二遍走查 snapshot4

contracts/SmartRoute/DODOApprove.sol

@@ -15,7 +15,12 @@ contract DODOApprove is Ownable {
     using SafeERC20 for IERC20;
     address public dodoProxy;
 
+    // ============ Events ============
+
+    event SetDODOProxy(address indexed oldProxy, address indexed newProxy);
+
     function setDODOProxy(address _dodoProxy) external onlyOwner {
+        emit SetDODOProxy(dodoProxy, _dodoProxy);
         dodoProxy = _dodoProxy;
     }
 

contracts/SmartRoute/DODOV1Proxy01.sol

@@ -11,7 +11,7 @@ import {IERC20} from "../intf/IERC20.sol";
 import {UniversalERC20} from "./lib/UniversalERC20.sol";
 import {SafeMath} from "../lib/SafeMath.sol";
 import {IDODOV1} from "./intf/IDODOV1.sol";
-import {IDODOSellHelper} from './helper/DODOSellHelper.sol';
+import {IDODOSellHelper} from "./helper/DODOSellHelper.sol";
 import {IWETH} from "../intf/IWETH.sol";
 import {IDODOApprove} from "../intf/IDODOApprove.sol";
 import {IDODOV1Proxy01} from "./intf/IDODOV1Proxy01.sol";
@@ -21,25 +21,30 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard {
     using SafeMath for uint256;
     using UniversalERC20 for IERC20;
 
+    // ============ Storage ============
+
     address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
     address public dodoApprove;
     address public dodoSellHelper;
     address payable public _WETH_;
 
-    modifier judgeExpired(uint256 deadline) {
+    // ============ Events ============
-        require(deadline >= block.timestamp, "DODOV1Proxy01: EXPIRED");
-        _;
-    }
 
     event OrderHistory(
         address indexed fromToken,
         address indexed toToken,
         address indexed sender,
         uint256 fromAmount,
-        uint256 returnAmount,
+        uint256 returnAmount
-        uint256 timeStamp
     );
 
+    // ============ Modifiers ============
+
+    modifier judgeExpired(uint256 deadline) {
+        require(deadline >= block.timestamp, "DODOV1Proxy01: EXPIRED");
+        _;
+    }
+
     constructor(
         address _dodoApprove,
         address _dodoSellHelper,
@@ -62,7 +67,7 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard {
         address[] memory dodoPairs,
         uint8[] memory directions,
         uint256 deadline
-    ) external virtual override payable preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
+    ) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) {
         if (fromToken != ETH_ADDRESS) {
             IDODOApprove(dodoApprove).claimTokens(
                 fromToken,
@@ -97,18 +102,10 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard {
         returnAmount = IERC20(toToken).universalBalanceOf(address(this));
         require(returnAmount >= minReturnAmount, "DODOV1Proxy01: Return amount is not enough");
 
-        if (toToken == ETH_ADDRESS) 
+        if (toToken == ETH_ADDRESS) IWETH(_WETH_).withdraw(returnAmount);
-            IWETH(_WETH_).withdraw(returnAmount);
         IERC20(toToken).universalTransfer(msg.sender, returnAmount);
-        
+
-        emit OrderHistory(
+        emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
-            fromToken,
-            toToken,
-            msg.sender,
-            fromTokenAmount,
-            returnAmount,
-            block.timestamp
-        );
     }
 
     function externalSwap(
@@ -120,7 +117,9 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard {
         uint256 minReturnAmount,
         bytes memory callDataConcat,
         uint256 deadline
-    ) external virtual override payable preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
+    ) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) {
+        uint256 toTokenOriginBalance = IERC20(toToken).universalBalanceOf(msg.sender);
+
         if (fromToken != ETH_ADDRESS) {
             IDODOApprove(dodoApprove).claimTokens(
                 fromToken,
@@ -140,17 +139,13 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard {
             IERC20(fromToken).universalBalanceOf(address(this))
         );
 
-        returnAmount = IERC20(toToken).universalBalanceOf(address(this));
+        IERC20(toToken).universalTransfer(
-        require(returnAmount >= minReturnAmount, "DODOV1Proxy01: Return amount is not enough");
-        IERC20(toToken).universalTransfer(msg.sender, returnAmount);
-
-        emit OrderHistory(
-            fromToken,
-            toToken,
             msg.sender,
-            fromTokenAmount,
+            IERC20(toToken).universalBalanceOf(address(this))
-            returnAmount,
-            block.timestamp
         );
+        returnAmount = IERC20(toToken).universalBalanceOf(msg.sender).sub(toTokenOriginBalance);
+        require(returnAmount >= minReturnAmount, "DODOV1Proxy01: Return amount is not enough");
+
+        emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
     }
 }

contracts/SmartRoute/DODOV2Proxy01.sol

@@ -10,8 +10,8 @@ pragma solidity 0.6.9;
 import {IDODOV2Proxy01} from "./intf/IDODOV2Proxy01.sol";
 import {IDODOV2} from "./intf/IDODOV2.sol";
 import {IDODOV1} from "./intf/IDODOV1.sol";
-import {IDODOApprove} from '../intf/IDODOApprove.sol';
+import {IDODOApprove} from "../intf/IDODOApprove.sol";
-import {IDODOSellHelper} from './helper/DODOSellHelper.sol';
+import {IDODOSellHelper} from "./helper/DODOSellHelper.sol";
 import {IERC20} from "../intf/IERC20.sol";
 import {IWETH} from "../intf/IWETH.sol";
 import {SafeMath} from "../lib/SafeMath.sol";
@@ -24,6 +24,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
     using SafeMath for uint256;
     using UniversalERC20 for IERC20;
 
+    // ============ Storage ============
+
     address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
     address payable public _WETH_;
     address public dodoApprove;
@@ -31,15 +33,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
     address public dvmFactory;
     address public dppFactory;
 
-    modifier judgeExpired(uint256 deadline) {
+    // ============ Events ============
-        require(deadline >= block.timestamp, "DODOV2Proxy01: EXPIRED");
-        _;
-    }
-
-    fallback() external payable {}
-
-    receive() external payable {}
-
 
     event OrderHistory(
         address indexed fromToken,
@@ -50,6 +44,17 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         uint256 timeStamp
     );
 
+    // ============ Modifiers ============
+
+    modifier judgeExpired(uint256 deadline) {
+        require(deadline >= block.timestamp, "DODOV2Proxy01: EXPIRED");
+        _;
+    }
+
+    fallback() external payable {}
+
+    receive() external payable {}
+
     constructor(
         address _dvmFactory,
         address _dppFactory,
@@ -64,6 +69,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         dodoSellHelper = _dodoSellHelper;
     }
 
+    // ============ DVM Functions (create & add liquidity) ============
+
     function createDODOVendingMachine(
         address assetTo,
         address baseToken,
@@ -120,33 +127,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         (shares, , ) = IDODOV2(newVendingMachine).buyShares(assetTo);
     }
 
-    function _addDVMLiquidity(
-        address DVMAddress,
-        uint256 baseInAmount,
-        uint256 quoteInAmount
-    ) internal virtual view returns (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) {
-        (uint256 baseReserve, uint256 quoteReserve) = IDODOV2(DVMAddress).getVaultReserve();
-        if (quoteReserve == 0 && baseReserve == 0) {
-            baseAdjustedInAmount = baseInAmount;
-            quoteAdjustedInAmount = quoteInAmount;
-        }
-        if (quoteReserve == 0 && baseReserve > 0) {
-            baseAdjustedInAmount = baseInAmount;
-            quoteAdjustedInAmount = 0;
-        }
-        if (quoteReserve > 0 && baseReserve > 0) {
-            uint256 baseIncreaseRatio = DecimalMath.divFloor(baseInAmount, baseReserve);
-            uint256 quoteIncreaseRatio = DecimalMath.divFloor(quoteInAmount, quoteReserve);
-            if (baseIncreaseRatio <= quoteIncreaseRatio) {
-                baseAdjustedInAmount = baseInAmount;
-                quoteAdjustedInAmount = DecimalMath.mulFloor(quoteReserve, baseIncreaseRatio);
-            } else {
-                quoteAdjustedInAmount = quoteInAmount;
-                baseAdjustedInAmount = DecimalMath.mulFloor(baseReserve, quoteIncreaseRatio);
-            }
-        }
-    }
-
     function addDVMLiquidity(
         address DVMAddress,
         address to,
@@ -176,7 +156,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         );
         require(
             baseAdjustedInAmount >= baseMinAmount && quoteAdjustedInAmount >= quoteMinAmount,
-            'DODOV2Proxy01: deposit amount is not enough'
+            "DODOV2Proxy01: deposit amount is not enough"
         );
         address _dvm = DVMAddress;
 
@@ -186,43 +166,34 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         (shares, , ) = IDODOV2(_dvm).buyShares(to);
     }
 
-    // ===================== Permit ======================
+    function _addDVMLiquidity(
-    function removeDVMLiquidity(
         address DVMAddress,
-        address payable to,
+        uint256 baseInAmount,
-        uint256 sharesAmount,
+        uint256 quoteInAmount
-        uint256 baseMinOutAmount,
+    ) internal virtual view returns (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) {
-        uint256 quoteMinOutAmount,
+        (uint256 baseReserve, uint256 quoteReserve) = IDODOV2(DVMAddress).getVaultReserve();
-        uint8 flag, // 0 -ERC20, 1 - baseOutETH, 2 - quoteOutETH
+        if (quoteReserve == 0 && baseReserve == 0) {
-        uint256 deadline
+            baseAdjustedInAmount = baseInAmount;
-    ) public virtual override preventReentrant judgeExpired(deadline) returns (uint256 baseOutAmount, uint256 quoteOutAmount) {
+            quoteAdjustedInAmount = quoteInAmount;
-        _deposit(msg.sender,DVMAddress,DVMAddress,sharesAmount,false);
+        }
-        if(flag == 0)
+        if (quoteReserve == 0 && baseReserve > 0) {
-            (baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(to);
+            baseAdjustedInAmount = baseInAmount;
-        else 
+            quoteAdjustedInAmount = 0;
-            (baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(address(this));
+        }
-        require(baseOutAmount >= baseMinOutAmount && quoteOutAmount >= quoteMinOutAmount, 'DODOV2Proxy01: Return Amount is not enough');
+        if (quoteReserve > 0 && baseReserve > 0) {
-        if(flag != 0){
+            uint256 baseIncreaseRatio = DecimalMath.divFloor(baseInAmount, baseReserve);
-           _withdraw(to, IDODOV2(DVMAddress)._BASE_TOKEN_(), baseOutAmount,flag == 1);
+            uint256 quoteIncreaseRatio = DecimalMath.divFloor(quoteInAmount, quoteReserve);
-           _withdraw(to, IDODOV2(DVMAddress)._QUOTE_TOKEN_(), quoteOutAmount, flag == 2); 
+            if (baseIncreaseRatio <= quoteIncreaseRatio) {
+                baseAdjustedInAmount = baseInAmount;
+                quoteAdjustedInAmount = DecimalMath.mulFloor(quoteReserve, baseIncreaseRatio);
+            } else {
+                quoteAdjustedInAmount = quoteInAmount;
+                baseAdjustedInAmount = DecimalMath.mulFloor(baseReserve, quoteIncreaseRatio);
+            }
         }
     }
 
-    function removeDVMLiquidityWithPermit(
+    // ============ DPP Functions (create & reset) ============
-        address DVMAddress,
-        address payable to,
-        uint256 sharesAmount,
-        uint256 baseMinOutAmount,
-        uint256 quoteMinOutAmount,
-        uint8 flag, // 0 -ERC20, 1 - baseOutETH, 2 - quoteOutETH
-        uint256 deadline,
-        bool approveMax, uint8 v, bytes32 r, bytes32 s
-    ) external virtual override preventReentrant returns (uint256 baseOutAmount, uint256 quoteOutAmount) {
-        uint256 value = approveMax ? uint256(-1) : sharesAmount;
-        IDODOV2(DVMAddress).permit(msg.sender, dodoApprove, value, deadline, v, r, s);
-        (baseOutAmount,quoteOutAmount) = removeDVMLiquidity(DVMAddress,to,sharesAmount,baseMinOutAmount,quoteMinOutAmount,flag,deadline);
-    }
-    // ============================================
 
     function createDODOPrivatePool(
         address baseToken,
@@ -234,7 +205,15 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         uint256 i,
         uint256 k,
         uint256 deadline
-    ) external virtual override payable preventReentrant judgeExpired(deadline) returns (address newPrivatePool) {
+    )
+        external
+        virtual
+        override
+        payable
+        preventReentrant
+        judgeExpired(deadline)
+        returns (address newPrivatePool)
+    {
         newPrivatePool = IDODOV2(dppFactory).createDODOPrivatePool();
 
         address _baseToken = baseToken;
@@ -305,6 +284,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         _withdraw(msg.sender, IDODOV2(DPPAddress)._QUOTE_TOKEN_(), quoteOutAmount, flag == 4);
     }
 
+    // ============ Swap ============
+
     function dodoSwapETHToToken(
         address payable assetTo,
         address toToken,
@@ -313,7 +294,15 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         address[] memory dodoPairs,
         uint8[] memory directions,
         uint256 deadline
-    ) external virtual override payable preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
+    )
+        external
+        virtual
+        override
+        payable
+        preventReentrant
+        judgeExpired(deadline)
+        returns (uint256 returnAmount)
+    {
         uint256 originToTokenBalance = IERC20(toToken).balanceOf(msg.sender);
 
         require(msg.value == fromTokenAmount, "DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH");
@@ -356,7 +345,14 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         address[] memory dodoPairs,
         uint8[] memory directions,
         uint256 deadline
-    ) external virtual override preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
+    )
+        external
+        virtual
+        override
+        preventReentrant
+        judgeExpired(deadline)
+        returns (uint256 returnAmount)
+    {
         IDODOApprove(dodoApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
 
         for (uint256 i = 0; i < dodoPairs.length; i++) {
@@ -397,7 +393,14 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         address[] memory dodoPairs,
         uint8[] memory directions,
         uint256 deadline
-    ) external virtual override preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
+    )
+        external
+        virtual
+        override
+        preventReentrant
+        judgeExpired(deadline)
+        returns (uint256 returnAmount)
+    {
         uint256 originToTokenBalance = IERC20(toToken).balanceOf(msg.sender);
         IDODOApprove(dodoApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
 
@@ -437,9 +440,22 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         uint256 minReturnAmount,
         bytes memory callDataConcat,
         uint256 deadline
-    ) external virtual override payable preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
+    )
+        external
+        virtual
+        override
+        payable
+        preventReentrant
+        judgeExpired(deadline)
+        returns (uint256 returnAmount)
+    {
         if (fromToken != ETH_ADDRESS) {
-            IDODOApprove(dodoApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
+            IDODOApprove(dodoApprove).claimTokens(
+                fromToken,
+                msg.sender,
+                address(this),
+                fromTokenAmount
+            );
             IERC20(fromToken).universalApproveMax(approveTarget, fromTokenAmount);
         }
 
@@ -474,8 +490,16 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         address[] memory dodoPairs,
         uint8[] memory directions,
         uint256 deadline
-    ) external virtual override payable preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
+    )
-        _deposit(msg.sender,address(this),fromToken,fromTokenAmount, fromToken == ETH_ADDRESS);
+        external
+        virtual
+        override
+        payable
+        preventReentrant
+        judgeExpired(deadline)
+        returns (uint256 returnAmount)
+    {
+        _deposit(msg.sender, address(this), fromToken, fromTokenAmount, fromToken == ETH_ADDRESS);
 
         for (uint256 i = 0; i < dodoPairs.length; i++) {
             address curDodoPair = dodoPairs[i];
@@ -498,7 +522,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
 
         returnAmount = IERC20(toToken).universalBalanceOf(address(this));
         require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough");
-        
+
         _withdraw(msg.sender, toToken, returnAmount, toToken == ETH_ADDRESS);
 
         emit OrderHistory(
@@ -521,8 +545,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
         if (isETH) {
             if (amount > 0) {
                 IWETH(_WETH_).deposit{value: amount}();
-                if(to != address(this)) 
+                if (to != address(this)) SafeERC20.safeTransfer(IERC20(_WETH_), to, amount);
-                    SafeERC20.safeTransfer(IERC20(_WETH_), to, amount);
             }
         } else {
             IDODOApprove(dodoApprove).claimTokens(token, from, to, amount);

contracts/SmartRoute/helper/DODOCalleeHelper.sol

@@ -18,11 +18,11 @@ contract DODOCalleeHelper is ReentrancyGuard {
     address payable public _WETH_;
 
     fallback() external payable {
-        require(msg.sender == _WETH_, "WE_DONT_SAVED_YOUR_ETH");
+        require(msg.sender == _WETH_, "WE_SAVED_YOUR_ETH");
     }
 
     receive() external payable {
-        require(msg.sender == _WETH_, "WE_DONT_SAVED_YOUR_ETH");
+        require(msg.sender == _WETH_, "WE_SAVED_YOUR_ETH");
     }
 
     constructor(address payable _weth) public {
@@ -57,4 +57,4 @@ contract DODOCalleeHelper is ReentrancyGuard {
             SafeERC20.safeTransfer(IERC20(token), to, amount);
         }
     }
-}
+}

contracts/SmartRoute/intf/IDODOV2Proxy01.sol

@@ -8,7 +8,7 @@
 pragma solidity 0.6.9;
 pragma experimental ABIEncoderV2;
 
-import {IDODOV1Proxy01} from './IDODOV1Proxy01.sol';
+import {IDODOV1Proxy01} from "./IDODOV1Proxy01.sol";
 
 interface IDODOV2Proxy01 is IDODOV1Proxy01 {
     function dodoSwapETHToToken(
@@ -73,31 +73,6 @@ interface IDODOV2Proxy01 is IDODOV1Proxy01 {
             uint256 quoteAdjustedInAmount
         );
 
-    // ====================  Permit ================================
-
-    function removeDVMLiquidity(
-        address DVMAddress,
-        address payable to,
-        uint256 sharesAmount,
-        uint256 baseMinOutAmount,
-        uint256 quoteMinOutAmount,
-        uint8 flag, // 0 -ERC20, 1 - baseOutETH, 2 - quoteOutETH
-        uint256 deadline
-    ) external returns (uint256 baseOutAmount, uint256 quoteOutAmount);
-
-    function removeDVMLiquidityWithPermit(
-        address DVMAddress,
-        address payable to,
-        uint256 sharesAmount,
-        uint256 baseMinOutAmount,
-        uint256 quoteMinOutAmount,
-        uint8 flag, // 0 -ERC20, 1 - baseOutETH, 2 - quoteOutETH
-        uint256 deadline,
-        bool approveMax, uint8 v, bytes32 r, bytes32 s
-    ) external returns (uint256 baseOutAmount, uint256 quoteOutAmount);
-    // ==============================================================
-
-
     function createDODOPrivatePool(
         address baseToken,
         address quoteToken,

contracts/SmartRoute/lib/UniversalERC20.sol

@@ -17,10 +17,6 @@ library UniversalERC20 {
 
     IERC20 private constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
 
-    function isETH(IERC20 token) internal pure returns (bool) {
-        return token == ETH_ADDRESS;
-    }
-
     function universalTransfer(
         IERC20 token,
         address payable to,
@@ -56,4 +52,8 @@ library UniversalERC20 {
             return token.balanceOf(who);
         }
     }
+
+    function isETH(IERC20 token) internal pure returns (bool) {
+        return token == ETH_ADDRESS;
+    }
 }

contracts/lib/DecimalMath.sol

@@ -19,8 +19,8 @@ import {SafeMath} from "./SafeMath.sol";
 library DecimalMath {
     using SafeMath for uint256;
 
-    uint256 constant ONE = 10**18;
+    uint256 internal constant ONE = 10**18;
-    uint256 constant ONE2 = 10**36;
+    uint256 internal constant ONE2 = 10**36;
 
     function mulFloor(uint256 target, uint256 d) internal pure returns (uint256) {
         return target.mul(d) / (10**18);