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

add unit test && fix

Browse Source
This commit is contained in:
owen05
2021-09-20 14:52:23 +08:00
parent cc57ee2c14
commit 013cbf66ca
10 changed files with 491 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

225
test/NFTPool/erc1155NftPool.test.ts Normal file
View File

@@ -0,0 +1,225 @@
/*
Copyright 2021 DODO ZOO.
SPDX-License-Identifier: Apache-2.0
*/
// import * as assert from 'assert';
import { decimalStr, MAX_UINT256 } from '../utils/Converter';
import { logGas } from '../utils/Log';
import { NFTPoolContext, getNFTPoolContext } from '../utils/NFTPoolContext';
import { assert } from 'chai';
import * as contracts from '../utils/Contracts';
import BigNumber from 'bignumber.js';
const truffleAssert = require('truffle-assertions');
let maker: string;
let user: string;
async function init(ctx: NFTPoolContext): Promise<void> {
maker = ctx.SpareAccounts[0];
user = ctx.SpareAccounts[1];
}
async function createNFTPool(ctx: NFTPoolContext) {
var tx = await logGas(ctx.DODONFTPoolProxy.methods.createNewNFTPoolV1(
maker,
ctx.DodoNft1155.options.address,
2,
['Filter01', 'FRAG', 'FRAG'],
[decimalStr("10000000"), decimalStr("0.005")],
[true, true, true],
[0, 4, 12, 4],
[decimalStr("1"), decimalStr("0.9"), decimalStr("1"), decimalStr("0.9"), decimalStr("2"), decimalStr("0.9")],
[7]
), ctx.sendParam(maker), "createNewNFTPoolV1");
var newFilterAdmin = tx.events['CreateNFTPool'].returnValues['newFilterAdmin']
var filter = tx.events['CreateNFTPool'].returnValues['filter']
return [newFilterAdmin, filter];
}
async function mintNFT(ctx: NFTPoolContext, amount) {
var tx = await ctx.DodoNft1155.methods.mint(
"http://projectowen.oss-cn-beijing.aliyuncs.com/2021-09-19-035145.png",
amount
).send(ctx.sendParam(user));
var tokenId = tx.events['DODONFTMint'].returnValues['tokenId']
return tokenId
}
async function erc1155In(ctx: NFTPoolContext) {
var [filterAdmin, filter] = await createNFTPool(ctx)
var tokenIds = []
var amounts = []
for (var i = 0; i < 5; i++) {
var curTokenId = await mintNFT(ctx, 2);
tokenIds.push(curTokenId);
amounts.push(2);
}
await ctx.DodoNft1155.methods.setApprovalForAll(
ctx.DODONFTApprove.options.address,
true
).send(ctx.sendParam(user))
await ctx.DODONFTPoolProxy.methods.erc1155In(
filter,
ctx.DodoNft1155.options.address,
tokenIds,
amounts,
user,
1
).send(ctx.sendParam(user));
return [filterAdmin, filter]
}
describe("ERC1155-NFTPool", () => {
let snapshotId: string;
let ctx: NFTPoolContext;
before(async () => {
ctx = await getNFTPoolContext();
await init(ctx);
});
beforeEach(async () => {
snapshotId = await ctx.EVM.snapshot();
});
afterEach(async () => {
await ctx.EVM.reset(snapshotId);
});
describe("ERC1155-NFTPool", () => {
it('erc1155In', async () => {
var [filterAdmin, filter] = await createNFTPool(ctx)
var tokenIds = []
var amounts = []
for (var i = 0; i < 4; i++) {
var curTokenId = await mintNFT(ctx, 2);
tokenIds.push(curTokenId);
amounts.push(2);
}
var beforeBalanceTokenId0 = await ctx.DodoNft1155.methods.balanceOf(filter, 0).call();
assert.equal(beforeBalanceTokenId0, 0)
await logGas(ctx.DodoNft1155.methods.setApprovalForAll(
ctx.DODONFTApprove.options.address,
true
), ctx.sendParam(user), "ApproveNFT");
var filterAdminInstance = contracts.getContractWithAddress(contracts.FILTER_ADMIN, filterAdmin);
var beforeBalance = await filterAdminInstance.methods.balanceOf(user).call();
console.log("beforeBalance:", beforeBalance);
var tx = await logGas(ctx.DODONFTPoolProxy.methods.erc1155In(
filter,
ctx.DodoNft1155.options.address,
tokenIds,
amounts,
user,
1
), ctx.sendParam(user), "erc1155In");
assert.equal(
tx.events['Erc1155In'].returnValues['received'],
'5666851260500000000'
)
var afterBalanceTokenId0 = await ctx.DodoNft1155.methods.balanceOf(filter, 0).call();
assert.equal(afterBalanceTokenId0, 2)
})
it('ERC1155TargetOut', async () => {
var [, filter] = await erc1155In(ctx);
var filterInstance = contracts.getContractWithAddress(contracts.FILTER_ERC1155_V1, filter);
var beforeAmount = await ctx.DodoNft1155.methods.balanceOf(filter, 0).call();
assert.equal(beforeAmount, 2)
//maker targetout
var tx = await logGas(ctx.DODONFTPoolProxy.methods.erc1155TargetOut(
filter,
[0, 1, 3],
[2, 1, 1],
MAX_UINT256,
), ctx.sendParam(maker), "Erc1155TargetOut");
var paid = tx.events['Erc1155TargetOut'].returnValues['paid']
assert.equal(paid, "3673527453990000000");
var maxNftOutAmount = await filterInstance.methods.getAvaliableNFTOutAmount().call();
var totalNftAmount = await filterInstance.methods._TOTAL_NFT_AMOUNT_().call();
assert.equal(maxNftOutAmount, 2);
assert.equal(totalNftAmount, 6);
var afterAmount = await ctx.DodoNft1155.methods.balanceOf(maker, 0).call();
assert.equal(afterAmount, 2)
})
it('ERC721RandomOut', async () => {
var [, filter] = await erc1155In(ctx);
var filterInstance = contracts.getContractWithAddress(contracts.FILTER_ERC1155_V1, filter);
//maker randomOut
var tx = await logGas(ctx.DODONFTPoolProxy.methods.erc1155RandomOut(
filter,
3,
MAX_UINT256,
), ctx.sendParam(maker), "Erc1155RandomOut");
var paid = tx.events['Erc1155RandomOut'].returnValues['paid']
assert.equal(paid, "1302665521995000000");
var maxNftOutAmount = await filterInstance.methods.getAvaliableNFTOutAmount().call();
var totalNftAmount = await filterInstance.methods._TOTAL_NFT_AMOUNT_().call();
assert.equal(maxNftOutAmount, 3);
assert.equal(totalNftAmount, 7);
})
it('emergencyWithdraw', async () => {
var [filterAdmin, filter] = await erc1155In(ctx);
await ctx.Controller.methods.setEmergencyWithdraw(filter, true).send(ctx.sendParam(ctx.Deployer));
var beforeAmount = await ctx.DodoNft1155.methods.balanceOf(filter, 0).call();
assert.equal(beforeAmount, 2)
var filterInstance = contracts.getContractWithAddress(contracts.FILTER_ERC1155_V1, filter);
await logGas(filterInstance.methods.emergencyWithdraw(
[ctx.DodoNft1155.options.address, ctx.DodoNft1155.options.address, ctx.DodoNft1155.options.address],
[0, 1, 4],
[1, 2, 2],
maker
), ctx.sendParam(maker), "EmergencyWithdraw")
var afterAmount = await ctx.DodoNft1155.methods.balanceOf(maker, 0).call();
assert.equal(afterAmount, 1)
afterAmount = await ctx.DodoNft1155.methods.balanceOf(filter, 0).call();
assert.equal(afterAmount, 1)
var maxNftOutAmount = await filterInstance.methods.getAvaliableNFTOutAmount().call();
var totalNftAmount = await filterInstance.methods._TOTAL_NFT_AMOUNT_().call();
assert.equal(maxNftOutAmount, 1);
assert.equal(totalNftAmount, 5);
})
});
});

