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

Merge branch 'feature/V2' of github.com:DODOEX/contractV2 into feature/V2

Browse Source
This commit is contained in:
mingda
2020-11-26 21:46:35 +08:00
parent b368027cfd 978b7eb1db
commit 68c377807b
15 changed files with 768 additions and 326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -9,59 +9,106 @@ pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {IDPP} from "../intf/IDPP.sol";
import {ISmartApprove} from '../../intf/ISmartApprove.sol';
import {InitializableOwnable} from "../../lib/InitializableOwnable.sol";
contract DPPAdmin is InitializableOwnable {
address public dpp;
address public _DPP_;
address public _OPERATOR_;
address public _DODO_SMART_APPROVE_;
function init(address owner, address _dpp) external {
function init(address owner, address dpp,address operator, address dodoSmartApprove) external {
initOwner(owner);
dpp = _dpp;
}
function setLpFeeRateModel(address newLpFeeRateModel) external onlyOwner {
IDPP(dpp).setLpFeeRateModel(newLpFeeRateModel);
}
function setMtFeeRateModel(address newMtFeeRateModel) external onlyOwner {
IDPP(dpp).setMtFeeRateModel(newMtFeeRateModel);
}
function setTradePermissionManager(address newTradePermissionManager) external onlyOwner {
IDPP(dpp).setTradePermissionManager(newTradePermissionManager);
}
function setMaintainer(address newMaintainer) external onlyOwner {
IDPP(dpp).setMaintainer(newMaintainer);
_DPP_ = dpp;
_OPERATOR_ = operator;
_DODO_SMART_APPROVE_ = dodoSmartApprove;
}
function setOperator(address newOperator) external onlyOwner {
IDPP(dpp).setOperator(newOperator);
_OPERATOR_ = newOperator;
}
function setLpFeeRateModel(address newLpFeeRateModel) external onlyOwner {
IDPP(_DPP_).setLpFeeRateModel(newLpFeeRateModel);
}
function setMtFeeRateModel(address newMtFeeRateModel) external onlyOwner {
IDPP(_DPP_).setMtFeeRateModel(newMtFeeRateModel);
}
function setTradePermissionManager(address newTradePermissionManager) external onlyOwner {
IDPP(_DPP_).setTradePermissionManager(newTradePermissionManager);
}
function setMaintainer(address newMaintainer) external onlyOwner {
IDPP(_DPP_).setMaintainer(newMaintainer);
}
function setGasPriceSource(address newGasPriceLimitSource) external onlyOwner {
IDPP(dpp).setGasPriceSource(newGasPriceLimitSource);
IDPP(_DPP_).setGasPriceSource(newGasPriceLimitSource);
}
function setISource(address newISource) external onlyOwner {
IDPP(dpp).setISource(newISource);
IDPP(_DPP_).setISource(newISource);
}
function setKSource(address newKSource) external onlyOwner {
IDPP(dpp).setKSource(newKSource);
IDPP(_DPP_).setKSource(newKSource);
}
function setBuy(bool open) external onlyOwner {
IDPP(dpp).setBuy(open);
IDPP(_DPP_).setBuy(open);
}
function setSell(bool open) external onlyOwner {
IDPP(dpp).setSell(open);
IDPP(_DPP_).setSell(open);
}
function retrieve(address payable to,address token,uint256 amount) external onlyOwner {
IDPP(dpp).retrieve(to,token,amount);
IDPP(_DPP_).retrieve(to,token,amount);
}
function reset(
address assetTo,
uint256 newLpFeeRate,
uint256 newMtFeeRate,
uint256 newI,
uint256 newK,
uint256 baseOutAmount,
uint256 quoteOutAmount
) external {
require(msg.sender == _OWNER_ || (msg.sender == ISmartApprove(_DODO_SMART_APPROVE_).getSmartSwap() && assetTo == _OPERATOR_), "RESET FORBIDDEN！");
IDPP(_DPP_).reset(
assetTo,
newLpFeeRate,
newMtFeeRate,
newI,
newK,
baseOutAmount,
quoteOutAmount
);
}
function resetETH(
address from,
uint256 newLpFeeRate,
uint256 newMtFeeRate,
uint256 newI,
uint256 newK,
uint256 baseOutAmount,
uint256 quoteOutAmount
) external {
require(msg.sender == _OWNER_ || (msg.sender == ISmartApprove(_DODO_SMART_APPROVE_).getSmartSwap() && from == _OPERATOR_), "RESET FORBIDDEN！");
IDPP(_DPP_).reset(
msg.sender,
newLpFeeRate,
newMtFeeRate,
newI,
newK,
baseOutAmount,
quoteOutAmount
);
}
// ============ Admin Version Control ============

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

@@ -105,4 +105,9 @@ contract DPPStorage is InitializableOwnable, ReentrancyGuard {
function getMtFeeRate(address trader) external view returns (uint256 feeRate) {
return _MT_FEE_RATE_MODEL_.getFeeRate(trader);
}
function getOwner() external view returns (address) {
return _OWNER_;
}
}

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

@@ -12,7 +12,6 @@ interface IDPP {
function init(
address owner,
address maintainer,
address operator,
address baseTokenAddress,
address quoteTokenAddress,
address lpFeeRateModel,
@@ -20,7 +19,6 @@ interface IDPP {
address kSource,
address iSource,
address gasPriceSource,
address dodoSmartApprove,
address tradePermissionManager
) external;
@@ -33,8 +31,6 @@ interface IDPP {
function setMaintainer(address newMaintainer) external;
function setOperator(address newOperator) external;
function setGasPriceSource(address newGasPriceLimitSource) external;
function setISource(address newISource) external;
@@ -48,4 +44,15 @@ interface IDPP {
function retrieve(address payable to,address token,uint256 amount) external;
function reset(
address assetTo,
uint256 newLpFeeRate,
uint256 newMtFeeRate,
uint256 newI,
uint256 newK,
uint256 baseOutAmount,
uint256 quoteOutAmount
) external;
}

2
contracts/DODOPrivatePool/intf/IDPPAdmin.sol
View File

@@ -9,5 +9,5 @@ pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IDPPAdmin {
function init(address owner, address _dpp) external;
function init(address owner, address dpp,address operator, address dodoSmartApprove) external;
}

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);

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

@@ -13,39 +13,39 @@ import {InitializableOwnable} from "../../lib/InitializableOwnable.sol";
contract DVMAdmin is InitializableOwnable {
address public dvm;
address public _DVM_;
function init(address owner, address _dvm) external {
function init(address owner, address dvm) external {
initOwner(owner);
dvm = _dvm;
_DVM_ = dvm;
}
function setLpFeeRateModel(address newLpFeeRateModel) external onlyOwner {
IDVM(dvm).setLpFeeRateModel(newLpFeeRateModel);
IDVM(_DVM_).setLpFeeRateModel(newLpFeeRateModel);
}
function setMtFeeRateModel(address newMtFeeRateModel) external onlyOwner {
IDVM(dvm).setMtFeeRateModel(newMtFeeRateModel);
IDVM(_DVM_).setMtFeeRateModel(newMtFeeRateModel);
}
function setTradePermissionManager(address newTradePermissionManager) external onlyOwner {
IDVM(dvm).setTradePermissionManager(newTradePermissionManager);
IDVM(_DVM_).setTradePermissionManager(newTradePermissionManager);
}
function setMaintainer(address newMaintainer) external onlyOwner {
IDVM(dvm).setMaintainer(newMaintainer);
IDVM(_DVM_).setMaintainer(newMaintainer);
}
function setGasPriceSource(address newGasPriceLimitSource) external onlyOwner {
IDVM(dvm).setGasPriceSource(newGasPriceLimitSource);
IDVM(_DVM_).setGasPriceSource(newGasPriceLimitSource);
}
function setBuy(bool open) external onlyOwner {
IDVM(dvm).setBuy(open);
IDVM(_DVM_).setBuy(open);
}
function setSell(bool open) external onlyOwner {
IDVM(dvm).setSell(open);
IDVM(_DVM_).setSell(open);
}
// ============ Admin Version Control ============

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]

7
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_;
@@ -99,4 +97,9 @@ contract DVMStorage is InitializableOwnable, ReentrancyGuard {
function getMtFeeRate(address trader) external view returns (uint256 feeRate) {
return _MT_FEE_RATE_MODEL_.getFeeRate(trader);
}
function getOwner() external view returns (address) {
return _OWNER_;
}
}

11
contracts/Factory/DPPFactory.sol
View File

@@ -54,11 +54,11 @@ contract DPPFactory is Ownable {
_CLONE_FACTORY_ = cloneFactory;
_DPP_TEMPLATE_ = dppTemplate;
_DPP_ADMIN_TEMPLATE_ = dppAdminTemplate;
_DODO_SMART_APPROVE_ = dodoSmartApprove;
_FEE_RATE_MODEL_TEMPLATE_ = defautFeeRateModelTemplate;
_PERMISSION_MANAGER_TEMPLATE_ = defaultPermissionManagerTemplate;
_VALUE_SOURCE_ = defaultExternalValueTemplate;
_DEFAULT_GAS_PRICE_SOURCE_ = defaultGasPriceSource;
_DODO_SMART_APPROVE_ = dodoSmartApprove;
}
function createDODOPrivatePool() external returns(address newPrivatePool) {
@@ -77,11 +77,10 @@ contract DPPFactory is Ownable {
) external {
{
address _dppAddress = dppAddress;
address adminModel = _createDPPAdminModel(from,_dppAddress);
address adminModel = _createDPPAdminModel(from,_dppAddress,from,_DODO_SMART_APPROVE_);
IDPP(_dppAddress).init(
adminModel,
from,
from,
baseToken,
quoteToken,
_createFeeRateModel(_dppAddress, lpFeeRate),
@@ -89,7 +88,6 @@ contract DPPFactory is Ownable {
_createExternalValueModel(_dppAddress, k),
_createExternalValueModel(_dppAddress, i),
_DEFAULT_GAS_PRICE_SOURCE_,
_DODO_SMART_APPROVE_,
_createPermissionManager(adminModel)
);
}
@@ -123,16 +121,15 @@ contract DPPFactory is Ownable {
IExternalValue(valueModel).init(owner, value);
}
function _createDPPAdminModel(address owner, address dpp) internal returns (address adminModel) {
function _createDPPAdminModel(address owner, address dpp,address operator, address dodoSmartApprove) internal returns (address adminModel) {
adminModel = ICloneFactory(_CLONE_FACTORY_).clone(_DPP_ADMIN_TEMPLATE_);
IDPPAdmin(adminModel).init(owner,dpp);
IDPPAdmin(adminModel).init(owner,dpp,operator,dodoSmartApprove);
}
function updateAdminTemplate(address _newDPPAdminTemplate) external onlyOwner {
_DPP_ADMIN_TEMPLATE_ = _newDPPAdminTemplate;
}
function getPrivatePool(address baseToken, address quoteToken)
external
view

370
contracts/SmartRoute/DODOV2Proxy01.sol
View File

@@ -31,6 +31,10 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
_;
}
fallback() external payable {}
receive() external payable {}
//============================== events ==================================
event OrderHistory(
address indexed fromToken,
@@ -40,8 +44,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 returnAmount,
uint256 timeStamp
);
event ExternalRecord(address indexed to, address indexed sender);
//========================================================================
constructor(
@@ -58,8 +60,8 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
dodoSellHelper = _dodoSellHelper;
}
//TODO:ETH
function createDODOVendingMachine(
address assetTo,
address baseToken,
address quoteToken,
uint256 baseInAmount,
@@ -70,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);
}
@@ -108,7 +127,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
}
}
//TODO:ETH
function addDVMLiquidity(
address DVMAddress,
address to,
@@ -117,29 +135,50 @@ 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");
require(baseActualInAmount >= baseMinAmount && quoteActualInAmount >= quoteMinAmount, 'DODOV2Proxy01: deposit amount is not enough');
}
//TODO:ETH 构造data
function removeDVMLiquidity(
function addDVMLiquidityETH(
address DVMAddress,
address to,
uint256 shares,
uint256 baseOutMinAmount,
uint256 quoteOutMinAmount,
uint256 baseInAmount,
uint256 quoteInAmount,
uint256 baseMinAmount,
uint256 quoteMinAmount,
uint8 flag, // 1 - baseInETH, 2 - quoteInETH
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");
) 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 createDODOPrivatePool(
@@ -158,7 +197,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
if(baseToken != ETH_ADDRESS){
IDODOV2(smartApprove).claimTokens(baseToken, msg.sender, newPrivatePool, baseInAmount);
}else {
require(msg.value == baseInAmount, "DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH");
require(msg.value == baseInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: baseInAmount}();
assert(IWETH(_WETH_).transfer(newPrivatePool, baseInAmount));
baseToken = _WETH_;
@@ -168,7 +207,7 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
if(quoteToken != ETH_ADDRESS){
IDODOV2(smartApprove).claimTokens(quoteToken, msg.sender, newPrivatePool, quoteInAmount);
}else {
require(msg.value == quoteInAmount, "DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH");
require(msg.value == quoteInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: quoteInAmount}();
assert(IWETH(_WETH_).transfer(newPrivatePool, quoteInAmount));
quoteToken = _WETH_;
@@ -186,7 +225,6 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
);
}
//TODO:ETH
function resetDODOPrivatePool(
address DPPAddress,
uint256 newLpFeeRate,
@@ -198,12 +236,13 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
uint256 baseOutAmount,
uint256 quoteOutAmount,
uint256 deadline
) external virtual override payable judgeExpired(deadline) {
if(baseInAmount > 0)
) external virtual override 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(
IDODOV2(IDODOV2(DPPAddress).getOwner()).reset(
msg.sender,
newLpFeeRate,
newMtFeeRate,
newI,
@@ -213,8 +252,83 @@ contract DODOV2Proxy01 is IDODOV2Proxy01 {
);
}
function dodoSwap(
address fromToken,
function resetDODOPrivatePoolETH(
address DPPAddress,
uint256 newLpFeeRate,
uint256 newMtFeeRate,
uint256 newI,
uint256 newK,
uint256 baseInAmount,
uint256 quoteInAmount,
uint256 baseOutAmount,
uint256 quoteOutAmount,
uint8 flag, // 1 - baseInETH, 2 - quoteInETH, 3 - baseOutETH, 4 - quoteOutETH
uint256 deadline
) external virtual override payable judgeExpired(deadline) {
if(baseInAmount > 0){
if(flag == 1){
require(msg.value == baseInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: baseInAmount}();
assert(IWETH(_WETH_).transfer(DPPAddress, baseInAmount));
}else {
IDODOV2(smartApprove).claimTokens(IDODOV2(DPPAddress)._BASE_TOKEN_(), msg.sender, DPPAddress, baseInAmount);
}
}
if(quoteInAmount > 0){
if(flag == 2){
require(msg.value == quoteInAmount, 'DODOV2Proxy01: ETH_AMOUNT_NOT_MATCH');
IWETH(_WETH_).deposit{value: quoteInAmount}();
assert(IWETH(_WETH_).transfer(DPPAddress, quoteInAmount));
}else {
IDODOV2(smartApprove).claimTokens(IDODOV2(DPPAddress)._QUOTE_TOKEN_(), msg.sender, DPPAddress, quoteInAmount);
}
}
if( (flag == 3 && baseOutAmount > 0) || (flag == 4 && quoteOutAmount > 0) ) {
IDODOV2(IDODOV2(DPPAddress).getOwner()).resetETH(
msg.sender,
newLpFeeRate,
newMtFeeRate,
newI,
newK,
baseOutAmount,
quoteOutAmount
);
if(baseOutAmount > 0) {
if(flag == 3) {
uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this));
IWETH(_WETH_).withdraw(wethAmount);
(bool success,) = msg.sender.call{value:wethAmount}(new bytes(0));
require(success, 'DODOV2Proxy01: ETH_TRANSFER_FAILED');
}else {
IERC20(IDODOV2(DPPAddress)._BASE_TOKEN_()).universalTransfer(msg.sender, baseOutAmount);
}
}
if(quoteOutAmount > 0) {
if(flag == 4) {
uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this));
IWETH(_WETH_).withdraw(wethAmount);
(bool success,) = msg.sender.call{value:wethAmount}(new bytes(0));
require(success, 'DODOV2Proxy01: ETH_TRANSFER_FAILED');
}else {
IERC20(IDODOV2(DPPAddress)._QUOTE_TOKEN_()).universalTransfer(msg.sender, quoteOutAmount);
}
}
}else {
IDODOV2(IDODOV2(DPPAddress).getOwner()).reset(
msg.sender,
newLpFeeRate,
newMtFeeRate,
newI,
newK,
baseOutAmount,
quoteOutAmount
);
}
}
function dodoSwapETHToToken(
address payable assetTo,
address toToken,
uint256 fromTokenAmount,
uint256 minReturnAmount,
@@ -222,42 +336,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(
@@ -265,107 +432,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);
}
//====================== 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;
// }
}

13
contracts/intf/IDODOV2.sol
View File

@@ -24,6 +24,8 @@ interface IDODOV2 {
function _QUOTE_TOKEN_() external returns (address);
function getOwner() external view returns (address);
//========== DODOVendingMachine ========
function createDODOVendingMachine(
@@ -56,6 +58,17 @@ interface IDODOV2 {
) external;
function reset(
address assetTo,
uint256 newLpFeeRate,
uint256 newMtFeeRate,
uint256 newI,
uint256 newK,
uint256 baseOutAmount,
uint256 quoteOutAmount
) external;
function resetETH(
address from,
uint256 newLpFeeRate,
uint256 newMtFeeRate,
uint256 newI,

64
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,18 +76,18 @@ interface IDODOV2Proxy01 {
uint256 baseMinAmount,
uint256 quoteMinAmount,
uint256 deadline
) external payable returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount);
) external returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount);
function removeDVMLiquidity(
address DVMAddress,
function addDVMLiquidityETH(
address DVMAddress,
address to,
uint256 shares,
uint256 baseOutMinAmount,
uint256 quoteOutMinAmount,
uint256 baseInAmount,
uint256 quoteInAmount,
uint256 baseMinAmount,
uint256 quoteMinAmount,
uint8 flag, // 1 - baseInETH, 2 - quoteInETH
uint256 deadline
) external payable returns (uint256 baseOutAmount,uint256 quoteOutAmount);
) external payable returns (uint256 shares,uint256 baseActualInAmount,uint256 quoteActualInAmount);
function createDODOPrivatePool(
address baseToken,
@@ -78,10 +98,9 @@ interface IDODOV2Proxy01 {
uint256 mtFeeRate,
uint256 i,
uint256 k,
uint256 deadline
uint256 deadline
) external payable returns (address newPrivatePool);
function resetDODOPrivatePool(
address DPPAddress,
uint256 newLpFeeRate,
@@ -93,6 +112,21 @@ interface IDODOV2Proxy01 {
uint256 baseOutAmount,
uint256 quoteOutAmount,
uint256 deadline
) external;
function resetDODOPrivatePoolETH(
address DPPAddress,
uint256 newLpFeeRate,
uint256 newMtFeeRate,
uint256 newI,
uint256 newK,
uint256 baseInAmount,
uint256 quoteInAmount,
uint256 baseOutAmount,
uint256 quoteOutAmount,
uint8 flag, // 1 - baseInETH, 2 - quoteInETH, 3 - baseOutETH, 4 - quoteOutETH
uint256 deadline
) external payable;
//TODO: addLiquidityToClassical

283
test/Proxy/proxy.dpp.test.ts
View File

@@ -6,11 +6,13 @@
*/
// import * as assert from 'assert';
import { decimalStr, mweiStr} from '../utils/Converter';
import BigNumber from "bignumber.js";
import { decimalStr, mweiStr } from '../utils/Converter';
import { logGas } from '../utils/Log';
import { ProxyContext, getProxyContext } from '../utils/ProxyContext';
import { assert } from 'chai';
import * as contracts from '../utils/Contracts';
import { Contract } from 'web3-eth-contract';
let lp: string;
let project: string;
@@ -28,12 +30,11 @@ async function init(ctx: ProxyContext): Promise<void> {
project = ctx.SpareAccounts[1];
trader = ctx.SpareAccounts[2];
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("100000"));
await ctx.mintTestToken(project, ctx.DODO, decimalStr("100000"));
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("100000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000000"));
await ctx.mintTestToken(project, ctx.DODO, decimalStr("1000000"));
await ctx.mintTestToken(lp, ctx.USDT, mweiStr("100000"));
await ctx.mintTestToken(project, ctx.USDT, mweiStr("100000"));
await ctx.mintTestToken(lp, ctx.USDT, mweiStr("1000000"));
await ctx.mintTestToken(project, ctx.USDT, mweiStr("1000000"));
// await ctx.WETH.methods.deposit().send(ctx.sendParam(lp, '80'));
// await ctx.WETH.methods.deposit().send(ctx.sendParam(project, '80'));
@@ -44,7 +45,7 @@ async function init(ctx: ProxyContext): Promise<void> {
}
async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string): Promise<string> {
async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string,i:string): Promise<string> {
let PROXY = ctx.DODOProxy;
await PROXY.methods.createDODOPrivatePool(
token0,
@@ -53,7 +54,7 @@ async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, t
token1Amount,
config.lpFeeRate,
config.mtFeeRate,
config.i,
i,
config.k,
Math.floor(new Date().getTime()/1000 + 60 * 10)
).send(ctx.sendParam(project,ethValue));
@@ -68,12 +69,16 @@ describe("DODOProxyV2.0", () => {
let ctx: ProxyContext;
let dpp_DODO_USDT: string;
let dpp_WETH_USDT: string;
let DPP_DODO_USDT: Contract;
let DPP_WETH_USDT: Contract;
before(async () => {
ctx = await getProxyContext();
await init(ctx);
dpp_DODO_USDT = await initCreateDPP(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("10000"),mweiStr("10000"),"0");
dpp_WETH_USDT = await initCreateDPP(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("10"),mweiStr("10000"),"10");
dpp_DODO_USDT = await initCreateDPP(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("100000"),mweiStr("30000"), "0",mweiStr("0.3"));
DPP_DODO_USDT = contracts.getContractWithAddress(contracts.DPP_NAME,dpp_DODO_USDT);
dpp_WETH_USDT = await initCreateDPP(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("5"),mweiStr("30000"),"5",mweiStr("600"));
DPP_WETH_USDT = contracts.getContractWithAddress(contracts.DPP_NAME,dpp_WETH_USDT);
console.log("dpp_DODO_USDT:",dpp_DODO_USDT);
console.log("dpp_WETH_USDT:",dpp_WETH_USDT);
});
@@ -92,7 +97,7 @@ describe("DODOProxyV2.0", () => {
var quoteToken = ctx.USDT.options.address;
var baseAmount = decimalStr("10000");
var quoteAmount = mweiStr("10000");
await ctx.DODOProxy.methods.createDODOPrivatePool(
await logGas(await ctx.DODOProxy.methods.createDODOPrivatePool(
baseToken,
quoteToken,
baseAmount,
@@ -102,19 +107,19 @@ describe("DODOProxyV2.0", () => {
config.i,
config.k,
Math.floor(new Date().getTime()/1000 + 60 * 10)
).send(ctx.sendParam(project));
),ctx.sendParam(project),"createDPP");
var addrs = await ctx.DPPFactory.methods.getPrivatePool(baseToken,quoteToken).call();
var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[0]).call();
var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[1]).call();
assert.equal(
dppInfo[0],
project
);
assert.equal(
await ctx.DODO.methods.balanceOf(addrs[0]).call(),
await ctx.DODO.methods.balanceOf(addrs[1]).call(),
baseAmount
);
assert.equal(
await ctx.USDT.methods.balanceOf(addrs[0]).call(),
await ctx.USDT.methods.balanceOf(addrs[1]).call(),
quoteAmount
);
});
@@ -123,9 +128,9 @@ describe("DODOProxyV2.0", () => {
it("createDPP - ETH", async () => {
var baseToken = '0x000000000000000000000000000000000000000E';
var quoteToken = ctx.USDT.options.address;
var baseAmount = decimalStr("10");
var baseAmount = decimalStr("5");
var quoteAmount = mweiStr("10000");
await ctx.DODOProxy.methods.createDODOPrivatePool(
await logGas(await ctx.DODOProxy.methods.createDODOPrivatePool(
baseToken,
quoteToken,
baseAmount,
@@ -135,79 +140,231 @@ describe("DODOProxyV2.0", () => {
config.i,
config.k,
Math.floor(new Date().getTime()/1000 + 60 * 10)
).send(ctx.sendParam(project, "10"));
),ctx.sendParam(project, "5"),"createDPP - Wrap ETH");
var addrs = await ctx.DPPFactory.methods.getPrivatePool(ctx.WETH.options.address,quoteToken).call();
var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[0]).call();
var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[1]).call();
assert.equal(
dppInfo[0],
project
);
assert.equal(
await ctx.WETH.methods.balanceOf(addrs[0]).call(),
await ctx.WETH.methods.balanceOf(addrs[1]).call(),
baseAmount
);
assert.equal(
await ctx.USDT.methods.balanceOf(addrs[0]).call(),
await ctx.USDT.methods.balanceOf(addrs[1]).call(),
quoteAmount
);
});
it("resetDPP", async () => {
// await ctx.DODOProxy.methods.resetDODOPrivatePool(
// dpp_DODO_USDT,
// config.lpFeeRate,
// config.mtFeeRate,
// config.i,
// config.k,
// Math.floor(new Date().getTime()/1000 + 60 * 10)
// ).send(ctx.sendParam(project, "10"));
var beforeState = await DPP_DODO_USDT.methods.getPMMState().call();
assert.equal(beforeState.K,config.k);
assert.equal(beforeState.B0,decimalStr("100000"));
assert.equal(beforeState.Q0,mweiStr("30000"));
await logGas(await ctx.DODOProxy.methods.resetDODOPrivatePool(
dpp_DODO_USDT,
config.lpFeeRate,
config.mtFeeRate,
mweiStr("0.3"),
decimalStr("0.2"),
decimalStr("1000"),
mweiStr("1000"),
decimalStr("0"),
mweiStr("0"),
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(project),"resetDPP");
var afterState = await DPP_DODO_USDT.methods.getPMMState().call();
assert.equal(afterState.K,decimalStr("0.2"));
assert.equal(afterState.B0,decimalStr("101000"));
assert.equal(afterState.Q0,mweiStr("31000"));
});
/**
* trade
*/
it("trade-sellQuote-R=1", async () => {
//R变号与不变号
});
it("trade-sellQuote-R>1", async () => {
//R变号与不变号
it("resetDPP - OutETH", async () => {
var beforeState = await DPP_WETH_USDT.methods.getPMMState().call();
assert.equal(beforeState.K,config.k);
assert.equal(beforeState.B0,decimalStr("5"));
assert.equal(beforeState.Q0,mweiStr("30000"));
var b_ETH = await ctx.Web3.eth.getBalance(project);
var tx = await logGas(await ctx.DODOProxy.methods.resetDODOPrivatePoolETH(
dpp_WETH_USDT,
config.lpFeeRate,
config.mtFeeRate,
mweiStr("600"),
decimalStr("0.2"),
decimalStr("0"),
mweiStr("1000"),
decimalStr("1"),
mweiStr("0"),
3,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(project),"resetDPP-OutETH");
var afterState = await DPP_WETH_USDT.methods.getPMMState().call();
assert.equal(afterState.K,decimalStr("0.2"));
assert.equal(afterState.B0,decimalStr("4"));
assert.equal(afterState.Q0,mweiStr("31000"));
var a_ETH = await ctx.Web3.eth.getBalance(project);
console.log("b_ETH:",b_ETH);
console.log("a_ETH:",a_ETH);
assert.equal(new BigNumber(b_ETH).isGreaterThan(new BigNumber(a_ETH).minus(decimalStr("1"))),true);
});
it("trade-sellQuote-R<1", async () => {
//R变号与不变号
it("resetDPP - InETH", async () => {
var beforeState = await DPP_WETH_USDT.methods.getPMMState().call();
assert.equal(beforeState.K,config.k);
assert.equal(beforeState.B0,decimalStr("5"));
assert.equal(beforeState.Q0,mweiStr("30000"));
var b_ETH = await ctx.Web3.eth.getBalance(project);
var tx = await logGas(await ctx.DODOProxy.methods.resetDODOPrivatePoolETH(
dpp_WETH_USDT,
config.lpFeeRate,
config.mtFeeRate,
mweiStr("600"),
decimalStr("0.2"),
decimalStr("1"),
mweiStr("1000"),
decimalStr("0"),
mweiStr("0"),
1,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(project,"1"),"resetDPP-InETH");
var afterState = await DPP_WETH_USDT.methods.getPMMState().call();
assert.equal(afterState.K,decimalStr("0.2"));
assert.equal(afterState.B0,decimalStr("6"));
assert.equal(afterState.Q0,mweiStr("31000"));
var a_ETH = await ctx.Web3.eth.getBalance(project);
console.log("b_ETH:",b_ETH);
console.log("a_ETH:",a_ETH);
assert.equal(new BigNumber(b_ETH).isGreaterThan(new BigNumber(a_ETH).plus(decimalStr("1"))),true);
});
it("swap - one hop", async () => {
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("1000"));
var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var b_USDT = await ctx.USDT.methods.balanceOf(trader).call();
var dodoPairs = [
dpp_DODO_USDT
]
var directions = [
0
]
var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken(
trader,
ctx.DODO.options.address,
ctx.USDT.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(trader),"swap - one hop");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var a_USDT = await ctx.USDT.methods.balanceOf(trader).call();
console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
console.log("b_USDT:" + b_USDT + " a_USDT:" + a_USDT);
assert.equal(a_DOOD,decimalStr("500"));
assert.equal(a_USDT,"149474924");
});
it("trade-sellBase-R=1", async () => {
//R变号与不变号
it("swap - two hop", async () => {
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("1000"));
var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var b_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var dodoPairs = [
dpp_DODO_USDT,
dpp_WETH_USDT
]
var directions = [
0,
1
]
var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken(
trader,
ctx.DODO.options.address,
ctx.WETH.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(trader),"swap - two hop");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call();
console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH);
assert.equal(a_DOOD,decimalStr("500"));
assert.equal(a_WETH,"247088894507188480");
});
it("swap - two hop - inETH", async () => {
var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var b_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var b_ETH = await ctx.Web3.eth.getBalance(trader);
var dodoPairs = [
dpp_WETH_USDT,
dpp_DODO_USDT
]
var directions = [
0,
1
]
var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapETHToToken(
trader,
ctx.DODO.options.address,
decimalStr("1"),
1,
dodoPairs,
directions,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(trader,"1"),"swap - two hop - inETH");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var a_ETH = await ctx.Web3.eth.getBalance(trader);
console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH);
console.log("b_ETH:" + b_ETH + " a_ETH:" + a_ETH);
assert.equal(a_DOOD,"1979965731049456633086");
});
it("trade-sellBase-R>1", async () => {
//R变号与不变号
it("swap - two hop - outETH", async () => {
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("100000"));
var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var b_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var b_ETH = await ctx.Web3.eth.getBalance(trader);
var dodoPairs = [
dpp_DODO_USDT,
dpp_WETH_USDT
]
var directions = [
0,
1
]
var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToETH(
trader,
ctx.DODO.options.address,
decimalStr("10000"),
1,
dodoPairs,
directions,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(trader),"swap - two hop - outETH");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var a_ETH = await ctx.Web3.eth.getBalance(trader);
console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH);
console.log("b_ETH:" + b_ETH + " a_ETH:" + a_ETH);
assert.equal(a_DOOD,decimalStr("90000"));
assert.equal(
tx.events['OrderHistory'].returnValues['returnAmount'],
"3760778358599649282"
)
});
it("trade-sellBase-R<1", async () => {
//R变号与不变号
});
it("retrieve", async () => {
//eth允许
//控制无法提取base && quote
});
/**
* 直接底层dpp操作测试
*/
});
});

186
test/Proxy/proxy.dvm.test.ts
View File

@@ -6,11 +6,13 @@
*/
// import * as assert from 'assert';
import { decimalStr, mweiStr} from '../utils/Converter';
import BigNumber from "bignumber.js";
import { decimalStr, mweiStr } from '../utils/Converter';
import { logGas } from '../utils/Log';
import { ProxyContext, getProxyContext } from '../utils/ProxyContext';
import { assert } from 'chai';
import * as contracts from '../utils/Contracts';
import { Contract } from 'web3-eth-contract';
let lp: string;
let project: string;
@@ -27,46 +29,59 @@ async function init(ctx: ProxyContext): Promise<void> {
lp = ctx.SpareAccounts[0];
project = ctx.SpareAccounts[1];
trader = ctx.SpareAccounts[2];
await ctx.approveProxy(lp);
await ctx.approveProxy(project);
await ctx.approveProxy(trader);
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("100000"));
await ctx.mintTestToken(project, ctx.DODO, decimalStr("100000"));
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("100000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000000"));
await ctx.mintTestToken(project, ctx.DODO, decimalStr("1000000"));
await ctx.mintTestToken(lp, ctx.USDT, mweiStr("100000"));
await ctx.mintTestToken(project, ctx.USDT, mweiStr("100000"));
await ctx.mintTestToken(lp, ctx.USDT, mweiStr("1000000"));
await ctx.mintTestToken(project, ctx.USDT, mweiStr("1000000"));
// await ctx.WETH.methods.deposit().send(ctx.sendParam(lp, '80'));
// await ctx.WETH.methods.deposit().send(ctx.sendParam(project, '80'));
await ctx.approveProxy(lp);
await ctx.approveProxy(project);
await ctx.approveProxy(trader);
}
async function initCreateDVM(ctx: ProxyContext, token0: any, token1:any, token0Amount: string, token1Amount: string): Promise<void> {
async function initCreateDVM(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string,i:string): Promise<string> {
let PROXY = ctx.DODOProxy;
await PROXY.methods.createDODOVendingMachine(
token0.options.address,
token1.options.address,
project,
token0,
token1,
token0Amount,
token1Amount,
config.lpFeeRate,
config.mtFeeRate,
config.i,
config.k,
Math.floor(new Date().getTime()/1000 + 60 * 10);
).send(ctx.sendParam(project));
Math.floor(new Date().getTime()/1000 + 60 * 10)
).send(ctx.sendParam(project,ethValue));
if(token0 == '0x000000000000000000000000000000000000000E') token0 = ctx.WETH.options.address;
if(token1 == '0x000000000000000000000000000000000000000E') token1 = ctx.WETH.options.address;
var addr = await ctx.DVMFactory.methods._REGISTRY_(token0,token1,0).call();
return addr;
}
describe("DODOProxyV2.0", () => {
let snapshotId: string;
let ctx: ProxyContext;
let dvm_DODO_USDT: string;
let dvm_WETH_USDT: string;
let DVM_DODO_USDT: Contract;
let DVM_WETH_USDT: Contract;
before(async () => {
ctx = await getProxyContext();
await init(ctx);
// await initCreateDVM(ctx,ctx.DODO,ctx.USDT,decimalStr("10000"),decimalStr("10000"));
// await initCreateDVM(ctx,ctx.WETH,ctx.USDT,decimalStr("50"),decimalStr("10000"));
dvm_DODO_USDT = await initCreateDVM(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("100000"),mweiStr("30000"), "0",mweiStr("0.3"));
DVM_DODO_USDT = contracts.getContractWithAddress(contracts.DVM_NAME,dvm_DODO_USDT);
dvm_WETH_USDT = await initCreateDVM(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("5"),mweiStr("30000"),"5",mweiStr("600"));
DVM_WETH_USDT = contracts.getContractWithAddress(contracts.DVM_NAME,dvm_WETH_USDT);
console.log("dvm_DODO_USDT:",dvm_DODO_USDT);
console.log("dvm_WETH_USDT:",dvm_WETH_USDT);
});
beforeEach(async () => {
@@ -78,44 +93,123 @@ describe("DODOProxyV2.0", () => {
});
describe("DODOProxy", () => {
/**
* 1. 创建空池子
* 2. 创建ERC20 Token DVM
* 3. 创建ETH && ERC20 Token
*/
it("createDVM", async () => {
});
/**
* 1. 添加ERC20 Amount
* 2. 添加ERC20 + ETH
*/
it("addLiquidityToDVM", async () => {
var baseToken = ctx.DODO.options.address;
var quoteToken = ctx.USDT.options.address;
var baseAmount = decimalStr("10000");
var quoteAmount = mweiStr("10000");
await logGas(await ctx.DODOProxy.methods.createDODOVendingMachine(
project,
baseToken,
quoteToken,
baseAmount,
quoteAmount,
config.lpFeeRate,
config.mtFeeRate,
config.i,
config.k,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(project),"createDVM");
var addrs = await ctx.DVMFactory.methods.getVendingMachine(baseToken,quoteToken).call();
var dvmInfo = await ctx.DVMFactory.methods._DVM_INFO_(addrs[1]).call();
assert.equal(
dvmInfo[0],
project
);
assert.equal(
await ctx.DODO.methods.balanceOf(addrs[1]).call(),
baseAmount
);
assert.equal(
await ctx.USDT.methods.balanceOf(addrs[1]).call(),
quoteAmount
);
});
/**
* 1. 移除ERC20 Amount
* 2. 移除ERC20 + ETH
*/
it("removeLiquidityToDVM", async () => {
it("createDVM - ETH", async () => {
var baseToken = '0x000000000000000000000000000000000000000E';
var quoteToken = ctx.USDT.options.address;
var baseAmount = decimalStr("5");
var quoteAmount = mweiStr("10000");
await logGas(await ctx.DODOProxy.methods.createDODOVendingMachine(
project,
baseToken,
quoteToken,
baseAmount,
quoteAmount,
config.lpFeeRate,
config.mtFeeRate,
config.i,
config.k,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(project, '5'),"createDVM - Wrap ETH");
var addrs = await ctx.DVMFactory.methods.getVendingMachine(ctx.WETH.options.address,quoteToken).call();
var dvmInfo = await ctx.DVMFactory.methods._DVM_INFO_(addrs[1]).call();
assert.equal(
dvmInfo[0],
project
);
assert.equal(
await ctx.WETH.methods.balanceOf(addrs[1]).call(),
baseAmount
);
assert.equal(
await ctx.USDT.methods.balanceOf(addrs[1]).call(),
quoteAmount
);
});
/**
*
*/
it("dodoSwap", async () => {
it("addLiquidity", async () => {
var b_baseReserve = await DVM_DODO_USDT.methods._BASE_RESERVE_().call();
var b_quoteReserve = await DVM_DODO_USDT.methods._QUOTE_RESERVE_().call();
var b_dlp = await DVM_DODO_USDT.methods.balanceOf(lp).call();
assert.equal(b_baseReserve,decimalStr("100000"));
assert.equal(b_quoteReserve,mweiStr("30000"));
assert.equal(b_dlp,decimalStr("0"));
await logGas(await ctx.DODOProxy.methods.addDVMLiquidity(
dvm_DODO_USDT,
lp,
decimalStr("1000"),
mweiStr("300"),
decimalStr("0"),
mweiStr("0"),
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(lp),"addLiquidity");
var a_baseReserve = await DVM_DODO_USDT.methods._BASE_RESERVE_().call();
var a_quoteReserve = await DVM_DODO_USDT.methods._QUOTE_RESERVE_().call();
var a_dlp = await DVM_DODO_USDT.methods.balanceOf(lp).call();
assert.equal(a_baseReserve,decimalStr("101000"));
assert.equal(a_quoteReserve,mweiStr("30300"));
assert.equal(a_dlp,"1000000000000000000000");
});
/**
* 直接底层dvm操作测试
*/
it("addLiquidity - ETH", async () => {
var b_baseReserve = await DVM_WETH_USDT.methods._BASE_RESERVE_().call();
var b_quoteReserve = await DVM_WETH_USDT.methods._QUOTE_RESERVE_().call();
var b_dlp = await DVM_WETH_USDT.methods.balanceOf(lp).call();
assert.equal(b_baseReserve,decimalStr("5"));
assert.equal(b_quoteReserve,mweiStr("30000"));
assert.equal(b_dlp,decimalStr("0"));
await logGas(await ctx.DODOProxy.methods.addDVMLiquidityETH(
dvm_WETH_USDT,
lp,
decimalStr("1"),
mweiStr("6000"),
decimalStr("0"),
mweiStr("0"),
1,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(lp,'1'),"addLiquidity - ETH");
var a_baseReserve = await DVM_WETH_USDT.methods._BASE_RESERVE_().call();
var a_quoteReserve = await DVM_WETH_USDT.methods._QUOTE_RESERVE_().call();
var a_dlp = await DVM_WETH_USDT.methods.balanceOf(lp).call();
assert.equal(a_baseReserve,decimalStr("6"));
assert.equal(a_quoteReserve,mweiStr("36000"));
assert.equal(a_dlp,"1000000000000000000");
});
});
});

7
test/utils/ProxyContext.ts
View File

@@ -10,7 +10,7 @@ import Web3 from 'web3';
import { Contract } from 'web3-eth-contract';
import * as contracts from './Contracts';
import { decimalStr, MAX_UINT256 } from './Converter';
import { decimalStr, mweiStr, MAX_UINT256 } from './Converter';
import { EVM, getDefaultWeb3 } from './EVM';
import * as log from './Log';
@@ -63,7 +63,7 @@ export class ProxyContext {
var permissionManagerTemplate = await contracts.newContract(contracts.PERMISSION_MANAGER_NAME)
var vauleSource = await contracts.newContract(contracts.EXTERNAL_VALUE_NAME)
var defaultGasSource = await contracts.newContract(contracts.EXTERNAL_VALUE_NAME)
await defaultGasSource.methods.init(this.Deployer,decimalStr("1000000"));
await defaultGasSource.methods.init(this.Deployer,MAX_UINT256).send(this.sendParam(this.Deployer));
this.DVMFactory = await contracts.newContract(contracts.DVM_FACTORY_NAME,
[
@@ -125,7 +125,8 @@ export class ProxyContext {
return {
from: sender,
gas: process.env["COVERAGE"] ? 10000000000 : 7000000,
gasPrice: process.env.GAS_PRICE,
// gasPrice: process.env.GAS_PRICE,
gasPrice: mweiStr("1000"),
value: decimalStr(value),
};
}