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

dvm proxy test ing

Browse Source
This commit is contained in:
owen05
2020-11-26 21:03:36 +08:00
parent 3a7fe02ab0
commit e3637fe022
8 changed files with 546 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
contracts/DODOVendingMachine/impl/DVM.sol
View File

@@ -30,7 +30,6 @@ contract DVM is DVMTrader, DVMFunding {
uint256 k
) external {
initOwner(owner);
_ADMIN_ = owner;
_BASE_TOKEN_ = IERC20(baseTokenAddress);
_QUOTE_TOKEN_ = IERC20(quoteTokenAddress);
_LP_FEE_RATE_MODEL_ = IFeeRateModel(lpFeeRateModel);

11
contracts/DODOVendingMachine/impl/DVMFunding.sol
View File

@@ -28,26 +28,25 @@ contract DVMFunding is DVMVault {
require(baseInput > 0, "NO_BASE_INPUT");
uint256 baseReserve = _BASE_RESERVE_;
uint256 quoteReserve = _QUOTE_RESERVE_;
uint256 mintAmount;
// case 1. initial supply
// 包含了 baseReserve == 0 && quoteReserve == 0 的情况
// 在提币的时候向下取整。因此永远不会出现，balance为0但totalsupply不为0的情况
// 但有可能出现，reserve>0但totalSupply=0的场景
if (totalSupply == 0) {
mintAmount = getBaseBalance(); // 以免出现balance很大但shares很小的情况
shares = getBaseBalance(); // 以免出现balance很大但shares很小的情况
} else if (baseReserve > 0 && quoteReserve == 0) {
// case 2. supply when quote reserve is 0
mintAmount = baseInput.mul(totalSupply).div(baseReserve);
shares = baseInput.mul(totalSupply).div(baseReserve);
} else if (baseReserve > 0 && quoteReserve > 0) {
// case 3. normal case
uint256 baseInputRatio = DecimalMath.divFloor(baseInput, baseReserve);
uint256 quoteInputRatio = DecimalMath.divFloor(quoteInput, quoteReserve);
uint256 mintRatio = quoteInputRatio < baseInputRatio ? quoteInputRatio : baseInputRatio;
mintAmount = DecimalMath.mulFloor(totalSupply, mintRatio);
shares = DecimalMath.mulFloor(totalSupply, mintRatio);
}
_mint(to, mintAmount);
_mint(to, shares);
_sync();
return (mintAmount, baseInput, quoteInput);
return (shares, baseInput, quoteInput);
}
// withdraw amount [round down]

2
contracts/DODOVendingMachine/impl/DVMStorage.sol
View File

@@ -21,8 +21,6 @@ import {IERC20} from "../../intf/IERC20.sol";
contract DVMStorage is InitializableOwnable, ReentrancyGuard {
using SafeMath for uint256;
address public _ADMIN_;
// ============ Variables for Control ============
IExternalValue public _GAS_PRICE_LIMIT_;

203
contracts/SmartRoute/DODOV2Proxy01.sol
View File

@@ -44,8 +44,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 returnAmount,
uint256 timeStamp
);
event ExternalRecord(address indexed to, address indexed sender);
//========================================================================
constructor(
@@ -62,8 +60,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
dodoSellHelper = _dodoSellHelper;
}
//TODO:ETH
function createDODOVendingMachine(
address assetTo,
address baseToken,
address quoteToken,
uint256 baseInAmount,
@@ -74,13 +72,30 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
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(msg.sender, 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);
{
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(smartApprove).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(smartApprove).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);
}
@@ -112,7 +127,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
}
}
//TODO:ETH
function addDVMLiquidity(
address DVMAddress,
address to,
@@ -121,18 +135,52 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 baseMinAmount,
uint256 quoteMinAmount,
uint256 deadline
) external virtual override payable judgeExpired(deadline) returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount) {
) external virtual override judgeExpired(deadline) returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount) {
(uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount);
address _dvm = DVMAddress;
if(baseAdjustedInAmount > 0)
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 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 baseActualInAmount,uint256 quoteActualInAmount) {
(uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount);
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));
}else {
IDODOV2(smartApprove).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));
}else {
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');
}
function removeDVMLiquidity(
address DVMAddress,
address to,
@@ -140,9 +188,9 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 baseOutMinAmount,
uint256 quoteOutMinAmount,
uint256 deadline
) external virtual override payable judgeExpired(deadline) returns (uint256 baseOutAmount,uint256 quoteOutAmount) {
) external virtual override judgeExpired(deadline) returns (uint256 baseOutAmount,uint256 quoteOutAmount) {
require(shares > 0, 'DODOV2Proxy01: Insufficient_Liquidity');
(baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(to, shares, "");
(baseOutAmount,quoteOutAmount) = IDODOV2(DVMAddress).sellShares(to);
require(baseOutAmount >= baseOutMinAmount && quoteOutAmount >= quoteOutMinAmount,'DODOV2Proxy01: withdraw amount is not enough');
}
@@ -292,8 +340,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
}
}
function dodoSwap(
address fromToken,
function dodoSwapETHToToken(
address payable assetTo,
address toToken,
uint256 fromTokenAmount,
uint256 minReturnAmount,
@@ -301,42 +349,95 @@ 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(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)));
}
require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.');
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);
if (directions[i] == 0) {
returnAmount = IDODOV2(dodoPairs[i]).sellBase(assetTo);
} else {
returnAmount = IDODOV2(dodoPairs[i]).sellQuote(assetTo);
}
} else {
curTo = dodoPairs[i+1];
}
if (directions[i] == 0) {
IDODOV2(dodoPairs[i]).sellBase(curTo);
} else {
IDODOV2(dodoPairs[i]).sellQuote(curTo);
if (directions[i] == 0) {
IDODOV2(dodoPairs[i]).sellBase(dodoPairs[i+1]);
} else {
IDODOV2(dodoPairs[i]).sellQuote(dodoPairs[i+1]);
}
}
}
IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this)));
require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough');
emit OrderHistory(ETH_ADDRESS, toToken, assetTo, fromTokenAmount, returnAmount, block.timestamp);
}
if (toToken == ETH_ADDRESS) {
uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this));
IWETH(_WETH_).withdraw(wethAmount);
function dodoSwapTokenToETH(
address payable assetTo,
address fromToken,
uint256 fromTokenAmount,
uint256 minReturnAmount,
address[] memory dodoPairs,
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(smartApprove).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));
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);
}
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 dodoSwapTokenToToken(
address payable assetTo,
address fromToken,
address toToken,
uint256 fromTokenAmount,
uint256 minReturnAmount,
address[] memory dodoPairs,
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(smartApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
for (uint256 i = 0; i < dodoPairs.length; i++) {
if(i == dodoPairs.length - 1){
if (directions[i] == 0) {
returnAmount = IDODOV2(dodoPairs[i]).sellBase(assetTo);
} else {
returnAmount = 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]);
}
}
}
require(returnAmount >= minReturnAmount, 'DODOV2Proxy01: Return amount is not enough');
emit OrderHistory(fromToken, toToken, assetTo, fromTokenAmount, returnAmount, block.timestamp);
}
function externalSwap(
@@ -344,32 +445,26 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
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.");
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
);
(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)));
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 ExternalRecord(to, msg.sender);
}
}

