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

Allow ETH as quote in DODOEthProxy

Browse Source
This commit is contained in:
Michael Zhou
2020-09-07 18:08:27 +08:00
parent b83b940c49
commit 4bebaa9057
4 changed files with 616 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
test/DODOEthProxy.test.ts
View File

@@ -1,125 +0,0 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
import { DODOContext, getDODOContext, DefaultDODOContextInitConfig } from './utils/Context';
import * as contracts from "./utils/Contracts";
import * as assert from "assert"
import { decimalStr, MAX_UINT256 } from './utils/Converter';
import { Contract } from "web3-eth-contract";
import { logGas } from './utils/Log';
let lp: string
let trader: string
let DODOEthProxy: Contract
async function init(ctx: DODOContext): Promise<void> {
// switch ctx to eth proxy mode
let WETH = await contracts.newContract(contracts.WETH_CONTRACT_NAME)
await ctx.DODOZoo.methods.breedDODO(
ctx.Maintainer,
WETH.options.address,
ctx.QUOTE.options.address,
ctx.ORACLE.options.address,
DefaultDODOContextInitConfig.lpFeeRate,
DefaultDODOContextInitConfig.mtFeeRate,
DefaultDODOContextInitConfig.k,
DefaultDODOContextInitConfig.gasPriceLimit
).send(ctx.sendParam(ctx.Deployer))
ctx.DODO = await contracts.getContractWithAddress(contracts.DODO_CONTRACT_NAME, await ctx.DODOZoo.methods.getDODO(WETH.options.address, ctx.QUOTE.options.address).call())
ctx.BASE = WETH
ctx.BaseCapital = await contracts.getContractWithAddress(contracts.DODO_LP_TOKEN_CONTRACT_NAME, await ctx.DODO.methods._BASE_CAPITAL_TOKEN_().call())
DODOEthProxy = await contracts.newContract(contracts.DODO_ETH_PROXY_CONTRACT_NAME, [ctx.DODOZoo.options.address, WETH.options.address])
// env
lp = ctx.spareAccounts[0]
trader = ctx.spareAccounts[1]
await ctx.setOraclePrice(decimalStr("100"))
await ctx.approveDODO(lp)
await ctx.approveDODO(trader)
await ctx.QUOTE.methods.mint(lp, decimalStr("1000")).send(ctx.sendParam(ctx.Deployer))
await ctx.QUOTE.methods.mint(trader, decimalStr("1000")).send(ctx.sendParam(ctx.Deployer))
await ctx.QUOTE.methods.approve(DODOEthProxy.options.address, MAX_UINT256).send(ctx.sendParam(trader))
await ctx.DODO.methods.depositQuote(decimalStr("1000")).send(ctx.sendParam(lp))
}
describe("DODO ETH PROXY", () => {
let snapshotId: string
let ctx: DODOContext
before(async () => {
ctx = await getDODOContext()
await init(ctx)
await ctx.QUOTE.methods.approve(DODOEthProxy.options.address, MAX_UINT256).send(ctx.sendParam(trader))
})
beforeEach(async () => {
snapshotId = await ctx.EVM.snapshot();
let depositAmount = "10"
await DODOEthProxy.methods.depositEth(decimalStr(depositAmount), ctx.QUOTE.options.address).send(ctx.sendParam(lp, depositAmount))
});
afterEach(async () => {
await ctx.EVM.reset(snapshotId)
});
describe("buy&sell eth directly", () => {
it("buy", async () => {
let buyAmount = "1"
logGas(await DODOEthProxy.methods.buyEthWith(ctx.QUOTE.options.address, decimalStr(buyAmount), decimalStr("200")).send(ctx.sendParam(trader)), "buy with eth directly")
assert.equal(await ctx.DODO.methods._BASE_BALANCE_().call(), decimalStr("8.999"))
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "898581839502056240973")
ctx.Web3
})
it("sell", async () => {
let sellAmount = "1"
logGas(await DODOEthProxy.methods.sellEthTo(ctx.QUOTE.options.address, decimalStr(sellAmount), decimalStr("50")).send(ctx.sendParam(trader, sellAmount)), "sell to eth directly")
assert.equal(await ctx.DODO.methods._BASE_BALANCE_().call(), decimalStr("11"))
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "1098617454226610630663")
})
})
describe("withdraw eth directly", () => {
it("withdraw", async () => {
let baseLpTokenAddress = await ctx.DODO.methods._BASE_CAPITAL_TOKEN_().call()
let baseLpToken = contracts.getContractWithAddress(contracts.TEST_ERC20_CONTRACT_NAME, baseLpTokenAddress)
await baseLpToken.methods.approve(DODOEthProxy.options.address, MAX_UINT256).send(ctx.sendParam(lp))
await DODOEthProxy.methods.withdrawEth(decimalStr("5"), ctx.QUOTE.options.address).send(ctx.sendParam(lp))
assert.equal(await ctx.DODO.methods.getLpBaseBalance(lp).call(), decimalStr("5"))
// console.log(await ctx.Web3.eth.getBalance(lp)) eth balance confirmed
})
it("withdraw all", async () => {
let baseLpTokenAddress = await ctx.DODO.methods._BASE_CAPITAL_TOKEN_().call()
let baseLpToken = contracts.getContractWithAddress(contracts.TEST_ERC20_CONTRACT_NAME, baseLpTokenAddress)
await baseLpToken.methods.approve(DODOEthProxy.options.address, MAX_UINT256).send(ctx.sendParam(lp))
await DODOEthProxy.methods.withdrawAllEth(ctx.QUOTE.options.address).send(ctx.sendParam(lp))
assert.equal(await ctx.DODO.methods.getLpBaseBalance(lp).call(), "0")
// console.log(await ctx.Web3.eth.getBalance(lp)) eth balance confirmed
})
})
describe("revert cases", () => {
it("value not match", async () => {
await assert.rejects(
DODOEthProxy.methods.sellEthTo(ctx.QUOTE.options.address, decimalStr("1"), decimalStr("50")).send(ctx.sendParam(trader, "2")),
/ETH_AMOUNT_NOT_MATCH/
)
await assert.rejects(
DODOEthProxy.methods.depositEth(decimalStr("1"), ctx.QUOTE.options.address).send(ctx.sendParam(lp, "2")),
/ETH_AMOUNT_NOT_MATCH/
)
})
})
})

