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

dvm proxy test ing

Browse Source
This commit is contained in:
owen05
2020-11-26 21:03:36 +08:00
parent 3a7fe02ab0
commit e3637fe022
8 changed files with 546 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
test/Proxy/proxy.dpp.test.ts
View File

@@ -7,7 +7,7 @@
// import * as assert from 'assert';
import BigNumber from "bignumber.js";
import { decimalStr, mweiStr} from '../utils/Converter';
import { decimalStr, mweiStr } from '../utils/Converter';
import { logGas } from '../utils/Log';
import { ProxyContext, getProxyContext } from '../utils/ProxyContext';
import { assert } from 'chai';
@@ -30,12 +30,11 @@ async function init(ctx: ProxyContext): Promise<void> {
project = ctx.SpareAccounts[1];
trader = ctx.SpareAccounts[2];
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("100000"));
await ctx.mintTestToken(project, ctx.DODO, decimalStr("100000"));
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("100000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000000"));
await ctx.mintTestToken(project, ctx.DODO, decimalStr("1000000"));
await ctx.mintTestToken(lp, ctx.USDT, mweiStr("100000"));
await ctx.mintTestToken(project, ctx.USDT, mweiStr("100000"));
await ctx.mintTestToken(lp, ctx.USDT, mweiStr("1000000"));
await ctx.mintTestToken(project, ctx.USDT, mweiStr("1000000"));
// await ctx.WETH.methods.deposit().send(ctx.sendParam(lp, '80'));
// await ctx.WETH.methods.deposit().send(ctx.sendParam(project, '80'));
@@ -46,7 +45,7 @@ async function init(ctx: ProxyContext): Promise<void> {
}
async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string): Promise<string> {
async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string,i:string): Promise<string> {
let PROXY = ctx.DODOProxy;
await PROXY.methods.createDODOPrivatePool(
token0,
@@ -55,7 +54,7 @@ async function initCreateDPP(ctx: ProxyContext, token0: string, token1:string, t
token1Amount,
config.lpFeeRate,
config.mtFeeRate,
config.i,
i,
config.k,
Math.floor(new Date().getTime()/1000 + 60 * 10)
).send(ctx.sendParam(project,ethValue));
@@ -76,9 +75,9 @@ describe("DODOProxyV2.0", () => {
before(async () => {
ctx = await getProxyContext();
await init(ctx);
dpp_DODO_USDT = await initCreateDPP(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("10000"),mweiStr("10000"), "0");
dpp_DODO_USDT = await initCreateDPP(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("100000"),mweiStr("30000"), "0",mweiStr("0.3"));
DPP_DODO_USDT = contracts.getContractWithAddress(contracts.DPP_NAME,dpp_DODO_USDT);
dpp_WETH_USDT = await initCreateDPP(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("5"),mweiStr("10000"),"5");
dpp_WETH_USDT = await initCreateDPP(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("5"),mweiStr("30000"),"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);
@@ -110,17 +109,17 @@ describe("DODOProxyV2.0", () => {
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(project),"createDPP");
var addrs = await ctx.DPPFactory.methods.getPrivatePool(baseToken,quoteToken).call();
var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[0]).call();
var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[1]).call();
assert.equal(
dppInfo[0],
project
);
assert.equal(
await ctx.DODO.methods.balanceOf(addrs[0]).call(),
await ctx.DODO.methods.balanceOf(addrs[1]).call(),
baseAmount
);
assert.equal(
await ctx.USDT.methods.balanceOf(addrs[0]).call(),
await ctx.USDT.methods.balanceOf(addrs[1]).call(),
quoteAmount
);
});
@@ -143,17 +142,17 @@ describe("DODOProxyV2.0", () => {
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();
var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[0]).call();
var dppInfo = await ctx.DPPFactory.methods._DPP_INFO_(addrs[1]).call();
assert.equal(
dppInfo[0],
project
);
assert.equal(
await ctx.WETH.methods.balanceOf(addrs[0]).call(),
await ctx.WETH.methods.balanceOf(addrs[1]).call(),
baseAmount
);
assert.equal(
await ctx.USDT.methods.balanceOf(addrs[0]).call(),
await ctx.USDT.methods.balanceOf(addrs[1]).call(),
quoteAmount
);
});
@@ -161,13 +160,13 @@ describe("DODOProxyV2.0", () => {
it("resetDPP", async () => {
var beforeState = await DPP_DODO_USDT.methods.getPMMState().call();
assert.equal(beforeState.K,config.k);
assert.equal(beforeState.B0,decimalStr("10000"));
assert.equal(beforeState.Q0,mweiStr("10000"));
assert.equal(beforeState.B0,decimalStr("100000"));
assert.equal(beforeState.Q0,mweiStr("30000"));
await logGas(await ctx.DODOProxy.methods.resetDODOPrivatePool(
dpp_DODO_USDT,
config.lpFeeRate,
config.mtFeeRate,
config.i,
mweiStr("0.3"),
decimalStr("0.2"),
decimalStr("1000"),
mweiStr("1000"),
@@ -177,21 +176,22 @@ describe("DODOProxyV2.0", () => {
),ctx.sendParam(project),"resetDPP");
var afterState = await DPP_DODO_USDT.methods.getPMMState().call();
assert.equal(afterState.K,decimalStr("0.2"));
assert.equal(afterState.B0,decimalStr("11000"));
assert.equal(afterState.Q0,mweiStr("11000"));
assert.equal(afterState.B0,decimalStr("101000"));
assert.equal(afterState.Q0,mweiStr("31000"));
});
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("10000"));
assert.equal(beforeState.Q0,mweiStr("30000"));
var b_ETH = await ctx.Web3.eth.getBalance(project);
var tx = await logGas(await ctx.DODOProxy.methods.resetDODOPrivatePoolETH(
dpp_WETH_USDT,
config.lpFeeRate,
config.mtFeeRate,
config.i,
mweiStr("600"),
decimalStr("0.2"),
decimalStr("0"),
mweiStr("1000"),
@@ -199,16 +199,172 @@ describe("DODOProxyV2.0", () => {
mweiStr("0"),
3,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(project),"resetDPP-ETH");
),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("11000"));
assert.equal(afterState.Q0,mweiStr("31000"));
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(a_ETH).isGreaterThan(new BigNumber(b_ETH)),true);
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("30000"));
var b_ETH = await ctx.Web3.eth.getBalance(project);
var tx = await logGas(await ctx.DODOProxy.methods.resetDODOPrivatePoolETH(
dpp_WETH_USDT,
config.lpFeeRate,
config.mtFeeRate,
mweiStr("600"),
decimalStr("0.2"),
decimalStr("1"),
mweiStr("1000"),
decimalStr("0"),
mweiStr("0"),
1,
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("31000"));
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 hop", 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
]
var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken(
trader,
ctx.DODO.options.address,
ctx.USDT.options.address,
decimalStr("500"),
1,
dodoPairs,
directions,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(trader),"swap - one hop");
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,"149474924");
});
it("swap - two hop", 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 = [
0,
1
]
var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToToken(
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 hop");
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,"247088894507188480");
});
it("swap - two hop - 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 = [
0,
1
]
var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapETHToToken(
trader,
ctx.DODO.options.address,
decimalStr("1"),
1,
dodoPairs,
directions,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(trader,"1"),"swap - two hop - 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,"1979965731049456633086");
});
it("swap - two hop - 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,
dpp_WETH_USDT
]
var directions = [
0,
1
]
var tx = await logGas(await ctx.DODOProxy.methods.dodoSwapTokenToETH(
trader,
ctx.DODO.options.address,
decimalStr("10000"),
1,
dodoPairs,
directions,
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(trader),"swap - two hop - 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'],
"3760778358599649282"
)
});
});
});

