dvm proxy test ing

contracts/DODOVendingMachine/impl/DVM.sol

@@ -30,7 +30,6 @@ contract DVM is DVMTrader, DVMFunding {
         uint256 k
     ) external {
         initOwner(owner);
-        _ADMIN_ = owner;
         _BASE_TOKEN_ = IERC20(baseTokenAddress);
         _QUOTE_TOKEN_ = IERC20(quoteTokenAddress);
         _LP_FEE_RATE_MODEL_ = IFeeRateModel(lpFeeRateModel);

contracts/DODOVendingMachine/impl/DVMFunding.sol

@@ -28,26 +28,25 @@ contract DVMFunding is DVMVault {
         require(baseInput > 0, "NO_BASE_INPUT");
         uint256 baseReserve = _BASE_RESERVE_;
         uint256 quoteReserve = _QUOTE_RESERVE_;
-        uint256 mintAmount;
         // case 1. initial supply
         // 包含了 baseReserve == 0 && quoteReserve == 0 的情况
         // 在提币的时候向下取整。因此永远不会出现，balance为0但totalsupply不为0的情况
         // 但有可能出现，reserve>0但totalSupply=0的场景
         if (totalSupply == 0) {
-            mintAmount = getBaseBalance(); // 以免出现balance很大但shares很小的情况
+            shares = getBaseBalance(); // 以免出现balance很大但shares很小的情况
         } else if (baseReserve > 0 && quoteReserve == 0) {
             // case 2. supply when quote reserve is 0
-            mintAmount = baseInput.mul(totalSupply).div(baseReserve);
+            shares = baseInput.mul(totalSupply).div(baseReserve);
         } else if (baseReserve > 0 && quoteReserve > 0) {
             // case 3. normal case
             uint256 baseInputRatio = DecimalMath.divFloor(baseInput, baseReserve);
             uint256 quoteInputRatio = DecimalMath.divFloor(quoteInput, quoteReserve);
             uint256 mintRatio = quoteInputRatio < baseInputRatio ? quoteInputRatio : baseInputRatio;
-            mintAmount = DecimalMath.mulFloor(totalSupply, mintRatio);
+            shares = DecimalMath.mulFloor(totalSupply, mintRatio);
         }
-        _mint(to, mintAmount);
+        _mint(to, shares);
         _sync();
-        return (mintAmount, baseInput, quoteInput);
+        return (shares, baseInput, quoteInput);
     }
 
     // withdraw amount [round down]

contracts/DODOVendingMachine/impl/DVMStorage.sol

@@ -21,8 +21,6 @@ import {IERC20} from "../../intf/IERC20.sol";
 contract DVMStorage is InitializableOwnable, ReentrancyGuard {
     using SafeMath for uint256;
 
-    address public _ADMIN_;
-
     // ============ Variables for Control ============
 
     IExternalValue public _GAS_PRICE_LIMIT_;

contracts/SmartRoute/DODOV2Proxy01.sol

@@ -44,8 +44,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
         uint256 returnAmount,
         uint256 timeStamp
     );
-
-    event ExternalRecord(address indexed to, address indexed sender);
     //========================================================================
 
     constructor(
@@ -62,8 +60,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
         dodoSellHelper = _dodoSellHelper;
     }
     
-    //TODO:ETH
     function createDODOVendingMachine(
+        address assetTo,
         address baseToken,
         address quoteToken,
         uint256 baseInAmount,
@@ -74,13 +72,30 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
         uint256 k,
         uint256 deadline
     ) external virtual override payable judgeExpired(deadline) returns (address newVendingMachine,uint256 shares) {
-        require(k > 0 && k<= 10**18, 'DODOV2Proxy01: K OUT OF RANGE');
+        {
-        newVendingMachine = IDODOV2(dvmFactory).createDODOVendingMachine(msg.sender, baseToken,quoteToken,lpFeeRate,mtFeeRate,i,k);
+        address _baseToken = baseToken == ETH_ADDRESS ? _WETH_ : baseToken;
-        if(baseInAmount > 0) 
+        address _quoteToken = quoteToken == ETH_ADDRESS ? _WETH_ : quoteToken;
-            IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newVendingMachine, baseInAmount);
+        newVendingMachine = IDODOV2(dvmFactory).createDODOVendingMachine(msg.sender, _baseToken, _quoteToken, lpFeeRate, mtFeeRate, i, k);
-        if(quoteInAmount > 0)
+        }
-            IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newVendingMachine, quoteInAmount);
+        if(baseInAmount > 0){
-        (shares,,) = IDODOV2(newVendingMachine).buyShares(msg.sender);
+            if(baseToken != ETH_ADDRESS){
+                IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newVendingMachine, baseInAmount);
+            }else {
+                require(msg.value == baseInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
+                IWETH(_WETH_).deposit{value: baseInAmount}();
+                assert(IWETH(_WETH_).transfer(newVendingMachine, baseInAmount));
+            }
+        }
+        if(quoteInAmount > 0){
+            if(quoteToken != ETH_ADDRESS){
+                IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newVendingMachine, quoteInAmount);
+            }else {
+                require(msg.value == quoteInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
+                IWETH(_WETH_).deposit{value: quoteInAmount}();
+                assert(IWETH(_WETH_).transfer(newVendingMachine, quoteInAmount));
+            }
+        }
+        (shares,,) = IDODOV2(newVendingMachine).buyShares(assetTo);
     }
 
 
@@ -112,7 +127,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
         }
     }
 
