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

fix admin control && update proxy test framework

Browse Source
This commit is contained in:
owen05
2020-11-25 17:08:28 +08:00
parent 8a4da4b525
commit 8da583d5a8
25 changed files with 383 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
contracts/DODOPrivatePool/impl/DPP.sol
View File

@@ -15,13 +15,10 @@ import {IERC20} from "../../intf/IERC20.sol";
import {DPPTrader} from "./DPPTrader.sol";
contract DPP is DPPTrader {
constructor() public {
_FACTORY_ = msg.sender;
}
function init(
address owner,
address maintainer,
address operator,
address baseTokenAddress,
address quoteTokenAddress,
address lpFeeRateModel,
@@ -29,12 +26,13 @@ contract DPP is DPPTrader {
address kSource,
address iSource,
address gasPriceSource,
address dodoSmartApprove,
address tradePermissionManager
) external {
require(msg.sender == _FACTORY_, 'INIT FORBIDDEN');
initOwner(owner);
_ADMIN_ = owner;
_MAINTAINER_ = maintainer;
_OPERATOR_ = operator;
_BASE_TOKEN_ = IERC20(baseTokenAddress);
_QUOTE_TOKEN_ = IERC20(quoteTokenAddress);
_LP_FEE_RATE_MODEL_ = IFeeRateModel(lpFeeRateModel);
@@ -43,6 +41,8 @@ contract DPP is DPPTrader {
_K_ = IExternalValue(kSource);
_GAS_PRICE_LIMIT_ = IExternalValue(gasPriceSource);
_TRADE_PERMISSION_ = IPermissionManager(tradePermissionManager);
_DODO_SMART_APPROVE_ = dodoSmartApprove;
_resetTargetAndReserve();
}
// ============ Version Control ============

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

@@ -36,6 +36,10 @@ contract DPPAdmin is InitializableOwnable {
IDPP(dpp).setMaintainer(newMaintainer);
}
function setOperator(address newOperator) external onlyOwner {
IDPP(dpp).setOperator(newOperator);
}
function setGasPriceSource(address newGasPriceLimitSource) external onlyOwner {
IDPP(dpp).setGasPriceSource(newGasPriceLimitSource);
}
@@ -55,4 +59,13 @@ contract DPPAdmin is InitializableOwnable {
function setSell(bool open) external onlyOwner {
IDPP(dpp).setSell(open);
}
function retrieve(address payable to,address token,uint256 amount) external onlyOwner {
IDPP(dpp).retrieve(to,token,amount);
}
// ============ Admin Version Control ============
function version() external pure returns (uint256) {
return 100; // 1.0.0
}
}

7
contracts/DODOPrivatePool/impl/DPPStorage.sol
View File

@@ -27,8 +27,8 @@ import {PMMPricing} from "../../lib/PMMPricing.sol";
contract DPPStorage is InitializableOwnable, ReentrancyGuard {
using SafeMath for uint256;
address public _FACTORY_;
address public _ADMIN_;
address public _DODO_SMART_APPROVE_;
// ============ Variables for Control ============
@@ -44,6 +44,7 @@ contract DPPStorage is InitializableOwnable, ReentrancyGuard {
// ============ Core Address ============
address public _MAINTAINER_; // collect maintainer fee
address public _OPERATOR_;
IERC20 public _BASE_TOKEN_;
IERC20 public _QUOTE_TOKEN_;
@@ -79,6 +80,10 @@ contract DPPStorage is InitializableOwnable, ReentrancyGuard {
_MAINTAINER_ = newMaintainer;
}
function setOperator(address newOperator) external onlyOwner {
_OPERATOR_ = newOperator;
}
function setGasPriceSource(address newGasPriceLimitSource) external onlyOwner {
_GAS_PRICE_LIMIT_ = IExternalValue(newGasPriceLimitSource);
}

17
contracts/DODOPrivatePool/impl/DPPVault.sol
View File

@@ -15,6 +15,7 @@ import {SafeMath} from "../../lib/SafeMath.sol";
import {DecimalMath} from "../../lib/DecimalMath.sol";
import {SafeERC20} from "../../lib/SafeERC20.sol";
import {Ownable} from "../../lib/Ownable.sol";
import {ISmartApprove} from '../../intf/ISmartApprove.sol';
contract DPPVault is DPPStorage {
using SafeMath for uint256;
@@ -55,12 +56,6 @@ contract DPPVault is DPPStorage {
_QUOTE_RESERVE_ = _QUOTE_TOKEN_.balanceOf(address(this));
}
//TODO:
function initTargetAndReserve() public {
require(tx.origin == _OWNER_, "INIT FORBIDDEN！");
_resetTargetAndReserve();
}
function _resetTargetAndReserve() internal {
_BASE_TARGET_ = _BASE_TOKEN_.balanceOf(address(this));
_QUOTE_TARGET_ = _QUOTE_TOKEN_.balanceOf(address(this));
@@ -69,6 +64,7 @@ contract DPPVault is DPPStorage {
}
function reset(
address from,
uint256 newLpFeeRate,
uint256 newMtFeeRate,
uint256 newI,
@@ -76,11 +72,10 @@ contract DPPVault is DPPStorage {
uint256 baseOutAmount,
uint256 quoteOutAmount
) public {
//TODO: owner 权限可以是operator
require(tx.origin == _OWNER_, "RESET FORBIDDEN！");
require(msg.sender == ISmartApprove(_DODO_SMART_APPROVE_).getSmartSwap() && from == _OPERATOR_, "RESET FORBIDDEN！");
require(newK > 0 && newK <= 10**18, "K OUT OF RANGE!");
if(baseOutAmount > 0) _transferBaseOut(tx.origin, baseOutAmount);
if(quoteOutAmount > 0) _transferQuoteOut(tx.origin, quoteOutAmount);
if(baseOutAmount > 0) _transferBaseOut(from, baseOutAmount);
if(quoteOutAmount > 0) _transferQuoteOut(from, quoteOutAmount);
_resetTargetAndReserve();
_LP_FEE_RATE_MODEL_.setFeeRate(newLpFeeRate);
_MT_FEE_RATE_MODEL_.setFeeRate(newMtFeeRate);
@@ -115,7 +110,7 @@ contract DPPVault is DPPStorage {
uint256 amount
) external onlyOwner {
require(to != address(_BASE_TOKEN_) && to != address(_QUOTE_TOKEN_), "USE_WITHDRAW");
if (token == 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) {
if (token == 0x000000000000000000000000000000000000000E) {
to.transfer(amount);
} else {
IERC20(token).safeTransfer(msg.sender, amount);

6
contracts/DODOPrivatePool/intf/IDPP.sol
View File

@@ -12,6 +12,7 @@ interface IDPP {
function init(
address owner,
address maintainer,
address operator,
address baseTokenAddress,
address quoteTokenAddress,
address lpFeeRateModel,
@@ -19,6 +20,7 @@ interface IDPP {
address kSource,
address iSource,
address gasPriceSource,
address dodoSmartApprove,
address tradePermissionManager
) external;
@@ -31,6 +33,8 @@ interface IDPP {
function setMaintainer(address newMaintainer) external;
function setOperator(address newOperator) external;
function setGasPriceSource(address newGasPriceLimitSource) external;
function setISource(address newISource) external;
@@ -42,4 +46,6 @@ interface IDPP {
function setSell(bool open) external;
//==============================
function retrieve(address payable to,address token,uint256 amount) external;
}

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

@@ -17,10 +17,6 @@ import {DVMFunding} from "./DVMFunding.sol";
import {DVMVault} from "./DVMVault.sol";
contract DVM is DVMTrader, DVMFunding {
constructor() public {
_FACTORY_ = msg.sender;
}
function init(
address owner,
address maintainer,
@@ -33,7 +29,6 @@ contract DVM is DVMTrader, DVMFunding {
uint256 i,
uint256 k
) external {
require(msg.sender == _FACTORY_, 'INIT FORBIDDEN');
initOwner(owner);
_ADMIN_ = owner;
_BASE_TOKEN_ = IERC20(baseTokenAddress);

5
contracts/DODOVendingMachine/impl/DVMAdmin.sol
View File

@@ -47,4 +47,9 @@ contract DVMAdmin is InitializableOwnable {
function setSell(bool open) external onlyOwner {
IDVM(dvm).setSell(open);
}
// ============ Admin Version Control ============
function version() external pure returns (uint256) {
return 100; // 1.0.0
}
}

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

@@ -21,7 +21,6 @@ import {IERC20} from "../../intf/IERC20.sol";
contract DVMStorage is InitializableOwnable, ReentrancyGuard {
using SafeMath for uint256;
address public _FACTORY_;
address public _ADMIN_;
// ============ Variables for Control ============
@@ -63,8 +62,6 @@ contract DVMStorage is InitializableOwnable, ReentrancyGuard {
uint256 public _I_;
// ============ Setting Functions ============
//TODO: owner权限问题论证
function setLpFeeRateModel(address newLpFeeRateModel) external onlyOwner {
_LP_FEE_RATE_MODEL_ = IFeeRateModel(newLpFeeRateModel);
}

82
contracts/Factory/DPPFactory.sol
View File

@@ -22,7 +22,9 @@ contract DPPFactory is Ownable {
address public _DPP_ADMIN_TEMPLATE_;
address public _FEE_RATE_MODEL_TEMPLATE_;
address public _PERMISSION_MANAGER_TEMPLATE_;
address public _DEFAULT_GAS_PRICE_SOURCE_;
address public _VALUE_SOURCE_;
address public _DODO_SMART_APPROVE_;
//TODO: 平台修改tag的权限 && 池子标签类型
struct DPPInfo {
@@ -31,13 +33,13 @@ contract DPPFactory is Ownable {
}
// base -> quote -> DPP address list
mapping(address => mapping(address => address[])) _REGISTRY_;
mapping(address => mapping(address => address[])) public _REGISTRY_;
// token0 -> token1 -> DPP address list
mapping(address => mapping(address => address[])) _SORT_REGISTRY_;
mapping(address => mapping(address => address[])) public _SORT_REGISTRY_;
// creator -> DPP address list
mapping(address => address[]) _USER_REGISTRY_;
mapping(address => address[]) public _USER_REGISTRY_;
// DPP address -> info
mapping(address => DPPInfo) _DPP_INFO_;
mapping(address => DPPInfo) public _DPP_INFO_;
constructor(
address cloneFactory,
@@ -45,7 +47,9 @@ contract DPPFactory is Ownable {
address dppAdminTemplate,
address defautFeeRateModelTemplate,
address defaultPermissionManagerTemplate,
address defaultExternalValueTemplate
address defaultExternalValueTemplate,
address defaultGasPriceSource,
address dodoSmartApprove
) public {
_CLONE_FACTORY_ = cloneFactory;
_DPP_TEMPLATE_ = dppTemplate;
@@ -53,40 +57,52 @@ contract DPPFactory is Ownable {
_FEE_RATE_MODEL_TEMPLATE_ = defautFeeRateModelTemplate;
_PERMISSION_MANAGER_TEMPLATE_ = defaultPermissionManagerTemplate;
_VALUE_SOURCE_ = defaultExternalValueTemplate;
_DEFAULT_GAS_PRICE_SOURCE_ = defaultGasPriceSource;
_DODO_SMART_APPROVE_ = dodoSmartApprove;
}
function createDODOPrivatePool(
function createDODOPrivatePool() external returns(address newPrivatePool) {
newPrivatePool = ICloneFactory(_CLONE_FACTORY_).clone(_DPP_TEMPLATE_);
}
function initDODOPrivatePool(
address dppAddress,
address from,
address baseToken,
address quoteToken,
uint256 lpFeeRate,
uint256 mtFeeRate,
uint256 i,
uint256 k
) external returns (address newPrivatePool) {
(address token0, address token1) = baseToken < quoteToken ? (baseToken, quoteToken) : (quoteToken, baseToken);
newPrivatePool = ICloneFactory(_CLONE_FACTORY_).clone(_DPP_TEMPLATE_);
IDPP(newPrivatePool).init(
_createDPPAdminModel(msg.sender,newPrivatePool),
msg.sender,
uint256 k,
uint256 i
) external {
{
address _dppAddress = dppAddress;
address adminModel = _createDPPAdminModel(from,_dppAddress);
IDPP(_dppAddress).init(
adminModel,
from,
from,
baseToken,
quoteToken,
_createFeeRateModel(newPrivatePool, lpFeeRate),
_createFeeRateModel(newPrivatePool, mtFeeRate),
_createExternalValueModel(newPrivatePool, k),
_createExternalValueModel(newPrivatePool, i),
//TODO:hardcode
_createExternalValueModel(msg.sender, 10**22),
//TODO:讨论
_createPermissionManager(msg.sender)
_createFeeRateModel(_dppAddress, lpFeeRate),
_createFeeRateModel(_dppAddress, mtFeeRate),
_createExternalValueModel(_dppAddress, k),
_createExternalValueModel(_dppAddress, i),
_DEFAULT_GAS_PRICE_SOURCE_,
_DODO_SMART_APPROVE_,
_createPermissionManager(adminModel)
);
}
_REGISTRY_[baseToken][quoteToken].push(newPrivatePool);
_SORT_REGISTRY_[token0][token1].push(newPrivatePool);
_USER_REGISTRY_[msg.sender].push(newPrivatePool);
_DPP_INFO_[newPrivatePool] = (
{
(address token0, address token1) = baseToken < quoteToken ? (baseToken, quoteToken) : (quoteToken, baseToken);
_SORT_REGISTRY_[token0][token1].push(dppAddress);
}
_REGISTRY_[baseToken][quoteToken].push(dppAddress);
_USER_REGISTRY_[from].push(dppAddress);
_DPP_INFO_[dppAddress] = (
DPPInfo({
creator: msg.sender,
creator: from,
createTimeStamp: block.timestamp
})
);
@@ -112,8 +128,16 @@ contract DPPFactory is Ownable {
IDPPAdmin(adminModel).init(owner,dpp);
}
//TODO: 讨论 or 升级整个Factory
function updateAdminTemplate(address _newDPPAdminTemplate) external onlyOwner {
_DPP_ADMIN_TEMPLATE_ = _newDPPAdminTemplate;
}
function getPrivatePool(address baseToken, address quoteToken)
external
view
returns (address[] memory pools)
{
return _REGISTRY_[baseToken][quoteToken];
}
}

30
contracts/Factory/DVMFactory.sol
View File

@@ -30,13 +30,13 @@ contract DVMFactory is Ownable {
}
// base -> quote -> DVM address list
mapping(address => mapping(address => address[])) _REGISTRY_;
mapping(address => mapping(address => address[])) public _REGISTRY_;
// token0 -> token1 -> DVM address list
mapping(address => mapping(address => address[])) _SORT_REGISTRY_;
mapping(address => mapping(address => address[])) public _SORT_REGISTRY_;
// creator -> DVM address list
mapping(address => address[]) _USER_REGISTRY_;
mapping(address => address[]) public _USER_REGISTRY_;
// DVM address -> info
mapping(address => DVMInfo) _DVM_INFO_;
mapping(address => DVMInfo) public _DVM_INFO_;
constructor(
address cloneFactory,
@@ -55,6 +55,7 @@ contract DVMFactory is Ownable {
}
function createDODOVendingMachine(
address from,
address baseToken,
address quoteToken,
uint256 lpFeeRate,
@@ -62,32 +63,34 @@ contract DVMFactory is Ownable {
uint256 i,
uint256 k
) external returns (address newVendingMachine) {
(address token0, address token1) = baseToken < quoteToken ? (baseToken, quoteToken) : (quoteToken, baseToken);
newVendingMachine = ICloneFactory(_CLONE_FACTORY_).clone(_DVM_TEMPLATE_);
{
address adminModel = _createDVMAdminModel(from,newVendingMachine);
IDVM(newVendingMachine).init(
_createDVMAdminModel(msg.sender,newVendingMachine),
msg.sender,
adminModel,
from,
baseToken,
quoteToken,
_createFeeRateModel(newVendingMachine, lpFeeRate),
_createFeeRateModel(newVendingMachine, mtFeeRate),
_createPermissionManager(msg.sender),
_createPermissionManager(adminModel),
_DEFAULT_GAS_PRICE_SOURCE_,
i,
k
);
}
_REGISTRY_[baseToken][quoteToken].push(newVendingMachine);
{
(address token0, address token1) = baseToken < quoteToken ? (baseToken, quoteToken) : (quoteToken, baseToken);
_SORT_REGISTRY_[token0][token1].push(newVendingMachine);
_USER_REGISTRY_[msg.sender].push(newVendingMachine);
}
_USER_REGISTRY_[from].push(newVendingMachine);
_DVM_INFO_[newVendingMachine] = (
DVMInfo({
creator: msg.sender,
creator: from,
createTimeStamp: block.timestamp
})
);
return newVendingMachine;
}
function _createFeeRateModel(address owner, uint256 feeRate) internal returns (address feeRateModel) {
@@ -105,7 +108,6 @@ contract DVMFactory is Ownable {
IDVMAdmin(adminModel).init(owner,dvm);
}
//TODO: 讨论 or 升级整个Factory
function updateAdminTemplate(address _newDVMAdminTemplate) external onlyOwner {
_DVM_ADMIN_TEMPLATE_ = _newDVMAdminTemplate;
}

19
contracts/SmartRoute/DODOV2Proxy01.sol
View File

@@ -19,7 +19,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
using SafeMath for uint256;
using UniversalERC20 for IERC20;
address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address constant ETH_ADDRESS = 0x000000000000000000000000000000000000000E;
address payable public _WETH_;
address public smartApprove;
address public dodoSellHelper;
@@ -44,8 +44,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
event ExternalRecord(address indexed to, address indexed sender);
//========================================================================
constructor(
address _dvmFactory,
address _dppFactory,
@@ -73,7 +71,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
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);
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)
@@ -156,12 +154,21 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 k,
uint256 deadline
) external virtual override payable judgeExpired(deadline) returns (address newPrivatePool) {
newPrivatePool = IDODOV2(dppFactory).createDODOPrivatePool(baseToken, quoteToken, lpFeeRate, mtFeeRate, i, k);
newPrivatePool = IDODOV2(dppFactory).createDODOPrivatePool();
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();
IDODOV2(dppFactory).initDODOPrivatePool(
newPrivatePool,
msg.sender,
baseToken,
quoteToken,
lpFeeRate,
mtFeeRate,
k,
i
);
}
//TODO:ETH

52
contracts/SmartRoute/SmartSwap.sol → contracts/SmartRoute/SmartSwap01.sol
View File

@@ -12,17 +12,22 @@ 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 {ISmartApprove} from "../intf/ISmartApprove.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 {
using SafeMath for uint256;
using UniversalERC20 for IERC20;
address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address public smartApprove;
address public dodoSellHelper;
IERC20 constant ETH_ADDRESS = IERC20(0x000000000000000000000000000000000000000E);
ISmartApprove public smartApprove;
IDODOSellHelper public dodoSellHelper;
address payable public _WETH_;
@@ -32,8 +37,8 @@ contract SmartSwap is Ownable {
}
event OrderHistory(
address indexed fromToken,
address indexed toToken,
IERC20 indexed fromToken,
IERC20 indexed toToken,
address indexed sender,
uint256 fromAmount,
uint256 returnAmount,
@@ -45,8 +50,8 @@ contract SmartSwap is Ownable {
address _dodoSellHelper,
address payable _weth
) public {
smartApprove = _smartApprove;
dodoSellHelper = _dodoSellHelper;
smartApprove = ISmartApprove(_smartApprove);
dodoSellHelper = IDODOSellHelper(_dodoSellHelper);
_WETH_ = _weth;
}
@@ -55,8 +60,8 @@ contract SmartSwap is Ownable {
receive() external payable {}
function dodoSwap(
address fromToken,
address toToken,
IERC20 fromToken,
IERC20 toToken,
uint256 fromTokenAmount,
uint256 minReturnAmount,
address[] memory dodoPairs,
@@ -67,7 +72,7 @@ contract SmartSwap is Ownable {
require(dodoPairs.length > 0, "DODO SmartSwap: pairs should exists.");
if (fromToken != ETH_ADDRESS) {
ISmartApprove(smartApprove).claimTokens(fromToken, msg.sender, address(this),fromTokenAmount);
smartApprove.claimTokens(fromToken, msg.sender, address(this),fromTokenAmount);
} else {
require(msg.value == fromTokenAmount, "DODO SmartSwap: ETH_AMOUNT_NOT_MATCH");
IWETH(_WETH_).deposit{value: fromTokenAmount}();
@@ -84,33 +89,32 @@ contract SmartSwap is Ownable {
address curDodoQuote = IDODO(curDodoPair)._QUOTE_TOKEN_();
uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this));
IERC20(curDodoQuote).universalApprove(curDodoPair, curAmountIn);
uint256 canBuyBaseAmount = IDODOSellHelper(dodoSellHelper).querySellQuoteToken(
uint256 canBuyBaseAmount = dodoSellHelper.querySellQuoteToken(
curDodoPair,
curAmountIn
);
IDODO(curDodoPair).buyBaseToken(canBuyBaseAmount, curAmountIn, "");
}
}
IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this)));
fromToken.universalTransfer(msg.sender, 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));
returnAmount = toToken.universalBalanceOf(address(this));
require(returnAmount >= minReturnAmount, "DODO SmartSwap: Return amount is not enough");
IERC20(toToken).universalTransfer(msg.sender, returnAmount);
toToken.universalTransfer(msg.sender, returnAmount);
emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
}
function externalSwap(
address fromToken,
address toToken,
IERC20 fromToken,
IERC20 toToken,
address approveTarget,
address to,
uint256 gasSwap,
uint256 fromTokenAmount,
uint256 minReturnAmount,
bytes memory callDataConcat,
@@ -120,21 +124,21 @@ contract SmartSwap is Ownable {
require(minReturnAmount > 0, "DODO SmartSwap: Min return should be bigger then 0.");
if (fromToken != ETH_ADDRESS) {
ISmartApprove(smartApprove).claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
IERC20(fromToken).universalApprove(approveTarget, fromTokenAmount);
smartApprove.claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
fromToken.universalApprove(approveTarget, fromTokenAmount);
}
(bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0, gas: gasSwap}(
(bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0}(
callDataConcat
);
require(success, "DODO SmartSwap: Contract Swap execution Failed");
IERC20(fromToken).universalTransfer(msg.sender, IERC20(fromToken).universalBalanceOf(address(this)));
returnAmount = IERC20(toToken).universalBalanceOf(address(this));
fromToken.universalTransfer(msg.sender, fromToken.universalBalanceOf(address(this)));
returnAmount = toToken.universalBalanceOf(address(this));
require(returnAmount >= minReturnAmount, "DODO SmartSwap: Return amount is not enough");
IERC20(toToken).universalTransfer(msg.sender, returnAmount);
toToken.universalTransfer(msg.sender, returnAmount);
emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount, block.timestamp);
}
}

13
contracts/intf/IDODOV2.sol
View File

@@ -27,6 +27,7 @@ interface IDODOV2 {
//========== DODOVendingMachine ========
function createDODOVendingMachine(
address from,
address baseToken,
address quoteToken,
uint256 lpFeeRate,
@@ -41,16 +42,18 @@ interface IDODOV2 {
//========== DODOPrivatePool ===========
function initTargetAndReserve() external;
function createDODOPrivatePool() external returns (address newPrivatePool);
function createDODOPrivatePool(
function initDODOPrivatePool(
address dppAddress,
address from,
address baseToken,
address quoteToken,
uint256 lpFeeRate,
uint256 mtFeeRate,
uint256 i,
uint256 k
) external returns (address newPrivatePool);
uint256 k,
uint256 i
) external;
function reset(
uint256 newLpFeeRate,

2
contracts/lib/UniversalERC20.sol
View File

@@ -16,7 +16,7 @@ library UniversalERC20 {
using SafeERC20 for IERC20;
IERC20 private constant ZERO_ADDRESS = IERC20(0x0000000000000000000000000000000000000000);
IERC20 private constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
IERC20 private constant ETH_ADDRESS = IERC20(0x000000000000000000000000000000000000000E);
function isETH(IERC20 token) internal pure returns (bool) {
return (token == ZERO_ADDRESS || token == ETH_ADDRESS);