diff --git a/contracts/SmartRoute/DODOIncentive.sol b/contracts/SmartRoute/DODOIncentive.sol index fc4328d..e60f83c 100644 --- a/contracts/SmartRoute/DODOIncentive.sol +++ b/contracts/SmartRoute/DODOIncentive.sol @@ -12,6 +12,9 @@ import {SafeERC20} from "../lib/SafeERC20.sol"; import {SafeMath} from "../lib/SafeMath.sol"; import {IERC20} from "../intf/IERC20.sol"; +interface IDODOIncentive { + function triggerIncentive(address fromToken,address toToken, address assetTo) external; +} contract DODOIncentive is InitializableOwnable { using SafeMath for uint256; @@ -20,18 +23,18 @@ contract DODOIncentive is InitializableOwnable { // ============ Storage ============ address public immutable _DODO_TOKEN_; address public _DODO_PROXY_; - uint256 public dodoPerBlock; - uint256 public defaultRate; - uint256 public startBlock; + uint256 public dodoPerBlock = 10 * 10**18; + uint256 public defaultRate = 10; mapping(address => uint256) public boosts; + uint256 public startBlock; + uint32 public lastRewardBlock; uint112 public totalReward; uint112 public totalDistribution; - constructor(address _dodoToken, address _dodoProxy) public { + constructor(address _dodoToken) public { _DODO_TOKEN_ = _dodoToken; - _DODO_PROXY_ = _dodoProxy; } // ============ Events ============ @@ -41,14 +44,14 @@ contract DODOIncentive is InitializableOwnable { event SetNewProxy(address dodoProxy); event SetPerReward(uint256 dodoPerBlock); event SetDefaultRate(uint256 defaultRate); - event Incentive(address user,uint256 reward, address fromToken, address toToken); + event Incentive(address user,uint256 reward); // ============ Ownable ============ function switchIncentive(uint256 _startBlock) public onlyOwner { if(startBlock != 0) { require(block.number >= startBlock); - _update(); + _update(0,totalDistribution); startBlock = 0; }else { require(block.number <= _startBlock && _startBlock < uint32(-1)); @@ -66,7 +69,7 @@ contract DODOIncentive is InitializableOwnable { } function changePerReward(uint256 _dodoPerBlock) public onlyOwner { - _update(); + _update(0,totalDistribution); dodoPerBlock = _dodoPerBlock; emit SetPerReward(dodoPerBlock); } @@ -90,28 +93,36 @@ contract DODOIncentive is InitializableOwnable { // ============ Incentive function============ function triggerIncentive(address fromToken,address toToken, address assetTo) external { require(msg.sender == _DODO_PROXY_, "DODOIncentive:Access restricted"); - if(startBlock == 0 || block.number < startBlock) return; + uint256 _startBlock = startBlock; + if(_startBlock == 0 || block.number < _startBlock) return; uint256 curTotalDistribution = totalDistribution; uint256 fromRate = boosts[fromToken]; uint256 toRate = boosts[toToken]; - uint256 rate = (fromRate >= toRate ? fromRate : toRate).add(defaultRate); - _update(); - uint256 reward = uint256(totalReward).sub(curTotalDistribution).mul(rate).div(1000); + // uint256 rate = (fromRate >= toRate ? fromRate : toRate).add(defaultRate); + uint256 rate = (fromRate >= toRate ? fromRate : toRate) + defaultRate; - uint256 _totalDistribution = curTotalDistribution.add(reward); - require(_totalDistribution < uint112(-1), "OVERFLOW"); - totalDistribution = uint112(_totalDistribution); + // uint256 _totalReward = uint256(totalReward).add(block.number.sub(uint256(lastRewardBlock)).mul(dodoPerBlock)); + uint256 _totalReward = totalReward + (block.number - lastRewardBlock) * dodoPerBlock; + // uint256 reward = _totalReward.sub(curTotalDistribution).mul(rate).div(1000); + uint256 reward = (_totalReward - curTotalDistribution) * rate / 1000; + // uint256 _totalDistribution = curTotalDistribution.add(reward); + uint256 _totalDistribution = curTotalDistribution + reward; + _update(_totalReward,_totalDistribution); IERC20(_DODO_TOKEN_).transfer(assetTo,reward); - emit Incentive(assetTo,reward,fromToken,toToken); + + emit Incentive(assetTo,reward); } - function _update() internal { - uint256 _totalReward = uint256(totalReward).add(block.number.sub(uint256(lastRewardBlock)).mul(dodoPerBlock)); - require(_totalReward < uint112(-1) && block.number < uint32(-1), "OVERFLOW"); - totalReward = uint112(_totalReward); + function _update(uint256 _totalReward, uint256 _totalDistribution) internal { + if(_totalReward == 0) + // _totalReward = uint256(totalReward).add(block.number.sub(uint256(lastRewardBlock)).mul(dodoPerBlock)); + _totalReward = totalReward + (block.number - lastRewardBlock) * dodoPerBlock; + require(_totalReward < uint112(-1) && _totalDistribution < uint112(-1) && block.number < uint32(-1), "OVERFLOW"); lastRewardBlock = uint32(block.number); + totalReward = uint112(_totalReward); + totalDistribution = uint112(_totalDistribution); } } \ No newline at end of file diff --git a/contracts/SmartRoute/DODOV1Proxy02.sol b/contracts/SmartRoute/DODOV1Proxy02.sol new file mode 100644 index 0000000..4d52100 --- /dev/null +++ b/contracts/SmartRoute/DODOV1Proxy02.sol @@ -0,0 +1,290 @@ +/* + + Copyright 2020 DODO ZOO. + SPDX-License-Identifier: Apache-2.0 + +*/ + +pragma solidity 0.6.9; + +import {IERC20} from "../intf/IERC20.sol"; +import {UniversalERC20} from "./lib/UniversalERC20.sol"; +import {SafeMath} from "../lib/SafeMath.sol"; +import {IDODOV1} from "./intf/IDODOV1.sol"; +import {IDODOSellHelper} from "./helper/DODOSellHelper.sol"; +import {IWETH} from "../intf/IWETH.sol"; +import {IChi} from "./intf/IChi.sol"; +import {IUni} from "./intf/IUni.sol"; +import {IDODOApprove} from "../intf/IDODOApprove.sol"; +import {IDODOV1Proxy02} from "./intf/IDODOV1Proxy02.sol"; +import {InitializableOwnable} from "../lib/InitializableOwnable.sol"; +import {IDODOIncentive} from "./DODOIncentive.sol"; + +/** + * @title DODOV1Proxy02 + * @author DODO Breeder + * + * @notice Entrance of trading in DODO platform + */ +contract DODOV1Proxy02 is IDODOV1Proxy02, InitializableOwnable { + using SafeMath for uint256; + using UniversalERC20 for IERC20; + + // ============ Storage ============ + + address constant _ETH_ADDRESS_ = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + address public immutable _DODO_INCENTIVE_; + address public immutable _DODO_APPROVE_; + address public immutable _DODO_SELL_HELPER_; + address public immutable _WETH_; + address public immutable _CHI_TOKEN_; + uint256 public _GAS_DODO_MAX_RETURN_ = 0; + uint256 public _GAS_EXTERNAL_RETURN_ = 0; + mapping (address => bool) public isWhiteListed; + + // ============ Events ============ + + event OrderHistory( + address indexed fromToken, + address indexed toToken, + address indexed sender, + uint256 fromAmount, + uint256 returnAmount + ); + + // ============ Modifiers ============ + + modifier judgeExpired(uint256 deadLine) { + require(deadLine >= block.timestamp, "DODOV1Proxy02: EXPIRED"); + _; + } + + constructor( + address dodoApporve, + address dodoSellHelper, + address weth, + address chiToken, + address dodoIncentive + ) public { + _DODO_APPROVE_ = dodoApporve; + _DODO_SELL_HELPER_ = dodoSellHelper; + _WETH_ = weth; + _CHI_TOKEN_ = chiToken; + _DODO_INCENTIVE_ = dodoIncentive; + } + + fallback() external payable {} + + receive() external payable {} + + function updateGasReturn(uint256 newDodoGasReturn, uint256 newExternalGasReturn) public onlyOwner { + _GAS_DODO_MAX_RETURN_ = newDodoGasReturn; + _GAS_EXTERNAL_RETURN_ = newExternalGasReturn; + } + + function addWhiteList (address contractAddr) public onlyOwner { + isWhiteListed[contractAddr] = true; + } + + function removeWhiteList (address contractAddr) public onlyOwner { + isWhiteListed[contractAddr] = false; + } + + function dodoSwapV1( + address fromToken, + address toToken, + uint256 fromTokenAmount, + uint256 minReturnAmount, + address[] memory dodoPairs, + uint256 directions, + bool isIncentive, + uint256 deadLine + ) external override payable judgeExpired(deadLine) returns (uint256 returnAmount) { + require(dodoPairs.length > 0, "DODOV1Proxy02: PAIRS_EMPTY"); + require(minReturnAmount > 0, "DODOV1Proxy02: RETURN_AMOUNT_ZERO"); + uint256 originGas = gasleft(); + + if (fromToken != _ETH_ADDRESS_) { + IDODOApprove(_DODO_APPROVE_).claimTokens( + fromToken, + msg.sender, + address(this), + fromTokenAmount + ); + } else { + require(msg.value == fromTokenAmount, "DODOV1Proxy02: ETH_AMOUNT_NOT_MATCH"); + IWETH(_WETH_).deposit{value: fromTokenAmount}(); + } + + for (uint256 i = 0; i < dodoPairs.length; i++) { + address curDodoPair = dodoPairs[i]; + if (directions & 1 == 0) { + address curDodoBase = IDODOV1(curDodoPair)._BASE_TOKEN_(); + uint256 curAmountIn = IERC20(curDodoBase).balanceOf(address(this)); + IERC20(curDodoBase).universalApproveMax(curDodoPair, curAmountIn); + IDODOV1(curDodoPair).sellBaseToken(curAmountIn, 0, ""); + } else { + address curDodoQuote = IDODOV1(curDodoPair)._QUOTE_TOKEN_(); + uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this)); + IERC20(curDodoQuote).universalApproveMax(curDodoPair, curAmountIn); + uint256 canBuyBaseAmount = IDODOSellHelper(_DODO_SELL_HELPER_).querySellQuoteToken( + curDodoPair, + curAmountIn + ); + IDODOV1(curDodoPair).buyBaseToken(canBuyBaseAmount, curAmountIn, ""); + } + directions = directions >> 1; + } + + if (toToken == _ETH_ADDRESS_) { + returnAmount = IWETH(_WETH_).balanceOf(address(this)); + IWETH(_WETH_).withdraw(returnAmount); + } else { + returnAmount = IERC20(toToken).tokenBalanceOf(address(this)); + } + + require(returnAmount >= minReturnAmount, "DODOV1Proxy02: Return amount is not enough"); + IERC20(toToken).universalTransfer(msg.sender, returnAmount); + + emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount); + + uint256 _gasDodoMaxReturn = _GAS_DODO_MAX_RETURN_; + if(_gasDodoMaxReturn > 0) { + uint256 calcGasTokenBurn = originGas.sub(gasleft()) / 65000; + uint256 gasTokenBurn = calcGasTokenBurn > _gasDodoMaxReturn ? _gasDodoMaxReturn : calcGasTokenBurn; + if(gasleft() > 27710 + gasTokenBurn * 6080) + IChi(_CHI_TOKEN_).freeUpTo(gasTokenBurn); + } + + if(isIncentive) { + IDODOIncentive(_DODO_INCENTIVE_).triggerIncentive(fromToken,toToken,msg.sender); + } + } + + function externalSwap( + address fromToken, + address toToken, + address approveTarget, + address swapTarget, + uint256 fromTokenAmount, + uint256 minReturnAmount, + bytes memory callDataConcat, + bool isIncentive, + uint256 deadLine + ) external override payable judgeExpired(deadLine) returns (uint256 returnAmount) { + require(minReturnAmount > 0, "DODOV1Proxy02: RETURN_AMOUNT_ZERO"); + + address _fromToken = fromToken; + address _toToken = toToken; + + uint256 toTokenOriginBalance = IERC20(_toToken).universalBalanceOf(msg.sender); + + if (_fromToken != _ETH_ADDRESS_) { + IDODOApprove(_DODO_APPROVE_).claimTokens( + _fromToken, + msg.sender, + address(this), + fromTokenAmount + ); + IERC20(_fromToken).universalApproveMax(approveTarget, fromTokenAmount); + } + + require(isWhiteListed[swapTarget], "DODOV1Proxy02: Not Whitelist Contract"); + (bool success, ) = swapTarget.call{value: _fromToken == _ETH_ADDRESS_ ? msg.value : 0}(callDataConcat); + + require(success, "DODOV1Proxy02: External Swap execution Failed"); + + IERC20(_toToken).universalTransfer( + msg.sender, + IERC20(_toToken).universalBalanceOf(address(this)) + ); + returnAmount = IERC20(_toToken).universalBalanceOf(msg.sender).sub(toTokenOriginBalance); + require(returnAmount >= minReturnAmount, "DODOV1Proxy02: Return amount is not enough"); + + emit OrderHistory(_fromToken, _toToken, msg.sender, fromTokenAmount, returnAmount); + + uint256 _gasExternalReturn = _GAS_EXTERNAL_RETURN_; + if(_gasExternalReturn > 0) { + if(gasleft() > 27710 + _gasExternalReturn * 6080) + IChi(_CHI_TOKEN_).freeUpTo(_gasExternalReturn); + } + + if(isIncentive) { + IDODOIncentive(_DODO_INCENTIVE_).triggerIncentive(_fromToken,_toToken,msg.sender); + } + } + + + function mixSwapV1( + address fromToken, + address toToken, + uint256 fromTokenAmount, + uint256 minReturnAmount, + address[] memory mixPairs, + uint256[] memory directions, + address[] memory portionPath, + bool isIncentive, + uint256 deadLine + ) external override payable judgeExpired(deadLine) returns (uint256 returnAmount) { + require(mixPairs.length == directions.length, "DODOV1Proxy02: PARAMS_LENGTH_NOT_MATCH"); + require(mixPairs.length > 0, "DODOV1Proxy02: PAIRS_EMPTY"); + require(minReturnAmount > 0, "DODOV1Proxy02: RETURN_AMOUNT_ZERO"); + + uint256 toTokenOriginBalance = IERC20(toToken).universalBalanceOf(msg.sender); + + if (fromToken != _ETH_ADDRESS_) { + IDODOApprove(_DODO_APPROVE_).claimTokens( + fromToken, + msg.sender, + address(this), + fromTokenAmount + ); + } else { + require(msg.value == fromTokenAmount, "DODOV1Proxy02: ETH_AMOUNT_NOT_MATCH"); + IWETH(_WETH_).deposit{value: fromTokenAmount}(); + } + + for (uint256 i = 0; i < mixPairs.length; i++) { + address curPair = mixPairs[i]; + if (directions[i] == 0) { + address curDodoBase = IDODOV1(curPair)._BASE_TOKEN_(); + uint256 curAmountIn = IERC20(curDodoBase).balanceOf(address(this)); + IERC20(curDodoBase).universalApproveMax(curPair, curAmountIn); + IDODOV1(curPair).sellBaseToken(curAmountIn, 0, ""); + } else if(directions[i] == 1){ + address curDodoQuote = IDODOV1(curPair)._QUOTE_TOKEN_(); + uint256 curAmountIn = IERC20(curDodoQuote).balanceOf(address(this)); + IERC20(curDodoQuote).universalApproveMax(curPair, curAmountIn); + uint256 canBuyBaseAmount = IDODOSellHelper(_DODO_SELL_HELPER_).querySellQuoteToken( + curPair, + curAmountIn + ); + IDODOV1(curPair).buyBaseToken(canBuyBaseAmount, curAmountIn, ""); + } else { + uint256 curAmountIn = IERC20(portionPath[0]).balanceOf(address(this)); + IERC20(portionPath[0]).universalApproveMax(curPair, curAmountIn); + IUni(curPair).swapExactTokensForTokens(curAmountIn,0,portionPath,address(this),deadLine); + } + } + + IERC20(toToken).universalTransfer( + msg.sender, + IERC20(toToken).universalBalanceOf(address(this)) + ); + + returnAmount = IERC20(toToken).universalBalanceOf(msg.sender).sub(toTokenOriginBalance); + require(returnAmount >= minReturnAmount, "DODOV1Proxy02: Return amount is not enough"); + + emit OrderHistory(fromToken, toToken, msg.sender, fromTokenAmount, returnAmount); + + uint256 _gasExternalReturn = _GAS_EXTERNAL_RETURN_; + if(_gasExternalReturn > 0) { + if(gasleft() > 27710 + _gasExternalReturn * 6080) + IChi(_CHI_TOKEN_).freeUpTo(_gasExternalReturn); + } + + if(isIncentive) { + IDODOIncentive(_DODO_INCENTIVE_).triggerIncentive(fromToken,toToken,msg.sender); + } + } +} diff --git a/contracts/SmartRoute/intf/IDODOV1Proxy02.sol b/contracts/SmartRoute/intf/IDODOV1Proxy02.sol new file mode 100644 index 0000000..8e829a2 --- /dev/null +++ b/contracts/SmartRoute/intf/IDODOV1Proxy02.sol @@ -0,0 +1,46 @@ +/* + + Copyright 2020 DODO ZOO. + SPDX-License-Identifier: Apache-2.0 + +*/ + +pragma solidity 0.6.9; +pragma experimental ABIEncoderV2; + +interface IDODOV1Proxy02 { + function dodoSwapV1( + address fromToken, + address toToken, + uint256 fromTokenAmount, + uint256 minReturnAmount, + address[] memory dodoPairs, + uint256 directions, + bool isIncentive, + uint256 deadLine + ) external payable returns (uint256 returnAmount); + + function externalSwap( + address fromToken, + address toToken, + address approveTarget, + address to, + uint256 fromTokenAmount, + uint256 minReturnAmount, + bytes memory callDataConcat, + bool isIncentive, + uint256 deadLine + ) external payable returns (uint256 returnAmount); + + function mixSwapV1( + address fromToken, + address toToken, + uint256 fromTokenAmount, + uint256 minReturnAmount, + address[] memory mixPairs, + uint256[] memory directions, + address[] memory portionPath, + bool isIncentive, + uint256 deadLine + ) external payable returns (uint256 returnAmount); +} diff --git a/test/Proxy/proxy.incentive.test.ts b/test/Proxy/proxy.incentive.test.ts deleted file mode 100644 index 76d840c..0000000 --- a/test/Proxy/proxy.incentive.test.ts +++ /dev/null @@ -1,142 +0,0 @@ -/* - - Copyright 2020 DODO ZOO. - SPDX-License-Identifier: Apache-2.0 - -*/ - -import { decimalStr, mweiStr } from '../utils/Converter'; -import { logGas } from '../utils/Log'; -import { ProxyContext, getProxyContext } from '../utils/ProxyContextV2'; -import { assert } from 'chai'; -import * as contracts from '../utils/Contracts'; - -let lp: string; -let project: string; -let trader: string; - -let config = { - lpFeeRate: decimalStr("0.002"), - mtFeeRate: decimalStr("0.001"), - k: decimalStr("0.1"), - i: decimalStr("100"), -}; - -async function init(ctx: ProxyContext): Promise { - lp = ctx.SpareAccounts[0]; - project = ctx.SpareAccounts[1]; - trader = ctx.SpareAccounts[2]; - - await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000000")); - await ctx.mintTestToken(project, ctx.DODO, decimalStr("1000000")); - - await ctx.mintTestToken(lp, ctx.USDT, mweiStr("1000000")); - await ctx.mintTestToken(project, ctx.USDT, mweiStr("1000000")); - - await ctx.approveProxy(lp); - await ctx.approveProxy(project); - await ctx.approveProxy(trader); -} - - -async function initCreateDPP(ctx: ProxyContext, token0: string, token1: string, token0Amount: string, token1Amount: string, ethValue: string, i: string): Promise { - let PROXY = ctx.DODOProxyV2; - await PROXY.methods.createDODOPrivatePool( - token0, - token1, - token0Amount, - token1Amount, - config.lpFeeRate, - i, - config.k, - Math.floor(new Date().getTime() / 1000 + 60 * 10) - ).send(ctx.sendParam(project, ethValue)); - if (token0 == '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') token0 = ctx.WETH.options.address; - if (token1 == '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') token1 = ctx.WETH.options.address; - var addr = await ctx.DPPFactory.methods._REGISTRY_(token0, token1, 0).call(); - return addr; -} - -async function initCreateDVM(ctx: ProxyContext, token0: string, token1: string, token0Amount: string, token1Amount: string, ethValue: string, i: string): Promise { - let PROXY = ctx.DODOProxyV2; - await PROXY.methods.createDODOVendingMachine( - project, - token0, - token1, - token0Amount, - token1Amount, - config.lpFeeRate, - i, - config.k, - Math.floor(new Date().getTime() / 1000 + 60 * 10) - ).send(ctx.sendParam(project, ethValue)); - if (token0 == '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') token0 = ctx.WETH.options.address; - if (token1 == '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') token1 = ctx.WETH.options.address; - var addr = await ctx.DVMFactory.methods._REGISTRY_(token0, token1, 0).call(); - return addr; -} - -describe("DODOProxyV2.0", () => { - let snapshotId: string; - let ctx: ProxyContext; - let dpp_DODO_USDT: string; - let dvm_WETH_USDT: string; - - before(async () => { - let ETH = await contracts.newContract( - contracts.WETH_CONTRACT_NAME - ); - ctx = await getProxyContext(ETH.options.address); - await init(ctx); - dpp_DODO_USDT = await initCreateDPP(ctx, ctx.DODO.options.address, ctx.USDT.options.address, decimalStr("100000"), mweiStr("20000"), "0", mweiStr("0.2")); - dvm_WETH_USDT = await initCreateDVM(ctx, '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', ctx.USDT.options.address, decimalStr("5"), mweiStr("3000"), "5", mweiStr("600")); - console.log("dpp_DODO_USDT:", dpp_DODO_USDT); - console.log("dvm_WETH_USDT:", dvm_WETH_USDT); - }); - - beforeEach(async () => { - snapshotId = await ctx.EVM.snapshot(); - }); - - afterEach(async () => { - await ctx.EVM.reset(snapshotId); - }); - - describe("DODOIncentive", () => { - - it("incentive-switch with trade", async () => { - - }); - - it("incentive-changeBoost with trade", async () => { - - }); - - it("tigger - incentive", async () => { - await ctx.mintTestToken(trader, ctx.DODO, decimalStr("1000")); - var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call(); - var b_WETH = await ctx.WETH.methods.balanceOf(trader).call(); - var dodoPairs = [ - dpp_DODO_USDT, - dvm_WETH_USDT - ] - var directions = 2 - await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken( - trader, - ctx.DODO.options.address, - ctx.WETH.options.address, - decimalStr("500"), - 1, - dodoPairs, - directions, - Math.floor(new Date().getTime() / 1000 + 60 * 10) - ), ctx.sendParam(trader), "swap - two jump"); - var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call(); - var a_WETH = await ctx.WETH.methods.balanceOf(trader).call(); - console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD); - console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH); - assert.equal(a_DOOD, decimalStr("500")); - assert.equal(a_WETH, "129932374904193666"); - }); - }); -}); diff --git a/test/Route/Incentive.test.ts b/test/Route/Incentive.test.ts new file mode 100644 index 0000000..8e05f0c --- /dev/null +++ b/test/Route/Incentive.test.ts @@ -0,0 +1,274 @@ +/* + + Copyright 2020 DODO ZOO. + SPDX-License-Identifier: Apache-2.0 + +*/ + +import BigNumber from 'bignumber.js'; +import { DODOContext, getDODOContext } from '../utils-v1/ProxyContextV1'; +import { decimalStr, MAX_UINT256, fromWei, mweiStr } from '../utils-v1/Converter'; +import { logGas } from '../utils-v1/Log'; +import * as contracts from '../utils-v1/Contracts'; +import { assert } from 'chai'; + +let lp: string; +let trader: string; + +async function initDODO_USDT(ctx: DODOContext): Promise { + 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.mintToken(DODO, USDT, lp, decimalStr("10000000"), mweiStr("1000000")); + + await DODO_USDT.methods + .depositBaseTo(lp, decimalStr("10000000")) + .send(ctx.sendParam(lp)); + await DODO_USDT.methods + .depositQuoteTo(lp, mweiStr("1000000")) + .send(ctx.sendParam(lp)); +} + +async function initUSDT_USDC(ctx: DODOContext): Promise { + 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("1000000"), mweiStr("1000000")); + + await USDT_USDC.methods + .depositBaseTo(lp, mweiStr("1000000")) + .send(ctx.sendParam(lp)); + await USDT_USDC.methods + .depositQuoteTo(lp, mweiStr("1000000")) + .send(ctx.sendParam(lp)); +} + + +async function initWETH_USDC(ctx: DODOContext): Promise { + 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(null, USDC, lp, decimalStr("0"), mweiStr("3600")); + await WETH.methods.deposit().send(ctx.sendParam(lp, '8')); + + await WETH_USDC.methods + .depositBaseTo(lp, decimalStr("8")) + .send(ctx.sendParam(lp)); + await WETH_USDC.methods + .depositQuoteTo(lp, mweiStr("3600")) + .send(ctx.sendParam(lp)); +} + +async function initIncentive(ctx: DODOContext): Promise { + var blockNum = await ctx.Web3.eth.getBlockNumber(); + await ctx.DODOIncentive.methods.switchIncentive(blockNum + 1).send(ctx.sendParam(ctx.Deployer)); + await ctx.mintToken(ctx.DODO, null, ctx.DODOIncentive.options.address, decimalStr("10000"), mweiStr("0")); +} + +//mock sdk logic +async function calcRoute(ctx: DODOContext, fromTokenAmount: string, slippage: number, routes: any[], pairs: any[], isIncentive: boolean) { + let tmpDirections: number[] = [] + let strDirections: string = '' + let dodoPairs: string[] = [] + + for (let i = 0; i < pairs.length; i++) { + let curPair = pairs[i] + dodoPairs.push(curPair.pair) + if (routes[i].address == '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') { + tmpDirections[i] = 0; + } else if (curPair.base === routes[i].address) { + tmpDirections[i] = 0; + } else { + tmpDirections[i] = 1; + } + } + + var [returmAmount,] = await ctx.DODOSwapCalcHelper.methods.calcReturnAmountV1( + fromTokenAmount, + dodoPairs, + tmpDirections, + ).call(); + // console.log("returnAmount:", returmAmount) + // console.log("localAmount:", swapAmount) + // console.log("midPrices:", midPrices) + + + let toAmount = new BigNumber(returmAmount).multipliedBy(1 - slippage).toFixed(0, BigNumber.ROUND_DOWN) + let deadline = Math.floor(new Date().getTime() / 1000 + 60 * 10); + + for (let i = tmpDirections.length - 1; i >= 0; i--) { + strDirections += tmpDirections[i].toString() + } + + return ctx.DODOV1Proxy02.methods.dodoSwapV1( + routes[0].address, + routes[routes.length - 1].address, + fromTokenAmount, + toAmount, + dodoPairs, + parseInt(strDirections, 2), + isIncentive, + deadline + ) +} + +describe("Trader", () => { + let snapshotId: string; + let ctx: DODOContext; + + before(async () => { + let ETH = await contracts.newContract( + contracts.WETH_CONTRACT_NAME + ); + ctx = await getDODOContext(ETH.options.address); + await initDODO_USDT(ctx); + await initUSDT_USDC(ctx); + await initWETH_USDC(ctx); + await initIncentive(ctx); + }); + + beforeEach(async () => { + snapshotId = await ctx.EVM.snapshot(); + }); + + afterEach(async () => { + await ctx.EVM.reset(snapshotId); + }); + + describe("route calc with incentive test", () => { + it("incentive-switch with trade", async () => { + await ctx.DODOIncentive.methods.changePerReward(decimalStr("10")).send(ctx.sendParam(ctx.Deployer)); + var totalReward = await ctx.DODOIncentive.methods.totalReward().call(); + var totalDistribution = await ctx.DODOIncentive.methods.totalDistribution().call(); + var blockNum = await ctx.Web3.eth.getBlockNumber(); + console.log("Init - Total Reward:" + fromWei(totalReward, 'ether') + "; Total distribution:" + fromWei(totalDistribution, 'ether') + "; BlockNumber:" + blockNum); + + //Aim to increase block + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + blockNum = await ctx.Web3.eth.getBlockNumber(); + console.log("Close BlockNumber:", blockNum + 1) + await ctx.DODOIncentive.methods.switchIncentive(0).send(ctx.sendParam(ctx.Deployer)); + totalReward = await ctx.DODOIncentive.methods.totalReward().call(); + totalDistribution = await ctx.DODOIncentive.methods.totalDistribution().call(); + blockNum = await ctx.Web3.eth.getBlockNumber(); + console.log("Close incentive - Total Reward:" + fromWei(totalReward, 'ether') + "; Total distribution:" + fromWei(totalDistribution, 'ether') + "; BlockNumber:" + blockNum) + //Aim to increase block + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + + blockNum = await ctx.Web3.eth.getBlockNumber(); + await ctx.DODOIncentive.methods.switchIncentive(blockNum + 1).send(ctx.sendParam(ctx.Deployer)); + console.log("Open BlockNumber:", blockNum + 1) + //Aim to increase block + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + await ctx.DODOIncentive.methods.changePerReward(decimalStr("10")).send(ctx.sendParam(ctx.Deployer)); + totalReward = await ctx.DODOIncentive.methods.totalReward().call(); + totalDistribution = await ctx.DODOIncentive.methods.totalDistribution().call(); + blockNum = await ctx.Web3.eth.getBlockNumber(); + console.log("End incentive - Total Reward:" + fromWei(totalReward, 'ether') + "; Total distribution:" + fromWei(totalDistribution, 'ether') + "; BlockNumber:" + blockNum) + assert(totalReward, decimalStr("100")); + }); + + it("incentive-changeBoost with trade", async () => { + await ctx.DODOIncentive.methods.changePerReward(decimalStr("10")).send(ctx.sendParam(ctx.Deployer)); + var totalReward = await ctx.DODOIncentive.methods.totalReward().call(); + var totalDistribution = await ctx.DODOIncentive.methods.totalDistribution().call(); + var blockNum = await ctx.Web3.eth.getBlockNumber(); + console.log("Init - Total Reward:" + fromWei(totalReward, 'ether') + "; Total distribution:" + fromWei(totalDistribution, 'ether') + "; BlockNumber:" + blockNum); + + //Aim to increase block + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + + blockNum = await ctx.Web3.eth.getBlockNumber(); + console.log("Change BlockNumber:", blockNum + 1) + await ctx.DODOIncentive.methods.changePerReward(decimalStr("20")).send(ctx.sendParam(ctx.Deployer)); + totalReward = await ctx.DODOIncentive.methods.totalReward().call(); + totalDistribution = await ctx.DODOIncentive.methods.totalDistribution().call(); + blockNum = await ctx.Web3.eth.getBlockNumber(); + console.log("change incentive - Total Reward:" + fromWei(totalReward, 'ether') + "; Total distribution:" + fromWei(totalDistribution, 'ether') + "; BlockNumber:" + blockNum) + + //Aim to increase block + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + await ctx.mintToken(ctx.DODO, null, lp, decimalStr("100"), mweiStr("0")); + await ctx.DODOIncentive.methods.changePerReward(decimalStr("10")).send(ctx.sendParam(ctx.Deployer)); + totalReward = await ctx.DODOIncentive.methods.totalReward().call(); + totalDistribution = await ctx.DODOIncentive.methods.totalDistribution().call(); + blockNum = await ctx.Web3.eth.getBlockNumber(); + console.log("End incentive - Total Reward:" + fromWei(totalReward, 'ether') + "; Total distribution:" + fromWei(totalDistribution, 'ether') + "; BlockNumber:" + blockNum) + assert(totalReward, decimalStr("140")); + }); + + it("directly swap with incentive", async () => { + await ctx.mintToken(ctx.DODO, ctx.USDT, trader, decimalStr("1000"), mweiStr("0")); + 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')); + + var b_totalReward = await ctx.DODOIncentive.methods.totalReward().call(); + var b_totalDistribution = await ctx.DODOIncentive.methods.totalDistribution().call(); + console.log("Before Total Reward:" + fromWei(b_totalReward, 'ether') + "; Total distribution:" + fromWei(b_totalDistribution, 'ether')) + + //approve DODO entry + await ctx.DODO.methods.approve(ctx.DODOApprove.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 + }]; + + var pairs = [{ + pair: ctx.DODO_USDT.options.address, + base: ctx.DODO.options.address, + pairContract: ctx.DODO_USDT + }]; + await logGas(await calcRoute(ctx, decimalStr('10'), 0.1, routes, pairs, false), ctx.sendParam(trader), "directly swap without incentive first") + await logGas(await calcRoute(ctx, decimalStr('10'), 0.1, routes, pairs, false), ctx.sendParam(trader), "directly swap without incentive second") + var a_DODO = await ctx.DODO.methods.balanceOf(trader).call() + var a_USDT = await ctx.USDT.methods.balanceOf(trader).call() + console.log("After No Incentive DODO:" + fromWei(a_DODO, 'ether') + "; USDT:" + fromWei(a_USDT, 'mwei')); + + await logGas(await calcRoute(ctx, decimalStr('10'), 0.1, routes, pairs, true), ctx.sendParam(trader), "directly swap with incentive first") + await logGas(await calcRoute(ctx, decimalStr('10'), 0.1, routes, pairs, true), ctx.sendParam(trader), "directly swap with incentive second") + + var a_totalReward = await ctx.DODOIncentive.methods.totalReward().call(); + var a_totalDistribution = await ctx.DODOIncentive.methods.totalDistribution().call(); + console.log("After Total Reward:" + fromWei(a_totalReward, 'ether') + "; Total distribution:" + fromWei(a_totalDistribution, 'ether')) + + a_DODO = await ctx.DODO.methods.balanceOf(trader).call() + a_USDT = await ctx.USDT.methods.balanceOf(trader).call() + console.log("After Incentive DODO:" + fromWei(a_DODO, 'ether') + "; USDT:" + fromWei(a_USDT, 'mwei')); + assert(a_DODO, decimalStr("961.493")); + }); + }); +}); diff --git a/test/Route/Route.test.ts b/test/Route/Route.test.ts index 720975b..7159bed 100644 --- a/test/Route/Route.test.ts +++ b/test/Route/Route.test.ts @@ -119,7 +119,7 @@ async function calcRoute(ctx: DODOContext, fromTokenAmount: string, slippage: nu // console.log("minAmount:",toAmount); let deadline = Math.floor(new Date().getTime() / 1000 + 60 * 10); - return ctx.DODOProxyV1.methods.dodoSwapV1( + return ctx.DODOV1Proxy01.methods.dodoSwapV1( routes[0].address, routes[routes.length - 1].address, fromTokenAmount, @@ -135,6 +135,7 @@ describe("Trader", () => { let ctx: DODOContext; before(async () => { + console.log("Confirm DODOApprove's current Proxy version!"); let ETH = await contracts.newContract( contracts.WETH_CONTRACT_NAME ); @@ -156,7 +157,7 @@ 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() - var c_b_CHI = await ctx.CHI.methods.balanceOf(ctx.DODOProxyV1.options.address).call() + var c_b_CHI = await ctx.CHI.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() console.log("Before DODO:" + fromWei(b_DODO, 'ether') + "; USDT:" + fromWei(b_USDT, 'mwei')); //approve DODO entry await ctx.DODO.methods.approve(ctx.DODOApprove.options.address, MAX_UINT256).send(ctx.sendParam(trader)) @@ -183,9 +184,9 @@ describe("Trader", () => { 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("===============================================") - var c_DODO = await ctx.DODO.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_USDT = await ctx.USDT.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_a_CHI = await ctx.CHI.methods.balanceOf(ctx.DODOProxyV1.options.address).call() + var c_DODO = await ctx.DODO.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_USDT = await ctx.USDT.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_a_CHI = await ctx.CHI.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() console.log("Contract DODO:" + fromWei(c_DODO, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei')); console.log("Contract gas Token Before:" + c_b_CHI + " ;After:" + c_a_CHI); // console.log("USDT:" + a_USDT); @@ -228,9 +229,9 @@ describe("Trader", () => { 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("===============================================") - var c_DODO = await ctx.DODO.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_USDT = await ctx.USDT.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_USDC = await ctx.USDC.methods.balanceOf(ctx.DODOProxyV1.options.address).call() + var c_DODO = await ctx.DODO.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_USDT = await ctx.USDT.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_USDC = await ctx.USDC.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() console.log("Contract DODO:" + fromWei(c_DODO, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei') + "; USDC:" + fromWei(c_USDC, 'mwei')); // console.log("USDC:" + a_USDC); assert(a_USDC, "1988019"); @@ -278,10 +279,10 @@ describe("Trader", () => { 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("===============================================") - var c_DODO = await ctx.DODO.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_USDT = await ctx.USDT.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_USDC = await ctx.USDC.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_WETH = await ctx.WETH.methods.balanceOf(ctx.DODOProxyV1.options.address).call() + var c_DODO = await ctx.DODO.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_USDT = await ctx.USDT.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_USDC = await ctx.USDC.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_WETH = await ctx.WETH.methods.balanceOf(ctx.DODOV1Proxy01.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("WETH:" + a_WETH); assert(a_WETH, "4404365055045800"); @@ -317,10 +318,10 @@ describe("Trader", () => { 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.DODOProxyV1.options.address) - var c_WETH = await ctx.WETH.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_USDT = await ctx.USDT.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_USDC = await ctx.USDC.methods.balanceOf(ctx.DODOProxyV1.options.address).call() + var c_ETH = await ctx.Web3.eth.getBalance(ctx.DODOV1Proxy01.options.address) + var c_WETH = await ctx.WETH.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_USDT = await ctx.USDT.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_USDC = await ctx.USDC.methods.balanceOf(ctx.DODOV1Proxy01.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')) @@ -364,10 +365,10 @@ describe("Trader", () => { 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.DODOProxyV1.options.address) - var c_WETH = await ctx.WETH.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_USDT = await ctx.USDT.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_USDC = await ctx.USDC.methods.balanceOf(ctx.DODOProxyV1.options.address).call() + var c_ETH = await ctx.Web3.eth.getBalance(ctx.DODOV1Proxy01.options.address) + var c_WETH = await ctx.WETH.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_USDT = await ctx.USDT.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_USDC = await ctx.USDC.methods.balanceOf(ctx.DODOV1Proxy01.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')) @@ -422,11 +423,11 @@ describe("Trader", () => { 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.DODOProxyV1.options.address) - var c_WETH = await ctx.WETH.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_USDT = await ctx.USDT.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_USDC = await ctx.USDC.methods.balanceOf(ctx.DODOProxyV1.options.address).call() - var c_DODO = await ctx.DODO.methods.balanceOf(ctx.DODOProxyV1.options.address).call() + var c_ETH = await ctx.Web3.eth.getBalance(ctx.DODOV1Proxy01.options.address) + var c_WETH = await ctx.WETH.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_USDT = await ctx.USDT.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_USDC = await ctx.USDC.methods.balanceOf(ctx.DODOV1Proxy01.options.address).call() + var c_DODO = await ctx.DODO.methods.balanceOf(ctx.DODOV1Proxy01.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/Contracts.ts b/test/utils-v1/Contracts.ts index afd14ab..9e39448 100644 --- a/test/utils-v1/Contracts.ts +++ b/test/utils-v1/Contracts.ts @@ -28,11 +28,13 @@ const DODOMineReader = require(`${jsonPath}DODOMineReader.json`) const LockedTokenVault = require(`${jsonPath}LockedTokenVault.json`) /*v1.5 */ const SmartSwap = require(`${jsonPath2}DODOV1Proxy01.json`) +const SmartSwap02 = require(`${jsonPath2}DODOV1Proxy02.json`) const SmartApprove = require(`${jsonPath2}DODOApprove.json`) const DODOSellHelper = require(`${jsonPath2}DODOSellHelper.json`) const WETH = require(`${jsonPath2}WETH9.json`) const CHI = require(`${jsonPath2}ChiToken.json`) const DODOSwapCalcHelper = require(`${jsonPath2}DODOSwapCalcHelper.json`) +const DODOIncentive = require(`${jsonPath2}DODOIncentive.json`) /******/ import { getDefaultWeb3 } from './EVM'; @@ -55,10 +57,12 @@ export const DODO_MINE_NAME = "DODOMine" export const DODO_MINE_READER_NAME = "DODOMineReader" /*v1.5 */ export const SMART_SWAP = "DODOV1Proxy01" +export const SMART_SWAP_02 = "DODOV1Proxy02" export const SMART_APPROVE = "DODOApprove" export const DODO_SELL_HELPER = "DODOSellHelper" export const CHI_TOKEN = "ChiToken" export const DODO_SWAP_CALC_HELPER = "DODOSwapCalcHelper" +export const DODO_INCENTIVE = "DODOIncentive" /******/ var contractMap: { [name: string]: any } = {} @@ -78,10 +82,12 @@ contractMap[DODO_MINE_NAME] = DODOMine contractMap[DODO_MINE_READER_NAME] = DODOMineReader /*v1.5 */ contractMap[SMART_SWAP] = SmartSwap +contractMap[SMART_SWAP_02] = SmartSwap02 contractMap[SMART_APPROVE] = SmartApprove contractMap[DODO_SELL_HELPER] = DODOSellHelper contractMap[CHI_TOKEN] = CHI contractMap[DODO_SWAP_CALC_HELPER] = DODOSwapCalcHelper +contractMap[DODO_INCENTIVE] = DODOIncentive /******/ interface ContractJson { diff --git a/test/utils-v1/ProxyContextV1.ts b/test/utils-v1/ProxyContextV1.ts index e239e9d..55199cb 100644 --- a/test/utils-v1/ProxyContextV1.ts +++ b/test/utils-v1/ProxyContextV1.ts @@ -71,11 +71,14 @@ export class DODOContext { DODO_USDT_ORACLE: Contract; USDT_USDC_ORACLE: Contract; WETH_USDC_ORACLE: Contract; - DODOProxyV1: Contract; + DODOV1Proxy01: Contract; + DODOV1Proxy02: Contract; DODOApprove: Contract; DODOSellHelper: Contract; //Helper DODOSwapCalcHelper: Contract; + //Functions + DODOIncentive: Contract; constructor() { } @@ -224,6 +227,12 @@ export class DODOContext { contracts.SMART_APPROVE ); + //DODO Incentive + this.DODOIncentive = await contracts.newContract( + contracts.DODO_INCENTIVE, + [this.DODO.options.address] + ) + //Gas Token this.CHI = await contracts.newContract( contracts.CHI_TOKEN @@ -231,18 +240,25 @@ export class DODOContext { // await this.CHI.methods.mint(140).send(this.sendParam(this.Deployer)); - this.DODOProxyV1 = await contracts.newContract( + this.DODOV1Proxy01 = await contracts.newContract( contracts.SMART_SWAP, [this.DODOApprove.options.address, this.DODOSellHelper.options.address, this.WETH.options.address, this.CHI.options.address] // [this.DODOApprove.options.address, this.DODOSellHelper.options.address, this.WETH.options.address, "0x0000000000000000000000000000000000000000"] ); - await this.DODOProxyV1.methods.initOwner(this.Deployer).send(this.sendParam(this.Deployer)); - await this.DODOApprove.methods.init(this.Deployer,this.DODOProxyV1.options.address).send(this.sendParam(this.Deployer)); + this.DODOV1Proxy02 = await contracts.newContract( + contracts.SMART_SWAP_02, + [this.DODOApprove.options.address, this.DODOSellHelper.options.address, this.WETH.options.address, this.CHI.options.address,this.DODOIncentive.options.address] + // [this.DODOApprove.options.address, this.DODOSellHelper.options.address, this.WETH.options.address, "0x0000000000000000000000000000000000000000"] + ); - - // await this.CHI.methods.transfer(this.DODOProxyV1.options.address,140).send(this.sendParam(this.Deployer)); + await this.DODOV1Proxy01.methods.initOwner(this.Deployer).send(this.sendParam(this.Deployer)); + await this.DODOV1Proxy02.methods.initOwner(this.Deployer).send(this.sendParam(this.Deployer)); + await this.DODOIncentive.methods.initOwner(this.Deployer).send(this.sendParam(this.Deployer)); + await this.DODOApprove.methods.init(this.Deployer,this.DODOV1Proxy02.options.address).send(this.sendParam(this.Deployer)); + await this.DODOIncentive.methods.changeDODOProxy(this.DODOV1Proxy02.options.address).send(this.sendParam(this.Deployer)); + this.DODOSwapCalcHelper = await contracts.newContract( contracts.DODO_SWAP_CALC_HELPER,[this.DODOSellHelper.options.address] ); diff --git a/truffle-test.sh b/truffle-test.sh index 9415d60..7783009 100644 --- a/truffle-test.sh +++ b/truffle-test.sh @@ -26,9 +26,9 @@ then truffle test ./test/Proxy/proxy.cp.test.ts fi -if [ "$1"x = "proxy-incentive"x ] +if [ "$1"x = "route-incentive"x ] then - truffle test ./test/Proxy/proxy.incentive.test.ts + truffle test ./test/Route/Incentive.test.ts fi if [ "$1"x = "route"x ]