-    //TODO:ETH 
     function addDVMLiquidity(
         address DVMAddress,
         address to,
@@ -121,18 +135,52 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
         uint256 baseMinAmount,
         uint256 quoteMinAmount,
         uint256 deadline
-    ) external virtual override payable judgeExpired(deadline) returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount) {
+    ) external virtual override judgeExpired(deadline) returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount) {
         (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount);
         address _dvm = DVMAddress;
-        if(baseAdjustedInAmount > 0)
+        if(baseAdjustedInAmount > 0) {
             IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._BASE_TOKEN_(), msg.sender, _dvm, baseAdjustedInAmount);
+        }
         if(quoteAdjustedInAmount > 0)
             IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._QUOTE_TOKEN_(), msg.sender, _dvm, quoteAdjustedInAmount);
         (shares,baseActualInAmount,quoteActualInAmount) = IDODOV2(_dvm).buyShares(to);
         require(baseActualInAmount >= baseMinAmount && quoteActualInAmount >= quoteMinAmount, 'DODOV2Proxy01: deposit amount is not enough');
     }
 
-    //TODO:ETH 构造data
+    function addDVMLiquidityETH(
+        address DVMAddress,
+        address to,
+        uint256 baseInAmount,
+        uint256 quoteInAmount,
+        uint256 baseMinAmount,
+        uint256 quoteMinAmount,
+        uint8 flag, // 1 - baseInETH, 2 - quoteInETH
+        uint256 deadline
+    ) external virtual override payable judgeExpired(deadline) returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount) {
+        (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount);
+        address _dvm = DVMAddress;
+        if(baseAdjustedInAmount > 0) {
+            if(flag == 1) {
+                require(msg.value >= baseAdjustedInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
+                IWETH(_WETH_).deposit{value: baseAdjustedInAmount}();
+                assert(IWETH(_WETH_).transfer(_dvm, baseAdjustedInAmount));
+            }else {
+                IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._BASE_TOKEN_(), msg.sender, _dvm, baseAdjustedInAmount);
+            }
+        }
+        if(quoteAdjustedInAmount > 0){
+            if(flag == 2) {
+                require(msg.value >= quoteAdjustedInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
+                IWETH(_WETH_).deposit{value: quoteAdjustedInAmount}();
+                assert(IWETH(_WETH_).transfer(_dvm, quoteAdjustedInAmount)); 
+            }else {
+              IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._QUOTE_TOKEN_(), msg.sender, _dvm, quoteAdjustedInAmount);  
+            }
+        }
+        (shares,baseActualInAmount,quoteActualInAmount) = IDODOV2(_dvm).buyShares(to);
+        require(baseActualInAmount >= baseMinAmount && quoteActualInAmount >= quoteMinAmount, 'DODOV2Proxy01: deposit amount is not enough');
+    }
+
     function removeDVMLiquidity(
         address DVMAddress,
         address to,
@@ -140,9 +188,9 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
         uint256 baseOutMinAmount,
         uint256 quoteOutMinAmount,
         uint256 deadline
-    ) external virtual override payable judgeExpired(deadline) returns (uint256 baseOutAmount,uint256 quoteOutAmount) {
+    ) external virtual override judgeExpired(deadline) returns (uint256 baseOutAmount,uint256 quoteOutAmount) {
         require(shares > 0, 'DODOV2Proxy01: Insufficient_Liquidity');
-        (baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(to, shares, "");
+        (baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(to);
         require(baseOutAmount >= baseOutMinAmount && quoteOutAmount >= quoteOutMinAmount,'DODOV2Proxy01: withdraw amount is not enough');
     }
 
@@ -292,8 +340,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
         }
     }
 
-    function dodoSwap(
+    function dodoSwapETHToToken(
-        address fromToken,
+        address payable assetTo,
         address toToken,
         uint256 fromTokenAmount,
         uint256 minReturnAmount,
@@ -301,42 +349,95 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
         uint256[] memory directions,
         uint256 deadline
     ) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) {
-        require(minReturnAmount > 0, "DODOV2Proxy01: Min return should be bigger than 0.");
+        require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.');
-        require(dodoPairs.length > 0, "DODOV2Proxy01: pairs should exists.");
+        require(msg.value == fromTokenAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
-
+        IWETH(_WETH_).deposit{value: fromTokenAmount}();
-        if (fromToken != ETH_ADDRESS) {
+        IWETH(_WETH_).transfer(dodoPairs[0],IWETH(_WETH_).balanceOf(address(this)));
-            IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
-        } else {
-            require(msg.value == fromTokenAmount, "DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH");
-            IWETH(_WETH_).deposit{value: fromTokenAmount}();
-            IWETH(_WETH_).transfer(dodoPairs[0],IWETH(_WETH_).balanceOf(address(this)));
-        }
 
         for (uint256 i = 0; i < dodoPairs.length; i++) {
-            address curTo;
             if(i == dodoPairs.length - 1){
-                curTo = address(this);
+                if (directions[i] == 0) {
+                    returnAmount = IDODOV2(dodoPairs[i]).sellBase(assetTo);
+                } else {
+                    returnAmount = IDODOV2(dodoPairs[i]).sellQuote(assetTo);
+                }
             } else {
-                curTo = dodoPairs[i+1];
+                if (directions[i] == 0) {
-            }
+                    IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i+1]);
-            if (directions[i] == 0) {
+                } else {
-                IDODOV2(dodoPairs[i]).sellBase(curTo);
+                    IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i+1]);
-            } else {
+                }
-                IDODOV2(dodoPairs[i]).sellQuote(curTo);
             }
         }
-        IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this)));
+        require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough');
+        emit OrderHistory(ETH_ADDRESS, toToken, assetTo, fromTokenAmount, returnAmount, block.timestamp);
+    }
 
