convert TestContractHandler class to function

test/TestContractHandler.ts

@@ -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 (
+const estimateGasAndDeployContract = async (
-  contract: Contract,
+  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 {
+export interface Addresses {
-  public ERC721Factory: Contract
+  factory721Address: string
-  public ERC20Template: Contract
+  template721Address: string
-  public ERC721Template: Contract
+  template20Address: string
-  public Router: Contract
+  routerAddress: string
-  public SideStaking: Contract
+  sideStakingAddress: string
-  public FixedRate: Contract
+  fixedRateAddress: string
-  public Dispenser: Contract
+  dispenserAddress: string
-  public OPFCollector: Contract
+  poolTemplateAddress: string
-  public PoolTemplate: Contract
+  opfCollectorAddress: string
-  public MockERC20: Contract
+  oceanAddress: string
-  public MockOcean: Contract
+  daiAddress: string
-
+  usdcAddress: string
-  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) {
+export const deployContracts = async (owner: string): Promise<Addresses> => {
   const addresses = getAddresses()
 
   // DEPLOY OPF Fee Collector
-    this.opfCollectorAddress =
+  addresses.opfCollectorAddress =
     addresses.OPFCommunityFeeCollector ||
-      (await deployContract(
+    (await estimateGasAndDeployContract(
-        this.OPFCollector,
+      OPFCommunityFeeCollector.abi as AbiItem[],
       OPFCommunityFeeCollector.bytecode,
       [owner, owner],
       owner
     ))
 
   // DEPLOY POOL TEMPLATE
-    this.poolTemplateAddress =
+  addresses.poolTemplateAddress =
     addresses.poolTemplate ||
-      (await deployContract(this.PoolTemplate, PoolTemplate.bytecode, [], owner))
+    (await estimateGasAndDeployContract(
+      PoolTemplate.abi as AbiItem[],
+      PoolTemplate.bytecode,
+      [],
+      owner
+    ))
 
   // DEPLOY ERC20 TEMPLATE
-    this.template20Address =
+  addresses.template20Address =
     addresses.ERC20Template['1'] ||
-      (await deployContract(this.ERC20Template, ERC20Template.bytecode, [], owner))
+    (await estimateGasAndDeployContract(
+      ERC20Template.abi as AbiItem[],
+      ERC20Template.bytecode,
+      [],
+      owner
+    ))
 
   // DEPLOY ERC721 TEMPLATE
-    this.template721Address =
+  addresses.template721Address =
     addresses.ERC721Template['1'] ||
-      (await deployContract(this.ERC721Template, ERC721Template.bytecode, [], owner))
+    (await estimateGasAndDeployContract(
+      ERC721Template.abi as AbiItem[],
+      ERC721Template.bytecode,
+      [],
+      owner
+    ))
 
   // DEPLOY OCEAN MOCK
-    this.oceanAddress =
+  addresses.oceanAddress =
     addresses.Ocean ||
-      (await deployContract(
+    (await estimateGasAndDeployContract(
-        this.MockERC20,
+      MockERC20.abi as AbiItem[],
       MockERC20.bytecode,
       ['OCEAN', 'OCEAN', 18],
       owner
     ))
 
   // DEPLOY ROUTER
-    this.routerAddress =
+  addresses.routerAddress =
     addresses.Router ||
-      (await deployContract(
+    (await estimateGasAndDeployContract(
-        this.Router,
+      Router.abi as AbiItem[],
       Router.bytecode,
       [
         owner,
-          this.oceanAddress,
+        addresses.oceanAddress,
-          this.poolTemplateAddress,
+        addresses.poolTemplateAddress,
-          this.opfCollectorAddress,
+        addresses.opfCollectorAddress,
         []
       ],
       owner
     ))
 
   // DEPLOY SIDE STAKING
-    this.sideStakingAddress =
+  addresses.sideStakingAddress =
     addresses.Staking ||
-      (await deployContract(
+    (await estimateGasAndDeployContract(
-        this.SideStaking,
+      SideStaking.abi as AbiItem[],
       SideStaking.bytecode,
-        [this.routerAddress],
+      [addresses.routerAddress],
       owner
     ))
 
   // DEPLOY FIXED RATE
-    this.fixedRateAddress =
+  addresses.fixedRateAddress =
     addresses.FixedPrice ||
-      (await deployContract(
+    (await estimateGasAndDeployContract(
-        this.FixedRate,
+      FixedRate.abi as AbiItem[],
       FixedRate.bytecode,
-        [this.routerAddress, this.opfCollectorAddress],
+      [addresses.routerAddress, addresses.opfCollectorAddress],
       owner
     ))
 
   // DEPLOY Dispenser
-    this.dispenserAddress =
+  addresses.dispenserAddress =
     addresses.Dispenser ||
-      (await deployContract(
+    (await estimateGasAndDeployContract(
-        this.Dispenser,
+      Dispenser.abi as AbiItem[],
       Dispenser.bytecode,
-        [this.routerAddress],
+      [addresses.routerAddress],
       owner
     ))
 
   // DEPLOY ERC721 FACTORY
-    this.factory721Address =
+  addresses.factory721Address =
     addresses.ERC721Factory ||
-      (await deployContract(
+    (await estimateGasAndDeployContract(
-        this.ERC721Factory,
+      ERC721Factory.abi as AbiItem[],
       ERC721Factory.bytecode,
       [
-          this.template721Address,
+        addresses.template721Address,
-          this.template20Address,
+        addresses.template20Address,
-          this.opfCollectorAddress,
+        addresses.opfCollectorAddress,
-          this.routerAddress
+        addresses.routerAddress
       ],
       owner
     ))
 
   // DEPLOY USDC MOCK
-    this.usdcAddress =
+  addresses.usdcAddress =
     addresses.MockUSDC ||
-      (await deployContract(
+    (await estimateGasAndDeployContract(
-        this.MockERC20,
+      MockERC20.abi as AbiItem[],
       MockERC20.bytecode,
       ['USDC', 'USDC', 6],
       owner
     ))
 
   // DEPLOY DAI MOCK
-    this.daiAddress =
+  addresses.daiAddress =
     addresses.MockDAI ||
-      (await deployContract(
+    (await estimateGasAndDeployContract(
-        this.MockERC20,
+      MockERC20.abi as AbiItem[],
       MockERC20.bytecode,
       ['DAI', 'DAI', 18],
       owner
     ))
 
   if (!addresses.Router) {
-      const RouterContract = new this.web3.eth.Contract(
+    const RouterContract = new web3.eth.Contract(
       Router.abi as AbiItem[],
-        this.routerAddress
+      addresses.routerAddress
     )
 
     await RouterContract.methods
-        .addFactory(this.factory721Address)
+      .addFactory(addresses.factory721Address)
       .send({ from: owner })
     await RouterContract.methods
-        .addFixedRateContract(this.fixedRateAddress)
+      .addFixedRateContract(addresses.fixedRateAddress)
       .send({ from: owner })
     await RouterContract.methods
-        .addDispenserContract(this.dispenserAddress)
+      .addDispenserContract(addresses.dispenserAddress)
       .send({ from: owner })
     await RouterContract.methods
-        .addSSContract(this.sideStakingAddress)
+      .addSSContract(addresses.sideStakingAddress)
       .send({ from: owner })
     // TODO: add OPF deployment
     // await RouterContract.methods
     //   .changeRouterOwner(this.opfCollectorAddress)
     //   .send({ from: owner })
   }
-  }
+  return addresses
 }

test/unit/NftFactory.test.ts

@@ -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)
+    contracts = await deployContracts(factoryOwner)
-    await contracts.deployContracts(factoryOwner)
 
     const daiContract = new web3.eth.Contract(
-      contracts.MockERC20.options.jsonInterface,
+      MockERC20.abi as AbiItem[],
       contracts.daiAddress
     )
     await daiContract.methods

test/unit/pools/Router.test.ts

@@ -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)
+    contracts = await deployContracts(factoryOwner)
-    await contracts.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
     )
 

test/unit/pools/balancer/Pool.test.ts

@@ -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)
+    contracts = await deployContracts(factoryOwner)
-    await contracts.deployContracts(factoryOwner)
 
     // initialize Pool instance
     pool = new Pool(web3, PoolTemplate.abi as AbiItem[])
     assert(pool != null)
 
-    daiContract = new web3.eth.Contract(
+    daiContract = new web3.eth.Contract(MockERC20.abi as AbiItem[], contracts.daiAddress)
-      contracts.MockERC20.options.jsonInterface,
-      contracts.daiAddress
-    )
 
     usdcContract = new web3.eth.Contract(
-      contracts.MockERC20.options.jsonInterface,
+      MockERC20.abi as AbiItem[],
       contracts.usdcAddress
     )
     await approve(

test/unit/pools/dispenser/Dispenser.test.ts

@@ -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)
+    contracts = await deployContracts(factoryOwner)
-    await contracts.deployContracts(factoryOwner)
   })
 
   it('should initialize Dispenser class', async () => {

test/unit/pools/fixedRate/FixedRateExchange.test.ts

@@ -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)
+    contracts = await deployContracts(factoryOwner)
-    await contracts.deployContracts(factoryOwner)
 
     // initialize fixed rate
     //
 
-    daiContract = new web3.eth.Contract(
+    daiContract = new web3.eth.Contract(MockERC20.abi as AbiItem[], contracts.daiAddress)
-      contracts.MockERC20.options.jsonInterface,
-      contracts.daiAddress
-    )
 
     usdcContract = new web3.eth.Contract(
-      contracts.MockERC20.options.jsonInterface,
+      MockERC20.abi as AbiItem[],
       contracts.usdcAddress
     )
   })

test/unit/pools/ssContracts/SideStaking.test.ts

@@ -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(
+    daiContract = new web3.eth.Contract(MockERC20.abi as AbiItem[], contracts.daiAddress)
-      contracts.MockERC20.options.jsonInterface,
-      contracts.daiAddress
-    )
 
     usdcContract = new web3.eth.Contract(
-      contracts.MockERC20.options.jsonInterface,
+      MockERC20.abi as AbiItem[],
       contracts.usdcAddress
     )
     await approve(

test/unit/tokens/Datatoken.test.ts

@@ -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)
+    contracts = await deployContracts(nftOwner)
-    await contractHandler.deployContracts(nftOwner)
 
     const daiContract = new web3.eth.Contract(
-      contractHandler.MockERC20.options.jsonInterface,
+      MockERC20.abi as AbiItem[],
-      contractHandler.daiAddress
+      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,
+      fixedRateAddress: contracts.fixedRateAddress,
-      baseTokenAddress: contractHandler.daiAddress,
+      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,
+      fixedRateAddress: contracts.fixedRateAddress,
-      baseTokenAddress: contractHandler.daiAddress,
+      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)
   })

test/unit/tokens/Nft.test.ts

@@ -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)
+    contracts = await deployContracts(nftOwner)
-    await contractHandler.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[]
     )