232
test/DODOEthProxyAsBase.test.ts Normal file
View File

@@ -0,0 +1,232 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
import * as assert from 'assert';
import { BigNumber } from 'bignumber.js';
import { TransactionReceipt } from 'web3-core';
import { Contract } from 'web3-eth-contract';
import {
DefaultDODOContextInitConfig,
DODOContext,
getDODOContext,
} from './utils/Context';
import * as contracts from './utils/Contracts';
import { decimalStr, MAX_UINT256 } from './utils/Converter';
import { logGas } from './utils/Log';
let lp: string;
let trader: string;
let DODOEthProxy: Contract;
async function init(ctx: DODOContext): Promise<void> {
// switch ctx to eth proxy mode
const WETH = await contracts.newContract(contracts.WETH_CONTRACT_NAME);
await ctx.DODOZoo.methods
.breedDODO(
ctx.Maintainer,
WETH.options.address,
ctx.QUOTE.options.address,
ctx.ORACLE.options.address,
DefaultDODOContextInitConfig.lpFeeRate,
DefaultDODOContextInitConfig.mtFeeRate,
DefaultDODOContextInitConfig.k,
DefaultDODOContextInitConfig.gasPriceLimit
)
.send(ctx.sendParam(ctx.Deployer));
ctx.DODO = contracts.getContractWithAddress(
contracts.DODO_CONTRACT_NAME,
await ctx.DODOZoo.methods
.getDODO(WETH.options.address, ctx.QUOTE.options.address)
.call()
);
ctx.BASE = WETH;
DODOEthProxy = await contracts.newContract(
contracts.DODO_ETH_PROXY_CONTRACT_NAME,
[ctx.DODOZoo.options.address, WETH.options.address]
);
// env
lp = ctx.spareAccounts[0];
trader = ctx.spareAccounts[1];
await ctx.setOraclePrice(decimalStr("100"));
await ctx.approveDODO(lp);
await ctx.approveDODO(trader);
await ctx.QUOTE.methods
.mint(lp, decimalStr("1000"))
.send(ctx.sendParam(ctx.Deployer));
await ctx.QUOTE.methods
.mint(trader, decimalStr("1000"))
.send(ctx.sendParam(ctx.Deployer));
await ctx.QUOTE.methods
.approve(DODOEthProxy.options.address, MAX_UINT256)
.send(ctx.sendParam(trader));
await ctx.DODO.methods
.depositQuote(decimalStr("1000"))
.send(ctx.sendParam(lp));
}
describe("DODO ETH PROXY", () => {
let snapshotId: string;
let ctx: DODOContext;
before(async () => {
ctx = await getDODOContext();
await init(ctx);
await ctx.QUOTE.methods
.approve(DODOEthProxy.options.address, MAX_UINT256)
.send(ctx.sendParam(trader));
});
beforeEach(async () => {
snapshotId = await ctx.EVM.snapshot();
const depositAmount = "10";
await DODOEthProxy.methods
.depositEthAsBase(decimalStr(depositAmount), ctx.QUOTE.options.address)
.send(ctx.sendParam(lp, depositAmount));
});
afterEach(async () => {
await ctx.EVM.reset(snapshotId);
});
describe("buy&sell eth directly", () => {
it("buy", async () => {
const buyAmount = "1";
logGas(
await DODOEthProxy.methods
.buyEthWithToken(
ctx.QUOTE.options.address,
decimalStr(buyAmount),
decimalStr("200")
)
.send(ctx.sendParam(trader)),
"buy ETH with token directly"
);
assert.strictEqual(
await ctx.DODO.methods._BASE_BALANCE_().call(),
decimalStr("8.999")
);
assert.strictEqual(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"898581839502056240973"
);
});
it("sell", async () => {
const sellAmount = "1";
logGas(
await DODOEthProxy.methods
.sellEthToToken(
ctx.QUOTE.options.address,
decimalStr(sellAmount),
decimalStr("50")
)
.send(ctx.sendParam(trader, sellAmount)),
"sell ETH to token directly"
);
assert.strictEqual(
await ctx.DODO.methods._BASE_BALANCE_().call(),
decimalStr("11")
);
assert.strictEqual(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"1098617454226610630663"
);
});
});
describe("withdraw eth directly", () => {
it("withdraw", async () => {
const withdrawAmount = decimalStr("5");
const baseLpTokenAddress = await ctx.DODO.methods
._BASE_CAPITAL_TOKEN_()
.call();
const baseLpToken = contracts.getContractWithAddress(
contracts.TEST_ERC20_CONTRACT_NAME,
baseLpTokenAddress
);
await baseLpToken.methods
.approve(DODOEthProxy.options.address, MAX_UINT256)
.send(ctx.sendParam(lp));
const lpEthBalanceBefore = await ctx.Web3.eth.getBalance(lp);
const txReceipt: TransactionReceipt = await DODOEthProxy.methods
.withdrawEthAsBase(withdrawAmount, ctx.QUOTE.options.address)
.send(ctx.sendParam(lp));
assert.strictEqual(
await ctx.DODO.methods.getLpBaseBalance(lp).call(),
withdrawAmount
);
const tx = await ctx.Web3.eth.getTransaction(txReceipt.transactionHash);
const ethSpentOnGas = new BigNumber(tx.gasPrice).times(txReceipt.gasUsed);
const lpEthBalanceAfter = await ctx.Web3.eth.getBalance(lp);
assert.ok(
new BigNumber(lpEthBalanceBefore)
.plus(withdrawAmount)
.minus(ethSpentOnGas)
.eq(lpEthBalanceAfter)
);
});
it("withdraw all", async () => {
const withdrawAmount = decimalStr("10");
const baseLpTokenAddress = await ctx.DODO.methods
._BASE_CAPITAL_TOKEN_()
.call();
const baseLpToken = contracts.getContractWithAddress(
contracts.TEST_ERC20_CONTRACT_NAME,
baseLpTokenAddress
);
await baseLpToken.methods
.approve(DODOEthProxy.options.address, MAX_UINT256)
.send(ctx.sendParam(lp));
const lpEthBalanceBefore = await ctx.Web3.eth.getBalance(lp);
const txReceipt: TransactionReceipt = await DODOEthProxy.methods
.withdrawAllEthAsBase(ctx.QUOTE.options.address)
.send(ctx.sendParam(lp));
assert.strictEqual(
await ctx.DODO.methods.getLpBaseBalance(lp).call(),
"0"
);
const tx = await ctx.Web3.eth.getTransaction(txReceipt.transactionHash);
const ethSpentOnGas = new BigNumber(tx.gasPrice).times(txReceipt.gasUsed);
const lpEthBalanceAfter = await ctx.Web3.eth.getBalance(lp);
assert.ok(
new BigNumber(lpEthBalanceBefore)
.plus(withdrawAmount)
.minus(ethSpentOnGas)
.eq(lpEthBalanceAfter)
);
});
});
describe("revert cases", () => {
it("value not match", async () => {
await assert.rejects(
DODOEthProxy.methods
.sellEthToToken(
ctx.QUOTE.options.address,
decimalStr("1"),
decimalStr("50")
)
.send(ctx.sendParam(trader, "2")),
/ETH_AMOUNT_NOT_MATCH/
);
await assert.rejects(
DODOEthProxy.methods
.depositEthAsBase(decimalStr("1"), ctx.QUOTE.options.address)
.send(ctx.sendParam(lp, "2")),
/ETH_AMOUNT_NOT_MATCH/
);
});
});
});