-        if (toToken == ETH_ADDRESS) {
+    function dodoSwapTokenToETH(
-            uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this));
+        address payable assetTo,
-            IWETH(_WETH_).withdraw(wethAmount);
+        address fromToken,
+        uint256 fromTokenAmount,
+        uint256 minReturnAmount,
+        address[] memory dodoPairs,
+        uint256[] memory directions,
+        uint256 deadline
+    ) external virtual override judgeExpired(deadline) returns (uint256 returnAmount) {
+        require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.');
+        IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
+
+        for (uint256 i = 0; i < dodoPairs.length; i++) {
+            if(i == dodoPairs.length - 1){
+                if (directions[i] == 0) {
+                    IDODOV2(dodoPairs[i]).sellBase(address(this));
+                } else {
+                    IDODOV2(dodoPairs[i]).sellQuote(address(this));
+                }
+            } else {
+                if (directions[i] == 0) {
+                    IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i+1]);
+                } else {
+                    IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i+1]);
+                }
+            }
         }
+        returnAmount = IWETH(_WETH_).balanceOf(address(this));
+        IWETH(_WETH_).withdraw(returnAmount);
+        require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough');
+        IERC20(ETH_ADDRESS).universalTransfer(assetTo, returnAmount);
+        emit OrderHistory(fromToken, ETH_ADDRESS, assetTo, fromTokenAmount, returnAmount, block.timestamp);
+    }
 
-        returnAmount = IERC20(toToken).universalBalanceOf(address(this));
 
-        require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough");
+    function dodoSwapTokenToToken(
-        IERC20(toToken).universalTransfer(msg.sender, returnAmount);
+        address payable assetTo,
-        emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
+        address fromToken,
+        address toToken,
+        uint256 fromTokenAmount,
+        uint256 minReturnAmount,
+        address[] memory dodoPairs,
+        uint256[] memory directions,
+        uint256 deadline
+    ) external virtual override judgeExpired(deadline) returns (uint256 returnAmount) {
+        require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.');
+        IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
+
+        for (uint256 i = 0; i < dodoPairs.length; i++) {
+            if(i == dodoPairs.length - 1){
+                if (directions[i] == 0) {
+                    returnAmount = IDODOV2(dodoPairs[i]).sellBase(assetTo);
+                } else {
+                    returnAmount = IDODOV2(dodoPairs[i]).sellQuote(assetTo);
+                }
+            } else {
+                if (directions[i] == 0) {
+                    IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i+1]);
+                } else {
+                    IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i+1]);
+                }
+            }
+        }
+        require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough');
+        emit OrderHistory(fromToken, toToken, assetTo, fromTokenAmount, returnAmount, block.timestamp);
     }
 
     function externalSwap(
@@ -344,32 +445,26 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
         address toToken,
         address approveTarget,
         address to,
-        uint256 gasSwap,
         uint256 fromTokenAmount,
         uint256 minReturnAmount,
         bytes memory callDataConcat,
         uint256 deadline
     ) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) {
-        
+        require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger then 0.');
-        require(minReturnAmount > 0, "DODOV2Proxy01: Min return should be bigger then 0.");
-
         if (fromToken != ETH_ADDRESS) {
             IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
             IERC20(fromToken).universalApprove(approveTarget, fromTokenAmount);
         }
 
-        (bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0, gas: gasSwap}(
+        (bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0}(callDataConcat);
-            callDataConcat
-        );
 
-        require(success, "DODOV2Proxy01: Contract Swap execution Failed");
+        require(success, 'DODOV2Proxy01: Contract Swap execution Failed');
 
         IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this)));
         returnAmount = IERC20(toToken).universalBalanceOf(address(this));
 
-        require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough");
+        require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough');
         IERC20(toToken).universalTransfer(msg.sender, returnAmount);
         emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
-        emit ExternalRecord(to, msg.sender);
     }
 }

contracts/intf/IDODOV2Proxy01.sol

