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

annotation && v2proxy add gasreturn and trade incentive && proxyV2 incentive test

Browse Source
This commit is contained in:
owen05
2021-01-08 17:19:23 +08:00
parent 267ad24edc
commit 34d9ccf668
33 changed files with 537 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

502
test/V2Proxy/proxy.classical.test.ts Normal file
View File

@@ -0,0 +1,502 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
import BigNumber from 'bignumber.js';
import { assert } from 'chai';
import { DODOContext, getDODOContext } from '../utils-v1/ProxyContextV1';
import { ProxyContext, getProxyContext } from '../utils/ProxyContextV2';
import { decimalStr, MAX_UINT256, fromWei, mweiStr } from '../utils-v1/Converter';
import { logGas } from '../utils-v1/Log';
import * as contracts from '../utils-v1/Contracts';
import { Contract } from 'web3-eth-contract';
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 ctx.mintToken(DODO, USDT, trader, decimalStr("1000"), mweiStr("1000"));
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 ctx.mintToken(null, USDC, trader, decimalStr("0"), mweiStr("100"));
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));
}
//mock sdk logic
async function calcRoute(ctx: ProxyContext, fromTokenAmount: string, slippage: number, routes: any[], pairs: any[]) {
let swapAmount = fromTokenAmount
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)
let curContact = pairs[i].pairContract
if (routes[i].address == '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') {
tmpDirections[i] = 0;
swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call();
} else if (curPair.base === routes[i].address) {
tmpDirections[i] = 0;
swapAmount = await curContact.methods.querySellBaseToken(swapAmount).call();
} else {
tmpDirections[i] = 1;
swapAmount = await ctx.DODOSellHelper.methods.querySellQuoteToken(curPair.pair, swapAmount).call();
}
}
for (let i = tmpDirections.length - 1; i >= 0; i--) {
strDirections += tmpDirections[i].toString()
}
let toAmount = new BigNumber(swapAmount).multipliedBy(1 - slippage).toFixed(0, BigNumber.ROUND_DOWN)
let deadline = Math.floor(new Date().getTime() / 1000 + 60 * 10);
return ctx.DODOProxyV2.methods.dodoSwapV1(
routes[0].address,
routes[routes.length - 1].address,
fromTokenAmount,
toAmount,
dodoPairs,
parseInt(strDirections,2),
false,
deadline
)
}
describe("AddLiquidity", () => {
let snapshotId1: string;
let snapshotId2: string;
let ctxV1: DODOContext;
let ctxV2: ProxyContext;
let DODO_LP: Contract;
let WETH_LP: Contract;
let USDT_LP: Contract;
let USDC_LP: Contract;
before(async () => {
let ETH = await contracts.newContract(
contracts.WETH_CONTRACT_NAME
);
ctxV1 = await getDODOContext(ETH.options.address);
ctxV2 = await getProxyContext(ETH.options.address);
await initDODO_USDT(ctxV1);
await initUSDT_USDC(ctxV1);
await initWETH_USDC(ctxV1);
var dodo_dlp = await ctxV1.DODO_USDT.methods._BASE_CAPITAL_TOKEN_().call();
var usdt_dlp = await ctxV1.DODO_USDT.methods._QUOTE_CAPITAL_TOKEN_().call();
DODO_LP = contracts.getContractWithAddress(contracts.DODO_LP_TOKEN_CONTRACT_NAME, dodo_dlp);
USDT_LP = contracts.getContractWithAddress(contracts.DODO_LP_TOKEN_CONTRACT_NAME, usdt_dlp);
var weth_dlp = await ctxV1.WETH_USDC.methods._BASE_CAPITAL_TOKEN_().call();
var usdc_dlp = await ctxV1.WETH_USDC.methods._QUOTE_CAPITAL_TOKEN_().call();
WETH_LP = contracts.getContractWithAddress(contracts.DODO_LP_TOKEN_CONTRACT_NAME, weth_dlp);
USDC_LP = contracts.getContractWithAddress(contracts.DODO_LP_TOKEN_CONTRACT_NAME, usdc_dlp);
});
beforeEach(async () => {
snapshotId1 = await ctxV1.EVM.snapshot();
snapshotId2 = await ctxV2.EVM.snapshot();
});
afterEach(async () => {
await ctxV1.EVM.reset(snapshotId1);
await ctxV2.EVM.reset(snapshotId2);
});
describe("AddLiquidity", () => {
it("AddLiquidity", async () => {
var b_DODO = await ctxV1.DODO.methods.balanceOf(trader).call()
var b_USDT = await ctxV1.USDT.methods.balanceOf(trader).call()
var dodo_lp = await DODO_LP.methods.balanceOf(trader).call()
var usdt_lp = await USDT_LP.methods.balanceOf(trader).call()
console.log("Before DODO:" + fromWei(b_DODO, 'ether') + "; USDT:" + fromWei(b_USDT, 'mwei'));
console.log("dodo_lp:" + dodo_lp + " usdt_lp:" + usdt_lp);
await ctxV1.DODO.methods.approve(ctxV2.DODOApprove.options.address, MAX_UINT256).send(ctxV2.sendParam(trader));
await ctxV1.USDT.methods.approve(ctxV2.DODOApprove.options.address, MAX_UINT256).send(ctxV2.sendParam(trader));
await logGas(await ctxV2.DODOProxyV2.methods.addLiquidityToV1(
ctxV1.DODO_USDT.options.address,
decimalStr("100"),
mweiStr("100"),
0,
0,
0,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctxV2.sendParam(trader), "addLiquidity");
var dodo_lp = await DODO_LP.methods.balanceOf(trader).call()
var usdt_lp = await USDT_LP.methods.balanceOf(trader).call()
var a_DODO = await ctxV1.DODO.methods.balanceOf(trader).call()
var a_USDT = await ctxV1.USDT.methods.balanceOf(trader).call()
console.log("After DODO:" + fromWei(a_DODO, 'ether') + "; USDT:" + fromWei(a_USDT, 'mwei'));
assert.equal(dodo_lp,decimalStr("100"));
assert.equal(usdt_lp,mweiStr("100"));
assert.equal(a_DODO,decimalStr("900"));
assert.equal(a_USDT,mweiStr("900"));
});
it("AddLiquidity - ETH", async () => {
var b_WETH = await ctxV1.WETH.methods.balanceOf(trader).call()
var b_USDC = await ctxV1.USDC.methods.balanceOf(trader).call()
var b_ETH = await ctxV2.Web3.eth.getBalance(trader);
var weth_lp = await WETH_LP.methods.balanceOf(trader).call()
var usdc_lp = await USDC_LP.methods.balanceOf(trader).call()
console.log("Before WETH:" + fromWei(b_WETH, 'ether') + "; USDC:" + fromWei(b_USDC, 'mwei') + "; ETH:" + fromWei(b_ETH, 'ether'));
console.log("weth_lp:" + weth_lp + " usdc_lp:" + usdc_lp);
await ctxV1.USDC.methods.approve(ctxV2.DODOApprove.options.address, MAX_UINT256).send(ctxV2.sendParam(trader));
await logGas(await ctxV2.DODOProxyV2.methods.addLiquidityToV1(
ctxV1.WETH_USDC.options.address,
decimalStr("1"),
mweiStr("100"),
0,
0,
1,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctxV2.sendParam(trader,"1"), "addLiquidity - eth");
var weth_lp = await WETH_LP.methods.balanceOf(trader).call()
var usdc_lp = await USDC_LP.methods.balanceOf(trader).call()
var a_WETH = await ctxV1.WETH.methods.balanceOf(trader).call()
var a_USDC = await ctxV1.USDC.methods.balanceOf(trader).call()
var a_ETH = await ctxV2.Web3.eth.getBalance(trader);
console.log("After WETH:" + fromWei(a_WETH, 'ether') + "; USDC:" + fromWei(a_USDC, 'mwei') + "; ETH:" + fromWei(a_ETH, 'ether'));
assert.equal(weth_lp,decimalStr("1"));
assert.equal(usdc_lp,mweiStr("100"));
});
it("DODO to USDT directly swap", async () => {
var b_DODO = await ctxV1.DODO.methods.balanceOf(trader).call()
var b_USDT = await ctxV1.USDT.methods.balanceOf(trader).call()
console.log("Before DODO:" + fromWei(b_DODO, 'ether') + "; USDT:" + fromWei(b_USDT, 'mwei'));
//approve DODO entry
await ctxV1.DODO.methods.approve(ctxV2.DODOApprove.options.address, MAX_UINT256).send(ctxV2.sendParam(trader))
//set route path
var routes = [{
address: ctxV1.DODO.options.address,
decimals: 18
},
{
address: ctxV1.USDT.options.address,
decimals: 6
}];
var pairs = [{
pair: ctxV1.DODO_USDT.options.address,
base: ctxV1.DODO.options.address,
pairContract: ctxV1.DODO_USDT
}];
await logGas(await calcRoute(ctxV2, decimalStr('10'), 0.1, routes, pairs), ctxV2.sendParam(trader), "directly swap first")
await logGas(await calcRoute(ctxV2, decimalStr('10'), 0.1, routes, pairs), ctxV2.sendParam(trader), "directly swap second")
// console.log(tx.events['OrderHistory']);
var a_DODO = await ctxV1.DODO.methods.balanceOf(trader).call()
var a_USDT = await ctxV1.USDT.methods.balanceOf(trader).call()
console.log("After DODO:" + fromWei(a_DODO, 'ether') + "; USDT:" + fromWei(a_USDT, 'mwei'));
console.log("===============================================")
var c_DODO = await ctxV1.DODO.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_USDT = await ctxV1.USDT.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
console.log("Contract DODO:" + fromWei(c_DODO, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei'));
assert(a_USDT, "1994000");
});
it("DODO to USDC two hops swap", async () => {
var b_DODO = await ctxV1.DODO.methods.balanceOf(trader).call()
var b_USDC = await ctxV1.USDC.methods.balanceOf(trader).call()
console.log("Before DODO:" + fromWei(b_DODO, 'ether') + "; USDC:" + fromWei(b_USDC, 'mwei'));
//approve DODO entry
await ctxV1.DODO.methods.approve(ctxV2.DODOApprove.options.address, MAX_UINT256).send(ctxV2.sendParam(trader))
//set route path
var routes = [{
address: ctxV1.DODO.options.address,
decimals: 18
}, {
address: ctxV1.USDT.options.address,
decimals: 6
}, {
address: ctxV1.USDC.options.address,
decimals: 6
}];
var pairs = [{
pair: ctxV1.DODO_USDT.options.address,
base: ctxV1.DODO.options.address,
pairContract: ctxV1.DODO_USDT
}, {
pair: ctxV1.USDT_USDC.options.address,
base: ctxV1.USDT.options.address,
pairContract: ctxV1.USDT_USDC
}];
await logGas(await calcRoute(ctxV2, decimalStr('10'), 0.1, routes, pairs), ctxV2.sendParam(trader), "two hops swap first")
await logGas(await calcRoute(ctxV2, decimalStr('10'), 0.1, routes, pairs), ctxV2.sendParam(trader), "two hops swap second")
// console.log(tx.events['Swapped']);
var a_DODO = await ctxV1.DODO.methods.balanceOf(trader).call()
var a_USDC = await ctxV1.USDC.methods.balanceOf(trader).call()
console.log("After DODO:" + fromWei(a_DODO, 'ether') + "; USDC:" + fromWei(a_USDC, 'mwei'));
console.log("===============================================")
var c_DODO = await ctxV1.DODO.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_USDT = await ctxV1.USDT.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_USDC = await ctxV1.USDC.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
console.log("Contract DODO:" + fromWei(c_DODO, 'ether') + "; USDT:" + fromWei(c_USDT, 'mwei') + "; USDC:" + fromWei(c_USDC, 'mwei'));
assert(a_USDC, "1988019");
});
it("DODO to WETH three hops swap", async () => {
var b_DODO = await ctxV1.DODO.methods.balanceOf(trader).call()
var b_WETH = await ctxV1.WETH.methods.balanceOf(trader).call()
console.log("Before DODO:" + fromWei(b_DODO, 'ether') + "; WETH:" + fromWei(b_WETH, 'ether'));
//approve DODO entry
await ctxV1.DODO.methods.approve(ctxV2.DODOApprove.options.address, MAX_UINT256).send(ctxV2.sendParam(trader))
//set route path
var routes = [{
address: ctxV1.DODO.options.address,
decimals: 18
}, {
address: ctxV1.USDT.options.address,
decimals: 6
}, {
address: ctxV1.USDC.options.address,
decimals: 6
}, {
address: ctxV1.WETH.options.address,
decimals: 18
}];
var pairs = [{
pair: ctxV1.DODO_USDT.options.address,
base: ctxV1.DODO.options.address,
pairContract: ctxV1.DODO_USDT
}, {
pair: ctxV1.USDT_USDC.options.address,
base: ctxV1.USDT.options.address,
pairContract: ctxV1.USDT_USDC
}, {
pair: ctxV1.WETH_USDC.options.address,
base: ctxV1.WETH.options.address,
pairContract: ctxV1.WETH_USDC
}];
var tx = await logGas(await calcRoute(ctxV2, decimalStr('10'), 0.1, routes, pairs), ctxV2.sendParam(trader), "three hops swap first")
var tx = await logGas(await calcRoute(ctxV2, decimalStr('10'), 0.1, routes, pairs), ctxV2.sendParam(trader), "three hops swap second")
console.log(tx.events['TestAmount']);
var a_DODO = await ctxV1.DODO.methods.balanceOf(trader).call()
var a_WETH = await ctxV1.WETH.methods.balanceOf(trader).call()
console.log("After DODO:" + fromWei(a_DODO, 'ether') + "; WETH:" + fromWei(a_WETH, 'ether'));
console.log("===============================================")
var c_DODO = await ctxV1.DODO.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_USDT = await ctxV1.USDT.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_USDC = await ctxV1.USDC.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_WETH = await ctxV1.WETH.methods.balanceOf(ctxV2.DODOProxyV2.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'));
assert(a_WETH, "4404365055045800");
});
it("ETH to USDT wrap eth and directly swap", async () => {
var b_ETH = await ctxV1.Web3.eth.getBalance(trader)
var b_WETH = await ctxV1.WETH.methods.balanceOf(trader).call()
var b_USDC = await ctxV1.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 ctxV1.Web3.eth.getBalance(ctxV1.WETH.options.address)
console.log("weth contract Before:" + fromWei(b_w_eth, 'ether'))
//set route path
var routes = [{
address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
decimals: 18
}, {
address: ctxV1.USDC.options.address,
decimals: 6
}];
var pairs = [{
pair: ctxV1.WETH_USDC.options.address,
base: ctxV1.WETH.options.address,
pairContract: ctxV1.WETH_USDC
}];
await logGas(await calcRoute(ctxV2, decimalStr('1'), 0.1, routes, pairs), ctxV2.sendParam(trader, '1'), "wrap eth and directly swap first")
await logGas(await calcRoute(ctxV2, decimalStr('1'), 0.1, routes, pairs), ctxV2.sendParam(trader, '1'), "wrap eth and directly swap second")
var a_ETH = await ctxV1.Web3.eth.getBalance(trader)
var a_WETH = await ctxV1.WETH.methods.balanceOf(trader).call()
var a_USDC = await ctxV1.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 ctxV1.Web3.eth.getBalance(ctxV2.DODOProxyV2.options.address)
var c_WETH = await ctxV1.WETH.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_USDT = await ctxV1.USDT.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_USDC = await ctxV1.USDC.methods.balanceOf(ctxV2.DODOProxyV2.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 ctxV1.Web3.eth.getBalance(ctxV1.WETH.options.address)
console.log("weth contract After:" + fromWei(a_w_eth, 'ether'))
assert(a_USDC, "869508322");
});
it("ETH to USDT wrap eth and two hops swap", async () => {
var b_ETH = await ctxV1.Web3.eth.getBalance(trader)
var b_WETH = await ctxV1.WETH.methods.balanceOf(trader).call()
var b_USDT = await ctxV1.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 ctxV1.Web3.eth.getBalance(ctxV1.WETH.options.address)
console.log("weth contract Before:" + fromWei(b_w_eth, 'ether'))
//set route path
var routes = [{
address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
decimals: 18
}, {
address: ctxV1.USDC.options.address,
decimals: 6
}, {
address: ctxV1.USDT.options.address,
decimals: 6
}];
var pairs = [{
pair: ctxV1.WETH_USDC.options.address,
base: ctxV1.WETH.options.address,
pairContract: ctxV1.WETH_USDC
}, {
pair: ctxV1.USDT_USDC.options.address,
base: ctxV1.USDT.options.address,
pairContract: ctxV1.USDT_USDC
}];
await logGas(await calcRoute(ctxV2, decimalStr('1'), 0.1, routes, pairs), ctxV2.sendParam(trader, '1'), "wrap eth and two hops swap first")
await logGas(await calcRoute(ctxV2, decimalStr('1'), 0.1, routes, pairs), ctxV2.sendParam(trader, '1'), "wrap eth and two hops swap second")
var a_ETH = await ctxV1.Web3.eth.getBalance(trader)
var a_WETH = await ctxV1.WETH.methods.balanceOf(trader).call()
var a_USDT = await ctxV1.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 ctxV1.Web3.eth.getBalance(ctxV2.DODOProxyV2.options.address)
var c_WETH = await ctxV1.WETH.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_USDT = await ctxV1.USDT.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_USDC = await ctxV1.USDC.methods.balanceOf(ctxV2.DODOProxyV2.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 ctxV1.Web3.eth.getBalance(ctxV1.WETH.options.address)
console.log("weth contract After:" + fromWei(a_w_eth, 'ether'))
assert(a_USDT, "866832169");
});
it("DODO to ETH unwrap eth and three hops swap", async () => {
var b_DODO = await ctxV1.DODO.methods.balanceOf(trader).call()
var b_ETH = await ctxV1.Web3.eth.getBalance(trader)
var b_WETH = await ctxV1.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 ctxV1.Web3.eth.getBalance(ctxV1.WETH.options.address)
console.log("weth contract Before:" + fromWei(b_w_eth, 'ether'))
//approve DODO entry
await ctxV1.DODO.methods.approve(ctxV2.DODOApprove.options.address, MAX_UINT256).send(ctxV2.sendParam(trader))
//set route path
var routes = [{
address: ctxV1.DODO.options.address,
decimals: 18
}, {
address: ctxV1.USDT.options.address,
decimals: 6
}, {
address: ctxV1.USDC.options.address,
decimals: 6
}, {
address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
decimals: 18
}];
var pairs = [{
pair: ctxV1.DODO_USDT.options.address,
base: ctxV1.DODO.options.address,
pairContract: ctxV1.DODO_USDT
}, {
pair: ctxV1.USDT_USDC.options.address,
base: ctxV1.USDT.options.address,
pairContract: ctxV1.USDT_USDC
}, {
pair: ctxV1.WETH_USDC.options.address,
base: ctxV1.WETH.options.address,
pairContract: ctxV1.WETH_USDC
}];
var tx = await logGas(await calcRoute(ctxV2, decimalStr('100'), 0.1, routes, pairs), ctxV2.sendParam(trader), "unwrap eth and three hops swap first")
var tx = await logGas(await calcRoute(ctxV2, decimalStr('100'), 0.1, routes, pairs), ctxV2.sendParam(trader), "unwrap eth and three hops swap second")
var a_ETH = await ctxV1.Web3.eth.getBalance(trader)
var a_WETH = await ctxV1.WETH.methods.balanceOf(trader).call()
var a_DODO = await ctxV1.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 ctxV1.Web3.eth.getBalance(ctxV2.DODOProxyV2.options.address)
var c_WETH = await ctxV1.WETH.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_USDT = await ctxV1.USDT.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_USDC = await ctxV1.USDC.methods.balanceOf(ctxV2.DODOProxyV2.options.address).call()
var c_DODO = await ctxV1.DODO.methods.balanceOf(ctxV2.DODOProxyV2.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 ctxV1.Web3.eth.getBalance(ctxV1.WETH.options.address)
console.log("weth contract After:" + fromWei(w_eth, 'ether'))
assert(tx.events['OrderHistory'].returnValues['returnAmount'], "22004556829826281");
});
});
});

216
test/V2Proxy/proxy.cp.test.ts Normal file
View File

@@ -0,0 +1,216 @@
/*
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';
import { Contract } from 'web3-eth-contract';
let project: string;
let buyer1: string;
let buyer2: string;
async function init(ctx: ProxyContext): Promise<void> {
project = ctx.SpareAccounts[1];
buyer1 = ctx.SpareAccounts[2];
buyer2 = ctx.SpareAccounts[3];
await ctx.mintTestToken(project, ctx.DODO, decimalStr("1000000"));
await ctx.mintTestToken(buyer1, ctx.USDT, mweiStr("10000"));
await ctx.mintTestToken(buyer2, ctx.USDT, mweiStr("10000"));
await ctx.approveProxy(project);
await ctx.approveProxy(buyer1);
await ctx.approveProxy(buyer2);
}
async function initCreateCP(ctx: ProxyContext, token0: string, token1: string, token0Amount: string, timeLine: number[], valueList: string[]): Promise<string> {
await ctx.DODOProxyV2.methods.createCrowdPooling(
token0,
token1,
token0Amount,
timeLine,
valueList,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
).send(ctx.sendParam(project, "0.2"));
if (token0 == '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') token0 = ctx.WETH.options.address;
if (token1 == '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE') token1 = ctx.WETH.options.address;
var addr = await ctx.CPFactory.methods._REGISTRY_(token0, token1, 0).call();
return addr;
}
function delay(ms: number) {
return new Promise(resolve => setTimeout(resolve, ms));
}
describe("DODOProxyV2.0", () => {
let snapshotId: string;
let ctx: ProxyContext;
let cp_DODO_USDT: string;
let cp_DODO_WETH: string;
let CP_DODO_USDT: Contract;
let CP_DODO_WETH: Contract;
before(async () => {
let ETH = await contracts.newContract(
contracts.WETH_CONTRACT_NAME
);
ctx = await getProxyContext(ETH.options.address);
await init(ctx);
var timeLine = [
Math.floor(new Date().getTime() / 1000) + 10,
60 * 60 * 24,
0,
60 * 60 * 24 * 30,
0
]
var valueList = [
mweiStr("10000"),
decimalStr("0"),
mweiStr("10"),
decimalStr("1")
]
cp_DODO_USDT = await initCreateCP(ctx, ctx.DODO.options.address, ctx.USDT.options.address, decimalStr("100000"), timeLine, valueList);
CP_DODO_USDT = contracts.getContractWithAddress(contracts.CROWD_POOLING_NAME, cp_DODO_USDT);
console.log("cp_DODO_USDT:", cp_DODO_USDT);
cp_DODO_WETH = await initCreateCP(ctx, ctx.DODO.options.address, ctx.WETH.options.address, decimalStr("100000"), timeLine, valueList);
CP_DODO_WETH = contracts.getContractWithAddress(contracts.CROWD_POOLING_NAME, cp_DODO_WETH);
console.log("cp_DODO_WETH:", cp_DODO_WETH);
console.log("Wait to bid start...");
await delay(11000);
});
beforeEach(async () => {
snapshotId = await ctx.EVM.snapshot();
});
afterEach(async () => {
await ctx.EVM.reset(snapshotId);
});
describe("DODOProxy", () => {
it("createCP", async () => {
var baseToken = ctx.DODO.options.address;
var quoteToken = ctx.USDT.options.address;
var baseAmount = decimalStr("1");
var timeLine = [
Math.floor(new Date().getTime() / 1000) + 10,
60 * 60 * 24,
0,
60 * 60 * 24 * 30,
0
]
var valueList = [
mweiStr("5"),
decimalStr("0"),
mweiStr("10"),
decimalStr("1")
]
await logGas(await ctx.DODOProxyV2.methods.createCrowdPooling(
baseToken,
quoteToken,
baseAmount,
timeLine,
valueList,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(project, "0.2"), "createCP");
var addrs = await ctx.CPFactory.methods.getCrowdPooling(baseToken, quoteToken).call();
assert.equal(
await ctx.DODO.methods.balanceOf(addrs[1]).call(),
baseAmount
);
});
it("bid", async () => {
var b_base = await ctx.DODO.methods.balanceOf(cp_DODO_USDT).call();
var b_quote = await ctx.USDT.methods.balanceOf(cp_DODO_USDT).call();
var b_lp_1 = await CP_DODO_USDT.methods.getShares(buyer1).call();
var b_lp_2 = await CP_DODO_USDT.methods.getShares(buyer2).call();
assert.equal(b_base, decimalStr("100000"));
assert.equal(b_quote, mweiStr("0"));
assert.equal(b_lp_1, decimalStr("0"));
assert.equal(b_lp_2, decimalStr("0"));
await logGas(await ctx.DODOProxyV2.methods.bid(
cp_DODO_USDT,
mweiStr("50"),
0,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(buyer1), "bid");
await logGas(await ctx.DODOProxyV2.methods.bid(
cp_DODO_USDT,
mweiStr("80"),
0,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(buyer2), "bid");
await logGas(await ctx.DODOProxyV2.methods.bid(
cp_DODO_USDT,
mweiStr("80"),
0,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(buyer2), "bid");
await logGas(await ctx.DODOProxyV2.methods.bid(
cp_DODO_USDT,
mweiStr("80"),
0,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(buyer2), "bid");
var a_base = await ctx.DODO.methods.balanceOf(cp_DODO_USDT).call();
var a_quote = await ctx.USDT.methods.balanceOf(cp_DODO_USDT).call();
var a_lp_1 = await CP_DODO_USDT.methods.getShares(buyer1).call();
var a_lp_2 = await CP_DODO_USDT.methods.getShares(buyer2).call();
assert.equal(a_base, decimalStr("100000"));
assert.equal(a_quote, mweiStr("290"));
assert.equal(a_lp_1, mweiStr("50"));
assert.equal(a_lp_2, mweiStr("240"));
});
it("bid - ETH", async () => {
var b_base = await ctx.DODO.methods.balanceOf(cp_DODO_WETH).call();
var b_quote = await ctx.WETH.methods.balanceOf(cp_DODO_WETH).call();
var b_lp_1 = await CP_DODO_WETH.methods.getShares(buyer1).call();
var b_lp_2 = await CP_DODO_WETH.methods.getShares(buyer2).call();
assert.equal(b_base, decimalStr("100000"));
assert.equal(b_quote, decimalStr("0"));
assert.equal(b_lp_1, decimalStr("0"));
assert.equal(b_lp_2, decimalStr("0"));
await logGas(await ctx.DODOProxyV2.methods.bid(
cp_DODO_WETH,
decimalStr("2"),
1,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(buyer1, "2"), "bid");
await logGas(await ctx.DODOProxyV2.methods.bid(
cp_DODO_WETH,
decimalStr("1"),
1,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(buyer2, "1"), "bid");
var a_base = await ctx.DODO.methods.balanceOf(cp_DODO_WETH).call();
var a_quote = await ctx.WETH.methods.balanceOf(cp_DODO_WETH).call();
var a_lp_1 = await CP_DODO_WETH.methods.getShares(buyer1).call();
var a_lp_2 = await CP_DODO_WETH.methods.getShares(buyer2).call();
assert.equal(a_base, decimalStr("100000"));
assert.equal(a_quote, decimalStr("3"));
assert.equal(a_lp_1, decimalStr("2"));
assert.equal(a_lp_2, decimalStr("1"));
});
});
});

418
test/V2Proxy/proxy.dpp.test.ts Normal file
View File

@@ -0,0 +1,418 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
import BigNumber from "bignumber.js";
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';
import { Contract } from 'web3-eth-contract';
let lp: string;
let project: string;
let trader: string;
let config = {
lpFeeRate: decimalStr("0.002"),
k: decimalStr("0.1"),
i: decimalStr("1"),
};
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.mintTestToken(lp, ctx.USDC, mweiStr("1000000"));
await ctx.mintTestToken(project, ctx.USDC, 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;
}
describe("DODOProxyV2.0", () => {
let snapshotId: string;
let ctx: ProxyContext;
let dpp_DODO_USDT: string;
let dpp_WETH_USDT: string;
let dpp_WETH_USDC: string;
let dpp_USDT_USDC: string;
let DPP_DODO_USDT: Contract;
let DPP_WETH_USDT: Contract;
let DPP_WETH_USDC: Contract;
let DPP_USDT_USDC: Contract;
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"));
DPP_DODO_USDT = contracts.getContractWithAddress(contracts.DPP_NAME, dpp_DODO_USDT);
dpp_USDT_USDC = await initCreateDPP(ctx, ctx.USDT.options.address, ctx.USDC.options.address, mweiStr("100000"), mweiStr("100000"), "0", decimalStr("1"));
DPP_USDT_USDC = contracts.getContractWithAddress(contracts.DPP_NAME, dpp_USDT_USDC);
dpp_WETH_USDC = await initCreateDPP(ctx, '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', ctx.USDC.options.address, decimalStr("5"), mweiStr("3000"), "5", mweiStr("600"));
DPP_WETH_USDC = contracts.getContractWithAddress(contracts.DPP_NAME, dpp_WETH_USDC);
dpp_WETH_USDT = await initCreateDPP(ctx, '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', ctx.USDT.options.address, decimalStr("5"), mweiStr("3000"), "5", mweiStr("600"));
DPP_WETH_USDT = contracts.getContractWithAddress(contracts.DPP_NAME, dpp_WETH_USDT);
console.log("dpp_DODO_USDT:", dpp_DODO_USDT);
console.log("dpp_WETH_USDT:", dpp_WETH_USDT);
console.log("dpp_WETH_USDC:", dpp_WETH_USDC);
console.log("dpp_USDT_USDC:", dpp_USDT_USDC);
});
beforeEach(async () => {
snapshotId = await ctx.EVM.snapshot();
});
afterEach(async () => {
await ctx.EVM.reset(snapshotId);
});
describe("DODOProxy", () => {
it("createDPP", async () => {
var baseToken = ctx.DODO.options.address;
var quoteToken = ctx.USDT.options.address;
var baseAmount = decimalStr("10000");
var quoteAmount = mweiStr("10000");
await logGas(await ctx.DODOProxyV2.methods.createDODOPrivatePool(
baseToken,
quoteToken,
baseAmount,
quoteAmount,
config.lpFeeRate,
config.i,
config.k,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(project), "createDPP");
var addrs = await ctx.DPPFactory.methods.getPrivatePool(baseToken, quoteToken).call();
assert.equal(
await ctx.DODO.methods.balanceOf(addrs[1]).call(),
baseAmount
);
assert.equal(
await ctx.USDT.methods.balanceOf(addrs[1]).call(),
quoteAmount
);
});
// it("createDPP - ETH", async () => {
// var baseToken = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
// var quoteToken = ctx.USDT.options.address;
// var baseAmount = decimalStr("5");
// var quoteAmount = mweiStr("10000");
// await logGas(await ctx.DODOProxyV2.methods.createDODOPrivatePool(
// baseToken,
// quoteToken,
// baseAmount,
// quoteAmount,
// config.lpFeeRate,
// config.i,
// config.k,
// Math.floor(new Date().getTime()/1000 + 60 * 10)
// ),ctx.sendParam(project, "5"),"createDPP - Wrap ETH");
// var addrs = await ctx.DPPFactory.methods.getPrivatePool(ctx.WETH.options.address,quoteToken).call();
// assert.equal(
// await ctx.WETH.methods.balanceOf(addrs[1]).call(),
// baseAmount
// );
// assert.equal(
// await ctx.USDT.methods.balanceOf(addrs[1]).call(),
// quoteAmount
// );
// });
it("resetDPP", async () => {
var beforeState = await DPP_DODO_USDT.methods.getPMMState().call();
assert.equal(beforeState.K, config.k);
assert.equal(beforeState.B, decimalStr("100000"));
assert.equal(beforeState.Q, mweiStr("20000"));
await logGas(await ctx.DODOProxyV2.methods.resetDODOPrivatePool(
dpp_DODO_USDT,
[config.lpFeeRate, mweiStr("0.2"), decimalStr("0.2")],
[decimalStr("1000"), mweiStr("1000"), decimalStr("0"), mweiStr("0")],
0,
decimalStr("100000"),
mweiStr("0"),
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(project), "resetDPP");
var afterState = await DPP_DODO_USDT.methods.getPMMState().call();
assert.equal(afterState.K, decimalStr("0.2"));
assert.equal(afterState.B, decimalStr("101000"));
assert.equal(afterState.Q, mweiStr("21000"));
});
it("resetDPP - OutETH", async () => {
var beforeState = await DPP_WETH_USDT.methods.getPMMState().call();
assert.equal(beforeState.K, config.k);
assert.equal(beforeState.B0, decimalStr("5"));
assert.equal(beforeState.Q0, mweiStr("3000"));
var b_ETH = await ctx.Web3.eth.getBalance(project);
await logGas(await ctx.DODOProxyV2.methods.resetDODOPrivatePool(
dpp_WETH_USDT,
[config.lpFeeRate, mweiStr("600"), decimalStr("0.2")],
[decimalStr("0"), mweiStr("100"), decimalStr("1"), mweiStr("0")],
3,
decimalStr("0"),
mweiStr("0"),
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(project), "resetDPP-OutETH");
var afterState = await DPP_WETH_USDT.methods.getPMMState().call();
assert.equal(afterState.K, decimalStr("0.2"));
assert.equal(afterState.B0, decimalStr("4"));
assert.equal(afterState.Q0, mweiStr("3100"));
var a_ETH = await ctx.Web3.eth.getBalance(project);
console.log("b_ETH:", b_ETH);
console.log("a_ETH:", a_ETH);
assert.equal(new BigNumber(b_ETH).isGreaterThan(new BigNumber(a_ETH).minus(decimalStr("1"))), true);
});
it("resetDPP - InETH", async () => {
var beforeState = await DPP_WETH_USDT.methods.getPMMState().call();
assert.equal(beforeState.K, config.k);
assert.equal(beforeState.B0, decimalStr("5"));
assert.equal(beforeState.Q0, mweiStr("3000"));
var b_ETH = await ctx.Web3.eth.getBalance(project);
await logGas(await ctx.DODOProxyV2.methods.resetDODOPrivatePool(
dpp_WETH_USDT,
[config.lpFeeRate, mweiStr("600"), decimalStr("0.2")],
[decimalStr("1"), mweiStr("100"), decimalStr("0"), mweiStr("0")],
1,
decimalStr("0"),
mweiStr("0"),
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(project, "1"), "resetDPP-InETH");
var afterState = await DPP_WETH_USDT.methods.getPMMState().call();
assert.equal(afterState.K, decimalStr("0.2"));
assert.equal(afterState.B0, decimalStr("6"));
assert.equal(afterState.Q0, mweiStr("3100"));
var a_ETH = await ctx.Web3.eth.getBalance(project);
console.log("b_ETH:", b_ETH);
console.log("a_ETH:", a_ETH);
assert.equal(new BigNumber(b_ETH).isGreaterThan(new BigNumber(a_ETH).plus(decimalStr("1"))), true);
});
it("swap - one jump", async () => {
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("1000"));
var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var b_USDT = await ctx.USDT.methods.balanceOf(trader).call();
var dodoPairs = [
dpp_DODO_USDT
]
var directions = 0
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.USDT.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - one jump first");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var a_USDT = await ctx.USDT.methods.balanceOf(trader).call();
// console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
// console.log("b_USDT:" + b_USDT + " a_USDT:" + a_USDT);
assert.equal(a_DOOD, decimalStr("500"));
assert.equal(a_USDT, "99749900");
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.USDT.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - one jump second");
});
it("swap - two jump", 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,
dpp_WETH_USDT
]
var directions = 2
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.WETH.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - two jump first");
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, "165350643050738035");
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.WETH.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - two jump second");
});
it("swap - two jump - inETH", async () => {
var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var b_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var b_ETH = await ctx.Web3.eth.getBalance(trader);
var dodoPairs = [
dpp_WETH_USDT,
dpp_DODO_USDT
]
var directions = 2
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2ETHToToken(
ctx.DODO.options.address,
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader, "1"), "swap - two jump - inETH first");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var a_ETH = await ctx.Web3.eth.getBalance(trader);
// console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
// console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH);
// console.log("b_ETH:" + b_ETH + " a_ETH:" + a_ETH);
assert.equal(a_DOOD, "2908497423869401229986");
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2ETHToToken(
ctx.DODO.options.address,
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader, "1"), "swap - two jump - inETH second");
});
it("swap - two jump - outETH", 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 b_ETH = await ctx.Web3.eth.getBalance(trader);
var dodoPairs = [
dpp_DODO_USDT,
dpp_WETH_USDT
]
var directions = 2
var tx = await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToETH(
ctx.DODO.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - two jump - outETH - first");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var a_ETH = await ctx.Web3.eth.getBalance(trader);
// console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
// console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH);
// console.log("b_ETH:" + b_ETH + " a_ETH:" + a_ETH);
assert.equal(a_DOOD, decimalStr("500"));
assert.equal(
tx.events['OrderHistory'].returnValues['returnAmount'],
"165350643050738035"
)
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToETH(
ctx.DODO.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - two jump - outETH - second");
});
it("swap - three jump", 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,
dpp_USDT_USDC,
dpp_WETH_USDC
]
var directions = 4
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.WETH.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - three jump first");
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, "165004688801375425");
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.WETH.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - three jump second");
});
});
});

450
test/V2Proxy/proxy.dvm.test.ts Normal file
View File

@@ -0,0 +1,450 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
import BigNumber from "bignumber.js";
import { decimalStr, MAX_UINT256, 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';
import { Contract } from 'web3-eth-contract';
let lp: string;
let project: string;
let trader: string;
let config = {
lpFeeRate: decimalStr("0.003"),
k: decimalStr("0.1"),
i: decimalStr("1"),
};
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.mintTestToken(lp, ctx.USDC, mweiStr("1000000"));
await ctx.mintTestToken(project, ctx.USDC, mweiStr("1000000"));
await ctx.approveProxy(lp);
await ctx.approveProxy(project);
await ctx.approveProxy(trader);
}
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(
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 dvm_DODO_USDT: string;
let dvm_USDT_USDC: string;
let dvm_WETH_USDT: string;
let dvm_WETH_USDC: string;
let DVM_DODO_USDT: Contract;
let DVM_USDT_USDC: Contract;
let DVM_WETH_USDT: Contract;
let DVM_WETH_USDC: Contract;
before(async () => {
let ETH = await contracts.newContract(
contracts.WETH_CONTRACT_NAME
);
ctx = await getProxyContext(ETH.options.address);
await init(ctx);
dvm_DODO_USDT = await initCreateDVM(ctx, ctx.DODO.options.address, ctx.USDT.options.address, decimalStr("100000"), mweiStr("20000"), "0", mweiStr("0.2"));
DVM_DODO_USDT = contracts.getContractWithAddress(contracts.DVM_NAME, dvm_DODO_USDT);
dvm_USDT_USDC = await initCreateDVM(ctx, ctx.USDT.options.address, ctx.USDC.options.address, mweiStr("100000"), mweiStr("1000"), "0", decimalStr("1"));
DVM_USDT_USDC = contracts.getContractWithAddress(contracts.DVM_NAME, dvm_USDT_USDC);
dvm_WETH_USDT = await initCreateDVM(ctx, '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', ctx.USDT.options.address, decimalStr("5"), mweiStr("3000"), "5", mweiStr("600"));
DVM_WETH_USDT = contracts.getContractWithAddress(contracts.DVM_NAME, dvm_WETH_USDT);
dvm_WETH_USDC = await initCreateDVM(ctx, '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE', ctx.USDC.options.address, decimalStr("5"), mweiStr("3000"), "5", mweiStr("600"));
DVM_WETH_USDC = contracts.getContractWithAddress(contracts.DVM_NAME, dvm_WETH_USDC);
console.log("dvm_DODO_USDT:", dvm_DODO_USDT);
console.log("dvm_USDT_USDC:", dvm_USDT_USDC);
console.log("dvm_WETH_USDT:", dvm_WETH_USDT);
console.log("dvm_WETH_USDC:", dvm_WETH_USDC);
});
beforeEach(async () => {
snapshotId = await ctx.EVM.snapshot();
});
afterEach(async () => {
await ctx.EVM.reset(snapshotId);
});
describe("DODOProxy", () => {
it("createDVM", async () => {
var baseToken = ctx.DODO.options.address;
var quoteToken = ctx.USDT.options.address;
var baseAmount = decimalStr("10000");
var quoteAmount = mweiStr("10000");
await logGas(await ctx.DODOProxyV2.methods.createDODOVendingMachine(
baseToken,
quoteToken,
baseAmount,
quoteAmount,
config.lpFeeRate,
config.i,
config.k,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(project), "createDVM");
var addrs = await ctx.DVMFactory.methods.getVendingMachine(baseToken, quoteToken).call();
assert.equal(
await ctx.DODO.methods.balanceOf(addrs[1]).call(),
baseAmount
);
assert.equal(
await ctx.USDT.methods.balanceOf(addrs[1]).call(),
quoteAmount
);
});
// it("createDVM - ETH", async () => {
// var baseToken = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
// var quoteToken = ctx.USDT.options.address;
// var baseAmount = decimalStr("5");
// var quoteAmount = mweiStr("10000");
// await logGas(await ctx.DODOProxyV2.methods.createDODOVendingMachine(
// baseToken,
// quoteToken,
// baseAmount,
// quoteAmount,
// config.lpFeeRate,
// config.i,
// config.k,
// Math.floor(new Date().getTime() / 1000 + 60 * 10)
// ), ctx.sendParam(project, '5'), "createDVM - Wrap ETH");
// var addrs = await ctx.DVMFactory.methods.getVendingMachine(ctx.WETH.options.address, quoteToken).call();
// assert.equal(
// await ctx.WETH.methods.balanceOf(addrs[1]).call(),
// baseAmount
// );
// assert.equal(
// await ctx.USDT.methods.balanceOf(addrs[1]).call(),
// quoteAmount
// );
// });
it("addLiquidity", async () => {
var b_baseReserve = await DVM_DODO_USDT.methods._BASE_RESERVE_().call();
var b_quoteReserve = await DVM_DODO_USDT.methods._QUOTE_RESERVE_().call();
var b_dlp = await DVM_DODO_USDT.methods.balanceOf(lp).call();
assert.equal(b_baseReserve, decimalStr("100000"));
assert.equal(b_quoteReserve, mweiStr("20000"));
assert.equal(b_dlp, decimalStr("0"));
await logGas(await ctx.DODOProxyV2.methods.addDVMLiquidity(
dvm_DODO_USDT,
decimalStr("1000"),
mweiStr("300"),
decimalStr("0"),
mweiStr("0"),
0,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(lp), "addLiquidity");
var a_baseReserve = await DVM_DODO_USDT.methods._BASE_RESERVE_().call();
var a_quoteReserve = await DVM_DODO_USDT.methods._QUOTE_RESERVE_().call();
var a_dlp = await DVM_DODO_USDT.methods.balanceOf(lp).call();
assert.equal(a_baseReserve, decimalStr("101000"));
assert.equal(a_quoteReserve, mweiStr("20200"));
assert.equal(a_dlp, "1000000000000000000000");
});
it("addLiquidity - ETH", async () => {
var b_baseReserve = await DVM_WETH_USDT.methods._BASE_RESERVE_().call();
var b_quoteReserve = await DVM_WETH_USDT.methods._QUOTE_RESERVE_().call();
var b_dlp = await DVM_WETH_USDT.methods.balanceOf(lp).call();
assert.equal(b_baseReserve, decimalStr("5"));
assert.equal(b_quoteReserve, mweiStr("3000"));
assert.equal(b_dlp, decimalStr("0"));
await logGas(await ctx.DODOProxyV2.methods.addDVMLiquidity(
dvm_WETH_USDT,
decimalStr("1"),
mweiStr("6000"),
decimalStr("0"),
mweiStr("0"),
1,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(lp, '1'), "addLiquidity - ETH");
var a_baseReserve = await DVM_WETH_USDT.methods._BASE_RESERVE_().call();
var a_quoteReserve = await DVM_WETH_USDT.methods._QUOTE_RESERVE_().call();
var a_dlp = await DVM_WETH_USDT.methods.balanceOf(lp).call();
assert.equal(a_baseReserve, decimalStr("6"));
assert.equal(a_quoteReserve, mweiStr("3600"));
assert.equal(a_dlp, "1000000000000000000");
});
it("sellShares - ETH helper", async () => {
var b_baseReserve = await DVM_WETH_USDT.methods._BASE_RESERVE_().call();
var b_quoteReserve = await DVM_WETH_USDT.methods._QUOTE_RESERVE_().call();
var b_dlp = await DVM_WETH_USDT.methods.balanceOf(project).call();
var b_WETH = await ctx.WETH.methods.balanceOf(project).call();
var b_USDT = await ctx.USDT.methods.balanceOf(project).call();
var b_ETH = await ctx.Web3.eth.getBalance(project);
// console.log("b_baseReserve:" + b_baseReserve + " b_quoteReserve:" + b_quoteReserve + " b_dlp:" + b_dlp + " b_WETH:" + b_WETH + " b_USDT:" + b_USDT + " b_ETH:" + b_ETH);
await logGas(await DVM_WETH_USDT.methods.sellShares(
decimalStr("1"),
ctx.DODOCalleeHelper.options.address,
decimalStr("0"),
mweiStr("0"),
'0x00',
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(project), "sellShares - ETH helper");
var a_baseReserve = await DVM_WETH_USDT.methods._BASE_RESERVE_().call();
var a_quoteReserve = await DVM_WETH_USDT.methods._QUOTE_RESERVE_().call();
var a_dlp = await DVM_WETH_USDT.methods.balanceOf(project).call();
var a_WETH = await ctx.WETH.methods.balanceOf(project).call();
var a_USDT = await ctx.USDT.methods.balanceOf(project).call();
var a_ETH = await ctx.Web3.eth.getBalance(project);
// console.log("a_baseReserve:" + a_baseReserve + " a_quoteReserve:" + a_quoteReserve + " a_dlp:" + a_dlp + " a_WETH:" + a_WETH + " a_USDT:" + a_USDT + " a_ETH:" + a_ETH);
assert.equal(a_baseReserve, decimalStr("4"));
assert.equal(a_quoteReserve, mweiStr("2400"));
assert.equal(a_dlp, decimalStr("4"));
assert.equal(a_WETH, decimalStr("0"));
assert.equal(a_USDT, mweiStr("877600"));
assert.equal(new BigNumber(b_ETH).isGreaterThan(new BigNumber(a_ETH).minus(decimalStr("1"))), true);
})
it("sellShares - Without ETH helper", async () => {
var b_baseReserve = await DVM_WETH_USDT.methods._BASE_RESERVE_().call();
var b_quoteReserve = await DVM_WETH_USDT.methods._QUOTE_RESERVE_().call();
var b_dlp = await DVM_WETH_USDT.methods.balanceOf(project).call();
var b_WETH = await ctx.WETH.methods.balanceOf(project).call();
var b_USDT = await ctx.USDT.methods.balanceOf(project).call();
var b_ETH = await ctx.Web3.eth.getBalance(project);
// console.log("b_baseReserve:" + b_baseReserve + " b_quoteReserve:" + b_quoteReserve + " b_dlp:" + b_dlp + " b_WETH:" + b_WETH + " b_USDT:" + b_USDT + " b_ETH:" + b_ETH);
await logGas(await DVM_WETH_USDT.methods.sellShares(
decimalStr("1"),
project,
decimalStr("0"),
mweiStr("0"),
'0x',
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(project), "sellShares - Without ETH helper");
var a_baseReserve = await DVM_WETH_USDT.methods._BASE_RESERVE_().call();
var a_quoteReserve = await DVM_WETH_USDT.methods._QUOTE_RESERVE_().call();
var a_dlp = await DVM_WETH_USDT.methods.balanceOf(project).call();
var a_WETH = await ctx.WETH.methods.balanceOf(project).call();
var a_USDT = await ctx.USDT.methods.balanceOf(project).call();
var a_ETH = await ctx.Web3.eth.getBalance(project);
// console.log("a_baseReserve:" + a_baseReserve + " a_quoteReserve:" + a_quoteReserve + " a_dlp:" + a_dlp + " a_WETH:" + a_WETH + " a_USDT:" + a_USDT + " a_ETH:" + a_ETH);
assert.equal(a_baseReserve, decimalStr("4"));
assert.equal(a_quoteReserve, mweiStr("2400"));
assert.equal(a_dlp, decimalStr("4"));
assert.equal(a_WETH, decimalStr("1"));
assert.equal(a_USDT, mweiStr("877600"));
})
it("swap - one jump", async () => {
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("1000"));
var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var b_USDT = await ctx.USDT.methods.balanceOf(trader).call();
var dodoPairs = [
dvm_DODO_USDT
]
var directions = 0
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.USDT.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - one jump first");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var a_USDT = await ctx.USDT.methods.balanceOf(trader).call();
// console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
// console.log("b_USDT:" + b_USDT + " a_USDT:" + a_USDT);
assert.equal(a_DOOD, decimalStr("500"));
assert.equal(a_USDT, "126151370");
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.USDT.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - one jump second");
});
it("swap - two jump", 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 = [
dvm_DODO_USDT,
dvm_WETH_USDT
]
var directions = 2
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.WETH.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - two jump first");
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, "163816613646287588");
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.WETH.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - two jump second");
});
it("swap - two jump - inETH", async () => {
var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var b_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var b_ETH = await ctx.Web3.eth.getBalance(trader);
var dodoPairs = [
dvm_WETH_USDT,
dvm_DODO_USDT
]
var directions = 2
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2ETHToToken(
ctx.DODO.options.address,
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader, "1"), "swap - two jump - inETH - first");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var a_ETH = await ctx.Web3.eth.getBalance(trader);
// console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
// console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH);
// console.log("b_ETH:" + b_ETH + " a_ETH:" + a_ETH);
assert.equal(a_DOOD, "2814340111190341070680");
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2ETHToToken(
ctx.DODO.options.address,
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader, "1"), "swap - two jump - inETH - second");
});
it("swap - two jump - outETH", async () => {
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("2000"));
var dodoPairs = [
dvm_DODO_USDT,
dvm_WETH_USDT
]
var directions = 2
var tx = await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToETH(
ctx.DODO.options.address,
decimalStr("1000"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - two jump - outETH first");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
assert.equal(a_DOOD, decimalStr("1000"));
assert.equal(
tx.events['OrderHistory'].returnValues['returnAmount'],
"323865907568573497"
)
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToETH(
ctx.DODO.options.address,
decimalStr("1000"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - two jump - outETH second");
});
it("swap - three jump", async () => {
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("1000"));
var dodoPairs = [
dvm_DODO_USDT,
dvm_USDT_USDC,
dvm_WETH_USDC
]
var directions = 4
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.WETH.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - three jump first");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call();
assert.equal(a_DOOD, decimalStr("500"));
assert.equal(a_WETH, "163633965833613187");
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.WETH.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - three jump second");
});
});
});

264
test/V2Proxy/proxy.incentive.test.ts Normal file
View File

@@ -0,0 +1,264 @@
/*
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(
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;
}
async function initIncentive(ctx: ProxyContext): Promise<void> {
var blockNum = await ctx.Web3.eth.getBlockNumber();
await ctx.DODOIncentive.methods.switchIncentive(blockNum + 1).send(ctx.sendParam(ctx.Deployer));
await ctx.mintTestToken(ctx.DODOIncentive.options.address, ctx.DODO, decimalStr("1000000"));
}
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);
await initIncentive(ctx);
});
beforeEach(async () => {
snapshotId = await ctx.EVM.snapshot();
});
afterEach(async () => {
await ctx.EVM.reset(snapshotId);
});
describe("DODOIncentive", () => {
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:" + totalReward + "; Total distribution:" + totalDistribution + "; BlockNumber:" + blockNum);
//Aim to increase block
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
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:" + totalReward + "; Total distribution:" + totalDistribution + "; BlockNumber:" + blockNum);
//Aim to increase block
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
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.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
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:" + totalReward + "; Total distribution:" + totalDistribution + "; 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:" + totalReward + "; Total distribution:" + totalDistribution + "; BlockNumber:" + blockNum);
//Aim to increase block
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
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:" + totalReward + "; Total distribution:" + totalDistribution + "; BlockNumber:" + blockNum);
//Aim to increase block
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000"));
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:" + totalReward + "; Total distribution:" + totalDistribution + "; BlockNumber:" + blockNum);
assert(totalReward, decimalStr("140"));
});
it("tigger - incentive", async () => {
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("2000"));
var b_DODO = await ctx.DODO.methods.balanceOf(trader).call()
var b_USDT = await ctx.USDT.methods.balanceOf(trader).call()
console.log("Before DODO:" + b_DODO + "; USDT:" + b_USDT);
var b_totalReward = await ctx.DODOIncentive.methods.totalReward().call();
var b_totalDistribution = await ctx.DODOIncentive.methods.totalDistribution().call();
console.log("Before Total Reward:" + b_totalReward + "; Total distribution:" + b_totalDistribution)
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:" + a_DODO + "; USDT:" + a_USDT);
var dodoPairs = [
dpp_DODO_USDT
]
var directions = 0
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.USDT.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap without incentive first");
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.USDT.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "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:" + a_DODO + "; USDT:" + a_USDT);
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.USDT.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
true,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap with incentive first");
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToToken(
ctx.DODO.options.address,
ctx.USDT.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
true,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "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:" + a_totalReward + "; Total distribution:" + a_totalDistribution)
a_DODO = await ctx.DODO.methods.balanceOf(trader).call()
a_USDT = await ctx.USDT.methods.balanceOf(trader).call()
console.log("After Incentive DODO:" + a_DODO + "; USDT:" + a_USDT);
assert(a_DODO, "1095000000000000000");
});
});
});

192
test/V2Proxy/proxy.mix.test.ts Normal file
View File

@@ -0,0 +1,192 @@
/*
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(
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("DODOProxy", () => {
it("swap - two jump", 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(
ctx.DODO.options.address,
ctx.WETH.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
false,
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");
});
it("swap - two jump - inETH", async () => {
var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var b_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var b_ETH = await ctx.Web3.eth.getBalance(trader);
var dodoPairs = [
dvm_WETH_USDT,
dpp_DODO_USDT
]
var directions = 2
await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2ETHToToken(
ctx.DODO.options.address,
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader, "1"), "swap - two jump - inETH");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var a_ETH = await ctx.Web3.eth.getBalance(trader);
console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH);
console.log("b_ETH:" + b_ETH + " a_ETH:" + a_ETH);
assert.equal(a_DOOD, "3589987832148472935171");
});
it("swap - two jump - outETH", async () => {
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("100000"));
var b_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var b_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var b_ETH = await ctx.Web3.eth.getBalance(trader);
var dodoPairs = [
dpp_DODO_USDT,
dvm_WETH_USDT
]
var directions = 2
var tx = await logGas(await ctx.DODOProxyV2.methods.dodoSwapV2TokenToETH(
ctx.DODO.options.address,
decimalStr("10000"),
1,
dodoPairs,
directions,
false,
Math.floor(new Date().getTime() / 1000 + 60 * 10)
), ctx.sendParam(trader), "swap - two jump - outETH");
var a_DOOD = await ctx.DODO.methods.balanceOf(trader).call();
var a_WETH = await ctx.WETH.methods.balanceOf(trader).call();
var a_ETH = await ctx.Web3.eth.getBalance(trader);
console.log("b_DOOD:" + b_DOOD + " a_DODO:" + a_DOOD);
console.log("b_WETH:" + b_WETH + " a_WETH:" + a_WETH);
console.log("b_ETH:" + b_ETH + " a_ETH:" + a_ETH);
assert.equal(a_DOOD, decimalStr("90000"));
assert.equal(
tx.events['OrderHistory'].returnValues['returnAmount'],
"2131271397594357833"
)
});
});
});