244
test/DODOEthProxyAsQuote.test.ts Normal file
View File

@@ -0,0 +1,244 @@
/*
Copyright 2020 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
import * as assert from 'assert';
import BigNumber from 'bignumber.js';
import { TransactionReceipt } from 'web3-core';
import { Contract } from 'web3-eth-contract';
import {
DefaultDODOContextInitConfig,
DODOContext,
getDODOContext,
} from './utils/Context';
import * as contracts from './utils/Contracts';
import { decimalStr, MAX_UINT256 } from './utils/Converter';
import { logGas } from './utils/Log';
let lp: string;
let trader: string;
let DODOEthProxy: Contract;
async function init(ctx: DODOContext): Promise<void> {
// switch ctx to eth proxy mode
const WETH = await contracts.newContract(contracts.WETH_CONTRACT_NAME);
await ctx.DODOZoo.methods
.breedDODO(
ctx.Maintainer,
ctx.BASE.options.address,
WETH.options.address,
ctx.ORACLE.options.address,
DefaultDODOContextInitConfig.lpFeeRate,
DefaultDODOContextInitConfig.mtFeeRate,
DefaultDODOContextInitConfig.k,
DefaultDODOContextInitConfig.gasPriceLimit
)
.send(ctx.sendParam(ctx.Deployer));
ctx.DODO = contracts.getContractWithAddress(
contracts.DODO_CONTRACT_NAME,
await ctx.DODOZoo.methods
.getDODO(ctx.BASE.options.address, WETH.options.address)
.call()
);
ctx.QUOTE = WETH;
DODOEthProxy = await contracts.newContract(
contracts.DODO_ETH_PROXY_CONTRACT_NAME,
[ctx.DODOZoo.options.address, WETH.options.address]
);
// env
lp = ctx.spareAccounts[0];
trader = ctx.spareAccounts[1];
await ctx.setOraclePrice(decimalStr("0.01"));
await ctx.approveDODO(lp);
await ctx.approveDODO(trader);
await ctx.BASE.methods
.mint(lp, decimalStr("1000"))
.send(ctx.sendParam(ctx.Deployer));
await ctx.BASE.methods
.mint(trader, decimalStr("1000"))
.send(ctx.sendParam(ctx.Deployer));
await ctx.BASE.methods
.approve(DODOEthProxy.options.address, MAX_UINT256)
.send(ctx.sendParam(trader));
await ctx.DODO.methods
.depositBase(decimalStr("1000"))
.send(ctx.sendParam(lp));
}
describe("DODO ETH PROXY", () => {
let snapshotId: string;
let ctx: DODOContext;
before(async () => {
ctx = await getDODOContext();
await init(ctx);
await ctx.BASE.methods
.approve(DODOEthProxy.options.address, MAX_UINT256)
.send(ctx.sendParam(trader));
});
beforeEach(async () => {
snapshotId = await ctx.EVM.snapshot();
let depositAmount = "10";
await DODOEthProxy.methods
.depositEthAsQuote(decimalStr(depositAmount), ctx.BASE.options.address)
.send(ctx.sendParam(lp, depositAmount));
});
afterEach(async () => {
await ctx.EVM.reset(snapshotId);
});
describe("buy&sell eth directly", () => {
it("buy", async () => {
const maxPayEthAmount = "2.1";
const ethInPoolBefore = decimalStr("10");
const traderEthBalanceBefore = await ctx.Web3.eth.getBalance(trader);
const txReceipt: TransactionReceipt = await DODOEthProxy.methods
.buyTokenWithEth(
ctx.BASE.options.address,
decimalStr("200"),
decimalStr(maxPayEthAmount)
)
.send(ctx.sendParam(trader, maxPayEthAmount));
logGas(txReceipt, "buy token with ETH directly");
const ethInPoolAfter = "12056338203652739553";
assert.strictEqual(
await ctx.DODO.methods._QUOTE_BALANCE_().call(),
ethInPoolAfter
);
assert.strictEqual(
await ctx.BASE.methods.balanceOf(trader).call(),
decimalStr("1200")
);
const tx = await ctx.Web3.eth.getTransaction(txReceipt.transactionHash);
const ethSpentOnGas = new BigNumber(tx.gasPrice).times(txReceipt.gasUsed);
const traderEthBalanceAfter = await ctx.Web3.eth.getBalance(trader);
const totalEthBefore = new BigNumber(traderEthBalanceBefore).plus(
ethInPoolBefore
);
const totalEthAfter = new BigNumber(traderEthBalanceAfter)
.plus(ethSpentOnGas)
.plus(ethInPoolAfter);
assert.ok(totalEthBefore.eq(totalEthAfter));
});
it("sell", async () => {
const minReceiveEthAmount = "0.45";
logGas(
await DODOEthProxy.methods
.sellTokenToEth(
ctx.BASE.options.address,
decimalStr("50"),
decimalStr(minReceiveEthAmount)
)
.send(ctx.sendParam(trader)),
"sell token to ETH directly"
);
assert.strictEqual(
await ctx.DODO.methods._QUOTE_BALANCE_().call(),
"9503598324131652490"
);
assert.strictEqual(
await ctx.BASE.methods.balanceOf(trader).call(),
decimalStr("950")
);
});
});
describe("withdraw eth directly", () => {
it("withdraw", async () => {
const withdrawAmount = decimalStr("5");
const quoteLpTokenAddress = await ctx.DODO.methods
._QUOTE_CAPITAL_TOKEN_()
.call();
const quoteLpToken = contracts.getContractWithAddress(
contracts.TEST_ERC20_CONTRACT_NAME,
quoteLpTokenAddress
);
await quoteLpToken.methods
.approve(DODOEthProxy.options.address, MAX_UINT256)
.send(ctx.sendParam(lp));
const lpEthBalanceBefore = await ctx.Web3.eth.getBalance(lp);
const txReceipt: TransactionReceipt = await DODOEthProxy.methods
.withdrawEthAsQuote(withdrawAmount, ctx.BASE.options.address)
.send(ctx.sendParam(lp));
assert.strictEqual(
await ctx.DODO.methods.getLpQuoteBalance(lp).call(),
withdrawAmount
);
const tx = await ctx.Web3.eth.getTransaction(txReceipt.transactionHash);
const ethSpentOnGas = new BigNumber(tx.gasPrice).times(txReceipt.gasUsed);
const lpEthBalanceAfter = await ctx.Web3.eth.getBalance(lp);
assert.ok(
new BigNumber(lpEthBalanceBefore)
.plus(withdrawAmount)
.minus(ethSpentOnGas)
.eq(lpEthBalanceAfter)
);
});
it("withdraw all", async () => {
const withdrawAmount = decimalStr("10");
const quoteLpTokenAddress = await ctx.DODO.methods
._QUOTE_CAPITAL_TOKEN_()
.call();
const quoteLpToken = contracts.getContractWithAddress(
contracts.TEST_ERC20_CONTRACT_NAME,
quoteLpTokenAddress
);
await quoteLpToken.methods
.approve(DODOEthProxy.options.address, MAX_UINT256)
.send(ctx.sendParam(lp));
const lpEthBalanceBefore = await ctx.Web3.eth.getBalance(lp);
const txReceipt: TransactionReceipt = await DODOEthProxy.methods
.withdrawAllEthAsQuote(ctx.BASE.options.address)
.send(ctx.sendParam(lp));
assert.strictEqual(
await ctx.DODO.methods.getLpQuoteBalance(lp).call(),
"0"
);
const tx = await ctx.Web3.eth.getTransaction(txReceipt.transactionHash);
const ethSpentOnGas = new BigNumber(tx.gasPrice).times(txReceipt.gasUsed);
const lpEthBalanceAfter = await ctx.Web3.eth.getBalance(lp);
assert.ok(
new BigNumber(lpEthBalanceBefore)
.plus(withdrawAmount)
.minus(ethSpentOnGas)
.eq(lpEthBalanceAfter)
);
});
});
describe("revert cases", () => {
it("value not match", async () => {
await assert.rejects(
DODOEthProxy.methods
.buyTokenWithEth(
ctx.BASE.options.address,
decimalStr("50"),
decimalStr("1")
)
.send(ctx.sendParam(trader, "2")),
/ETH_AMOUNT_NOT_MATCH/
);
await assert.rejects(
DODOEthProxy.methods
.depositEthAsQuote(decimalStr("1"), ctx.BASE.options.address)
.send(ctx.sendParam(lp, "2")),
/ETH_AMOUNT_NOT_MATCH/
);
});
});
});