Merge branch 'feature/V2' of github.com:DODOEX/contractV2 into feature/V2

.gitignore

@@ -4,6 +4,7 @@
 .idea
 
 build/
+build-v1/
 dist/
 node_modules/
 coverage/

contracts/DODOVendorMachine/impl/DVMStorage.sol

@@ -14,16 +14,26 @@ import {SafeMath} from "../../lib/SafeMath.sol";
 import {DODOMath} from "../../lib/DODOMath.sol";
 import {DecimalMath} from "../../lib/DecimalMath.sol";
 import {IPermissionManager} from "../../lib/PermissionManager.sol";
+<<<<<<< HEAD
 import {IExternalValue} from "../../lib/ExternalValue.sol";
 import {IFeeRateModel} from "../../intf/IFeeRateModel.sol";
 import {IERC20} from "../../intf/IERC20.sol";
+=======
+import {IGasPriceSource} from "../../lib/GasPriceSource.sol";
+import {IFeeRateModel} from "../../intf/IFeeRateModel.sol";
+import {IDVMVault} from "../intf/IDVMVault.sol";
+>>>>>>> bd21a14b5398693ec5ad47e52fed6a8ea1193e9b
 
 contract DVMStorage is InitializableOwnable, ReentrancyGuard {
     using SafeMath for uint256;
 
     // ============ Variables for Control ============
 
+<<<<<<< HEAD
     IExternalValue public _GAS_PRICE_LIMIT_;
+=======
+    IGasPriceSource public _GAS_PRICE_LIMIT_;
+>>>>>>> bd21a14b5398693ec5ad47e52fed6a8ea1193e9b
 
     // ============ Advanced Controls ============
 
@@ -36,6 +46,7 @@ contract DVMStorage is InitializableOwnable, ReentrancyGuard {
 
     address public _MAINTAINER_; // collect maintainer fee
 
+<<<<<<< HEAD
     IERC20 public _BASE_TOKEN_;
     IERC20 public _QUOTE_TOKEN_;
 
@@ -51,6 +62,10 @@ contract DVMStorage is InitializableOwnable, ReentrancyGuard {
     uint256 public totalSupply;
     mapping(address => uint256) internal _SHARES_;
     mapping(address => mapping(address => uint256)) internal _ALLOWED_;
+=======
+    address public _BASE_TOKEN_;
+    address public _QUOTE_TOKEN_;
+>>>>>>> bd21a14b5398693ec5ad47e52fed6a8ea1193e9b
 
     // ============ Variables for Pricing ============
 
@@ -59,6 +74,44 @@ contract DVMStorage is InitializableOwnable, ReentrancyGuard {
     uint256 public _K_;
     uint256 public _I_;
 
+<<<<<<< HEAD
+=======
+    IDVMVault public _VAULT_;
+
+    // ============ Modifiers ============
+
+    modifier isBuyAllow(address trader) {
+        require(!_BUYING_CLOSE_ && _TRADE_PERMISSION_.isAllowed(trader), "TRADER_BUY_NOT_ALLOWED");
+        _;
+    }
+
+    modifier isSellAllow(address trader) {
+        require(
+            !_SELLING_CLOSE_ && _TRADE_PERMISSION_.isAllowed(trader),
+            "TRADER_SELL_NOT_ALLOWED"
+        );
+        _;
+    }
+
+    modifier limitGasPrice() {
+        require(tx.gasprice <= _GAS_PRICE_LIMIT_.getGasPrice(), "GAS_PRICE_EXCEED");
+        _;
+    }
+
+    // ============ Helper Functions ============
+
+    function calculateBase0(uint256 baseAmount, uint256 quoteAmount) public view returns (uint256) {
+        uint256 fairAmount = DecimalMath.divFloor(quoteAmount, _I_);
+        return DODOMath._SolveQuadraticFunctionForTarget(baseAmount, _K_, fairAmount);
+    }
+
+    function getBase0() public view returns (uint256) {
+        (uint256 baseAmount, uint256 quoteAmount) = _VAULT_.getVaultReserve();
+        uint256 fairAmount = DecimalMath.divFloor(quoteAmount, _I_);
+        return DODOMath._SolveQuadraticFunctionForTarget(baseAmount, _K_, fairAmount);
+    }
+
+>>>>>>> bd21a14b5398693ec5ad47e52fed6a8ea1193e9b
     // ============ Setting Functions ============
 
     function setLpFeeRateModel(address newLpFeeRateModel) external onlyOwner {
@@ -78,7 +131,11 @@ contract DVMStorage is InitializableOwnable, ReentrancyGuard {
     }
 
     function setGasPriceSource(address newGasPriceLimitSource) external onlyOwner {
+<<<<<<< HEAD
         _GAS_PRICE_LIMIT_ = IExternalValue(newGasPriceLimitSource);
+=======
+        _GAS_PRICE_LIMIT_ = IGasPriceSource(newGasPriceLimitSource);
+>>>>>>> bd21a14b5398693ec5ad47e52fed6a8ea1193e9b
     }
 
     function setBuy(bool open) external onlyOwner {

contracts/DODOVendorMachine/intf/IDVMVault.sol

@@ -0,0 +1,71 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+interface IDVMVault {
+    function init(
+        address owner,
+        address _baseToken,
+        address _quoteToken
+    ) external;
+
+    function _BASE_TOKEN_() external returns (address);
+
+    function _QUOTE_TOKEN_() external returns (address);
+
+    function _BASE_RESERVE_() external returns (uint256);
+
+    function _QUOTE_RESERVE_() external returns (uint256);
+
+    function symbol() external returns (string memory);
+
+    function decimals() external returns (uint256);
+
+    function name() external returns (string memory);
+
+    function totalSupply() external returns (uint256);
+
+    function getVaultBalance() external view returns (uint256 baseBalance, uint256 quoteBalance);
+
+    function getVaultReserve() external view returns (uint256 baseReserve, uint256 quoteReserve);
+
+    function getBaseBalance() external view returns (uint256 baseBalance);
+
+    function getQuoteBalance() external view returns (uint256 quoteBalance);
+
+    function getBaseInput() external view returns (uint256 input);
+
+    function getQuoteInput() external view returns (uint256 input);
+
+    function sync() external;
+
+    function transferBaseOut(address to, uint256 amount) external;
+
+    function transferQuoteOut(address to, uint256 amount) external;
+
+    function transfer(address to, uint256 amount) external returns (bool);
+
+    function balanceOf(address owner) external view returns (uint256 balance);
+
+    function shareRatioOf(address owner) external view returns (uint256 shareRatio);
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 amount
+    ) external returns (bool);
+
+    function approve(address spender, uint256 amount) external returns (bool);
+
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function mint(address user, uint256 value) external;
+
+    function burn(address user, uint256 value) external;
+}

contracts/DODOZoo.sol

@@ -0,0 +1,134 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+import {Ownable} from "./lib/Ownable.sol";
+import {IDODO} from "./intf/IDODO.sol";
+import {ICloneFactory} from "./helper/CloneFactory.sol";
+
+
+/**
+ * @title DODOZoo
+ * @author DODO Breeder
+ *
+ * @notice Register of All DODO
+ */
+contract DODOZoo is Ownable {
+    address public _DODO_LOGIC_;
+    address public _CLONE_FACTORY_;
+
+    address public _DEFAULT_SUPERVISOR_;
+
+    mapping(address => mapping(address => address)) internal _DODO_REGISTER_;
+    address[] public _DODOs;
+
+    // ============ Events ============
+
+    event DODOBirth(address newBorn, address baseToken, address quoteToken);
+
+    // ============ Constructor Function ============
+
+    constructor(
+        address _dodoLogic,
+        address _cloneFactory,
+        address _defaultSupervisor
+    ) public {
+        _DODO_LOGIC_ = _dodoLogic;
+        _CLONE_FACTORY_ = _cloneFactory;
+        _DEFAULT_SUPERVISOR_ = _defaultSupervisor;
+    }
+
+    // ============ Admin Function ============
+
+    function setDODOLogic(address _dodoLogic) external onlyOwner {
+        _DODO_LOGIC_ = _dodoLogic;
+    }
+
+    function setCloneFactory(address _cloneFactory) external onlyOwner {
+        _CLONE_FACTORY_ = _cloneFactory;
+    }
+
+    function setDefaultSupervisor(address _defaultSupervisor) external onlyOwner {
+        _DEFAULT_SUPERVISOR_ = _defaultSupervisor;
+    }
+
+    function removeDODO(address dodo) external onlyOwner {
+        address baseToken = IDODO(dodo)._BASE_TOKEN_();
+        address quoteToken = IDODO(dodo)._QUOTE_TOKEN_();
+        require(isDODORegistered(baseToken, quoteToken), "DODO_NOT_REGISTERED");
+        _DODO_REGISTER_[baseToken][quoteToken] = address(0);
+        for (uint256 i = 0; i <= _DODOs.length - 1; i++) {
+            if (_DODOs[i] == dodo) {
+                _DODOs[i] = _DODOs[_DODOs.length - 1];
+                _DODOs.pop();
+                break;
+            }
+        }
+    }
+
+    function addDODO(address dodo) public onlyOwner {
+        address baseToken = IDODO(dodo)._BASE_TOKEN_();
+        address quoteToken = IDODO(dodo)._QUOTE_TOKEN_();
+        require(!isDODORegistered(baseToken, quoteToken), "DODO_REGISTERED");
+        _DODO_REGISTER_[baseToken][quoteToken] = dodo;
+        _DODOs.push(dodo);
+    }
+
+    // ============ Breed DODO Function ============
+
+    function breedDODO(
+        address maintainer,
+        address baseToken,
+        address quoteToken,
+        address oracle,
+        uint256 lpFeeRate,
+        uint256 mtFeeRate,
+        uint256 k,
+        uint256 gasPriceLimit
+    ) external onlyOwner returns (address newBornDODO) {
+        require(!isDODORegistered(baseToken, quoteToken), "DODO_REGISTERED");
+        newBornDODO = ICloneFactory(_CLONE_FACTORY_).clone(_DODO_LOGIC_);
+        IDODO(newBornDODO).init(
+            _OWNER_,
+            _DEFAULT_SUPERVISOR_,
+            maintainer,
+            baseToken,
+            quoteToken,
+            oracle,
+            lpFeeRate,
+            mtFeeRate,
+            k,
+            gasPriceLimit
+        );
+        addDODO(newBornDODO);
+        emit DODOBirth(newBornDODO, baseToken, quoteToken);
+        return newBornDODO;
+    }
+
+    // ============ View Functions ============
+
+    function isDODORegistered(address baseToken, address quoteToken) public view returns (bool) {
+        if (
+            _DODO_REGISTER_[baseToken][quoteToken] == address(0) &&
+            _DODO_REGISTER_[quoteToken][baseToken] == address(0)
+        ) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    function getDODO(address baseToken, address quoteToken) external view returns (address) {
+        return _DODO_REGISTER_[baseToken][quoteToken];
+    }
+
+    function getDODOs() external view returns (address[] memory) {
+        return _DODOs;
+    }
+}

contracts/SmartRoute/SmartSwap.sol

@@ -15,7 +15,7 @@ import {SafeMath} from "../lib/SafeMath.sol";
 import {IDODOSellHelper} from "../intf/IDODOSellHelper.sol";
 import {ISmartApprove} from "../intf/ISmartApprove.sol";
 import {IDODO} from "../intf/IDODO.sol";
-
+import {IWETH} from "../intf/IWETH.sol";
 
 contract SmartSwap is Ownable {
     using SafeMath for uint256;
@@ -25,6 +25,7 @@ contract SmartSwap is Ownable {
     IERC20 constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
     ISmartApprove public smartApprove;
     IDODOSellHelper public dodoSellHelper;
+    address payable public _WETH_;
 
     event OrderHistory(
         IERC20 indexed fromToken,
@@ -36,11 +37,20 @@ contract SmartSwap is Ownable {
 
     event ExternalRecord(address indexed to, address indexed sender);
 
-    constructor(address _smartApprove,address _dodoSellHelper) public {
+    constructor(
+        address _smartApprove,
+        address _dodoSellHelper,
+        address payable _weth
+    ) public {
         smartApprove = ISmartApprove(_smartApprove);
         dodoSellHelper = IDODOSellHelper(_dodoSellHelper);
+        _WETH_ = _weth;
     }
 
+    fallback() external payable {}
+
+    receive() external payable {}
+
     function dodoSwap(
         IERC20 fromToken,
         IERC20 toToken,
@@ -54,25 +64,37 @@ contract SmartSwap is Ownable {
 
         if (fromToken != ETH_ADDRESS) {
             smartApprove.claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
+        } else {
+            require(msg.value == fromTokenAmount, "ETH_AMOUNT_NOT_MATCH");
+            IWETH(_WETH_).deposit{value: fromTokenAmount}();
         }
 
         for (uint256 i = 0; i < dodoPairs.length; i++) {
             uint256 curDirection = directions[i];
             address curDodoPair = dodoPairs[i];
-            if(curDirection == 0){
+            if (curDirection == 0) {
                 address curDodoBase = IDODO(curDodoPair)._BASE_TOKEN_();
                 uint256 curAmountIn = IERC20(curDodoBase).balanceOf(address(this));
-                IERC20(curDodoBase).approve(curDodoPair,curAmountIn);
+                IERC20(curDodoBase).universalApprove(curDodoPair, curAmountIn);
                 IDODO(curDodoPair).sellBaseToken(curAmountIn, 0, "");
-            }else {
+            } else {
                 address curDodoQuote = IDODO(curDodoPair)._QUOTE_TOKEN_();
                 uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this));
-                IERC20(curDodoQuote).approve(curDodoPair,curAmountIn);
+                IERC20(curDodoQuote).universalApprove(curDodoPair, curAmountIn);
-                uint256 canBuyBaseAmount = dodoSellHelper.querySellQuoteToken(curDodoPair,curAmountIn);
+                uint256 canBuyBaseAmount = dodoSellHelper.querySellQuoteToken(
+                    curDodoPair,
+                    curAmountIn
+                );
                 IDODO(curDodoPair).buyBaseToken(canBuyBaseAmount, curAmountIn, "");
             }
         }
         fromToken.universalTransfer(msg.sender, fromToken.universalBalanceOf(address(this)));
+
+        if (toToken == ETH_ADDRESS) {
+            uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this));
+            IWETH(_WETH_).withdraw(wethAmount);
+        }
+
         returnAmount = toToken.universalBalanceOf(address(this));
 
         require(returnAmount >= minReturnAmount, "Return amount is not enough");
@@ -80,7 +102,6 @@ contract SmartSwap is Ownable {
         emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
     }
 
-
     function externalSwap(
         IERC20 fromToken,
         IERC20 toToken,
@@ -91,15 +112,16 @@ contract SmartSwap is Ownable {
         uint256 minReturnAmount,
         bytes memory callDataConcat
     ) public payable returns (uint256 returnAmount) {
-        
         require(minReturnAmount > 0, "Min return should be bigger then 0.");
 
         if (fromToken != ETH_ADDRESS) {
             smartApprove.claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
-            fromToken.approve(approveTarget, fromTokenAmount);
+            fromToken.universalApprove(approveTarget, fromTokenAmount);
         }
 
-        (bool success, ) = to.call{value: msg.value, gas: gasSwap}(callDataConcat);
+        (bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0, gas: gasSwap}(
+            callDataConcat
+        );
 
         require(success, "Contract Swap execution Failed");
 

contracts/helper/CloneFactory.sol

@@ -0,0 +1,33 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+interface ICloneFactory {
+    function clone(address prototype) external returns (address proxy);
+}
+
+// introduction of proxy mode design: https://docs.openzeppelin.com/upgrades/2.8/
+// minimum implementation of transparent proxy: https://eips.ethereum.org/EIPS/eip-1167
+
+contract CloneFactory is ICloneFactory {
+    function clone(address prototype) external override returns (address proxy) {
+        bytes20 targetBytes = bytes20(prototype);
+        assembly {
+            let clone := mload(0x40)
+            mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
+            mstore(add(clone, 0x14), targetBytes)
+            mstore(
+                add(clone, 0x28),
+                0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
+            )
+            proxy := create(0, clone, 0x37)
+        }
+        return proxy;
+    }
+}

contracts/helper/NativeOracle.sol

@@ -0,0 +1,25 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+import {Ownable} from "../lib/Ownable.sol";
+
+
+// Oracle only for test
+contract NaiveOracle is Ownable {
+    uint256 public tokenPrice;
+
+    function setPrice(uint256 newPrice) external onlyOwner {
+        tokenPrice = newPrice;
+    }
+
+    function getPrice() external view returns (uint256) {
+        return tokenPrice;
+    }
+}

contracts/helper/TestERC20.sol

@@ -0,0 +1,74 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+
+import {SafeMath} from "../lib/SafeMath.sol";
+
+contract TestERC20 {
+    using SafeMath for uint256;
+
+    string public name;
+    uint8 public decimals;
+    string public symbol;
+
+    mapping(address => uint256) balances;
+    mapping(address => mapping(address => uint256)) internal allowed;
+
+    event Transfer(address indexed from, address indexed to, uint256 amount);
+    event Approval(address indexed owner, address indexed spender, uint256 amount);
+
+    constructor(string memory _name, uint8 _decimals,string memory _symbol) public {
+        name = _name;
+        decimals = _decimals;
+        symbol = _symbol;
+    }
+
+    function transfer(address to, uint256 amount) public returns (bool) {
+        require(to != address(0), "TO_ADDRESS_IS_EMPTY");
+        require(amount <= balances[msg.sender], "BALANCE_NOT_ENOUGH");
+
+        balances[msg.sender] = balances[msg.sender].sub(amount);
+        balances[to] = balances[to].add(amount);
+        emit Transfer(msg.sender, to, amount);
+        return true;
+    }
+
+    function balanceOf(address owner) public view returns (uint256 balance) {
+        return balances[owner];
+    }
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 amount
+    ) public returns (bool) {
+        require(to != address(0), "TO_ADDRESS_IS_EMPTY");
+        require(amount <= balances[from], "BALANCE_NOT_ENOUGH");
+        require(amount <= allowed[from][msg.sender], "ALLOWANCE_NOT_ENOUGH");
+
+        balances[from] = balances[from].sub(amount);
+        balances[to] = balances[to].add(amount);
+        allowed[from][msg.sender] = allowed[from][msg.sender].sub(amount);
+        emit Transfer(from, to, amount);
+        return true;
+    }
+
+    function approve(address spender, uint256 amount) public returns (bool) {
+        allowed[msg.sender][spender] = amount;
+        emit Approval(msg.sender, spender, amount);
+        return true;
+    }
+
+    function allowance(address owner, address spender) public view returns (uint256) {
+        return allowed[owner][spender];
+    }
+
+    function mint(address account, uint256 amount) external {
+        balances[account] = balances[account].add(amount);
+    }
+}

contracts/helper/TestWETH.sol

@@ -0,0 +1,77 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+
+
+contract WETH9 {
+    string public name = "Wrapped Ether";
+    string public symbol = "WETH";
+    uint8 public decimals = 18;
+
+    event Approval(address indexed src, address indexed guy, uint256 wad);
+    event Transfer(address indexed src, address indexed dst, uint256 wad);
+    event Deposit(address indexed dst, uint256 wad);
+    event Withdrawal(address indexed src, uint256 wad);
+
+    mapping(address => uint256) public balanceOf;
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    fallback() external payable {
+        deposit();
+    }
+
+    receive() external payable {
+        deposit();
+    }
+
+    function deposit() public payable {
+        balanceOf[msg.sender] += msg.value;
+        emit Deposit(msg.sender, msg.value);
+    }
+
+    function withdraw(uint256 wad) public {
+        require(balanceOf[msg.sender] >= wad);
+        balanceOf[msg.sender] -= wad;
+        msg.sender.transfer(wad);
+        emit Withdrawal(msg.sender, wad);
+    }
+
+    function totalSupply() public view returns (uint256) {
+        return address(this).balance;
+    }
+
+    function approve(address guy, uint256 wad) public returns (bool) {
+        allowance[msg.sender][guy] = wad;
+        emit Approval(msg.sender, guy, wad);
+        return true;
+    }
+
+    function transfer(address dst, uint256 wad) public returns (bool) {
+        return transferFrom(msg.sender, dst, wad);
+    }
+
+    function transferFrom(
+        address src,
+        address dst,
+        uint256 wad
+    ) public returns (bool) {
+        require(balanceOf[src] >= wad);
+
+        if (src != msg.sender && allowance[src][msg.sender] != uint256(-1)) {
+            require(allowance[src][msg.sender] >= wad);
+            allowance[src][msg.sender] -= wad;
+        }
+
+        balanceOf[src] -= wad;
+        balanceOf[dst] += wad;
+
+        Transfer(src, dst, wad);
+
+        return true;
+    }
+}

contracts/lib/GasPriceSource.sol

@@ -0,0 +1,29 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+import {Ownable} from "./Ownable.sol";
+
+interface IGasPriceSource {
+    function setGasPrice(uint256) external;
+
+    function getGasPrice() external view returns (uint256);
+}
+
+contract GasPriceSource is IGasPriceSource, Ownable {
+    uint256 public _GAS_PRICE_;
+
+    function setGasPrice(uint256 gasPrice) external override {
+        _GAS_PRICE_ = gasPrice;
+    }
+
+    function getGasPrice() external override view returns (uint256) {
+        return _GAS_PRICE_;
+    }
+}

contracts/lib/UniversalERC20.sol

@@ -12,18 +12,26 @@ import {IERC20} from "../intf/IERC20.sol";
 import {SafeERC20} from "./SafeERC20.sol";
 
 library UniversalERC20 {
-
     using SafeMath for uint256;
     using SafeERC20 for IERC20;
 
     IERC20 private constant ZERO_ADDRESS = IERC20(0x0000000000000000000000000000000000000000);
     IERC20 private constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
 
-    function universalTransfer(IERC20 token, address to, uint256 amount) internal {
+    function universalTransfer(
+        IERC20 token,
+        address to,
+        uint256 amount
+    ) internal {
         universalTransfer(token, to, amount, false);
     }
 
-    function universalTransfer(IERC20 token, address to, uint256 amount, bool mayFail) internal returns(bool) {
+    function universalTransfer(
+        IERC20 token,
+        address to,
+        uint256 amount,
+        bool mayFail
+    ) internal returns (bool) {
         if (amount == 0) {
             return true;
         }
@@ -41,13 +49,33 @@ library UniversalERC20 {
         }
     }
 
-    function universalApprove(IERC20 token, address to, uint256 amount) internal {
+    function universalApprove(
+        IERC20 token,
+        address to,
+        uint256 amount
+    ) internal {
         if (token != ZERO_ADDRESS && token != ETH_ADDRESS) {
-            token.safeApprove(to, amount);
+            if (amount == 0) {
+                token.safeApprove(to, 0);
+                return;
+            }
+
+            uint256 allowance = token.allowance(address(this), to);
+            if (allowance < amount) {
+                if (allowance > 0) {
+                    token.safeApprove(to, 0);
+                }
+                token.safeApprove(to, amount);
+            }
         }
     }
 
-    function universalTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {
+    function universalTransferFrom(
+        IERC20 token,
+        address from,
+        address to,
+        uint256 amount
+    ) internal {
         if (amount == 0) {
             return;
         }
@@ -72,4 +100,4 @@ library UniversalERC20 {
             return token.balanceOf(who);
         }
     }
-}
+}

deploy-detail.txt

@@ -0,0 +1,8 @@
+====================================================
+network type: live
+Deploy time: 2020/11/16 上午10:26:34
+Deploy type: Smart Route
+SmartApprove Address:  0xe380Ad3181A69BF92133D2feb609867c4adC61eA
+DODOSellHelper Address:  0x533da777aedce766ceae696bf90f8541a4ba80eb
+SmartSwap Address:  0xcD8392A57ED2fBD6440037E52F176c26dEFc0ba4
+SmartApprovce setSmartSwap tx:  0x35eccc657ee0d473b6e58324123d3da568ce12389fedff914a8dada563b35b3a

migrations/1_initial_migration.js

@@ -1,5 +1,5 @@
 const Migrations = artifacts.require("Migrations");
 
-module.exports = function(deployer) {
+module.exports = function (deployer) {
-  deployer.deploy(Migrations);
+  // deployer.deploy(Migrations);
 };

migrations/2_deploy.js

@@ -1 +1,157 @@
-module.exports = async (deployer, network) => {};
+const fs = require("fs");
+const file = fs.createWriteStream("../deploy-detail.txt");
+let logger = new console.Console(file, file);
+
+const SmartApprove = artifacts.require("SmartApprove");
+const SmartSwap = artifacts.require("SmartSwap");
+const DODOSellHelper = artifacts.require("DODOSellHelper");
+const TestERC20 = artifacts.require("TestERC20");
+const NaiveOracle = artifacts.require("NaiveOracle");
+const DODOZoo = artifacts.require("DODOZoo");
+
+const DEPLOY_ROUTE = true;
+const DEPLOY_KOVAN_TOKEN = false;
+
+module.exports = async (deployer, network, accounts) => {
+  let DODOSellHelperAddress = "";
+  let DODOZooAddress = "";
+  let WETHAddress = "";
+  let SmartApproveAddress = "";
+  if (network == "kovan") {
+    DODOSellHelperAddress = "0xbdEae617F2616b45DCB69B287D52940a76035Fe3";
+    DODOZooAddress = "0x92230e929a2226b29ed3441ae5524886347c60c8";
+    WETHAddress = "0x5eca15b12d959dfcf9c71c59f8b467eb8c6efd0b";
+    SmartApproveAddress = "0x5627b7DEb3055e1e899003FDca0716b32C382084";
+  } else if (network == "live") {
+    DODOSellHelperAddress = "0x533da777aedce766ceae696bf90f8541a4ba80eb";
+    DODOZooAddress = "0x3a97247df274a17c59a3bd12735ea3fcdfb49950";
+    WETHAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
+    SmartApproveAddress = "0xe380Ad3181A69BF92133D2feb609867c4adC61eA";
+  } else return;
+
+  logger.log("====================================================");
+  logger.log("network type: " + network);
+  logger.log("Deploy time: " + new Date().toLocaleString());
+
+  if (DEPLOY_ROUTE) {
+    logger.log("Deploy type: Smart Route");
+    if (SmartApprove == "") {
+      await deployer.deploy(SmartApprove);
+      SmartApproveAddress = SmartApprove.address;
+    }
+    if (DODOSellHelperAddress == "") {
+      await deployer.deploy(DODOSellHelper);
+      DODOSellHelperAddress = DODOSellHelper.address;
+    }
+    logger.log("SmartApprove Address: ", SmartApproveAddress);
+    logger.log("DODOSellHelper Address: ", DODOSellHelperAddress);
+
+    await deployer.deploy(
+      SmartSwap,
+      SmartApproveAddress,
+      DODOSellHelperAddress,
+      WETHAddress
+    );
+    logger.log("SmartSwap Address: ", SmartSwap.address);
+
+    const SmartApproveInstance = await SmartApprove.at(SmartApproveAddress);
+    var tx = await SmartApproveInstance.setSmartSwap(SmartSwap.address);
+    logger.log("SmartApprovce setSmartSwap tx: ", tx.tx);
+  }
+
+  if (DEPLOY_KOVAN_TOKEN) {
+    logger.log("Deploy type: Create Tokens and Trading Pairs");
+    await deployer.deploy(TestERC20, "USDC", 6, "USDC");
+    const USDCAddr = TestERC20.address;
+    logger.log("USDC Addr: ", USDCAddr);
+    await deployer.deploy(TestERC20, "USDT", 6, "USDT");
+    const USDTAddr = TestERC20.address;
+    logger.log("USDT Addr: ", USDTAddr);
+    await deployer.deploy(TestERC20, "DODO", 18, "DODO");
+    const DODOAddr = TestERC20.address;
+    logger.log("DODO Addr: ", DODOAddr);
+    await deployer.deploy(TestERC20, "WOO", 18, "WOO");
+    const WooAddr = TestERC20.address;
+    logger.log("WOO Addr: ", WooAddr);
+    const WETHAddr = WETHAddress;
+    logger.log("WETH Addr: ", WETHAddr);
+
+    let config = {
+      lpFeeRate: "2000000000000000",
+      mtFeeRate: "1000000000000000",
+      k: "100000000000000000",
+      gasPriceLimit: "100000000000",
+    };
+
+    const DODOZooInstance = await DODOZoo.at(DODOZooAddress);
+
+    //USDT-USDC
+    await deployer.deploy(NaiveOracle);
+    var USDT_USDC_Oracle = NaiveOracle.address;
+    await DODOZooInstance.breedDODO(
+      accounts[0],
+      USDTAddr,
+      USDCAddr,
+      USDT_USDC_Oracle,
+      config.lpFeeRate,
+      config.mtFeeRate,
+      config.k,
+      config.gasPriceLimit
+    );
+    const USDT_USDC_Addr = await DODOZooInstance.getDODO(USDTAddr, USDCAddr);
+    logger.log("USDT_USDC_Addr:", USDT_USDC_Addr);
+
+    // DODO-USDT
+    await deployer.deploy(NaiveOracle);
+    var DODO_USDT_Oracle = NaiveOracle.address;
+    await DODOZooInstance.breedDODO(
+      accounts[0],
+      DODOAddr,
+      USDTAddr,
+      DODO_USDT_Oracle,
+      config.lpFeeRate,
+      config.mtFeeRate,
+      config.k,
+      config.gasPriceLimit
+    );
+    const DODO_USDT_Addr = await DODOZooInstance.getDODO(DODOAddr, USDTAddr);
+    logger.log("DODO_USDT_Addr:", DODO_USDT_Addr);
+
+    // //WETH-USDC
+    await deployer.deploy(NaiveOracle);
+    var WETH_USDC_Oracle = NaiveOracle.address;
+    await DODOZooInstance.breedDODO(
+      accounts[0],
+      WETHAddr,
+      USDCAddr,
+      WETH_USDC_Oracle,
+      config.lpFeeRate,
+      config.mtFeeRate,
+      config.k,
+      config.gasPriceLimit
+    );
+    const WETH_USDC_Addr = await DODOZooInstance.getDODO(WETHAddr, USDCAddr);
+    logger.log("WETH_USDC_Addr:", WETH_USDC_Addr);
+
+    //WOO-USDT
+    await deployer.deploy(NaiveOracle);
+    var WOO_USDT_Oracle = NaiveOracle.address;
+    await DODOZooInstance.breedDODO(
+      accounts[0],
+      WooAddr,
+      USDTAddr,
+      WOO_USDT_Oracle,
+      config.lpFeeRate,
+      config.mtFeeRate,
+      config.k,
+      config.gasPriceLimit
+    );
+    const WOO_USDT_Addr = await DODOZooInstance.getDODO(WooAddr, USDTAddr);
+    logger.log("WOO_USDT_Addr:", WOO_USDT_Addr);
+
+    //TODO:ing enableBaseDeposit enableQuoteDeposit enableTrading
+    //TODO:ing apporve pair to token
+    //TODO:ing mint to lp
+    //TODO:ing deposit to Base && quote pool
+  }
+};

test/Route/Route.test.ts

@@ -8,7 +8,7 @@
 import * as assert from 'assert';
 import BigNumber from 'bignumber.js';
 import { DODOContext, getDODOContext } from '../utils-v1/Context-route';
-import { decimalStr,MAX_UINT256,fromWei,mweiStr} from '../utils-v1/Converter';
+import { decimalStr, MAX_UINT256, fromWei, mweiStr } from '../utils-v1/Converter';
 import { logGas } from '../utils-v1/Log';
 import { DODOHelper } from '../utils-v1/dodoHelper';
 
@@ -16,99 +16,104 @@ let lp: string;
 let trader: string;
 
 async function initDODO_USDT(ctx: DODOContext): Promise<void> {
-  await ctx.setOraclePrice(ctx.DODO_USDT_ORACLE,mweiStr("0.1"));
+  await ctx.setOraclePrice(ctx.DODO_USDT_ORACLE, mweiStr("0.1"));
   lp = ctx.spareAccounts[0];
   trader = ctx.spareAccounts[1];
-  
+
   let DODO = ctx.DODO;
   let USDT = ctx.USDT;
   let DODO_USDT = ctx.DODO_USDT;
-  await ctx.approvePair(DODO,USDT,DODO_USDT.options.address,lp);
+  await ctx.approvePair(DODO, USDT, DODO_USDT.options.address, lp);
-  await ctx.approvePair(DODO,USDT,DODO_USDT.options.address,trader);
+  await ctx.approvePair(DODO, USDT, DODO_USDT.options.address, trader);
 
-  await ctx.mintToken(DODO,USDT, lp, decimalStr("10000"), mweiStr("1000"));
+  await ctx.mintToken(DODO, USDT, lp, decimalStr("10000000"), mweiStr("1000000"));
-  await ctx.mintToken(DODO,USDT,trader, decimalStr("100"), mweiStr("0"));
+  await ctx.mintToken(DODO, USDT, trader, decimalStr("1000"), mweiStr("0"));
 
   await DODO_USDT.methods
-    .depositBaseTo(lp, decimalStr("10000"))
+    .depositBaseTo(lp, decimalStr("10000000"))
     .send(ctx.sendParam(lp));
   await DODO_USDT.methods
-    .depositQuoteTo(lp, mweiStr("1000"))
+    .depositQuoteTo(lp, mweiStr("1000000"))
     .send(ctx.sendParam(lp));
 }
 
 async function initUSDT_USDC(ctx: DODOContext): Promise<void> {
-  await ctx.setOraclePrice(ctx.USDT_USDC_ORACLE,decimalStr("1"));
+  await ctx.setOraclePrice(ctx.USDT_USDC_ORACLE, decimalStr("1"));
   lp = ctx.spareAccounts[0];
   trader = ctx.spareAccounts[1];
-  
+
   let USDT = ctx.USDT;
   let USDC = ctx.USDC;
   let USDT_USDC = ctx.USDT_USDC;
 
-  await ctx.approvePair(USDT,USDC,USDT_USDC.options.address,lp);
+  await ctx.approvePair(USDT, USDC, USDT_USDC.options.address, lp);
-  await ctx.mintToken(USDT,USDC,lp, mweiStr("1000"), mweiStr("1000"));
+  await ctx.mintToken(USDT, USDC, lp, mweiStr("1000000"), mweiStr("1000000"));
 
   await USDT_USDC.methods
-    .depositBaseTo(lp, mweiStr("1000"))
+    .depositBaseTo(lp, mweiStr("1000000"))
     .send(ctx.sendParam(lp));
   await USDT_USDC.methods
-    .depositQuoteTo(lp, mweiStr("1000"))
+    .depositQuoteTo(lp, mweiStr("1000000"))
     .send(ctx.sendParam(lp));
 }
 
 
 async function initWETH_USDC(ctx: DODOContext): Promise<void> {
-  await ctx.setOraclePrice(ctx.WETH_USDC_ORACLE,mweiStr("450"));
+  await ctx.setOraclePrice(ctx.WETH_USDC_ORACLE, mweiStr("450"));
   lp = ctx.spareAccounts[0];
   trader = ctx.spareAccounts[1];
-  
+
   let WETH = ctx.WETH;
   let USDC = ctx.USDC;
   let WETH_USDC = ctx.WETH_USDC;
 
-  await ctx.approvePair(WETH,USDC,WETH_USDC.options.address,lp);
+  await ctx.approvePair(WETH, USDC, WETH_USDC.options.address, lp);
-  await ctx.mintToken(WETH,USDC,lp, decimalStr("1000"), mweiStr("450000"));
+  await ctx.mintToken(null, USDC, lp, decimalStr("0"), mweiStr("36000"));
+  await WETH.methods.deposit().send(ctx.sendParam(lp, '80'));
 
   await WETH_USDC.methods
-    .depositBaseTo(lp, decimalStr("1000"))
+    .depositBaseTo(lp, decimalStr("80"))
     .send(ctx.sendParam(lp));
   await WETH_USDC.methods
-    .depositQuoteTo(lp, mweiStr("450000"))
+    .depositQuoteTo(lp, mweiStr("36000"))
     .send(ctx.sendParam(lp));
 }
 
 //mock sdk logic
-async function calcRoute(ctx: DODOContext,fromTokenAmount:string,slippage:number,routes:any[],pairs:any[]) {
+async function calcRoute(ctx: DODOContext, fromTokenAmount: string, slippage: number, routes: any[], pairs: any[]) {
   let swapAmount = fromTokenAmount
-  let directions:number[] = []
+  let directions: number[] = []
-  let dodoPairs:string[] = []
+  let dodoPairs: string[] = []
 
 
   for (let i = 0; i < pairs.length; i++) {
     let curPair = pairs[i]
     dodoPairs.push(curPair.pair)
     let curContact = pairs[i].pairContract
-    if (curPair.base === routes[i].address) {
+    if (routes[i].address == '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') {
       directions[i] = 0;
       swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call();
-      console.log(i + "-swapAmount:",swapAmount);
+      console.log(i + "-swapAmount:", swapAmount);
+    } else if (curPair.base === routes[i].address) {
+      directions[i] = 0;
+      swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call();
+      console.log(i + "-swapAmount:", swapAmount);
     } else {
       directions[i] = 1;
-      swapAmount = await ctx.DODOSellHelper.methods.querySellQuoteToken(curPair.pair,swapAmount).call();
+      swapAmount = await ctx.DODOSellHelper.methods.querySellQuoteToken(curPair.pair, swapAmount).call();
-      console.log(i + "-swapAmount:",swapAmount);
+      console.log(i + "-swapAmount:", swapAmount);
     }
   }
 
-  let toAmount  = new BigNumber(swapAmount).multipliedBy(1-slippage).toFixed(0, BigNumber.ROUND_DOWN)
+  let toAmount = new BigNumber(swapAmount).multipliedBy(1 - slippage).toFixed(0, BigNumber.ROUND_DOWN)
-  
+
-  console.log("minAmount:",toAmount);
+  console.log("minAmount:", toAmount);
   // console.log("dodoPairs",dodoPairs);
   // console.log("directions",directions);
 
   return ctx.SmartSwap.methods.dodoSwap(
     routes[0].address,
-    routes[routes.length-1].address,
+    routes[routes.length - 1].address,
     fromTokenAmount,
     toAmount,
     dodoPairs,
@@ -139,9 +144,9 @@ describe("Trader", () => {
     it("DODO to USDT directly swap", async () => {
       var b_DODO = await ctx.DODO.methods.balanceOf(trader).call()
       var b_USDT = await ctx.USDT.methods.balanceOf(trader).call()
-      console.log("Before DODO:" + fromWei(b_DODO,'ether') + "; USDT:" + fromWei(b_USDT,'mwei'));
+      console.log("Before DODO:" + fromWei(b_DODO, 'ether') + "; USDT:" + fromWei(b_USDT, 'mwei'));
       //approve DODO entry
-      await ctx.DODO.methods.approve(ctx.SmartApprove.options.address,MAX_UINT256).send(ctx.sendParam(trader))
+      await ctx.DODO.methods.approve(ctx.SmartApprove.options.address, MAX_UINT256).send(ctx.sendParam(trader))
       //set route path
       var routes = [{
         address: ctx.DODO.options.address,
@@ -155,37 +160,35 @@ describe("Trader", () => {
       var pairs = [{
         pair: ctx.DODO_USDT.options.address,
         base: ctx.DODO.options.address,
-        /*only for test*/
         pairContract: ctx.DODO_USDT
-        /**************/
       }];
 
-      var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "directly swap")
+      var tx = await logGas(await calcRoute(ctx, decimalStr('10'), 0.1, routes, pairs), ctx.sendParam(trader), "directly swap")
       // console.log(tx.events['OrderHistory']);
       var a_DODO = await ctx.DODO.methods.balanceOf(trader).call()
       var a_USDT = await ctx.USDT.methods.balanceOf(trader).call()
-      console.log("After DODO:" + fromWei(a_DODO,'ether') + "; USDT:" + fromWei(a_USDT,'mwei'));
+      console.log("After DODO:" + fromWei(a_DODO, 'ether') + "; USDT:" + fromWei(a_USDT, 'mwei'));
       console.log("===============================================")
       var c_DODO = await ctx.DODO.methods.balanceOf(ctx.SmartSwap.options.address).call()
       var c_USDT = await ctx.USDT.methods.balanceOf(ctx.SmartSwap.options.address).call()
-      console.log("Contract DODO:" + fromWei(c_DODO,'ether') + "; USDT:" + fromWei(c_USDT,'mwei'));
+      console.log("Contract DODO:" + fromWei(c_DODO, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei'));
     });
 
 
     it("DODO to USDC two hops swap", async () => {
       var b_DODO = await ctx.DODO.methods.balanceOf(trader).call()
       var b_USDC = await ctx.USDC.methods.balanceOf(trader).call()
-      console.log("Before DODO:" + fromWei(b_DODO,'ether') + "; USDC:" + fromWei(b_USDC,'mwei'));
+      console.log("Before DODO:" + fromWei(b_DODO, 'ether') + "; USDC:" + fromWei(b_USDC, 'mwei'));
       //approve DODO entry
-      await ctx.DODO.methods.approve(ctx.SmartApprove.options.address,MAX_UINT256).send(ctx.sendParam(trader))
+      await ctx.DODO.methods.approve(ctx.SmartApprove.options.address, MAX_UINT256).send(ctx.sendParam(trader))
       //set route path
       var routes = [{
         address: ctx.DODO.options.address,
         decimals: 18
-      },{
+      }, {
         address: ctx.USDT.options.address,
         decimals: 6
-      },{
+      }, {
         address: ctx.USDC.options.address,
         decimals: 6
       }];
@@ -193,46 +196,42 @@ describe("Trader", () => {
       var pairs = [{
         pair: ctx.DODO_USDT.options.address,
         base: ctx.DODO.options.address,
-        /*only for test*/
         pairContract: ctx.DODO_USDT
-        /**************/
+      }, {
-      },{
         pair: ctx.USDT_USDC.options.address,
         base: ctx.USDT.options.address,
-        /*only for test*/
         pairContract: ctx.USDT_USDC
-        /**************/
       }];
 
-      var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "tow hops swap")
+      var tx = await logGas(await calcRoute(ctx, decimalStr('10'), 0.1, routes, pairs), ctx.sendParam(trader), "tow hops swap")
       // console.log(tx.events['Swapped']);
       var a_DODO = await ctx.DODO.methods.balanceOf(trader).call()
       var a_USDC = await ctx.USDC.methods.balanceOf(trader).call()
-      console.log("After DODO:" + fromWei(a_DODO,'ether') + "; USDC:" + fromWei(a_USDC,'mwei'));
+      console.log("After DODO:" + fromWei(a_DODO, 'ether') + "; USDC:" + fromWei(a_USDC, 'mwei'));
       console.log("===============================================")
       var c_DODO = await ctx.DODO.methods.balanceOf(ctx.SmartSwap.options.address).call()
       var c_USDT = await ctx.USDT.methods.balanceOf(ctx.SmartSwap.options.address).call()
       var c_USDC = await ctx.USDC.methods.balanceOf(ctx.SmartSwap.options.address).call()
-      console.log("Contract DODO:" + fromWei(c_DODO,'ether') + "; USDT:" + fromWei(c_USDT,'mwei') + "; USDC:" + fromWei(c_USDC,'mwei'));
+      console.log("Contract DODO:" + fromWei(c_DODO, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei') + "; USDC:" + fromWei(c_USDC, 'mwei'));
     });
 
     it("DODO to WETH three hops swap", async () => {
       var b_DODO = await ctx.DODO.methods.balanceOf(trader).call()
       var b_WETH = await ctx.WETH.methods.balanceOf(trader).call()
-      console.log("Before DODO:" + fromWei(b_DODO,'ether') + "; WETH:" + fromWei(b_WETH,'ether'));
+      console.log("Before DODO:" + fromWei(b_DODO, 'ether') + "; WETH:" + fromWei(b_WETH, 'ether'));
       //approve DODO entry
-      await ctx.DODO.methods.approve(ctx.SmartApprove.options.address,MAX_UINT256).send(ctx.sendParam(trader))
+      await ctx.DODO.methods.approve(ctx.SmartApprove.options.address, MAX_UINT256).send(ctx.sendParam(trader))
       //set route path
       var routes = [{
         address: ctx.DODO.options.address,
         decimals: 18
-      },{
+      }, {
         address: ctx.USDT.options.address,
         decimals: 6
-      },{
+      }, {
         address: ctx.USDC.options.address,
         decimals: 6
-      },{
+      }, {
         address: ctx.WETH.options.address,
         decimals: 18
       }];
@@ -240,34 +239,168 @@ describe("Trader", () => {
       var pairs = [{
         pair: ctx.DODO_USDT.options.address,
         base: ctx.DODO.options.address,
-        /*only for test*/
         pairContract: ctx.DODO_USDT
-        /**************/
+      }, {
-      },{
         pair: ctx.USDT_USDC.options.address,
         base: ctx.USDT.options.address,
-        /*only for test*/
         pairContract: ctx.USDT_USDC
-        /**************/
+      }, {
-      },{
         pair: ctx.WETH_USDC.options.address,
         base: ctx.WETH.options.address,
-        /*only for test*/
         pairContract: ctx.WETH_USDC
-        /**************/
       }];
 
-      var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "three hops swap")
+      var tx = await logGas(await calcRoute(ctx, decimalStr('10'), 0.1, routes, pairs), ctx.sendParam(trader), "three hops swap")
       console.log(tx.events['TestAmount']);
       var a_DODO = await ctx.DODO.methods.balanceOf(trader).call()
       var a_WETH = await ctx.WETH.methods.balanceOf(trader).call()
-      console.log("After DODO:" + fromWei(a_DODO,'ether') + "; WETH:" + fromWei(a_WETH,'ether'));
+      console.log("After DODO:" + fromWei(a_DODO, 'ether') + "; WETH:" + fromWei(a_WETH, 'ether'));
       console.log("===============================================")
       var c_DODO = await ctx.DODO.methods.balanceOf(ctx.SmartSwap.options.address).call()
       var c_USDT = await ctx.USDT.methods.balanceOf(ctx.SmartSwap.options.address).call()
       var c_USDC = await ctx.USDC.methods.balanceOf(ctx.SmartSwap.options.address).call()
       var c_WETH = await ctx.WETH.methods.balanceOf(ctx.SmartSwap.options.address).call()
-      console.log("Contract DODO:" + fromWei(c_DODO,'ether') + "; USDT:" + fromWei(c_USDT,'mwei') + "; USDC:" + fromWei(c_USDC,'mwei') + "; WETH:" + fromWei(c_WETH,'ether'));
+      console.log("Contract DODO:" + fromWei(c_DODO, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei') + "; USDC:" + fromWei(c_USDC, 'mwei') + "; WETH:" + fromWei(c_WETH, 'ether'));
     });
+
+
+    it("ETH to USDT wrap eth and directly swap", async () => {
+      var b_ETH = await ctx.Web3.eth.getBalance(trader)
+      var b_WETH = await ctx.WETH.methods.balanceOf(trader).call()
+      var b_USDC = await ctx.USDC.methods.balanceOf(trader).call()
+      console.log("Before ETH:" + fromWei(b_ETH, 'ether') + "; WETH:" + fromWei(b_WETH, 'ether') + "; USDC:" + fromWei(b_USDC, 'mwei'));
+      var b_w_eth = await ctx.Web3.eth.getBalance(ctx.WETH.options.address)
+      console.log("weth contract Before:" + fromWei(b_w_eth, 'ether'))
+      //set route path
+      var routes = [{
+        address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+        decimals: 18
+      }, {
+        address: ctx.USDC.options.address,
+        decimals: 6
+      }];
+
+      var pairs = [{
+        pair: ctx.WETH_USDC.options.address,
+        base: ctx.WETH.options.address,
+        pairContract: ctx.WETH_USDC
+      }];
+
+      var tx = await logGas(await calcRoute(ctx, decimalStr('1'), 0.1, routes, pairs), ctx.sendParam(trader, '1'), "wrap eth and directly swap")
+      var a_ETH = await ctx.Web3.eth.getBalance(trader)
+      var a_WETH = await ctx.WETH.methods.balanceOf(trader).call()
+      var a_USDC = await ctx.USDC.methods.balanceOf(trader).call()
+      console.log("After ETH:" + fromWei(a_ETH, 'ether') + "; WETH:" + fromWei(a_WETH, 'ether') + "; USDC:" + fromWei(a_USDC, 'mwei'));
+      console.log("===============================================")
+      var c_ETH = await ctx.Web3.eth.getBalance(ctx.SmartSwap.options.address)
+      var c_WETH = await ctx.WETH.methods.balanceOf(ctx.SmartSwap.options.address).call()
+      var c_USDT = await ctx.USDT.methods.balanceOf(ctx.SmartSwap.options.address).call()
+      var c_USDC = await ctx.USDC.methods.balanceOf(ctx.SmartSwap.options.address).call()
+      console.log("Contract ETH:" + fromWei(c_ETH, 'ether') + "; WETH:" + fromWei(c_WETH, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei') + "; USDC:" + fromWei(c_USDC, 'mwei'));
+      var a_w_eth = await ctx.Web3.eth.getBalance(ctx.WETH.options.address)
+      console.log("weth contract After:" + fromWei(a_w_eth, 'ether'))
+    });
+
+
+    it("ETH to USDT wrap eth and two hops swap", async () => {
+      var b_ETH = await ctx.Web3.eth.getBalance(trader)
+      var b_WETH = await ctx.WETH.methods.balanceOf(trader).call()
+      var b_USDT = await ctx.USDT.methods.balanceOf(trader).call()
+      console.log("Before ETH:" + fromWei(b_ETH, 'ether') + "; WETH:" + fromWei(b_WETH, 'ether') + "; USDT:" + fromWei(b_USDT, 'mwei'));
+      var b_w_eth = await ctx.Web3.eth.getBalance(ctx.WETH.options.address)
+      console.log("weth contract Before:" + fromWei(b_w_eth, 'ether'))
+      //set route path
+      var routes = [{
+        address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+        decimals: 18
+      }, {
+        address: ctx.USDC.options.address,
+        decimals: 6
+      }, {
+        address: ctx.USDT.options.address,
+        decimals: 6
+      }];
+
+      var pairs = [{
+        pair: ctx.WETH_USDC.options.address,
+        base: ctx.WETH.options.address,
+        pairContract: ctx.WETH_USDC
+      }, {
+        pair: ctx.USDT_USDC.options.address,
+        base: ctx.USDT.options.address,
+        pairContract: ctx.USDT_USDC
+      }];
+
+      var tx = await logGas(await calcRoute(ctx, decimalStr('1'), 0.1, routes, pairs), ctx.sendParam(trader, '1'), "wrap eth and tow hops swap")
+      var a_ETH = await ctx.Web3.eth.getBalance(trader)
+      var a_WETH = await ctx.WETH.methods.balanceOf(trader).call()
+      var a_USDT = await ctx.USDT.methods.balanceOf(trader).call()
+      console.log("After ETH:" + fromWei(a_ETH, 'ether') + "; WETH:" + fromWei(a_WETH, 'ether') + "; USDT:" + fromWei(a_USDT, 'mwei'));
+      console.log("===============================================")
+      var c_ETH = await ctx.Web3.eth.getBalance(ctx.SmartSwap.options.address)
+      var c_WETH = await ctx.WETH.methods.balanceOf(ctx.SmartSwap.options.address).call()
+      var c_USDT = await ctx.USDT.methods.balanceOf(ctx.SmartSwap.options.address).call()
+      var c_USDC = await ctx.USDC.methods.balanceOf(ctx.SmartSwap.options.address).call()
+      console.log("Contract ETH:" + fromWei(c_ETH, 'ether') + "; WETH:" + fromWei(c_WETH, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei') + "; USDC:" + fromWei(c_USDC, 'mwei'));
+      var a_w_eth = await ctx.Web3.eth.getBalance(ctx.WETH.options.address)
+      console.log("weth contract After:" + fromWei(a_w_eth, 'ether'))
+    });
+
+
+    it("DODO to ETH unwrap eth and three hops swap", async () => {
+      var b_DODO = await ctx.DODO.methods.balanceOf(trader).call()
+      var b_ETH = await ctx.Web3.eth.getBalance(trader)
+      var b_WETH = await ctx.WETH.methods.balanceOf(trader).call()
+      console.log("User Before ETH:" + fromWei(b_ETH, 'ether') + "; WETH:" + fromWei(b_WETH, 'ether') + "; DODO:" + fromWei(b_DODO, 'ether'));
+      var b_w_eth = await ctx.Web3.eth.getBalance(ctx.WETH.options.address)
+      console.log("weth contract Before:" + fromWei(b_w_eth, 'ether'))
+
+      //approve DODO entry
+      await ctx.DODO.methods.approve(ctx.SmartApprove.options.address, MAX_UINT256).send(ctx.sendParam(trader))
+      //set route path
+      var routes = [{
+        address: ctx.DODO.options.address,
+        decimals: 18
+      }, {
+        address: ctx.USDT.options.address,
+        decimals: 6
+      }, {
+        address: ctx.USDC.options.address,
+        decimals: 6
+      }, {
+        address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+        decimals: 18
+      }];
+
+      var pairs = [{
+        pair: ctx.DODO_USDT.options.address,
+        base: ctx.DODO.options.address,
+        pairContract: ctx.DODO_USDT
+      }, {
+        pair: ctx.USDT_USDC.options.address,
+        base: ctx.USDT.options.address,
+        pairContract: ctx.USDT_USDC
+      }, {
+        pair: ctx.WETH_USDC.options.address,
+        base: ctx.WETH.options.address,
+        pairContract: ctx.WETH_USDC
+      }];
+
+      var tx = await logGas(await calcRoute(ctx, decimalStr('1000'), 0.1, routes, pairs), ctx.sendParam(trader), "unwrap eth and three hops swap")
+      var a_ETH = await ctx.Web3.eth.getBalance(trader)
+      var a_WETH = await ctx.WETH.methods.balanceOf(trader).call()
+      var a_DODO = await ctx.DODO.methods.balanceOf(trader).call()
+      console.log("After ETH:" + fromWei(a_ETH, 'ether') + "; WETH:" + fromWei(a_WETH, 'ether') + "; DODO:" + fromWei(a_DODO, 'ether'));
+      console.log("===============================================")
+      var c_ETH = await ctx.Web3.eth.getBalance(ctx.SmartSwap.options.address)
+      var c_WETH = await ctx.WETH.methods.balanceOf(ctx.SmartSwap.options.address).call()
+      var c_USDT = await ctx.USDT.methods.balanceOf(ctx.SmartSwap.options.address).call()
+      var c_USDC = await ctx.USDC.methods.balanceOf(ctx.SmartSwap.options.address).call()
+      var c_DODO = await ctx.DODO.methods.balanceOf(ctx.SmartSwap.options.address).call()
+      console.log("Contract ETH:" + fromWei(c_ETH, 'ether') + "; WETH:" + fromWei(c_WETH, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei') + "; USDC:" + fromWei(c_USDC, 'mwei') + "; DODO:" + fromWei(c_DODO, "ether"));
+      var w_eth = await ctx.Web3.eth.getBalance(ctx.WETH.options.address)
+      console.log("weth contract After:" + fromWei(w_eth, 'ether'))
+    });
+
   });
 });

test/utils-v1/Context-route.ts

@@ -58,10 +58,10 @@ export class DODOContext {
   mtFeeRate: string;
   k: string;
   //token
-  DODO:Contract;
+  DODO: Contract;
-  USDT:Contract;
+  USDT: Contract;
-  USDC:Contract;
+  USDC: Contract;
-  WETH:Contract;
+  WETH: Contract;
   //pair
   DODO_USDT: Contract;
   USDT_USDC: Contract;
@@ -74,7 +74,7 @@ export class DODOContext {
   SmartApprove: Contract;
   DODOSellHelper: Contract;
 
-  constructor() {}
+  constructor() { }
 
   async init(config: DODOContextInitConfig) {
     this.k = config.k;
@@ -116,9 +116,10 @@ export class DODOContext {
       ["USDC", 6]
     );
     this.WETH = await contracts.newContract(
-      contracts.TEST_ERC20_CONTRACT_NAME,
+      contracts.WETH_CONTRACT_NAME
-      ["WETH", 18]
     );
+
+
     //创建交易对
     //DODO-USDT
     this.DODO_USDT_ORACLE = await contracts.newContract(
@@ -223,7 +224,7 @@ export class DODOContext {
 
     this.SmartSwap = await contracts.newContract(
       contracts.SMART_SWAP,
-      [this.SmartApprove.options.address,this.DODOSellHelper.options.address]
+      [this.SmartApprove.options.address, this.DODOSellHelper.options.address, this.WETH.options.address]
     );
 
     await this.SmartApprove.methods.setSmartSwap(this.SmartSwap.options.address).send(this.sendParam(this.Deployer));
@@ -240,20 +241,21 @@ export class DODOContext {
     };
   }
 
-  async setOraclePrice(oracle:Contract,price: string) {
+  async setOraclePrice(oracle: Contract, price: string) {
     await oracle.methods
       .setPrice(price)
       .send(this.sendParam(this.Deployer));
   }
 
-  async mintToken(tokenBase:Contract,tokenQuote:Contract,to: string, base: string, quote: string) {
+  async mintToken(tokenBase: Contract, tokenQuote: Contract, to: string, base: string, quote: string) {
-    await tokenBase.methods.mint(to, base).send(this.sendParam(this.Deployer));
+    if (tokenBase != null)
-    await tokenQuote.methods
+      await tokenBase.methods.mint(to, base).send(this.sendParam(this.Deployer));
-      .mint(to,  quote)
+    if (tokenQuote != null)
-      .send(this.sendParam(this.Deployer));
+      await tokenQuote.methods.mint(to, quote).send(this.sendParam(this.Deployer));
   }
 
-  async approvePair(tokenBase:Contract,tokenQuote:Contract, approveTarget:string,account: string) {
+
+  async approvePair(tokenBase: Contract, tokenQuote: Contract, approveTarget: string, account: string) {
     await tokenBase.methods
       .approve(approveTarget, MAX_UINT256)
       .send(this.sendParam(account));

test/utils-v1/Contracts.ts

@@ -17,7 +17,6 @@ const CloneFactory = require(`${jsonPath}CloneFactory.json`)
 const DODO = require(`${jsonPath}DODO.json`)
 const DODOZoo = require(`${jsonPath}DODOZoo.json`)
 const DODOEthProxy = require(`${jsonPath}DODOEthProxy.json`)
-const WETH = require(`${jsonPath}WETH9.json`)
 const TestERC20 = require(`${jsonPath}TestERC20.json`)
 const NaiveOracle = require(`${jsonPath}NaiveOracle.json`)
 const DODOLpToken = require(`${jsonPath}DODOLpToken.json`)
@@ -31,6 +30,7 @@ const LockedTokenVault = require(`${jsonPath}LockedTokenVault.json`)
 const SmartSwap = require(`${jsonPath2}SmartSwap.json`)
 const SmartApprove = require(`${jsonPath2}SmartApprove.json`)
 const DODOSellHelper = require(`${jsonPath2}DODOSellHelper.json`)
+const WETH = require(`${jsonPath2}WETH9.json`)
 /******/
 
 import { getDefaultWeb3 } from './EVM';