d-bis/dodo-contractV2
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix && addLiquidityToV1 && test

Browse Source
This commit is contained in:
owen05
2020-12-01 01:47:22 +08:00
parent c3f8e3cc40
commit 21624daa07
17 changed files with 419 additions and 226 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
contracts/SmartRoute/DODOApprove.sol
View File

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

54
contracts/SmartRoute/DODOV1Proxy01.sol
View File

@@ -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");

242
contracts/SmartRoute/DODOV2Proxy01.sol
View File

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

4
contracts/SmartRoute/helper/DODOCalleeHelper.sol
View File

@@ -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(

6
contracts/SmartRoute/intf/IDODOV1Proxy01.sol
View File

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

5
contracts/SmartRoute/intf/IDODOV2.sol
View File

@@ -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 ===========

39
contracts/SmartRoute/intf/IDODOV2Proxy01.sol
View File

@@ -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
}

4
contracts/SmartRoute/lib/UniversalERC20.sol
View File

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

162
test/Proxy/proxy.classical.test.ts Normal file
View File

@@ -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<void> {
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<void> {
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"));
});
});
});

18
test/Proxy/proxy.dpp.test.ts
View File

@@ -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<void> {
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"),

18
test/Proxy/proxy.dvm.test.ts
View File

@@ -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<void> {
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"),

14
test/Proxy/proxy.mix.test.ts
View File

@@ -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"),

24
test/Route/Route.test.ts
View File

@@ -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
}];

14
test/utils-v1/Context-route.ts
View File

@@ -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<DODOContext> {
var context = new DODOContext();
await context.init(config);
await context.init(config,weth);
return context;
}

14
test/utils-v1/Contracts.ts
View File

@@ -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

11
test/utils/ProxyContext.ts
View File

@@ -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<ProxyContext> {
export async function getProxyContext(weth:string): Promise<ProxyContext> {
var context = new ProxyContext();
await context.init();
await context.init(weth);
return context;
}

4
truffle-test.sh
View File

@@ -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