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

change contract name && fix addLiquidity

Browse Source
This commit is contained in:
owen05
2020-11-27 12:13:58 +08:00
parent 5154c86e24
commit 29f6f0d9f8
9 changed files with 88 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
contracts/DODOPrivatePool/impl/DPPAdmin.sol
View File

@@ -9,20 +9,20 @@ pragma solidity 0.6.9;
pragma experimental ABIEncoderV2; pragma experimental ABIEncoderV2;
import {IDPP} from "../intf/IDPP.sol"; import {IDPP} from "../intf/IDPP.sol";
import {ISmartApprove} from '../../intf/ISmartApprove.sol'; import {IDODOApprove} from '../../intf/IDODOApprove.sol';
import {InitializableOwnable} from "../../lib/InitializableOwnable.sol"; import {InitializableOwnable} from "../../lib/InitializableOwnable.sol";
contract DPPAdmin is InitializableOwnable { contract DPPAdmin is InitializableOwnable {
address public _DPP_; address public _DPP_;
address public _OPERATOR_; address public _OPERATOR_;
address public _DODO_SMART_APPROVE_; address public _DODO_APPROVE_;
function init(address owner, address dpp,address operator, address dodoSmartApprove) external { function init(address owner, address dpp,address operator, address dodoApprove) external {
initOwner(owner); initOwner(owner);
_DPP_ = dpp; _DPP_ = dpp;
_OPERATOR_ = operator; _OPERATOR_ = operator;
_DODO_SMART_APPROVE_ = dodoSmartApprove; _DODO_APPROVE_ = dodoApprove;
} }
function setOperator(address newOperator) external onlyOwner { function setOperator(address newOperator) external onlyOwner {
@@ -78,7 +78,7 @@ contract DPPAdmin is InitializableOwnable {
uint256 baseOutAmount, uint256 baseOutAmount,
uint256 quoteOutAmount uint256 quoteOutAmount
) external { ) external {
require(msg.sender == _OWNER_ || (msg.sender == ISmartApprove(_DODO_SMART_APPROVE_).getSmartSwap() && assetTo == _OPERATOR_), "RESET FORBIDDEN！"); require(msg.sender == _OWNER_ || (msg.sender == IDODOApprove(_DODO_APPROVE_).getDODOProxy() && assetTo == _OPERATOR_), "RESET FORBIDDEN！");
IDPP(_DPP_).reset( IDPP(_DPP_).reset(
assetTo, assetTo,
newLpFeeRate, newLpFeeRate,
@@ -99,7 +99,7 @@ contract DPPAdmin is InitializableOwnable {
uint256 baseOutAmount, uint256 baseOutAmount,
uint256 quoteOutAmount uint256 quoteOutAmount
) external { ) external {
require(msg.sender == _OWNER_ || (msg.sender == ISmartApprove(_DODO_SMART_APPROVE_).getSmartSwap() && from == _OPERATOR_), "RESET FORBIDDEN！"); require(msg.sender == _OWNER_ || (msg.sender == IDODOApprove(_DODO_APPROVE_).getDODOProxy() && from == _OPERATOR_), "RESET FORBIDDEN！");
IDPP(_DPP_).reset( IDPP(_DPP_).reset(
msg.sender, msg.sender,
newLpFeeRate, newLpFeeRate,

14
contracts/SmartRoute/SmartApprove.sol → contracts/SmartRoute/DODOApprove.sol
View File

@@ -11,16 +11,16 @@ import {IERC20} from "../intf/IERC20.sol";
import {SafeERC20} from "../lib/SafeERC20.sol"; import {SafeERC20} from "../lib/SafeERC20.sol";
import {Ownable} from "../lib/Ownable.sol"; import {Ownable} from "../lib/Ownable.sol";
contract SmartApprove is Ownable { contract DODOApprove is Ownable {
using SafeERC20 for IERC20; using SafeERC20 for IERC20;
address public smartSwap; address public dodoProxy;
function setSmartSwap(address _smartSwap) external onlyOwner { function setDODOProxy(address _dodoProxy) external onlyOwner {
smartSwap = _smartSwap; dodoProxy = _dodoProxy;
} }
function getSmartSwap() public view returns (address) { function getDODOProxy() public view returns (address) {
return smartSwap; return dodoProxy;
} }
function claimTokens( function claimTokens(
@@ -29,7 +29,7 @@ contract SmartApprove is Ownable {
address dest, address dest,
uint256 amount uint256 amount
) external { ) external {
require(msg.sender == smartSwap, "Not SmartSwap Address, Access restricted"); require(msg.sender == dodoProxy, 'DODOApprove:Access restricted');
IERC20(token).safeTransferFrom(who, dest, amount); IERC20(token).safeTransferFrom(who, dest, amount);
} }
} }

69
contracts/SmartRoute/SmartSwap01.sol → contracts/SmartRoute/DODOV1Proxy01.sol
View File

@@ -12,33 +12,28 @@ import {IERC20} from "../intf/IERC20.sol";
import {UniversalERC20} from "../lib/UniversalERC20.sol"; import {UniversalERC20} from "../lib/UniversalERC20.sol";
import {SafeMath} from "../lib/SafeMath.sol"; import {SafeMath} from "../lib/SafeMath.sol";
import {IDODOSellHelper} from "../intf/IDODOSellHelper.sol"; import {IDODOSellHelper} from "../intf/IDODOSellHelper.sol";
import {IDODOApprove} from "../intf/IDODOApprove.sol";
import {IDODO} from "../intf/IDODO.sol"; import {IDODO} from "../intf/IDODO.sol";
import {IWETH} from "../intf/IWETH.sol"; import {IWETH} from "../intf/IWETH.sol";
interface ISmartApprove {
function claimTokens(IERC20 token,address who,address dest,uint256 amount) external;
function getSmartSwap() external view returns (address);
}
contract DODOV1Proxy01 is Ownable {
contract SmartSwap is Ownable {
using SafeMath for uint256; using SafeMath for uint256;
using UniversalERC20 for IERC20; using UniversalERC20 for IERC20;
IERC20 constant ETH_ADDRESS = IERC20(0x000000000000000000000000000000000000000E); address constant ETH_ADDRESS = 0x000000000000000000000000000000000000000E;
ISmartApprove public smartApprove; address public dodoApprove;
IDODOSellHelper public dodoSellHelper; address public dodoSellHelper;
address payable public _WETH_; address payable public _WETH_;
modifier judgeExpired(uint256 deadline) { modifier judgeExpired(uint256 deadline) {
require(deadline >= block.timestamp, 'DODO SmartSwap: EXPIRED'); require(deadline >= block.timestamp, 'DODOV1Proxy01: EXPIRED');
_; _;
} }
event OrderHistory( event OrderHistory(
IERC20 indexed fromToken, address indexed fromToken,
IERC20 indexed toToken, address indexed toToken,
address indexed sender, address indexed sender,
uint256 fromAmount, uint256 fromAmount,
uint256 returnAmount, uint256 returnAmount,
@@ -46,12 +41,12 @@ contract SmartSwap is Ownable {
); );
constructor( constructor(
address _smartApprove, address _dodoApprove,
address _dodoSellHelper, address _dodoSellHelper,
address payable _weth address payable _weth
) public { ) public {
smartApprove = ISmartApprove(_smartApprove); dodoApprove = _dodoApprove;
dodoSellHelper = IDODOSellHelper(_dodoSellHelper); dodoSellHelper = _dodoSellHelper;
_WETH_ = _weth; _WETH_ = _weth;
} }
@@ -60,21 +55,20 @@ contract SmartSwap is Ownable {
receive() external payable {} receive() external payable {}
function dodoSwap( function dodoSwap(
IERC20 fromToken, address fromToken,
IERC20 toToken, address toToken,
uint256 fromTokenAmount, uint256 fromTokenAmount,
uint256 minReturnAmount, uint256 minReturnAmount,
address[] memory dodoPairs, address[] memory dodoPairs,
uint256[] memory directions, uint256[] memory directions,
uint256 deadline uint256 deadline
) public payable judgeExpired(deadline) returns (uint256 returnAmount) { ) public payable judgeExpired(deadline) returns (uint256 returnAmount) {
require(minReturnAmount > 0, "DODO SmartSwap: Min return should be bigger then 0."); require(minReturnAmount > 0, 'DODOV1Proxy01: Min return should be bigger then 0.');
require(dodoPairs.length > 0, "DODO SmartSwap: pairs should exists.");
if (fromToken != ETH_ADDRESS) { if (fromToken != ETH_ADDRESS) {
smartApprove.claimTokens(fromToken, msg.sender, address(this),fromTokenAmount); IDODOApprove(dodoApprove).claimTokens(fromToken, msg.sender, address(this),fromTokenAmount);
} else { } else {
require(msg.value == fromTokenAmount, "DODO SmartSwap: ETH_AMOUNT_NOT_MATCH"); require(msg.value == fromTokenAmount, 'DODOV1Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: fromTokenAmount}(); IWETH(_WETH_).deposit{value: fromTokenAmount}();
} }
@@ -89,30 +83,30 @@ contract SmartSwap is Ownable {
address curDodoQuote = IDODO(curDodoPair)._QUOTE_TOKEN_(); address curDodoQuote = IDODO(curDodoPair)._QUOTE_TOKEN_();
uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this)); uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this));
IERC20(curDodoQuote).universalApprove(curDodoPair, curAmountIn); IERC20(curDodoQuote).universalApprove(curDodoPair, curAmountIn);
uint256 canBuyBaseAmount = dodoSellHelper.querySellQuoteToken( uint256 canBuyBaseAmount = IDODOSellHelper(dodoSellHelper).querySellQuoteToken(
curDodoPair, curDodoPair,
curAmountIn curAmountIn
); );
IDODO(curDodoPair).buyBaseToken(canBuyBaseAmount, 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) { if (toToken == ETH_ADDRESS) {
uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this)); uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this));
IWETH(_WETH_).withdraw(wethAmount); 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"); require(returnAmount >= minReturnAmount, 'DODOV1Proxy01: 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 OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
} }
function externalSwap( function externalSwap(
IERC20 fromToken, address fromToken,
IERC20 toToken, address toToken,
address approveTarget, address approveTarget,
address to, address to,
uint256 fromTokenAmount, uint256 fromTokenAmount,
@@ -120,25 +114,24 @@ contract SmartSwap is Ownable {
bytes memory callDataConcat, bytes memory callDataConcat,
uint256 deadline uint256 deadline
) public payable judgeExpired(deadline) returns (uint256 returnAmount) { ) public payable judgeExpired(deadline) returns (uint256 returnAmount) {
require(minReturnAmount > 0, 'DODOV1Proxy01: Min return should be bigger then 0.');
require(minReturnAmount > 0, "DODO SmartSwap: Min return should be bigger then 0.");
if (fromToken != ETH_ADDRESS) { if (fromToken != ETH_ADDRESS) {
smartApprove.claimTokens(fromToken, msg.sender, address(this), fromTokenAmount); IDODOApprove(dodoApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
fromToken.universalApprove(approveTarget, fromTokenAmount); IERC20(fromToken).universalApprove(approveTarget, fromTokenAmount);
} }
(bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0}( (bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0}(
callDataConcat callDataConcat
); );
require(success, "DODO SmartSwap: Contract Swap execution Failed"); require(success, 'DODOV1Proxy01: Contract Swap execution Failed');
fromToken.universalTransfer(msg.sender, fromToken.universalBalanceOf(address(this))); IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this)));
returnAmount = toToken.universalBalanceOf(address(this)); returnAmount = IERC20(toToken).universalBalanceOf(address(this));
require(returnAmount >= minReturnAmount, "DODO SmartSwap: Return amount is not enough"); require(returnAmount >= minReturnAmount, 'DODOV1Proxy01: 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 OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
} }
} }

61
contracts/SmartRoute/DODOV2Proxy01.sol
View File

@@ -21,7 +21,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
address constant ETH_ADDRESS = 0x000000000000000000000000000000000000000E; address constant ETH_ADDRESS = 0x000000000000000000000000000000000000000E;
address payable public _WETH_; address payable public _WETH_;
address public smartApprove; address public dodoApprove;
address public dodoSellHelper; address public dodoSellHelper;
address public dvmFactory; address public dvmFactory;
address public dppFactory; address public dppFactory;
@@ -50,13 +50,13 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
address _dvmFactory, address _dvmFactory,
address _dppFactory, address _dppFactory,
address payable _weth, address payable _weth,
address _smartApprove, address _dodoApprove,
address _dodoSellHelper address _dodoSellHelper
) public { ) public {
dvmFactory = _dvmFactory; dvmFactory = _dvmFactory;
dppFactory = _dppFactory; dppFactory = _dppFactory;
_WETH_ = _weth; _WETH_ = _weth;
smartApprove = _smartApprove; dodoApprove = _dodoApprove;
dodoSellHelper = _dodoSellHelper; dodoSellHelper = _dodoSellHelper;
} }
@@ -79,7 +79,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
} }
if(baseInAmount > 0){ if(baseInAmount > 0){
if(baseToken != ETH_ADDRESS){ if(baseToken != ETH_ADDRESS){
IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newVendingMachine, baseInAmount); IDODOV2(dodoApprove).claimTokens(baseToken, msg.sender, newVendingMachine, baseInAmount);
}else { }else {
require(msg.value == baseInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH'); require(msg.value == baseInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: baseInAmount}(); IWETH(_WETH_).deposit{value: baseInAmount}();
@@ -88,7 +88,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
} }
if(quoteInAmount > 0){ if(quoteInAmount > 0){
if(quoteToken != ETH_ADDRESS){ if(quoteToken != ETH_ADDRESS){
IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newVendingMachine, quoteInAmount); IDODOV2(dodoApprove).claimTokens(quoteToken, msg.sender, newVendingMachine, quoteInAmount);
}else { }else {
require(msg.value == quoteInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH'); require(msg.value == quoteInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: quoteInAmount}(); IWETH(_WETH_).deposit{value: quoteInAmount}();
@@ -109,7 +109,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
baseAdjustedInAmount = baseInAmount; baseAdjustedInAmount = baseInAmount;
quoteAdjustedInAmount = quoteInAmount; quoteAdjustedInAmount = quoteInAmount;
} }
//TODO: 若init时候 baseInAmount > 0 quoteReserve = 0 之后没法添加quote？
if (quoteReserve == 0 && baseReserve > 0) { if (quoteReserve == 0 && baseReserve > 0) {
baseAdjustedInAmount = baseInAmount; baseAdjustedInAmount = baseInAmount;
quoteAdjustedInAmount = 0; quoteAdjustedInAmount = 0;
@@ -135,16 +134,16 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 baseMinAmount, uint256 baseMinAmount,
uint256 quoteMinAmount, uint256 quoteMinAmount,
uint256 deadline uint256 deadline
) external virtual override judgeExpired(deadline) returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount) { ) external virtual override judgeExpired(deadline) returns (uint256 shares,uint256 baseAdjustedInAmount,uint256 quoteAdjustedInAmount) {
(uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount); (baseAdjustedInAmount, quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount);
require(baseAdjustedInAmount >= baseMinAmount && quoteAdjustedInAmount >= quoteMinAmount, 'DODOV2Proxy01: deposit amount is not enough');
address _dvm = DVMAddress; address _dvm = DVMAddress;
if(baseAdjustedInAmount > 0) { if(baseAdjustedInAmount > 0) {
IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._BASE_TOKEN_(), msg.sender, _dvm, baseAdjustedInAmount); IDODOV2(dodoApprove).claimTokens(IDODOV2(_dvm)._BASE_TOKEN_(), msg.sender, _dvm, baseAdjustedInAmount);
} }
if(quoteAdjustedInAmount > 0) if(quoteAdjustedInAmount > 0)
IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._QUOTE_TOKEN_(), msg.sender, _dvm, quoteAdjustedInAmount); IDODOV2(dodoApprove).claimTokens(IDODOV2(_dvm)._QUOTE_TOKEN_(), msg.sender, _dvm, quoteAdjustedInAmount);
(shares,baseActualInAmount,quoteActualInAmount) = IDODOV2(_dvm).buyShares(to); (shares,,) = IDODOV2(_dvm).buyShares(to);
require(baseActualInAmount >= baseMinAmount && quoteActualInAmount >= quoteMinAmount, 'DODOV2Proxy01: deposit amount is not enough');
} }
function addDVMLiquidityETH( function addDVMLiquidityETH(
@@ -156,16 +155,21 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 quoteMinAmount, uint256 quoteMinAmount,
uint8 flag, // 1 - baseInETH, 2 - quoteInETH uint8 flag, // 1 - baseInETH, 2 - quoteInETH
uint256 deadline uint256 deadline
) external virtual override payable judgeExpired(deadline) returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount) { ) external virtual override payable judgeExpired(deadline) returns (uint256 shares,uint256 baseAdjustedInAmount,uint256 quoteAdjustedInAmount) {
(uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount); (baseAdjustedInAmount, quoteAdjustedInAmount) = _addDVMLiquidity(DVMAddress,baseInAmount,quoteInAmount);
require(baseAdjustedInAmount >= baseMinAmount && quoteAdjustedInAmount >= quoteMinAmount, 'DODOV2Proxy01: deposit amount is not enough');
address _dvm = DVMAddress; address _dvm = DVMAddress;
if(baseAdjustedInAmount > 0) { if(baseAdjustedInAmount > 0) {
if(flag == 1) { if(flag == 1) {
require(msg.value >= baseAdjustedInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH'); require(msg.value >= baseAdjustedInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: baseAdjustedInAmount}(); IWETH(_WETH_).deposit{value: baseAdjustedInAmount}();
assert(IWETH(_WETH_).transfer(_dvm, baseAdjustedInAmount)); assert(IWETH(_WETH_).transfer(_dvm, baseAdjustedInAmount));
if (msg.value > baseAdjustedInAmount) {
(bool success,) = msg.sender.call{value:msg.value - baseAdjustedInAmount}(new bytes(0));
require(success, 'DODOV2Proxy01: ETH_TRANSFER_FAILED');
}
}else { }else {
IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._BASE_TOKEN_(), msg.sender, _dvm, baseAdjustedInAmount); IDODOV2(dodoApprove).claimTokens(IDODOV2(_dvm)._BASE_TOKEN_(), msg.sender, _dvm, baseAdjustedInAmount);
} }
} }
if(quoteAdjustedInAmount > 0){ if(quoteAdjustedInAmount > 0){
@@ -173,12 +177,15 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
require(msg.value >= quoteAdjustedInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH'); require(msg.value >= quoteAdjustedInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: quoteAdjustedInAmount}(); IWETH(_WETH_).deposit{value: quoteAdjustedInAmount}();
assert(IWETH(_WETH_).transfer(_dvm, quoteAdjustedInAmount)); assert(IWETH(_WETH_).transfer(_dvm, quoteAdjustedInAmount));
if (msg.value > quoteAdjustedInAmount) {
(bool success,) = msg.sender.call{value:msg.value - quoteAdjustedInAmount}(new bytes(0));
require(success, 'DODOV2Proxy01: ETH_TRANSFER_FAILED');
}
}else { }else {
IDODOV2(smartApprove).claimTokens(IDODOV2(_dvm)._QUOTE_TOKEN_(), msg.sender, _dvm, quoteAdjustedInAmount); IDODOV2(dodoApprove).claimTokens(IDODOV2(_dvm)._QUOTE_TOKEN_(), msg.sender, _dvm, quoteAdjustedInAmount);
} }
} }
(shares,baseActualInAmount,quoteActualInAmount) = IDODOV2(_dvm).buyShares(to); (shares,,) = IDODOV2(_dvm).buyShares(to);
require(baseActualInAmount >= baseMinAmount && quoteActualInAmount >= quoteMinAmount, 'DODOV2Proxy01: deposit amount is not enough');
} }
function createDODOPrivatePool( function createDODOPrivatePool(
@@ -195,7 +202,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
newPrivatePool = IDODOV2(dppFactory).createDODOPrivatePool(); newPrivatePool = IDODOV2(dppFactory).createDODOPrivatePool();
if(baseInAmount > 0){ if(baseInAmount > 0){
if(baseToken != ETH_ADDRESS){ if(baseToken != ETH_ADDRESS){
IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newPrivatePool, baseInAmount); IDODOV2(dodoApprove).claimTokens(baseToken, msg.sender, newPrivatePool, baseInAmount);
}else { }else {
require(msg.value == baseInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH'); require(msg.value == baseInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: baseInAmount}(); IWETH(_WETH_).deposit{value: baseInAmount}();
@@ -205,7 +212,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
} }
if(quoteInAmount > 0){ if(quoteInAmount > 0){
if(quoteToken != ETH_ADDRESS){ if(quoteToken != ETH_ADDRESS){
IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newPrivatePool, quoteInAmount); IDODOV2(dodoApprove).claimTokens(quoteToken, msg.sender, newPrivatePool, quoteInAmount);
}else { }else {
require(msg.value == quoteInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH'); require(msg.value == quoteInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: quoteInAmount}(); IWETH(_WETH_).deposit{value: quoteInAmount}();
@@ -238,9 +245,9 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 deadline uint256 deadline
) external virtual override judgeExpired(deadline) { ) external virtual override judgeExpired(deadline) {
if(baseInAmount > 0) if(baseInAmount > 0)
IDODOV2(smartApprove).claimTokens(IDODOV2(DPPAddress)._BASE_TOKEN_(), msg.sender, DPPAddress, baseInAmount); IDODOV2(dodoApprove).claimTokens(IDODOV2(DPPAddress)._BASE_TOKEN_(), msg.sender, DPPAddress, baseInAmount);
if(quoteInAmount > 0) if(quoteInAmount > 0)
IDODOV2(smartApprove).claimTokens(IDODOV2(DPPAddress)._QUOTE_TOKEN_(), msg.sender, DPPAddress, quoteInAmount); IDODOV2(dodoApprove).claimTokens(IDODOV2(DPPAddress)._QUOTE_TOKEN_(), msg.sender, DPPAddress, quoteInAmount);
IDODOV2(IDODOV2(DPPAddress)._OWNER_()).reset( IDODOV2(IDODOV2(DPPAddress)._OWNER_()).reset(
msg.sender, msg.sender,
newLpFeeRate, newLpFeeRate,
@@ -271,7 +278,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
IWETH(_WETH_).deposit{value: baseInAmount}(); IWETH(_WETH_).deposit{value: baseInAmount}();
assert(IWETH(_WETH_).transfer(DPPAddress, baseInAmount)); assert(IWETH(_WETH_).transfer(DPPAddress, baseInAmount));
}else { }else {
IDODOV2(smartApprove).claimTokens(IDODOV2(DPPAddress)._BASE_TOKEN_(), msg.sender, DPPAddress, baseInAmount); IDODOV2(dodoApprove).claimTokens(IDODOV2(DPPAddress)._BASE_TOKEN_(), msg.sender, DPPAddress, baseInAmount);
} }
} }
if(quoteInAmount > 0){ if(quoteInAmount > 0){
@@ -280,7 +287,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
IWETH(_WETH_).deposit{value: quoteInAmount}(); IWETH(_WETH_).deposit{value: quoteInAmount}();
assert(IWETH(_WETH_).transfer(DPPAddress, quoteInAmount)); assert(IWETH(_WETH_).transfer(DPPAddress, quoteInAmount));
}else { }else {
IDODOV2(smartApprove).claimTokens(IDODOV2(DPPAddress)._QUOTE_TOKEN_(), msg.sender, DPPAddress, quoteInAmount); IDODOV2(dodoApprove).claimTokens(IDODOV2(DPPAddress)._QUOTE_TOKEN_(), msg.sender, DPPAddress, quoteInAmount);
} }
} }
if( (flag == 3 && baseOutAmount > 0) || (flag == 4 && quoteOutAmount > 0) ) { if( (flag == 3 && baseOutAmount > 0) || (flag == 4 && quoteOutAmount > 0) ) {
@@ -370,7 +377,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 deadline uint256 deadline
) external virtual override judgeExpired(deadline) returns (uint256 returnAmount) { ) external virtual override judgeExpired(deadline) returns (uint256 returnAmount) {
require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.'); require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.');
IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount); IDODOV2(dodoApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
for (uint256 i = 0; i < dodoPairs.length; i++) { for (uint256 i = 0; i < dodoPairs.length; i++) {
if(i == dodoPairs.length - 1){ if(i == dodoPairs.length - 1){
@@ -406,7 +413,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 deadline uint256 deadline
) external virtual override judgeExpired(deadline) returns (uint256 returnAmount) { ) external virtual override judgeExpired(deadline) returns (uint256 returnAmount) {
require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.'); require(minReturnAmount > 0, 'DODOV2Proxy01: Min return should be bigger than 0.');
IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount); IDODOV2(dodoApprove).claimTokens(fromToken, msg.sender, dodoPairs[0], fromTokenAmount);
for (uint256 i = 0; i < dodoPairs.length; i++) { for (uint256 i = 0; i < dodoPairs.length; i++) {
if(i == dodoPairs.length - 1){ if(i == dodoPairs.length - 1){
@@ -439,7 +446,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
) external virtual override payable judgeExpired(deadline) returns (uint256 returnAmount) { ) 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) { if (fromToken != ETH_ADDRESS) {
IDODOV2(smartApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount); IDODOV2(dodoApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
IERC20(fromToken).universalApprove(approveTarget, fromTokenAmount); IERC20(fromToken).universalApprove(approveTarget, fromTokenAmount);
} }

4
contracts/intf/ISmartApprove.sol → contracts/intf/IDODOApprove.sol
View File

@@ -8,7 +8,7 @@
pragma solidity 0.6.9; pragma solidity 0.6.9;
pragma experimental ABIEncoderV2; pragma experimental ABIEncoderV2;
interface ISmartApprove { interface IDODOApprove {
function claimTokens(address token,address who,address dest,uint256 amount) external; function claimTokens(address token,address who,address dest,uint256 amount) external;
function getSmartSwap() external view returns (address); function getDODOProxy() external view returns (address);
} }

4
contracts/intf/IDODOV2.sol
View File

@@ -24,8 +24,6 @@ interface IDODOV2 {
function _OWNER_() external returns (address); function _OWNER_() external returns (address);
function getOwner() external view returns (address);
//========== DODOVendingMachine ======== //========== DODOVendingMachine ========
function createDODOVendingMachine( function createDODOVendingMachine(
@@ -87,6 +85,6 @@ interface IDODOV2 {
function claimTokens(address token,address who,address dest,uint256 amount) external; function claimTokens(address token,address who,address dest,uint256 amount) external;
function getSmartSwap() external view returns (address); function getDODOProxy() external view returns (address);
} }

4
contracts/intf/IDODOV2Proxy01.sol
View File

@@ -74,7 +74,7 @@ interface IDODOV2Proxy01 {
uint256 baseMinAmount, uint256 baseMinAmount,
uint256 quoteMinAmount, uint256 quoteMinAmount,
uint256 deadline uint256 deadline
) external returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount); ) external returns (uint256 shares,uint256 baseAdjustedInAmount,uint256 quoteAdjustedInAmount);
function addDVMLiquidityETH( function addDVMLiquidityETH(
address DVMAddress, address DVMAddress,
@@ -85,7 +85,7 @@ interface IDODOV2Proxy01 {
uint256 quoteMinAmount, uint256 quoteMinAmount,
uint8 flag, // 1 - baseInETH, 2 - quoteInETH uint8 flag, // 1 - baseInETH, 2 - quoteInETH
uint256 deadline uint256 deadline
) external payable returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount); ) external payable returns (uint256 shares,uint256 baseAdjustedInAmount,uint256 quoteAdjustedInAmount);
function createDODOPrivatePool( function createDODOPrivatePool(
address baseToken, address baseToken,

2
test/utils/Contracts.ts
View File

@@ -39,7 +39,7 @@ export const DODO_PROXY_NAME = "DODOV2Proxy01"
export const FEE_RATE_MODEL_NAME = "FeeRateModel" export const FEE_RATE_MODEL_NAME = "FeeRateModel"
export const DPP_NAME = "DPP" export const DPP_NAME = "DPP"
export const DPP_FACTORY_NAME = "DPPFactory" export const DPP_FACTORY_NAME = "DPPFactory"
export const SMART_APPROVE = "SmartApprove" export const SMART_APPROVE = "DODOApprove"
export const DODO_SELL_HELPER = "DODOSellHelper" export const DODO_SELL_HELPER = "DODOSellHelper"
export const DVM_ADMIN_NAME = "DVMAdmin" export const DVM_ADMIN_NAME = "DVMAdmin"
export const DPP_ADMIN_NAME = "DPPAdmin" export const DPP_ADMIN_NAME = "DPPAdmin"

2
test/utils/ProxyContext.ts
View File

@@ -107,7 +107,7 @@ export class ProxyContext {
] ]
); );
await this.SmartApprove.methods.setSmartSwap(this.DODOProxy.options.address).send(this.sendParam(this.Deployer)); await this.SmartApprove.methods.setDODOProxy(this.DODOProxy.options.address).send(this.sendParam(this.Deployer));
this.DODO = await contracts.newContract( this.DODO = await contracts.newContract(
contracts.MINTABLE_ERC20_CONTRACT_NAME, contracts.MINTABLE_ERC20_CONTRACT_NAME,