350 lines
14 KiB
Solidity
350 lines
14 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 {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 构造data
|
||
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");
|
||
(baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(to, shares, "");
|
||
require(baseOutAmount >= baseOutMinAmount && quoteOutAmount >= quoteOutMinAmount,"DODOV2Proxy01: withdraw amount is not enough");
|
||
}
|
||
|
||
//TODO:ETH
|
||
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(baseToken, quoteToken, lpFeeRate, mtFeeRate, i, k);
|
||
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;
|
||
// }
|
||
}
|