@@ -11,8 +11,8 @@ pragma experimental ABIEncoderV2;
 import {IERC20} from "./IERC20.sol";
 
 interface IDODOV2Proxy01 {
-	function dodoSwap(
+	function dodoSwapETHToToken(
-        address fromToken,
+        address payable assetTo,
         address toToken,
         uint256 fromTokenAmount,
         uint256 minReturnAmount,
@@ -21,13 +21,32 @@ interface IDODOV2Proxy01 {
         uint256 deadline
     ) external payable returns (uint256 returnAmount);
 
+    function dodoSwapTokenToETH(
+        address payable assetTo,
+        address fromToken,
+        uint256 fromTokenAmount,
+        uint256 minReturnAmount,
+        address[] memory dodoPairs,
+        uint256[] memory directions,
+        uint256 deadline
+    ) external returns (uint256 returnAmount);
+
+    function dodoSwapTokenToToken(
+        address payable assetTo,
+        address fromToken,
+        address toToken,
+        uint256 fromTokenAmount,
+        uint256 minReturnAmount,
+        address[] memory dodoPairs,
+        uint256[] memory directions,
+        uint256 deadline
+    ) external returns (uint256 returnAmount);
 
     function externalSwap(
         address fromToken,
         address toToken,
         address approveTarget,
         address to,
-        uint256 gasSwap,
         uint256 fromTokenAmount,
         uint256 minReturnAmount,
         bytes memory callDataConcat,
@@ -36,6 +55,7 @@ interface IDODOV2Proxy01 {
 
     
     function createDODOVendingMachine(
+        address assetTo,
         address baseToken,
         address quoteToken,
         uint256 baseInAmount,
@@ -56,6 +76,17 @@ interface IDODOV2Proxy01 {
         uint256 baseMinAmount,
         uint256 quoteMinAmount,
         uint256 deadline
+    ) external returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount);
+
+    function addDVMLiquidityETH(
+        address DVMAddress,
+        address to,
+        uint256 baseInAmount,
+        uint256 quoteInAmount,
+        uint256 baseMinAmount,
+        uint256 quoteMinAmount,
+        uint8 flag, // 1 - baseInETH, 2 - quoteInETH
+        uint256 deadline
     ) external payable returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount);
 
     
@@ -66,7 +97,7 @@ interface IDODOV2Proxy01 {
         uint256 baseOutMinAmount,
         uint256 quoteOutMinAmount,
         uint256 deadline
-    ) external payable returns (uint256 baseOutAmount,uint256 quoteOutAmount);
+    ) external returns (uint256 baseOutAmount,uint256 quoteOutAmount);
 
 
     function createDODOPrivatePool(

test/Proxy/proxy.dpp.test.ts

@@ -7,7 +7,7 @@
 
 // import * as assert from 'assert';
 import BigNumber from "bignumber.js";
-import { decimalStr, mweiStr} from '../utils/Converter';
+import { decimalStr, mweiStr } from '../utils/Converter';
 import { logGas } from '../utils/Log';
 import { ProxyContext, getProxyContext } from '../utils/ProxyContext';
 import { assert } from 'chai';
@@ -30,12 +30,11 @@ async function init(ctx: ProxyContext): Promise<void> {
   project = ctx.SpareAccounts[1];
   trader = ctx.SpareAccounts[2];
 
-  await ctx.mintTestToken(lp, ctx.DODO, decimalStr("100000"));
+  await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000000"));
-  await ctx.mintTestToken(project, ctx.DODO, decimalStr("100000"));
+  await ctx.mintTestToken(project, ctx.DODO, decimalStr("1000000"));
-  await ctx.mintTestToken(trader, ctx.DODO, decimalStr("100000"));
 
-  await ctx.mintTestToken(lp, ctx.USDT, mweiStr("100000"));
+  await ctx.mintTestToken(lp, ctx.USDT, mweiStr("1000000"));
-  await ctx.mintTestToken(project, ctx.USDT, mweiStr("100000"));
+  await ctx.mintTestToken(project, ctx.USDT, mweiStr("1000000"));
 
   // await ctx.WETH.methods.deposit().send(ctx.sendParam(lp, '80'));
   // await ctx.WETH.methods.deposit().send(ctx.sendParam(project, '80'));
@@ -46,7 +45,7 @@ async function init(ctx: ProxyContext): Promise<void> {
 }
 
 
-async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string): Promise<string> {
+async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string,i:string): Promise<string> {
   let PROXY = ctx.DODOProxy;
   await PROXY.methods.createDODOPrivatePool(
     token0,
@@ -55,7 +54,7 @@ async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, t
     token1Amount,
     config.lpFeeRate,
     config.mtFeeRate,
-    config.i,
+    i,
     config.k,
     Math.floor(new Date().getTime()/1000 + 60 * 10)
   ).send(ctx.sendParam(project,ethValue));
@@ -76,9 +75,9 @@ describe("DODOProxyV2.0", () => {
   before(async () => {
     ctx = await getProxyContext();
     await init(ctx);
-    dpp_DODO_USDT = await initCreateDPP(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("10000"),mweiStr("10000"), "0");
+    dpp_DODO_USDT = await initCreateDPP(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("100000"),mweiStr("30000"), "0",mweiStr("0.3"));
     DPP_DODO_USDT = contracts.getContractWithAddress(contracts.DPP_NAME,dpp_DODO_USDT);
-    dpp_WETH_USDT = await initCreateDPP(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("5"),mweiStr("10000"),"5");
+    dpp_WETH_USDT = await initCreateDPP(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("5"),mweiStr("30000"),"5",mweiStr("600"));
     DPP_WETH_USDT = contracts.getContractWithAddress(contracts.DPP_NAME,dpp_WETH_USDT);
     console.log("dpp_DODO_USDT:",dpp_DODO_USDT);
     console.log("dpp_WETH_USDT:",dpp_WETH_USDT);
@@ -110,17 +109,17 @@ describe("DODOProxyV2.0", () => {
         Math.floor(new Date().getTime()/1000 + 60 * 10)
       ),ctx.sendParam(project),"createDPP");
       var addrs = await ctx.DPPFactory.methods.getPrivatePool(baseToken,quoteToken).call();
-      var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[0]).call();
+      var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[1]).call();
       assert.equal(
         dppInfo[0],
         project
       );
       assert.equal(
-        await ctx.DODO.methods.balanceOf(addrs[0]).call(),
+        await ctx.DODO.methods.balanceOf(addrs[1]).call(),
         baseAmount
       );
       assert.equal(
-        await ctx.USDT.methods.balanceOf(addrs[0]).call(),
+        await ctx.USDT.methods.balanceOf(addrs[1]).call(),
         quoteAmount
       );
     });
@@ -143,17 +142,17 @@ describe("DODOProxyV2.0", () => {
         Math.floor(new Date().getTime()/1000 + 60 * 10)
       ),ctx.sendParam(project, "5"),"createDPP - Wrap ETH");
       var addrs = await ctx.DPPFactory.methods.getPrivatePool(ctx.WETH.options.address,quoteToken).call();
-      var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[0]).call();
+      var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[1]).call();
       assert.equal(
         dppInfo[0],
         project
       );
       assert.equal(
-        await ctx.WETH.methods.balanceOf(addrs[0]).call(),
+        await ctx.WETH.methods.balanceOf(addrs[1]).call(),
         baseAmount
       );
       assert.equal(
-        await ctx.USDT.methods.balanceOf(addrs[0]).call(),
+        await ctx.USDT.methods.balanceOf(addrs[1]).call(),
         quoteAmount
       );
     });
@@ -161,13 +160,13 @@ describe("DODOProxyV2.0", () => {
     it("resetDPP", async () => {
       var beforeState = await DPP_DODO_USDT.methods.getPMMState().call();
       assert.equal(beforeState.K,config.k);
-      assert.equal(beforeState.B0,decimalStr("10000"));
+      assert.equal(beforeState.B0,decimalStr("100000"));
-      assert.equal(beforeState.Q0,mweiStr("10000"));
+      assert.equal(beforeState.Q0,mweiStr("30000"));
       await logGas(await ctx.DODOProxy.methods.resetDODOPrivatePool(
         dpp_DODO_USDT,
         config.lpFeeRate,
         config.mtFeeRate,
-        config.i,
+        mweiStr("0.3"),
         decimalStr("0.2"),
         decimalStr("1000"),
         mweiStr("1000"),
@@ -177,21 +176,22 @@ describe("DODOProxyV2.0", () => {
       ),ctx.sendParam(project),"resetDPP");
       var afterState = await DPP_DODO_USDT.methods.getPMMState().call();
       assert.equal(afterState.K,decimalStr("0.2"));
-      assert.equal(afterState.B0,decimalStr("11000"));
+      assert.equal(afterState.B0,decimalStr("101000"));
-      assert.equal(afterState.Q0,mweiStr("11000"));
+      assert.equal(afterState.Q0,mweiStr("31000"));
     });
 
+
     it("resetDPP - OutETH", async () => {
       var beforeState = await DPP_WETH_USDT.methods.getPMMState().call();
       assert.equal(beforeState.K,config.k);
       assert.equal(beforeState.B0,decimalStr("5"));
-      assert.equal(beforeState.Q0,mweiStr("10000"));
+      assert.equal(beforeState.Q0,mweiStr("30000"));
       var b_ETH = await ctx.Web3.eth.getBalance(project);
       var tx = await logGas(await ctx.DODOProxy.methods.resetDODOPrivatePoolETH(
         dpp_WETH_USDT,
         config.lpFeeRate,
         config.mtFeeRate,
-        config.i,
+        mweiStr("600"),
         decimalStr("0.2"),
         decimalStr("0"),
         mweiStr("1000"),
@@ -199,16 +199,172 @@ describe("DODOProxyV2.0", () => {
         mweiStr("0"),
         3,
         Math.floor(new Date().getTime()/1000 + 60 * 10)
-      ),ctx.sendParam(project),"resetDPP-ETH");
+      ),ctx.sendParam(project),"resetDPP-OutETH");
       var afterState = await DPP_WETH_USDT.methods.getPMMState().call();
       assert.equal(afterState.K,decimalStr("0.2"));
       assert.equal(afterState.B0,decimalStr("4"));
-      assert.equal(afterState.Q0,mweiStr("11000"));
+      assert.equal(afterState.Q0,mweiStr("31000"));
       var a_ETH = await ctx.Web3.eth.getBalance(project);
       console.log("b_ETH:",b_ETH);
       console.log("a_ETH:",a_ETH);
-      assert.equal(new BigNumber(a_ETH).isGreaterThan(new BigNumber(b_ETH)),true);
+      assert.equal(new BigNumber(b_ETH).isGreaterThan(new BigNumber(a_ETH).minus(decimalStr("1"))),true);
     });
 
+
+    it("resetDPP - InETH", async () => {
+      var beforeState = await DPP_WETH_USDT.methods.getPMMState().call();
+      assert.equal(beforeState.K,config.k);
+      assert.equal(beforeState.B0,decimalStr("5"));
+      assert.equal(beforeState.Q0,mweiStr("30000"));
+      var b_ETH = await ctx.Web3.eth.getBalance(project);
+      var tx = await logGas(await ctx.DODOProxy.methods.resetDODOPrivatePoolETH(
+        dpp_WETH_USDT,
+        config.lpFeeRate,
+        config.mtFeeRate,
+        mweiStr("600"),
+        decimalStr("0.2"),
+        decimalStr("1"),
+        mweiStr("1000"),
+        decimalStr("0"),
+        mweiStr("0"),
+        1,
+        Math.floor(new Date().getTime()/1000 + 60 * 10)
+      ),ctx.sendParam(project,"1"),"resetDPP-InETH");
+      var afterState = await DPP_WETH_USDT.methods.getPMMState().call();
+      assert.equal(afterState.K,decimalStr("0.2"));
+      assert.equal(afterState.B0,decimalStr("6"));
+      assert.equal(afterState.Q0,mweiStr("31000"));
+      var a_ETH = await ctx.Web3.eth.getBalance(project);
+      console.log("b_ETH:",b_ETH);
+      console.log("a_ETH:",a_ETH);
+      assert.equal(new BigNumber(b_ETH).isGreaterThan(new BigNumber(a_ETH).plus(decimalStr("1"))),true);
+    });
+
+    it("swap - one hop", async () => {
+      await ctx.mintTestToken(trader, ctx.DODO, decimalStr("1000"));
+      var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
+      var b_USDT = await ctx.USDT.methods.balanceOf(trader).call();
+      var dodoPairs = [
+        dpp_DODO_USDT
+      ]
+      var directions = [
+        0
+      ]
+      var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken(
+        trader,
+        ctx.DODO.options.address,
+        ctx.USDT.options.address,
+        decimalStr("500"),
+        1,
+        dodoPairs,
+        directions,
+        Math.floor(new Date().getTime()/1000 + 60 * 10)
+      ),ctx.sendParam(trader),"swap - one hop");
+      var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
+      var a_USDT = await ctx.USDT.methods.balanceOf(trader).call();
+      console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
+      console.log("b_USDT:" + b_USDT + " a_USDT:" + a_USDT);
+      assert.equal(a_DOOD,decimalStr("500"));
+      assert.equal(a_USDT,"149474924");
+    });
+
+
+    it("swap - two hop", async () => {
+      await ctx.mintTestToken(trader, ctx.DODO, decimalStr("1000"));
+      var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
+      var b_WETH = await ctx.WETH.methods.balanceOf(trader).call();
+      var dodoPairs = [
+        dpp_DODO_USDT,
+        dpp_WETH_USDT
+      ]
+      var directions = [
+        0,
+        1
+      ]
+      var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken(
+        trader,
+        ctx.DODO.options.address,
+        ctx.WETH.options.address,
+        decimalStr("500"),
+        1,
+        dodoPairs,
+        directions,
+        Math.floor(new Date().getTime()/1000 + 60 * 10)
+      ),ctx.sendParam(trader),"swap - two hop");
+      var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
+      var a_WETH = await ctx.WETH.methods.balanceOf(trader).call();
+      console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
+      console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH);
+      assert.equal(a_DOOD,decimalStr("500"));
+      assert.equal(a_WETH,"247088894507188480");
+    });
+
+    it("swap - two hop - inETH", async () => {
+      var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
+      var b_WETH = await ctx.WETH.methods.balanceOf(trader).call();
+      var b_ETH = await ctx.Web3.eth.getBalance(trader);
+      var dodoPairs = [
+        dpp_WETH_USDT,
+        dpp_DODO_USDT
+      ]
+      var directions = [
+        0,
+        1
+      ]
+      var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapETHToToken(
+        trader,
+        ctx.DODO.options.address,
+        decimalStr("1"),
+        1,
+        dodoPairs,
+        directions,
+        Math.floor(new Date().getTime()/1000 + 60 * 10)
+      ),ctx.sendParam(trader,"1"),"swap - two hop - inETH");
+      var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
+      var a_WETH = await ctx.WETH.methods.balanceOf(trader).call();
+      var a_ETH = await ctx.Web3.eth.getBalance(trader);
+      console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
+      console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH);
+      console.log("b_ETH:" + b_ETH + " a_ETH:" + a_ETH);
+      assert.equal(a_DOOD,"1979965731049456633086");
+    });
+
+
+    it("swap - two hop - outETH", async () => {
+      await ctx.mintTestToken(trader, ctx.DODO, decimalStr("100000"));
+      var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
+      var b_WETH = await ctx.WETH.methods.balanceOf(trader).call();
+      var b_ETH = await ctx.Web3.eth.getBalance(trader);
+      var dodoPairs = [
+        dpp_DODO_USDT,
+        dpp_WETH_USDT
+      ]
+      var directions = [
+        0,
+        1
+      ]
+      var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToETH(
+        trader,
+        ctx.DODO.options.address,
+        decimalStr("10000"),
+        1,
+        dodoPairs,
+        directions,
+        Math.floor(new Date().getTime()/1000 + 60 * 10)
+      ),ctx.sendParam(trader),"swap - two hop - outETH");
+      var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
+      var a_WETH = await ctx.WETH.methods.balanceOf(trader).call();
+      var a_ETH = await ctx.Web3.eth.getBalance(trader);
+      console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
+      console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH);
+      console.log("b_ETH:" + b_ETH + " a_ETH:" + a_ETH);
+      assert.equal(a_DOOD,decimalStr("90000"));
+      assert.equal(
+        tx.events['OrderHistory'].returnValues['returnAmount'],
+        "3760778358599649282"
+      )
+    });
+
+
   });
 });

