diff --git a/.gitignore b/.gitignore index 7f476ea..658570c 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,7 @@ .idea build/ +build-v1/ dist/ node_modules/ coverage/ diff --git a/contracts/DODOVendorMachine/impl/DVMStorage.sol b/contracts/DODOVendorMachine/impl/DVMStorage.sol index b1f1afb..be8a389 100644 --- a/contracts/DODOVendorMachine/impl/DVMStorage.sol +++ b/contracts/DODOVendorMachine/impl/DVMStorage.sol @@ -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 { diff --git a/contracts/DODOVendorMachine/intf/IDVMVault.sol b/contracts/DODOVendorMachine/intf/IDVMVault.sol new file mode 100644 index 0000000..a310e47 --- /dev/null +++ b/contracts/DODOVendorMachine/intf/IDVMVault.sol @@ -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; +} diff --git a/contracts/DODOZoo.sol b/contracts/DODOZoo.sol new file mode 100644 index 0000000..c47cc10 --- /dev/null +++ b/contracts/DODOZoo.sol @@ -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; + } +} diff --git a/contracts/SmartRoute/SmartSwap.sol b/contracts/SmartRoute/SmartSwap.sol index a501ea2..5d05dc7 100644 --- a/contracts/SmartRoute/SmartSwap.sol +++ b/contracts/SmartRoute/SmartSwap.sol @@ -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"); diff --git a/contracts/helper/CloneFactory.sol b/contracts/helper/CloneFactory.sol new file mode 100644 index 0000000..fd8f755 --- /dev/null +++ b/contracts/helper/CloneFactory.sol @@ -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; + } +} diff --git a/contracts/helper/NativeOracle.sol b/contracts/helper/NativeOracle.sol new file mode 100644 index 0000000..b472960 --- /dev/null +++ b/contracts/helper/NativeOracle.sol @@ -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; + } +} diff --git a/contracts/helper/TestERC20.sol b/contracts/helper/TestERC20.sol new file mode 100644 index 0000000..a420d04 --- /dev/null +++ b/contracts/helper/TestERC20.sol @@ -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); + } +} diff --git a/contracts/helper/TestWETH.sol b/contracts/helper/TestWETH.sol new file mode 100644 index 0000000..4ebf56c --- /dev/null +++ b/contracts/helper/TestWETH.sol @@ -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; + } +} diff --git a/contracts/lib/GasPriceSource.sol b/contracts/lib/GasPriceSource.sol new file mode 100644 index 0000000..d1a71a5 --- /dev/null +++ b/contracts/lib/GasPriceSource.sol @@ -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_; + } +} diff --git a/contracts/lib/UniversalERC20.sol b/contracts/lib/UniversalERC20.sol index 7005a5b..9557cd8 100644 --- a/contracts/lib/UniversalERC20.sol +++ b/contracts/lib/UniversalERC20.sol @@ -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); } } -} \ No newline at end of file +} diff --git a/deploy-detail.txt b/deploy-detail.txt new file mode 100644 index 0000000..0f0c76c --- /dev/null +++ b/deploy-detail.txt @@ -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 diff --git a/migrations/1_initial_migration.js b/migrations/1_initial_migration.js index ee2135d..3439329 100644 --- a/migrations/1_initial_migration.js +++ b/migrations/1_initial_migration.js @@ -1,5 +1,5 @@ const Migrations = artifacts.require("Migrations"); -module.exports = function(deployer) { - deployer.deploy(Migrations); +module.exports = function (deployer) { + // deployer.deploy(Migrations); }; diff --git a/migrations/2_deploy.js b/migrations/2_deploy.js index 63ed46d..89350a9 100644 --- a/migrations/2_deploy.js +++ b/migrations/2_deploy.js @@ -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 + } +}; diff --git a/test/Route/Route.test.ts b/test/Route/Route.test.ts index 08823c8..16463bb 100644 --- a/test/Route/Route.test.ts +++ b/test/Route/Route.test.ts @@ -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 { - 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 { - 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 { - 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')) + }); + }); }); diff --git a/test/utils-v1/Context-route.ts b/test/utils-v1/Context-route.ts index 43761ac..3c25e69 100644 --- a/test/utils-v1/Context-route.ts +++ b/test/utils-v1/Context-route.ts @@ -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)); diff --git a/test/utils-v1/Contracts.ts b/test/utils-v1/Contracts.ts index 306f274..b7ddecd 100644 --- a/test/utils-v1/Contracts.ts +++ b/test/utils-v1/Contracts.ts @@ -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';