284 lines
11 KiB
TypeScript
284 lines
11 KiB
TypeScript
/*
|
|
|
|
Copyright 2020 DODO ZOO.
|
|
SPDX-License-Identifier: Apache-2.0
|
|
|
|
*/
|
|
import { decimalStr, fromWei} from '../utils/Converter';
|
|
import { logGas } from '../utils/Log';
|
|
import { assert } from 'chai';
|
|
import { Contract } from 'web3-eth-contract';
|
|
import * as contracts from '../utils/Contracts';
|
|
import { DropsContext, getDropsContext } from '../utils/DropsContext';
|
|
import { DVMContext, getDVMContext } from '../utils/DVMContext';
|
|
|
|
let maintainer: string;
|
|
let user1: string;
|
|
let user2: string;
|
|
let user3: string;
|
|
let ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
|
|
let RandomGenerator: Contract;
|
|
|
|
async function init(ctx: DropsContext, ctxDVM: DVMContext, isReveal: Boolean, mode: Boolean): Promise<void> {
|
|
maintainer = ctx.SpareAccounts[0];
|
|
user1 = ctx.SpareAccounts[1];
|
|
user2 = ctx.SpareAccounts[2];
|
|
user3 = ctx.SpareAccounts[3];
|
|
|
|
await ctx.mintTestToken(user1, ctx.DODO, decimalStr("10000"));
|
|
await ctx.mintTestToken(user2, ctx.DODO, decimalStr("10000"));
|
|
await ctx.mintTestToken(user3, ctx.DODO, decimalStr("10000"));
|
|
await ctx.approveProxy(ctx.DODO, user1);
|
|
await ctx.approveProxy(ctx.DODO, user2);
|
|
await ctx.approveProxy(ctx.DODO, user3);
|
|
|
|
|
|
var nftContract;
|
|
if(mode) {
|
|
nftContract = ctx.DropsERC1155.options.address
|
|
}else {
|
|
nftContract = ctx.DropsERC721.options.address
|
|
}
|
|
var rngAddress;
|
|
if (isReveal) {
|
|
rngAddress = ZERO_ADDRESS;
|
|
}else {
|
|
await ctxDVM.mintTestToken(maintainer, decimalStr("10"), decimalStr("1000"));
|
|
await ctxDVM.transferBaseToDVM(maintainer, decimalStr("10"))
|
|
await ctxDVM.transferQuoteToDVM(maintainer, decimalStr("1000"))
|
|
await ctxDVM.DVM.methods.buyShares(maintainer).send(ctx.sendParam(maintainer));
|
|
|
|
RandomGenerator = await contracts.newContract(contracts.RANDOM_GENERATOR,
|
|
[
|
|
[
|
|
ctxDVM.DVM.options.address,
|
|
ctxDVM.DVM.options.address,
|
|
ctxDVM.DVM.options.address
|
|
]
|
|
]
|
|
)
|
|
rngAddress = RandomGenerator.options.address
|
|
}
|
|
|
|
var addrList = [
|
|
ctx.Deployer,
|
|
ctx.DODO.options.address,
|
|
ctx.DropsFeeModel.options.address,
|
|
maintainer,
|
|
rngAddress,
|
|
nftContract
|
|
]
|
|
|
|
var curTime = Math.floor(new Date().getTime() / 1000)
|
|
|
|
await ctx.DropsV2.methods.init(
|
|
addrList,
|
|
[curTime + 10, curTime + 20, curTime + 30],
|
|
[10000000000000, 10000000000000, 0],
|
|
[10, 10, 0],
|
|
curTime + 10,
|
|
isReveal,
|
|
mode
|
|
).send(ctx.sendParam(ctx.Deployer));
|
|
|
|
}
|
|
|
|
async function setReveal(ctx: DropsContext) {
|
|
await ctx.DropsV2.methods.setRevealRn().send(ctx.sendParam(ctx.Deployer));
|
|
}
|
|
|
|
async function setTokenIdList(ctx: DropsContext) {
|
|
var tokenList = [1, 2, 3, 4, 5, 6, 7, 8]
|
|
await ctx.DropsV2.methods.setFixedAmountInfo(tokenList).send(ctx.sendParam(ctx.Deployer));
|
|
}
|
|
|
|
async function setProbMap(ctx: DropsContext) {
|
|
var probIntervals = [1, 5, 20, 50, 100]
|
|
var tokenIdMaps = [
|
|
[0],
|
|
[1, 2],
|
|
[3, 4, 5],
|
|
[6, 7],
|
|
[8, 9, 10, 11]
|
|
]
|
|
await ctx.DropsV2.methods.setProbInfo(probIntervals, tokenIdMaps).send(ctx.sendParam(ctx.Deployer));
|
|
}
|
|
|
|
async function getTicketsInfo(ctx: DropsContext, user: string): Promise<[string, string]> {
|
|
var totalTickets = await ctx.DropsV2.methods.totalSupply().call();
|
|
var userTickets = await ctx.DropsV2.methods.balanceOf(user).call();
|
|
console.log("User Tickets:" + userTickets + " totalTickets:" + totalTickets);
|
|
return [totalTickets, userTickets];
|
|
}
|
|
|
|
async function getBuyTokenBalance(ctx: DropsContext, user: string, token: Contract): Promise<[string, string]> {
|
|
var userDodo = await token.methods.balanceOf(user).call();
|
|
var dropsDodo = await token.methods.balanceOf(ctx.DropsV2.options.address).call();
|
|
console.log("User Dodo:" + userDodo + " Drops Dodo:" + dropsDodo);
|
|
return [userDodo, dropsDodo];
|
|
}
|
|
|
|
async function getNFTOwner(nft721: Contract, tokenId: number): Promise<string> {
|
|
var userAddr = await nft721.methods.ownerOf(tokenId).call();
|
|
return userAddr
|
|
}
|
|
|
|
async function getNFTBalance(nft1155: Contract, user:string, tokenId: number): Promise<[number]> {
|
|
var num = await nft1155.methods.balanceOf(user, tokenId).call();
|
|
return num
|
|
}
|
|
|
|
|
|
describe("DODODropsV2", () => {
|
|
let snapshotId: string;
|
|
let ctx: DropsContext;
|
|
let ctxDVM: DVMContext;
|
|
|
|
before(async () => {
|
|
let config = {
|
|
lpFeeRate: decimalStr("0.002"),
|
|
mtFeeRate: decimalStr("0.001"),
|
|
k: decimalStr("1"),
|
|
i: "1",
|
|
};
|
|
ctxDVM = await getDVMContext(config);
|
|
ctx = await getDropsContext();
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
snapshotId = await ctx.EVM.snapshot();
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await ctx.EVM.reset(snapshotId);
|
|
});
|
|
|
|
describe("DODODropsV2", () => {
|
|
it("buyTicket", async () => {
|
|
await init(ctx, ctxDVM, true, false);
|
|
await ctx.EVM.increaseTime(10);
|
|
await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 2), ctx.sendParam(user1), "buyTickets-user1");
|
|
await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 3), ctx.sendParam(user2), "buyTickets-user2");
|
|
|
|
var [totalSupply,] = await getTicketsInfo(ctx, user1)
|
|
assert(totalSupply, '5')
|
|
|
|
var [, dropsDodoBalance] = await getBuyTokenBalance(ctx, user1, ctx.DODO)
|
|
assert(dropsDodoBalance, decimalStr('0.00005'))
|
|
});
|
|
|
|
it("redeemPrize-fixedAmount-reveal", async () => {
|
|
await init(ctx, ctxDVM, true, false);
|
|
await setTokenIdList(ctx);
|
|
await ctx.EVM.increaseTime(10);
|
|
await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 2), ctx.sendParam(user1), "buyTickets-user1");
|
|
|
|
await setReveal(ctx);
|
|
|
|
var tx = await logGas(await ctx.DropsV2.methods.redeemTicket(1, ZERO_ADDRESS), ctx.sendParam(user1), "redeem-prize");
|
|
var tokenId = tx.events['RedeemPrize'].returnValues['tokenId'];
|
|
|
|
var nftOwner = await getNFTOwner(ctx.DropsERC721, tokenId);
|
|
|
|
assert(user1, nftOwner);
|
|
});
|
|
|
|
it("redeemPrize-probAmount-reveal", async () => {
|
|
await init(ctx, ctxDVM, true, true);
|
|
await setProbMap(ctx);
|
|
await ctx.EVM.increaseTime(10);
|
|
await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 2), ctx.sendParam(user1), "buyTickets-user1");
|
|
|
|
await setReveal(ctx);
|
|
|
|
var tx = await logGas(await ctx.DropsV2.methods.redeemTicket(1, ZERO_ADDRESS), ctx.sendParam(user1), "redeem-prize");
|
|
var tokenId = tx.events['RedeemPrize'].returnValues['tokenId'];
|
|
|
|
var nftAmount = await getNFTBalance(ctx.DropsERC1155, user1, tokenId);
|
|
|
|
console.log("nftAmount:", nftAmount);
|
|
|
|
assert(nftAmount, '1');
|
|
});
|
|
|
|
|
|
it("redeemPrize-fixedAmount-rng", async () => {
|
|
await init(ctx, ctxDVM, false, false);
|
|
await setTokenIdList(ctx);
|
|
await ctx.EVM.increaseTime(10);
|
|
await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 2), ctx.sendParam(user1), "buyTickets-user1");
|
|
|
|
var tx = await logGas(await ctx.DropsV2.methods.redeemTicket(1, ZERO_ADDRESS), ctx.sendParam(user1), "redeem-prize");
|
|
var tokenId = tx.events['RedeemPrize'].returnValues['tokenId'];
|
|
console.log("tokenId:", tokenId);
|
|
var nftOwner = await getNFTOwner(ctx.DropsERC721, tokenId);
|
|
|
|
assert(user1, nftOwner);
|
|
});
|
|
|
|
it("redeemPrize-probAmount-rng", async () => {
|
|
await init(ctx, ctxDVM, false, true);
|
|
await setProbMap(ctx);
|
|
await ctx.EVM.increaseTime(10);
|
|
await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 2), ctx.sendParam(user1), "buyTickets-user1");
|
|
|
|
var tx = await logGas(await ctx.DropsV2.methods.redeemTicket(1, ZERO_ADDRESS), ctx.sendParam(user1), "redeem-prize");
|
|
var tokenId = tx.events['RedeemPrize'].returnValues['tokenId'];
|
|
|
|
var nftAmount = await getNFTBalance(ctx.DropsERC1155, user1, tokenId);
|
|
|
|
console.log("nftAmount:", nftAmount);
|
|
|
|
assert(nftAmount, '1');
|
|
});
|
|
|
|
it("setProbMap", async () => {
|
|
await init(ctx, ctxDVM, true, true);
|
|
var probIntervals = [4, 10, 50, 100, 105]
|
|
var tokenIdMaps = [
|
|
[0],
|
|
[1, 38],
|
|
[3, 4, 5],
|
|
[6, 7],
|
|
[19, 30, 35, 40]
|
|
]
|
|
await logGas(await ctx.DropsV2.methods.setProbInfo(probIntervals, tokenIdMaps), ctx.sendParam(ctx.Deployer), "setProbInfo");
|
|
var prob = await ctx.DropsV2.methods._PROB_INTERVAL_(0).call();
|
|
assert(prob, '4')
|
|
var tokenId = await ctx.DropsV2.methods._TOKEN_ID_MAP_(1, 1).call();
|
|
assert(tokenId, '38')
|
|
})
|
|
|
|
it("setTokenList", async () => {
|
|
await init(ctx, ctxDVM, true, false);
|
|
var tokenList = [4, 10, 50, 100, 105]
|
|
await logGas(await ctx.DropsV2.methods.setFixedAmountInfo(tokenList), ctx.sendParam(ctx.Deployer), "setFixedAmountInfo");
|
|
var tokenId = await ctx.DropsV2.methods._TOKEN_ID_LIST_(1).call();
|
|
assert(tokenId, '10')
|
|
})
|
|
|
|
it("withdraw", async () => {
|
|
await init(ctx, ctxDVM, true, true);
|
|
await setProbMap(ctx);
|
|
await ctx.EVM.increaseTime(10);
|
|
await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 2), ctx.sendParam(user1), "buyTickets-user1");
|
|
await logGas(await ctx.DropsProxy.methods.buyTickets(ctx.DropsV2.options.address, 3), ctx.sendParam(user2), "buyTickets-user2");
|
|
|
|
var b_drops_balance = await ctx.DODO.methods.balanceOf(ctx.DropsV2.options.address).call()
|
|
var b_owner = await ctx.DODO.methods.balanceOf(ctx.Deployer).call();
|
|
|
|
await ctx.DropsV2.methods.withdraw().send(ctx.sendParam(ctx.Deployer));
|
|
|
|
var a_drops_balance = await ctx.DODO.methods.balanceOf(ctx.DropsV2.options.address).call()
|
|
var a_owner = await ctx.DODO.methods.balanceOf(ctx.Deployer).call();
|
|
|
|
console.log("b_drops_balance:", fromWei(b_drops_balance, 'ether'))
|
|
console.log("a_drops_balance:", fromWei(a_drops_balance, 'ether'))
|
|
|
|
console.log("b_owner:", fromWei(b_owner, 'ether'))
|
|
console.log("a_owner:", fromWei(a_owner, 'ether'))
|
|
assert(a_owner, decimalStr("0.00005"))
|
|
})
|
|
});
|
|
});
|