41
contracts/intf/IDODOV2Proxy01.sol
View File

@@ -11,8 +11,8 @@ pragma experimental ABIEncoderV2;
import {IERC20} from "./IERC20.sol";
interface IDODOV2Proxy01 {
function dodoSwap(
address fromToken,
function dodoSwapETHToToken(
address payable assetTo,
address toToken,
uint256 fromTokenAmount,
uint256 minReturnAmount,
@@ -21,13 +21,32 @@ interface IDODOV2Proxy01 {
uint256 deadline
) external payable returns (uint256 returnAmount);
function dodoSwapTokenToETH(
address payable assetTo,
address fromToken,
uint256 fromTokenAmount,
uint256 minReturnAmount,
address[] memory dodoPairs,
uint256[] memory directions,
uint256 deadline
) external returns (uint256 returnAmount);
function dodoSwapTokenToToken(
address payable assetTo,
address fromToken,
address toToken,
uint256 fromTokenAmount,
uint256 minReturnAmount,
address[] memory dodoPairs,
uint256[] memory directions,
uint256 deadline
) external returns (uint256 returnAmount);
function externalSwap(
address fromToken,
address toToken,
address approveTarget,
address to,
uint256 gasSwap,
uint256 fromTokenAmount,
uint256 minReturnAmount,
bytes memory callDataConcat,
@@ -36,6 +55,7 @@ interface IDODOV2Proxy01 {
function createDODOVendingMachine(
address assetTo,
address baseToken,
address quoteToken,
uint256 baseInAmount,
@@ -56,6 +76,17 @@ interface IDODOV2Proxy01 {
uint256 baseMinAmount,
uint256 quoteMinAmount,
uint256 deadline
) external returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount);
function addDVMLiquidityETH(
address DVMAddress,
address to,
uint256 baseInAmount,
uint256 quoteInAmount,
uint256 baseMinAmount,
uint256 quoteMinAmount,
uint8 flag, // 1 - baseInETH, 2 - quoteInETH
uint256 deadline
) external payable returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount);
@@ -66,7 +97,7 @@ interface IDODOV2Proxy01 {
uint256 baseOutMinAmount,
uint256 quoteOutMinAmount,
uint256 deadline
) external payable returns (uint256 baseOutAmount,uint256 quoteOutAmount);
) external returns (uint256 baseOutAmount,uint256 quoteOutAmount);
function createDODOPrivatePool(