311
test/NFTPool/erc721NftPool.test.ts
View File

@@ -11,23 +11,74 @@ import { decimalStr, MAX_UINT256 } from '../utils/Converter';
import { logGas } from '../utils/Log';
import { NFTPoolContext, getNFTPoolContext } from '../utils/NFTPoolContext';
import { assert } from 'chai';
import * as contracts from '../utils/Contracts';
import BigNumber from 'bignumber.js';
import { StringLiteralLike } from 'typescript';
const truffleAssert = require('truffle-assertions');
let maker: string;
let user: string;
//createNFTPool
async function init(ctx: NFTPoolContext): Promise<void> {
maker = ctx.SpareAccounts[0];
user = ctx.SpareAccounts[1];
}
//erc721In
async function createNFTPool(ctx: NFTPoolContext) {
var tx = await logGas(ctx.DODONFTPoolProxy.methods.createNewNFTPoolV1(
maker,
ctx.DodoNft.options.address,
1,
['Filter01', 'FRAG', 'FRAG'],
[decimalStr("10000000"), decimalStr("0.005")],
[true, true, true],
[0, 4, 5, 1],
[decimalStr("1"), decimalStr("0.9"), decimalStr("1"), decimalStr("0.9"), decimalStr("2"), decimalStr("0.9")],
[7]
), ctx.sendParam(maker), "createNewNFTPoolV1");
//erc721TargetOut
var newFilterAdmin = tx.events['CreateNFTPool'].returnValues['newFilterAdmin']
var filter = tx.events['CreateNFTPool'].returnValues['filter']
//erc721RandomOut
return [newFilterAdmin, filter];
}
//createFilter
async function mintNFT(ctx: NFTPoolContext) {
var tx = await ctx.DodoNft.methods.mint(
"http://projectowen.oss-cn-beijing.aliyuncs.com/2021-09-19-035145.png"
).send(ctx.sendParam(user));
var tokenId = tx.events['DODONFTMint'].returnValues['tokenId']
return tokenId
}
async function erc721In(ctx: NFTPoolContext) {
var [filterAdmin, filter] = await createNFTPool(ctx)
var tokenIds = []
for (var i = 0; i < 5; i++) {
var curTokenId = await mintNFT(ctx);
tokenIds.push(curTokenId);
}
await ctx.DodoNft.methods.setApprovalForAll(
ctx.DODONFTApprove.options.address,
true
).send(ctx.sendParam(user))
await ctx.DODONFTPoolProxy.methods.erc721In(
filter,
ctx.DodoNft.options.address,
tokenIds,
user,
1
).send(ctx.sendParam(user));
return [filterAdmin, filter]
}
describe("ERC721-NFTPool", () => {
let snapshotId: string;
let ctx: DVMContext;
let ctx: NFTPoolContext;
before(async () => {
ctx = await getNFTPoolContext();
@@ -42,163 +93,147 @@ describe("ERC721-NFTPool", () => {
await ctx.EVM.reset(snapshotId);
});
describe("buy shares", () => {
describe("ERC721-NFTPool", () => {
it("buy shares from init states", async () => {
it("createNewNFTPoolV1", async () => {
var tx = await logGas(ctx.DODONFTPoolProxy.methods.createNewNFTPoolV1(
maker,
ctx.DodoNft.options.address,
1,
['Filter01', 'FRAG', 'FRAG'],
[decimalStr("10000000"), decimalStr("0.005")],
[true, true, true],
[0, 3, 2, 1],
[decimalStr("1"), decimalStr("1.1"), decimalStr("1"), decimalStr("1.1"), decimalStr("2"), decimalStr("1.1")],
[5]
), ctx.sendParam(maker), "createNewNFTPoolV1");
await ctx.transferBaseToDVM(lp, decimalStr("10"))
await logGas(ctx.DVM.methods.buyShares(lp), ctx.sendParam(lp), "buy shares");
var newFilterAdmin = tx.events['CreateNFTPool'].returnValues['newFilterAdmin']
var filter = tx.events['CreateNFTPool'].returnValues['filter']
console.log("newFilterAdmin:", newFilterAdmin)
console.log("filterV1:", filter)
// vault balances
assert.equal(
await ctx.BASE.methods.balanceOf(ctx.DVM.options.address).call(),
decimalStr("10")
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(ctx.DVM.options.address).call(),
decimalStr("0")
);
assert.equal(
await ctx.DVM.methods._BASE_RESERVE_().call(),
decimalStr("10")
tx.events['CreateNFTPool'].returnValues['filterAdminOwner'],
maker
)
assert.equal(
await ctx.DVM.methods._QUOTE_RESERVE_().call(),
decimalStr("0")
)
// shares number
assert.equal(await ctx.DVM.methods.balanceOf(lp).call(), decimalStr("10"))
});
it("buy shares from init states with quote != 0", async () => {
await ctx.transferBaseToDVM(lp, decimalStr("10"))
await ctx.transferQuoteToDVM(lp, decimalStr("100"))
await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp));
assert.equal(await ctx.DVM.methods.balanceOf(lp).call(), decimalStr("10"))
assert.equal(await ctx.DVM.methods.getMidPrice().call(), "102078438912577213500")
})
it('erc721In', async () => {
var [filterAdmin, filter] = await createNFTPool(ctx)
var tokenIds = []
for (var i = 0; i < 4; i++) {
var curTokenId = await mintNFT(ctx);
tokenIds.push(curTokenId);
}
it("buy shares with balanced input", async () => {
await ctx.transferBaseToDVM(lp, decimalStr("10"))
await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp))
await logGas(ctx.DodoNft.methods.setApprovalForAll(
ctx.DODONFTApprove.options.address,
true
), ctx.sendParam(user), "ApproveNFT");
await ctx.transferQuoteToDVM(trader, decimalStr("200"))
await ctx.DVM.methods.sellQuote(trader).send(ctx.sendParam(trader))
var filterAdminInstance = contracts.getContractWithAddress(contracts.FILTER_ADMIN, filterAdmin);
var vaultBaseBalance = new BigNumber(await ctx.BASE.methods.balanceOf(ctx.DVM.options.address).call())
var vaultQuoteBalance = new BigNumber(await ctx.QUOTE.methods.balanceOf(ctx.DVM.options.address).call())
var increaseRatio = new BigNumber("0.1")
var beforeBalance = await filterAdminInstance.methods.balanceOf(user).call();
console.log("beforeBalance:", beforeBalance);
await ctx.transferBaseToDVM(trader, vaultBaseBalance.multipliedBy(increaseRatio).toFixed(0))
await ctx.transferQuoteToDVM(trader, vaultQuoteBalance.multipliedBy(increaseRatio).toFixed(0))
await ctx.DVM.methods.buyShares(trader).send(ctx.sendParam(trader))
var tx = await logGas(ctx.DODONFTPoolProxy.methods.erc721In(
filter,
ctx.DodoNft.options.address,
tokenIds,
user,
1
), ctx.sendParam(user), "erc721In");
var afterBalance = await filterAdminInstance.methods.balanceOf(user).call();
console.log("afterBalance:", afterBalance);
assert.equal(
await ctx.BASE.methods.balanceOf(ctx.DVM.options.address).call(),
"8852116395368015179"
);
assert.equal(
await ctx.QUOTE.methods.balanceOf(ctx.DVM.options.address).call(),
"220000000000000000000"
);
assert.equal(await ctx.DVM.methods.balanceOf(trader).call(), "999999999999999990")
tx.events['Erc721In'].returnValues['received'],
'3421805000000000000'
)
})
it("buy shares with unbalanced input (less quote)", async () => {
await ctx.transferBaseToDVM(lp, decimalStr("10"))
await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp))
it('ERC721TargetOut', async () => {
var [, filter] = await erc721In(ctx);
await ctx.transferQuoteToDVM(trader, decimalStr("200"))
await ctx.DVM.methods.sellQuote(trader).send(ctx.sendParam(trader))
var filterInstance = contracts.getContractWithAddress(contracts.FILTER_ERC721_V1, filter);
var vaultBaseBalance = new BigNumber(await ctx.BASE.methods.balanceOf(ctx.DVM.options.address).call())
var vaultQuoteBalance = new BigNumber(await ctx.QUOTE.methods.balanceOf(ctx.DVM.options.address).call())
var increaseRatio = new BigNumber("0.1")
var beforeOwner = await ctx.DodoNft.methods.ownerOf(0).call();
assert.equal(beforeOwner, filter)
await ctx.transferBaseToDVM(trader, vaultBaseBalance.multipliedBy(increaseRatio).toFixed(0))
await ctx.transferQuoteToDVM(trader, vaultQuoteBalance.multipliedBy(increaseRatio).div(2).toFixed(0))
await ctx.DVM.methods.buyShares(trader).send(ctx.sendParam(trader))
//maker targetout
var tx = await logGas(ctx.DODONFTPoolProxy.methods.erc721TargetOut(
filter,
[0, 1, 3],
MAX_UINT256,
), ctx.sendParam(maker), "Erc721TargetOut");
assert.equal(await ctx.DVM.methods.balanceOf(trader).call(), "500000000000000000")
var paid = tx.events['Erc721TargetOut'].returnValues['paid']
assert.equal(paid, "4412151000000000000");
var maxNftOutAmount = await filterInstance.methods.getAvaliableNFTOutAmount().call();
var totalNftAmount = await filterInstance.methods._TOTAL_NFT_AMOUNT_().call();
var tokenId2 = await filterInstance.methods.getNFTIndexById(2).call();
assert.equal(maxNftOutAmount, 1);
assert.equal(totalNftAmount, 2);
assert.equal(tokenId2, 1);
var afterOwner = await ctx.DodoNft.methods.ownerOf(0).call();
assert.equal(afterOwner, maker)
})
it("buy shares with unbalanced input (less base)", async () => {
await ctx.transferBaseToDVM(lp, decimalStr("10"))
await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp))
await ctx.transferQuoteToDVM(trader, decimalStr("200"))
await ctx.DVM.methods.sellQuote(trader).send(ctx.sendParam(trader))
it('ERC721RandomOut', async () => {
var [, filter] = await erc721In(ctx);
var vaultBaseBalance = new BigNumber(await ctx.BASE.methods.balanceOf(ctx.DVM.options.address).call())
var vaultQuoteBalance = new BigNumber(await ctx.QUOTE.methods.balanceOf(ctx.DVM.options.address).call())
var increaseRatio = new BigNumber("0.1")
var filterInstance = contracts.getContractWithAddress(contracts.FILTER_ERC721_V1, filter);
await ctx.transferBaseToDVM(trader, vaultBaseBalance.multipliedBy(increaseRatio).div(2).toFixed(0))
await ctx.transferQuoteToDVM(trader, vaultQuoteBalance.multipliedBy(increaseRatio).toFixed(0))
await ctx.DVM.methods.buyShares(trader).send(ctx.sendParam(trader))
//maker randomOut
var tx = await logGas(ctx.DODONFTPoolProxy.methods.erc721RandomOut(
filter,
3,
MAX_UINT256,
), ctx.sendParam(maker), "Erc721RandomOut");
assert.equal(await ctx.DVM.methods.balanceOf(trader).call(), "499999999999999990")
var paid = tx.events['Erc721RandomOut'].returnValues['paid']
assert.equal(paid, "2206075500000000000");
var maxNftOutAmount = await filterInstance.methods.getAvaliableNFTOutAmount().call();
var totalNftAmount = await filterInstance.methods._TOTAL_NFT_AMOUNT_().call();
assert.equal(maxNftOutAmount, 1);
assert.equal(totalNftAmount, 2);
})
it('emergencyWithdraw', async () => {
var [filterAdmin, filter] = await erc721In(ctx);
await ctx.Controller.methods.setEmergencyWithdraw(filter, true).send(ctx.sendParam(ctx.Deployer));
var beforeOwner = await ctx.DodoNft.methods.ownerOf(0).call();
assert.equal(beforeOwner, filter)
var filterInstance = contracts.getContractWithAddress(contracts.FILTER_ERC721_V1, filter);
await logGas(filterInstance.methods.emergencyWithdraw(
[ctx.DodoNft.options.address, ctx.DodoNft.options.address, ctx.DodoNft.options.address],
[0, 1, 4],
maker
), ctx.sendParam(maker), "EmergencyWithdraw")
var afterOwner = await ctx.DodoNft.methods.ownerOf(0).call();
assert.equal(afterOwner, maker)
var maxNftOutAmount = await filterInstance.methods.getAvaliableNFTOutAmount().call();
var totalNftAmount = await filterInstance.methods._TOTAL_NFT_AMOUNT_().call();
assert.equal(maxNftOutAmount, 1);
assert.equal(totalNftAmount, 2);
})
});
describe("sell shares", () => {
it("not the last one sell shares", async () => {
await ctx.transferBaseToDVM(lp, decimalStr("10"))
await ctx.transferQuoteToDVM(lp, decimalStr("100"))
await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp))
await ctx.transferBaseToDVM(trader, decimalStr("1"))
await ctx.transferQuoteToDVM(trader, decimalStr("10"))
await ctx.DVM.methods.buyShares(trader).send(ctx.sendParam(trader))
var vaultShares = new BigNumber(await ctx.DVM.methods.balanceOf(lp).call())
var bob = ctx.SpareAccounts[5]
await ctx.DVM.methods.sellShares(vaultShares.div(2).toFixed(0), bob, 0, 0, "0x", MAX_UINT256).send(ctx.sendParam(lp))
assert.equal(await ctx.BASE.methods.balanceOf(bob).call(), decimalStr("5"))
assert.equal(await ctx.QUOTE.methods.balanceOf(bob).call(), decimalStr("50"))
await ctx.DVM.methods.sellShares(vaultShares.div(2).toFixed(0), bob, 0, 0, "0x", MAX_UINT256).send(ctx.sendParam(lp))
assert.equal(await ctx.BASE.methods.balanceOf(bob).call(), decimalStr("10"))
assert.equal(await ctx.QUOTE.methods.balanceOf(bob).call(), decimalStr("100"))
})
it("the last one sell shares", async () => {
await ctx.transferBaseToDVM(lp, decimalStr("10"))
await ctx.transferQuoteToDVM(lp, decimalStr("100"))
await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp))
var vaultShares = await ctx.DVM.methods.balanceOf(lp).call()
var bob = ctx.SpareAccounts[5]
await ctx.DVM.methods.sellShares(vaultShares, bob, 0, 0, "0x", MAX_UINT256).send(ctx.sendParam(lp))
assert.equal(await ctx.BASE.methods.balanceOf(bob).call(), decimalStr("10"))
assert.equal(await ctx.QUOTE.methods.balanceOf(bob).call(), decimalStr("100"))
})
it("revert cases", async () => {
await ctx.transferBaseToDVM(lp, decimalStr("10"))
await ctx.transferQuoteToDVM(lp, decimalStr("100"))
await ctx.DVM.methods.buyShares(lp).send(ctx.sendParam(lp))
var vaultShares = await ctx.DVM.methods.balanceOf(lp).call()
var bob = ctx.SpareAccounts[5]
await truffleAssert.reverts(
ctx.DVM.methods.sellShares(new BigNumber(vaultShares).multipliedBy(2), bob, 0, 0, "0x", MAX_UINT256).send(ctx.sendParam(lp)),
"DLP_NOT_ENOUGH"
)
await truffleAssert.reverts(
ctx.DVM.methods.sellShares(vaultShares, bob, decimalStr("100"), 0, "0x", MAX_UINT256).send(ctx.sendParam(lp)),
"WITHDRAW_NOT_ENOUGH"
)
await truffleAssert.reverts(
ctx.DVM.methods.sellShares(vaultShares, bob, 0, decimalStr("10000"), "0x", MAX_UINT256).send(ctx.sendParam(lp)),
"WITHDRAW_NOT_ENOUGH"
)
await truffleAssert.reverts(
ctx.DVM.methods.sellShares(vaultShares, bob, 0, decimalStr("10000"), "0x", "0").send(ctx.sendParam(lp)),
"TIME_EXPIRED"
)
})
})
});

4
test/utils/Contracts.ts
View File

@@ -77,8 +77,8 @@ export const DROPS_PROXY = "DODODropsProxy"
export const DODO_NFT = "DODONFT"
export const DODO_NFT_1155 = "DODONFT1155"
export const FILTER_ERC721_V1 = "FilterERC721"
export const FILTER_ERC1155_V1 = "FilterERC1155"
export const FILTER_ERC721_V1 = "FilterERC721V1"
export const FILTER_ERC1155_V1 = "FilterERC1155V1"
export const FILTER_ADMIN = "FilterAdmin"
export const CONTROLLER = "Controller"
export const DODO_NFT_APPROVE = "DODONFTApprove"

2
test/utils/NFTPoolContext.ts
View File

@@ -77,7 +77,7 @@ export class NFTPoolContext {
this.Controller.options.address,
this.Deployer,
this.DODONFTApprove.options.address,
"" //TODO:ERC721 => ERC20 DODOApprove
"0x0000000000000000000000000000000000000000" //TODO:ERC721 => ERC20 DODOApprove
]
)