diff --git a/contracts/DODOVendorMachine/impl/DVM.sol b/contracts/DODOVendorMachine/impl/DVM.sol index 4b437ad..e1d598b 100644 --- a/contracts/DODOVendorMachine/impl/DVM.sol +++ b/contracts/DODOVendorMachine/impl/DVM.sol @@ -13,7 +13,7 @@ import {IPermissionManager} from "../../lib/PermissionManager.sol"; import {IGasPriceSource} from "../../lib/GasPriceSource.sol"; import {DVMTrader} from "./DVMTrader.sol"; import {DVMFunding} from "./DVMFunding.sol"; -import {DVMVault} from "./DVMVault.sol"; +import {IDVMVault} from "../intf/IDVMVault.sol"; contract DVM is DVMTrader, DVMFunding { function init( @@ -28,7 +28,7 @@ contract DVM is DVMTrader, DVMFunding { uint256 k ) external { initOwner(owner); - _VAULT_ = DVMVault(vault); + _VAULT_ = IDVMVault(vault); _BASE_TOKEN_ = _VAULT_._BASE_TOKEN_(); _QUOTE_TOKEN_ = _VAULT_._QUOTE_TOKEN_(); _LP_FEE_RATE_MODEL_ = IFeeRateModel(lpFeeRateModel); diff --git a/contracts/DODOVendorMachine/intf/IDVMVault.sol b/contracts/DODOVendorMachine/intf/IDVMVault.sol index de8a251..a310e47 100644 --- a/contracts/DODOVendorMachine/intf/IDVMVault.sol +++ b/contracts/DODOVendorMachine/intf/IDVMVault.sol @@ -19,9 +19,9 @@ interface IDVMVault { function _QUOTE_TOKEN_() external returns (address); - function _BASE_RESERVE_() external returns (address); + function _BASE_RESERVE_() external returns (uint256); - function _QUOTE_RESERVE_() external returns (address); + function _QUOTE_RESERVE_() external returns (uint256); function symbol() external returns (string memory); 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..78ab7d0 100644 --- a/contracts/SmartRoute/SmartSwap.sol +++ b/contracts/SmartRoute/SmartSwap.sol @@ -15,6 +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 { @@ -25,6 +26,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,9 +38,15 @@ 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 { + require(msg.sender == _WETH_, "WE_CAN_NOT_SAVED_YOUR_ETH"); } function dodoSwap( @@ -54,6 +62,9 @@ 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++) { @@ -73,6 +84,12 @@ contract SmartSwap is Ownable { } } 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"); 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/deploy-detail.txt b/deploy-detail.txt index c728994..aaf3713 100644 --- a/deploy-detail.txt +++ b/deploy-detail.txt @@ -1,8 +1,3 @@ ==================================================== -network type: kovan -Deploy time: 2020/11/12 上午9:38:54 -Deploy type: Smart Route -SmartApprove Address: 0x8D2625d0f1ed3C7E1E506Bf86b4660c1781Fd7C0 -DODOSellHelper Address: 0xbdEae617F2616b45DCB69B287D52940a76035Fe3 -SmartSwap Address: 0xC1632dD29D5c4ac1Cd7b9B7d1e23E91bB092acAC -SmartApprovce setSmartSwap tx: 0x2e641cd363b3c42579308502dbca07e45377032fb52ae5f1acbd0d865d0ce7e3 +network type: development +Deploy time: 2020/11/13 下午3:47:21 diff --git a/migrations/2_deploy.js b/migrations/2_deploy.js index b32ec7d..f88306d 100644 --- a/migrations/2_deploy.js +++ b/migrations/2_deploy.js @@ -5,15 +5,25 @@ 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_ROUTE = false; +const DEPLOY_KOVAN_TOKEN = false; -module.exports = async (deployer, network) => { +module.exports = async (deployer, network,accounts) => { let DODOSellHelperAddress = "" + let DODOZooAddress = "" + let WETHAddress = "" if(network == 'kovan'){ DODOSellHelperAddress = "0xbdEae617F2616b45DCB69B287D52940a76035Fe3"; + DODOZooAddress = "0x92230e929a2226b29ed3441ae5524886347c60c8"; + WETHAddress = "0x5eca15b12d959dfcf9c71c59f8b467eb8c6efd0b"; }else { - DODOSellHelperAddress = ""; + DODOSellHelperAddress = "0x533da777aedce766ceae696bf90f8541a4ba80eb"; + DODOZooAddress = "0x3a97247df274a17c59a3bd12735ea3fcdfb49950"; + WETHAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"; } logger.log("===================================================="); @@ -37,6 +47,103 @@ module.exports = async (deployer, network) => { 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 31f0e2b..685cc5d 100644 --- a/test/Route/Route.test.ts +++ b/test/Route/Route.test.ts @@ -26,14 +26,14 @@ async function initDODO_USDT(ctx: DODOContext): Promise { 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)); } @@ -47,13 +47,13 @@ async function initUSDT_USDC(ctx: DODOContext): Promise { 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.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)); } @@ -68,13 +68,14 @@ async function initWETH_USDC(ctx: DODOContext): Promise { 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.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)); } @@ -89,7 +90,11 @@ async function calcRoute(ctx: DODOContext,fromTokenAmount:string,slippage:number 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); + }else if (curPair.base === routes[i].address) { directions[i] = 0; swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call(); console.log(i + "-swapAmount:",swapAmount); @@ -257,5 +262,145 @@ describe("Trader", () => { 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')); }); + + + 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..8e79e6c 100644 --- a/test/utils-v1/Context-route.ts +++ b/test/utils-v1/Context-route.ts @@ -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)); @@ -247,12 +248,13 @@ export class DODOContext { } 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)); + 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) { await tokenBase.methods .approve(approveTarget, MAX_UINT256) 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';