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

contracts/SmartRoute/SmartSwap.sol

@@ -12,8 +12,9 @@ import {ExternalCall} from "../lib/ExternalCall.sol";
 import {IERC20} from "../intf/IERC20.sol";
 import {UniversalERC20} from "../lib/UniversalERC20.sol";
 import {SafeMath} from "../lib/SafeMath.sol";
-import {DecimalMath} from "../lib/DecimalMath.sol";
+import {IDODOSellHelper} from "../intf/IDODOSellHelper.sol";
 import {ISmartApprove} from "../intf/ISmartApprove.sol";
+import {IDODO} from "../intf/IDODO.sol";
 
 
 contract SmartSwap is Ownable {
@@ -21,11 +22,11 @@ contract SmartSwap is Ownable {
     using UniversalERC20 for IERC20;
     using ExternalCall for address;
 
-    ISmartApprove public smartApprove;
-
     IERC20 constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
+    ISmartApprove public smartApprove;
+    IDODOSellHelper public dodoSellHelper;
 
-    event Swapped(
+    event OrderHistory(
         IERC20 indexed fromToken,
         IERC20 indexed toToken,
         address indexed sender,
@@ -35,8 +36,9 @@ contract SmartSwap is Ownable {
 
     event ExternalRecord(address indexed to, address indexed sender);
 
-    constructor(address _smartApprove) public {
+    constructor(address _smartApprove,address _dodoSellHelper) public {
         smartApprove = ISmartApprove(_smartApprove);
+        dodoSellHelper = IDODOSellHelper(_dodoSellHelper);
     }
 
     function dodoSwap(
@@ -44,40 +46,41 @@ contract SmartSwap is Ownable {
         IERC20 toToken,
         uint256 fromTokenAmount,
         uint256 minReturnAmount,
-        address[] memory callPairs,
+        address[] memory dodoPairs,
-        bytes memory callDataConcat,
+        uint256[] memory directions
-        uint256[] memory starts,
-        uint256[] memory gasLimitsAndValues
     ) public payable returns (uint256 returnAmount) {
         require(minReturnAmount > 0, "Min return should be bigger then 0.");
-        require(callPairs.length > 0, "pairs should exists.");
+        require(dodoPairs.length > 0, "pairs should exists.");
 
         if (fromToken != ETH_ADDRESS) {
             smartApprove.claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
         }
 
-        for (uint256 i = 0; i < callPairs.length; i++) {
+        for (uint256 i = 0; i < dodoPairs.length; i++) {
-            require(callPairs[i] != address(smartApprove), "Access denied");
+            uint256 curDirection = directions[i];
-            require(
+            address curDodoPair = dodoPairs[i];
-                callPairs[i].externalCall(
+            if(curDirection == 0){
-                    gasLimitsAndValues[i] & ((1 << 128) - 1),
+                address curDodoBase = IDODO(curDodoPair)._BASE_TOKEN_();
-                    callDataConcat,
+                uint256 curAmountIn = IERC20(curDodoBase).balanceOf(address(this));
-                    starts[i],
+                IERC20(curDodoBase).approve(curDodoPair,curAmountIn);
-                    starts[i + 1] - starts[i],
+                IDODO(curDodoPair).sellBaseToken(curAmountIn, 0, "");
-                    gasLimitsAndValues[i] >> 128
+            }else {
-                ),"Swap Transaction Error!"
+                address curDodoQuote = IDODO(curDodoPair)._QUOTE_TOKEN_();
-            );
+                uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this));
+                IERC20(curDodoQuote).approve(curDodoPair,curAmountIn);
+                uint256 canBuyBaseAmount = dodoSellHelper.querySellQuoteToken(curDodoPair,curAmountIn);
+                IDODO(curDodoPair).buyBaseToken(canBuyBaseAmount, curAmountIn, "");
+            }
         }
-
         fromToken.universalTransfer(msg.sender, fromToken.universalBalanceOf(address(this)));
         returnAmount = toToken.universalBalanceOf(address(this));
 
         require(returnAmount >= minReturnAmount, "Return amount is not enough");
         toToken.universalTransfer(msg.sender, returnAmount);
-        emit Swapped(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
+        emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
     }
 
-    //TODO:change
+
     function externalSwap(
         IERC20 fromToken,
         IERC20 toToken,
@@ -100,16 +103,12 @@ contract SmartSwap is Ownable {
 
         require(success, "Contract Swap execution Failed");
 
-        // Return back all unswapped
         fromToken.universalTransfer(msg.sender, fromToken.universalBalanceOf(address(this)));
-
         returnAmount = toToken.universalBalanceOf(address(this));
 
         require(returnAmount >= minReturnAmount, "Return amount is not enough");
         toToken.universalTransfer(msg.sender, returnAmount);
-
+        emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
-        emit Swapped(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
-
         emit ExternalRecord(to, msg.sender);
     }
 }

contracts/helper/DODOSellHelper.sol

@@ -0,0 +1,226 @@
+/**
+ *Submitted for verification at Etherscan.io on 2020-10-10
+*/
+
+// File: contracts/intf/IDODO.sol
+
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+import {IDODO} from "../intf/IDODO.sol";
+import {SafeMath} from "../lib/SafeMath.sol";
+import {DecimalMath} from "../lib/DecimalMath.sol";
+// import {DODOMath} from "../lib/DODOMath.sol";
+
+
+library DODOMath {
+    using SafeMath for uint256;
+
+    /*
+        Integrate dodo curve fron V1 to V2
+        require V0>=V1>=V2>0
+        res = (1-k)i(V1-V2)+ikV0*V0(1/V2-1/V1)
+        let V1-V2=delta
+        res = i*delta*(1-k+k(V0^2/V1/V2))
+    */
+    function _GeneralIntegrate(
+        uint256 V0,
+        uint256 V1,
+        uint256 V2,
+        uint256 i,
+        uint256 k
+    ) internal pure returns (uint256) {
+        uint256 fairAmount = DecimalMath.mul(i, V1.sub(V2)); // i*delta
+        uint256 V0V0V1V2 = DecimalMath.divCeil(V0.mul(V0).div(V1), V2);
+        uint256 penalty = DecimalMath.mul(k, V0V0V1V2); // k(V0^2/V1/V2)
+        return DecimalMath.mul(fairAmount, DecimalMath.ONE.sub(k).add(penalty));
+    }
+
+    /*
+        The same with integration expression above, we have:
+        i*deltaB = (Q2-Q1)*(1-k+kQ0^2/Q1/Q2)
+        Given Q1 and deltaB, solve Q2
+        This is a quadratic function and the standard version is
+        aQ2^2 + bQ2 + c = 0, where
+        a=1-k
+        -b=(1-k)Q1-kQ0^2/Q1+i*deltaB
+        c=-kQ0^2
+        and Q2=(-b+sqrt(b^2+4(1-k)kQ0^2))/2(1-k)
+        note: another root is negative, abondan
+        if deltaBSig=true, then Q2>Q1
+        if deltaBSig=false, then Q2<Q1
+    */
+    function _SolveQuadraticFunctionForTrade(
+        uint256 Q0,
+        uint256 Q1,
+        uint256 ideltaB,
+        bool deltaBSig,
+        uint256 k
+    ) internal pure returns (uint256) {
+        // calculate -b value and sig
+        // -b = (1-k)Q1-kQ0^2/Q1+i*deltaB
+        uint256 kQ02Q1 = DecimalMath.mul(k, Q0).mul(Q0).div(Q1); // kQ0^2/Q1
+        uint256 b = DecimalMath.mul(DecimalMath.ONE.sub(k), Q1); // (1-k)Q1
+        bool minusbSig = true;
+        if (deltaBSig) {
+            b = b.add(ideltaB); // (1-k)Q1+i*deltaB
+        } else {
+            kQ02Q1 = kQ02Q1.add(ideltaB); // i*deltaB+kQ0^2/Q1
+        }
+        if (b >= kQ02Q1) {
+            b = b.sub(kQ02Q1);
+            minusbSig = true;
+        } else {
+            b = kQ02Q1.sub(b);
+            minusbSig = false;
+        }
+
+        // calculate sqrt
+        uint256 squareRoot = DecimalMath.mul(
+            DecimalMath.ONE.sub(k).mul(4),
+            DecimalMath.mul(k, Q0).mul(Q0)
+        ); // 4(1-k)kQ0^2
+        squareRoot = b.mul(b).add(squareRoot).sqrt(); // sqrt(b*b+4(1-k)kQ0*Q0)
+
+        // final res
+        uint256 denominator = DecimalMath.ONE.sub(k).mul(2); // 2(1-k)
+        uint256 numerator;
+        if (minusbSig) {
+            numerator = b.add(squareRoot);
+        } else {
+            numerator = squareRoot.sub(b);
+        }
+
+        if (deltaBSig) {
+            return DecimalMath.divFloor(numerator, denominator);
+        } else {
+            return DecimalMath.divCeil(numerator, denominator);
+        }
+    }
+
+    /*
+        Start from the integration function
+        i*deltaB = (Q2-Q1)*(1-k+kQ0^2/Q1/Q2)
+        Assume Q2=Q0, Given Q1 and deltaB, solve Q0
+        let fairAmount = i*deltaB
+    */
+    function _SolveQuadraticFunctionForTarget(
+        uint256 V1,
+        uint256 k,
+        uint256 fairAmount
+    ) internal pure returns (uint256 V0) {
+        // V0 = V1+V1*(sqrt-1)/2k
+        uint256 sqrt = DecimalMath.divCeil(DecimalMath.mul(k, fairAmount).mul(4), V1);
+        sqrt = sqrt.add(DecimalMath.ONE).mul(DecimalMath.ONE).sqrt();
+        uint256 premium = DecimalMath.divCeil(sqrt.sub(DecimalMath.ONE), k.mul(2));
+        // V0 is greater than or equal to V1 according to the solution
+        return DecimalMath.mul(V1, DecimalMath.ONE.add(premium));
+    }
+}
+
+
+contract DODOSellHelper {
+    using SafeMath for uint256;
+
+    enum RStatus {ONE, ABOVE_ONE, BELOW_ONE}
+
+    uint256 constant ONE = 10**18;
+
+    struct DODOState {
+        uint256 oraclePrice;
+        uint256 K;
+        uint256 B;
+        uint256 Q;
+        uint256 baseTarget;
+        uint256 quoteTarget;
+        RStatus rStatus;
+    }
+
+    function querySellBaseToken(address dodo, uint256 amount) public view returns (uint256) {
+        return IDODO(dodo).querySellBaseToken(amount);
+    }
+
+    function querySellQuoteToken(address dodo, uint256 amount) public view returns (uint256) {
+        DODOState memory state;
+        (state.baseTarget, state.quoteTarget) = IDODO(dodo).getExpectedTarget();
+        state.rStatus = RStatus(IDODO(dodo)._R_STATUS_());
+        state.oraclePrice = IDODO(dodo).getOraclePrice();
+        state.Q = IDODO(dodo)._QUOTE_BALANCE_();
+        state.B = IDODO(dodo)._BASE_BALANCE_();
+        state.K = IDODO(dodo)._K_();
+
+        uint256 boughtAmount;
+        // Determine the status (RStatus) and calculate the amount
+        // based on the state
+        if (state.rStatus == RStatus.ONE) {
+            boughtAmount = _ROneSellQuoteToken(amount, state);
+        } else if (state.rStatus == RStatus.ABOVE_ONE) {
+            boughtAmount = _RAboveSellQuoteToken(amount, state);
+        } else {
+            uint256 backOneBase = state.B.sub(state.baseTarget);
+            uint256 backOneQuote = state.quoteTarget.sub(state.Q);
+            if (amount <= backOneQuote) {
+                boughtAmount = _RBelowSellQuoteToken(amount, state);
+            } else {
+                boughtAmount = backOneBase.add(
+                    _ROneSellQuoteToken(amount.sub(backOneQuote), state)
+                );
+            }
+        }
+        // Calculate fees
+        return
+            DecimalMath.divFloor(
+                boughtAmount,
+                DecimalMath.ONE.add(IDODO(dodo)._MT_FEE_RATE_()).add(IDODO(dodo)._LP_FEE_RATE_())
+            );
+    }
+
+    function _ROneSellQuoteToken(uint256 amount, DODOState memory state)
+        internal
+        pure
+        returns (uint256 receiveBaseToken)
+    {
+        uint256 i = DecimalMath.divFloor(ONE, state.oraclePrice);
+        uint256 B2 = DODOMath._SolveQuadraticFunctionForTrade(
+            state.baseTarget,
+            state.baseTarget,
+            DecimalMath.mul(i, amount),
+            false,
+            state.K
+        );
+        return state.baseTarget.sub(B2);
+    }
+
+    function _RAboveSellQuoteToken(uint256 amount, DODOState memory state)
+        internal
+        pure
+        returns (uint256 receieBaseToken)
+    {
+        uint256 i = DecimalMath.divFloor(ONE, state.oraclePrice);
+        uint256 B2 = DODOMath._SolveQuadraticFunctionForTrade(
+            state.baseTarget,
+            state.B,
+            DecimalMath.mul(i, amount),
+            false,
+            state.K
+        );
+        return state.B.sub(B2);
+    }
+
+    function _RBelowSellQuoteToken(uint256 amount, DODOState memory state)
+        internal
+        pure
+        returns (uint256 receiveBaseToken)
+    {
+        uint256 Q1 = state.Q.add(amount);
+        uint256 i = DecimalMath.divFloor(ONE, state.oraclePrice);
+        return DODOMath._GeneralIntegrate(state.quoteTarget, Q1, state.Q, i, state.K);
+    }
+}

contracts/intf/IDODO.sol

@@ -0,0 +1,81 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+
+interface IDODO {
+    function init(
+        address owner,
+        address supervisor,
+        address maintainer,
+        address baseToken,
+        address quoteToken,
+        address oracle,
+        uint256 lpFeeRate,
+        uint256 mtFeeRate,
+        uint256 k,
+        uint256 gasPriceLimit
+    ) external;
+
+    function transferOwnership(address newOwner) external;
+
+    function claimOwnership() external;
+
+    function sellBaseToken(
+        uint256 amount,
+        uint256 minReceiveQuote,
+        bytes calldata data
+    ) external returns (uint256);
+
+    function buyBaseToken(
+        uint256 amount,
+        uint256 maxPayQuote,
+        bytes calldata data
+    ) external returns (uint256);
+
+    function querySellBaseToken(uint256 amount) external view returns (uint256 receiveQuote);
+
+    function queryBuyBaseToken(uint256 amount) external view returns (uint256 payQuote);
+
+    function depositBaseTo(address to, uint256 amount) external returns (uint256);
+
+    function withdrawBase(uint256 amount) external returns (uint256);
+
+    function withdrawAllBase() external returns (uint256);
+
+    function depositQuoteTo(address to, uint256 amount) external returns (uint256);
+
+    function withdrawQuote(uint256 amount) external returns (uint256);
+
+    function withdrawAllQuote() external returns (uint256);
+
+    function _BASE_CAPITAL_TOKEN_() external returns (address);
+
+    function _QUOTE_CAPITAL_TOKEN_() external returns (address);
+
+    function _BASE_TOKEN_() external returns (address);
+
+    function _QUOTE_TOKEN_() external returns (address);
+
+    function _R_STATUS_() external view returns (uint8);
+
+    function _QUOTE_BALANCE_() external view returns (uint256);
+
+    function _BASE_BALANCE_() external view returns (uint256);
+
+    function _K_() external view returns (uint256);
+
+    function _MT_FEE_RATE_() external view returns (uint256);
+
+    function _LP_FEE_RATE_() external view returns (uint256);
+
+    function getExpectedTarget() external view returns (uint256 baseTarget, uint256 quoteTarget);
+
+    function getOraclePrice() external view returns (uint256);
+}

contracts/intf/IDODOSellHelper.sol

@@ -0,0 +1,14 @@
+/*
+
+    Copyright 2020 DODO ZOO.
+    SPDX-License-Identifier: Apache-2.0
+
+*/
+
+pragma solidity 0.6.9;
+pragma experimental ABIEncoderV2;
+
+interface IDODOSellHelper {
+    function querySellQuoteToken(address dodo, uint256 amount) external view returns (uint256);
+    function querySellBaseToken(address dodo, uint256 amount) external view returns (uint256);
+}

test/Route/Route.test.ts

@@ -48,7 +48,6 @@ async function initUSDT_USDC(ctx: DODOContext): Promise<void> {
 
   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,trader, mweiStr("0"), mweiStr("0"));
 
   await USDT_USDC.methods
     .depositBaseTo(lp, mweiStr("1000"))
@@ -58,6 +57,7 @@ async function initUSDT_USDC(ctx: DODOContext): Promise<void> {
     .send(ctx.sendParam(lp));
 }
 
+
 async function initWETH_USDC(ctx: DODOContext): Promise<void> {
   await ctx.setOraclePrice(ctx.WETH_USDC_ORACLE,mweiStr("450"));
   lp = ctx.spareAccounts[0];
@@ -81,77 +81,38 @@ async function initWETH_USDC(ctx: DODOContext): Promise<void> {
 //mock sdk logic
 async function calcRoute(ctx: DODOContext,fromTokenAmount:string,slippage:number,routes:any[],pairs:any[]) {
   let swapAmount = fromTokenAmount
+  let directions:number[] = []
+  let dodoPairs:string[] = []
+
 
-  let callPairs: string[] = []
-  let datas: string = ""
-  let starts: number[] = []
-  let gAndV: number[] = []
   for (let i = 0; i < pairs.length; i++) {
-    if(i == 0){
-      starts.push(0);
-    }
     let curPair = pairs[i]
-    let curContact =pairs[i].pairContract;
+    dodoPairs.push(curPair.pair)
-    let curData = '';
+    let curContact = pairs[i].pairContract
-    let curApproveData = '';
-
     if (curPair.base === routes[i].address) {
-      curApproveData = await pairs[i].baseContract.methods.approve(curPair.pair,swapAmount).encodeABI()
+      directions[i] = 0;
-      curApproveData = curApproveData.substring(2,curApproveData.length)
-      datas += curApproveData
-      starts.push(datas.length/2)
-      gAndV.push(0)
-      callPairs.push(pairs[i].baseContract.options.address);
-      curData = await curContact.methods.sellBaseToken(swapAmount, 0, "0x").encodeABI()
-      console.log(i + ":b-for-swapAmount:",swapAmount);
       swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call();
-      console.log(i + ":a-for-swapAmount:",swapAmount);
+      console.log(i + "-swapAmount:",swapAmount);
     } else {
-      curApproveData = await pairs[i].quoteContract.methods.approve(curPair.pair,swapAmount).encodeABI()
+      directions[i] = 1;
-      curApproveData = curApproveData.substring(2,curApproveData.length)
+      swapAmount = await ctx.DODOSellHelper.methods.querySellQuoteToken(curPair.pair,swapAmount).call();
-      datas += curApproveData
+      console.log(i + "-swapAmount:",swapAmount);
-      starts.push(datas.length/2)
-      gAndV.push(0)
-      callPairs.push(pairs[i].quoteContract.options.address);
-      console.log(i + ":b-for-swapAmount:",swapAmount);
-      let baseDecimal = await pairs[i].baseContract.methods.decimals().call();
-      let quoteDecimal = await pairs[i].quoteContract.methods.decimals().call();
-      let curPairDetail = {
-        B: new BigNumber(await curContact.methods._BASE_BALANCE_().call() / 10 ** baseDecimal),
-        Q: new BigNumber(await curContact.methods._QUOTE_BALANCE_().call() / 10 ** quoteDecimal),
-        B0: new BigNumber(await curContact.methods._TARGET_BASE_TOKEN_AMOUNT_().call() / 10 ** baseDecimal),
-        Q0: new BigNumber(await curContact.methods._TARGET_QUOTE_TOKEN_AMOUNT_().call() / 10 ** quoteDecimal),
-        RStatus: await curContact.methods._R_STATUS_().call(),
-        OraclePrice: new BigNumber(await curContact.methods.getOraclePrice().call() / 10 ** (18-baseDecimal + quoteDecimal)),
-        k: new BigNumber(parseInt(ctx.k) / 1e18),
-        mtFeeRate: new BigNumber(parseInt(ctx.mtFeeRate) / 1e18),
-        lpFeeRate: new BigNumber(parseInt(ctx.lpFeeRate) / 1e18)
-      }
-      let dodoHelper = new DODOHelper(curPairDetail)
-      //TODO:2倍？
-      let tmpQuoteAmount = new BigNumber(swapAmount).multipliedBy(1-0.006).toFixed(0, BigNumber.ROUND_DOWN)
-      let tmpBaseAmount = dodoHelper.queryBuyQuote(new BigNumber(fromWei(tmpQuoteAmount,'mwei'))).toString();
-      curData = await curContact.methods.buyBaseToken(decimalStr(tmpBaseAmount), swapAmount, "0x").encodeABI()
-      swapAmount = decimalStr(tmpBaseAmount);
-      console.log(i + ":a-for-swapAmount:",swapAmount);
     }
-    curData = curData.substring(2,curData.length)
-    datas += curData
-    starts.push(datas.length/2)
-    gAndV.push(0)
-    callPairs.push(curPair.pair)
   }
-  datas = "0x" + datas;
+
   let toAmount  = new BigNumber(swapAmount).multipliedBy(1-slippage).toFixed(0, BigNumber.ROUND_DOWN)
+  
+  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,
     fromTokenAmount,
     toAmount,
-    callPairs,
+    dodoPairs,
-    datas,
+    directions
-    starts,
-    gAndV
   )
 }
 
@@ -195,14 +156,12 @@ describe("Trader", () => {
         pair: ctx.DODO_USDT.options.address,
         base: ctx.DODO.options.address,
         /*only for test*/
-        pairContract: ctx.DODO_USDT,
+        pairContract: ctx.DODO_USDT
-        baseContract: ctx.DODO,
-        quoteContract: ctx.USDT
         /**************/
       }];
 
-      var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "route swap")
+      var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "directly swap")
-      // console.log(tx.events['Swapped']);
+      // 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'));
@@ -235,21 +194,17 @@ describe("Trader", () => {
         pair: ctx.DODO_USDT.options.address,
         base: ctx.DODO.options.address,
         /*only for test*/
-        pairContract: ctx.DODO_USDT,
+        pairContract: ctx.DODO_USDT
-        baseContract: ctx.DODO,
-        quoteContract: ctx.USDT
         /**************/
       },{
         pair: ctx.USDT_USDC.options.address,
         base: ctx.USDT.options.address,
         /*only for test*/
-        pairContract: ctx.USDT_USDC,
+        pairContract: ctx.USDT_USDC
-        baseContract: ctx.USDT,
-        quoteContract: ctx.USDC
         /**************/
       }];
 
-      var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "route 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()
@@ -286,30 +241,24 @@ describe("Trader", () => {
         pair: ctx.DODO_USDT.options.address,
         base: ctx.DODO.options.address,
         /*only for test*/
-        pairContract: ctx.DODO_USDT,
+        pairContract: ctx.DODO_USDT
-        baseContract: ctx.DODO,
-        quoteContract: ctx.USDT
         /**************/
       },{
         pair: ctx.USDT_USDC.options.address,
         base: ctx.USDT.options.address,
         /*only for test*/
-        pairContract: ctx.USDT_USDC,
+        pairContract: ctx.USDT_USDC
-        baseContract: ctx.USDT,
-        quoteContract: ctx.USDC
         /**************/
       },{
         pair: ctx.WETH_USDC.options.address,
         base: ctx.WETH.options.address,
         /*only for test*/
-        pairContract: ctx.WETH_USDC,
+        pairContract: ctx.WETH_USDC
-        baseContract: ctx.WETH,
-        quoteContract: ctx.USDC
         /**************/
       }];
 
-      var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "route swap")
+      var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "three hops swap")
-      // console.log(tx.events['Swapped']);
+      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'));

test/utils-v1/Context-route.ts

@@ -57,7 +57,6 @@ export class DODOContext {
   lpFeeRate: string;
   mtFeeRate: string;
   k: string;
-  
   //token
   DODO:Contract;
   USDT:Contract;
@@ -73,6 +72,7 @@ export class DODOContext {
   //SmartRoute
   SmartSwap: Contract;
   SmartApprove: Contract;
+  DODOSellHelper: Contract;
 
   constructor() {}
 
@@ -213,13 +213,17 @@ export class DODOContext {
       .send(this.sendParam(this.Deployer));
     await this.WETH_USDC.methods.enableTrading().send(this.sendParam(this.Deployer));
 
+    this.DODOSellHelper = await contracts.newContract(
+      contracts.DODO_SELL_HELPER
+    );
+
     this.SmartApprove = await contracts.newContract(
       contracts.SMART_APPROVE
     );
 
     this.SmartSwap = await contracts.newContract(
       contracts.SMART_SWAP,
-      [this.SmartApprove.options.address]
+      [this.SmartApprove.options.address,this.DODOSellHelper.options.address]
     );
 
     await this.SmartApprove.methods.setSmartSwap(this.SmartSwap.options.address).send(this.sendParam(this.Deployer));

test/utils-v1/Contracts.ts

@@ -30,6 +30,7 @@ const LockedTokenVault = require(`${jsonPath}LockedTokenVault.json`)
 /*v1.5*/
 const SmartSwap = require(`${jsonPath2}SmartSwap.json`)
 const SmartApprove = require(`${jsonPath2}SmartApprove.json`)
+const DODOSellHelper = require(`${jsonPath2}DODOSellHelper.json`)
 /******/
 
 import { getDefaultWeb3 } from './EVM';
@@ -53,6 +54,7 @@ export const DODO_MINE_READER_NAME = "DODOMineReader"
 /*v1.5*/
 export const SMART_SWAP = "SmartSwap"
 export const SMART_APPROVE = "SmartApprove"
+export const DODO_SELL_HELPER = "DODOSellHelper"
 /******/
 
 var contractMap: { [name: string]: any } = {}
@@ -73,6 +75,7 @@ contractMap[DODO_MINE_READER_NAME] = DODOMineReader
 /*v1.5*/
 contractMap[SMART_SWAP] = SmartSwap
 contractMap[SMART_APPROVE] = SmartApprove
+contractMap[DODO_SELL_HELPER] = DODOSellHelper
 /******/
 
 interface ContractJson {