test/Proxy/proxy.dvm.test.ts

@@ -6,11 +6,13 @@
 */
 
 // import * as assert from 'assert';
-
+import BigNumber from "bignumber.js";
-import { decimalStr, mweiStr} from '../utils/Converter';
+import { decimalStr, mweiStr } from '../utils/Converter';
 import { logGas } from '../utils/Log';
 import { ProxyContext, getProxyContext } from '../utils/ProxyContext';
 import { assert } from 'chai';
+import * as contracts from '../utils/Contracts';
+import { Contract } from 'web3-eth-contract';
 
 let lp: string;
 let project: string;
@@ -27,46 +29,59 @@ async function init(ctx: ProxyContext): Promise<void> {
   lp = ctx.SpareAccounts[0];
   project = ctx.SpareAccounts[1];
   trader = ctx.SpareAccounts[2];
-  await ctx.approveProxy(lp);
-  await ctx.approveProxy(project);
-  await ctx.approveProxy(trader);
 
-  await ctx.mintTestToken(lp, ctx.DODO, decimalStr("100000"));
+  await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000000"));
-  await ctx.mintTestToken(project, ctx.DODO, decimalStr("100000"));
+  await ctx.mintTestToken(project, ctx.DODO, decimalStr("1000000"));
-  await ctx.mintTestToken(trader, ctx.DODO, decimalStr("100000"));
 
-  await ctx.mintTestToken(lp, ctx.USDT, mweiStr("100000"));
+  await ctx.mintTestToken(lp, ctx.USDT, mweiStr("1000000"));
-  await ctx.mintTestToken(project, ctx.USDT, mweiStr("100000"));
+  await ctx.mintTestToken(project, ctx.USDT, mweiStr("1000000"));
 
   // await ctx.WETH.methods.deposit().send(ctx.sendParam(lp, '80'));
   // await ctx.WETH.methods.deposit().send(ctx.sendParam(project, '80'));
+
+  await ctx.approveProxy(lp);
+  await ctx.approveProxy(project);
+  await ctx.approveProxy(trader);
 }
 
