route and wrap and unwrap eth && test

2020-11-13 15:48:55 +08:00
parent 69658fc9fa
commit abd2b8aea2
13 changed files with 643 additions and 34 deletions
--- a/contracts/DODOVendorMachine/impl/DVM.sol
+++ b/contracts/DODOVendorMachine/impl/DVM.sol
@@ -13,7 +13,7 @@ import {IPermissionManager} from "../../lib/PermissionManager.sol";
 import {IGasPriceSource} from "../../lib/GasPriceSource.sol";
 import {DVMTrader} from "./DVMTrader.sol";
 import {DVMFunding} from "./DVMFunding.sol";
-import {DVMVault} from "./DVMVault.sol";
+import {IDVMVault} from "../intf/IDVMVault.sol";

 contract DVM is DVMTrader, DVMFunding {
    function init(
@@ -28,7 +28,7 @@ contract DVM is DVMTrader, DVMFunding {
        uint256 k
    ) external {
        initOwner(owner);
-        _VAULT_ = DVMVault(vault);
+        _VAULT_ = IDVMVault(vault);
        _BASE_TOKEN_ = _VAULT_._BASE_TOKEN_();
        _QUOTE_TOKEN_ = _VAULT_._QUOTE_TOKEN_();
        _LP_FEE_RATE_MODEL_ = IFeeRateModel(lpFeeRateModel);
--- a/contracts/DODOVendorMachine/intf/IDVMVault.sol
+++ b/contracts/DODOVendorMachine/intf/IDVMVault.sol
@@ -19,9 +19,9 @@ interface IDVMVault {

    function _QUOTE_TOKEN_() external returns (address);

-    function _BASE_RESERVE_() external returns (address);
+    function _BASE_RESERVE_() external returns (uint256);

-    function _QUOTE_RESERVE_() external returns (address);
+    function _QUOTE_RESERVE_() external returns (uint256);

    function symbol() external returns (string memory);

--- a/contracts/DODOZoo.sol
+++ b/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;
+    }
+}
--- a/contracts/SmartRoute/SmartSwap.sol
+++ b/contracts/SmartRoute/SmartSwap.sol
@@ -15,6 +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 {
@@ -25,6 +26,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,9 +38,15 @@ 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 {
+        require(msg.sender == _WETH_, "WE_CAN_NOT_SAVED_YOUR_ETH");
    }

    function dodoSwap(
@@ -54,6 +62,9 @@ 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++) {
@@ -73,6 +84,12 @@ contract SmartSwap is Ownable {
            }
        }
        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");
--- a/contracts/helper/CloneFactory.sol
+++ b/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;
+    }
+}
--- a/contracts/helper/NativeOracle.sol
+++ b/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;
+    }
+}
--- a/contracts/helper/TestERC20.sol
+++ b/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);
+    }
+}
--- a/contracts/helper/TestWETH.sol
+++ b/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;
+    }
+}
--- a/deploy-detail.txt
+++ b/deploy-detail.txt
@@ -1,8 +1,3 @@
 ====================================================
-network type: kovan
-Deploy time: 2020/11/12 上午9:38:54
-Deploy type: Smart Route
-SmartApprove Address:  0x8D2625d0f1ed3C7E1E506Bf86b4660c1781Fd7C0
-DODOSellHelper Address:  0xbdEae617F2616b45DCB69B287D52940a76035Fe3
-SmartSwap Address:  0xC1632dD29D5c4ac1Cd7b9B7d1e23E91bB092acAC
-SmartApprovce setSmartSwap tx:  0x2e641cd363b3c42579308502dbca07e45377032fb52ae5f1acbd0d865d0ce7e3
+network type: development
+Deploy time: 2020/11/13 下午3:47:21
--- a/migrations/2_deploy.js
+++ b/migrations/2_deploy.js
@@ -5,15 +5,25 @@ 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_ROUTE = false;
+const DEPLOY_KOVAN_TOKEN = false;

-module.exports = async (deployer, network) => {
+module.exports = async (deployer, network,accounts) => {
  let DODOSellHelperAddress = ""
+  let DODOZooAddress = ""
+  let WETHAddress = ""
  if(network == 'kovan'){
    DODOSellHelperAddress = "0xbdEae617F2616b45DCB69B287D52940a76035Fe3";
+    DODOZooAddress = "0x92230e929a2226b29ed3441ae5524886347c60c8";
+    WETHAddress = "0x5eca15b12d959dfcf9c71c59f8b467eb8c6efd0b";
  }else {
-    DODOSellHelperAddress = "";
+    DODOSellHelperAddress = "0x533da777aedce766ceae696bf90f8541a4ba80eb";
+    DODOZooAddress = "0x3a97247df274a17c59a3bd12735ea3fcdfb49950";
+    WETHAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
  }

  logger.log("====================================================");
@@ -37,6 +47,103 @@ module.exports = async (deployer, network) => {
    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 
+  }
+
 };


--- a/test/Route/Route.test.ts
+++ b/test/Route/Route.test.ts
@@ -26,14 +26,14 @@ async function initDODO_USDT(ctx: DODOContext): Promise<void> {
  await ctx.approvePair(DODO,USDT,DODO_USDT.options.address,lp);
  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,trader, decimalStr("100"), mweiStr("0"));
+  await ctx.mintToken(DODO,USDT, lp, decimalStr("10000000"), mweiStr("1000000"));
+  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));
 }

@@ -47,13 +47,13 @@ async function initUSDT_USDC(ctx: DODOContext): Promise<void> {
  let USDT_USDC = ctx.USDT_USDC;

  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));
 }

@@ -68,13 +68,14 @@ async function initWETH_USDC(ctx: DODOContext): Promise<void> {
  let WETH_USDC = ctx.WETH_USDC;

  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));
 }

@@ -89,7 +90,11 @@ async function calcRoute(ctx: DODOContext,fromTokenAmount:string,slippage:number
    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);
+    }else if (curPair.base === routes[i].address) {
      directions[i] = 0;
      swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call();
      console.log(i + "-swapAmount:",swapAmount);
@@ -257,5 +262,145 @@ describe("Trader", () => {
      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'));
    });
+
+
+    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'))
+    });
+
  });
 });
--- a/test/utils-v1/Context-route.ts
+++ b/test/utils-v1/Context-route.ts
@@ -116,9 +116,10 @@ export class DODOContext {
      ["USDC", 6]
    );
    this.WETH = await contracts.newContract(
-      contracts.TEST_ERC20_CONTRACT_NAME,
-      ["WETH", 18]
+      contracts.WETH_CONTRACT_NAME
    );
+
+
    //创建交易对
    //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));
@@ -247,12 +248,13 @@ export class DODOContext {
  }

  async mintToken(tokenBase:Contract,tokenQuote:Contract,to: string, base: string, quote: string) {
-    await tokenBase.methods.mint(to, base).send(this.sendParam(this.Deployer));
-    await tokenQuote.methods
-      .mint(to,  quote)
-      .send(this.sendParam(this.Deployer));
+    if(tokenBase != null)
+      await tokenBase.methods.mint(to, base).send(this.sendParam(this.Deployer));
+    if(tokenQuote != null)
+      await tokenQuote.methods.mint(to,  quote).send(this.sendParam(this.Deployer));
  }

+
  async approvePair(tokenBase:Contract,tokenQuote:Contract, approveTarget:string,account: string) {
    await tokenBase.methods
      .approve(approveTarget, MAX_UINT256)
--- a/test/utils-v1/Contracts.ts
+++ b/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';