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

nft test ing

Browse Source
This commit is contained in:
owen05
2021-04-12 00:53:59 +08:00
parent 805f639c3a
commit 0bace9f613
7 changed files with 361 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

205
test/DODONFT/nftMainFlow.test.ts
View File

@@ -4,12 +4,11 @@
SPDX-License-Identifier: Apache-2.0
*/
import { decimalStr, mweiStr } from '../utils/Converter';
import { decimalStr, mweiStr, fromWei } from '../utils/Converter';
import { logGas } from '../utils/Log';
import { NFTContext, getDODONftContext } from '../utils/NFTContext';
import { assert } from 'chai';
import * as contracts from '../utils/Contracts';
import { Contract } from 'web3-eth-contract';
let author: string;
let user1: string;
@@ -23,26 +22,73 @@ async function init(ctx: NFTContext): Promise<void> {
await ctx.mintTestToken(user1, ctx.USDT, mweiStr("10000"));
await ctx.mintTestToken(user2, ctx.USDT, mweiStr("10000"));
await ctx.approveProxy(user1);
await ctx.approveProxy(user2);
await ctx.approveProxy(ctx.USDT, user1);
await ctx.approveProxy(ctx.USDT, user2);
}
async function createNFTVault(ctx: NFTContext) {
var tx = await ctx.NFTProxy.methods.createNFTCollateralVault(
"DODONFT",
"https://app.dodoex.io"
).send(ctx.sendParam(author));
async function getFeeGlobalState(ctx: NFTContext, feeAddress: string, baseToken, quoteToken, stakeToken) {
let feeInstance = contracts.getContractWithAddress(contracts.NFT_FEE, feeAddress);
let baseReserve = await feeInstance.methods._BASE_RESERVE_().call();
let quoteReserve = await feeInstance.methods._QUOTE_RESERVE_().call();
let baseBalance = await baseToken.methods.balanceOf(feeAddress).call();
let quoteBalance = await quoteToken.methods.balanceOf(feeAddress).call();
let stakeVault = await feeInstance.methods._STAKE_VAULT_().call();
let stakeBalance = await stakeToken.methods.balanceOf(stakeVault).call();
let stakeReserve = await feeInstance.methods._STAKE_RESERVE_().call();
let baseRatio = await feeInstance.methods._BASE_REWARD_RATIO_().call();
let quoteRatio = await feeInstance.methods._QUOTE_REWARD_RATIO_().call();
return tx.events['CreateNFTCollateralVault']['returnValues']['vault'];
console.log("fee baseBalance:" + fromWei(baseBalance, 'ether') + " quoteBalance:" + fromWei(quoteBalance, 'mwei') + " vault stakeBalance:" + fromWei(stakeBalance, 'ether'));
console.log("fee baseReserve:" + fromWei(baseReserve, 'ether') + " quoteReserve:" + fromWei(quoteReserve, 'mwei') + " stakeReserve:" + fromWei(stakeReserve, 'ether'));
console.log("baseRatio:" + fromWei(baseRatio, 'ether') + " quoteRatio:" + fromWei(quoteRatio, 'mwei'));
return {
"baseReserve": baseReserve,
"quoteReserve": quoteReserve,
"stakeReserve": stakeReserve,
"baseBalance": baseBalance,
"quoteBalance": quoteBalance,
"stakeBalance": stakeBalance,
"baseRatio": baseRatio,
"quoteRatio": quoteRatio
}
}
async function createERC721(ctx:NFTContext) {
var tx = await ctx.NFTTokenFacotry.methods.createERC721(
"https://app.dodoex.io"
).send(ctx.sendParam(author));
return tx.events['NewERC721']['returnValues']['erc721'];
async function getFeeUserState(ctx: NFTContext, feeAddress: string, userAddress: string) {
let feeInstance = contracts.getContractWithAddress(contracts.NFT_FEE, feeAddress);
let userShares = await feeInstance.methods._SHARES_(userAddress).call();
let [baseRewards, quoteRewards] = await feeInstance.methods.getPendingReward(userAddress).call();
let userBasePerShares = await feeInstance.methods._USER_BASE_PER_SHARE_(userAddress).call();
let userQuotePerShares = await feeInstance.methods._USER_QUOTE_PER_SHARE_(userAddress).call();
console.log("user shares:" + fromWei(userShares, 'ether'));
console.log("user baseRewards:" + fromWei(baseRewards, 'ether') + " userQuoteRewards:" + fromWei(quoteRewards, 'mwei'));
console.log("user basePerShares:" + fromWei(userBasePerShares, 'ether') + " userQuotePerShares:" + fromWei(userQuotePerShares, 'mwei'));
return {
"userShares": userShares,
"userBaseRewards": baseRewards,
"userQuoteRewards": quoteRewards,
"userBasePerShares": userBasePerShares,
"userQuotePerShares": userQuotePerShares
}
}
async function mockTrade(ctx: NFTContext, dvmAddress: string, dvmInstance, fragInstance) {
await ctx.transferQuoteToDVM(ctx.USDT, dvmAddress, user1, mweiStr("20"));
await dvmInstance.methods.sellQuote(user1).send(ctx.sendParam(user1));
await ctx.transferBaseToDVM(fragInstance, dvmAddress, user1, decimalStr("10"));
await dvmInstance.methods.sellBase(user1).send(ctx.sendParam(user1));
await ctx.transferQuoteToDVM(ctx.USDT, dvmAddress, user2, mweiStr("80"));
await dvmInstance.methods.sellQuote(user2).send(ctx.sendParam(user2));
await ctx.transferBaseToDVM(fragInstance, dvmAddress, user2, decimalStr("20"));
await dvmInstance.methods.sellBase(user2).send(ctx.sendParam(user2));
}
describe("DODONFT", () => {
let snapshotId: string;
@@ -74,41 +120,43 @@ describe("DODONFT", () => {
});
it("createTokenAndTransferToVault", async () => {
var erc721Address = await createERC721(ctx);
var vaultAddress = await createNFTVault(ctx);
var erc721Address = await ctx.createERC721(ctx, author);
var vaultAddress = await ctx.createNFTVault(ctx, author);
var nftVaultInstance = contracts.getContractWithAddress(contracts.NFT_VAULT, vaultAddress);
var erc721Instance = contracts.getContractWithAddress(contracts.ERC721, erc721Address);
await erc721Instance.methods.safeTransferFrom(author, vaultAddress, 0).send(ctx.sendParam(author));
var nftIndex = await nftVaultInstance.methods.getIdByTokenIdAndAddr(erc721Address,0).call();
var nftIndex = await nftVaultInstance.methods.getIdByTokenIdAndAddr(erc721Address, 0).call();
var nftInfo = await nftVaultInstance.methods.getNftInfoById(nftIndex).call();
assert(nftInfo.amount, '1')
assert(nftInfo.tokenId, '0')
});
it.only("createFragment", async () => {
var erc721Address = await createERC721(ctx);
var vaultAddress = await createNFTVault(ctx);
it("createFragment", async () => {
var erc721Address = await ctx.createERC721(ctx, author);
var vaultAddress = await ctx.createNFTVault(ctx, author);
var nftVaultInstance = contracts.getContractWithAddress(contracts.NFT_VAULT, vaultAddress);
var erc721Instance = contracts.getContractWithAddress(contracts.ERC721, erc721Address);
await erc721Instance.methods.safeTransferFrom(author, vaultAddress, 0).send(ctx.sendParam(author));
var quoteToken = "0x156595bAF85D5C29E91d959889B022d952190A64";
var vaultPreOwner = "0xaac153c1344cA14497A5dd22b1F70C28793625aa";
var stakeToken = "0x854b0f89BAa9101e49Bfb357A38071C9db5d0DFa";
// var quoteToken = ctx.USDT.options.address;
// var vaultPreOwner = author;
// var stakeToken = "0x0000000000000000000000000000000000000000";
// var quoteToken = "0x156595bAF85D5C29E91d959889B022d952190A64";
// var vaultPreOwner = "0xaac153c1344cA14497A5dd22b1F70C28793625aa";
// var stakeToken = "0x854b0f89BAa9101e49Bfb357A38071C9db5d0DFa";
var quoteToken = ctx.USDT.options.address;
var vaultPreOwner = author;
var stakeToken = "0x0000000000000000000000000000000000000000";
var dvmParams = [
"0",
"10000000000000000",
"1000000",
"1000000000000000000"
"0", //lpFeeRate
decimalStr("0.01"), //mtFeeRate
mweiStr("1"), // I
decimalStr("1") // K
];
var fragParams = [
"100000000000000000000000000",
"200000000000000000",
"1617976800"
decimalStr("100000000"), //totalSupply
decimalStr("0.2"), //ownerRatio
Math.floor(new Date().getTime() / 1000 + 60 * 60) //buyoutTimeStamp 1h later
]
var isOpenTwap = false
var callData = ctx.NFTProxy.methods.createFragment(
quoteToken,
@@ -118,35 +166,96 @@ describe("DODONFT", () => {
fragParams,
isOpenTwap
).encodeABI();
console.log("data:",callData);
console.log("data:", callData);
// var tx = await logGas(await nftVaultInstance.methods.createFragment(
// ctx.NFTProxy.options.address,
// callData
// ), ctx.sendParam(author), "createFragment");
await logGas(await nftVaultInstance.methods.createFragment(
ctx.NFTProxy.options.address,
callData
), ctx.sendParam(author), "createFragment");
// console.log("tx:",tx);
let [fragAddress, , dvmAddress] = await ctx.getRegistry(ctx, vaultAddress);
var dvmInstance = contracts.getContractWithAddress(contracts.DVM_NAME, dvmAddress);
var midPrice = await dvmInstance.methods.getMidPrice().call();
assert(midPrice, mweiStr("1"));
let newVaultOwner = await nftVaultInstance.methods._OWNER_().call();
assert(fragAddress, newVaultOwner);
});
it("stakeToFeeDistributor", async () => {
it.only("stakeToFeeDistributor", async () => {
let [vaultAddress, fragAddress, feeAddress, dvmAddress] = await ctx.createFragment(ctx, author, null, null, null);
});
var nftFeeInstance = contracts.getContractWithAddress(contracts.NFT_FEE, feeAddress);
var dvmInstance = contracts.getContractWithAddress(contracts.DVM_NAME, dvmAddress);
var fragInstance = contracts.getContractWithAddress(contracts.NFT_FRAG, fragAddress);
await ctx.approveProxy(fragInstance, user1);
await ctx.approveProxy(fragInstance, user2);
//mock trading
//stake
await mockTrade(ctx, dvmAddress, dvmInstance, fragInstance);
it("dvm-trade", async () => {
await logGas(await ctx.NFTProxy.methods.stakeToFeeDistributor(
feeAddress,
decimalStr("5"),
0
), ctx.sendParam(user1), "stakeToFeeDistributor");
});
await logGas(await ctx.NFTProxy.methods.stakeToFeeDistributor(
feeAddress,
decimalStr("10"),
0
), ctx.sendParam(user2), "stakeToFeeDistributor");
it("claim", async () => {
await mockTrade(ctx, dvmAddress, dvmInstance, fragInstance);
});
await logGas(await ctx.NFTProxy.methods.stakeToFeeDistributor(
feeAddress,
decimalStr("10"),
0
), ctx.sendParam(user1), "stakeToFeeDistributor");
it("unstake", async () => {
await logGas(await ctx.NFTProxy.methods.stakeToFeeDistributor(
feeAddress,
decimalStr("20"),
0
), ctx.sendParam(user2), "stakeToFeeDistributor");
let globalObj = await getFeeGlobalState(ctx, feeAddress, fragInstance, ctx.USDT, fragInstance);
assert(globalObj['quoteBalance'], mweiStr("0.6"));
assert(globalObj['stakeReserve'], decimalStr("45"));
let user1Obj = await getFeeUserState(ctx, feeAddress, user1);
assert(user1Obj['userQuoteRewards'], mweiStr("0.1"));
assert(user1Obj['userShares'], decimalStr("15"));
let user2Obj = await getFeeUserState(ctx, feeAddress, user2);
assert(user2Obj['userBaseRewards'], decimalStr("0.66666480000453957"));
assert(user2Obj['userShares'], decimalStr("30"));
//claim
var user1BaseBalanceStart = await fragInstance.methods.balanceOf(user1).call()
await logGas(await nftFeeInstance.methods.claim(user1), ctx.sendParam(user1), "claim");
var user1BaseBalanceEnd = await fragInstance.methods.balanceOf(user1).call()
user1Obj = await getFeeUserState(ctx, feeAddress, user1);
await getFeeGlobalState(ctx, feeAddress, fragInstance, ctx.USDT, fragInstance);
assert(user1Obj['userQuoteRewards'], "0");
assert(globalObj['quoteBalance'], mweiStr("0.5"));
assert(user1BaseBalanceEnd - user1BaseBalanceStart, "333332400002269700");
//unstake
var user2BaseBalanceStart = await fragInstance.methods.balanceOf(user2).call()
await logGas(await nftFeeInstance.methods.unstake(decimalStr("30"),user2, true), ctx.sendParam(user2), "unstake");
var user2BaseBalanceEnd = await fragInstance.methods.balanceOf(user2).call()
user2Obj = await getFeeUserState(ctx, feeAddress, user2);
await getFeeGlobalState(ctx, feeAddress, fragInstance, ctx.USDT, fragInstance);
assert(user2Obj['userQuoteRewards'], "0");
assert(globalObj['quoteBalance'], mweiStr("0.3"));
assert(globalObj['stakeReserve'], mweiStr("15"));
assert(globalObj['stakeBalance'], mweiStr("15"));
assert(user2BaseBalanceEnd - user2BaseBalanceStart, "30666664800004540000");
});
it("buyout", async () => {
});
it("redeem", async () => {

99
test/utils/NFTContext.ts
View File

@@ -24,7 +24,7 @@ export class NFTContext {
EVM: EVM;
Web3: Web3;
NFTTokenFacotry: Contract;
NFTRegister: Contract;
CollatteralVault: Contract;
Fragment: Contract;
@@ -33,10 +33,11 @@ export class NFTContext {
NFTProxy: Contract;
DODOApprove: Contract;
DODOApproveProxy: Contract;
//token
USDT: Contract;
WETH: Contract;
DODO: Contract;
Deployer: string;
Maintainer: string;
@@ -59,6 +60,11 @@ export class NFTContext {
["USDT Token", "USDT", 6]
);
this.DODO = await contracts.newContract(
contracts.MINTABLE_ERC20_CONTRACT_NAME,
["DODO Token", "DODO", 6]
);
var cloneFactory = await contracts.newContract(
contracts.CLONE_FACTORY_CONTRACT_NAME
);
@@ -116,6 +122,8 @@ export class NFTContext {
await this.NFTProxy.methods.initOwner(this.Deployer).send(this.sendParam(this.Deployer));
await this.NFTRegister.methods.addAmindList(this.NFTProxy.options.address).send(this.sendParam(this.Deployer));
await this.DODOApprove.methods.init(this.Deployer, this.DODOApproveProxy.options.address).send(this.sendParam(this.Deployer));
await this.DODOApproveProxy.methods.init(this.Deployer, [this.NFTProxy.options.address]).send(this.sendParam(this.Deployer));
@@ -136,14 +144,91 @@ export class NFTContext {
await token.methods.mint(to, amount).send(this.sendParam(this.Deployer));
}
async approveProxy(account: string) {
await this.USDT.methods
.approve(this.DODOApprove.options.address, MAX_UINT256)
.send(this.sendParam(account));
await this.WETH.methods
async approveProxy(token, account: string) {
await token.methods
.approve(this.DODOApprove.options.address, MAX_UINT256)
.send(this.sendParam(account));
}
async getRegistry(ctx: NFTContext, vaultAddress: string) {
let fragAddress = await ctx.NFTRegister.methods._VAULT_FRAG_REGISTRY_(vaultAddress).call();
let feeDistrubitor = await ctx.NFTRegister.methods._FRAG_FEE_REGISTRY_(fragAddress).call();
let fragInstance = contracts.getContractWithAddress(contracts.NFT_FRAG, fragAddress);
let dvmAddress = await fragInstance.methods._DVM_().call();
return [fragAddress, feeDistrubitor, dvmAddress];
}
async createNFTVault(ctx: NFTContext, author: string) {
var tx = await ctx.NFTProxy.methods.createNFTCollateralVault(
"DODONFT",
"https://app.dodoex.io"
).send(ctx.sendParam(author));
return tx.events['CreateNFTCollateralVault']['returnValues']['vault'];
}
async createERC721(ctx: NFTContext, author: string) {
var tx = await ctx.NFTTokenFacotry.methods.createERC721(
"https://app.dodoex.io"
).send(ctx.sendParam(author));
return tx.events['NewERC721']['returnValues']['erc721'];
}
async createFragment(ctx: NFTContext, author: string, dvmParams, fragParams, addrs) {
var erc721Address = await this.createERC721(ctx, author);
var vaultAddress = await this.createNFTVault(ctx, author);
var nftVaultInstance = contracts.getContractWithAddress(contracts.NFT_VAULT, vaultAddress);
var erc721Instance = contracts.getContractWithAddress(contracts.ERC721, erc721Address);
await erc721Instance.methods.safeTransferFrom(author, vaultAddress,0).send(ctx.sendParam(author));
if (dvmParams == null) {
dvmParams = [
"0", //lpFeeRate
decimalStr("0.01"), //mtFeeRate
mweiStr("1"), // I
decimalStr("1") // K
];
}
if (fragParams == null) {
fragParams = [
decimalStr("100000000"), //totalSupply
decimalStr("0.2"), //ownerRatio
Math.floor(new Date().getTime() / 1000 + 60 * 60) //buyoutTimeStamp 1h later
]
}
if (addrs == null) {
addrs = []
addrs.push(ctx.USDT.options.address);//quoteToken
addrs.push(author);//vaultPreOwner
addrs.push("0x0000000000000000000000000000000000000000");//stakeToken
}
var callData = ctx.NFTProxy.methods.createFragment(
addrs[0],
addrs[1],
addrs[2],
dvmParams,
fragParams,
false
).encodeABI();
await nftVaultInstance.methods.createFragment(
ctx.NFTProxy.options.address,
callData
).send(ctx.sendParam(author));
let [fragAddress, feeAddress, dvmAddress] = await this.getRegistry(ctx, vaultAddress);
return [vaultAddress, fragAddress, feeAddress, dvmAddress, callData]
}
async transferBaseToDVM(baseToken, dvm: string, account: string, amount: string) {
await baseToken.methods.transfer(dvm, amount).send(this.sendParam(account))
}
async transferQuoteToDVM(quoteToken, dvm: string, account: string, amount: string) {
await quoteToken.methods.transfer(dvm, amount).send(this.sendParam(account))
}
}
export async function getDODONftContext(weth: string): Promise<NFTContext> {