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-18 17:58:36 +08:00
parent d78de94b44 bd21a14b53
commit b9c458a6f0
17 changed files with 954 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -4,6 +4,7 @@
.idea
build/
build-v1/
dist/
node_modules/
coverage/

57
contracts/DODOVendorMachine/impl/DVMStorage.sol
View File

@@ -14,16 +14,26 @@ import {SafeMath} from "../../lib/SafeMath.sol";
import {DODOMath} from "../../lib/DODOMath.sol";
import {DecimalMath} from "../../lib/DecimalMath.sol";
import {IPermissionManager} from "../../lib/PermissionManager.sol";
<<<<<<< HEAD
import {IExternalValue} from "../../lib/ExternalValue.sol";
import {IFeeRateModel} from "../../intf/IFeeRateModel.sol";
import {IERC20} from "../../intf/IERC20.sol";
=======
import {IGasPriceSource} from "../../lib/GasPriceSource.sol";
import {IFeeRateModel} from "../../intf/IFeeRateModel.sol";
import {IDVMVault} from "../intf/IDVMVault.sol";
>>>>>>> bd21a14b5398693ec5ad47e52fed6a8ea1193e9b
contract DVMStorage is InitializableOwnable, ReentrancyGuard {
using SafeMath for uint256;
// ============ Variables for Control ============
<<<<<<< HEAD
IExternalValue public _GAS_PRICE_LIMIT_;
=======
IGasPriceSource public _GAS_PRICE_LIMIT_;
>>>>>>> bd21a14b5398693ec5ad47e52fed6a8ea1193e9b
// ============ Advanced Controls ============
@@ -36,6 +46,7 @@ contract DVMStorage is InitializableOwnable, ReentrancyGuard {
address public _MAINTAINER_; // collect maintainer fee
<<<<<<< HEAD
IERC20 public _BASE_TOKEN_;
IERC20 public _QUOTE_TOKEN_;
@@ -51,6 +62,10 @@ contract DVMStorage is InitializableOwnable, ReentrancyGuard {
uint256 public totalSupply;
mapping(address => uint256) internal _SHARES_;
mapping(address => mapping(address => uint256)) internal _ALLOWED_;
=======
address public _BASE_TOKEN_;
address public _QUOTE_TOKEN_;
>>>>>>> bd21a14b5398693ec5ad47e52fed6a8ea1193e9b
// ============ Variables for Pricing ============
@@ -59,6 +74,44 @@ contract DVMStorage is InitializableOwnable, ReentrancyGuard {
uint256 public _K_;
uint256 public _I_;
<<<<<<< HEAD
=======
IDVMVault public _VAULT_;
// ============ Modifiers ============
modifier isBuyAllow(address trader) {
require(!_BUYING_CLOSE_ && _TRADE_PERMISSION_.isAllowed(trader), "TRADER_BUY_NOT_ALLOWED");
_;
}
modifier isSellAllow(address trader) {
require(
!_SELLING_CLOSE_ && _TRADE_PERMISSION_.isAllowed(trader),
"TRADER_SELL_NOT_ALLOWED"
);
_;
}
modifier limitGasPrice() {
require(tx.gasprice <= _GAS_PRICE_LIMIT_.getGasPrice(), "GAS_PRICE_EXCEED");
_;
}
// ============ Helper Functions ============
function calculateBase0(uint256 baseAmount, uint256 quoteAmount) public view returns (uint256) {
uint256 fairAmount = DecimalMath.divFloor(quoteAmount, _I_);
return DODOMath._SolveQuadraticFunctionForTarget(baseAmount, _K_, fairAmount);
}
function getBase0() public view returns (uint256) {
(uint256 baseAmount, uint256 quoteAmount) = _VAULT_.getVaultReserve();
uint256 fairAmount = DecimalMath.divFloor(quoteAmount, _I_);
return DODOMath._SolveQuadraticFunctionForTarget(baseAmount, _K_, fairAmount);
}
>>>>>>> bd21a14b5398693ec5ad47e52fed6a8ea1193e9b
// ============ Setting Functions ============
function setLpFeeRateModel(address newLpFeeRateModel) external onlyOwner {
@@ -78,7 +131,11 @@ contract DVMStorage is InitializableOwnable, ReentrancyGuard {
}
function setGasPriceSource(address newGasPriceLimitSource) external onlyOwner {
<<<<<<< HEAD
_GAS_PRICE_LIMIT_ = IExternalValue(newGasPriceLimitSource);
=======
_GAS_PRICE_LIMIT_ = IGasPriceSource(newGasPriceLimitSource);
>>>>>>> bd21a14b5398693ec5ad47e52fed6a8ea1193e9b
}
function setBuy(bool open) external onlyOwner {

71
contracts/DODOVendorMachine/intf/IDVMVault.sol Normal file
View File

@@ -0,0 +1,71 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface IDVMVault {
function init(
address owner,
address _baseToken,
address _quoteToken
) external;
function _BASE_TOKEN_() external returns (address);
function _QUOTE_TOKEN_() external returns (address);
function _BASE_RESERVE_() external returns (uint256);
function _QUOTE_RESERVE_() external returns (uint256);
function symbol() external returns (string memory);
function decimals() external returns (uint256);
function name() external returns (string memory);
function totalSupply() external returns (uint256);
function getVaultBalance() external view returns (uint256 baseBalance, uint256 quoteBalance);
function getVaultReserve() external view returns (uint256 baseReserve, uint256 quoteReserve);
function getBaseBalance() external view returns (uint256 baseBalance);
function getQuoteBalance() external view returns (uint256 quoteBalance);
function getBaseInput() external view returns (uint256 input);
function getQuoteInput() external view returns (uint256 input);
function sync() external;
function transferBaseOut(address to, uint256 amount) external;
function transferQuoteOut(address to, uint256 amount) external;
function transfer(address to, uint256 amount) external returns (bool);
function balanceOf(address owner) external view returns (uint256 balance);
function shareRatioOf(address owner) external view returns (uint256 shareRatio);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function mint(address user, uint256 value) external;
function burn(address user, uint256 value) external;
}

134
contracts/DODOZoo.sol Normal file
View File

@@ -0,0 +1,134 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {Ownable} from "./lib/Ownable.sol";
import {IDODO} from "./intf/IDODO.sol";
import {ICloneFactory} from "./helper/CloneFactory.sol";
/**
* @title DODOZoo
* @author DODO Breeder
*
* @notice Register of All DODO
*/
contract DODOZoo is Ownable {
address public _DODO_LOGIC_;
address public _CLONE_FACTORY_;
address public _DEFAULT_SUPERVISOR_;
mapping(address => mapping(address => address)) internal _DODO_REGISTER_;
address[] public _DODOs;
// ============ Events ============
event DODOBirth(address newBorn, address baseToken, address quoteToken);
// ============ Constructor Function ============
constructor(
address _dodoLogic,
address _cloneFactory,
address _defaultSupervisor
) public {
_DODO_LOGIC_ = _dodoLogic;
_CLONE_FACTORY_ = _cloneFactory;
_DEFAULT_SUPERVISOR_ = _defaultSupervisor;
}
// ============ Admin Function ============
function setDODOLogic(address _dodoLogic) external onlyOwner {
_DODO_LOGIC_ = _dodoLogic;
}
function setCloneFactory(address _cloneFactory) external onlyOwner {
_CLONE_FACTORY_ = _cloneFactory;
}
function setDefaultSupervisor(address _defaultSupervisor) external onlyOwner {
_DEFAULT_SUPERVISOR_ = _defaultSupervisor;
}
function removeDODO(address dodo) external onlyOwner {
address baseToken = IDODO(dodo)._BASE_TOKEN_();
address quoteToken = IDODO(dodo)._QUOTE_TOKEN_();
require(isDODORegistered(baseToken, quoteToken), "DODO_NOT_REGISTERED");
_DODO_REGISTER_[baseToken][quoteToken] = address(0);
for (uint256 i = 0; i <= _DODOs.length - 1; i++) {
if (_DODOs[i] == dodo) {
_DODOs[i] = _DODOs[_DODOs.length - 1];
_DODOs.pop();
break;
}
}
}
function addDODO(address dodo) public onlyOwner {
address baseToken = IDODO(dodo)._BASE_TOKEN_();
address quoteToken = IDODO(dodo)._QUOTE_TOKEN_();
require(!isDODORegistered(baseToken, quoteToken), "DODO_REGISTERED");
_DODO_REGISTER_[baseToken][quoteToken] = dodo;
_DODOs.push(dodo);
}
// ============ Breed DODO Function ============
function breedDODO(
address maintainer,
address baseToken,
address quoteToken,
address oracle,
uint256 lpFeeRate,
uint256 mtFeeRate,
uint256 k,
uint256 gasPriceLimit
) external onlyOwner returns (address newBornDODO) {
require(!isDODORegistered(baseToken, quoteToken), "DODO_REGISTERED");
newBornDODO = ICloneFactory(_CLONE_FACTORY_).clone(_DODO_LOGIC_);
IDODO(newBornDODO).init(
_OWNER_,
_DEFAULT_SUPERVISOR_,
maintainer,
baseToken,
quoteToken,
oracle,
lpFeeRate,
mtFeeRate,
k,
gasPriceLimit
);
addDODO(newBornDODO);
emit DODOBirth(newBornDODO, baseToken, quoteToken);
return newBornDODO;
}
// ============ View Functions ============
function isDODORegistered(address baseToken, address quoteToken) public view returns (bool) {
if (
_DODO_REGISTER_[baseToken][quoteToken] == address(0) &&
_DODO_REGISTER_[quoteToken][baseToken] == address(0)
) {
return false;
} else {
return true;
}
}
function getDODO(address baseToken, address quoteToken) external view returns (address) {
return _DODO_REGISTER_[baseToken][quoteToken];
}
function getDODOs() external view returns (address[] memory) {
return _DODOs;
}
}

44
contracts/SmartRoute/SmartSwap.sol
View File

@@ -15,7 +15,7 @@ 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";
contract SmartSwap is Ownable {
using SafeMath for uint256;
@@ -25,6 +25,7 @@ contract SmartSwap is Ownable {
IERC20 constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
ISmartApprove public smartApprove;
IDODOSellHelper public dodoSellHelper;
address payable public _WETH_;
event OrderHistory(
IERC20 indexed fromToken,
@@ -36,11 +37,20 @@ contract SmartSwap is Ownable {
event ExternalRecord(address indexed to, address indexed sender);
constructor(address _smartApprove,address _dodoSellHelper) public {
constructor(
address _smartApprove,
address _dodoSellHelper,
address payable _weth
) public {
smartApprove = ISmartApprove(_smartApprove);
dodoSellHelper = IDODOSellHelper(_dodoSellHelper);
_WETH_ = _weth;
}
fallback() external payable {}
receive() external payable {}
function dodoSwap(
IERC20 fromToken,
IERC20 toToken,
@@ -54,25 +64,37 @@ contract SmartSwap is Ownable {
if (fromToken != ETH_ADDRESS) {
smartApprove.claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
} else {
require(msg.value == fromTokenAmount, "ETH_AMOUNT_NOT_MATCH");
IWETH(_WETH_).deposit{value: fromTokenAmount}();
}
for (uint256 i = 0; i < dodoPairs.length; i++) {
uint256 curDirection = directions[i];
address curDodoPair = dodoPairs[i];
if(curDirection == 0){
if (curDirection == 0) {
address curDodoBase = IDODO(curDodoPair)._BASE_TOKEN_();
uint256 curAmountIn = IERC20(curDodoBase).balanceOf(address(this));
IERC20(curDodoBase).approve(curDodoPair,curAmountIn);
IERC20(curDodoBase).universalApprove(curDodoPair, curAmountIn);
IDODO(curDodoPair).sellBaseToken(curAmountIn, 0, "");
}else {
} else {
address curDodoQuote = IDODO(curDodoPair)._QUOTE_TOKEN_();
uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this));
IERC20(curDodoQuote).approve(curDodoPair,curAmountIn);
uint256 canBuyBaseAmount = dodoSellHelper.querySellQuoteToken(curDodoPair,curAmountIn);
IERC20(curDodoQuote).universalApprove(curDodoPair, curAmountIn);
uint256 canBuyBaseAmount = dodoSellHelper.querySellQuoteToken(
curDodoPair,
curAmountIn
);
IDODO(curDodoPair).buyBaseToken(canBuyBaseAmount, curAmountIn, "");
}
}
fromToken.universalTransfer(msg.sender, fromToken.universalBalanceOf(address(this)));
if (toToken == ETH_ADDRESS) {
uint256 wethAmount = IWETH(_WETH_).balanceOf(address(this));
IWETH(_WETH_).withdraw(wethAmount);
}
returnAmount = toToken.universalBalanceOf(address(this));
require(returnAmount >= minReturnAmount, "Return amount is not enough");
@@ -80,7 +102,6 @@ contract SmartSwap is Ownable {
emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount);
}
function externalSwap(
IERC20 fromToken,
IERC20 toToken,
@@ -91,15 +112,16 @@ contract SmartSwap is Ownable {
uint256 minReturnAmount,
bytes memory callDataConcat
) public payable returns (uint256 returnAmount) {
require(minReturnAmount > 0, "Min return should be bigger then 0.");
if (fromToken != ETH_ADDRESS) {
smartApprove.claimTokens(fromToken, msg.sender, address(this), fromTokenAmount);
fromToken.approve(approveTarget, fromTokenAmount);
fromToken.universalApprove(approveTarget, fromTokenAmount);
}
(bool success, ) = to.call{value: msg.value, gas: gasSwap}(callDataConcat);
(bool success, ) = to.call{value: fromToken == ETH_ADDRESS ? msg.value : 0, gas: gasSwap}(
callDataConcat
);
require(success, "Contract Swap execution Failed");

33
contracts/helper/CloneFactory.sol Normal file
View File

@@ -0,0 +1,33 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
interface ICloneFactory {
function clone(address prototype) external returns (address proxy);
}
// introduction of proxy mode design: https://docs.openzeppelin.com/upgrades/2.8/
// minimum implementation of transparent proxy: https://eips.ethereum.org/EIPS/eip-1167
contract CloneFactory is ICloneFactory {
function clone(address prototype) external override returns (address proxy) {
bytes20 targetBytes = bytes20(prototype);
assembly {
let clone := mload(0x40)
mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(clone, 0x14), targetBytes)
mstore(
add(clone, 0x28),
0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
)
proxy := create(0, clone, 0x37)
}
return proxy;
}
}

25
contracts/helper/NativeOracle.sol Normal file
View File

@@ -0,0 +1,25 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {Ownable} from "../lib/Ownable.sol";
// Oracle only for test
contract NaiveOracle is Ownable {
uint256 public tokenPrice;
function setPrice(uint256 newPrice) external onlyOwner {
tokenPrice = newPrice;
}
function getPrice() external view returns (uint256) {
return tokenPrice;
}
}

74
contracts/helper/TestERC20.sol Normal file
View File

@@ -0,0 +1,74 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
import {SafeMath} from "../lib/SafeMath.sol";
contract TestERC20 {
using SafeMath for uint256;
string public name;
uint8 public decimals;
string public symbol;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) internal allowed;
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(string memory _name, uint8 _decimals,string memory _symbol) public {
name = _name;
decimals = _decimals;
symbol = _symbol;
}
function transfer(address to, uint256 amount) public returns (bool) {
require(to != address(0), "TO_ADDRESS_IS_EMPTY");
require(amount <= balances[msg.sender], "BALANCE_NOT_ENOUGH");
balances[msg.sender] = balances[msg.sender].sub(amount);
balances[to] = balances[to].add(amount);
emit Transfer(msg.sender, to, amount);
return true;
}
function balanceOf(address owner) public view returns (uint256 balance) {
return balances[owner];
}
function transferFrom(
address from,
address to,
uint256 amount
) public returns (bool) {
require(to != address(0), "TO_ADDRESS_IS_EMPTY");
require(amount <= balances[from], "BALANCE_NOT_ENOUGH");
require(amount <= allowed[from][msg.sender], "ALLOWANCE_NOT_ENOUGH");
balances[from] = balances[from].sub(amount);
balances[to] = balances[to].add(amount);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(amount);
emit Transfer(from, to, amount);
return true;
}
function approve(address spender, uint256 amount) public returns (bool) {
allowed[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return allowed[owner][spender];
}
function mint(address account, uint256 amount) external {
balances[account] = balances[account].add(amount);
}
}

77
contracts/helper/TestWETH.sol Normal file
View File

@@ -0,0 +1,77 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
contract WETH9 {
string public name = "Wrapped Ether";
string public symbol = "WETH";
uint8 public decimals = 18;
event Approval(address indexed src, address indexed guy, uint256 wad);
event Transfer(address indexed src, address indexed dst, uint256 wad);
event Deposit(address indexed dst, uint256 wad);
event Withdrawal(address indexed src, uint256 wad);
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
fallback() external payable {
deposit();
}
receive() external payable {
deposit();
}
function deposit() public payable {
balanceOf[msg.sender] += msg.value;
emit Deposit(msg.sender, msg.value);
}
function withdraw(uint256 wad) public {
require(balanceOf[msg.sender] >= wad);
balanceOf[msg.sender] -= wad;
msg.sender.transfer(wad);
emit Withdrawal(msg.sender, wad);
}
function totalSupply() public view returns (uint256) {
return address(this).balance;
}
function approve(address guy, uint256 wad) public returns (bool) {
allowance[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
function transfer(address dst, uint256 wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(
address src,
address dst,
uint256 wad
) public returns (bool) {
require(balanceOf[src] >= wad);
if (src != msg.sender && allowance[src][msg.sender] != uint256(-1)) {
require(allowance[src][msg.sender] >= wad);
allowance[src][msg.sender] -= wad;
}
balanceOf[src] -= wad;
balanceOf[dst] += wad;
Transfer(src, dst, wad);
return true;
}
}

29
contracts/lib/GasPriceSource.sol Normal file
View File

@@ -0,0 +1,29 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;
import {Ownable} from "./Ownable.sol";
interface IGasPriceSource {
function setGasPrice(uint256) external;
function getGasPrice() external view returns (uint256);
}
contract GasPriceSource is IGasPriceSource, Ownable {
uint256 public _GAS_PRICE_;
function setGasPrice(uint256 gasPrice) external override {
_GAS_PRICE_ = gasPrice;
}
function getGasPrice() external override view returns (uint256) {
return _GAS_PRICE_;
}
}

42
contracts/lib/UniversalERC20.sol
View File

@@ -12,18 +12,26 @@ import {IERC20} from "../intf/IERC20.sol";
import {SafeERC20} from "./SafeERC20.sol";
library UniversalERC20 {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private constant ZERO_ADDRESS = IERC20(0x0000000000000000000000000000000000000000);
IERC20 private constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
function universalTransfer(IERC20 token, address to, uint256 amount) internal {
function universalTransfer(
IERC20 token,
address to,
uint256 amount
) internal {
universalTransfer(token, to, amount, false);
}
function universalTransfer(IERC20 token, address to, uint256 amount, bool mayFail) internal returns(bool) {
function universalTransfer(
IERC20 token,
address to,
uint256 amount,
bool mayFail
) internal returns (bool) {
if (amount == 0) {
return true;
}
@@ -41,13 +49,33 @@ library UniversalERC20 {
}
}
function universalApprove(IERC20 token, address to, uint256 amount) internal {
function universalApprove(
IERC20 token,
address to,
uint256 amount
) internal {
if (token != ZERO_ADDRESS && token != ETH_ADDRESS) {
token.safeApprove(to, amount);
if (amount == 0) {
token.safeApprove(to, 0);
return;
}
uint256 allowance = token.allowance(address(this), to);
if (allowance < amount) {
if (allowance > 0) {
token.safeApprove(to, 0);
}
token.safeApprove(to, amount);
}
}
}
function universalTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {
function universalTransferFrom(
IERC20 token,
address from,
address to,
uint256 amount
) internal {
if (amount == 0) {
return;
}
@@ -72,4 +100,4 @@ library UniversalERC20 {
return token.balanceOf(who);
}
}
}
}

8
deploy-detail.txt Normal file
View File

@@ -0,0 +1,8 @@
====================================================
network type: live
Deploy time: 2020/11/16 上午10:26:34
Deploy type: Smart Route
SmartApprove Address: 0xe380Ad3181A69BF92133D2feb609867c4adC61eA
DODOSellHelper Address: 0x533da777aedce766ceae696bf90f8541a4ba80eb
SmartSwap Address: 0xcD8392A57ED2fBD6440037E52F176c26dEFc0ba4
SmartApprovce setSmartSwap tx: 0x35eccc657ee0d473b6e58324123d3da568ce12389fedff914a8dada563b35b3a

4
migrations/1_initial_migration.js
View File

@@ -1,5 +1,5 @@
const Migrations = artifacts.require("Migrations");
module.exports = function(deployer) {
deployer.deploy(Migrations);
module.exports = function (deployer) {
// deployer.deploy(Migrations);
};

158
migrations/2_deploy.js
View File

@@ -1 +1,157 @@
module.exports = async (deployer, network) => {};
const fs = require("fs");
const file = fs.createWriteStream("../deploy-detail.txt");
let logger = new console.Console(file, file);
const SmartApprove = artifacts.require("SmartApprove");
const SmartSwap = artifacts.require("SmartSwap");
const DODOSellHelper = artifacts.require("DODOSellHelper");
const TestERC20 = artifacts.require("TestERC20");
const NaiveOracle = artifacts.require("NaiveOracle");
const DODOZoo = artifacts.require("DODOZoo");
const DEPLOY_ROUTE = true;
const DEPLOY_KOVAN_TOKEN = false;
module.exports = async (deployer, network, accounts) => {
let DODOSellHelperAddress = "";
let DODOZooAddress = "";
let WETHAddress = "";
let SmartApproveAddress = "";
if (network == "kovan") {
DODOSellHelperAddress = "0xbdEae617F2616b45DCB69B287D52940a76035Fe3";
DODOZooAddress = "0x92230e929a2226b29ed3441ae5524886347c60c8";
WETHAddress = "0x5eca15b12d959dfcf9c71c59f8b467eb8c6efd0b";
SmartApproveAddress = "0x5627b7DEb3055e1e899003FDca0716b32C382084";
} else if (network == "live") {
DODOSellHelperAddress = "0x533da777aedce766ceae696bf90f8541a4ba80eb";
DODOZooAddress = "0x3a97247df274a17c59a3bd12735ea3fcdfb49950";
WETHAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
SmartApproveAddress = "0xe380Ad3181A69BF92133D2feb609867c4adC61eA";
} else return;
logger.log("====================================================");
logger.log("network type: " + network);
logger.log("Deploy time: " + new Date().toLocaleString());
if (DEPLOY_ROUTE) {
logger.log("Deploy type: Smart Route");
if (SmartApprove == "") {
await deployer.deploy(SmartApprove);
SmartApproveAddress = SmartApprove.address;
}
if (DODOSellHelperAddress == "") {
await deployer.deploy(DODOSellHelper);
DODOSellHelperAddress = DODOSellHelper.address;
}
logger.log("SmartApprove Address: ", SmartApproveAddress);
logger.log("DODOSellHelper Address: ", DODOSellHelperAddress);
await deployer.deploy(
SmartSwap,
SmartApproveAddress,
DODOSellHelperAddress,
WETHAddress
);
logger.log("SmartSwap Address: ", SmartSwap.address);
const SmartApproveInstance = await SmartApprove.at(SmartApproveAddress);
var tx = await SmartApproveInstance.setSmartSwap(SmartSwap.address);
logger.log("SmartApprovce setSmartSwap tx: ", tx.tx);
}
if (DEPLOY_KOVAN_TOKEN) {
logger.log("Deploy type: Create Tokens and Trading Pairs");
await deployer.deploy(TestERC20, "USDC", 6, "USDC");
const USDCAddr = TestERC20.address;
logger.log("USDC Addr: ", USDCAddr);
await deployer.deploy(TestERC20, "USDT", 6, "USDT");
const USDTAddr = TestERC20.address;
logger.log("USDT Addr: ", USDTAddr);
await deployer.deploy(TestERC20, "DODO", 18, "DODO");
const DODOAddr = TestERC20.address;
logger.log("DODO Addr: ", DODOAddr);
await deployer.deploy(TestERC20, "WOO", 18, "WOO");
const WooAddr = TestERC20.address;
logger.log("WOO Addr: ", WooAddr);
const WETHAddr = WETHAddress;
logger.log("WETH Addr: ", WETHAddr);
let config = {
lpFeeRate: "2000000000000000",
mtFeeRate: "1000000000000000",
k: "100000000000000000",
gasPriceLimit: "100000000000",
};
const DODOZooInstance = await DODOZoo.at(DODOZooAddress);
//USDT-USDC
await deployer.deploy(NaiveOracle);
var USDT_USDC_Oracle = NaiveOracle.address;
await DODOZooInstance.breedDODO(
accounts[0],
USDTAddr,
USDCAddr,
USDT_USDC_Oracle,
config.lpFeeRate,
config.mtFeeRate,
config.k,
config.gasPriceLimit
);
const USDT_USDC_Addr = await DODOZooInstance.getDODO(USDTAddr, USDCAddr);
logger.log("USDT_USDC_Addr:", USDT_USDC_Addr);
// DODO-USDT
await deployer.deploy(NaiveOracle);
var DODO_USDT_Oracle = NaiveOracle.address;
await DODOZooInstance.breedDODO(
accounts[0],
DODOAddr,
USDTAddr,
DODO_USDT_Oracle,
config.lpFeeRate,
config.mtFeeRate,
config.k,
config.gasPriceLimit
);
const DODO_USDT_Addr = await DODOZooInstance.getDODO(DODOAddr, USDTAddr);
logger.log("DODO_USDT_Addr:", DODO_USDT_Addr);
// //WETH-USDC
await deployer.deploy(NaiveOracle);
var WETH_USDC_Oracle = NaiveOracle.address;
await DODOZooInstance.breedDODO(
accounts[0],
WETHAddr,
USDCAddr,
WETH_USDC_Oracle,
config.lpFeeRate,
config.mtFeeRate,
config.k,
config.gasPriceLimit
);
const WETH_USDC_Addr = await DODOZooInstance.getDODO(WETHAddr, USDCAddr);
logger.log("WETH_USDC_Addr:", WETH_USDC_Addr);
//WOO-USDT
await deployer.deploy(NaiveOracle);
var WOO_USDT_Oracle = NaiveOracle.address;
await DODOZooInstance.breedDODO(
accounts[0],
WooAddr,
USDTAddr,
WOO_USDT_Oracle,
config.lpFeeRate,
config.mtFeeRate,
config.k,
config.gasPriceLimit
);
const WOO_USDT_Addr = await DODOZooInstance.getDODO(WooAddr, USDTAddr);
logger.log("WOO_USDT_Addr:", WOO_USDT_Addr);
//TODO:ing enableBaseDeposit enableQuoteDeposit enableTrading
//TODO:ing apporve pair to token
//TODO:ing mint to lp
//TODO:ing deposit to Base && quote pool
}
};

267
test/Route/Route.test.ts
View File

@@ -8,7 +8,7 @@
import * as assert from 'assert';
import BigNumber from 'bignumber.js';
import { DODOContext, getDODOContext } from '../utils-v1/Context-route';
import { decimalStr,MAX_UINT256,fromWei,mweiStr} from '../utils-v1/Converter';
import { decimalStr, MAX_UINT256, fromWei, mweiStr } from '../utils-v1/Converter';
import { logGas } from '../utils-v1/Log';
import { DODOHelper } from '../utils-v1/dodoHelper';
@@ -16,99 +16,104 @@ let lp: string;
let trader: string;
async function initDODO_USDT(ctx: DODOContext): Promise<void> {
await ctx.setOraclePrice(ctx.DODO_USDT_ORACLE,mweiStr("0.1"));
await ctx.setOraclePrice(ctx.DODO_USDT_ORACLE, mweiStr("0.1"));
lp = ctx.spareAccounts[0];
trader = ctx.spareAccounts[1];
let DODO = ctx.DODO;
let USDT = ctx.USDT;
let DODO_USDT = ctx.DODO_USDT;
await ctx.approvePair(DODO,USDT,DODO_USDT.options.address,lp);
await ctx.approvePair(DODO,USDT,DODO_USDT.options.address,trader);
await ctx.approvePair(DODO, USDT, DODO_USDT.options.address, lp);
await ctx.approvePair(DODO, USDT, DODO_USDT.options.address, trader);
await ctx.mintToken(DODO,USDT, lp, decimalStr("10000"), mweiStr("1000"));
await ctx.mintToken(DODO,USDT,trader, decimalStr("100"), mweiStr("0"));
await ctx.mintToken(DODO, USDT, lp, decimalStr("10000000"), mweiStr("1000000"));
await ctx.mintToken(DODO, USDT, trader, decimalStr("1000"), mweiStr("0"));
await DODO_USDT.methods
.depositBaseTo(lp, decimalStr("10000"))
.depositBaseTo(lp, decimalStr("10000000"))
.send(ctx.sendParam(lp));
await DODO_USDT.methods
.depositQuoteTo(lp, mweiStr("1000"))
.depositQuoteTo(lp, mweiStr("1000000"))
.send(ctx.sendParam(lp));
}
async function initUSDT_USDC(ctx: DODOContext): Promise<void> {
await ctx.setOraclePrice(ctx.USDT_USDC_ORACLE,decimalStr("1"));
await ctx.setOraclePrice(ctx.USDT_USDC_ORACLE, decimalStr("1"));
lp = ctx.spareAccounts[0];
trader = ctx.spareAccounts[1];
let USDT = ctx.USDT;
let USDC = ctx.USDC;
let USDT_USDC = ctx.USDT_USDC;
await ctx.approvePair(USDT,USDC,USDT_USDC.options.address,lp);
await ctx.mintToken(USDT,USDC,lp, mweiStr("1000"), mweiStr("1000"));
await ctx.approvePair(USDT, USDC, USDT_USDC.options.address, lp);
await ctx.mintToken(USDT, USDC, lp, mweiStr("1000000"), mweiStr("1000000"));
await USDT_USDC.methods
.depositBaseTo(lp, mweiStr("1000"))
.depositBaseTo(lp, mweiStr("1000000"))
.send(ctx.sendParam(lp));
await USDT_USDC.methods
.depositQuoteTo(lp, mweiStr("1000"))
.depositQuoteTo(lp, mweiStr("1000000"))
.send(ctx.sendParam(lp));
}
async function initWETH_USDC(ctx: DODOContext): Promise<void> {
await ctx.setOraclePrice(ctx.WETH_USDC_ORACLE,mweiStr("450"));
await ctx.setOraclePrice(ctx.WETH_USDC_ORACLE, mweiStr("450"));
lp = ctx.spareAccounts[0];
trader = ctx.spareAccounts[1];
let WETH = ctx.WETH;
let USDC = ctx.USDC;
let WETH_USDC = ctx.WETH_USDC;
await ctx.approvePair(WETH,USDC,WETH_USDC.options.address,lp);
await ctx.mintToken(WETH,USDC,lp, decimalStr("1000"), mweiStr("450000"));
await ctx.approvePair(WETH, USDC, WETH_USDC.options.address, lp);
await ctx.mintToken(null, USDC, lp, decimalStr("0"), mweiStr("36000"));
await WETH.methods.deposit().send(ctx.sendParam(lp, '80'));
await WETH_USDC.methods
.depositBaseTo(lp, decimalStr("1000"))
.depositBaseTo(lp, decimalStr("80"))
.send(ctx.sendParam(lp));
await WETH_USDC.methods
.depositQuoteTo(lp, mweiStr("450000"))
.depositQuoteTo(lp, mweiStr("36000"))
.send(ctx.sendParam(lp));
}
//mock sdk logic
async function calcRoute(ctx: DODOContext,fromTokenAmount:string,slippage:number,routes:any[],pairs:any[]) {
async function calcRoute(ctx: DODOContext, fromTokenAmount: string, slippage: number, routes: any[], pairs: any[]) {
let swapAmount = fromTokenAmount
let directions:number[] = []
let dodoPairs:string[] = []
let directions: number[] = []
let dodoPairs: string[] = []
for (let i = 0; i < pairs.length; i++) {
let curPair = pairs[i]
dodoPairs.push(curPair.pair)
let curContact = pairs[i].pairContract
if (curPair.base === routes[i].address) {
if (routes[i].address == '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') {
directions[i] = 0;
swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call();
console.log(i + "-swapAmount:",swapAmount);
console.log(i + "-swapAmount:", swapAmount);
} else if (curPair.base === routes[i].address) {
directions[i] = 0;
swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call();
console.log(i + "-swapAmount:", swapAmount);
} else {
directions[i] = 1;
swapAmount = await ctx.DODOSellHelper.methods.querySellQuoteToken(curPair.pair,swapAmount).call();
console.log(i + "-swapAmount:",swapAmount);
swapAmount = await ctx.DODOSellHelper.methods.querySellQuoteToken(curPair.pair, swapAmount).call();
console.log(i + "-swapAmount:", swapAmount);
}
}
let toAmount = new BigNumber(swapAmount).multipliedBy(1-slippage).toFixed(0, BigNumber.ROUND_DOWN)
console.log("minAmount:",toAmount);
let toAmount = new BigNumber(swapAmount).multipliedBy(1 - slippage).toFixed(0, BigNumber.ROUND_DOWN)
console.log("minAmount:", toAmount);
// console.log("dodoPairs",dodoPairs);
// console.log("directions",directions);
return ctx.SmartSwap.methods.dodoSwap(
routes[0].address,
routes[routes.length-1].address,
routes[routes.length - 1].address,
fromTokenAmount,
toAmount,
dodoPairs,
@@ -139,9 +144,9 @@ describe("Trader", () => {
it("DODO to USDT directly swap", async () => {
var b_DODO = await ctx.DODO.methods.balanceOf(trader).call()
var b_USDT = await ctx.USDT.methods.balanceOf(trader).call()
console.log("Before DODO:" + fromWei(b_DODO,'ether') + "; USDT:" + fromWei(b_USDT,'mwei'));
console.log("Before DODO:" + fromWei(b_DODO, 'ether') + "; USDT:" + fromWei(b_USDT, 'mwei'));
//approve DODO entry
await ctx.DODO.methods.approve(ctx.SmartApprove.options.address,MAX_UINT256).send(ctx.sendParam(trader))
await ctx.DODO.methods.approve(ctx.SmartApprove.options.address, MAX_UINT256).send(ctx.sendParam(trader))
//set route path
var routes = [{
address: ctx.DODO.options.address,
@@ -155,37 +160,35 @@ describe("Trader", () => {
var pairs = [{
pair: ctx.DODO_USDT.options.address,
base: ctx.DODO.options.address,
/*only for test*/
pairContract: ctx.DODO_USDT
/**************/
}];
var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "directly swap")
var tx = await logGas(await calcRoute(ctx, decimalStr('10'), 0.1, routes, pairs), ctx.sendParam(trader), "directly swap")
// console.log(tx.events['OrderHistory']);
var a_DODO = await ctx.DODO.methods.balanceOf(trader).call()
var a_USDT = await ctx.USDT.methods.balanceOf(trader).call()
console.log("After DODO:" + fromWei(a_DODO,'ether') + "; USDT:" + fromWei(a_USDT,'mwei'));
console.log("After DODO:" + fromWei(a_DODO, 'ether') + "; USDT:" + fromWei(a_USDT, 'mwei'));
console.log("===============================================")
var c_DODO = await ctx.DODO.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_USDT = await ctx.USDT.methods.balanceOf(ctx.SmartSwap.options.address).call()
console.log("Contract DODO:" + fromWei(c_DODO,'ether') + "; USDT:" + fromWei(c_USDT,'mwei'));
console.log("Contract DODO:" + fromWei(c_DODO, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei'));
});
it("DODO to USDC two hops swap", async () => {
var b_DODO = await ctx.DODO.methods.balanceOf(trader).call()
var b_USDC = await ctx.USDC.methods.balanceOf(trader).call()
console.log("Before DODO:" + fromWei(b_DODO,'ether') + "; USDC:" + fromWei(b_USDC,'mwei'));
console.log("Before DODO:" + fromWei(b_DODO, 'ether') + "; USDC:" + fromWei(b_USDC, 'mwei'));
//approve DODO entry
await ctx.DODO.methods.approve(ctx.SmartApprove.options.address,MAX_UINT256).send(ctx.sendParam(trader))
await ctx.DODO.methods.approve(ctx.SmartApprove.options.address, MAX_UINT256).send(ctx.sendParam(trader))
//set route path
var routes = [{
address: ctx.DODO.options.address,
decimals: 18
},{
}, {
address: ctx.USDT.options.address,
decimals: 6
},{
}, {
address: ctx.USDC.options.address,
decimals: 6
}];
@@ -193,46 +196,42 @@ describe("Trader", () => {
var pairs = [{
pair: ctx.DODO_USDT.options.address,
base: ctx.DODO.options.address,
/*only for test*/
pairContract: ctx.DODO_USDT
/**************/
},{
}, {
pair: ctx.USDT_USDC.options.address,
base: ctx.USDT.options.address,
/*only for test*/
pairContract: ctx.USDT_USDC
/**************/
}];
var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "tow hops swap")
var tx = await logGas(await calcRoute(ctx, decimalStr('10'), 0.1, routes, pairs), ctx.sendParam(trader), "tow hops swap")
// console.log(tx.events['Swapped']);
var a_DODO = await ctx.DODO.methods.balanceOf(trader).call()
var a_USDC = await ctx.USDC.methods.balanceOf(trader).call()
console.log("After DODO:" + fromWei(a_DODO,'ether') + "; USDC:" + fromWei(a_USDC,'mwei'));
console.log("After DODO:" + fromWei(a_DODO, 'ether') + "; USDC:" + fromWei(a_USDC, 'mwei'));
console.log("===============================================")
var c_DODO = await ctx.DODO.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_USDT = await ctx.USDT.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_USDC = await ctx.USDC.methods.balanceOf(ctx.SmartSwap.options.address).call()
console.log("Contract DODO:" + fromWei(c_DODO,'ether') + "; USDT:" + fromWei(c_USDT,'mwei') + "; USDC:" + fromWei(c_USDC,'mwei'));
console.log("Contract DODO:" + fromWei(c_DODO, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei') + "; USDC:" + fromWei(c_USDC, 'mwei'));
});
it("DODO to WETH three hops swap", async () => {
var b_DODO = await ctx.DODO.methods.balanceOf(trader).call()
var b_WETH = await ctx.WETH.methods.balanceOf(trader).call()
console.log("Before DODO:" + fromWei(b_DODO,'ether') + "; WETH:" + fromWei(b_WETH,'ether'));
console.log("Before DODO:" + fromWei(b_DODO, 'ether') + "; WETH:" + fromWei(b_WETH, 'ether'));
//approve DODO entry
await ctx.DODO.methods.approve(ctx.SmartApprove.options.address,MAX_UINT256).send(ctx.sendParam(trader))
await ctx.DODO.methods.approve(ctx.SmartApprove.options.address, MAX_UINT256).send(ctx.sendParam(trader))
//set route path
var routes = [{
address: ctx.DODO.options.address,
decimals: 18
},{
}, {
address: ctx.USDT.options.address,
decimals: 6
},{
}, {
address: ctx.USDC.options.address,
decimals: 6
},{
}, {
address: ctx.WETH.options.address,
decimals: 18
}];
@@ -240,34 +239,168 @@ describe("Trader", () => {
var pairs = [{
pair: ctx.DODO_USDT.options.address,
base: ctx.DODO.options.address,
/*only for test*/
pairContract: ctx.DODO_USDT
/**************/
},{
}, {
pair: ctx.USDT_USDC.options.address,
base: ctx.USDT.options.address,
/*only for test*/
pairContract: ctx.USDT_USDC
/**************/
},{
}, {
pair: ctx.WETH_USDC.options.address,
base: ctx.WETH.options.address,
/*only for test*/
pairContract: ctx.WETH_USDC
/**************/
}];
var tx = await logGas(await calcRoute(ctx,decimalStr('10'),0.1,routes,pairs), ctx.sendParam(trader), "three hops swap")
var tx = await logGas(await calcRoute(ctx, decimalStr('10'), 0.1, routes, pairs), ctx.sendParam(trader), "three hops swap")
console.log(tx.events['TestAmount']);
var a_DODO = await ctx.DODO.methods.balanceOf(trader).call()
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call()
console.log("After DODO:" + fromWei(a_DODO,'ether') + "; WETH:" + fromWei(a_WETH,'ether'));
console.log("After DODO:" + fromWei(a_DODO, 'ether') + "; WETH:" + fromWei(a_WETH, 'ether'));
console.log("===============================================")
var c_DODO = await ctx.DODO.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_USDT = await ctx.USDT.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_USDC = await ctx.USDC.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_WETH = await ctx.WETH.methods.balanceOf(ctx.SmartSwap.options.address).call()
console.log("Contract DODO:" + fromWei(c_DODO,'ether') + "; USDT:" + fromWei(c_USDT,'mwei') + "; USDC:" + fromWei(c_USDC,'mwei') + "; WETH:" + fromWei(c_WETH,'ether'));
console.log("Contract DODO:" + fromWei(c_DODO, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei') + "; USDC:" + fromWei(c_USDC, 'mwei') + "; WETH:" + fromWei(c_WETH, 'ether'));
});
it("ETH to USDT wrap eth and directly swap", async () => {
var b_ETH = await ctx.Web3.eth.getBalance(trader)
var b_WETH = await ctx.WETH.methods.balanceOf(trader).call()
var b_USDC = await ctx.USDC.methods.balanceOf(trader).call()
console.log("Before ETH:" + fromWei(b_ETH, 'ether') + "; WETH:" + fromWei(b_WETH, 'ether') + "; USDC:" + fromWei(b_USDC, 'mwei'));
var b_w_eth = await ctx.Web3.eth.getBalance(ctx.WETH.options.address)
console.log("weth contract Before:" + fromWei(b_w_eth, 'ether'))
//set route path
var routes = [{
address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
decimals: 18
}, {
address: ctx.USDC.options.address,
decimals: 6
}];
var pairs = [{
pair: ctx.WETH_USDC.options.address,
base: ctx.WETH.options.address,
pairContract: ctx.WETH_USDC
}];
var tx = await logGas(await calcRoute(ctx, decimalStr('1'), 0.1, routes, pairs), ctx.sendParam(trader, '1'), "wrap eth and directly swap")
var a_ETH = await ctx.Web3.eth.getBalance(trader)
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call()
var a_USDC = await ctx.USDC.methods.balanceOf(trader).call()
console.log("After ETH:" + fromWei(a_ETH, 'ether') + "; WETH:" + fromWei(a_WETH, 'ether') + "; USDC:" + fromWei(a_USDC, 'mwei'));
console.log("===============================================")
var c_ETH = await ctx.Web3.eth.getBalance(ctx.SmartSwap.options.address)
var c_WETH = await ctx.WETH.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_USDT = await ctx.USDT.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_USDC = await ctx.USDC.methods.balanceOf(ctx.SmartSwap.options.address).call()
console.log("Contract ETH:" + fromWei(c_ETH, 'ether') + "; WETH:" + fromWei(c_WETH, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei') + "; USDC:" + fromWei(c_USDC, 'mwei'));
var a_w_eth = await ctx.Web3.eth.getBalance(ctx.WETH.options.address)
console.log("weth contract After:" + fromWei(a_w_eth, 'ether'))
});
it("ETH to USDT wrap eth and two hops swap", async () => {
var b_ETH = await ctx.Web3.eth.getBalance(trader)
var b_WETH = await ctx.WETH.methods.balanceOf(trader).call()
var b_USDT = await ctx.USDT.methods.balanceOf(trader).call()
console.log("Before ETH:" + fromWei(b_ETH, 'ether') + "; WETH:" + fromWei(b_WETH, 'ether') + "; USDT:" + fromWei(b_USDT, 'mwei'));
var b_w_eth = await ctx.Web3.eth.getBalance(ctx.WETH.options.address)
console.log("weth contract Before:" + fromWei(b_w_eth, 'ether'))
//set route path
var routes = [{
address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
decimals: 18
}, {
address: ctx.USDC.options.address,
decimals: 6
}, {
address: ctx.USDT.options.address,
decimals: 6
}];
var pairs = [{
pair: ctx.WETH_USDC.options.address,
base: ctx.WETH.options.address,
pairContract: ctx.WETH_USDC
}, {
pair: ctx.USDT_USDC.options.address,
base: ctx.USDT.options.address,
pairContract: ctx.USDT_USDC
}];
var tx = await logGas(await calcRoute(ctx, decimalStr('1'), 0.1, routes, pairs), ctx.sendParam(trader, '1'), "wrap eth and tow hops swap")
var a_ETH = await ctx.Web3.eth.getBalance(trader)
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call()
var a_USDT = await ctx.USDT.methods.balanceOf(trader).call()
console.log("After ETH:" + fromWei(a_ETH, 'ether') + "; WETH:" + fromWei(a_WETH, 'ether') + "; USDT:" + fromWei(a_USDT, 'mwei'));
console.log("===============================================")
var c_ETH = await ctx.Web3.eth.getBalance(ctx.SmartSwap.options.address)
var c_WETH = await ctx.WETH.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_USDT = await ctx.USDT.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_USDC = await ctx.USDC.methods.balanceOf(ctx.SmartSwap.options.address).call()
console.log("Contract ETH:" + fromWei(c_ETH, 'ether') + "; WETH:" + fromWei(c_WETH, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei') + "; USDC:" + fromWei(c_USDC, 'mwei'));
var a_w_eth = await ctx.Web3.eth.getBalance(ctx.WETH.options.address)
console.log("weth contract After:" + fromWei(a_w_eth, 'ether'))
});
it("DODO to ETH unwrap eth and three hops swap", async () => {
var b_DODO = await ctx.DODO.methods.balanceOf(trader).call()
var b_ETH = await ctx.Web3.eth.getBalance(trader)
var b_WETH = await ctx.WETH.methods.balanceOf(trader).call()
console.log("User Before ETH:" + fromWei(b_ETH, 'ether') + "; WETH:" + fromWei(b_WETH, 'ether') + "; DODO:" + fromWei(b_DODO, 'ether'));
var b_w_eth = await ctx.Web3.eth.getBalance(ctx.WETH.options.address)
console.log("weth contract Before:" + fromWei(b_w_eth, 'ether'))
//approve DODO entry
await ctx.DODO.methods.approve(ctx.SmartApprove.options.address, MAX_UINT256).send(ctx.sendParam(trader))
//set route path
var routes = [{
address: ctx.DODO.options.address,
decimals: 18
}, {
address: ctx.USDT.options.address,
decimals: 6
}, {
address: ctx.USDC.options.address,
decimals: 6
}, {
address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
decimals: 18
}];
var pairs = [{
pair: ctx.DODO_USDT.options.address,
base: ctx.DODO.options.address,
pairContract: ctx.DODO_USDT
}, {
pair: ctx.USDT_USDC.options.address,
base: ctx.USDT.options.address,
pairContract: ctx.USDT_USDC
}, {
pair: ctx.WETH_USDC.options.address,
base: ctx.WETH.options.address,
pairContract: ctx.WETH_USDC
}];
var tx = await logGas(await calcRoute(ctx, decimalStr('1000'), 0.1, routes, pairs), ctx.sendParam(trader), "unwrap eth and three hops swap")
var a_ETH = await ctx.Web3.eth.getBalance(trader)
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call()
var a_DODO = await ctx.DODO.methods.balanceOf(trader).call()
console.log("After ETH:" + fromWei(a_ETH, 'ether') + "; WETH:" + fromWei(a_WETH, 'ether') + "; DODO:" + fromWei(a_DODO, 'ether'));
console.log("===============================================")
var c_ETH = await ctx.Web3.eth.getBalance(ctx.SmartSwap.options.address)
var c_WETH = await ctx.WETH.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_USDT = await ctx.USDT.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_USDC = await ctx.USDC.methods.balanceOf(ctx.SmartSwap.options.address).call()
var c_DODO = await ctx.DODO.methods.balanceOf(ctx.SmartSwap.options.address).call()
console.log("Contract ETH:" + fromWei(c_ETH, 'ether') + "; WETH:" + fromWei(c_WETH, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei') + "; USDC:" + fromWei(c_USDC, 'mwei') + "; DODO:" + fromWei(c_DODO, "ether"));
var w_eth = await ctx.Web3.eth.getBalance(ctx.WETH.options.address)
console.log("weth contract After:" + fromWei(w_eth, 'ether'))
});
});
});

32
test/utils-v1/Context-route.ts
View File

@@ -58,10 +58,10 @@ export class DODOContext {
mtFeeRate: string;
k: string;
//token
DODO:Contract;
USDT:Contract;
USDC:Contract;
WETH:Contract;
DODO: Contract;
USDT: Contract;
USDC: Contract;
WETH: Contract;
//pair
DODO_USDT: Contract;
USDT_USDC: Contract;
@@ -74,7 +74,7 @@ export class DODOContext {
SmartApprove: Contract;
DODOSellHelper: Contract;
constructor() {}
constructor() { }
async init(config: DODOContextInitConfig) {
this.k = config.k;
@@ -116,9 +116,10 @@ export class DODOContext {
["USDC", 6]
);
this.WETH = await contracts.newContract(
contracts.TEST_ERC20_CONTRACT_NAME,
["WETH", 18]
contracts.WETH_CONTRACT_NAME
);
//创建交易对
//DODO-USDT
this.DODO_USDT_ORACLE = await contracts.newContract(
@@ -223,7 +224,7 @@ export class DODOContext {
this.SmartSwap = await contracts.newContract(
contracts.SMART_SWAP,
[this.SmartApprove.options.address,this.DODOSellHelper.options.address]
[this.SmartApprove.options.address, this.DODOSellHelper.options.address, this.WETH.options.address]
);
await this.SmartApprove.methods.setSmartSwap(this.SmartSwap.options.address).send(this.sendParam(this.Deployer));
@@ -240,20 +241,21 @@ export class DODOContext {
};
}
async setOraclePrice(oracle:Contract,price: string) {
async setOraclePrice(oracle: Contract, price: string) {
await oracle.methods
.setPrice(price)
.send(this.sendParam(this.Deployer));
}
async mintToken(tokenBase:Contract,tokenQuote:Contract,to: string, base: string, quote: string) {
await tokenBase.methods.mint(to, base).send(this.sendParam(this.Deployer));
await tokenQuote.methods
.mint(to,  quote)
.send(this.sendParam(this.Deployer));
async mintToken(tokenBase: Contract, tokenQuote: Contract, to: string, base: string, quote: string) {
if (tokenBase != null)
await tokenBase.methods.mint(to, base).send(this.sendParam(this.Deployer));
if (tokenQuote != null)
await tokenQuote.methods.mint(to, quote).send(this.sendParam(this.Deployer));
}
async approvePair(tokenBase:Contract,tokenQuote:Contract, approveTarget:string,account: string) {
async approvePair(tokenBase: Contract, tokenQuote: Contract, approveTarget: string, account: string) {
await tokenBase.methods
.approve(approveTarget, MAX_UINT256)
.send(this.sendParam(account));

2
test/utils-v1/Contracts.ts
View File

@@ -17,7 +17,6 @@ const CloneFactory = require(`${jsonPath}CloneFactory.json`)
const DODO = require(`${jsonPath}DODO.json`)
const DODOZoo = require(`${jsonPath}DODOZoo.json`)
const DODOEthProxy = require(`${jsonPath}DODOEthProxy.json`)
const WETH = require(`${jsonPath}WETH9.json`)
const TestERC20 = require(`${jsonPath}TestERC20.json`)
const NaiveOracle = require(`${jsonPath}NaiveOracle.json`)
const DODOLpToken = require(`${jsonPath}DODOLpToken.json`)
@@ -31,6 +30,7 @@ const LockedTokenVault = require(`${jsonPath}LockedTokenVault.json`)
const SmartSwap = require(`${jsonPath2}SmartSwap.json`)
const SmartApprove = require(`${jsonPath2}SmartApprove.json`)
const DODOSellHelper = require(`${jsonPath2}DODOSellHelper.json`)
const WETH = require(`${jsonPath2}WETH9.json`)
/******/
import { getDefaultWeb3 } from './EVM';