diff --git a/contracts/SmartRoute/DODOApprove.sol b/contracts/SmartRoute/DODOApprove.sol index fbd0fa2..33720dd 100644 --- a/contracts/SmartRoute/DODOApprove.sol +++ b/contracts/SmartRoute/DODOApprove.sol @@ -13,19 +13,19 @@ import {Ownable} from "../lib/Ownable.sol"; contract DODOApprove is Ownable { using SafeERC20 for IERC20; - address public dodoProxy; + address public _DODO_PROXY_; // ============ Events ============ event SetDODOProxy(address indexed oldProxy, address indexed newProxy); - function setDODOProxy(address _dodoProxy) external onlyOwner { - emit SetDODOProxy(dodoProxy, _dodoProxy); - dodoProxy = _dodoProxy; + function setDODOProxy(address newDodoProxy) external onlyOwner { + emit SetDODOProxy(_DODO_PROXY_, newDodoProxy); + _DODO_PROXY_ = newDodoProxy; } function getDODOProxy() public view returns (address) { - return dodoProxy; + return _DODO_PROXY_; } function claimTokens( @@ -34,7 +34,7 @@ contract DODOApprove is Ownable { address dest, uint256 amount ) external { - require(msg.sender == dodoProxy, "DODOApprove:Access restricted"); + require(msg.sender == _DODO_PROXY_, "DODOApprove:Access restricted"); if (amount > 0) { IERC20(token).safeTransferFrom(who, dest, amount); } diff --git a/contracts/SmartRoute/DODOV1Proxy01.sol b/contracts/SmartRoute/DODOV1Proxy01.sol index abc6ff6..8d76e7b 100644 --- a/contracts/SmartRoute/DODOV1Proxy01.sol +++ b/contracts/SmartRoute/DODOV1Proxy01.sol @@ -23,9 +23,9 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard { // ============ Storage ============ - address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; - address public dodoApprove; - address public dodoSellHelper; + address constant _ETH_ADDRESS_ = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + address public _DODO_APPROVE_; + address public _DODO_SELL_HELPER_; address payable public _WETH_; // ============ Events ============ @@ -40,36 +40,36 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard { // ============ Modifiers ============ - modifier judgeExpired(uint256 deadline) { - require(deadline >= block.timestamp, "DODOV1Proxy01: EXPIRED"); + modifier judgeExpired(uint256 deadLine) { + require(deadLine >= block.timestamp, "DODOV1Proxy01: EXPIRED"); _; } constructor( - address _dodoApprove, - address _dodoSellHelper, - address payable _weth + address dodoApporve, + address dodoSellHelper, + address payable weth ) public { - dodoApprove = _dodoApprove; - dodoSellHelper = _dodoSellHelper; - _WETH_ = _weth; + _DODO_APPROVE_ = dodoApporve; + _DODO_SELL_HELPER_ = dodoSellHelper; + _WETH_ = weth; } fallback() external payable {} receive() external payable {} - function dodoSwap( + function dodoSwapV1( address fromToken, address toToken, uint256 fromTokenAmount, uint256 minReturnAmount, address[] memory dodoPairs, uint8[] memory directions, - uint256 deadline - ) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) { - if (fromToken != ETH_ADDRESS) { - IDODOApprove(dodoApprove).claimTokens( + uint256 deadLine + ) external virtual override payable judgeExpired(deadLine) returns (uint256 returnAmount) { + if (fromToken != _ETH_ADDRESS_) { + IDODOApprove(_DODO_APPROVE_).claimTokens( fromToken, msg.sender, address(this), @@ -91,7 +91,7 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard { address curDodoQuote = IDODOV1(curDodoPair)._QUOTE_TOKEN_(); uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this)); IERC20(curDodoQuote).universalApproveMax(curDodoPair, curAmountIn); - uint256 canBuyBaseAmount = IDODOSellHelper(dodoSellHelper).querySellQuoteToken( + uint256 canBuyBaseAmount = IDODOSellHelper(_DODO_SELL_HELPER_).querySellQuoteToken( curDodoPair, curAmountIn ); @@ -99,10 +99,14 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard { } } - returnAmount = IERC20(toToken).universalBalanceOf(address(this)); + if (toToken == _ETH_ADDRESS_) { + returnAmount = IWETH(_WETH_).balanceOf(address(this)); + IWETH(_WETH_).withdraw(returnAmount); + } else { + returnAmount = IERC20(toToken).tokenBalanceOf(address(this)); + } + require(returnAmount >= minReturnAmount, "DODOV1Proxy01: Return amount is not enough"); - - if (toToken == ETH_ADDRESS) IWETH(_WETH_).withdraw(returnAmount); IERC20(toToken).universalTransfer(msg.sender, returnAmount); emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount); @@ -116,12 +120,12 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard { uint256 fromTokenAmount, uint256 minReturnAmount, bytes memory callDataConcat, - uint256 deadline - ) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) { + uint256 deadLine + ) external virtual override payable judgeExpired(deadLine) returns (uint256 returnAmount) { uint256 toTokenOriginBalance = IERC20(toToken).universalBalanceOf(msg.sender); - if (fromToken != ETH_ADDRESS) { - IDODOApprove(dodoApprove).claimTokens( + if (fromToken != _ETH_ADDRESS_) { + IDODOApprove(_DODO_APPROVE_).claimTokens( fromToken, msg.sender, address(this), @@ -130,7 +134,7 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard { IERC20(fromToken).universalApproveMax(approveTarget, fromTokenAmount); } - (bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0}(callDataConcat); + (bool success, ) = to.call{value: fromToken == _ETH_ADDRESS_ ? msg.value : 0}(callDataConcat); require(success, "DODOV1Proxy01: Contract Swap execution Failed"); diff --git a/contracts/SmartRoute/DODOV2Proxy01.sol b/contracts/SmartRoute/DODOV2Proxy01.sol index a4e2cb6..68e0918 100644 --- a/contracts/SmartRoute/DODOV2Proxy01.sol +++ b/contracts/SmartRoute/DODOV2Proxy01.sol @@ -26,12 +26,12 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { // ============ Storage ============ - address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + address constant _ETH_ADDRESS_ = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; address payable public _WETH_; - address public dodoApprove; - address public dodoSellHelper; - address public dvmFactory; - address public dppFactory; + address public _DODO_APPROVE_; + address public _DODO_SELL_HELPER_; + address public _DVM_FACTORY_; + address public _DPP_FACTORY_; // ============ Events ============ @@ -40,14 +40,13 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { address indexed toToken, address indexed sender, uint256 fromAmount, - uint256 returnAmount, - uint256 timeStamp + uint256 returnAmount ); // ============ Modifiers ============ - modifier judgeExpired(uint256 deadline) { - require(deadline >= block.timestamp, "DODOV2Proxy01: EXPIRED"); + modifier judgeExpired(uint256 deadLine) { + require(deadLine >= block.timestamp, "DODOV2Proxy01: EXPIRED"); _; } @@ -56,17 +55,17 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { receive() external payable {} constructor( - address _dvmFactory, - address _dppFactory, - address payable _weth, - address _dodoApprove, - address _dodoSellHelper + address dvmFactory, + address dppFactory, + address payable weth, + address dodoApprove, + address dodoSellHelper ) public { - dvmFactory = _dvmFactory; - dppFactory = _dppFactory; - _WETH_ = _weth; - dodoApprove = _dodoApprove; - dodoSellHelper = _dodoSellHelper; + _DVM_FACTORY_ = dvmFactory; + _DPP_FACTORY_ = dppFactory; + _WETH_ = weth; + _DODO_APPROVE_ = dodoApprove; + _DODO_SELL_HELPER_ = dodoSellHelper; } // ============ DVM Functions (create & add liquidity) ============ @@ -81,20 +80,20 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { uint256 mtFeeRate, uint256 i, uint256 k, - uint256 deadline + uint256 deadLine ) external virtual override payable preventReentrant - judgeExpired(deadline) + judgeExpired(deadLine) returns (address newVendingMachine, uint256 shares) { { - address _baseToken = baseToken == ETH_ADDRESS ? _WETH_ : baseToken; - address _quoteToken = quoteToken == ETH_ADDRESS ? _WETH_ : quoteToken; - newVendingMachine = IDODOV2(dvmFactory).createDODOVendingMachine( + address _baseToken = baseToken == _ETH_ADDRESS_ ? _WETH_ : baseToken; + address _quoteToken = quoteToken == _ETH_ADDRESS_ ? _WETH_ : quoteToken; + newVendingMachine = IDODOV2(_DVM_FACTORY_).createDODOVendingMachine( msg.sender, _baseToken, _quoteToken, @@ -113,14 +112,14 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { newVendingMachine, _baseToken, baseInAmount, - _baseToken == ETH_ADDRESS + _baseToken == _ETH_ADDRESS_ ); _deposit( msg.sender, newVendingMachine, _quoteToken, quoteInAmount, - _quoteToken == ETH_ADDRESS + _quoteToken == _ETH_ADDRESS_ ); } @@ -128,21 +127,21 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { } function addDVMLiquidity( - address DVMAddress, + address dvmAddress, address to, uint256 baseInAmount, uint256 quoteInAmount, uint256 baseMinAmount, uint256 quoteMinAmount, uint8 flag, // 0 - ERC20, 1 - baseInETH, 2 - quoteInETH - uint256 deadline + uint256 deadLine ) external virtual override payable preventReentrant - judgeExpired(deadline) + judgeExpired(deadLine) returns ( uint256 shares, uint256 baseAdjustedInAmount, @@ -150,7 +149,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { ) { (baseAdjustedInAmount, quoteAdjustedInAmount) = _addDVMLiquidity( - DVMAddress, + dvmAddress, baseInAmount, quoteInAmount ); @@ -158,20 +157,23 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { baseAdjustedInAmount >= baseMinAmount && quoteAdjustedInAmount >= quoteMinAmount, "DODOV2Proxy01: deposit amount is not enough" ); - address _dvm = DVMAddress; + address _dvm = dvmAddress; _deposit(msg.sender, _dvm, IDODOV2(_dvm)._BASE_TOKEN_(), baseAdjustedInAmount, flag == 1); _deposit(msg.sender, _dvm, IDODOV2(_dvm)._QUOTE_TOKEN_(), quoteAdjustedInAmount, flag == 2); - + (shares, , ) = IDODOV2(_dvm).buyShares(to); + // refund dust eth + if (flag == 1 && msg.value > baseAdjustedInAmount) msg.sender.transfer(msg.value - baseAdjustedInAmount); + if (flag == 2 && msg.value > quoteAdjustedInAmount) msg.sender.transfer(msg.value - quoteAdjustedInAmount); } function _addDVMLiquidity( - address DVMAddress, + address dvmAddress, uint256 baseInAmount, uint256 quoteInAmount ) internal virtual view returns (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) { - (uint256 baseReserve, uint256 quoteReserve) = IDODOV2(DVMAddress).getVaultReserve(); + (uint256 baseReserve, uint256 quoteReserve) = IDODOV2(dvmAddress).getVaultReserve(); if (quoteReserve == 0 && baseReserve == 0) { baseAdjustedInAmount = baseInAmount; quoteAdjustedInAmount = quoteInAmount; @@ -204,33 +206,33 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { uint256 mtFeeRate, uint256 i, uint256 k, - uint256 deadline + uint256 deadLine ) external virtual override payable preventReentrant - judgeExpired(deadline) + judgeExpired(deadLine) returns (address newPrivatePool) { - newPrivatePool = IDODOV2(dppFactory).createDODOPrivatePool(); + newPrivatePool = IDODOV2(_DPP_FACTORY_).createDODOPrivatePool(); address _baseToken = baseToken; address _quoteToken = quoteToken; - _deposit(msg.sender, newPrivatePool, _baseToken, baseInAmount, _baseToken == ETH_ADDRESS); + _deposit(msg.sender, newPrivatePool, _baseToken, baseInAmount, _baseToken == _ETH_ADDRESS_); _deposit( msg.sender, newPrivatePool, _quoteToken, quoteInAmount, - _quoteToken == ETH_ADDRESS + _quoteToken == _ETH_ADDRESS_ ); - if (_baseToken == ETH_ADDRESS) _baseToken = _WETH_; - if (_quoteToken == ETH_ADDRESS) _quoteToken = _WETH_; + if (_baseToken == _ETH_ADDRESS_) _baseToken = _WETH_; + if (_quoteToken == _ETH_ADDRESS_) _quoteToken = _WETH_; - IDODOV2(dppFactory).initDODOPrivatePool( + IDODOV2(_DPP_FACTORY_).initDODOPrivatePool( newPrivatePool, msg.sender, _baseToken, @@ -243,7 +245,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { } function resetDODOPrivatePool( - address DPPAddress, + address dppAddress, uint256 newLpFeeRate, uint256 newMtFeeRate, uint256 newI, @@ -253,24 +255,24 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { uint256 baseOutAmount, uint256 quoteOutAmount, uint8 flag, // 0 - ERC20, 1 - baseInETH, 2 - quoteInETH, 3 - baseOutETH, 4 - quoteOutETH - uint256 deadline - ) external virtual override payable preventReentrant judgeExpired(deadline) { + uint256 deadLine + ) external virtual override payable preventReentrant judgeExpired(deadLine) { _deposit( msg.sender, - DPPAddress, - IDODOV2(DPPAddress)._BASE_TOKEN_(), + dppAddress, + IDODOV2(dppAddress)._BASE_TOKEN_(), baseInAmount, flag == 1 ); _deposit( msg.sender, - DPPAddress, - IDODOV2(DPPAddress)._QUOTE_TOKEN_(), + dppAddress, + IDODOV2(dppAddress)._QUOTE_TOKEN_(), quoteInAmount, flag == 2 ); - IDODOV2(IDODOV2(DPPAddress)._OWNER_()).reset( + IDODOV2(IDODOV2(dppAddress)._OWNER_()).reset( msg.sender, newLpFeeRate, newMtFeeRate, @@ -280,34 +282,31 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { quoteOutAmount ); - _withdraw(msg.sender, IDODOV2(DPPAddress)._BASE_TOKEN_(), baseOutAmount, flag == 3); - _withdraw(msg.sender, IDODOV2(DPPAddress)._QUOTE_TOKEN_(), quoteOutAmount, flag == 4); + _withdraw(msg.sender, IDODOV2(dppAddress)._BASE_TOKEN_(), baseOutAmount, flag == 3); + _withdraw(msg.sender, IDODOV2(dppAddress)._QUOTE_TOKEN_(), quoteOutAmount, flag == 4); } // ============ Swap ============ - function dodoSwapETHToToken( + function dodoSwapV2ETHToToken( address payable assetTo, address toToken, - uint256 fromTokenAmount, uint256 minReturnAmount, address[] memory dodoPairs, uint8[] memory directions, - uint256 deadline + uint256 deadLine ) external virtual override payable - preventReentrant - judgeExpired(deadline) + judgeExpired(deadLine) returns (uint256 returnAmount) { uint256 originToTokenBalance = IERC20(toToken).balanceOf(msg.sender); - require(msg.value == fromTokenAmount, "DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH"); - IWETH(_WETH_).deposit{value: fromTokenAmount}(); - IWETH(_WETH_).transfer(dodoPairs[0], fromTokenAmount); + IWETH(_WETH_).deposit{value: msg.value}(); + IWETH(_WETH_).transfer(dodoPairs[0], msg.value); for (uint256 i = 0; i < dodoPairs.length; i++) { if (i == dodoPairs.length - 1) { @@ -328,32 +327,30 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { returnAmount = IERC20(toToken).balanceOf(msg.sender).sub(originToTokenBalance); require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough"); emit OrderHistory( - ETH_ADDRESS, + _ETH_ADDRESS_, toToken, assetTo, - fromTokenAmount, - returnAmount, - block.timestamp + msg.value, + returnAmount ); } - function dodoSwapTokenToETH( + function dodoSwapV2TokenToETH( address payable assetTo, address fromToken, uint256 fromTokenAmount, uint256 minReturnAmount, address[] memory dodoPairs, uint8[] memory directions, - uint256 deadline + uint256 deadLine ) external virtual override - preventReentrant - judgeExpired(deadline) + judgeExpired(deadLine) returns (uint256 returnAmount) { - IDODOApprove(dodoApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount); + IDODOApprove(_DODO_APPROVE_).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount); for (uint256 i = 0; i < dodoPairs.length; i++) { if (i == dodoPairs.length - 1) { @@ -376,15 +373,14 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { assetTo.transfer(returnAmount); emit OrderHistory( fromToken, - ETH_ADDRESS, + _ETH_ADDRESS_, assetTo, fromTokenAmount, - returnAmount, - block.timestamp + returnAmount ); } - function dodoSwapTokenToToken( + function dodoSwapV2TokenToToken( address payable assetTo, address fromToken, address toToken, @@ -392,17 +388,16 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { uint256 minReturnAmount, address[] memory dodoPairs, uint8[] memory directions, - uint256 deadline + uint256 deadLine ) external virtual override - preventReentrant - judgeExpired(deadline) + judgeExpired(deadLine) returns (uint256 returnAmount) { uint256 originToTokenBalance = IERC20(toToken).balanceOf(msg.sender); - IDODOApprove(dodoApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount); + IDODOApprove(_DODO_APPROVE_).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount); for (uint256 i = 0; i < dodoPairs.length; i++) { if (i == dodoPairs.length - 1) { @@ -426,8 +421,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { toToken, assetTo, fromTokenAmount, - returnAmount, - block.timestamp + returnAmount ); } @@ -439,18 +433,19 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { uint256 fromTokenAmount, uint256 minReturnAmount, bytes memory callDataConcat, - uint256 deadline + uint256 deadLine ) external virtual override payable - preventReentrant - judgeExpired(deadline) + judgeExpired(deadLine) returns (uint256 returnAmount) { - if (fromToken != ETH_ADDRESS) { - IDODOApprove(dodoApprove).claimTokens( + uint256 toTokenOriginBalance = IERC20(toToken).universalBalanceOf(msg.sender); + + if (fromToken != _ETH_ADDRESS_) { + IDODOApprove(_DODO_APPROVE_).claimTokens( fromToken, msg.sender, address(this), @@ -459,7 +454,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { IERC20(fromToken).universalApproveMax(approveTarget, fromTokenAmount); } - (bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0}(callDataConcat); + (bool success, ) = to.call{value: fromToken == _ETH_ADDRESS_ ? msg.value : 0}(callDataConcat); require(success, "DODOV2Proxy01: Contract Swap execution Failed"); @@ -468,38 +463,40 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { IERC20(fromToken).universalBalanceOf(address(this)) ); - returnAmount = IERC20(toToken).universalBalanceOf(address(this)); + IERC20(toToken).universalTransfer( + msg.sender, + IERC20(toToken).universalBalanceOf(address(this)) + ); + + returnAmount = IERC20(toToken).universalBalanceOf(msg.sender).sub(toTokenOriginBalance); 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 + returnAmount ); } - function dodoSwap( + function dodoSwapV1( address fromToken, address toToken, uint256 fromTokenAmount, uint256 minReturnAmount, address[] memory dodoPairs, uint8[] memory directions, - uint256 deadline + uint256 deadLine ) external virtual override payable - preventReentrant - judgeExpired(deadline) + judgeExpired(deadLine) returns (uint256 returnAmount) { - _deposit(msg.sender, address(this), fromToken, fromTokenAmount, fromToken == ETH_ADDRESS); + _deposit(msg.sender, address(this), fromToken, fromTokenAmount, fromToken == _ETH_ADDRESS_); for (uint256 i = 0; i < dodoPairs.length; i++) { address curDodoPair = dodoPairs[i]; @@ -512,29 +509,58 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { address curDodoQuote = IDODOV1(curDodoPair)._QUOTE_TOKEN_(); uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this)); IERC20(curDodoQuote).universalApproveMax(curDodoPair, curAmountIn); - uint256 canBuyBaseAmount = IDODOSellHelper(dodoSellHelper).querySellQuoteToken( + uint256 canBuyBaseAmount = IDODOSellHelper(_DODO_SELL_HELPER_).querySellQuoteToken( curDodoPair, curAmountIn ); IDODOV1(curDodoPair).buyBaseToken(canBuyBaseAmount, curAmountIn, ""); } } - - returnAmount = IERC20(toToken).universalBalanceOf(address(this)); + + if (toToken == _ETH_ADDRESS_) { + returnAmount = IWETH(_WETH_).balanceOf(address(this)); + IWETH(_WETH_).withdraw(returnAmount); + } else { + returnAmount = IERC20(toToken).tokenBalanceOf(address(this)); + } + require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough"); + IERC20(toToken).universalTransfer(msg.sender, returnAmount); - _withdraw(msg.sender, toToken, returnAmount, toToken == ETH_ADDRESS); - - emit OrderHistory( - fromToken, - toToken, - msg.sender, - fromTokenAmount, - returnAmount, - block.timestamp - ); + emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount); } + + function addLiquidityToV1( + address to, + address pair, + uint256 baseAmount, + uint256 quoteAmount, + uint256 baseMinShares, + uint256 quoteMinShares, + uint8 flag, // 0 erc20 In 1 baseInETH 2 quoteIn ETH + uint256 deadLine + ) external virtual override payable judgeExpired(deadLine) returns(uint256 baseShares, uint256 quoteShares) { + address _baseToken = IDODOV1(pair)._BASE_TOKEN_(); + address _quoteToken = IDODOV1(pair)._QUOTE_TOKEN_(); + + _deposit(msg.sender, address(this), _baseToken, baseAmount, flag == 1); + _deposit(msg.sender, address(this), _quoteToken, quoteAmount, flag == 2); + + + if(baseAmount > 0) { + IERC20(_baseToken).universalApproveMax(pair, baseAmount); + baseShares = IDODOV1(pair).depositBaseTo(to, baseAmount); + } + if(quoteAmount > 0) { + IERC20(_quoteToken).universalApproveMax(pair, quoteAmount); + quoteShares = IDODOV1(pair).depositQuoteTo(to, quoteAmount); + } + + require(baseShares >= baseMinShares && quoteShares >= quoteMinShares,"DODOV2Proxy01: Return DLP is not enough"); + } + + function _deposit( address from, address to, @@ -548,7 +574,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard { if (to != address(this)) SafeERC20.safeTransfer(IERC20(_WETH_), to, amount); } } else { - IDODOApprove(dodoApprove).claimTokens(token, from, to, amount); + IDODOApprove(_DODO_APPROVE_).claimTokens(token, from, to, amount); } } diff --git a/contracts/SmartRoute/helper/DODOCalleeHelper.sol b/contracts/SmartRoute/helper/DODOCalleeHelper.sol index 33c61d6..a2320f0 100644 --- a/contracts/SmartRoute/helper/DODOCalleeHelper.sol +++ b/contracts/SmartRoute/helper/DODOCalleeHelper.sol @@ -25,8 +25,8 @@ contract DODOCalleeHelper is ReentrancyGuard { require(msg.sender == _WETH_, "WE_SAVED_YOUR_ETH"); } - constructor(address payable _weth) public { - _WETH_ = _weth; + constructor(address payable weth) public { + _WETH_ = weth; } function DVMSellShareCall( diff --git a/contracts/SmartRoute/intf/IDODOV1Proxy01.sol b/contracts/SmartRoute/intf/IDODOV1Proxy01.sol index 01867d9..8522581 100644 --- a/contracts/SmartRoute/intf/IDODOV1Proxy01.sol +++ b/contracts/SmartRoute/intf/IDODOV1Proxy01.sol @@ -9,14 +9,14 @@ pragma solidity 0.6.9; pragma experimental ABIEncoderV2; interface IDODOV1Proxy01 { - function dodoSwap( + function dodoSwapV1( address fromToken, address toToken, uint256 fromTokenAmount, uint256 minReturnAmount, address[] memory dodoPairs, uint8[] memory directions, - uint256 deadline + uint256 deadLine ) external payable returns (uint256 returnAmount); function externalSwap( @@ -27,6 +27,6 @@ interface IDODOV1Proxy01 { uint256 fromTokenAmount, uint256 minReturnAmount, bytes memory callDataConcat, - uint256 deadline + uint256 deadLine ) external payable returns (uint256 returnAmount); } diff --git a/contracts/SmartRoute/intf/IDODOV2.sol b/contracts/SmartRoute/intf/IDODOV2.sol index 52f9a88..5a5c9ca 100644 --- a/contracts/SmartRoute/intf/IDODOV2.sol +++ b/contracts/SmartRoute/intf/IDODOV2.sol @@ -38,11 +38,6 @@ interface IDODOV2 { function buyShares(address to) external returns (uint256,uint256,uint256); - // ============= permit ================= - function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; - function sellShares(address to) external returns (uint256,uint256); - // ====================================== - //========== DODOPrivatePool =========== diff --git a/contracts/SmartRoute/intf/IDODOV2Proxy01.sol b/contracts/SmartRoute/intf/IDODOV2Proxy01.sol index 708d893..afb5f54 100644 --- a/contracts/SmartRoute/intf/IDODOV2Proxy01.sol +++ b/contracts/SmartRoute/intf/IDODOV2Proxy01.sol @@ -11,27 +11,26 @@ pragma experimental ABIEncoderV2; import {IDODOV1Proxy01} from "./IDODOV1Proxy01.sol"; interface IDODOV2Proxy01 is IDODOV1Proxy01 { - function dodoSwapETHToToken( + function dodoSwapV2ETHToToken( address payable assetTo, address toToken, - uint256 fromTokenAmount, uint256 minReturnAmount, address[] memory dodoPairs, uint8[] memory directions, - uint256 deadline + uint256 deadLine ) external payable returns (uint256 returnAmount); - function dodoSwapTokenToETH( + function dodoSwapV2TokenToETH( address payable assetTo, address fromToken, uint256 fromTokenAmount, uint256 minReturnAmount, address[] memory dodoPairs, uint8[] memory directions, - uint256 deadline + uint256 deadLine ) external returns (uint256 returnAmount); - function dodoSwapTokenToToken( + function dodoSwapV2TokenToToken( address payable assetTo, address fromToken, address toToken, @@ -39,7 +38,7 @@ interface IDODOV2Proxy01 is IDODOV1Proxy01 { uint256 minReturnAmount, address[] memory dodoPairs, uint8[] memory directions, - uint256 deadline + uint256 deadLine ) external returns (uint256 returnAmount); function createDODOVendingMachine( @@ -52,18 +51,18 @@ interface IDODOV2Proxy01 is IDODOV1Proxy01 { uint256 mtFeeRate, uint256 i, uint256 k, - uint256 deadline + uint256 deadLine ) external payable returns (address newVendingMachine, uint256 shares); function addDVMLiquidity( - address DVMAddress, + address dvmAddress, address to, uint256 baseInAmount, uint256 quoteInAmount, uint256 baseMinAmount, uint256 quoteMinAmount, uint8 flag, // 0 - ERC20, 1 - baseInETH, 2 - quoteInETH - uint256 deadline + uint256 deadLine ) external payable @@ -82,11 +81,11 @@ interface IDODOV2Proxy01 is IDODOV1Proxy01 { uint256 mtFeeRate, uint256 i, uint256 k, - uint256 deadline + uint256 deadLine ) external payable returns (address newPrivatePool); function resetDODOPrivatePool( - address DPPAddress, + address dppAddress, uint256 newLpFeeRate, uint256 newMtFeeRate, uint256 newI, @@ -96,12 +95,18 @@ interface IDODOV2Proxy01 is IDODOV1Proxy01 { uint256 baseOutAmount, uint256 quoteOutAmount, uint8 flag, // 0 - ERC20, 1 - baseInETH, 2 - quoteInETH, 3 - baseOutETH, 4 - quoteOutETH - uint256 deadline + uint256 deadLine ) external payable; - //TODO: addLiquidityToClassical + function addLiquidityToV1( + address to, + address pair, + uint256 baseAmount, + uint256 quoteAmount, + uint256 baseMinShares, + uint256 quoteMinShares, + uint8 flag, // 0 erc20 Out 1 baseOutETH 2 quoteOut ETH + uint256 deadLine + ) external payable returns(uint256, uint256); - //TODO: removeLiquidityToClassical - - //TODO: Compatible with classical swap } diff --git a/contracts/SmartRoute/lib/UniversalERC20.sol b/contracts/SmartRoute/lib/UniversalERC20.sol index 36562d6..a8ca436 100644 --- a/contracts/SmartRoute/lib/UniversalERC20.sol +++ b/contracts/SmartRoute/lib/UniversalERC20.sol @@ -53,6 +53,10 @@ library UniversalERC20 { } } + function tokenBalanceOf(IERC20 token, address who) internal view returns (uint256) { + return token.balanceOf(who); + } + function isETH(IERC20 token) internal pure returns (bool) { return token == ETH_ADDRESS; } diff --git a/test/Proxy/proxy.classical.test.ts b/test/Proxy/proxy.classical.test.ts new file mode 100644 index 0000000..e032f4f --- /dev/null +++ b/test/Proxy/proxy.classical.test.ts @@ -0,0 +1,162 @@ +/* + + Copyright 2020 DODO ZOO. + SPDX-License-Identifier: Apache-2.0 + +*/ + +import { assert } from 'chai'; +import { DODOContext, getDODOContext } from '../utils-v1/Context-route'; +import { ProxyContext, getProxyContext } from '../utils/ProxyContext'; +import { decimalStr, MAX_UINT256, fromWei, mweiStr } from '../utils-v1/Converter'; +import { logGas } from '../utils-v1/Log'; +import * as contracts from '../utils-v1/Contracts'; +import { Contract } from 'web3-eth-contract'; + +let lp: string; +let trader: string; + +async function initDODO_USDT(ctx: DODOContext): Promise { + await ctx.setOraclePrice(ctx.DODO_USDT_ORACLE, mweiStr("0.1")); + lp = ctx.spareAccounts[0]; + trader = ctx.spareAccounts[1]; + + let DODO = ctx.DODO; + let USDT = ctx.USDT; + let DODO_USDT = ctx.DODO_USDT; + await ctx.approvePair(DODO, USDT, DODO_USDT.options.address, lp); + await ctx.approvePair(DODO, USDT, DODO_USDT.options.address, trader); + + await ctx.mintToken(DODO, USDT, lp, decimalStr("10000000"), mweiStr("1000000")); + await ctx.mintToken(DODO, USDT, trader, decimalStr("1000"), mweiStr("1000")); + + await DODO_USDT.methods + .depositBaseTo(lp, decimalStr("10000000")) + .send(ctx.sendParam(lp)); + await DODO_USDT.methods + .depositQuoteTo(lp, mweiStr("1000000")) + .send(ctx.sendParam(lp)); +} + +async function initWETH_USDC(ctx: DODOContext): Promise { + await ctx.setOraclePrice(ctx.WETH_USDC_ORACLE, mweiStr("450")); + lp = ctx.spareAccounts[0]; + trader = ctx.spareAccounts[1]; + + let WETH = ctx.WETH; + let USDC = ctx.USDC; + let WETH_USDC = ctx.WETH_USDC; + + await ctx.approvePair(WETH, USDC, WETH_USDC.options.address, lp); + await ctx.mintToken(null, USDC, lp, decimalStr("0"), mweiStr("3600")); + await ctx.mintToken(null, USDC, trader, decimalStr("0"), mweiStr("100")); + await WETH.methods.deposit().send(ctx.sendParam(lp, '8')); + + await WETH_USDC.methods + .depositBaseTo(lp, decimalStr("8")) + .send(ctx.sendParam(lp)); + await WETH_USDC.methods + .depositQuoteTo(lp, mweiStr("3600")) + .send(ctx.sendParam(lp)); +} + +describe("AddLiquidity", () => { + let snapshotId1: string; + let snapshotId2: string; + let ctxV1: DODOContext; + let ctxV2: ProxyContext; + let DODO_LP: Contract; + let WETH_LP: Contract; + let USDT_LP: Contract; + let USDC_LP: Contract; + + before(async () => { + let ETH = await contracts.newContract( + contracts.WETH_CONTRACT_NAME + ); + ctxV1 = await getDODOContext(ETH.options.address); + ctxV2 = await getProxyContext(ETH.options.address); + await initDODO_USDT(ctxV1); + await initWETH_USDC(ctxV1); + var dodo_dlp = await ctxV1.DODO_USDT.methods._BASE_CAPITAL_TOKEN_().call(); + var usdt_dlp = await ctxV1.DODO_USDT.methods._QUOTE_CAPITAL_TOKEN_().call(); + DODO_LP = contracts.getContractWithAddress(contracts.DODO_LP_TOKEN_CONTRACT_NAME, dodo_dlp); + USDT_LP = contracts.getContractWithAddress(contracts.DODO_LP_TOKEN_CONTRACT_NAME, usdt_dlp); + + var weth_dlp = await ctxV1.WETH_USDC.methods._BASE_CAPITAL_TOKEN_().call(); + var usdc_dlp = await ctxV1.WETH_USDC.methods._QUOTE_CAPITAL_TOKEN_().call(); + WETH_LP = contracts.getContractWithAddress(contracts.DODO_LP_TOKEN_CONTRACT_NAME, weth_dlp); + USDC_LP = contracts.getContractWithAddress(contracts.DODO_LP_TOKEN_CONTRACT_NAME, usdc_dlp); + }); + + beforeEach(async () => { + snapshotId1 = await ctxV1.EVM.snapshot(); + snapshotId2 = await ctxV2.EVM.snapshot(); + }); + + afterEach(async () => { + await ctxV1.EVM.reset(snapshotId1); + await ctxV2.EVM.reset(snapshotId2); + }); + + describe("AddLiquidity", () => { + it("AddLiquidity", async () => { + var b_DODO = await ctxV1.DODO.methods.balanceOf(trader).call() + var b_USDT = await ctxV1.USDT.methods.balanceOf(trader).call() + var dodo_lp = await DODO_LP.methods.balanceOf(trader).call() + var usdt_lp = await USDT_LP.methods.balanceOf(trader).call() + console.log("Before DODO:" + fromWei(b_DODO, 'ether') + "; USDT:" + fromWei(b_USDT, 'mwei')); + console.log("dodo_lp:" + dodo_lp + " usdt_lp:" + usdt_lp); + await ctxV1.DODO.methods.approve(ctxV2.SmartApprove.options.address, MAX_UINT256).send(ctxV2.sendParam(trader)); + await ctxV1.USDT.methods.approve(ctxV2.SmartApprove.options.address, MAX_UINT256).send(ctxV2.sendParam(trader)); + var tx = await logGas(await ctxV2.DODOProxy.methods.addLiquidityToV1( + trader, + ctxV1.DODO_USDT.options.address, + decimalStr("100"), + mweiStr("100"), + 0, + 0, + 0, + Math.floor(new Date().getTime() / 1000 + 60 * 10) + ), ctxV2.sendParam(trader), "addLiquidity"); + var dodo_lp = await DODO_LP.methods.balanceOf(trader).call() + var usdt_lp = await USDT_LP.methods.balanceOf(trader).call() + var a_DODO = await ctxV1.DODO.methods.balanceOf(trader).call() + var a_USDT = await ctxV1.USDT.methods.balanceOf(trader).call() + console.log("After DODO:" + fromWei(a_DODO, 'ether') + "; USDT:" + fromWei(a_USDT, 'mwei')); + assert.equal(dodo_lp,decimalStr("100")); + assert.equal(usdt_lp,mweiStr("100")); + assert.equal(a_DODO,decimalStr("900")); + assert.equal(a_USDT,mweiStr("900")); + }); + + it("AddLiquidity - ETH", async () => { + var b_WETH = await ctxV1.WETH.methods.balanceOf(trader).call() + var b_USDC = await ctxV1.USDC.methods.balanceOf(trader).call() + var b_ETH = await ctxV2.Web3.eth.getBalance(trader); + var weth_lp = await WETH_LP.methods.balanceOf(trader).call() + var usdc_lp = await USDC_LP.methods.balanceOf(trader).call() + console.log("Before WETH:" + fromWei(b_WETH, 'ether') + "; USDC:" + fromWei(b_USDC, 'mwei') + "; ETH:" + fromWei(b_ETH, 'ether')); + console.log("weth_lp:" + weth_lp + " usdc_lp:" + usdc_lp); + await ctxV1.USDC.methods.approve(ctxV2.SmartApprove.options.address, MAX_UINT256).send(ctxV2.sendParam(trader)); + var tx = await logGas(await ctxV2.DODOProxy.methods.addLiquidityToV1( + trader, + ctxV1.WETH_USDC.options.address, + decimalStr("1"), + mweiStr("100"), + 0, + 0, + 1, + Math.floor(new Date().getTime() / 1000 + 60 * 10) + ), ctxV2.sendParam(trader,"1"), "addLiquidity - eth"); + var weth_lp = await WETH_LP.methods.balanceOf(trader).call() + var usdc_lp = await USDC_LP.methods.balanceOf(trader).call() + var a_WETH = await ctxV1.WETH.methods.balanceOf(trader).call() + var a_USDC = await ctxV1.USDC.methods.balanceOf(trader).call() + var a_ETH = await ctxV2.Web3.eth.getBalance(trader); + console.log("After WETH:" + fromWei(a_WETH, 'ether') + "; USDC:" + fromWei(a_USDC, 'mwei') + "; ETH:" + fromWei(a_ETH, 'ether')); + assert.equal(weth_lp,decimalStr("1")); + assert.equal(usdc_lp,mweiStr("100")); + }); + }); +}); diff --git a/test/Proxy/proxy.dpp.test.ts b/test/Proxy/proxy.dpp.test.ts index 2ad3958..8a6d181 100644 --- a/test/Proxy/proxy.dpp.test.ts +++ b/test/Proxy/proxy.dpp.test.ts @@ -5,7 +5,6 @@ */ -// import * as assert from 'assert'; import BigNumber from "bignumber.js"; import { decimalStr, mweiStr } from '../utils/Converter'; import { logGas } from '../utils/Log'; @@ -36,9 +35,6 @@ async function init(ctx: ProxyContext): Promise { await ctx.mintTestToken(lp, ctx.USDT, mweiStr("1000000")); 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); @@ -73,7 +69,10 @@ describe("DODOProxyV2.0", () => { let DPP_WETH_USDT: Contract; before(async () => { - ctx = await getProxyContext(); + let ETH = await contracts.newContract( + contracts.WETH_CONTRACT_NAME + ); + ctx = await getProxyContext(ETH.options.address); await init(ctx); 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); @@ -241,7 +240,7 @@ describe("DODOProxyV2.0", () => { var directions = [ 0 ] - var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken( + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapV2TokenToToken( trader, ctx.DODO.options.address, ctx.USDT.options.address, @@ -271,7 +270,7 @@ describe("DODOProxyV2.0", () => { 0, 1 ] - var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken( + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapV2TokenToToken( trader, ctx.DODO.options.address, ctx.WETH.options.address, @@ -301,10 +300,9 @@ describe("DODOProxyV2.0", () => { 0, 1 ] - var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapETHToToken( + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapV2ETHToToken( trader, ctx.DODO.options.address, - decimalStr("1"), 1, dodoPairs, directions, @@ -333,7 +331,7 @@ describe("DODOProxyV2.0", () => { 0, 1 ] - var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToETH( + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapV2TokenToETH( trader, ctx.DODO.options.address, decimalStr("10000"), diff --git a/test/Proxy/proxy.dvm.test.ts b/test/Proxy/proxy.dvm.test.ts index a8a094c..1e15ef2 100644 --- a/test/Proxy/proxy.dvm.test.ts +++ b/test/Proxy/proxy.dvm.test.ts @@ -5,7 +5,6 @@ */ -// import * as assert from 'assert'; const ethUtil = require('ethereumjs-util'); import { SignHelper } from "../utils/SignHelper"; import BigNumber from "bignumber.js"; @@ -71,9 +70,6 @@ async function init(ctx: ProxyContext): Promise { await ctx.mintTestToken(lp, ctx.USDT, mweiStr("1000000")); 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); @@ -109,7 +105,10 @@ describe("DODOProxyV2.0", () => { let DVM_WETH_USDT: Contract; before(async () => { - ctx = await getProxyContext(); + let ETH = await contracts.newContract( + contracts.WETH_CONTRACT_NAME + ); + ctx = await getProxyContext(ETH.options.address); await init(ctx); dvm_DODO_USDT = await initCreateDVM(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("100000"),mweiStr("30000"), "0",mweiStr("0.3")); DVM_DODO_USDT = contracts.getContractWithAddress(contracts.DVM_NAME,dvm_DODO_USDT); @@ -285,7 +284,7 @@ describe("DODOProxyV2.0", () => { var directions = [ 0 ] - var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken( + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapV2TokenToToken( trader, ctx.DODO.options.address, ctx.USDT.options.address, @@ -316,7 +315,7 @@ describe("DODOProxyV2.0", () => { 0, 1 ] - var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken( + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapV2TokenToToken( trader, ctx.DODO.options.address, ctx.WETH.options.address, @@ -346,10 +345,9 @@ describe("DODOProxyV2.0", () => { 0, 1 ] - var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapETHToToken( + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapV2ETHToToken( trader, ctx.DODO.options.address, - decimalStr("1"), 1, dodoPairs, directions, @@ -378,7 +376,7 @@ describe("DODOProxyV2.0", () => { 0, 1 ] - var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToETH( + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapV2TokenToETH( trader, ctx.DODO.options.address, decimalStr("10000"), diff --git a/test/Proxy/proxy.mix.test.ts b/test/Proxy/proxy.mix.test.ts index 84c9cd0..114f7be 100644 --- a/test/Proxy/proxy.mix.test.ts +++ b/test/Proxy/proxy.mix.test.ts @@ -5,13 +5,11 @@ */ -// import * as assert from 'assert'; 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; @@ -87,7 +85,10 @@ describe("DODOProxyV2.0", () => { let dvm_WETH_USDT: string; before(async () => { - ctx = await getProxyContext(); + let ETH = await contracts.newContract( + contracts.WETH_CONTRACT_NAME + ); + ctx = await getProxyContext(ETH.options.address); await init(ctx); dpp_DODO_USDT = await initCreateDPP(ctx, ctx.DODO.options.address, ctx.USDT.options.address, decimalStr("100000"), mweiStr("30000"), "0", mweiStr("0.3")); dvm_WETH_USDT = await initCreateDVM(ctx, '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', ctx.USDT.options.address, decimalStr("5"), mweiStr("30000"), "5", mweiStr("600")); @@ -117,7 +118,7 @@ describe("DODOProxyV2.0", () => { 0, 1 ] - var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken( + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapV2TokenToToken( trader, ctx.DODO.options.address, ctx.WETH.options.address, @@ -147,10 +148,9 @@ describe("DODOProxyV2.0", () => { 0, 1 ] - var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapETHToToken( + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapV2ETHToToken( trader, ctx.DODO.options.address, - decimalStr("1"), 1, dodoPairs, directions, @@ -179,7 +179,7 @@ describe("DODOProxyV2.0", () => { 0, 1 ] - var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToETH( + var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapV2TokenToETH( trader, ctx.DODO.options.address, decimalStr("10000"), diff --git a/test/Route/Route.test.ts b/test/Route/Route.test.ts index 7ab28e8..0fb4445 100644 --- a/test/Route/Route.test.ts +++ b/test/Route/Route.test.ts @@ -5,12 +5,11 @@ */ -import * as assert from 'assert'; import BigNumber from 'bignumber.js'; import { DODOContext, getDODOContext } from '../utils-v1/Context-route'; import { decimalStr, MAX_UINT256, fromWei, mweiStr } from '../utils-v1/Converter'; import { logGas } from '../utils-v1/Log'; -import { DODOHelper } from '../utils-v1/dodoHelper'; +import * as contracts from '../utils-v1/Contracts'; let lp: string; let trader: string; @@ -90,18 +89,18 @@ async function calcRoute(ctx: DODOContext, fromTokenAmount: string, slippage: nu let curPair = pairs[i] dodoPairs.push(curPair.pair) let curContact = pairs[i].pairContract - if (routes[i].address == '0x000000000000000000000000000000000000000E') { + if (routes[i].address == '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') { directions[i] = 0; swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call(); - console.log(i + "-swapAmount:", swapAmount); + // console.log(i + "-swapAmount:", swapAmount); } else if (curPair.base === routes[i].address) { directions[i] = 0; swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call(); - console.log(i + "-swapAmount:", swapAmount); + // console.log(i + "-swapAmount:", swapAmount); } else { directions[i] = 1; swapAmount = await ctx.DODOSellHelper.methods.querySellQuoteToken(curPair.pair, swapAmount).call(); - console.log(i + "-swapAmount:", swapAmount); + // console.log(i + "-swapAmount:", swapAmount); } } @@ -110,7 +109,7 @@ async function calcRoute(ctx: DODOContext, fromTokenAmount: string, slippage: nu console.log("minAmount:",toAmount); let deadline = Math.floor(new Date().getTime()/1000 + 60 * 10); - return ctx.SmartSwap.methods.dodoSwap( + return ctx.SmartSwap.methods.dodoSwapV1( routes[0].address, routes[routes.length - 1].address, fromTokenAmount, @@ -126,7 +125,10 @@ describe("Trader", () => { let ctx: DODOContext; before(async () => { - ctx = await getDODOContext(); + let ETH = await contracts.newContract( + contracts.WETH_CONTRACT_NAME + ); + ctx = await getDODOContext(ETH.options.address); await initDODO_USDT(ctx); await initUSDT_USDC(ctx); await initWETH_USDC(ctx); @@ -276,7 +278,7 @@ describe("Trader", () => { console.log("weth contract Before:" + fromWei(b_w_eth, 'ether')) //set route path var routes = [{ - address: "0x000000000000000000000000000000000000000E", + address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", decimals: 18 }, { address: ctx.USDC.options.address, @@ -315,7 +317,7 @@ describe("Trader", () => { console.log("weth contract Before:" + fromWei(b_w_eth, 'ether')) //set route path var routes = [{ - address: "0x000000000000000000000000000000000000000E", + address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", decimals: 18 }, { address: ctx.USDC.options.address, @@ -373,7 +375,7 @@ describe("Trader", () => { address: ctx.USDC.options.address, decimals: 6 }, { - address: "0x000000000000000000000000000000000000000E", + address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", decimals: 18 }]; diff --git a/test/utils-v1/Context-route.ts b/test/utils-v1/Context-route.ts index 3c25e69..a8261d6 100644 --- a/test/utils-v1/Context-route.ts +++ b/test/utils-v1/Context-route.ts @@ -69,14 +69,13 @@ export class DODOContext { DODO_USDT_ORACLE: Contract; USDT_USDC_ORACLE: Contract; WETH_USDC_ORACLE: Contract; - //SmartRoute SmartSwap: Contract; SmartApprove: Contract; DODOSellHelper: Contract; constructor() { } - async init(config: DODOContextInitConfig) { + async init(config: DODOContextInitConfig,weth:string) { this.k = config.k; this.mtFeeRate = config.mtFeeRate; this.lpFeeRate = config.lpFeeRate; @@ -115,9 +114,8 @@ export class DODOContext { contracts.TEST_ERC20_CONTRACT_NAME, ["USDC", 6] ); - this.WETH = await contracts.newContract( - contracts.WETH_CONTRACT_NAME - ); + + this.WETH = contracts.getContractWithAddress(contracts.WETH_CONTRACT_NAME, weth); //创建交易对 @@ -227,7 +225,7 @@ export class DODOContext { [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)); + await this.SmartApprove.methods.setDODOProxy(this.SmartSwap.options.address).send(this.sendParam(this.Deployer)); console.log(log.blueText("[Init dodo context]")); } @@ -266,9 +264,9 @@ export class DODOContext { } export async function getDODOContext( - config: DODOContextInitConfig = DefaultDODOContextInitConfig + weth:string, config: DODOContextInitConfig = DefaultDODOContextInitConfig ): Promise { var context = new DODOContext(); - await context.init(config); + await context.init(config,weth); return context; } diff --git a/test/utils-v1/Contracts.ts b/test/utils-v1/Contracts.ts index b7ddecd..fefa093 100644 --- a/test/utils-v1/Contracts.ts +++ b/test/utils-v1/Contracts.ts @@ -26,9 +26,9 @@ const DODOToken = require(`${jsonPath}DODOToken.json`) const DODOMine = require(`${jsonPath}DODOMine.json`) const DODOMineReader = require(`${jsonPath}DODOMineReader.json`) const LockedTokenVault = require(`${jsonPath}LockedTokenVault.json`) -/*v1.5*/ -const SmartSwap = require(`${jsonPath2}SmartSwap.json`) -const SmartApprove = require(`${jsonPath2}SmartApprove.json`) +/*v1.5 */ +const SmartSwap = require(`${jsonPath2}DODOV1Proxy01.json`) +const SmartApprove = require(`${jsonPath2}DODOApprove.json`) const DODOSellHelper = require(`${jsonPath2}DODOSellHelper.json`) const WETH = require(`${jsonPath2}WETH9.json`) /******/ @@ -51,9 +51,9 @@ export const DODO_TOKEN_CONTRACT_NAME = "DODOToken" export const LOCKED_TOKEN_VAULT_CONTRACT_NAME = "LockedTokenVault" export const DODO_MINE_NAME = "DODOMine" export const DODO_MINE_READER_NAME = "DODOMineReader" -/*v1.5*/ -export const SMART_SWAP = "SmartSwap" -export const SMART_APPROVE = "SmartApprove" +/*v1.5 */ +export const SMART_SWAP = "DODOV1Proxy01" +export const SMART_APPROVE = "DODOApprove" export const DODO_SELL_HELPER = "DODOSellHelper" /******/ @@ -72,7 +72,7 @@ contractMap[DODO_TOKEN_CONTRACT_NAME] = DODOToken contractMap[LOCKED_TOKEN_VAULT_CONTRACT_NAME] = LockedTokenVault contractMap[DODO_MINE_NAME] = DODOMine contractMap[DODO_MINE_READER_NAME] = DODOMineReader -/*v1.5*/ +/*v1.5 */ contractMap[SMART_SWAP] = SmartSwap contractMap[SMART_APPROVE] = SmartApprove contractMap[DODO_SELL_HELPER] = DODOSellHelper diff --git a/test/utils/ProxyContext.ts b/test/utils/ProxyContext.ts index c58cf7b..6b734e1 100644 --- a/test/utils/ProxyContext.ts +++ b/test/utils/ProxyContext.ts @@ -41,7 +41,7 @@ export class ProxyContext { constructor() { } - async init() { + async init(weth:string) { this.EVM = new EVM(); this.Web3 = getDefaultWeb3(); @@ -50,9 +50,7 @@ export class ProxyContext { this.Maintainer = allAccounts[1]; this.SpareAccounts = allAccounts.slice(2, 10); - this.WETH = await contracts.newContract( - contracts.WETH_CONTRACT_NAME - ); + this.WETH = contracts.getContractWithAddress(contracts.WETH_CONTRACT_NAME, weth); var cloneFactory = await contracts.newContract( contracts.CLONE_FACTORY_CONTRACT_NAME @@ -132,7 +130,6 @@ export class ProxyContext { return { from: sender, gas: process.env["COVERAGE"] ? 10000000000 : 7000000, - // gasPrice: process.env.GAS_PRICE, gasPrice: mweiStr("1000"), value: decimalStr(value), }; @@ -155,8 +152,8 @@ export class ProxyContext { } } -export async function getProxyContext(): Promise { +export async function getProxyContext(weth:string): Promise { var context = new ProxyContext(); - await context.init(); + await context.init(weth); return context; } diff --git a/truffle-test.sh b/truffle-test.sh index fa07378..27aeca5 100644 --- a/truffle-test.sh +++ b/truffle-test.sh @@ -16,6 +16,10 @@ then truffle test ./test/Proxy/proxy.mix.test.ts fi +if [ "$1"x = "proxy-classical"x ] +then + truffle test ./test/Proxy/proxy.classical.test.ts +fi if [ "$1"x = "route"x ] then