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

dodov2proxy

Browse Source
This commit is contained in:
owen05
2020-11-23 22:33:23 +08:00
parent 8458022a3c
commit 71e1d8717c
15 changed files with 589 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

348
contracts/SmartRoute/DODOV2Proxy01.sol Normal file
View File

@@ -0,0 +1,348 @@
/*
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 {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 smartApprove;
address public dodoSellHelper;
address public dvmFactory;
address public dppFactory;
modifier judgeExpired(uint256 deadline) {
require(deadline >= block.timestamp, 'DODOV2Proxy01: EXPIRED');
_;
}
//============================== events ==================================
event OrderHistory(
address indexed fromToken,
address indexed toToken,
address indexed sender,
uint256 fromAmount,
uint256 returnAmount,
uint256 timeStamp
);
event ExternalRecord(address indexed to, address indexed sender);
//========================================================================
constructor(
address _dvmFactory,
address _dppFactory,
address payable _weth,
address _smartApprove,
address _dodoSellHelper
) public {
dvmFactory = _dvmFactory;
dppFactory = _dppFactory;
_WETH_ = _weth;
smartApprove = _smartApprove;
dodoSellHelper = _dodoSellHelper;
}
//TODO:ETH
function createDODOVendingMachine(
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) {
require(k > 0 && k<= 10**18, "DODOV2Proxy01: K OUT OF RANGE");
newVendingMachine = IDODOV2(dvmFactory).createDODOVendingMachine(baseToken,quoteToken,lpFeeRate,mtFeeRate,i,k);
if(baseInAmount > 0)
IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newVendingMachine, baseInAmount);
if(quoteInAmount > 0)
IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newVendingMachine, quoteInAmount);
(shares,,) = IDODOV2(newVendingMachine).buyShares(msg.sender);
}
function _addDVMLiquidity(
address DVMAddress,
uint256 baseInAmount,
uint256 quoteInAmount
) internal virtual view returns (uint baseAdjustedInAmount, uint quoteAdjustedInAmount) {
(uint256 baseReserve, uint256 quoteReserve) = IDODOV2(DVMAddress).getVaultReserve();
if (quoteReserve == 0 && baseReserve == 0) {
baseAdjustedInAmount = baseInAmount;
quoteAdjustedInAmount = quoteInAmount;
}
//TODO: 若init时候 baseInAmount > 0 quoteReserve = 0 之后没法添加quote？
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);
}
}
}
//TODO:ETH
function addDVMLiquidity(
address DVMAddress,
address to,
uint256 baseInAmount,
uint256 quoteInAmount,
uint256 baseMinAmount,
uint256 quoteMinAmount,
uint256 deadline
) external virtual override payable judgeExpired(deadline) returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount) {
(uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount);
address _dvm = DVMAddress;
if(baseAdjustedInAmount > 0)
IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._BASE_TOKEN_(), msg.sender, _dvm, baseAdjustedInAmount);
if(quoteAdjustedInAmount > 0)
IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._QUOTE_TOKEN_(), msg.sender, _dvm, quoteAdjustedInAmount);
(shares,baseActualInAmount,quoteActualInAmount) = IDODOV2(_dvm).buyShares(to);
require(baseActualInAmount >= baseMinAmount && quoteActualInAmount >= quoteMinAmount, "DODOV2Proxy01: deposit amount is not enough");
}
//TODO:ETH
function removeDVMLiquidity(
address DVMAddress,
address to,
uint256 shares,
uint256 baseOutMinAmount,
uint256 quoteOutMinAmount,
uint256 deadline
) external virtual override payable judgeExpired(deadline) returns (uint256 baseOutAmount,uint256 quoteOutAmount) {
require(shares > 0, "DODOV2Proxy01: Insufficient_Liquidity");
IDODOV2(smartApprove).claimTokens(DVMAddress, msg.sender, DVMAddress, shares);
(baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(to);
require(baseOutAmount >= baseOutMinAmount && quoteOutAmount >= quoteOutMinAmount,"DODOV2Proxy01: withdraw amount is not enough");
}
//TODO:ETH
function createDODOPrivatePool(
address baseToken,
address quoteToken,
uint256 baseInAmount,
uint256 quoteInAmount,
address[] memory valueTemplates, //feeRateAddr,mtRateAddr,kAddr,iAddr
uint256[] memory values, // feeRate,mtRate,k,i
uint256 deadline
) external virtual override payable judgeExpired(deadline) returns (address newPrivatePool) {
newPrivatePool = IDODOV2(dppFactory).createDODOPrivatePool(baseToken,quoteToken,valueTemplates,values);
if(baseInAmount > 0)
IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newPrivatePool, baseInAmount);
if(quoteInAmount > 0)
IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newPrivatePool, quoteInAmount);
IDODOV2(newPrivatePool).initTargetAndReserve();
}
//TODO:ETH
function resetDODOPrivatePool(
address DPPAddress,
uint256 newLpFeeRate,
uint256 newMtFeeRate,
uint256 newI,
uint256 newK,
uint256 baseInAmount,
uint256 quoteInAmount,
uint256 baseOutAmount,
uint256 quoteOutAmount,
uint256 deadline
) external virtual override payable judgeExpired(deadline) {
if(baseInAmount > 0)
IDODOV2(smartApprove).claimTokens(IDODOV2(DPPAddress)._BASE_TOKEN_(), msg.sender, DPPAddress, baseInAmount);
if(quoteInAmount > 0)
IDODOV2(smartApprove).claimTokens(IDODOV2(DPPAddress)._QUOTE_TOKEN_(), msg.sender, DPPAddress, quoteInAmount);
IDODOV2(DPPAddress).reset(
newLpFeeRate,
newMtFeeRate,
newI,
newK,
baseOutAmount,
quoteOutAmount
);
}
function dodoSwap(
address fromToken,
address toToken,
uint256 fromTokenAmount,
uint256 minReturnAmount,
address[] memory dodoPairs,
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(dodoPairs.length > 0, "DODOV2Proxy01: pairs should exists.");
if (fromToken != ETH_ADDRESS) {
IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
} else {
require(msg.value == fromTokenAmount, "DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH");
IWETH(_WETH_).deposit{value: fromTokenAmount}();
IWETH(_WETH_).transfer(dodoPairs[0],IWETH(_WETH_).balanceOf(address(this)));
}
for (uint256 i = 0; i < dodoPairs.length; i++) {
address curTo;
if(i == dodoPairs.length - 1){
curTo = address(this);
} else {
curTo = dodoPairs[i+1];
}
if (directions[i] == 0) {
IDODOV2(dodoPairs[i]).sellBase(curTo);
} else {
IDODOV2(dodoPairs[i]).sellQuote(curTo);
}
}
IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this)));
if (toToken == ETH_ADDRESS) {
uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this));
IWETH(_WETH_).withdraw(wethAmount);
}
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 externalSwap(
address fromToken,
address toToken,
address approveTarget,
address to,
uint256 gasSwap,
uint256 fromTokenAmount,
uint256 minReturnAmount,
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(smartApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
IERC20(fromToken).universalApprove(approveTarget, fromTokenAmount);
}
(bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0, gas: gasSwap}(
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);
emit ExternalRecord(to, msg.sender);
}
//====================== temporary for test ======================
// function sellBaseOnDVM(
// address DVMAddress,
// address to,
// uint256 baseAmount,
// uint256 minReceive
// ) public returns (uint256 receiveAmount) {
// IERC20(IDVM(DVMAddress)._BASE_TOKEN_()).safeTransferFrom(
// msg.sender,
// DVMAddress,
// baseAmount
// );
// receiveAmount = IDVM(DVMAddress).sellBase(to);
// require(receiveAmount >= minReceive, "RECEIVE_NOT_ENOUGH");
// return receiveAmount;
// }
// function sellQuoteOnDVM(
// address DVMAddress,
// address to,
// uint256 quoteAmount,
// uint256 minReceive
// ) public returns (uint256 receiveAmount) {
// IERC20(IDVM(DVMAddress)._QUOTE_TOKEN_()).safeTransferFrom(
// msg.sender,
// DVMAddress,
// quoteAmount
// );
// receiveAmount = IDVM(DVMAddress).sellQuote(to);
// require(receiveAmount >= minReceive, "RECEIVE_NOT_ENOUGU");
// return receiveAmount;
// }
// function depositToDVM(
// address DVMAddress,
// address to,
// uint256 baseAmount,
// uint256 quoteAmount
// ) public returns (uint256 shares) {
// uint256 adjustedBaseAmount;
// uint256 adjustedQuoteAmount;
// (uint256 baseReserve, uint256 quoteReserve) = IDVM(DVMAddress).getVaultReserve();
// if (quoteReserve == 0 && baseReserve == 0) {
// adjustedBaseAmount = baseAmount;
// adjustedQuoteAmount = quoteAmount;
// }
// if (quoteReserve == 0 && baseReserve > 0) {
// adjustedBaseAmount = baseAmount;
// adjustedQuoteAmount = 0;
// }
// if (quoteReserve > 0 && baseReserve > 0) {
// uint256 baseIncreaseRatio = DecimalMath.divFloor(baseAmount, baseReserve);
// uint256 quoteIncreaseRatio = DecimalMath.divFloor(quoteAmount, quoteReserve);
// if (baseIncreaseRatio <= quoteIncreaseRatio) {
// adjustedBaseAmount = baseAmount;
// adjustedQuoteAmount = DecimalMath.mulFloor(quoteReserve, baseIncreaseRatio);
// } else {
// adjustedQuoteAmount = quoteAmount;
// adjustedBaseAmount = DecimalMath.mulFloor(baseReserve, quoteIncreaseRatio);
// }
// }
// IERC20(IDVM(DVMAddress)._BASE_TOKEN_()).safeTransferFrom(
// msg.sender,
// DVMAddress,
// adjustedBaseAmount
// );
// IERC20(IDVM(DVMAddress)._QUOTE_TOKEN_()).safeTransferFrom(
// msg.sender,
// DVMAddress,
// adjustedQuoteAmount
// );
// shares = IDVM(DVMAddress).buyShares(to);
// return shares;
// }
}

117
contracts/SmartRoute/DVMProxy.sol
View File

@@ -1,117 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
import {IDVM} from "../DODOVendingMachine/intf/IDVM.sol";
import {IERC20} from "../intf/IERC20.sol";
import {SafeERC20} from "../lib/SafeERC20.sol";
import {SafeMath} from "../lib/SafeMath.sol";
import {DecimalMath} from "../lib/DecimalMath.sol";
contract DVMProxy {
using SafeMath for uint256;
using SafeERC20 for IERC20;
//TODO: dodoSwap
//TODO: externalSwap
//TODO: createDVM
//TODO: addLiquidityToDVM
//TODO: removeLiquidityToDVM（待定）
//TODO: createDPP
//TODO: resetDPP
//TODO: addLiquidityToClassical
//TODO: removeLiquidityToClassical
function sellBaseOnDVM(
address DVMAddress,
address to,
uint256 baseAmount,
uint256 minReceive
) public returns (uint256 receiveAmount) {
IERC20(IDVM(DVMAddress)._BASE_TOKEN_()).safeTransferFrom(
msg.sender,
DVMAddress,
baseAmount
);
receiveAmount = IDVM(DVMAddress).sellBase(to);
require(receiveAmount >= minReceive, "RECEIVE_NOT_ENOUGH");
return receiveAmount;
}
function sellQuoteOnDVM(
address DVMAddress,
address to,
uint256 quoteAmount,
uint256 minReceive
) public returns (uint256 receiveAmount) {
IERC20(IDVM(DVMAddress)._QUOTE_TOKEN_()).safeTransferFrom(
msg.sender,
DVMAddress,
quoteAmount
);
receiveAmount = IDVM(DVMAddress).sellQuote(to);
require(receiveAmount >= minReceive, "RECEIVE_NOT_ENOUGU");
return receiveAmount;
}
function depositToDVM(
address DVMAddress,
address to,
uint256 baseAmount,
uint256 quoteAmount
) public returns (uint256 shares) {
uint256 adjustedBaseAmount;
uint256 adjustedQuoteAmount;
(uint256 baseReserve, uint256 quoteReserve) = IDVM(DVMAddress).getVaultReserve();
if (quoteReserve == 0 && baseReserve == 0) {
adjustedBaseAmount = baseAmount;
adjustedQuoteAmount = quoteAmount;
}
if (quoteReserve == 0 && baseReserve > 0) {
adjustedBaseAmount = baseAmount;
adjustedQuoteAmount = 0;
}
if (quoteReserve > 0 && baseReserve > 0) {
uint256 baseIncreaseRatio = DecimalMath.divFloor(baseAmount, baseReserve);
uint256 quoteIncreaseRatio = DecimalMath.divFloor(quoteAmount, quoteReserve);
if (baseIncreaseRatio <= quoteIncreaseRatio) {
adjustedBaseAmount = baseAmount;
adjustedQuoteAmount = DecimalMath.mulFloor(quoteReserve, baseIncreaseRatio);
} else {
adjustedQuoteAmount = quoteAmount;
adjustedBaseAmount = DecimalMath.mulFloor(baseReserve, quoteIncreaseRatio);
}
}
IERC20(IDVM(DVMAddress)._BASE_TOKEN_()).safeTransferFrom(
msg.sender,
DVMAddress,
adjustedBaseAmount
);
IERC20(IDVM(DVMAddress)._QUOTE_TOKEN_()).safeTransferFrom(
msg.sender,
DVMAddress,
adjustedQuoteAmount
);
shares = IDVM(DVMAddress).buyShares(to);
return shares;
}
}

4
contracts/SmartRoute/SmartApprove.sol
View File

@@ -24,12 +24,12 @@ contract SmartApprove is Ownable {
}
function claimTokens(
IERC20 token,
address token,
address who,
address dest,
uint256 amount
) external {
require(msg.sender == smartSwap, "Not SmartSwap Address, Access restricted");
token.safeTransferFrom(who, dest, amount);
IERC20(token).safeTransferFrom(who, dest, amount);
}
}

42
contracts/SmartRoute/SmartSwap.sol
View File

@@ -20,9 +20,9 @@ contract SmartSwap is Ownable {
using SafeMath for uint256;
using UniversalERC20 for IERC20;
IERC20 constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
ISmartApprove public smartApprove;
IDODOSellHelper public dodoSellHelper;
address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address public smartApprove;
address public dodoSellHelper;
address payable public _WETH_;
@@ -32,8 +32,8 @@ contract SmartSwap is Ownable {
}
event OrderHistory(
IERC20 indexed fromToken,
IERC20 indexed toToken,
address indexed fromToken,
address indexed toToken,
address indexed sender,
uint256 fromAmount,
uint256 returnAmount,
@@ -47,8 +47,8 @@ contract SmartSwap is Ownable {
address _dodoSellHelper,
address payable _weth
) public {
smartApprove = ISmartApprove(_smartApprove);
dodoSellHelper = IDODOSellHelper(_dodoSellHelper);
smartApprove = _smartApprove;
dodoSellHelper = _dodoSellHelper;
_WETH_ = _weth;
}
@@ -57,8 +57,8 @@ contract SmartSwap is Ownable {
receive() external payable {}
function dodoSwap(
IERC20 fromToken,
IERC20 toToken,
address fromToken,
address toToken,
uint256 fromTokenAmount,
uint256 minReturnAmount,
address[] memory dodoPairs,
@@ -69,7 +69,7 @@ contract SmartSwap is Ownable {
require(dodoPairs.length > 0, "DODO SmartSwap: pairs should exists.");
if (fromToken != ETH_ADDRESS) {
smartApprove.claimTokens(fromToken, msg.sender, address(this),fromTokenAmount);
ISmartApprove(smartApprove).claimTokens(fromToken, msg.sender, address(this),fromTokenAmount);
} else {
require(msg.value == fromTokenAmount, "DODO SmartSwap: ETH_AMOUNT_NOT_MATCH");
IWETH(_WETH_).deposit{value: fromTokenAmount}();
@@ -87,30 +87,30 @@ contract SmartSwap is Ownable {
address curDodoQuote = IDODO(curDodoPair)._QUOTE_TOKEN_();
uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this));
IERC20(curDodoQuote).universalApprove(curDodoPair, curAmountIn);
uint256 canBuyBaseAmount = dodoSellHelper.querySellQuoteToken(
uint256 canBuyBaseAmount = IDODOSellHelper(dodoSellHelper).querySellQuoteToken(
curDodoPair,
curAmountIn
);
IDODO(curDodoPair).buyBaseToken(canBuyBaseAmount, curAmountIn, "");
}
}
fromToken.universalTransfer(msg.sender, fromToken.universalBalanceOf(address(this)));
IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this)));
if (toToken == ETH_ADDRESS) {
uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this));
IWETH(_WETH_).withdraw(wethAmount);
}
returnAmount = toToken.universalBalanceOf(address(this));
returnAmount = IERC20(toToken).universalBalanceOf(address(this));
require(returnAmount >= minReturnAmount, "DODO SmartSwap: Return amount is not enough");
toToken.universalTransfer(msg.sender, returnAmount);
IERC20(toToken).universalTransfer(msg.sender, returnAmount);
emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
}
function externalSwap(
IERC20 fromToken,
IERC20 toToken,
address fromToken,
address toToken,
address approveTarget,
address to,
uint256 gasSwap,
@@ -123,8 +123,8 @@ contract SmartSwap is Ownable {
require(minReturnAmount > 0, "DODO SmartSwap: Min return should be bigger then 0.");
if (fromToken != ETH_ADDRESS) {
smartApprove.claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
fromToken.universalApprove(approveTarget, fromTokenAmount);
ISmartApprove(smartApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
IERC20(fromToken).universalApprove(approveTarget, fromTokenAmount);
}
(bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0, gas: gasSwap}(
@@ -133,11 +133,11 @@ contract SmartSwap is Ownable {
require(success, "DODO SmartSwap: Contract Swap execution Failed");
fromToken.universalTransfer(msg.sender, fromToken.universalBalanceOf(address(this)));
returnAmount = toToken.universalBalanceOf(address(this));
IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this)));
returnAmount = IERC20(toToken).universalBalanceOf(address(this));
require(returnAmount >= minReturnAmount, "DODO SmartSwap: Return amount is not enough");
toToken.universalTransfer(msg.sender, returnAmount);
IERC20(toToken).universalTransfer(msg.sender, returnAmount);
emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
emit ExternalRecord(to, msg.sender);
}