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

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

Browse Source
This commit is contained in:
牛涛涛
2021-01-06 18:20:52 +08:00
parent b6843ab25f 66ab633d41
commit f2fca85611
9 changed files with 697 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
contracts/SmartRoute/DODOIncentive.sol
View File

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

290
contracts/SmartRoute/DODOV1Proxy02.sol Normal file
View File

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

46
contracts/SmartRoute/intf/IDODOV1Proxy02.sol Normal file
View File

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

142
test/Proxy/proxy.incentive.test.ts
View File

@@ -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<void> {
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<string> {
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<string> {
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");
});
});
});

274
test/Route/Incentive.test.ts Normal file
View File

@@ -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<void> {
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<void> {
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<void> {
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<void> {
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"));
});
});
});

51
test/Route/Route.test.ts
View File

@@ -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'))

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

@@ -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 {

28
test/utils-v1/ProxyContextV1.ts
View File

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

4
truffle-test.sh
View File

@@ -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 ]