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

第一次走查

Browse Source
This commit is contained in:
mingda
2020-11-28 17:44:39 +08:00
parent 7fc0ede7ea
commit 13904ae413
27 changed files with 667 additions and 856 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
contracts/SmartRoute/DODOApprove.sol
View File

@@ -29,7 +29,9 @@ contract DODOApprove is Ownable {
address dest,
uint256 amount
) external {
require(msg.sender == dodoProxy, 'DODOApprove:Access restricted');
IERC20(token).safeTransferFrom(who, dest, amount);
require(msg.sender == dodoProxy, "DODOApprove:Access restricted");
if (amount > 0) {
IERC20(token).safeTransferFrom(who, dest, amount);
}
}
}

64
contracts/SmartRoute/DODOV1Proxy01.sol
View File

@@ -9,14 +9,13 @@ pragma solidity 0.6.9;
import {Ownable} from "../lib/Ownable.sol";
import {IERC20} from "../intf/IERC20.sol";
import {UniversalERC20} from "../lib/UniversalERC20.sol";
import {UniversalERC20} from "./UniversalERC20.sol";
import {SafeMath} from "../lib/SafeMath.sol";
import {IDODOSellHelper} from "../intf/IDODOSellHelper.sol";
import {IDODOApprove} from "../intf/IDODOApprove.sol";
import {IDODO} from "../intf/IDODO.sol";
import {IWETH} from "../intf/IWETH.sol";
contract DODOV1Proxy01 is Ownable {
using SafeMath for uint256;
using UniversalERC20 for IERC20;
@@ -27,7 +26,7 @@ contract DODOV1Proxy01 is Ownable {
address payable public _WETH_;
modifier judgeExpired(uint256 deadline) {
require(deadline >= block.timestamp, 'DODOV1Proxy01: EXPIRED');
require(deadline >= block.timestamp, "DODOV1Proxy01: EXPIRED");
_;
}
@@ -63,12 +62,15 @@ contract DODOV1Proxy01 is Ownable {
uint256[] memory directions,
uint256 deadline
) public payable judgeExpired(deadline) returns (uint256 returnAmount) {
require(minReturnAmount > 0, 'DODOV1Proxy01: Min return should be bigger then 0.');
if (fromToken != ETH_ADDRESS) {
IDODOApprove(dodoApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
IDODOApprove(dodoApprove).claimTokens(
fromToken,
msg.sender,
address(this),
fromTokenAmount
);
} else {
require(msg.value == fromTokenAmount, 'DODOV1Proxy01: ETH_AMOUNT_NOT_MATCH');
require(msg.value == fromTokenAmount, "DODOV1Proxy01: ETH_AMOUNT_NOT_MATCH");
IWETH(_WETH_).deposit{value: fromTokenAmount}();
}
@@ -98,9 +100,16 @@ contract DODOV1Proxy01 is Ownable {
returnAmount = IERC20(toToken).universalBalanceOf(address(this));
require(returnAmount >= minReturnAmount, 'DODOV1Proxy01: Return amount is not enough');
require(returnAmount >= minReturnAmount, "DODOV1Proxy01: Return amount is not enough");
IERC20(toToken).universalTransfer(msg.sender, returnAmount);
emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
emit OrderHistory(
fromToken,
toToken,
msg.sender,
fromTokenAmount,
returnAmount,
block.timestamp
);
}
function externalSwap(
@@ -112,24 +121,37 @@ contract DODOV1Proxy01 is Ownable {
uint256 minReturnAmount,
bytes memory callDataConcat,
uint256 deadline
) public payable judgeExpired(deadline) returns (uint256 returnAmount) {
require(minReturnAmount > 0, 'DODOV1Proxy01: Min return should be bigger then 0.');
) public payable judgeExpired(deadline) returns (uint256 returnAmount) {
if (fromToken != ETH_ADDRESS) {
IDODOApprove(dodoApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
IERC20(fromToken).universalApprove(approveTarget, fromTokenAmount);
IDODOApprove(dodoApprove).claimTokens(
fromToken,
msg.sender,
address(this),
fromTokenAmount
);
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");
IERC20(fromToken).universalTransfer(
msg.sender,
IERC20(fromToken).universalBalanceOf(address(this))
);
require(success, 'DODOV1Proxy01: Contract Swap execution Failed');
returnAmount = IERC20(toToken).universalBalanceOf(address(this));
require(returnAmount >= minReturnAmount, 'DODOV1Proxy01: Return amount is not enough');
require(returnAmount >= minReturnAmount, "DODOV1Proxy01: Return amount is not enough");
IERC20(toToken).universalTransfer(msg.sender, returnAmount);
emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
emit OrderHistory(
fromToken,
toToken,
msg.sender,
fromTokenAmount,
returnAmount,
block.timestamp
);
}
}

424
contracts/SmartRoute/DODOV2Proxy01.sol
View File

@@ -12,7 +12,8 @@ import {IDODOV2} from "../intf/IDODOV2.sol";
import {IERC20} from "../intf/IERC20.sol";
import {IWETH} from "../intf/IWETH.sol";
import {SafeMath} from "../lib/SafeMath.sol";
import {UniversalERC20} from "../lib/UniversalERC20.sol";
import {UniversalERC20} from "./UniversalERC20.sol";
import {SafeERC20} from "../lib/SafeERC20.sol";
import {DecimalMath} from "../lib/DecimalMath.sol";
contract DODOV2Proxy01 is IDODOV2Proxy01 {
@@ -22,12 +23,11 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address payable public _WETH_;
address public dodoApprove;
address public dodoSellHelper;
address public dvmFactory;
address public dppFactory;
modifier judgeExpired(uint256 deadline) {
require(deadline >= block.timestamp, 'DODOV2Proxy01: EXPIRED');
require(deadline >= block.timestamp, "DODOV2Proxy01: EXPIRED");
_;
}
@@ -44,22 +44,21 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 returnAmount,
uint256 timeStamp
);
//========================================================================
constructor(
address _dvmFactory,
address _dppFactory,
address payable _weth,
address _dodoApprove,
address _dodoSellHelper
address _dodoApprove
) public {
dvmFactory = _dvmFactory;
dppFactory = _dppFactory;
_WETH_ = _weth;
dodoApprove = _dodoApprove;
dodoSellHelper = _dodoSellHelper;
}
function createDODOVendingMachine(
address assetTo,
address baseToken,
@@ -71,39 +70,55 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 i,
uint256 k,
uint256 deadline
) external virtual override payable judgeExpired(deadline) returns (address newVendingMachine,uint256 shares) {
)
external
virtual
override
payable
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(msg.sender, _baseToken, _quoteToken, lpFeeRate, mtFeeRate, i, k);
address _baseToken = baseToken == ETH_ADDRESS ? _WETH_ : baseToken;
address _quoteToken = quoteToken == ETH_ADDRESS ? _WETH_ : quoteToken;
newVendingMachine = IDODOV2(dvmFactory).createDODOVendingMachine(
msg.sender,
_baseToken,
_quoteToken,
lpFeeRate,
mtFeeRate,
i,
k
);
}
if(baseInAmount > 0){
if(baseToken != ETH_ADDRESS){
IDODOV2(dodoApprove).claimTokens(baseToken, msg.sender, newVendingMachine, baseInAmount);
}else {
require(msg.value == baseInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: baseInAmount}();
assert(IWETH(_WETH_).transfer(newVendingMachine, baseInAmount));
}
}
if(quoteInAmount > 0){
if(quoteToken != ETH_ADDRESS){
IDODOV2(dodoApprove).claimTokens(quoteToken, msg.sender, newVendingMachine, quoteInAmount);
}else {
require(msg.value == quoteInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: quoteInAmount}();
assert(IWETH(_WETH_).transfer(newVendingMachine, quoteInAmount));
}
}
(shares,,) = IDODOV2(newVendingMachine).buyShares(assetTo);
}
{
address _baseToken = baseToken;
address _quoteToken = quoteToken;
_deposit(
msg.sender,
newVendingMachine,
_baseToken,
baseInAmount,
_baseToken == ETH_ADDRESS
);
_deposit(
msg.sender,
newVendingMachine,
_quoteToken,
quoteInAmount,
_quoteToken == ETH_ADDRESS
);
}
(shares, , ) = IDODOV2(newVendingMachine).buyShares(assetTo);
}
function _addDVMLiquidity(
address DVMAddress,
uint256 baseInAmount,
uint256 quoteInAmount
) internal virtual view returns (uint baseAdjustedInAmount, uint quoteAdjustedInAmount) {
) internal virtual view returns (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) {
(uint256 baseReserve, uint256 quoteReserve) = IDODOV2(DVMAddress).getVaultReserve();
if (quoteReserve == 0 && baseReserve == 0) {
baseAdjustedInAmount = baseInAmount;
@@ -133,59 +148,35 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 quoteInAmount,
uint256 baseMinAmount,
uint256 quoteMinAmount,
uint8 flag, // 0 - ERC20, 1 - baseInETH, 2 - quoteInETH
uint256 deadline
) external virtual override judgeExpired(deadline) returns (uint256 shares,uint256 baseAdjustedInAmount,uint256 quoteAdjustedInAmount) {
(baseAdjustedInAmount, quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount);
require(baseAdjustedInAmount >= baseMinAmount && quoteAdjustedInAmount >= quoteMinAmount, 'DODOV2Proxy01: deposit amount is not enough');
)
external
virtual
override
payable
judgeExpired(deadline)
returns (
uint256 shares,
uint256 baseAdjustedInAmount,
uint256 quoteAdjustedInAmount
)
{
(baseAdjustedInAmount, quoteAdjustedInAmount) = _addDVMLiquidity(
DVMAddress,
baseInAmount,
quoteInAmount
);
require(
baseAdjustedInAmount >= baseMinAmount && quoteAdjustedInAmount >= quoteMinAmount,
"DODOV2Proxy01: deposit amount is not enough"
);
address _dvm = DVMAddress;
if(baseAdjustedInAmount > 0) {
IDODOV2(dodoApprove).claimTokens(IDODOV2(_dvm)._BASE_TOKEN_(), msg.sender, _dvm, baseAdjustedInAmount);
}
if(quoteAdjustedInAmount > 0)
IDODOV2(dodoApprove).claimTokens(IDODOV2(_dvm)._QUOTE_TOKEN_(), msg.sender, _dvm, quoteAdjustedInAmount);
(shares,,) = IDODOV2(_dvm).buyShares(to);
}
function addDVMLiquidityETH(
address DVMAddress,
address to,
uint256 baseInAmount,
uint256 quoteInAmount,
uint256 baseMinAmount,
uint256 quoteMinAmount,
uint8 flag, // 1 - baseInETH, 2 - quoteInETH
uint256 deadline
) external virtual override payable judgeExpired(deadline) returns (uint256 shares,uint256 baseAdjustedInAmount,uint256 quoteAdjustedInAmount) {
(baseAdjustedInAmount, quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount);
require(baseAdjustedInAmount >= baseMinAmount && quoteAdjustedInAmount >= quoteMinAmount, 'DODOV2Proxy01: deposit amount is not enough');
address _dvm = DVMAddress;
if(baseAdjustedInAmount > 0) {
if(flag == 1) {
require(msg.value >= baseAdjustedInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: baseAdjustedInAmount}();
assert(IWETH(_WETH_).transfer(_dvm, baseAdjustedInAmount));
if (msg.value > baseAdjustedInAmount) {
(bool success,) = msg.sender.call{value:msg.value - baseAdjustedInAmount}(new bytes(0));
require(success, 'DODOV2Proxy01: ETH_TRANSFER_FAILED');
}
}else {
IDODOV2(dodoApprove).claimTokens(IDODOV2(_dvm)._BASE_TOKEN_(), msg.sender, _dvm, baseAdjustedInAmount);
}
}
if(quoteAdjustedInAmount > 0){
if(flag == 2) {
require(msg.value >= quoteAdjustedInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: quoteAdjustedInAmount}();
assert(IWETH(_WETH_).transfer(_dvm, quoteAdjustedInAmount));
if (msg.value > quoteAdjustedInAmount) {
(bool success,) = msg.sender.call{value:msg.value - quoteAdjustedInAmount}(new bytes(0));
require(success, 'DODOV2Proxy01: ETH_TRANSFER_FAILED');
}
}else {
IDODOV2(dodoApprove).claimTokens(IDODOV2(_dvm)._QUOTE_TOKEN_(), msg.sender, _dvm, quoteAdjustedInAmount);
}
}
(shares,,) = IDODOV2(_dvm).buyShares(to);
_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);
}
function createDODOPrivatePool(
@@ -200,31 +191,26 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 deadline
) external virtual override payable judgeExpired(deadline) returns (address newPrivatePool) {
newPrivatePool = IDODOV2(dppFactory).createDODOPrivatePool();
if(baseInAmount > 0){
if(baseToken != ETH_ADDRESS){
IDODOV2(dodoApprove).claimTokens(baseToken, msg.sender, newPrivatePool, baseInAmount);
}else {
require(msg.value == baseInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: baseInAmount}();
assert(IWETH(_WETH_).transfer(newPrivatePool, baseInAmount));
baseToken = _WETH_;
}
}
if(quoteInAmount > 0){
if(quoteToken != ETH_ADDRESS){
IDODOV2(dodoApprove).claimTokens(quoteToken, msg.sender, newPrivatePool, quoteInAmount);
}else {
require(msg.value == quoteInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: quoteInAmount}();
assert(IWETH(_WETH_).transfer(newPrivatePool, quoteInAmount));
quoteToken = _WETH_;
}
}
address _baseToken = baseToken;
address _quoteToken = quoteToken;
_deposit(msg.sender, newPrivatePool, _baseToken, baseInAmount, _baseToken == ETH_ADDRESS);
_deposit(
msg.sender,
newPrivatePool,
_quoteToken,
quoteInAmount,
_quoteToken == ETH_ADDRESS
);
if (_baseToken == ETH_ADDRESS) _baseToken = _WETH_;
if (_quoteToken == ETH_ADDRESS) _quoteToken = _WETH_;
IDODOV2(dppFactory).initDODOPrivatePool(
newPrivatePool,
msg.sender,
baseToken,
quoteToken,
_baseToken,
_quoteToken,
lpFeeRate,
mtFeeRate,
k,
@@ -242,12 +228,24 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 quoteInAmount,
uint256 baseOutAmount,
uint256 quoteOutAmount,
uint8 flag, // 0 - ERC20, 1 - baseInETH, 2 - quoteInETH, 3 - baseOutETH, 4 - quoteOutETH
uint256 deadline
) external virtual override judgeExpired(deadline) {
if(baseInAmount > 0)
IDODOV2(dodoApprove).claimTokens(IDODOV2(DPPAddress)._BASE_TOKEN_(), msg.sender, DPPAddress, baseInAmount);
if(quoteInAmount > 0)
IDODOV2(dodoApprove).claimTokens(IDODOV2(DPPAddress)._QUOTE_TOKEN_(), msg.sender, DPPAddress, quoteInAmount);
) external virtual override payable judgeExpired(deadline) {
_deposit(
msg.sender,
DPPAddress,
IDODOV2(DPPAddress)._BASE_TOKEN_(),
baseInAmount,
flag == 1
);
_deposit(
msg.sender,
DPPAddress,
IDODOV2(DPPAddress)._QUOTE_TOKEN_(),
quoteInAmount,
flag == 2
);
IDODOV2(IDODOV2(DPPAddress)._OWNER_()).reset(
msg.sender,
newLpFeeRate,
@@ -257,81 +255,9 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
baseOutAmount,
quoteOutAmount
);
}
function resetDODOPrivatePoolETH(
address DPPAddress,
uint256 newLpFeeRate,
uint256 newMtFeeRate,
uint256 newI,
uint256 newK,
uint256 baseInAmount,
uint256 quoteInAmount,
uint256 baseOutAmount,
uint256 quoteOutAmount,
uint8 flag, // 1 - baseInETH, 2 - quoteInETH, 3 - baseOutETH, 4 - quoteOutETH
uint256 deadline
) external virtual override payable judgeExpired(deadline) {
if(baseInAmount > 0){
if(flag == 1){
require(msg.value == baseInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: baseInAmount}();
assert(IWETH(_WETH_).transfer(DPPAddress, baseInAmount));
}else {
IDODOV2(dodoApprove).claimTokens(IDODOV2(DPPAddress)._BASE_TOKEN_(), msg.sender, DPPAddress, baseInAmount);
}
}
if(quoteInAmount > 0){
if(flag == 2){
require(msg.value == quoteInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: quoteInAmount}();
assert(IWETH(_WETH_).transfer(DPPAddress, quoteInAmount));
}else {
IDODOV2(dodoApprove).claimTokens(IDODOV2(DPPAddress)._QUOTE_TOKEN_(), msg.sender, DPPAddress, quoteInAmount);
}
}
if( (flag == 3 && baseOutAmount > 0) || (flag == 4 && quoteOutAmount > 0) ) {
IDODOV2(IDODOV2(DPPAddress)._OWNER_()).resetETH(
msg.sender,
newLpFeeRate,
newMtFeeRate,
newI,
newK,
baseOutAmount,
quoteOutAmount
);
if(baseOutAmount > 0) {
if(flag == 3) {
uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this));
IWETH(_WETH_).withdraw(wethAmount);
(bool success,) = msg.sender.call{value:wethAmount}(new bytes(0));
require(success, 'DODOV2Proxy01: ETH_TRANSFER_FAILED');
}else {
IERC20(IDODOV2(DPPAddress)._BASE_TOKEN_()).universalTransfer(msg.sender, baseOutAmount);
}
}
if(quoteOutAmount > 0) {
if(flag == 4) {
uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this));
IWETH(_WETH_).withdraw(wethAmount);
(bool success,) = msg.sender.call{value:wethAmount}(new bytes(0));
require(success, 'DODOV2Proxy01: ETH_TRANSFER_FAILED');
}else {
IERC20(IDODOV2(DPPAddress)._QUOTE_TOKEN_()).universalTransfer(msg.sender, quoteOutAmount);
}
}
}else {
IDODOV2(IDODOV2(DPPAddress)._OWNER_()).reset(
msg.sender,
newLpFeeRate,
newMtFeeRate,
newI,
newK,
baseOutAmount,
quoteOutAmount
);
}
_withdraw(msg.sender, IDODOV2(DPPAddress)._BASE_TOKEN_(), baseOutAmount, flag == 3);
_withdraw(msg.sender, IDODOV2(DPPAddress)._QUOTE_TOKEN_(), quoteOutAmount, flag == 4);
}
function dodoSwapETHToToken(
@@ -343,28 +269,38 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256[] memory directions,
uint256 deadline
) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) {
require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.');
require(msg.value == fromTokenAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
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],IWETH(_WETH_).balanceOf(address(this)));
IWETH(_WETH_).transfer(dodoPairs[0], fromTokenAmount);
for (uint256 i = 0; i < dodoPairs.length; i++) {
if(i == dodoPairs.length - 1){
if (i == dodoPairs.length - 1) {
if (directions[i] == 0) {
returnAmount = IDODOV2(dodoPairs[i]).sellBase(assetTo);
IDODOV2(dodoPairs[i]).sellBase(assetTo);
} else {
returnAmount = IDODOV2(dodoPairs[i]).sellQuote(assetTo);
IDODOV2(dodoPairs[i]).sellQuote(assetTo);
}
} else {
if (directions[i] == 0) {
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i+1]);
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i + 1]);
} else {
IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i+1]);
IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i + 1]);
}
}
}
require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough');
emit OrderHistory(ETH_ADDRESS, toToken, assetTo, fromTokenAmount, returnAmount, block.timestamp);
returnAmount = IERC20(toToken).balanceOf(msg.sender).sub(originToTokenBalance);
require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough");
emit OrderHistory(
ETH_ADDRESS,
toToken,
assetTo,
fromTokenAmount,
returnAmount,
block.timestamp
);
}
function dodoSwapTokenToETH(
@@ -376,11 +312,10 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256[] memory directions,
uint256 deadline
) external virtual override judgeExpired(deadline) returns (uint256 returnAmount) {
require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.');
IDODOV2(dodoApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
for (uint256 i = 0; i < dodoPairs.length; i++) {
if(i == dodoPairs.length - 1){
if (i == dodoPairs.length - 1) {
if (directions[i] == 0) {
IDODOV2(dodoPairs[i]).sellBase(address(this));
} else {
@@ -388,20 +323,26 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
}
} else {
if (directions[i] == 0) {
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i+1]);
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i + 1]);
} else {
IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i+1]);
IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i + 1]);
}
}
}
returnAmount = IWETH(_WETH_).balanceOf(address(this));
require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough");
IWETH(_WETH_).withdraw(returnAmount);
require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough');
IERC20(ETH_ADDRESS).universalTransfer(assetTo, returnAmount);
emit OrderHistory(fromToken, ETH_ADDRESS, assetTo, fromTokenAmount, returnAmount, block.timestamp);
assetTo.transfer(returnAmount);
emit OrderHistory(
fromToken,
ETH_ADDRESS,
assetTo,
fromTokenAmount,
returnAmount,
block.timestamp
);
}
function dodoSwapTokenToToken(
address payable assetTo,
address fromToken,
@@ -412,26 +353,34 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256[] memory directions,
uint256 deadline
) external virtual override judgeExpired(deadline) returns (uint256 returnAmount) {
require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.');
uint256 originToTokenBalance = IERC20(toToken).balanceOf(msg.sender);
IDODOV2(dodoApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
for (uint256 i = 0; i < dodoPairs.length; i++) {
if(i == dodoPairs.length - 1){
if (i == dodoPairs.length - 1) {
if (directions[i] == 0) {
returnAmount = IDODOV2(dodoPairs[i]).sellBase(assetTo);
IDODOV2(dodoPairs[i]).sellBase(assetTo);
} else {
returnAmount = IDODOV2(dodoPairs[i]).sellQuote(assetTo);
IDODOV2(dodoPairs[i]).sellQuote(assetTo);
}
} else {
if (directions[i] == 0) {
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i+1]);
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i + 1]);
} else {
IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i+1]);
IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i + 1]);
}
}
}
require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough');
emit OrderHistory(fromToken, toToken, assetTo, fromTokenAmount, returnAmount, block.timestamp);
returnAmount = IERC20(toToken).balanceOf(msg.sender).sub(originToTokenBalance);
require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough");
emit OrderHistory(
fromToken,
toToken,
assetTo,
fromTokenAmount,
returnAmount,
block.timestamp
);
}
function externalSwap(
@@ -444,21 +393,64 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
bytes memory callDataConcat,
uint256 deadline
) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) {
require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger then 0.');
if (fromToken != ETH_ADDRESS) {
IDODOV2(dodoApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
IERC20(fromToken).universalApprove(approveTarget, fromTokenAmount);
IERC20(fromToken).universalApproveMax(approveTarget, fromTokenAmount);
}
(bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0}(callDataConcat);
require(success, 'DODOV2Proxy01: Contract Swap execution Failed');
require(success, "DODOV2Proxy01: Contract Swap execution Failed");
IERC20(fromToken).universalTransfer(
msg.sender,
IERC20(fromToken).universalBalanceOf(address(this))
);
IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this)));
returnAmount = IERC20(toToken).universalBalanceOf(address(this));
require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough');
require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough");
IERC20(toToken).universalTransfer(msg.sender, returnAmount);
emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
emit OrderHistory(
fromToken,
toToken,
msg.sender,
fromTokenAmount,
returnAmount,
block.timestamp
);
}
function _deposit(
address from,
address to,
address token,
uint256 amount,
bool isETH
) internal {
if (isETH) {
if (amount > 0) {
IWETH(_WETH_).deposit{value: amount}();
SafeERC20.safeTransfer(IERC20(_WETH_), to, amount);
}
} else {
IDODOV2(dodoApprove).claimTokens(token, from, to, amount);
}
}
function _withdraw(
address to,
address token,
uint256 amount,
bool isETH
) internal {
if (isETH) {
if (amount > 0) {
IWETH(_WETH_).withdraw(amount);
msg.sender.transfer(amount);
}
} else {
SafeERC20.safeTransfer(IERC20(token), to, amount);
}
}
}

59
contracts/SmartRoute/UniversalERC20.sol Normal file
View File

@@ -0,0 +1,59 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
import {SafeMath} from "../lib/SafeMath.sol";
import {IERC20} from "../intf/IERC20.sol";
import {SafeERC20} from "../lib/SafeERC20.sol";
library UniversalERC20 {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
function isETH(IERC20 token) internal pure returns (bool) {
return token == ETH_ADDRESS;
}
function universalTransfer(
IERC20 token,
address payable to,
uint256 amount
) internal {
if (amount > 0) {
if (isETH(token)) {
to.transfer(amount);
} else {
token.safeTransfer(to, amount);
}
}
}
function universalApproveMax(
IERC20 token,
address to,
uint256 amount
) internal {
uint256 allowance = token.allowance(address(this), to);
if (allowance < amount) {
if (allowance > 0) {
token.safeApprove(to, 0);
}
token.safeApprove(to, uint256(-1));
}
}
function universalBalanceOf(IERC20 token, address who) internal view returns (uint256) {
if (isETH(token)) {
return who.balance;
} else {
return token.balanceOf(who);
}
}
}