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;
import {IDPP} from "../intf/IDPP.sol";
import {ISmartApprove} from '../../intf/ISmartApprove.sol';
import {IDODOApprove} from '../../intf/IDODOApprove.sol';
import {InitializableOwnable} from "../../lib/InitializableOwnable.sol";
contract DPPAdmin is InitializableOwnable {
address public _DPP_;
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);
_DPP_ = dpp;
_OPERATOR_ = operator;
_DODO_SMART_APPROVE_ = dodoSmartApprove;
_DODO_APPROVE_ = dodoApprove;
}
function setOperator(address newOperator) external onlyOwner {
@@ -78,7 +78,7 @@ contract DPPAdmin is InitializableOwnable {
uint256 baseOutAmount,
uint256 quoteOutAmount
) 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(
assetTo,
newLpFeeRate,
@@ -99,7 +99,7 @@ contract DPPAdmin is InitializableOwnable {
uint256 baseOutAmount,
uint256 quoteOutAmount
) 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(
msg.sender,
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 {Ownable} from "../lib/Ownable.sol";
contract SmartApprove is Ownable {
contract DODOApprove is Ownable {
using SafeERC20 for IERC20;
address public smartSwap;
address public dodoProxy;
function setSmartSwap(address _smartSwap) external onlyOwner {
smartSwap = _smartSwap;
function setDODOProxy(address _dodoProxy) external onlyOwner {
dodoProxy = _dodoProxy;
}
function getSmartSwap() public view returns (address) {
return smartSwap;
function getDODOProxy() public view returns (address) {
return dodoProxy;
}
function claimTokens(
@@ -29,7 +29,7 @@ contract SmartApprove is Ownable {
address dest,
uint256 amount
) external {
require(msg.sender == smartSwap, "Not SmartSwap Address, Access restricted");
require(msg.sender == dodoProxy, 'DODOApprove:Access restricted');
IERC20(token).safeTransferFrom(who, dest, amount);
}
}

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

63
contracts/SmartRoute/DODOV2Proxy01.sol
View File

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

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

@@ -8,7 +8,7 @@
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface ISmartApprove {
interface IDODOApprove {
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 getOwner() external view returns (address);
//========== DODOVendingMachine ========
function createDODOVendingMachine(
@@ -87,6 +85,6 @@ interface IDODOV2 {
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 quoteMinAmount,
uint256 deadline
) external returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount);
) external returns (uint256 shares,uint256 baseAdjustedInAmount,uint256 quoteAdjustedInAmount);
function addDVMLiquidityETH(
address DVMAddress,
@@ -85,7 +85,7 @@ interface IDODOV2Proxy01 {
uint256 quoteMinAmount,
uint8 flag, // 1 - baseInETH, 2 - quoteInETH
uint256 deadline
) external payable returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount);
) external payable returns (uint256 shares,uint256 baseAdjustedInAmount,uint256 quoteAdjustedInAmount);
function createDODOPrivatePool(
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 DPP_NAME = "DPP"
export const DPP_FACTORY_NAME = "DPPFactory"
export const SMART_APPROVE = "SmartApprove"
export const SMART_APPROVE = "DODOApprove"
export const DODO_SELL_HELPER = "DODOSellHelper"
export const DVM_ADMIN_NAME = "DVMAdmin"
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(
contracts.MINTABLE_ERC20_CONTRACT_NAME,