-async function initCreateDVM(ctx: ProxyContext, token0: any, token1:any, token0Amount: string, token1Amount: string): Promise<void> {
+async function initCreateDVM(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string,i:string): Promise<string> {
   let PROXY = ctx.DODOProxy;
   await PROXY.methods.createDODOVendingMachine(
-    token0.options.address,
+    project,
-    token1.options.address,
+    token0,
+    token1,
     token0Amount,
     token1Amount,
     config.lpFeeRate,
     config.mtFeeRate,
     config.i,
     config.k,
-    Math.floor(new Date().getTime()/1000 + 60 * 10);
+    Math.floor(new Date().getTime()/1000 + 60 * 10)
-  ).send(ctx.sendParam(project));
+  ).send(ctx.sendParam(project,ethValue));
+  if(token0 == '0x000000000000000000000000000000000000000E') token0 = ctx.WETH.options.address;
+  if(token1 == '0x000000000000000000000000000000000000000E') token1 = ctx.WETH.options.address;
+  var addr = await ctx.DVMFactory.methods._REGISTRY_(token0,token1,0).call();
+  return addr;
 }
 
 
 describe("DODOProxyV2.0", () => {
   let snapshotId: string;
   let ctx: ProxyContext;
+  let dvm_DODO_USDT: string;
+  let dvm_WETH_USDT: string;
+  let DVM_DODO_USDT: Contract;
+  let DVM_WETH_USDT: Contract;
 
   before(async () => {
     ctx = await getProxyContext();
     await init(ctx);
-    // await initCreateDVM(ctx,ctx.DODO,ctx.USDT,decimalStr("10000"),decimalStr("10000"));
+    dvm_DODO_USDT = await initCreateDVM(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("100000"),mweiStr("30000"), "0",mweiStr("0.3"));
-    // await initCreateDVM(ctx,ctx.WETH,ctx.USDT,decimalStr("50"),decimalStr("10000"));
+    DVM_DODO_USDT = contracts.getContractWithAddress(contracts.DVM_NAME,dvm_DODO_USDT);
+    dvm_WETH_USDT = await initCreateDVM(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("5"),mweiStr("30000"),"5",mweiStr("600"));
+    DVM_WETH_USDT = contracts.getContractWithAddress(contracts.DVM_NAME,dvm_WETH_USDT);
+    console.log("dvm_DODO_USDT:",dvm_DODO_USDT);
+    console.log("dvm_WETH_USDT:",dvm_WETH_USDT);
   });
 
   beforeEach(async () => {
@@ -78,30 +93,149 @@ describe("DODOProxyV2.0", () => {
   });
 
   describe("DODOProxy", () => {
-    /**
-     * 1. 创建空池子
-     * 2. 创建ERC20 Token DVM
-     * 3. 创建ETH && ERC20 Token 
-     */
     it("createDVM", async () => {
-
+      var baseToken = ctx.DODO.options.address;
-    });
+      var quoteToken = ctx.USDT.options.address;
-
+      var baseAmount = decimalStr("10000");
-    /**
+      var quoteAmount = mweiStr("10000");
-     * 1. 添加ERC20 Amount
+      await logGas(await ctx.DODOProxy.methods.createDODOVendingMachine(
-     * 2. 添加ERC20 + ETH 
+        project,
-     */
+        baseToken,
-    it("addLiquidityToDVM", async () => {
+        quoteToken,
-
+        baseAmount,
+        quoteAmount,
+        config.lpFeeRate,
+        config.mtFeeRate,
+        config.i,
+        config.k,
+        Math.floor(new Date().getTime()/1000 + 60 * 10)
+      ),ctx.sendParam(project),"createDVM");
+      var addrs = await ctx.DVMFactory.methods.getVendingMachine(baseToken,quoteToken).call();
+      var dvmInfo = await ctx.DVMFactory.methods._DVM_INFO_(addrs[1]).call();
+      assert.equal(
+        dvmInfo[0],
+        project
+      );
+      assert.equal(
+        await ctx.DODO.methods.balanceOf(addrs[1]).call(),
+        baseAmount
+      );
+      assert.equal(
+        await ctx.USDT.methods.balanceOf(addrs[1]).call(),
+        quoteAmount
+      );
     });
 
 
-    /**
+    it("createDVM - ETH", async () => {
-     * 1. 移除ERC20 Amount
+      var baseToken = '0x000000000000000000000000000000000000000E';
-     * 2. 移除ERC20 + ETH 
+      var quoteToken = ctx.USDT.options.address;
-     */
+      var baseAmount = decimalStr("5");
-    it("removeLiquidityToDVM", async () => {
+      var quoteAmount = mweiStr("10000");
+      await logGas(await ctx.DODOProxy.methods.createDODOVendingMachine(
+        project,
+        baseToken,
+        quoteToken,
+        baseAmount,
+        quoteAmount,
+        config.lpFeeRate,
+        config.mtFeeRate,
+        config.i,
+        config.k,
+        Math.floor(new Date().getTime()/1000 + 60 * 10)
+      ),ctx.sendParam(project, '5'),"createDVM - Wrap ETH");
+      var addrs = await ctx.DVMFactory.methods.getVendingMachine(ctx.WETH.options.address,quoteToken).call();
+      var dvmInfo = await ctx.DVMFactory.methods._DVM_INFO_(addrs[1]).call();
+      assert.equal(
+        dvmInfo[0],
+        project
+      );
+      assert.equal(
+        await ctx.WETH.methods.balanceOf(addrs[1]).call(),
+        baseAmount
+      );
+      assert.equal(
+        await ctx.USDT.methods.balanceOf(addrs[1]).call(),
+        quoteAmount
+      );
+    });
  
+
+    it("addLiquidity", async () => {
+      var b_baseReserve = await DVM_DODO_USDT.methods._BASE_RESERVE_().call();
+      var b_quoteReserve = await DVM_DODO_USDT.methods._QUOTE_RESERVE_().call();
+      var b_dlp = await DVM_DODO_USDT.methods.balanceOf(lp).call();
+      assert.equal(b_baseReserve,decimalStr("100000"));
+      assert.equal(b_quoteReserve,mweiStr("30000"));
+      assert.equal(b_dlp,decimalStr("0"));
+      await logGas(await ctx.DODOProxy.methods.addDVMLiquidity(
+        dvm_DODO_USDT,
+        lp,
+        decimalStr("1000"),
+        mweiStr("300"),
+        decimalStr("0"),
+        mweiStr("0"),
+        Math.floor(new Date().getTime()/1000 + 60 * 10)
+      ),ctx.sendParam(lp),"addLiquidity");
+      var a_baseReserve = await DVM_DODO_USDT.methods._BASE_RESERVE_().call();
+      var a_quoteReserve = await DVM_DODO_USDT.methods._QUOTE_RESERVE_().call();
+      var a_dlp = await DVM_DODO_USDT.methods.balanceOf(lp).call();
+      assert.equal(a_baseReserve,decimalStr("101000"));
+      assert.equal(a_quoteReserve,mweiStr("30300"));
+      assert.equal(a_dlp,"1000000000000000000000");
+    });
+
+
+    it("addLiquidity - ETH", async () => {
+      var b_baseReserve = await DVM_WETH_USDT.methods._BASE_RESERVE_().call();
+      var b_quoteReserve = await DVM_WETH_USDT.methods._QUOTE_RESERVE_().call();
+      var b_dlp = await DVM_WETH_USDT.methods.balanceOf(lp).call();
+      assert.equal(b_baseReserve,decimalStr("5"));
+      assert.equal(b_quoteReserve,mweiStr("30000"));
+      assert.equal(b_dlp,decimalStr("0"));
+      await logGas(await ctx.DODOProxy.methods.addDVMLiquidityETH(
+        dvm_WETH_USDT,
+        lp,
+        decimalStr("1"),
+        mweiStr("6000"),
+        decimalStr("0"),
+        mweiStr("0"),
+        1,
+        Math.floor(new Date().getTime()/1000 + 60 * 10)
+      ),ctx.sendParam(lp,'1'),"addLiquidity - ETH");
+      var a_baseReserve = await DVM_WETH_USDT.methods._BASE_RESERVE_().call();
+      var a_quoteReserve = await DVM_WETH_USDT.methods._QUOTE_RESERVE_().call();
+      var a_dlp = await DVM_WETH_USDT.methods.balanceOf(lp).call();
+      assert.equal(a_baseReserve,decimalStr("6"));
+      assert.equal(a_quoteReserve,mweiStr("36000"));
+      assert.equal(a_dlp,"1000000000000000000");
+    });
+
+    //TODO:ing   
+    it("removeLiquidity", async () => {
+      var b_baseReserve = await DVM_DODO_USDT.methods._BASE_RESERVE_().call();
+      var b_quoteReserve = await DVM_DODO_USDT.methods._QUOTE_RESERVE_().call();
+      var b_dlp = await DVM_DODO_USDT.methods.balanceOf(project).call();
+      assert.equal(b_baseReserve,decimalStr("100000"));
+      assert.equal(b_quoteReserve,mweiStr("30000"));
+      console.log("b_dlp:" + b_dlp);
+      // assert.equal(b_dlp,decimalStr("0"));
+      await logGas(await ctx.DODOProxy.methods.removeDVMLiquidity(
+        dvm_DODO_USDT,
+        project,
+        decimalStr("100"),
+        decimalStr("0"),
+        mweiStr("0"),
+        Math.floor(new Date().getTime()/1000 + 60 * 10)
+      ),ctx.sendParam(project),"removeLiquidity");
+      var a_baseReserve = await DVM_DODO_USDT.methods._BASE_RESERVE_().call();
+      var a_quoteReserve = await DVM_DODO_USDT.methods._QUOTE_RESERVE_().call();
+      var a_dlp = await DVM_DODO_USDT.methods.balanceOf(project).call();
+      // assert.equal(a_baseReserve,decimalStr("6"));
+      // assert.equal(a_quoteReserve,mweiStr("36000"));
+      // assert.equal(a_dlp,"1000000000000000000");
+      console.log("b_dlp:" + b_dlp + " a_dlp:" + a_dlp);
+      console.log("a_baseReserve:" + a_baseReserve + " a_quoteReserve:" + a_quoteReserve);
     });
 
     /**
@@ -112,10 +246,5 @@ describe("DODOProxyV2.0", () => {
     });
 
 
-
-    /**
-     * 直接底层dvm操作测试
-     */
-
   });
 });

