oceanprotocol/ocean.js
1
0
Fork 0
mirror of https://github.com/oceanprotocol/ocean.js.git synced 2024-11-26 20:39:05 +01:00
Code Releases Activity

convert TestContractHandler class to function

Browse Source
This commit is contained in:
Miquel A. Cabot 2022-03-19 15:32:02 +01:00
parent 1e12ddd630
commit a77f1c5862
9 changed files with 228 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

368
test/TestContractHandler.ts
View File

@ -1,5 +1,4 @@
import Web3 from 'web3'
import { Contract } from 'web3-eth-contract'
import { AbiItem } from 'web3-utils/types'
import ERC721Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC721Template.sol/ERC721Template.json'
import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
@ -11,14 +10,15 @@ import FixedRate from '@oceanprotocol/contracts/artifacts/contracts/pools/fixedR
import Dispenser from '@oceanprotocol/contracts/artifacts/contracts/pools/dispenser/Dispenser.sol/Dispenser.json'
import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/MockERC20Decimals.sol/MockERC20Decimals.json'
import OPFCommunityFeeCollector from '@oceanprotocol/contracts/artifacts/contracts/communityFee/OPFCommunityFeeCollector.sol/OPFCommunityFeeCollector.json'
import { getAddresses, GAS_PRICE } from './config'
import { web3, getAddresses, GAS_PRICE } from './config'
const deployContract = async (
contract: Contract,
const estimateGasAndDeployContract = async (
abi: AbiItem | AbiItem[],
bytecode: string,
argumentsArray: any[],
owner: string
) => {
const contract = new web3.eth.Contract(abi)
// get est gascost
const estimatedGas = await contract
.deploy({
@ -45,191 +45,177 @@ const deployContract = async (
})
}
export class TestContractHandler {
public ERC721Factory: Contract
public ERC20Template: Contract
public ERC721Template: Contract
public Router: Contract
public SideStaking: Contract
public FixedRate: Contract
public Dispenser: Contract
public OPFCollector: Contract
public PoolTemplate: Contract
public MockERC20: Contract
public MockOcean: Contract
public factory721Address: string
public template721Address: string
public template20Address: string
public routerAddress: string
public sideStakingAddress: string
public fixedRateAddress: string
public dispenserAddress: string
public poolTemplateAddress: string
public opfCollectorAddress: string
public oceanAddress: string
public daiAddress: string
public usdcAddress: string
public web3: Web3
constructor(web3: Web3) {
this.web3 = web3
this.ERC721Template = new this.web3.eth.Contract(ERC721Template.abi as AbiItem[])
this.ERC20Template = new this.web3.eth.Contract(ERC20Template.abi as AbiItem[])
this.PoolTemplate = new this.web3.eth.Contract(PoolTemplate.abi as AbiItem[])
this.ERC721Factory = new this.web3.eth.Contract(ERC721Factory.abi as AbiItem[])
this.Router = new this.web3.eth.Contract(Router.abi as AbiItem[])
this.SideStaking = new this.web3.eth.Contract(SideStaking.abi as AbiItem[])
this.FixedRate = new this.web3.eth.Contract(FixedRate.abi as AbiItem[])
this.Dispenser = new this.web3.eth.Contract(Dispenser.abi as AbiItem[])
this.MockERC20 = new this.web3.eth.Contract(MockERC20.abi as AbiItem[])
this.OPFCollector = new this.web3.eth.Contract(
OPFCommunityFeeCollector.abi as AbiItem[]
)
}
public async deployContracts(owner: string) {
const addresses = getAddresses()
// DEPLOY OPF Fee Collector
this.opfCollectorAddress =
addresses.OPFCommunityFeeCollector ||
(await deployContract(
this.OPFCollector,
OPFCommunityFeeCollector.bytecode,
[owner, owner],
owner
))
// DEPLOY POOL TEMPLATE
this.poolTemplateAddress =
addresses.poolTemplate ||
(await deployContract(this.PoolTemplate, PoolTemplate.bytecode, [], owner))
// DEPLOY ERC20 TEMPLATE
this.template20Address =
addresses.ERC20Template['1'] ||
(await deployContract(this.ERC20Template, ERC20Template.bytecode, [], owner))
// DEPLOY ERC721 TEMPLATE
this.template721Address =
addresses.ERC721Template['1'] ||
(await deployContract(this.ERC721Template, ERC721Template.bytecode, [], owner))
// DEPLOY OCEAN MOCK
this.oceanAddress =
addresses.Ocean ||
(await deployContract(
this.MockERC20,
MockERC20.bytecode,
['OCEAN', 'OCEAN', 18],
owner
))
// DEPLOY ROUTER
this.routerAddress =
addresses.Router ||
(await deployContract(
this.Router,
Router.bytecode,
[
owner,
this.oceanAddress,
this.poolTemplateAddress,
this.opfCollectorAddress,
[]
],
owner
))
// DEPLOY SIDE STAKING
this.sideStakingAddress =
addresses.Staking ||
(await deployContract(
this.SideStaking,
SideStaking.bytecode,
[this.routerAddress],
owner
))
// DEPLOY FIXED RATE
this.fixedRateAddress =
addresses.FixedPrice ||
(await deployContract(
this.FixedRate,
FixedRate.bytecode,
[this.routerAddress, this.opfCollectorAddress],
owner
))
// DEPLOY Dispenser
this.dispenserAddress =
addresses.Dispenser ||
(await deployContract(
this.Dispenser,
Dispenser.bytecode,
[this.routerAddress],
owner
))
// DEPLOY ERC721 FACTORY
this.factory721Address =
addresses.ERC721Factory ||
(await deployContract(
this.ERC721Factory,
ERC721Factory.bytecode,
[
this.template721Address,
this.template20Address,
this.opfCollectorAddress,
this.routerAddress
],
owner
))
// DEPLOY USDC MOCK
this.usdcAddress =
addresses.MockUSDC ||
(await deployContract(
this.MockERC20,
MockERC20.bytecode,
['USDC', 'USDC', 6],
owner
))
// DEPLOY DAI MOCK
this.daiAddress =
addresses.MockDAI ||
(await deployContract(
this.MockERC20,
MockERC20.bytecode,
['DAI', 'DAI', 18],
owner
))
if (!addresses.Router) {
const RouterContract = new this.web3.eth.Contract(
Router.abi as AbiItem[],
this.routerAddress
)
await RouterContract.methods
.addFactory(this.factory721Address)
.send({ from: owner })
await RouterContract.methods
.addFixedRateContract(this.fixedRateAddress)
.send({ from: owner })
await RouterContract.methods
.addDispenserContract(this.dispenserAddress)
.send({ from: owner })
await RouterContract.methods
.addSSContract(this.sideStakingAddress)
.send({ from: owner })
// TODO: add OPF deployment
// await RouterContract.methods
// .changeRouterOwner(this.opfCollectorAddress)
// .send({ from: owner })
}
}
export interface Addresses {
factory721Address: string
template721Address: string
template20Address: string
routerAddress: string
sideStakingAddress: string
fixedRateAddress: string
dispenserAddress: string
poolTemplateAddress: string
opfCollectorAddress: string
oceanAddress: string
daiAddress: string
usdcAddress: string
}
export const deployContracts = async (owner: string): Promise<Addresses> => {
const addresses = getAddresses()
// DEPLOY OPF Fee Collector
addresses.opfCollectorAddress =
addresses.OPFCommunityFeeCollector ||
(await estimateGasAndDeployContract(
OPFCommunityFeeCollector.abi as AbiItem[],
OPFCommunityFeeCollector.bytecode,
[owner, owner],
owner
))
// DEPLOY POOL TEMPLATE
addresses.poolTemplateAddress =
addresses.poolTemplate ||
(await estimateGasAndDeployContract(
PoolTemplate.abi as AbiItem[],
PoolTemplate.bytecode,
[],
owner
))
// DEPLOY ERC20 TEMPLATE
addresses.template20Address =
addresses.ERC20Template['1'] ||
(await estimateGasAndDeployContract(
ERC20Template.abi as AbiItem[],
ERC20Template.bytecode,
[],
owner
))
// DEPLOY ERC721 TEMPLATE
addresses.template721Address =
addresses.ERC721Template['1'] ||
(await estimateGasAndDeployContract(
ERC721Template.abi as AbiItem[],
ERC721Template.bytecode,
[],
owner
))
// DEPLOY OCEAN MOCK
addresses.oceanAddress =
addresses.Ocean ||
(await estimateGasAndDeployContract(
MockERC20.abi as AbiItem[],
MockERC20.bytecode,
['OCEAN', 'OCEAN', 18],
owner
))
// DEPLOY ROUTER
addresses.routerAddress =
addresses.Router ||
(await estimateGasAndDeployContract(
Router.abi as AbiItem[],
Router.bytecode,
[
owner,
addresses.oceanAddress,
addresses.poolTemplateAddress,
addresses.opfCollectorAddress,
[]
],
owner
))
// DEPLOY SIDE STAKING
addresses.sideStakingAddress =
addresses.Staking ||
(await estimateGasAndDeployContract(
SideStaking.abi as AbiItem[],
SideStaking.bytecode,
[addresses.routerAddress],
owner
))
// DEPLOY FIXED RATE
addresses.fixedRateAddress =
addresses.FixedPrice ||
(await estimateGasAndDeployContract(
FixedRate.abi as AbiItem[],
FixedRate.bytecode,
[addresses.routerAddress, addresses.opfCollectorAddress],
owner
))
// DEPLOY Dispenser
addresses.dispenserAddress =
addresses.Dispenser ||
(await estimateGasAndDeployContract(
Dispenser.abi as AbiItem[],
Dispenser.bytecode,
[addresses.routerAddress],
owner
))
// DEPLOY ERC721 FACTORY
addresses.factory721Address =
addresses.ERC721Factory ||
(await estimateGasAndDeployContract(
ERC721Factory.abi as AbiItem[],
ERC721Factory.bytecode,
[
addresses.template721Address,
addresses.template20Address,
addresses.opfCollectorAddress,
addresses.routerAddress
],
owner
))
// DEPLOY USDC MOCK
addresses.usdcAddress =
addresses.MockUSDC ||
(await estimateGasAndDeployContract(
MockERC20.abi as AbiItem[],
MockERC20.bytecode,
['USDC', 'USDC', 6],
owner
))
// DEPLOY DAI MOCK
addresses.daiAddress =
addresses.MockDAI ||
(await estimateGasAndDeployContract(
MockERC20.abi as AbiItem[],
MockERC20.bytecode,
['DAI', 'DAI', 18],
owner
))
if (!addresses.Router) {
const RouterContract = new web3.eth.Contract(
Router.abi as AbiItem[],
addresses.routerAddress
)
await RouterContract.methods
.addFactory(addresses.factory721Address)
.send({ from: owner })
await RouterContract.methods
.addFixedRateContract(addresses.fixedRateAddress)
.send({ from: owner })
await RouterContract.methods
.addDispenserContract(addresses.dispenserAddress)
.send({ from: owner })
await RouterContract.methods
.addSSContract(addresses.sideStakingAddress)
.send({ from: owner })
// TODO: add OPF deployment
// await RouterContract.methods
// .changeRouterOwner(this.opfCollectorAddress)
// .send({ from: owner })
}
return addresses
}

10
test/unit/NftFactory.test.ts
View File

@ -1,7 +1,8 @@
import { assert, expect } from 'chai'
import { AbiItem } from 'web3-utils/types'
import { TestContractHandler } from '../TestContractHandler'
import { deployContracts, Addresses } from '../TestContractHandler'
import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/MockERC20Decimals.sol/MockERC20Decimals.json'
import { web3 } from '../config'
import { NftFactory, NftCreateData, TokenOrder, ZERO_ADDRESS, signHash } from '../../src'
import {
@ -17,7 +18,7 @@ describe('Nft Factory test', () => {
let user1: string
let user2: string
let user3: string
let contracts: TestContractHandler
let contracts: Addresses
let nftFactory: NftFactory
let dtAddress: string
let dtAddress2: string
@ -33,11 +34,10 @@ describe('Nft Factory test', () => {
})
it('should deploy contracts', async () => {
contracts = new TestContractHandler(web3)
await contracts.deployContracts(factoryOwner)
contracts = await deployContracts(factoryOwner)
const daiContract = new web3.eth.Contract(
contracts.MockERC20.options.jsonInterface,
MockERC20.abi as AbiItem[],
contracts.daiAddress
)
await daiContract.methods

12
test/unit/pools/Router.test.ts
View File

@ -1,8 +1,9 @@
import { assert, expect } from 'chai'
import { AbiItem } from 'web3-utils/types'
import { TestContractHandler } from '../../TestContractHandler'
import { deployContracts, Addresses } from '../../TestContractHandler'
import ERC721Factory from '@oceanprotocol/contracts/artifacts/contracts/ERC721Factory.sol/ERC721Factory.json'
import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/MockERC20Decimals.sol/MockERC20Decimals.json'
import { web3 } from '../../config'
import { NftFactory, NftCreateData } from '../../../src'
import { Router } from '../../../src/pools/Router'
@ -16,7 +17,7 @@ describe('Router unit test', () => {
let user1: string
let user2: string
let user3: string
let contracts: TestContractHandler
let contracts: Addresses
let router: Router
let dtAddress: string
let dtAddress2: string
@ -32,11 +33,10 @@ describe('Router unit test', () => {
})
it('should deploy contracts', async () => {
contracts = new TestContractHandler(web3)
await contracts.deployContracts(factoryOwner)
contracts = await deployContracts(factoryOwner)
const daiContract = new web3.eth.Contract(
contracts.MockERC20.options.jsonInterface,
MockERC20.abi as AbiItem[],
contracts.daiAddress
)
await daiContract.methods
@ -78,7 +78,7 @@ describe('Router unit test', () => {
it('#buyDTBatch - should buy multiple DT in one call', async () => {
// APPROVE DAI
const daiContract = new web3.eth.Contract(
contracts.MockERC20.options.jsonInterface,
MockERC20.abi as AbiItem[],
contracts.daiAddress
)

15
test/unit/pools/balancer/Pool.test.ts
View File

@ -4,7 +4,8 @@ import { Contract } from 'web3-eth-contract'
import ERC721Factory from '@oceanprotocol/contracts/artifacts/contracts/ERC721Factory.sol/ERC721Factory.json'
import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
import PoolTemplate from '@oceanprotocol/contracts/artifacts/contracts/pools/balancer/BPool.sol/BPool.json'
import { TestContractHandler } from '../../../TestContractHandler'
import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/MockERC20Decimals.sol/MockERC20Decimals.json'
import { deployContracts, Addresses } from '../../../TestContractHandler'
import { web3 } from '../../../config'
import {
allowance,
@ -30,7 +31,7 @@ describe('Pool unit test', () => {
let user1: string
let user2: string
let user3: string
let contracts: TestContractHandler
let contracts: Addresses
let pool: Pool
let dtAddress: string
let dtAddress2: string
@ -50,20 +51,16 @@ describe('Pool unit test', () => {
})
it('should deploy contracts', async () => {
contracts = new TestContractHandler(web3)
await contracts.deployContracts(factoryOwner)
contracts = await deployContracts(factoryOwner)
// initialize Pool instance
pool = new Pool(web3, PoolTemplate.abi as AbiItem[])
assert(pool != null)
daiContract = new web3.eth.Contract(
contracts.MockERC20.options.jsonInterface,
contracts.daiAddress
)
daiContract = new web3.eth.Contract(MockERC20.abi as AbiItem[], contracts.daiAddress)
usdcContract = new web3.eth.Contract(
contracts.MockERC20.options.jsonInterface,
MockERC20.abi as AbiItem[],
contracts.usdcAddress
)
await approve(

7
test/unit/pools/dispenser/Dispenser.test.ts
View File

@ -2,7 +2,7 @@ import { AbiItem } from 'web3-utils'
import { assert, expect } from 'chai'
import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
import DispenserTemplate from '@oceanprotocol/contracts/artifacts/contracts/pools/dispenser/Dispenser.sol/Dispenser.json'
import { TestContractHandler } from '../../../TestContractHandler'
import { deployContracts, Addresses } from '../../../TestContractHandler'
import { web3 } from '../../../config'
import {
NftFactory,
@ -19,7 +19,7 @@ describe('Dispenser flow', () => {
let user1: string
let user2: string
let user3: string
let contracts: TestContractHandler
let contracts: Addresses
let DispenserAddress: string
let DispenserClass: Dispenser
let nftFactory: NftFactory
@ -37,8 +37,7 @@ describe('Dispenser flow', () => {
})
it('should deploy contracts', async () => {
contracts = new TestContractHandler(web3)
await contracts.deployContracts(factoryOwner)
contracts = await deployContracts(factoryOwner)
})
it('should initialize Dispenser class', async () => {

15
test/unit/pools/fixedRate/FixedRateExchange.test.ts
View File

@ -4,7 +4,8 @@ import { Contract } from 'web3-eth-contract'
import BN from 'bn.js'
import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
import FixedRate from '@oceanprotocol/contracts/artifacts/contracts/pools/fixedRate/FixedRateExchange.sol/FixedRateExchange.json'
import { TestContractHandler } from '../../../TestContractHandler'
import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/MockERC20Decimals.sol/MockERC20Decimals.json'
import { deployContracts, Addresses } from '../../../TestContractHandler'
import { web3 } from '../../../config'
import { NftFactory, NftCreateData, FixedRateExchange } from '../../../../src'
import { FreCreationParams, Erc20CreateParams } from '../../../../src/@types'
@ -22,7 +23,7 @@ describe('Fixed Rate unit test', () => {
let daiAddress: string
let usdcAddress: string
let exchangeId: string
let contracts: TestContractHandler
let contracts: Addresses
let fixedRate: FixedRateExchange
let dtAddress: string
let dtAddress2: string
@ -44,19 +45,15 @@ describe('Fixed Rate unit test', () => {
})
it('should deploy contracts', async () => {
contracts = new TestContractHandler(web3)
await contracts.deployContracts(factoryOwner)
contracts = await deployContracts(factoryOwner)
// initialize fixed rate
//
daiContract = new web3.eth.Contract(
contracts.MockERC20.options.jsonInterface,
contracts.daiAddress
)
daiContract = new web3.eth.Contract(MockERC20.abi as AbiItem[], contracts.daiAddress)
usdcContract = new web3.eth.Contract(
contracts.MockERC20.options.jsonInterface,
MockERC20.abi as AbiItem[],
contracts.usdcAddress
)
})

15
test/unit/pools/ssContracts/SideStaking.test.ts
View File

@ -4,7 +4,8 @@ import { Contract } from 'web3-eth-contract'
import SSContract from '@oceanprotocol/contracts/artifacts/contracts/pools/ssContracts/SideStaking.sol/SideStaking.json'
import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
import PoolTemplate from '@oceanprotocol/contracts/artifacts/contracts/pools/balancer/BPool.sol/BPool.json'
import { TestContractHandler } from '../../../TestContractHandler'
import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/MockERC20Decimals.sol/MockERC20Decimals.json'
import { deployContracts, Addresses } from '../../../TestContractHandler'
import { web3 } from '../../../config'
import {
allowance,
@ -32,7 +33,7 @@ describe('SideStaking unit test', () => {
let user3: string
let initialBlock: number
let sideStakingAddress: string
let contracts: TestContractHandler
let contracts: Addresses
let pool: Pool
let sideStaking: SideStaking
let dtAddress: string
@ -54,9 +55,8 @@ describe('SideStaking unit test', () => {
})
it('should deploy contracts', async () => {
contracts = new TestContractHandler(web3)
sideStakingAddress = contracts.sideStakingAddress
await contracts.deployContracts(factoryOwner)
contracts = await deployContracts(factoryOwner)
// initialize Pool instance
pool = new Pool(web3, PoolTemplate.abi as AbiItem[])
@ -65,13 +65,10 @@ describe('SideStaking unit test', () => {
sideStaking = new SideStaking(web3, SSContract.abi as AbiItem[])
assert(sideStaking != null)
daiContract = new web3.eth.Contract(
contracts.MockERC20.options.jsonInterface,
contracts.daiAddress
)
daiContract = new web3.eth.Contract(MockERC20.abi as AbiItem[], contracts.daiAddress)
usdcContract = new web3.eth.Contract(
contracts.MockERC20.options.jsonInterface,
MockERC20.abi as AbiItem[],
contracts.usdcAddress
)
await approve(

30
test/unit/tokens/Datatoken.test.ts
View File

@ -3,7 +3,8 @@ import ERC20TemplateEnterprise from '@oceanprotocol/contracts/artifacts/contract
import ERC721Factory from '@oceanprotocol/contracts/artifacts/contracts/ERC721Factory.sol/ERC721Factory.json'
import ERC721Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC721Template.sol/ERC721Template.json'
import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
import { TestContractHandler } from '../../TestContractHandler'
import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/MockERC20Decimals.sol/MockERC20Decimals.json'
import { deployContracts, Addresses } from '../../TestContractHandler'
import { AbiItem } from 'web3-utils'
import { web3 } from '../../config'
import {
@ -23,7 +24,7 @@ describe('Datatoken', () => {
let user1: string
let user2: string
let user3: string
let contractHandler: TestContractHandler
let contracts: Addresses
let nftDatatoken: Nft
let datatoken: Datatoken
let nftFactory: NftFactory
@ -44,21 +45,20 @@ describe('Datatoken', () => {
})
it('should deploy contracts', async () => {
contractHandler = new TestContractHandler(web3)
await contractHandler.deployContracts(nftOwner)
contracts = await deployContracts(nftOwner)
const daiContract = new web3.eth.Contract(
contractHandler.MockERC20.options.jsonInterface,
contractHandler.daiAddress
MockERC20.abi as AbiItem[],
contracts.daiAddress
)
await daiContract.methods
.approve(contractHandler.factory721Address, web3.utils.toWei('10000'))
.approve(contracts.factory721Address, web3.utils.toWei('10000'))
.send({ from: nftOwner })
})
it('should initialize NFTFactory instance and create a new NFT', async () => {
nftFactory = new NftFactory(
contractHandler.factory721Address,
contracts.factory721Address,
web3,
ERC721Factory.abi as AbiItem[]
)
@ -139,8 +139,8 @@ describe('Datatoken', () => {
it('#createFixedRate - should create FRE for the erc20 dt', async () => {
const freParams: FreCreationParams = {
fixedRateAddress: contractHandler.fixedRateAddress,
baseTokenAddress: contractHandler.daiAddress,
fixedRateAddress: contracts.fixedRateAddress,
baseTokenAddress: contracts.daiAddress,
owner: nftOwner,
marketFeeCollector: nftOwner,
baseTokenDecimals: 18,
@ -157,8 +157,8 @@ describe('Datatoken', () => {
it('#createFixedRate - should FAIL create FRE if NOT ERC20Deployer', async () => {
assert((await nftDatatoken.isErc20Deployer(nftAddress, user3)) === false)
const freParams: FreCreationParams = {
fixedRateAddress: contractHandler.fixedRateAddress,
baseTokenAddress: contractHandler.daiAddress,
fixedRateAddress: contracts.fixedRateAddress,
baseTokenAddress: contracts.daiAddress,
owner: nftOwner,
marketFeeCollector: nftOwner,
baseTokenDecimals: 18,
@ -182,7 +182,7 @@ describe('Datatoken', () => {
const dispenser = await datatoken.createDispenser(
datatokenAddress,
nftOwner,
contractHandler.dispenserAddress,
contracts.dispenserAddress,
dispenserParams
)
assert(dispenser !== null)
@ -198,7 +198,7 @@ describe('Datatoken', () => {
await datatoken.createDispenser(
datatokenAddress,
user2,
contractHandler.dispenserAddress,
contracts.dispenserAddress,
dispenserParams
)
} catch (e) {
@ -403,7 +403,7 @@ describe('Datatoken', () => {
datatokenAddress,
nftOwner,
order,
contractHandler.dispenserAddress
contracts.dispenserAddress
)
assert(buyFromDispenseTx !== null)
})

9
test/unit/tokens/Nft.test.ts
View File

@ -1,7 +1,7 @@
import { assert } from 'chai'
import ERC721Factory from '@oceanprotocol/contracts/artifacts/contracts/ERC721Factory.sol/ERC721Factory.json'
import ERC721Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC721Template.sol/ERC721Template.json'
import { TestContractHandler } from '../../TestContractHandler'
import { deployContracts, Addresses } from '../../TestContractHandler'
import { AbiItem } from 'web3-utils'
import sha256 from 'crypto-js/sha256'
import { web3 } from '../../config'
@ -13,7 +13,7 @@ describe('NFT', () => {
let user1: string
let user2: string
let user3: string
let contractHandler: TestContractHandler
let contracts: Addresses
let nftDatatoken: Nft
let nftFactory: NftFactory
let nftAddress: string
@ -32,13 +32,12 @@ describe('NFT', () => {
})
it('should deploy contracts', async () => {
contractHandler = new TestContractHandler(web3)
await contractHandler.deployContracts(nftOwner)
contracts = await deployContracts(nftOwner)
})
it('should initialize NFTFactory instance and create a new NFT', async () => {
nftFactory = new NftFactory(
contractHandler.factory721Address,
contracts.factory721Address,
web3,
ERC721Factory.abi as AbiItem[]
)