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

Merge pull request #2 from Dominator008/fix-test

Browse Source 
Fix tests
This commit is contained in:
radar-bear
2020-09-08 23:45:08 +08:00
committed by GitHub
parent 06e4f00c9b e3ce9758e5
commit 1c366455ea
3 changed files with 1362 additions and 494 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1014
test/LiquidityProvider.test.ts
View File

File diff suppressed because it is too large Load Diff

662
test/Trader.test.ts
View File

@@ -5,277 +5,621 @@
*/ */
import * as assert from 'assert';
import { DODOContext, getDODOContext } from './utils/Context'; import { DODOContext, getDODOContext } from './utils/Context';
import { decimalStr } from './utils/Converter'; import { decimalStr } from './utils/Converter';
import { logGas } from './utils/Log'; import { logGas } from './utils/Log';
import * as assert from "assert"
let lp: string let lp: string;
let trader: string let trader: string;
async function init(ctx: DODOContext): Promise<void> { async function init(ctx: DODOContext): Promise<void> {
await ctx.setOraclePrice(decimalStr("100")) await ctx.setOraclePrice(decimalStr("100"));
lp = ctx.spareAccounts[0] lp = ctx.spareAccounts[0];
trader = ctx.spareAccounts[1] trader = ctx.spareAccounts[1];
await ctx.approveDODO(lp) await ctx.approveDODO(lp);
await ctx.approveDODO(trader) await ctx.approveDODO(trader);
await ctx.mintTestToken(lp, decimalStr("10"), decimalStr("1000")) await ctx.mintTestToken(lp, decimalStr("10"), decimalStr("1000"));
await ctx.mintTestToken(trader, decimalStr("10"), decimalStr("1000")) await ctx.mintTestToken(trader, decimalStr("10"), decimalStr("1000"));
await ctx.DODO.methods.depositBaseTo(lp, decimalStr("10")).send(ctx.sendParam(lp)) await ctx.DODO.methods
await ctx.DODO.methods.depositQuoteTo(lp, decimalStr("1000")).send(ctx.sendParam(lp)) .depositBaseTo(lp, decimalStr("10"))
.send(ctx.sendParam(lp));
await ctx.DODO.methods
.depositQuoteTo(lp, decimalStr("1000"))
.send(ctx.sendParam(lp));
} }
describe("Trader", () => { describe("Trader", () => {
let snapshotId: string;
let snapshotId: string let ctx: DODOContext;
let ctx: DODOContext
before(async () => { before(async () => {
ctx = await getDODOContext() ctx = await getDODOContext();
await init(ctx); await init(ctx);
}) });
beforeEach(async () => { beforeEach(async () => {
snapshotId = await ctx.EVM.snapshot(); snapshotId = await ctx.EVM.snapshot();
}); });
afterEach(async () => { afterEach(async () => {
await ctx.EVM.reset(snapshotId) await ctx.EVM.reset(snapshotId);
}); });
describe("R goes above ONE", () => { describe("R goes above ONE", () => {
it("buy when R equals ONE", async () => { it("buy when R equals ONE", async () => {
logGas(await ctx.DODO.methods.buyBaseToken(decimalStr("1"), decimalStr("110"), "0x").send(ctx.sendParam(trader)), "buy base token when balanced") await logGas(
ctx.DODO.methods.buyBaseToken(decimalStr("1"), decimalStr("110"), "0x"),
ctx.sendParam(trader),
"buy base token when balanced"
);
// trader balances // trader balances
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), decimalStr("11")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "898581839502056240973") await ctx.BASE.methods.balanceOf(trader).call(),
decimalStr("11")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"898581839502056240973"
);
// maintainer balances // maintainer balances
assert.equal(await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(), decimalStr("0.001")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(), decimalStr("0")) await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(),
decimalStr("0.001")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(),
decimalStr("0")
);
// dodo balances // dodo balances
assert.equal(await ctx.DODO.methods._BASE_BALANCE_().call(), decimalStr("8.999")) assert.equal(
assert.equal(await ctx.DODO.methods._QUOTE_BALANCE_().call(), "1101418160497943759027") await ctx.DODO.methods._BASE_BALANCE_().call(),
decimalStr("8.999")
);
assert.equal(
await ctx.DODO.methods._QUOTE_BALANCE_().call(),
"1101418160497943759027"
);
// price update // price update
assert.equal(await ctx.DODO.methods.getMidPrice().call(), "102353368821735563400") assert.equal(
}) await ctx.DODO.methods.getMidPrice().call(),
"102353368821735563400"
);
});
it("buy when R is ABOVE ONE", async () => { it("buy when R is ABOVE ONE", async () => {
await ctx.DODO.methods.buyBaseToken(decimalStr("1"), decimalStr("110"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
logGas(await ctx.DODO.methods.buyBaseToken(decimalStr("1"), decimalStr("130"), "0x").send(ctx.sendParam(trader)), "buy when R is ABOVE ONE") .buyBaseToken(decimalStr("1"), decimalStr("110"), "0x")
.send(ctx.sendParam(trader));
await logGas(
ctx.DODO.methods.buyBaseToken(decimalStr("1"), decimalStr("130"), "0x"),
ctx.sendParam(trader),
"buy when R is ABOVE ONE"
);
// trader balances // trader balances
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), decimalStr("12")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "794367183433412077653") await ctx.BASE.methods.balanceOf(trader).call(),
decimalStr("12")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"794367183433412077653"
);
// maintainer balances // maintainer balances
assert.equal(await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(), decimalStr("0.002")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(), decimalStr("0")) await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(),
decimalStr("0.002")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(),
decimalStr("0")
);
// dodo balances // dodo balances
assert.equal(await ctx.DODO.methods._BASE_BALANCE_().call(), decimalStr("7.998")) assert.equal(
assert.equal(await ctx.DODO.methods._QUOTE_BALANCE_().call(), "1205632816566587922347") await ctx.DODO.methods._BASE_BALANCE_().call(),
}) decimalStr("7.998")
);
assert.equal(
await ctx.DODO.methods._QUOTE_BALANCE_().call(),
"1205632816566587922347"
);
});
it("sell when R is ABOVE ONE", async () => { it("sell when R is ABOVE ONE", async () => {
await ctx.DODO.methods.buyBaseToken(decimalStr("1"), decimalStr("110"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
logGas(await ctx.DODO.methods.sellBaseToken(decimalStr("0.5"), decimalStr("40"), "0x").send(ctx.sendParam(trader)), "sell when R is ABOVE ONE") .buyBaseToken(decimalStr("1"), decimalStr("110"), "0x")
.send(ctx.sendParam(trader));
await logGas(
ctx.DODO.methods.sellBaseToken(
decimalStr("0.5"),
decimalStr("40"),
"0x"
),
ctx.sendParam(trader),
"sell when R is ABOVE ONE"
);
// trader balances // trader balances
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), decimalStr("10.5")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "949280846351657143136") await ctx.BASE.methods.balanceOf(trader).call(),
decimalStr("10.5")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"949280846351657143136"
);
// maintainer balances // maintainer balances
assert.equal(await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(), decimalStr("0.001")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(), "50851561534203512") await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(),
decimalStr("0.001")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(),
"50851561534203512"
);
// dodo balances // dodo balances
assert.equal(await ctx.DODO.methods._BASE_BALANCE_().call(), decimalStr("9.499")) assert.equal(
assert.equal(await ctx.DODO.methods._QUOTE_BALANCE_().call(), "1050668302086808653352") await ctx.DODO.methods._BASE_BALANCE_().call(),
}) decimalStr("9.499")
);
assert.equal(
await ctx.DODO.methods._QUOTE_BALANCE_().call(),
"1050668302086808653352"
);
});
it("sell when R is ABOVE ONE and RStatus back to ONE", async () => { it("sell when R is ABOVE ONE and RStatus back to ONE", async () => {
await ctx.DODO.methods.buyBaseToken(decimalStr("1"), decimalStr("110"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
logGas(await ctx.DODO.methods.sellBaseToken("1003002430889317763", decimalStr("90"), "0x").send(ctx.sendParam(trader)), "sell when R is ABOVE ONE and RStatus back to ONE") .buyBaseToken(decimalStr("1"), decimalStr("110"), "0x")
.send(ctx.sendParam(trader));
await logGas(
ctx.DODO.methods.sellBaseToken(
"1003002430889317763",
decimalStr("90"),
"0x"
),
ctx.sendParam(trader),
"sell when R is ABOVE ONE and RStatus back to ONE"
);
// R status // R status
assert.equal(await ctx.DODO.methods._R_STATUS_().call(), "0") assert.equal(await ctx.DODO.methods._R_STATUS_().call(), "0");
// trader balances // trader balances
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), "9996997569110682237") assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "999695745518506168723") await ctx.BASE.methods.balanceOf(trader).call(),
"9996997569110682237"
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"999695745518506168723"
);
// maintainer balances // maintainer balances
assert.equal(await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(), decimalStr("0.001")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(), "101418160497943759") await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(),
decimalStr("0.001")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(),
"101418160497943759"
);
// dodo balances // dodo balances
assert.equal(await ctx.DODO.methods._BASE_BALANCE_().call(), "10002002430889317763") assert.equal(
assert.equal(await ctx.DODO.methods._QUOTE_BALANCE_().call(), "1000202836320995887518") await ctx.DODO.methods._BASE_BALANCE_().call(),
"10002002430889317763"
);
assert.equal(
await ctx.DODO.methods._QUOTE_BALANCE_().call(),
"1000202836320995887518"
);
// target status // target status
assert.equal(await ctx.DODO.methods._TARGET_BASE_TOKEN_AMOUNT_().call(), "10002002430889317763") assert.equal(
assert.equal(await ctx.DODO.methods._TARGET_QUOTE_TOKEN_AMOUNT_().call(), "1000202836320995887518") await ctx.DODO.methods._TARGET_BASE_TOKEN_AMOUNT_().call(),
}) "10002002430889317763"
);
assert.equal(
await ctx.DODO.methods._TARGET_QUOTE_TOKEN_AMOUNT_().call(),
"1000202836320995887518"
);
});
it("sell when R is ABOVE ONE and RStatus becomes BELOW ONE", async () => { it("sell when R is ABOVE ONE and RStatus becomes BELOW ONE", async () => {
await ctx.DODO.methods.buyBaseToken(decimalStr("1"), decimalStr("110"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
logGas(await ctx.DODO.methods.sellBaseToken(decimalStr("2"), decimalStr("90"), "0x").send(ctx.sendParam(trader)), "sell when R is ABOVE ONE and RStatus becomes BELOW ONE [gas cost worst case]") .buyBaseToken(decimalStr("1"), decimalStr("110"), "0x")
.send(ctx.sendParam(trader));
await logGas(
ctx.DODO.methods.sellBaseToken(decimalStr("2"), decimalStr("90"), "0x"),
ctx.sendParam(trader),
"sell when R is ABOVE ONE and RStatus becomes BELOW ONE [gas cost worst case]"
);
// R status // R status
assert.equal(await ctx.DODO.methods._R_STATUS_().call(), "2") assert.equal(await ctx.DODO.methods._R_STATUS_().call(), "2");
// trader balances // trader balances
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), decimalStr("9")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "1098020621600061709144") await ctx.BASE.methods.balanceOf(trader).call(),
decimalStr("9")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"1098020621600061709144"
);
// maintainer balances // maintainer balances
assert.equal(await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(), decimalStr("0.001")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(), "200038898794388634") await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(),
decimalStr("0.001")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(),
"200038898794388634"
);
// dodo balances // dodo balances
assert.equal(await ctx.DODO.methods._BASE_BALANCE_().call(), decimalStr("10.999")) assert.equal(
assert.equal(await ctx.DODO.methods._QUOTE_BALANCE_().call(), "901779339501143902222") await ctx.DODO.methods._BASE_BALANCE_().call(),
decimalStr("10.999")
);
assert.equal(
await ctx.DODO.methods._QUOTE_BALANCE_().call(),
"901779339501143902222"
);
// target status // target status
assert.equal(await ctx.DODO.methods._TARGET_BASE_TOKEN_AMOUNT_().call(), "10002002430889317763") assert.equal(
assert.equal(await ctx.DODO.methods._TARGET_QUOTE_TOKEN_AMOUNT_().call(), "1000400077797588777268") await ctx.DODO.methods._TARGET_BASE_TOKEN_AMOUNT_().call(),
}) "10002002430889317763"
}) );
assert.equal(
await ctx.DODO.methods._TARGET_QUOTE_TOKEN_AMOUNT_().call(),
"1000400077797588777268"
);
});
});
describe("R goes below ONE", () => { describe("R goes below ONE", () => {
it("sell when R equals ONE", async () => { it("sell when R equals ONE", async () => {
logGas(await ctx.DODO.methods.sellBaseToken(decimalStr("1"), decimalStr("90"), "0x").send(ctx.sendParam(trader)), "sell base token when balanced") await logGas(
ctx.DODO.methods.sellBaseToken(decimalStr("1"), decimalStr("90"), "0x"),
ctx.sendParam(trader),
"sell base token when balanced"
);
// trader balances // trader balances
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), decimalStr("9")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "1098617454226610630663") await ctx.BASE.methods.balanceOf(trader).call(),
decimalStr("9")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"1098617454226610630663"
);
// maintainer balances // maintainer balances
assert.equal(await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(), "0") assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(), "98914196817061816") await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(),
"0"
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(),
"98914196817061816"
);
// dodo balances // dodo balances
assert.equal(await ctx.DODO.methods._BASE_BALANCE_().call(), decimalStr("11")) assert.equal(
assert.equal(await ctx.DODO.methods._QUOTE_BALANCE_().call(), "901283631576572307521") await ctx.DODO.methods._BASE_BALANCE_().call(),
decimalStr("11")
);
assert.equal(
await ctx.DODO.methods._QUOTE_BALANCE_().call(),
"901283631576572307521"
);
// price update // price update
assert.equal(await ctx.DODO.methods.getMidPrice().call(), "97736983274307939149") assert.equal(
}) await ctx.DODO.methods.getMidPrice().call(),
"97736983274307939149"
);
});
it("sell when R is BELOW ONE", async () => { it("sell when R is BELOW ONE", async () => {
await ctx.DODO.methods.sellBaseToken(decimalStr("3"), decimalStr("90"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
logGas(await ctx.DODO.methods.sellBaseToken(decimalStr("3"), decimalStr("90"), "0x").send(ctx.sendParam(trader)), "sell when R is BELOW ONE") .sellBaseToken(decimalStr("3"), decimalStr("90"), "0x")
.send(ctx.sendParam(trader));
await logGas(
ctx.DODO.methods.sellBaseToken(decimalStr("3"), decimalStr("90"), "0x"),
ctx.sendParam(trader),
"sell when R is BELOW ONE"
);
// trader balances // trader balances
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), decimalStr("4")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "1535961012052716726151") await ctx.BASE.methods.balanceOf(trader).call(),
decimalStr("4")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"1535961012052716726151"
);
// maintainer balances // maintainer balances
assert.equal(await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(), "0") assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(), "537573733252474148") await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(),
"0"
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(),
"537573733252474148"
);
// dodo balances // dodo balances
assert.equal(await ctx.DODO.methods._BASE_BALANCE_().call(), decimalStr("16")) assert.equal(
assert.equal(await ctx.DODO.methods._QUOTE_BALANCE_().call(), "463501414214030799701") await ctx.DODO.methods._BASE_BALANCE_().call(),
}) decimalStr("16")
);
assert.equal(
await ctx.DODO.methods._QUOTE_BALANCE_().call(),
"463501414214030799701"
);
});
it("buy when R is BELOW ONE", async () => { it("buy when R is BELOW ONE", async () => {
await ctx.DODO.methods.sellBaseToken(decimalStr("1"), decimalStr("90"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
logGas(await ctx.DODO.methods.buyBaseToken(decimalStr("0.5"), decimalStr("60"), "0x").send(ctx.sendParam(trader)), "buy when R is BELOW ONE") .sellBaseToken(decimalStr("1"), decimalStr("90"), "0x")
.send(ctx.sendParam(trader));
await logGas(
ctx.DODO.methods.buyBaseToken(
decimalStr("0.5"),
decimalStr("60"),
"0x"
),
ctx.sendParam(trader),
"buy when R is BELOW ONE"
);
// trader balances // trader balances
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), decimalStr("9.5")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "1049294316148665165453") await ctx.BASE.methods.balanceOf(trader).call(),
decimalStr("9.5")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"1049294316148665165453"
);
// maintainer balances // maintainer balances
assert.equal(await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(), decimalStr("0.0005")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(), "98914196817061816") await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(),
decimalStr("0.0005")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(),
"98914196817061816"
);
// dodo balances // dodo balances
assert.equal(await ctx.DODO.methods._BASE_BALANCE_().call(), decimalStr("10.4995")) assert.equal(
assert.equal(await ctx.DODO.methods._QUOTE_BALANCE_().call(), "950606769654517772731") await ctx.DODO.methods._BASE_BALANCE_().call(),
}) decimalStr("10.4995")
);
assert.equal(
await ctx.DODO.methods._QUOTE_BALANCE_().call(),
"950606769654517772731"
);
});
it("buy when R is BELOW ONE and RStatus back to ONE", async () => { it("buy when R is BELOW ONE and RStatus back to ONE", async () => {
await ctx.DODO.methods.sellBaseToken(decimalStr("1"), decimalStr("90"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
logGas(await ctx.DODO.methods.buyBaseToken("997008973080757728", decimalStr("110"), "0x").send(ctx.sendParam(trader)), "buy when R is BELOW ONE and RStatus back to ONE") .sellBaseToken(decimalStr("1"), decimalStr("90"), "0x")
.send(ctx.sendParam(trader));
await logGas(
ctx.DODO.methods.buyBaseToken(
"997008973080757728",
decimalStr("110"),
"0x"
),
ctx.sendParam(trader),
"buy when R is BELOW ONE and RStatus back to ONE"
);
// R status // R status
assert.equal(await ctx.DODO.methods._R_STATUS_().call(), "0") assert.equal(await ctx.DODO.methods._R_STATUS_().call(), "0");
// trader balances // trader balances
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), "9997008973080757728") assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "999703024198699411500") await ctx.BASE.methods.balanceOf(trader).call(),
"9997008973080757728"
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"999703024198699411500"
);
// maintainer balances // maintainer balances
assert.equal(await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(), "997008973080757") assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(), "98914196817061816") await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(),
"997008973080757"
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(),
"98914196817061816"
);
// dodo balances // dodo balances
assert.equal(await ctx.DODO.methods._BASE_BALANCE_().call(), "10001994017946161515") assert.equal(
assert.equal(await ctx.DODO.methods._QUOTE_BALANCE_().call(), "1000198061604483526684") await ctx.DODO.methods._BASE_BALANCE_().call(),
"10001994017946161515"
);
assert.equal(
await ctx.DODO.methods._QUOTE_BALANCE_().call(),
"1000198061604483526684"
);
// target status // target status
assert.equal(await ctx.DODO.methods._TARGET_BASE_TOKEN_AMOUNT_().call(), "10001994017946161515") assert.equal(
assert.equal(await ctx.DODO.methods._TARGET_QUOTE_TOKEN_AMOUNT_().call(), "1000198061604483526684") await ctx.DODO.methods._TARGET_BASE_TOKEN_AMOUNT_().call(),
}) "10001994017946161515"
);
assert.equal(
await ctx.DODO.methods._TARGET_QUOTE_TOKEN_AMOUNT_().call(),
"1000198061604483526684"
);
});
it("buy when R is BELOW ONE and RStatus becomes ABOVE ONE", async () => { it("buy when R is BELOW ONE and RStatus becomes ABOVE ONE", async () => {
await ctx.DODO.methods.sellBaseToken(decimalStr("1"), decimalStr("90"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
logGas(await ctx.DODO.methods.buyBaseToken(decimalStr("2"), decimalStr("220"), "0x").send(ctx.sendParam(trader)), "buy when R is BELOW ONE and RStatus becomes ABOVE ONE [gas cost worst case]") .sellBaseToken(decimalStr("1"), decimalStr("90"), "0x")
.send(ctx.sendParam(trader));
await logGas(
ctx.DODO.methods.buyBaseToken(decimalStr("2"), decimalStr("220"), "0x"),
ctx.sendParam(trader),
"buy when R is BELOW ONE and RStatus becomes ABOVE ONE [gas cost worst case]"
);
// R status // R status
assert.equal(await ctx.DODO.methods._R_STATUS_().call(), "1") assert.equal(await ctx.DODO.methods._R_STATUS_().call(), "1");
// trader balances // trader balances
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), decimalStr("11")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "897977789597854403796") await ctx.BASE.methods.balanceOf(trader).call(),
decimalStr("11")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"897977789597854403796"
);
// maintainer balances // maintainer balances
assert.equal(await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(), decimalStr("0.002")) assert.equal(
assert.equal(await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(), "98914196817061816") await ctx.BASE.methods.balanceOf(ctx.Maintainer).call(),
decimalStr("0.002")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(ctx.Maintainer).call(),
"98914196817061816"
);
// dodo balances // dodo balances
assert.equal(await ctx.DODO.methods._BASE_BALANCE_().call(), decimalStr("8.998")) assert.equal(
assert.equal(await ctx.DODO.methods._QUOTE_BALANCE_().call(), "1101923296205328534388") await ctx.DODO.methods._BASE_BALANCE_().call(),
decimalStr("8.998")
);
assert.equal(
await ctx.DODO.methods._QUOTE_BALANCE_().call(),
"1101923296205328534388"
);
// target status // target status
assert.equal(await ctx.DODO.methods._TARGET_BASE_TOKEN_AMOUNT_().call(), "10004000000000000000") assert.equal(
assert.equal(await ctx.DODO.methods._TARGET_QUOTE_TOKEN_AMOUNT_().call(), "1000198061604483526684") await ctx.DODO.methods._TARGET_BASE_TOKEN_AMOUNT_().call(),
}) "10004000000000000000"
}) );
assert.equal(
await ctx.DODO.methods._TARGET_QUOTE_TOKEN_AMOUNT_().call(),
"1000198061604483526684"
);
});
});
describe("Corner cases", () => { describe("Corner cases", () => {
it("buy or sell 0", async () => { it("buy or sell 0", async () => {
await ctx.DODO.methods.sellBaseToken(decimalStr("0"), decimalStr("0"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), decimalStr("10")) .sellBaseToken(decimalStr("0"), decimalStr("0"), "0x")
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), decimalStr("1000")) .send(ctx.sendParam(trader));
assert.equal(
await ctx.BASE.methods.balanceOf(trader).call(),
decimalStr("10")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
decimalStr("1000")
);
await ctx.DODO.methods.buyBaseToken(decimalStr("0"), decimalStr("0"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), decimalStr("10")) .buyBaseToken(decimalStr("0"), decimalStr("0"), "0x")
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), decimalStr("1000")) .send(ctx.sendParam(trader));
}) assert.equal(
await ctx.BASE.methods.balanceOf(trader).call(),
decimalStr("10")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
decimalStr("1000")
);
});
it("buy or sell a tiny amount", async () => { it("buy or sell a tiny amount", async () => {
// no precision problem // no precision problem
await ctx.DODO.methods.sellBaseToken("1", decimalStr("0"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), "9999999999999999999") .sellBaseToken("1", decimalStr("0"), "0x")
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "1000000000000000000100") .send(ctx.sendParam(trader));
assert.equal(
await ctx.BASE.methods.balanceOf(trader).call(),
"9999999999999999999"
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"1000000000000000000100"
);
// have precision problem, charge 0 // have precision problem, charge 0
await ctx.DODO.methods.buyBaseToken("1", decimalStr("1"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), "10000000000000000000") .buyBaseToken("1", decimalStr("1"), "0x")
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "1000000000000000000100") .send(ctx.sendParam(trader));
assert.equal(await ctx.DODO.methods._R_STATUS_().call(), "0") assert.equal(
await ctx.BASE.methods.balanceOf(trader).call(),
"10000000000000000000"
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"1000000000000000000100"
);
assert.equal(await ctx.DODO.methods._R_STATUS_().call(), "0");
// no precision problem if trading amount is extremely small // no precision problem if trading amount is extremely small
await ctx.DODO.methods.buyBaseToken("10", decimalStr("1"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
assert.equal(await ctx.BASE.methods.balanceOf(trader).call(), "10000000000000000010") .buyBaseToken("10", decimalStr("1"), "0x")
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "999999999999999999100") .send(ctx.sendParam(trader));
}) assert.equal(
await ctx.BASE.methods.balanceOf(trader).call(),
"10000000000000000010"
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(trader).call(),
"999999999999999999100"
);
});
it("sell a huge amount of base token", async () => { it("sell a huge amount of base token", async () => {
await ctx.mintTestToken(trader, decimalStr("10000"), "0") await ctx.mintTestToken(trader, decimalStr("10000"), "0");
await ctx.DODO.methods.sellBaseToken(decimalStr("10000"), "0", "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
.sellBaseToken(decimalStr("10000"), "0", "0x")
.send(ctx.sendParam(trader));
// nearly drain out quote pool // nearly drain out quote pool
// because the fee donated is greater than remaining quote pool // because the fee donated is greater than remaining quote pool
// quote lp earn a considerable profit // quote lp earn a considerable profit
assert.equal(await ctx.QUOTE.methods.balanceOf(trader).call(), "1996900220185135480813") assert.equal(
assert.equal(await ctx.DODO.methods.getLpQuoteBalance(lp).call(), "4574057156329524019750") await ctx.QUOTE.methods.balanceOf(trader).call(),
}) "1996900220185135480813"
}) );
assert.equal(
await ctx.DODO.methods.getLpQuoteBalance(lp).call(),
"4574057156329524019750"
);
});
});
describe("Revert cases", () => { describe("Revert cases", () => {
it("price limit", async () => { it("price limit", async () => {
await assert.rejects( await assert.rejects(
ctx.DODO.methods.buyBaseToken(decimalStr("1"), decimalStr("100"), "0x").send(ctx.sendParam(trader)), ctx.DODO.methods
.buyBaseToken(decimalStr("1"), decimalStr("100"), "0x")
.send(ctx.sendParam(trader)),
/BUY_BASE_COST_TOO_MUCH/ /BUY_BASE_COST_TOO_MUCH/
) );
await assert.rejects( await assert.rejects(
ctx.DODO.methods.sellBaseToken(decimalStr("1"), decimalStr("100"), "0x").send(ctx.sendParam(trader)), ctx.DODO.methods
.sellBaseToken(decimalStr("1"), decimalStr("100"), "0x")
.send(ctx.sendParam(trader)),
/SELL_BASE_RECEIVE_NOT_ENOUGH/ /SELL_BASE_RECEIVE_NOT_ENOUGH/
) );
}) });
it("base balance limit", async () => { it("base balance limit", async () => {
await assert.rejects( await assert.rejects(
ctx.DODO.methods.buyBaseToken(decimalStr("11"), decimalStr("10000"), "0x").send(ctx.sendParam(trader)), ctx.DODO.methods
.buyBaseToken(decimalStr("11"), decimalStr("10000"), "0x")
.send(ctx.sendParam(trader)),
/DODO_BASE_BALANCE_NOT_ENOUGH/ /DODO_BASE_BALANCE_NOT_ENOUGH/
) );
await ctx.DODO.methods.buyBaseToken(decimalStr("1"), decimalStr("200"), "0x").send(ctx.sendParam(trader)) await ctx.DODO.methods
.buyBaseToken(decimalStr("1"), decimalStr("200"), "0x")
.send(ctx.sendParam(trader));
await assert.rejects( await assert.rejects(
ctx.DODO.methods.buyBaseToken(decimalStr("11"), decimalStr("10000"), "0x").send(ctx.sendParam(trader)), ctx.DODO.methods
.buyBaseToken(decimalStr("11"), decimalStr("10000"), "0x")
.send(ctx.sendParam(trader)),
/DODO_BASE_BALANCE_NOT_ENOUGH/ /DODO_BASE_BALANCE_NOT_ENOUGH/
) );
}) });
}) });
}) });