test/utils/ProxyContext.ts

@@ -10,7 +10,7 @@ import Web3 from 'web3';
 import { Contract } from 'web3-eth-contract';
 
 import * as contracts from './Contracts';
-import { decimalStr, MAX_UINT256 } from './Converter';
+import { decimalStr, mweiStr, MAX_UINT256 } from './Converter';
 import { EVM, getDefaultWeb3 } from './EVM';
 import * as log from './Log';
 
@@ -63,7 +63,7 @@ export class ProxyContext {
     var permissionManagerTemplate = await contracts.newContract(contracts.PERMISSION_MANAGER_NAME)
     var vauleSource = await contracts.newContract(contracts.EXTERNAL_VALUE_NAME)
     var defaultGasSource = await contracts.newContract(contracts.EXTERNAL_VALUE_NAME)
-    await defaultGasSource.methods.init(this.Deployer,decimalStr("1000000"));
+    await defaultGasSource.methods.init(this.Deployer,MAX_UINT256).send(this.sendParam(this.Deployer));
 
     this.DVMFactory = await contracts.newContract(contracts.DVM_FACTORY_NAME,
       [
@@ -125,7 +125,8 @@ export class ProxyContext {
     return {
       from: sender,
       gas: process.env["COVERAGE"] ? 10000000000 : 7000000,
-      gasPrice: process.env.GAS_PRICE,
+      // gasPrice: process.env.GAS_PRICE,
+      gasPrice: mweiStr("1000"),
       value: decimalStr(value),
     };
   }