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

第二遍走查 snapshot4

Browse Source
This commit is contained in:
mingda
2020-11-30 16:08:11 +08:00
parent 4550a872f4
commit e5c24453bb
7 changed files with 146 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
contracts/SmartRoute/DODOApprove.sol
View File

@@ -15,7 +15,12 @@ contract DODOApprove is Ownable {
using SafeERC20 for IERC20;
address public dodoProxy;
// ============ Events ============
event SetDODOProxy(address indexed oldProxy, address indexed newProxy);
function setDODOProxy(address _dodoProxy) external onlyOwner {
emit SetDODOProxy(dodoProxy, _dodoProxy);
dodoProxy = _dodoProxy;
}

55
contracts/SmartRoute/DODOV1Proxy01.sol
View File

@@ -11,7 +11,7 @@ import {IERC20} from "../intf/IERC20.sol";
import {UniversalERC20} from "./lib/UniversalERC20.sol";
import {SafeMath} from "../lib/SafeMath.sol";
import {IDODOV1} from "./intf/IDODOV1.sol";
import {IDODOSellHelper} from './helper/DODOSellHelper.sol';
import {IDODOSellHelper} from "./helper/DODOSellHelper.sol";
import {IWETH} from "../intf/IWETH.sol";
import {IDODOApprove} from "../intf/IDODOApprove.sol";
import {IDODOV1Proxy01} from "./intf/IDODOV1Proxy01.sol";
@@ -21,25 +21,30 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard {
using SafeMath for uint256;
using UniversalERC20 for IERC20;
// ============ Storage ============
address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address public dodoApprove;
address public dodoSellHelper;
address payable public _WETH_;
modifier judgeExpired(uint256 deadline) {
require(deadline >= block.timestamp, "DODOV1Proxy01: EXPIRED");
_;
}
// ============ Events ============
event OrderHistory(
address indexed fromToken,
address indexed toToken,
address indexed sender,
uint256 fromAmount,
uint256 returnAmount,
uint256 timeStamp
uint256 returnAmount
);
// ============ Modifiers ============
modifier judgeExpired(uint256 deadline) {
require(deadline >= block.timestamp, "DODOV1Proxy01: EXPIRED");
_;
}
constructor(
address _dodoApprove,
address _dodoSellHelper,
@@ -62,7 +67,7 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard {
address[] memory dodoPairs,
uint8[] memory directions,
uint256 deadline
) external virtual override payable preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) {
if (fromToken != ETH_ADDRESS) {
IDODOApprove(dodoApprove).claimTokens(
fromToken,
@@ -97,18 +102,10 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard {
returnAmount = IERC20(toToken).universalBalanceOf(address(this));
require(returnAmount >= minReturnAmount, "DODOV1Proxy01: Return amount is not enough");
if (toToken == ETH_ADDRESS)
IWETH(_WETH_).withdraw(returnAmount);
if (toToken == ETH_ADDRESS) IWETH(_WETH_).withdraw(returnAmount);
IERC20(toToken).universalTransfer(msg.sender, returnAmount);
emit OrderHistory(
fromToken,
toToken,
msg.sender,
fromTokenAmount,
returnAmount,
block.timestamp
);
emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
}
function externalSwap(
@@ -120,7 +117,9 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard {
uint256 minReturnAmount,
bytes memory callDataConcat,
uint256 deadline
) external virtual override payable preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) {
uint256 toTokenOriginBalance = IERC20(toToken).universalBalanceOf(msg.sender);
if (fromToken != ETH_ADDRESS) {
IDODOApprove(dodoApprove).claimTokens(
fromToken,
@@ -140,17 +139,13 @@ contract DODOV1Proxy01 is IDODOV1Proxy01, ReentrancyGuard {
IERC20(fromToken).universalBalanceOf(address(this))
);
returnAmount = IERC20(toToken).universalBalanceOf(address(this));
require(returnAmount >= minReturnAmount, "DODOV1Proxy01: Return amount is not enough");
IERC20(toToken).universalTransfer(msg.sender, returnAmount);
emit OrderHistory(
fromToken,
toToken,
IERC20(toToken).universalTransfer(
msg.sender,
fromTokenAmount,
returnAmount,
block.timestamp
IERC20(toToken).universalBalanceOf(address(this))
);
returnAmount = IERC20(toToken).universalBalanceOf(msg.sender).sub(toTokenOriginBalance);
require(returnAmount >= minReturnAmount, "DODOV1Proxy01: Return amount is not enough");
emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
}
}

189
contracts/SmartRoute/DODOV2Proxy01.sol
View File

@@ -10,8 +10,8 @@ pragma solidity 0.6.9;
import {IDODOV2Proxy01} from "./intf/IDODOV2Proxy01.sol";
import {IDODOV2} from "./intf/IDODOV2.sol";
import {IDODOV1} from "./intf/IDODOV1.sol";
import {IDODOApprove} from '../intf/IDODOApprove.sol';
import {IDODOSellHelper} from './helper/DODOSellHelper.sol';
import {IDODOApprove} from "../intf/IDODOApprove.sol";
import {IDODOSellHelper} from "./helper/DODOSellHelper.sol";
import {IERC20} from "../intf/IERC20.sol";
import {IWETH} from "../intf/IWETH.sol";
import {SafeMath} from "../lib/SafeMath.sol";
@@ -24,6 +24,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
using SafeMath for uint256;
using UniversalERC20 for IERC20;
// ============ Storage ============
address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address payable public _WETH_;
address public dodoApprove;
@@ -31,15 +33,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
address public dvmFactory;
address public dppFactory;
modifier judgeExpired(uint256 deadline) {
require(deadline >= block.timestamp, "DODOV2Proxy01: EXPIRED");
_;
}
fallback() external payable {}
receive() external payable {}
// ============ Events ============
event OrderHistory(
address indexed fromToken,
@@ -50,6 +44,17 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
uint256 timeStamp
);
// ============ Modifiers ============
modifier judgeExpired(uint256 deadline) {
require(deadline >= block.timestamp, "DODOV2Proxy01: EXPIRED");
_;
}
fallback() external payable {}
receive() external payable {}
constructor(
address _dvmFactory,
address _dppFactory,
@@ -64,6 +69,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
dodoSellHelper = _dodoSellHelper;
}
// ============ DVM Functions (create & add liquidity) ============
function createDODOVendingMachine(
address assetTo,
address baseToken,
@@ -120,33 +127,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
(shares, , ) = IDODOV2(newVendingMachine).buyShares(assetTo);
}
function _addDVMLiquidity(
address DVMAddress,
uint256 baseInAmount,
uint256 quoteInAmount
) internal virtual view returns (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) {
(uint256 baseReserve, uint256 quoteReserve) = IDODOV2(DVMAddress).getVaultReserve();
if (quoteReserve == 0 && baseReserve == 0) {
baseAdjustedInAmount = baseInAmount;
quoteAdjustedInAmount = quoteInAmount;
}
if (quoteReserve == 0 && baseReserve > 0) {
baseAdjustedInAmount = baseInAmount;
quoteAdjustedInAmount = 0;
}
if (quoteReserve > 0 && baseReserve > 0) {
uint256 baseIncreaseRatio = DecimalMath.divFloor(baseInAmount, baseReserve);
uint256 quoteIncreaseRatio = DecimalMath.divFloor(quoteInAmount, quoteReserve);
if (baseIncreaseRatio <= quoteIncreaseRatio) {
baseAdjustedInAmount = baseInAmount;
quoteAdjustedInAmount = DecimalMath.mulFloor(quoteReserve, baseIncreaseRatio);
} else {
quoteAdjustedInAmount = quoteInAmount;
baseAdjustedInAmount = DecimalMath.mulFloor(baseReserve, quoteIncreaseRatio);
}
}
}
function addDVMLiquidity(
address DVMAddress,
address to,
@@ -176,7 +156,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
);
require(
baseAdjustedInAmount >= baseMinAmount && quoteAdjustedInAmount >= quoteMinAmount,
'DODOV2Proxy01: deposit amount is not enough'
"DODOV2Proxy01: deposit amount is not enough"
);
address _dvm = DVMAddress;
@@ -186,43 +166,34 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
(shares, , ) = IDODOV2(_dvm).buyShares(to);
}
// ===================== Permit ======================
function removeDVMLiquidity(
function _addDVMLiquidity(
address DVMAddress,
address payable to,
uint256 sharesAmount,
uint256 baseMinOutAmount,
uint256 quoteMinOutAmount,
uint8 flag, // 0 -ERC20, 1 - baseOutETH, 2 - quoteOutETH
uint256 deadline
) public virtual override preventReentrant judgeExpired(deadline) returns (uint256 baseOutAmount, uint256 quoteOutAmount) {
_deposit(msg.sender,DVMAddress,DVMAddress,sharesAmount,false);
if(flag == 0)
(baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(to);
else
(baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(address(this));
require(baseOutAmount >= baseMinOutAmount && quoteOutAmount >= quoteMinOutAmount, 'DODOV2Proxy01: Return Amount is not enough');
if(flag != 0){
_withdraw(to, IDODOV2(DVMAddress)._BASE_TOKEN_(), baseOutAmount,flag == 1);
_withdraw(to, IDODOV2(DVMAddress)._QUOTE_TOKEN_(), quoteOutAmount, flag == 2);
uint256 baseInAmount,
uint256 quoteInAmount
) internal virtual view returns (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) {
(uint256 baseReserve, uint256 quoteReserve) = IDODOV2(DVMAddress).getVaultReserve();
if (quoteReserve == 0 && baseReserve == 0) {
baseAdjustedInAmount = baseInAmount;
quoteAdjustedInAmount = quoteInAmount;
}
if (quoteReserve == 0 && baseReserve > 0) {
baseAdjustedInAmount = baseInAmount;
quoteAdjustedInAmount = 0;
}
if (quoteReserve > 0 && baseReserve > 0) {
uint256 baseIncreaseRatio = DecimalMath.divFloor(baseInAmount, baseReserve);
uint256 quoteIncreaseRatio = DecimalMath.divFloor(quoteInAmount, quoteReserve);
if (baseIncreaseRatio <= quoteIncreaseRatio) {
baseAdjustedInAmount = baseInAmount;
quoteAdjustedInAmount = DecimalMath.mulFloor(quoteReserve, baseIncreaseRatio);
} else {
quoteAdjustedInAmount = quoteInAmount;
baseAdjustedInAmount = DecimalMath.mulFloor(baseReserve, quoteIncreaseRatio);
}
}
}
function removeDVMLiquidityWithPermit(
address DVMAddress,
address payable to,
uint256 sharesAmount,
uint256 baseMinOutAmount,
uint256 quoteMinOutAmount,
uint8 flag, // 0 -ERC20, 1 - baseOutETH, 2 - quoteOutETH
uint256 deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external virtual override preventReentrant returns (uint256 baseOutAmount, uint256 quoteOutAmount) {
uint256 value = approveMax ? uint256(-1) : sharesAmount;
IDODOV2(DVMAddress).permit(msg.sender, dodoApprove, value, deadline, v, r, s);
(baseOutAmount,quoteOutAmount) = removeDVMLiquidity(DVMAddress,to,sharesAmount,baseMinOutAmount,quoteMinOutAmount,flag,deadline);
}
// ============================================
// ============ DPP Functions (create & reset) ============
function createDODOPrivatePool(
address baseToken,
@@ -234,7 +205,15 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
uint256 i,
uint256 k,
uint256 deadline
) external virtual override payable preventReentrant judgeExpired(deadline) returns (address newPrivatePool) {
)
external
virtual
override
payable
preventReentrant
judgeExpired(deadline)
returns (address newPrivatePool)
{
newPrivatePool = IDODOV2(dppFactory).createDODOPrivatePool();
address _baseToken = baseToken;
@@ -305,6 +284,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
_withdraw(msg.sender, IDODOV2(DPPAddress)._QUOTE_TOKEN_(), quoteOutAmount, flag == 4);
}
// ============ Swap ============
function dodoSwapETHToToken(
address payable assetTo,
address toToken,
@@ -313,7 +294,15 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
address[] memory dodoPairs,
uint8[] memory directions,
uint256 deadline
) external virtual override payable preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
)
external
virtual
override
payable
preventReentrant
judgeExpired(deadline)
returns (uint256 returnAmount)
{
uint256 originToTokenBalance = IERC20(toToken).balanceOf(msg.sender);
require(msg.value == fromTokenAmount, "DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH");
@@ -356,7 +345,14 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
address[] memory dodoPairs,
uint8[] memory directions,
uint256 deadline
) external virtual override preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
)
external
virtual
override
preventReentrant
judgeExpired(deadline)
returns (uint256 returnAmount)
{
IDODOApprove(dodoApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
for (uint256 i = 0; i < dodoPairs.length; i++) {
@@ -397,7 +393,14 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
address[] memory dodoPairs,
uint8[] memory directions,
uint256 deadline
) external virtual override preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
)
external
virtual
override
preventReentrant
judgeExpired(deadline)
returns (uint256 returnAmount)
{
uint256 originToTokenBalance = IERC20(toToken).balanceOf(msg.sender);
IDODOApprove(dodoApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
@@ -437,9 +440,22 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
uint256 minReturnAmount,
bytes memory callDataConcat,
uint256 deadline
) external virtual override payable preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
)
external
virtual
override
payable
preventReentrant
judgeExpired(deadline)
returns (uint256 returnAmount)
{
if (fromToken != ETH_ADDRESS) {
IDODOApprove(dodoApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
IDODOApprove(dodoApprove).claimTokens(
fromToken,
msg.sender,
address(this),
fromTokenAmount
);
IERC20(fromToken).universalApproveMax(approveTarget, fromTokenAmount);
}
@@ -474,8 +490,16 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
address[] memory dodoPairs,
uint8[] memory directions,
uint256 deadline
) external virtual override payable preventReentrant judgeExpired(deadline) returns (uint256 returnAmount) {
_deposit(msg.sender,address(this),fromToken,fromTokenAmount, fromToken == ETH_ADDRESS);
)
external
virtual
override
payable
preventReentrant
judgeExpired(deadline)
returns (uint256 returnAmount)
{
_deposit(msg.sender, address(this), fromToken, fromTokenAmount, fromToken == ETH_ADDRESS);
for (uint256 i = 0; i < dodoPairs.length; i++) {
address curDodoPair = dodoPairs[i];
@@ -498,7 +522,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
returnAmount = IERC20(toToken).universalBalanceOf(address(this));
require(returnAmount >= minReturnAmount, "DODOV2Proxy01: Return amount is not enough");
_withdraw(msg.sender, toToken, returnAmount, toToken == ETH_ADDRESS);
emit OrderHistory(
@@ -521,8 +545,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01, ReentrancyGuard {
if (isETH) {
if (amount > 0) {
IWETH(_WETH_).deposit{value: amount}();
if(to != address(this))
SafeERC20.safeTransfer(IERC20(_WETH_), to, amount);
if (to != address(this)) SafeERC20.safeTransfer(IERC20(_WETH_), to, amount);
}
} else {
IDODOApprove(dodoApprove).claimTokens(token, from, to, amount);

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

@@ -18,11 +18,11 @@ contract DODOCalleeHelper is ReentrancyGuard {
address payable public _WETH_;
fallback() external payable {
require(msg.sender == _WETH_, "WE_DONT_SAVED_YOUR_ETH");
require(msg.sender == _WETH_, "WE_SAVED_YOUR_ETH");
}
receive() external payable {
require(msg.sender == _WETH_, "WE_DONT_SAVED_YOUR_ETH");
require(msg.sender == _WETH_, "WE_SAVED_YOUR_ETH");
}
constructor(address payable _weth) public {
@@ -57,4 +57,4 @@ contract DODOCalleeHelper is ReentrancyGuard {
SafeERC20.safeTransfer(IERC20(token), to, amount);
}
}
}
}

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

@@ -8,7 +8,7 @@
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {IDODOV1Proxy01} from './IDODOV1Proxy01.sol';
import {IDODOV1Proxy01} from "./IDODOV1Proxy01.sol";
interface IDODOV2Proxy01 is IDODOV1Proxy01 {
function dodoSwapETHToToken(
@@ -73,31 +73,6 @@ interface IDODOV2Proxy01 is IDODOV1Proxy01 {
uint256 quoteAdjustedInAmount
);
// ==================== Permit ================================
function removeDVMLiquidity(
address DVMAddress,
address payable to,
uint256 sharesAmount,
uint256 baseMinOutAmount,
uint256 quoteMinOutAmount,
uint8 flag, // 0 -ERC20, 1 - baseOutETH, 2 - quoteOutETH
uint256 deadline
) external returns (uint256 baseOutAmount, uint256 quoteOutAmount);
function removeDVMLiquidityWithPermit(
address DVMAddress,
address payable to,
uint256 sharesAmount,
uint256 baseMinOutAmount,
uint256 quoteMinOutAmount,
uint8 flag, // 0 -ERC20, 1 - baseOutETH, 2 - quoteOutETH
uint256 deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint256 baseOutAmount, uint256 quoteOutAmount);
// ==============================================================
function createDODOPrivatePool(
address baseToken,
address quoteToken,

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

@@ -17,10 +17,6 @@ library UniversalERC20 {
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,
@@ -56,4 +52,8 @@ library UniversalERC20 {
return token.balanceOf(who);
}
}
function isETH(IERC20 token) internal pure returns (bool) {
return token == ETH_ADDRESS;
}
}

4
contracts/lib/DecimalMath.sol
View File

@@ -19,8 +19,8 @@ import {SafeMath} from "./SafeMath.sol";
library DecimalMath {
using SafeMath for uint256;
uint256 constant ONE = 10**18;
uint256 constant ONE2 = 10**36;
uint256 internal constant ONE = 10**18;
uint256 internal constant ONE2 = 10**36;
function mulFloor(uint256 target, uint256 d) internal pure returns (uint256) {
return target.mul(d) / (10**18);