180
test/UniswapArbitrageur.test.ts
View File

@@ -5,116 +5,172 @@
*/ */
import { DODOContext, getDODOContext } from './utils/Context'; import * as assert from 'assert';
import { decimalStr } from './utils/Converter';
import { logGas } from './utils/Log';
import * as assert from "assert"
import { newContract, UNISWAP_CONTRACT_NAME, UNISWAP_ARBITRAGEUR_CONTRACT_NAME } from './utils/Contracts';
import { Contract } from 'web3-eth-contract'; import { Contract } from 'web3-eth-contract';
let lp: string import { DODOContext, getDODOContext } from './utils/Context';
let keeper: string import {
newContract,
UNISWAP_ARBITRAGEUR_CONTRACT_NAME,
UNISWAP_CONTRACT_NAME,
} from './utils/Contracts';
import { decimalStr } from './utils/Converter';
import { logGas } from './utils/Log';
let Uniswap: Contract let lp: string;
let UniswapArbitrageur: Contract let keeper: string;
let UniswapReverse: Contract let Uniswap: Contract;
let UniswapArbitrageurReverse: Contract let UniswapArbitrageur: Contract;
let UniswapReverse: Contract;
let UniswapArbitrageurReverse: Contract;
async function init(ctx: DODOContext): Promise<void> { async function init(ctx: DODOContext): Promise<void> {
await ctx.setOraclePrice(decimalStr("100")) await ctx.setOraclePrice(decimalStr("100"));
lp = ctx.spareAccounts[0] lp = ctx.spareAccounts[0];
keeper = ctx.spareAccounts[1] keeper = ctx.spareAccounts[1];
await ctx.approveDODO(lp) await ctx.approveDODO(lp);
await ctx.mintTestToken(lp, decimalStr("100"), decimalStr("10000")) await ctx.mintTestToken(lp, decimalStr("100"), decimalStr("10000"));
await ctx.DODO.methods.depositBase(decimalStr("10")).send(ctx.sendParam(lp)) await ctx.DODO.methods.depositBase(decimalStr("10")).send(ctx.sendParam(lp));
await ctx.DODO.methods.depositQuote(decimalStr("1000")).send(ctx.sendParam(lp)) await ctx.DODO.methods
.depositQuote(decimalStr("1000"))
.send(ctx.sendParam(lp));
Uniswap = await newContract(UNISWAP_CONTRACT_NAME) Uniswap = await newContract(UNISWAP_CONTRACT_NAME);
Uniswap.methods.initialize(ctx.BASE.options.address, ctx.QUOTE.options.address).send(ctx.sendParam(ctx.Deployer)) Uniswap.methods
ctx.BASE.methods.transfer(Uniswap.options.address, decimalStr("10")).send(ctx.sendParam(lp)) .initialize(ctx.BASE.options.address, ctx.QUOTE.options.address)
ctx.QUOTE.methods.transfer(Uniswap.options.address, decimalStr("2000")).send(ctx.sendParam(lp)) .send(ctx.sendParam(ctx.Deployer));
Uniswap.methods.sync().send(ctx.sendParam(lp)) ctx.BASE.methods
.transfer(Uniswap.options.address, decimalStr("10"))
.send(ctx.sendParam(lp));
ctx.QUOTE.methods
.transfer(Uniswap.options.address, decimalStr("2000"))
.send(ctx.sendParam(lp));
Uniswap.methods.sync().send(ctx.sendParam(lp));
UniswapArbitrageur = await newContract(UNISWAP_ARBITRAGEUR_CONTRACT_NAME, [Uniswap.options.address, ctx.DODO.options.address]) UniswapArbitrageur = await newContract(UNISWAP_ARBITRAGEUR_CONTRACT_NAME, [
Uniswap.options.address,
ctx.DODO.options.address,
]);
UniswapReverse = await newContract(UNISWAP_CONTRACT_NAME) UniswapReverse = await newContract(UNISWAP_CONTRACT_NAME);
UniswapReverse.methods.initialize(ctx.BASE.options.address, ctx.QUOTE.options.address).send(ctx.sendParam(ctx.Deployer)) UniswapReverse.methods
ctx.BASE.methods.transfer(UniswapReverse.options.address, decimalStr("10")).send(ctx.sendParam(lp)) .initialize(ctx.BASE.options.address, ctx.QUOTE.options.address)
ctx.QUOTE.methods.transfer(UniswapReverse.options.address, decimalStr("2000")).send(ctx.sendParam(lp)) .send(ctx.sendParam(ctx.Deployer));
UniswapReverse.methods.sync().send(ctx.sendParam(lp)) ctx.BASE.methods
.transfer(UniswapReverse.options.address, decimalStr("10"))
.send(ctx.sendParam(lp));
ctx.QUOTE.methods
.transfer(UniswapReverse.options.address, decimalStr("2000"))
.send(ctx.sendParam(lp));
UniswapReverse.methods.sync().send(ctx.sendParam(lp));
UniswapArbitrageurReverse = await newContract(UNISWAP_ARBITRAGEUR_CONTRACT_NAME, [UniswapReverse.options.address, ctx.DODO.options.address]) UniswapArbitrageurReverse = await newContract(
UNISWAP_ARBITRAGEUR_CONTRACT_NAME,
[UniswapReverse.options.address, ctx.DODO.options.address]
);
} }
describe("Uniswap Arbitrageur", () => { describe("Uniswap Arbitrageur", () => {
let snapshotId: string;
let snapshotId: string let ctx: DODOContext;
let ctx: DODOContext
before(async () => { before(async () => {
ctx = await getDODOContext() ctx = await getDODOContext();
await init(ctx); await init(ctx);
}) });
beforeEach(async () => { beforeEach(async () => {
snapshotId = await ctx.EVM.snapshot(); snapshotId = await ctx.EVM.snapshot();
}); });
afterEach(async () => { afterEach(async () => {
await ctx.EVM.reset(snapshotId) await ctx.EVM.reset(snapshotId);
}); });
describe("arbitrage with not reverse pair", () => { describe("arbitrage with not reverse pair", () => {
it("buy at dodo", async () => { it("buy at dodo", async () => {
await ctx.setOraclePrice(decimalStr("100")) await ctx.setOraclePrice(decimalStr("100"));
// dodo price 100 uniswap price 200 // dodo price 100 uniswap price 200
// buy at dodo // buy at dodo
logGas(await UniswapArbitrageur.methods.executeBuyArbitrage(decimalStr("1")).send(ctx.sendParam(keeper)), "arbitrage buy at dodo not reverse") await logGas(
assert.equal(await ctx.QUOTE.methods.balanceOf(keeper).call(), "79836384956601695518") UniswapArbitrageur.methods.executeBuyArbitrage(decimalStr("1")),
}) ctx.sendParam(keeper),
"arbitrage buy at dodo not reverse"
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(keeper).call(),
"79836384956601695518"
);
});
it("sell at dodo", async () => { it("sell at dodo", async () => {
await ctx.setOraclePrice(decimalStr("300")) await ctx.setOraclePrice(decimalStr("300"));
// dodo price 300 uniswap price 200 // dodo price 300 uniswap price 200
// sell at dodo // sell at dodo
logGas(await UniswapArbitrageur.methods.executeSellArbitrage(decimalStr("1")).send(ctx.sendParam(keeper)), "arbitrage sell at dodo not reverse") await logGas(
assert.equal(await ctx.BASE.methods.balanceOf(keeper).call(), "252761069524143743") UniswapArbitrageur.methods.executeSellArbitrage(decimalStr("1")),
}) ctx.sendParam(keeper),
}) "arbitrage sell at dodo not reverse"
);
assert.equal(
await ctx.BASE.methods.balanceOf(keeper).call(),
"252761069524143743"
);
});
});
describe("arbitrage with reverse pair", () => { describe("arbitrage with reverse pair", () => {
it("buy at dodo", async () => { it("buy at dodo", async () => {
await ctx.setOraclePrice(decimalStr("100")) await ctx.setOraclePrice(decimalStr("100"));
// dodo price 100 uniswap price 200 // dodo price 100 uniswap price 200
// buy at dodo // buy at dodo
logGas(await UniswapArbitrageurReverse.methods.executeBuyArbitrage(decimalStr("1")).send(ctx.sendParam(keeper)), "arbitrage buy at dodo reverse") await logGas(
assert.equal(await ctx.QUOTE.methods.balanceOf(keeper).call(), "79836384956601695518") UniswapArbitrageurReverse.methods.executeBuyArbitrage(decimalStr("1")),
}) ctx.sendParam(keeper),
"arbitrage buy at dodo reverse"
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(keeper).call(),
"79836384956601695518"
);
});
it("sell at dodo", async () => { it("sell at dodo", async () => {
await ctx.setOraclePrice(decimalStr("300")) await ctx.setOraclePrice(decimalStr("300"));
// dodo price 300 uniswap price 200 // dodo price 300 uniswap price 200
// sell at dodo // sell at dodo
logGas(await UniswapArbitrageurReverse.methods.executeSellArbitrage(decimalStr("1")).send(ctx.sendParam(keeper)), "arbitrage sell at dodo reverse") await logGas(
assert.equal(await ctx.BASE.methods.balanceOf(keeper).call(), "252761069524143743") UniswapArbitrageurReverse.methods.executeSellArbitrage(decimalStr("1")),
}) ctx.sendParam(keeper),
}) "arbitrage sell at dodo reverse"
);
assert.equal(
await ctx.BASE.methods.balanceOf(keeper).call(),
"252761069524143743"
);
});
});
describe("revert cases", () => { describe("revert cases", () => {
it("price not match", async () => { it("price not match", async () => {
await ctx.setOraclePrice(decimalStr("200")) await ctx.setOraclePrice(decimalStr("200"));
await assert.rejects( await assert.rejects(
UniswapArbitrageurReverse.methods.executeBuyArbitrage(decimalStr("1")).send(ctx.sendParam(keeper)), UniswapArbitrageurReverse.methods
.executeBuyArbitrage(decimalStr("1"))
.send(ctx.sendParam(keeper)),
/NOT_PROFITABLE/ /NOT_PROFITABLE/
) );
await assert.rejects( await assert.rejects(
UniswapArbitrageurReverse.methods.executeSellArbitrage(decimalStr("1")).send(ctx.sendParam(keeper)), UniswapArbitrageurReverse.methods
.executeSellArbitrage(decimalStr("1"))
.send(ctx.sendParam(keeper)),
/NOT_PROFITABLE/ /NOT_PROFITABLE/
) );
}) });
}) });
}) });