211
test/Proxy/proxy.dvm.test.ts
View File

@@ -6,11 +6,13 @@
*/
// import * as assert from 'assert';
import { decimalStr, mweiStr} from '../utils/Converter';
import BigNumber from "bignumber.js";
import { decimalStr, mweiStr } from '../utils/Converter';
import { logGas } from '../utils/Log';
import { ProxyContext, getProxyContext } from '../utils/ProxyContext';
import { assert } from 'chai';
import * as contracts from '../utils/Contracts';
import { Contract } from 'web3-eth-contract';
let lp: string;
let project: string;
@@ -27,46 +29,59 @@ async function init(ctx: ProxyContext): Promise<void> {
lp = ctx.SpareAccounts[0];
project = ctx.SpareAccounts[1];
trader = ctx.SpareAccounts[2];
await ctx.approveProxy(lp);
await ctx.approveProxy(project);
await ctx.approveProxy(trader);
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("100000"));
await ctx.mintTestToken(project, ctx.DODO, decimalStr("100000"));
await ctx.mintTestToken(trader, ctx.DODO, decimalStr("100000"));
await ctx.mintTestToken(lp, ctx.DODO, decimalStr("1000000"));
await ctx.mintTestToken(project, ctx.DODO, decimalStr("1000000"));
await ctx.mintTestToken(lp, ctx.USDT, mweiStr("100000"));
await ctx.mintTestToken(project, ctx.USDT, mweiStr("100000"));
await ctx.mintTestToken(lp, ctx.USDT, mweiStr("1000000"));
await ctx.mintTestToken(project, ctx.USDT, mweiStr("1000000"));
// await ctx.WETH.methods.deposit().send(ctx.sendParam(lp, '80'));
// await ctx.WETH.methods.deposit().send(ctx.sendParam(project, '80'));
await ctx.approveProxy(lp);
await ctx.approveProxy(project);
await ctx.approveProxy(trader);
}
async function initCreateDVM(ctx: ProxyContext, token0: any, token1:any, token0Amount: string, token1Amount: string): Promise<void> {
async function initCreateDVM(ctx: ProxyContext, token0: string, token1:string, token0Amount: string, token1Amount: string, ethValue:string,i:string): Promise<string> {
let PROXY = ctx.DODOProxy;
await PROXY.methods.createDODOVendingMachine(
token0.options.address,
token1.options.address,
project,
token0,
token1,
token0Amount,
token1Amount,
config.lpFeeRate,
config.mtFeeRate,
config.i,
config.k,
Math.floor(new Date().getTime()/1000 + 60 * 10);
).send(ctx.sendParam(project));
Math.floor(new Date().getTime()/1000 + 60 * 10)
).send(ctx.sendParam(project,ethValue));
if(token0 == '0x000000000000000000000000000000000000000E') token0 = ctx.WETH.options.address;
if(token1 == '0x000000000000000000000000000000000000000E') 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_WETH_USDT: string;
let DVM_DODO_USDT: Contract;
let DVM_WETH_USDT: Contract;
before(async () => {
ctx = await getProxyContext();
await init(ctx);
// await initCreateDVM(ctx,ctx.DODO,ctx.USDT,decimalStr("10000"),decimalStr("10000"));
// await initCreateDVM(ctx,ctx.WETH,ctx.USDT,decimalStr("50"),decimalStr("10000"));
dvm_DODO_USDT = await initCreateDVM(ctx,ctx.DODO.options.address,ctx.USDT.options.address,decimalStr("100000"),mweiStr("30000"), "0",mweiStr("0.3"));
DVM_DODO_USDT = contracts.getContractWithAddress(contracts.DVM_NAME,dvm_DODO_USDT);
dvm_WETH_USDT = await initCreateDVM(ctx,'0x000000000000000000000000000000000000000E',ctx.USDT.options.address,decimalStr("5"),mweiStr("30000"),"5",mweiStr("600"));
DVM_WETH_USDT = contracts.getContractWithAddress(contracts.DVM_NAME,dvm_WETH_USDT);
console.log("dvm_DODO_USDT:",dvm_DODO_USDT);
console.log("dvm_WETH_USDT:",dvm_WETH_USDT);
});
beforeEach(async () => {
@@ -78,30 +93,149 @@ describe("DODOProxyV2.0", () => {
});
describe("DODOProxy", () => {
/**
* 1. 创建空池子
* 2. 创建ERC20 Token DVM
* 3. 创建ETH && ERC20 Token
*/
it("createDVM", async () => {
});
/**
* 1. 添加ERC20 Amount
* 2. 添加ERC20 + ETH
*/
it("addLiquidityToDVM", 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.DODOProxy.methods.createDODOVendingMachine(
project,
baseToken,
quoteToken,
baseAmount,
quoteAmount,
config.lpFeeRate,
config.mtFeeRate,
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();
var dvmInfo = await ctx.DVMFactory.methods._DVM_INFO_(addrs[1]).call();
assert.equal(
dvmInfo[0],
project
);
assert.equal(
await ctx.DODO.methods.balanceOf(addrs[1]).call(),
baseAmount
);
assert.equal(
await ctx.USDT.methods.balanceOf(addrs[1]).call(),
quoteAmount
);
});
/**
* 1. 移除ERC20 Amount
* 2. 移除ERC20 + ETH
*/
it("removeLiquidityToDVM", async () => {
it("createDVM - ETH", async () => {
var baseToken = '0x000000000000000000000000000000000000000E';
var quoteToken = ctx.USDT.options.address;
var baseAmount = decimalStr("5");
var quoteAmount = mweiStr("10000");
await logGas(await ctx.DODOProxy.methods.createDODOVendingMachine(
project,
baseToken,
quoteToken,
baseAmount,
quoteAmount,
config.lpFeeRate,
config.mtFeeRate,
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();
var dvmInfo = await ctx.DVMFactory.methods._DVM_INFO_(addrs[1]).call();
assert.equal(
dvmInfo[0],
project
);
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("30000"));
assert.equal(b_dlp,decimalStr("0"));
await logGas(await ctx.DODOProxy.methods.addDVMLiquidity(
dvm_DODO_USDT,
lp,
decimalStr("1000"),
mweiStr("300"),
decimalStr("0"),
mweiStr("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("30300"));
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("30000"));
assert.equal(b_dlp,decimalStr("0"));
await logGas(await ctx.DODOProxy.methods.addDVMLiquidityETH(
dvm_WETH_USDT,
lp,
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("36000"));
assert.equal(a_dlp,"1000000000000000000");
});
//TODO:ing
it("removeLiquidity", 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(project).call();
assert.equal(b_baseReserve,decimalStr("100000"));
assert.equal(b_quoteReserve,mweiStr("30000"));
console.log("b_dlp:" + b_dlp);
// assert.equal(b_dlp,decimalStr("0"));
await logGas(await ctx.DODOProxy.methods.removeDVMLiquidity(
dvm_DODO_USDT,
project,
decimalStr("100"),
decimalStr("0"),
mweiStr("0"),
Math.floor(new Date().getTime()/1000 + 60 * 10)
),ctx.sendParam(project),"removeLiquidity");
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(project).call();
// assert.equal(a_baseReserve,decimalStr("6"));
// assert.equal(a_quoteReserve,mweiStr("36000"));
// assert.equal(a_dlp,"1000000000000000000");
console.log("b_dlp:" + b_dlp + " a_dlp:" + a_dlp);
console.log("a_baseReserve:" + a_baseReserve + " a_quoteReserve:" + a_quoteReserve);
});
/**
@@ -112,10 +246,5 @@ describe("DODOProxyV2.0", () => {
});
/**
* 直接底层dvm操作测试
*/
});
});

7
test/utils/ProxyContext.ts
View File

@@ -10,7 +10,7 @@ import Web3 from 'web3';
import { Contract } from 'web3-eth-contract';
import * as contracts from './Contracts';
import { decimalStr, MAX_UINT256 } from './Converter';
import { decimalStr, mweiStr, MAX_UINT256 } from './Converter';
import { EVM, getDefaultWeb3 } from './EVM';
import * as log from './Log';
@@ -63,7 +63,7 @@ export class ProxyContext {
var permissionManagerTemplate = await contracts.newContract(contracts.PERMISSION_MANAGER_NAME)
var vauleSource = await contracts.newContract(contracts.EXTERNAL_VALUE_NAME)
var defaultGasSource = await contracts.newContract(contracts.EXTERNAL_VALUE_NAME)
await defaultGasSource.methods.init(this.Deployer,decimalStr("1000000"));
await defaultGasSource.methods.init(this.Deployer,MAX_UINT256).send(this.sendParam(this.Deployer));
this.DVMFactory = await contracts.newContract(contracts.DVM_FACTORY_NAME,
[
@@ -125,7 +125,8 @@ export class ProxyContext {
return {
from: sender,
gas: process.env["COVERAGE"] ? 10000000000 : 7000000,
gasPrice: process.env.GAS_PRICE,
// gasPrice: process.env.GAS_PRICE,
gasPrice: mweiStr("1000"),
value: decimalStr(value),
};
}