497 lines
16 KiB
Solidity
497 lines
16 KiB
Solidity
/*
|
|
|
|
Copyright 2020 DODO ZOO.
|
|
SPDX-License-Identifier: Apache-2.0
|
|
|
|
*/
|
|
|
|
pragma solidity 0.6.9;
|
|
|
|
import {IDODOV2Proxy01} from "./intf/IDODOV2Proxy01.sol";
|
|
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 {SafeERC20} from "../lib/SafeERC20.sol";
|
|
import {DecimalMath} from "../lib/DecimalMath.sol";
|
|
|
|
contract DODOV2Proxy01 is IDODOV2Proxy01 {
|
|
using SafeMath for uint256;
|
|
using UniversalERC20 for IERC20;
|
|
|
|
address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
|
|
address payable public _WETH_;
|
|
address public dodoApprove;
|
|
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,
|
|
address indexed toToken,
|
|
address indexed sender,
|
|
uint256 fromAmount,
|
|
uint256 returnAmount,
|
|
uint256 timeStamp
|
|
);
|
|
|
|
//========================================================================
|
|
|
|
constructor(
|
|
address _dvmFactory,
|
|
address _dppFactory,
|
|
address payable _weth,
|
|
address _dodoApprove
|
|
) public {
|
|
dvmFactory = _dvmFactory;
|
|
dppFactory = _dppFactory;
|
|
_WETH_ = _weth;
|
|
dodoApprove = _dodoApprove;
|
|
}
|
|
|
|
function createDODOVendingMachine(
|
|
address assetTo,
|
|
address baseToken,
|
|
address quoteToken,
|
|
uint256 baseInAmount,
|
|
uint256 quoteInAmount,
|
|
uint256 lpFeeRate,
|
|
uint256 mtFeeRate,
|
|
uint256 i,
|
|
uint256 k,
|
|
uint256 deadline
|
|
)
|
|
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;
|
|
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 (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,
|
|
uint256 baseInAmount,
|
|
uint256 quoteInAmount,
|
|
uint256 baseMinAmount,
|
|
uint256 quoteMinAmount,
|
|
uint8 flag, // 0 - ERC20, 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;
|
|
|
|
_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 removeDVMLiquidity(
|
|
address DVMAddress,
|
|
address payable to,
|
|
uint256 sharesAmount,
|
|
uint256 baseMinOutAmount,
|
|
uint256 quoteMinOutAmount,
|
|
uint8 flag, // 0 -ERC20, 1 - baseOutETH, 2 - quoteOutETH
|
|
uint256 deadline
|
|
) public virtual override 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);
|
|
}
|
|
}
|
|
|
|
|
|
// ================ Permit ======================
|
|
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 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);
|
|
}
|
|
// ============================================
|
|
|
|
function createDODOPrivatePool(
|
|
address baseToken,
|
|
address quoteToken,
|
|
uint256 baseInAmount,
|
|
uint256 quoteInAmount,
|
|
uint256 lpFeeRate,
|
|
uint256 mtFeeRate,
|
|
uint256 i,
|
|
uint256 k,
|
|
uint256 deadline
|
|
) external virtual override payable judgeExpired(deadline) returns (address newPrivatePool) {
|
|
newPrivatePool = IDODOV2(dppFactory).createDODOPrivatePool();
|
|
|
|
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,
|
|
lpFeeRate,
|
|
mtFeeRate,
|
|
k,
|
|
i
|
|
);
|
|
}
|
|
|
|
function resetDODOPrivatePool(
|
|
address DPPAddress,
|
|
uint256 newLpFeeRate,
|
|
uint256 newMtFeeRate,
|
|
uint256 newI,
|
|
uint256 newK,
|
|
uint256 baseInAmount,
|
|
uint256 quoteInAmount,
|
|
uint256 baseOutAmount,
|
|
uint256 quoteOutAmount,
|
|
uint8 flag, // 0 - ERC20, 1 - baseInETH, 2 - quoteInETH, 3 - baseOutETH, 4 - quoteOutETH
|
|
uint256 deadline
|
|
) 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,
|
|
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(
|
|
address payable assetTo,
|
|
address toToken,
|
|
uint256 fromTokenAmount,
|
|
uint256 minReturnAmount,
|
|
address[] memory dodoPairs,
|
|
uint8[] memory directions,
|
|
uint256 deadline
|
|
) external virtual override payable 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);
|
|
|
|
for (uint256 i = 0; i < dodoPairs.length; i++) {
|
|
if (i == dodoPairs.length - 1) {
|
|
if (directions[i] == 0) {
|
|
IDODOV2(dodoPairs[i]).sellBase(assetTo);
|
|
} else {
|
|
IDODOV2(dodoPairs[i]).sellQuote(assetTo);
|
|
}
|
|
} else {
|
|
if (directions[i] == 0) {
|
|
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i + 1]);
|
|
} else {
|
|
IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i + 1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
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(
|
|
address payable assetTo,
|
|
address fromToken,
|
|
uint256 fromTokenAmount,
|
|
uint256 minReturnAmount,
|
|
address[] memory dodoPairs,
|
|
uint8[] memory directions,
|
|
uint256 deadline
|
|
) external virtual override judgeExpired(deadline) returns (uint256 returnAmount) {
|
|
IDODOV2(dodoApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
|
|
|
|
for (uint256 i = 0; i < dodoPairs.length; i++) {
|
|
if (i == dodoPairs.length - 1) {
|
|
if (directions[i] == 0) {
|
|
IDODOV2(dodoPairs[i]).sellBase(address(this));
|
|
} else {
|
|
IDODOV2(dodoPairs[i]).sellQuote(address(this));
|
|
}
|
|
} else {
|
|
if (directions[i] == 0) {
|
|
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i + 1]);
|
|
} else {
|
|
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);
|
|
assetTo.transfer(returnAmount);
|
|
emit OrderHistory(
|
|
fromToken,
|
|
ETH_ADDRESS,
|
|
assetTo,
|
|
fromTokenAmount,
|
|
returnAmount,
|
|
block.timestamp
|
|
);
|
|
}
|
|
|
|
function dodoSwapTokenToToken(
|
|
address payable assetTo,
|
|
address fromToken,
|
|
address toToken,
|
|
uint256 fromTokenAmount,
|
|
uint256 minReturnAmount,
|
|
address[] memory dodoPairs,
|
|
uint8[] memory directions,
|
|
uint256 deadline
|
|
) external virtual override judgeExpired(deadline) returns (uint256 returnAmount) {
|
|
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 (directions[i] == 0) {
|
|
IDODOV2(dodoPairs[i]).sellBase(assetTo);
|
|
} else {
|
|
IDODOV2(dodoPairs[i]).sellQuote(assetTo);
|
|
}
|
|
} else {
|
|
if (directions[i] == 0) {
|
|
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i + 1]);
|
|
} else {
|
|
IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i + 1]);
|
|
}
|
|
}
|
|
}
|
|
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(
|
|
address fromToken,
|
|
address toToken,
|
|
address approveTarget,
|
|
address to,
|
|
uint256 fromTokenAmount,
|
|
uint256 minReturnAmount,
|
|
bytes memory callDataConcat,
|
|
uint256 deadline
|
|
) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) {
|
|
if (fromToken != ETH_ADDRESS) {
|
|
IDODOV2(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);
|
|
|
|
require(success, "DODOV2Proxy01: Contract Swap execution Failed");
|
|
|
|
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");
|
|
IERC20(toToken).universalTransfer(msg.sender, returnAmount);
|
|
|
|
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 payable to,
|
|
address token,
|
|
uint256 amount,
|
|
bool isETH
|
|
) internal {
|
|
if (isETH) {
|
|
if (amount > 0) {
|
|
IWETH(_WETH_).withdraw(amount);
|
|
to.transfer(amount);
|
|
}
|
|
} else {
|
|
SafeERC20.safeTransfer(IERC20(token), to, amount);
|
|
}
|
|
}
|
|
}
|