From c07a528dbe65019eea11a12fcdb7803a0a85f392 Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Mon, 21 Mar 2022 15:22:24 +0100
Subject: [PATCH 01/17] change NftFactory test directory

---
 package.json                                 |  2 +-
 test/unit/{ => factories}/NftFactory.test.ts | 14 ++++++++++----
 2 files changed, 11 insertions(+), 5 deletions(-)
 rename test/unit/{ => factories}/NftFactory.test.ts (97%)

diff --git a/package.json b/package.json
index 477128a1..4379c494 100644
--- a/package.json
+++ b/package.json
@@ -33,7 +33,7 @@
     "test:dispenser": "npm run mocha -- 'test/unit/pools/dispenser/Dispenser.test.ts'",
     "test:dt": "npm run mocha -- 'test/unit/tokens/Datatoken.test.ts'",
     "test:nftDt": "npm run mocha -- 'test/unit/tokens/Nft.test.ts'",
-    "test:factory": "npm run mocha -- 'test/unit/NftFactory.test.ts'",
+    "test:factory": "npm run mocha -- 'test/unit/factories/NftFactory.test.ts'",
     "test:router": "npm run mocha -- 'test/unit/pools/Router.test.ts'",
     "test:publishAll": "npm run mocha -- 'test/integration/PublishFlows.test.ts'",
     "test:unit": "npm run mocha -- 'test/unit/**/*.test.ts'",
diff --git a/test/unit/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
similarity index 97%
rename from test/unit/NftFactory.test.ts
rename to test/unit/factories/NftFactory.test.ts
index d60d0c3a..7f1d0f2e 100644
--- a/test/unit/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -1,16 +1,22 @@
 import { assert, expect } from 'chai'
 import { AbiItem } from 'web3-utils/types'
-import { deployContracts, Addresses } 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 { web3 } from '../../config'
+import {
+  NftFactory,
+  NftCreateData,
+  TokenOrder,
+  ZERO_ADDRESS,
+  signHash
+} from '../../../src'
 import {
   ProviderFees,
   FreCreationParams,
   Erc20CreateParams,
   PoolCreationParams
-} from '../../src/@types'
+} from '../../../src/@types'
 
 describe('Nft Factory test', () => {
   let factoryOwner: string

From 352b52afb3eb65bef4fa57ff3ea42e8ce847eb92 Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Wed, 23 Mar 2022 13:10:45 +0100
Subject: [PATCH 02/17] remove unused accounts

---
 test/unit/factories/NftFactory.test.ts | 66 ++++++++++++--------------
 1 file changed, 31 insertions(+), 35 deletions(-)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index 7f1d0f2e..59726fe1 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -20,10 +20,8 @@ import {
 
 describe('Nft Factory test', () => {
   let factoryOwner: string
-  let nftOwner: string
   let user1: string
   let user2: string
-  let user3: string
   let contracts: Addresses
   let nftFactory: NftFactory
   let dtAddress: string
@@ -33,10 +31,8 @@ describe('Nft Factory test', () => {
   before(async () => {
     const accounts = await web3.eth.getAccounts()
     factoryOwner = accounts[0]
-    nftOwner = accounts[1]
-    user1 = accounts[2]
-    user2 = accounts[3]
-    user3 = accounts[4]
+    user1 = accounts[1]
+    user2 = accounts[2]
   })
 
   it('should deploy contracts', async () => {
@@ -83,8 +79,8 @@ describe('Nft Factory test', () => {
     const ercParams: Erc20CreateParams = {
       templateIndex: 1,
       minter: factoryOwner,
-      feeManager: user3,
-      mpFeeAddress: user2,
+      feeManager: user2,
+      mpFeeAddress: user1,
       feeToken: '0x0000000000000000000000000000000000000000',
       cap: '10000',
       feeAmount: '0',
@@ -118,9 +114,9 @@ describe('Nft Factory test', () => {
 
     const ercParams: Erc20CreateParams = {
       templateIndex: 1,
-      minter: user2,
-      feeManager: user3,
-      mpFeeAddress: user2,
+      minter: user1,
+      feeManager: user2,
+      mpFeeAddress: user1,
       feeToken: '0x0000000000000000000000000000000000000000',
       cap: '1000000',
       feeAmount: '0',
@@ -169,8 +165,8 @@ describe('Nft Factory test', () => {
     const ercParams: Erc20CreateParams = {
       templateIndex: 1,
       minter: factoryOwner,
-      feeManager: user3,
-      mpFeeAddress: user2,
+      feeManager: user2,
+      mpFeeAddress: user1,
       feeToken: '0x0000000000000000000000000000000000000000',
       cap: '1000000',
       feeAmount: '0',
@@ -219,8 +215,8 @@ describe('Nft Factory test', () => {
     const ercParams: Erc20CreateParams = {
       templateIndex: 1,
       minter: factoryOwner,
-      feeManager: user3,
-      mpFeeAddress: user2,
+      feeManager: user2,
+      mpFeeAddress: user1,
       feeToken: '0x0000000000000000000000000000000000000000',
       cap: '1000000',
       feeAmount: '0',
@@ -253,39 +249,39 @@ describe('Nft Factory test', () => {
   })
 
   it('#startMultipleTokenOrder- should succed to start multiple orders', async () => {
-    const consumer = user2 // could be different user
+    const consumer = user1 // could be different user
     const dtAmount = web3.utils.toWei('1')
     const serviceIndex = 1 // dummy index
-    const consumeFeeAddress = user3 // marketplace fee Collector
+    const consumeFeeAddress = user2 // marketplace fee Collector
     const consumeFeeAmount = '0' // fee to be collected on top, requires approval
     const consumeFeeToken = contracts.daiAddress // token address for the feeAmount, in this case DAI
 
     // we reuse a DT created in a previous test
     const dtContract = new web3.eth.Contract(ERC20Template.abi as AbiItem[], dtAddress)
-    expect(await dtContract.methods.balanceOf(user2).call()).to.equal('0')
+    expect(await dtContract.methods.balanceOf(user1).call()).to.equal('0')
 
-    // dt owner mint dtAmount to user2
-    await dtContract.methods.mint(user2, dtAmount).send({ from: factoryOwner })
+    // dt owner mint dtAmount to user1
+    await dtContract.methods.mint(user1, dtAmount).send({ from: factoryOwner })
 
-    // user2 approves NFTFactory to move his dtAmount
+    // user1 approves NFTFactory to move his dtAmount
     await dtContract.methods
       .approve(contracts.erc721FactoryAddress, dtAmount)
-      .send({ from: user2 })
+      .send({ from: user1 })
 
     // we reuse another DT created in a previous test
     const dtContract2 = new web3.eth.Contract(ERC20Template.abi as AbiItem[], dtAddress2)
-    expect(await dtContract2.methods.balanceOf(user2).call()).to.equal('0')
+    expect(await dtContract2.methods.balanceOf(user1).call()).to.equal('0')
 
-    // dt owner mint dtAmount to user2
-    await dtContract2.methods.mint(user2, dtAmount).send({ from: factoryOwner })
-    // user2 approves NFTFactory to move his dtAmount
+    // dt owner mint dtAmount to user1
+    await dtContract2.methods.mint(user1, dtAmount).send({ from: factoryOwner })
+    // user1 approves NFTFactory to move his dtAmount
     await dtContract2.methods
       .approve(contracts.erc721FactoryAddress, dtAmount)
-      .send({ from: user2 })
+      .send({ from: user1 })
 
-    // we check user2 has enought DTs
-    expect(await dtContract.methods.balanceOf(user2).call()).to.equal(dtAmount)
-    expect(await dtContract2.methods.balanceOf(user2).call()).to.equal(dtAmount)
+    // we check user1 has enought DTs
+    expect(await dtContract.methods.balanceOf(user1).call()).to.equal(dtAmount)
+    expect(await dtContract2.methods.balanceOf(user1).call()).to.equal(dtAmount)
 
     const providerData = JSON.stringify({ timeout: 0 })
     const providerValidUntil = '0'
@@ -330,16 +326,16 @@ describe('Nft Factory test', () => {
         _consumeMarketFee: consumeMarketFee
       }
     ]
-    await nftFactory.startMultipleTokenOrder(user2, orders)
-    // we check user2 has no more DTs
-    expect(await dtContract.methods.balanceOf(user2).call()).to.equal('0')
-    expect(await dtContract2.methods.balanceOf(user2).call()).to.equal('0')
+    await nftFactory.startMultipleTokenOrder(user1, orders)
+    // we check user1 has no more DTs
+    expect(await dtContract.methods.balanceOf(user1).call()).to.equal('0')
+    expect(await dtContract2.methods.balanceOf(user1).call()).to.equal('0')
   })
 
   it('#checkDatatoken - should confirm if DT is from the factory', async () => {
     assert((await nftFactory.checkDatatoken(dtAddress)) === true)
     assert((await nftFactory.checkDatatoken(dtAddress2)) === true)
-    assert((await nftFactory.checkDatatoken(user2)) === false)
+    assert((await nftFactory.checkDatatoken(user1)) === false)
     assert((await nftFactory.checkDatatoken(nftAddress)) === false)
   })
 

From 4614833ce0ba79a2eeddf257832bf1d5969f6839 Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Wed, 23 Mar 2022 15:45:58 +0100
Subject: [PATCH 03/17] add constants

---
 test/unit/factories/NftFactory.test.ts | 117 ++++++++++++++-----------
 1 file changed, 64 insertions(+), 53 deletions(-)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index 59726fe1..00201e12 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -18,6 +18,17 @@ import {
   PoolCreationParams
 } from '../../../src/@types'
 
+const VESTING_AMOUNT = '10000'
+const CAP_AMOUNT = '1000000'
+const NFT_NAME = '72120Bundle'
+const NFT_SYMBOL = '72Bundle'
+const TOKEN_URI = 'https://oceanprotocol.com/nft/'
+const ERC20_NAME = 'ERC20B1'
+const ERC20_SYMBOL = 'ERC20DT1Symbol'
+const RATE = '1'
+const FEE = '0.001'
+const FEE_ZERO = '0'
+
 describe('Nft Factory test', () => {
   let factoryOwner: string
   let user1: string
@@ -37,14 +48,6 @@ describe('Nft Factory test', () => {
 
   it('should deploy contracts', async () => {
     contracts = await deployContracts(web3, factoryOwner)
-
-    const daiContract = new web3.eth.Contract(
-      MockERC20.abi as AbiItem[],
-      contracts.daiAddress
-    )
-    await daiContract.methods
-      .approve(contracts.erc721FactoryAddress, web3.utils.toWei('10000'))
-      .send({ from: factoryOwner })
   })
 
   it('should initiate NFTFactory instance', async () => {
@@ -61,6 +64,7 @@ describe('Nft Factory test', () => {
     assert(nftTemplate.isActive === true)
     assert(nftTemplate.templateAddress === contracts.erc721TemplateAddress)
   })
+
   it('#getTokenTemplate - should return Token template struct', async () => {
     const tokenTemplate = await nftFactory.getTokenTemplate(1)
     assert(tokenTemplate.isActive === true)
@@ -70,10 +74,10 @@ describe('Nft Factory test', () => {
   it('#createNftwithErc - should create an NFT and a Datatoken ', async () => {
     // we prepare transaction parameters objects
     const nftData: NftCreateData = {
-      name: '72120Bundle',
-      symbol: '72Bundle',
+      name: NFT_NAME,
+      symbol: NFT_SYMBOL,
       templateIndex: 1,
-      tokenURI: 'https://oceanprotocol.com/nft/'
+      tokenURI: TOKEN_URI
     }
 
     const ercParams: Erc20CreateParams = {
@@ -81,11 +85,11 @@ describe('Nft Factory test', () => {
       minter: factoryOwner,
       feeManager: user2,
       mpFeeAddress: user1,
-      feeToken: '0x0000000000000000000000000000000000000000',
-      cap: '10000',
-      feeAmount: '0',
-      name: 'ERC20B1',
-      symbol: 'ERC20DT1Symbol'
+      feeToken: ZERO_ADDRESS,
+      cap: CAP_AMOUNT,
+      feeAmount: FEE_ZERO,
+      name: ERC20_NAME,
+      symbol: ERC20_SYMBOL
     }
 
     const txReceipt = await nftFactory.createNftWithErc20(
@@ -106,10 +110,10 @@ describe('Nft Factory test', () => {
   it('#createNftErcWithPool- should create an NFT, a Datatoken and a pool DT/DAI', async () => {
     // we prepare transaction parameters objects
     const nftData: NftCreateData = {
-      name: '72120Bundle',
-      symbol: '72Bundle',
+      name: NFT_NAME,
+      symbol: NFT_SYMBOL,
       templateIndex: 1,
-      tokenURI: 'https://oceanprotocol.com/nft/'
+      tokenURI: TOKEN_URI
     }
 
     const ercParams: Erc20CreateParams = {
@@ -117,11 +121,11 @@ describe('Nft Factory test', () => {
       minter: user1,
       feeManager: user2,
       mpFeeAddress: user1,
-      feeToken: '0x0000000000000000000000000000000000000000',
-      cap: '1000000',
-      feeAmount: '0',
-      name: 'ERC20B1',
-      symbol: 'ERC20DT1Symbol'
+      feeToken: ZERO_ADDRESS,
+      cap: CAP_AMOUNT,
+      feeAmount: FEE_ZERO,
+      name: ERC20_NAME,
+      symbol: ERC20_SYMBOL
     }
 
     const poolParams: PoolCreationParams = {
@@ -131,15 +135,25 @@ describe('Nft Factory test', () => {
       publisherAddress: factoryOwner,
       marketFeeCollector: factoryOwner,
       poolTemplateAddress: contracts.poolTemplateAddress,
-      rate: '1',
+      rate: RATE,
       baseTokenDecimals: 18,
-      vestingAmount: '10000',
+      vestingAmount: VESTING_AMOUNT,
       vestedBlocks: 2500000,
       initialBaseTokenLiquidity: '2000',
-      swapFeeLiquidityProvider: '0.001',
-      swapFeeMarketRunner: '0.001'
+      swapFeeLiquidityProvider: FEE,
+      swapFeeMarketRunner: FEE
     }
 
+    // approve VESTING_AMOUNT DAI to nftFactory
+    const daiContract = new web3.eth.Contract(
+      MockERC20.abi as AbiItem[],
+      contracts.daiAddress
+    )
+
+    await daiContract.methods
+      .approve(contracts.erc721FactoryAddress, web3.utils.toWei(VESTING_AMOUNT))
+      .send({ from: factoryOwner })
+
     const txReceipt = await nftFactory.createNftErc20WithPool(
       factoryOwner,
       nftData,
@@ -156,10 +170,10 @@ describe('Nft Factory test', () => {
   it('#createNftErcWithFixedRate- should create an NFT, a datatoken and create a Fixed Rate Exchange', async () => {
     // we prepare transaction parameters objects
     const nftData: NftCreateData = {
-      name: '72120Bundle',
-      symbol: '72Bundle',
+      name: NFT_NAME,
+      symbol: NFT_SYMBOL,
       templateIndex: 1,
-      tokenURI: 'https://oceanprotocol.com/nft/'
+      tokenURI: TOKEN_URI
     }
 
     const ercParams: Erc20CreateParams = {
@@ -167,11 +181,11 @@ describe('Nft Factory test', () => {
       minter: factoryOwner,
       feeManager: user2,
       mpFeeAddress: user1,
-      feeToken: '0x0000000000000000000000000000000000000000',
-      cap: '1000000',
-      feeAmount: '0',
-      name: 'ERC20B1',
-      symbol: 'ERC20DT1Symbol'
+      feeToken: ZERO_ADDRESS,
+      cap: CAP_AMOUNT,
+      feeAmount: FEE_ZERO,
+      name: ERC20_NAME,
+      symbol: ERC20_SYMBOL
     }
 
     const freParams: FreCreationParams = {
@@ -181,8 +195,8 @@ describe('Nft Factory test', () => {
       marketFeeCollector: factoryOwner,
       baseTokenDecimals: 18,
       datatokenDecimals: 18,
-      fixedRate: '1',
-      marketFee: '0.001',
+      fixedRate: RATE,
+      marketFee: FEE,
       allowedConsumer: factoryOwner,
       withMint: false
     }
@@ -206,10 +220,10 @@ describe('Nft Factory test', () => {
   it('#createNftErcWithDispenser- should create an NFT, a datatoken and create a Dispenser', async () => {
     // we prepare transaction parameters objects
     const nftData: NftCreateData = {
-      name: '72120Bundle',
-      symbol: '72Bundle',
+      name: NFT_NAME,
+      symbol: NFT_SYMBOL,
       templateIndex: 1,
-      tokenURI: 'https://oceanprotocol.com/nft/'
+      tokenURI: TOKEN_URI
     }
 
     const ercParams: Erc20CreateParams = {
@@ -217,11 +231,11 @@ describe('Nft Factory test', () => {
       minter: factoryOwner,
       feeManager: user2,
       mpFeeAddress: user1,
-      feeToken: '0x0000000000000000000000000000000000000000',
-      cap: '1000000',
-      feeAmount: '0',
-      name: 'ERC20B1',
-      symbol: 'ERC20DT1Symbol'
+      feeToken: ZERO_ADDRESS,
+      cap: CAP_AMOUNT,
+      feeAmount: FEE_ZERO,
+      name: ERC20_NAME,
+      symbol: ERC20_SYMBOL
     }
 
     const dispenserParams = {
@@ -306,9 +320,9 @@ describe('Nft Factory test', () => {
       validUntil: providerValidUntil
     }
     const consumeMarketFee = {
-      consumeMarketFeeAddress: '0x0000000000000000000000000000000000000000',
-      consumeMarketFeeToken: '0x0000000000000000000000000000000000000000',
-      consumeMarketFeeAmount: '0'
+      consumeMarketFeeAddress: ZERO_ADDRESS,
+      consumeMarketFeeToken: ZERO_ADDRESS,
+      consumeMarketFeeAmount: FEE_ZERO
     }
     const orders: TokenOrder[] = [
       {
@@ -340,10 +354,7 @@ describe('Nft Factory test', () => {
   })
 
   it('#checkNFT - should return nftAddress if from the factory, or address(0) if not', async () => {
-    assert(
-      (await nftFactory.checkNFT(dtAddress)) ===
-        '0x0000000000000000000000000000000000000000'
-    )
+    assert((await nftFactory.checkNFT(dtAddress)) === ZERO_ADDRESS)
     assert((await nftFactory.checkNFT(nftAddress)) === nftAddress)
   })
 })

From a72c510b9e6bbe87c24c76a565119d2de8df9c6b Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Wed, 23 Mar 2022 15:54:38 +0100
Subject: [PATCH 04/17] add DATA_TOKEN_AMOUNT constant

---
 test/unit/factories/NftFactory.test.ts | 34 +++++++++++++-------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index 00201e12..0b2abd9c 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -20,9 +20,10 @@ import {
 
 const VESTING_AMOUNT = '10000'
 const CAP_AMOUNT = '1000000'
+const DATA_TOKEN_AMOUNT = web3.utils.toWei('1')
 const NFT_NAME = '72120Bundle'
 const NFT_SYMBOL = '72Bundle'
-const TOKEN_URI = 'https://oceanprotocol.com/nft/'
+const NFT_TOKEN_URI = 'https://oceanprotocol.com/nft/'
 const ERC20_NAME = 'ERC20B1'
 const ERC20_SYMBOL = 'ERC20DT1Symbol'
 const RATE = '1'
@@ -77,7 +78,7 @@ describe('Nft Factory test', () => {
       name: NFT_NAME,
       symbol: NFT_SYMBOL,
       templateIndex: 1,
-      tokenURI: TOKEN_URI
+      tokenURI: NFT_TOKEN_URI
     }
 
     const ercParams: Erc20CreateParams = {
@@ -113,7 +114,7 @@ describe('Nft Factory test', () => {
       name: NFT_NAME,
       symbol: NFT_SYMBOL,
       templateIndex: 1,
-      tokenURI: TOKEN_URI
+      tokenURI: NFT_TOKEN_URI
     }
 
     const ercParams: Erc20CreateParams = {
@@ -173,7 +174,7 @@ describe('Nft Factory test', () => {
       name: NFT_NAME,
       symbol: NFT_SYMBOL,
       templateIndex: 1,
-      tokenURI: TOKEN_URI
+      tokenURI: NFT_TOKEN_URI
     }
 
     const ercParams: Erc20CreateParams = {
@@ -223,7 +224,7 @@ describe('Nft Factory test', () => {
       name: NFT_NAME,
       symbol: NFT_SYMBOL,
       templateIndex: 1,
-      tokenURI: TOKEN_URI
+      tokenURI: NFT_TOKEN_URI
     }
 
     const ercParams: Erc20CreateParams = {
@@ -264,38 +265,37 @@ describe('Nft Factory test', () => {
 
   it('#startMultipleTokenOrder- should succed to start multiple orders', async () => {
     const consumer = user1 // could be different user
-    const dtAmount = web3.utils.toWei('1')
     const serviceIndex = 1 // dummy index
     const consumeFeeAddress = user2 // marketplace fee Collector
-    const consumeFeeAmount = '0' // fee to be collected on top, requires approval
+    const consumeFeeAmount = FEE_ZERO // fee to be collected on top, requires approval
     const consumeFeeToken = contracts.daiAddress // token address for the feeAmount, in this case DAI
 
     // we reuse a DT created in a previous test
     const dtContract = new web3.eth.Contract(ERC20Template.abi as AbiItem[], dtAddress)
     expect(await dtContract.methods.balanceOf(user1).call()).to.equal('0')
 
-    // dt owner mint dtAmount to user1
-    await dtContract.methods.mint(user1, dtAmount).send({ from: factoryOwner })
+    // dt owner mint DATA_TOKEN_AMOUNT to user1
+    await dtContract.methods.mint(user1, DATA_TOKEN_AMOUNT).send({ from: factoryOwner })
 
-    // user1 approves NFTFactory to move his dtAmount
+    // user1 approves NFTFactory to move his DATA_TOKEN_AMOUNT
     await dtContract.methods
-      .approve(contracts.erc721FactoryAddress, dtAmount)
+      .approve(contracts.erc721FactoryAddress, DATA_TOKEN_AMOUNT)
       .send({ from: user1 })
 
     // we reuse another DT created in a previous test
     const dtContract2 = new web3.eth.Contract(ERC20Template.abi as AbiItem[], dtAddress2)
     expect(await dtContract2.methods.balanceOf(user1).call()).to.equal('0')
 
-    // dt owner mint dtAmount to user1
-    await dtContract2.methods.mint(user1, dtAmount).send({ from: factoryOwner })
-    // user1 approves NFTFactory to move his dtAmount
+    // dt owner mint DATA_TOKEN_AMOUNT to user1
+    await dtContract2.methods.mint(user1, DATA_TOKEN_AMOUNT).send({ from: factoryOwner })
+    // user1 approves NFTFactory to move his DATA_TOKEN_AMOUNT
     await dtContract2.methods
-      .approve(contracts.erc721FactoryAddress, dtAmount)
+      .approve(contracts.erc721FactoryAddress, DATA_TOKEN_AMOUNT)
       .send({ from: user1 })
 
     // we check user1 has enought DTs
-    expect(await dtContract.methods.balanceOf(user1).call()).to.equal(dtAmount)
-    expect(await dtContract2.methods.balanceOf(user1).call()).to.equal(dtAmount)
+    expect(await dtContract.methods.balanceOf(user1).call()).to.equal(DATA_TOKEN_AMOUNT)
+    expect(await dtContract2.methods.balanceOf(user1).call()).to.equal(DATA_TOKEN_AMOUNT)
 
     const providerData = JSON.stringify({ timeout: 0 })
     const providerValidUntil = '0'

From 054351b88a562dd3658260023fec394b5600247f Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Wed, 23 Mar 2022 16:43:20 +0100
Subject: [PATCH 05/17] refactor nft and dt parameters

---
 test/unit/factories/NftFactory.test.ts | 154 +++++++++----------------
 1 file changed, 56 insertions(+), 98 deletions(-)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index 0b2abd9c..0e347648 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -2,6 +2,7 @@ import { assert, expect } from 'chai'
 import { AbiItem } from 'web3-utils/types'
 import { deployContracts, Addresses } from '../../TestContractHandler'
 import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
+import ERC721Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC721Template.sol/ERC721Template.json'
 import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/MockERC20Decimals.sol/MockERC20Decimals.json'
 import { web3 } from '../../config'
 import {
@@ -9,7 +10,8 @@ import {
   NftCreateData,
   TokenOrder,
   ZERO_ADDRESS,
-  signHash
+  signHash,
+  Nft
 } from '../../../src'
 import {
   ProviderFees,
@@ -30,8 +32,16 @@ const RATE = '1'
 const FEE = '0.001'
 const FEE_ZERO = '0'
 
+const NFT_DATA: NftCreateData = {
+  name: NFT_NAME,
+  symbol: NFT_SYMBOL,
+  templateIndex: 1,
+  tokenURI: NFT_TOKEN_URI
+}
+
 describe('Nft Factory test', () => {
   let factoryOwner: string
+  let nftOwner: string
   let user1: string
   let user2: string
   let contracts: Addresses
@@ -39,12 +49,26 @@ describe('Nft Factory test', () => {
   let dtAddress: string
   let dtAddress2: string
   let nftAddress: string
+  let ercParams: Erc20CreateParams
 
   before(async () => {
     const accounts = await web3.eth.getAccounts()
     factoryOwner = accounts[0]
-    user1 = accounts[1]
-    user2 = accounts[2]
+    nftOwner = accounts[1]
+    user1 = accounts[2]
+    user2 = accounts[3]
+
+    ercParams = {
+      templateIndex: 1,
+      minter: nftOwner,
+      feeManager: user2,
+      mpFeeAddress: user1,
+      feeToken: ZERO_ADDRESS,
+      cap: CAP_AMOUNT,
+      feeAmount: FEE_ZERO,
+      name: ERC20_NAME,
+      symbol: ERC20_SYMBOL
+    }
   })
 
   it('should deploy contracts', async () => {
@@ -72,32 +96,19 @@ describe('Nft Factory test', () => {
     assert(tokenTemplate.templateAddress === contracts.erc20TemplateAddress)
   })
 
+  it('#createNft - should create an NFT', async () => {
+    // we prepare transaction parameters objects
+    const nftAddress = await nftFactory.createNFT(nftOwner, NFT_DATA)
+
+    // we check the created nft
+    const nftDatatoken = new Nft(web3, ERC721Template.abi as AbiItem[])
+    const tokenURI = await nftDatatoken.getTokenURI(nftAddress, 1)
+    assert(tokenURI === NFT_TOKEN_URI)
+  })
+
   it('#createNftwithErc - should create an NFT and a Datatoken ', async () => {
     // we prepare transaction parameters objects
-    const nftData: NftCreateData = {
-      name: NFT_NAME,
-      symbol: NFT_SYMBOL,
-      templateIndex: 1,
-      tokenURI: NFT_TOKEN_URI
-    }
-
-    const ercParams: Erc20CreateParams = {
-      templateIndex: 1,
-      minter: factoryOwner,
-      feeManager: user2,
-      mpFeeAddress: user1,
-      feeToken: ZERO_ADDRESS,
-      cap: CAP_AMOUNT,
-      feeAmount: FEE_ZERO,
-      name: ERC20_NAME,
-      symbol: ERC20_SYMBOL
-    }
-
-    const txReceipt = await nftFactory.createNftWithErc20(
-      factoryOwner,
-      nftData,
-      ercParams
-    )
+    const txReceipt = await nftFactory.createNftWithErc20(nftOwner, NFT_DATA, ercParams)
 
     // EVENTS HAVE BEEN EMITTED
     expect(txReceipt.events.NFTCreated.event === 'NFTCreated')
@@ -110,31 +121,12 @@ describe('Nft Factory test', () => {
 
   it('#createNftErcWithPool- should create an NFT, a Datatoken and a pool DT/DAI', async () => {
     // we prepare transaction parameters objects
-    const nftData: NftCreateData = {
-      name: NFT_NAME,
-      symbol: NFT_SYMBOL,
-      templateIndex: 1,
-      tokenURI: NFT_TOKEN_URI
-    }
-
-    const ercParams: Erc20CreateParams = {
-      templateIndex: 1,
-      minter: user1,
-      feeManager: user2,
-      mpFeeAddress: user1,
-      feeToken: ZERO_ADDRESS,
-      cap: CAP_AMOUNT,
-      feeAmount: FEE_ZERO,
-      name: ERC20_NAME,
-      symbol: ERC20_SYMBOL
-    }
-
     const poolParams: PoolCreationParams = {
       ssContract: contracts.sideStakingAddress,
       baseTokenAddress: contracts.daiAddress,
       baseTokenSender: contracts.erc721FactoryAddress,
-      publisherAddress: factoryOwner,
-      marketFeeCollector: factoryOwner,
+      publisherAddress: nftOwner,
+      marketFeeCollector: nftOwner,
       poolTemplateAddress: contracts.poolTemplateAddress,
       rate: RATE,
       baseTokenDecimals: 18,
@@ -152,12 +144,16 @@ describe('Nft Factory test', () => {
     )
 
     await daiContract.methods
-      .approve(contracts.erc721FactoryAddress, web3.utils.toWei(VESTING_AMOUNT))
+      .transfer(nftOwner, web3.utils.toWei(VESTING_AMOUNT))
       .send({ from: factoryOwner })
 
+    await daiContract.methods
+      .approve(contracts.erc721FactoryAddress, web3.utils.toWei(VESTING_AMOUNT))
+      .send({ from: nftOwner })
+
     const txReceipt = await nftFactory.createNftErc20WithPool(
-      factoryOwner,
-      nftData,
+      nftOwner,
+      NFT_DATA,
       ercParams,
       poolParams
     )
@@ -170,41 +166,22 @@ describe('Nft Factory test', () => {
 
   it('#createNftErcWithFixedRate- should create an NFT, a datatoken and create a Fixed Rate Exchange', async () => {
     // we prepare transaction parameters objects
-    const nftData: NftCreateData = {
-      name: NFT_NAME,
-      symbol: NFT_SYMBOL,
-      templateIndex: 1,
-      tokenURI: NFT_TOKEN_URI
-    }
-
-    const ercParams: Erc20CreateParams = {
-      templateIndex: 1,
-      minter: factoryOwner,
-      feeManager: user2,
-      mpFeeAddress: user1,
-      feeToken: ZERO_ADDRESS,
-      cap: CAP_AMOUNT,
-      feeAmount: FEE_ZERO,
-      name: ERC20_NAME,
-      symbol: ERC20_SYMBOL
-    }
-
     const freParams: FreCreationParams = {
       fixedRateAddress: contracts.fixedRateAddress,
       baseTokenAddress: contracts.daiAddress,
-      owner: factoryOwner,
-      marketFeeCollector: factoryOwner,
+      owner: nftOwner,
+      marketFeeCollector: nftOwner,
       baseTokenDecimals: 18,
       datatokenDecimals: 18,
       fixedRate: RATE,
       marketFee: FEE,
-      allowedConsumer: factoryOwner,
+      allowedConsumer: user1,
       withMint: false
     }
 
     const txReceipt = await nftFactory.createNftErc20WithFixedRate(
-      factoryOwner,
-      nftData,
+      nftOwner,
+      NFT_DATA,
       ercParams,
       freParams
     )
@@ -220,25 +197,6 @@ describe('Nft Factory test', () => {
 
   it('#createNftErcWithDispenser- should create an NFT, a datatoken and create a Dispenser', async () => {
     // we prepare transaction parameters objects
-    const nftData: NftCreateData = {
-      name: NFT_NAME,
-      symbol: NFT_SYMBOL,
-      templateIndex: 1,
-      tokenURI: NFT_TOKEN_URI
-    }
-
-    const ercParams: Erc20CreateParams = {
-      templateIndex: 1,
-      minter: factoryOwner,
-      feeManager: user2,
-      mpFeeAddress: user1,
-      feeToken: ZERO_ADDRESS,
-      cap: CAP_AMOUNT,
-      feeAmount: FEE_ZERO,
-      name: ERC20_NAME,
-      symbol: ERC20_SYMBOL
-    }
-
     const dispenserParams = {
       dispenserAddress: contracts.dispenserAddress,
       maxTokens: '1',
@@ -248,8 +206,8 @@ describe('Nft Factory test', () => {
     }
 
     const txReceipt = await nftFactory.createNftErc20WithDispenser(
-      factoryOwner,
-      nftData,
+      nftOwner,
+      NFT_DATA,
       ercParams,
       dispenserParams
     )
@@ -275,7 +233,7 @@ describe('Nft Factory test', () => {
     expect(await dtContract.methods.balanceOf(user1).call()).to.equal('0')
 
     // dt owner mint DATA_TOKEN_AMOUNT to user1
-    await dtContract.methods.mint(user1, DATA_TOKEN_AMOUNT).send({ from: factoryOwner })
+    await dtContract.methods.mint(user1, DATA_TOKEN_AMOUNT).send({ from: nftOwner })
 
     // user1 approves NFTFactory to move his DATA_TOKEN_AMOUNT
     await dtContract.methods
@@ -287,7 +245,7 @@ describe('Nft Factory test', () => {
     expect(await dtContract2.methods.balanceOf(user1).call()).to.equal('0')
 
     // dt owner mint DATA_TOKEN_AMOUNT to user1
-    await dtContract2.methods.mint(user1, DATA_TOKEN_AMOUNT).send({ from: factoryOwner })
+    await dtContract2.methods.mint(user1, DATA_TOKEN_AMOUNT).send({ from: nftOwner })
     // user1 approves NFTFactory to move his DATA_TOKEN_AMOUNT
     await dtContract2.methods
       .approve(contracts.erc721FactoryAddress, DATA_TOKEN_AMOUNT)

From c7608ea6b8a79980e5e3ef25921df60aa4abc09f Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Wed, 23 Mar 2022 17:11:34 +0100
Subject: [PATCH 06/17] #createNftwithErc - should increment nft and token
 count

---
 test/unit/factories/NftFactory.test.ts | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index 0e347648..4591595e 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -106,7 +106,7 @@ describe('Nft Factory test', () => {
     assert(tokenURI === NFT_TOKEN_URI)
   })
 
-  it('#createNftwithErc - should create an NFT and a Datatoken ', async () => {
+  it('#createNftwithErc - should create an NFT and a Datatoken', async () => {
     // we prepare transaction parameters objects
     const txReceipt = await nftFactory.createNftWithErc20(nftOwner, NFT_DATA, ercParams)
 
@@ -119,6 +119,16 @@ describe('Nft Factory test', () => {
     dtAddress = txReceipt.events.TokenCreated.returnValues.newTokenAddress
   })
 
+  it('#createNftwithErc - should increment nft and token count', async () => {
+    const currentNFTCount = await nftFactory.getCurrentNFTCount()
+    const currentTokenCount = await nftFactory.getCurrentTokenCount()
+
+    await nftFactory.createNftWithErc20(nftOwner, NFT_DATA, ercParams)
+
+    expect((await nftFactory.getCurrentNFTCount()) === currentNFTCount + 1)
+    expect((await nftFactory.getCurrentTokenCount()) === currentTokenCount + 1)
+  })
+
   it('#createNftErcWithPool- should create an NFT, a Datatoken and a pool DT/DAI', async () => {
     // we prepare transaction parameters objects
     const poolParams: PoolCreationParams = {

From ed2c725ac2f13b1277e7e8dee7aad5ebe619dab6 Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Wed, 23 Mar 2022 17:11:41 +0100
Subject: [PATCH 07/17] refactor comments

---
 test/unit/factories/NftFactory.test.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index 4591595e..a9bfa9e0 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -110,7 +110,7 @@ describe('Nft Factory test', () => {
     // we prepare transaction parameters objects
     const txReceipt = await nftFactory.createNftWithErc20(nftOwner, NFT_DATA, ercParams)
 
-    // EVENTS HAVE BEEN EMITTED
+    // events have been emitted
     expect(txReceipt.events.NFTCreated.event === 'NFTCreated')
     expect(txReceipt.events.TokenCreated.event === 'TokenCreated')
 
@@ -168,7 +168,7 @@ describe('Nft Factory test', () => {
       poolParams
     )
 
-    // EVENTS HAVE BEEN EMITTED
+    // events have been emitted
     expect(txReceipt.events.NFTCreated.event === 'NFTCreated')
     expect(txReceipt.events.TokenCreated.event === 'TokenCreated')
     expect(txReceipt.events.NewPool.event === 'NewPool')
@@ -196,7 +196,7 @@ describe('Nft Factory test', () => {
       freParams
     )
 
-    // EVENTS HAVE BEEN EMITTED
+    // events have been emitted
     expect(txReceipt.events.NFTCreated.event === 'NFTCreated')
     expect(txReceipt.events.TokenCreated.event === 'TokenCreated')
     expect(txReceipt.events.NewFixedRate.event === 'NewFixedRate')
@@ -222,7 +222,7 @@ describe('Nft Factory test', () => {
       dispenserParams
     )
 
-    // EVENTS HAVE BEEN EMITTED
+    // events have been emitted
     expect(txReceipt.events.NFTCreated.event === 'NFTCreated')
     expect(txReceipt.events.TokenCreated.event === 'TokenCreated')
     expect(txReceipt.events.DispenserCreated.event === 'DispenserCreated')

From 5e9f99752c0411c2f2e96bd517827eb725256ebd Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Wed, 23 Mar 2022 19:19:33 +0100
Subject: [PATCH 08/17] test adding disabling and reactivating templates

---
 test/unit/factories/NftFactory.test.ts | 68 ++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index a9bfa9e0..b694c723 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -325,4 +325,72 @@ describe('Nft Factory test', () => {
     assert((await nftFactory.checkNFT(dtAddress)) === ZERO_ADDRESS)
     assert((await nftFactory.checkNFT(nftAddress)) === nftAddress)
   })
+
+  it('#addNFTTemplate - should add a new erc721 token template', async () => {
+    const currentNFTTemplateCount = await nftFactory.getCurrentNFTTemplateCount()
+
+    await nftFactory.addNFTTemplate(factoryOwner, contracts.erc721TemplateAddress)
+
+    expect(
+      (await nftFactory.getCurrentNFTTemplateCount()) === currentNFTTemplateCount + 1
+    )
+  })
+
+  it('#disableNFTTemplate - should disable an erc721 token template', async () => {
+    const currentNFTTemplateCount = await nftFactory.getCurrentNFTTemplateCount()
+
+    let nftTemplate = await nftFactory.getNFTTemplate(currentNFTTemplateCount)
+    assert(nftTemplate.isActive === true)
+
+    await nftFactory.disableNFTTemplate(factoryOwner, currentNFTTemplateCount)
+
+    nftTemplate = await nftFactory.getNFTTemplate(currentNFTTemplateCount)
+    assert(nftTemplate.isActive === false)
+  })
+
+  it('#reactivateNFTTemplate - should reactivate an erc721 previously disabled token template', async () => {
+    const currentNFTTemplateCount = await nftFactory.getCurrentNFTTemplateCount()
+
+    let nftTemplate = await nftFactory.getNFTTemplate(currentNFTTemplateCount)
+    assert(nftTemplate.isActive === false)
+
+    await nftFactory.reactivateNFTTemplate(factoryOwner, currentNFTTemplateCount)
+
+    nftTemplate = await nftFactory.getNFTTemplate(currentNFTTemplateCount)
+    assert(nftTemplate.isActive === true)
+  })
+
+  it('#addTokenTemplate - should add a new erc20 token template', async () => {
+    const currentTokenTemplateCount = await nftFactory.getCurrentTokenTemplateCount()
+
+    await nftFactory.addTokenTemplate(factoryOwner, contracts.erc20TemplateAddress)
+
+    expect(
+      (await nftFactory.getCurrentTokenTemplateCount()) === currentTokenTemplateCount + 1
+    )
+  })
+
+  it('#disableTokenTemplate - should disable an erc20 token template', async () => {
+    const currentTokenTemplateCount = await nftFactory.getCurrentTokenTemplateCount()
+
+    let tokenTemplate = await nftFactory.getTokenTemplate(currentTokenTemplateCount)
+    assert(tokenTemplate.isActive === true)
+
+    await nftFactory.disableTokenTemplate(factoryOwner, currentTokenTemplateCount)
+
+    tokenTemplate = await nftFactory.getTokenTemplate(currentTokenTemplateCount)
+    assert(tokenTemplate.isActive === false)
+  })
+
+  it('#reactivateTokenTemplate - should reactivate an previously disabled erc20 token template', async () => {
+    const currentTokenTemplateCount = await nftFactory.getCurrentTokenTemplateCount()
+
+    let tokenTemplate = await nftFactory.getTokenTemplate(currentTokenTemplateCount)
+    assert(tokenTemplate.isActive === false)
+
+    await nftFactory.reactivateTokenTemplate(factoryOwner, currentTokenTemplateCount)
+
+    tokenTemplate = await nftFactory.getTokenTemplate(currentTokenTemplateCount)
+    assert(tokenTemplate.isActive === true)
+  })
 })

From 0e876edadf4e2571c17457d71ff12e94ed703e5f Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Thu, 24 Mar 2022 09:55:27 +0100
Subject: [PATCH 09/17] fix error in NftFactory.disableTokenTemplate() and
 NftFactory.reactivateTokenTemplate()

---
 src/factories/NFTFactory.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/factories/NFTFactory.ts b/src/factories/NFTFactory.ts
index 5af4822f..ce3e97da 100644
--- a/src/factories/NFTFactory.ts
+++ b/src/factories/NFTFactory.ts
@@ -492,14 +492,14 @@ export class NftFactory {
     if ((await this.getOwner()) !== address) {
       throw new Error(`Caller is not Factory Owner`)
     }
-    if (templateIndex > (await this.getCurrentNFTTemplateCount())) {
+    if (templateIndex > (await this.getCurrentTokenTemplateCount())) {
       throw new Error(`Template index doesnt exist`)
     }
 
     if (templateIndex === 0) {
       throw new Error(`Template index cannot be ZERO`)
     }
-    if ((await this.getNFTTemplate(templateIndex)).isActive === false) {
+    if ((await this.getTokenTemplate(templateIndex)).isActive === false) {
       throw new Error(`Template is already disabled`)
     }
     const estGas = await this.estGasDisableTokenTemplate(address, templateIndex)
@@ -551,7 +551,7 @@ export class NftFactory {
     if ((await this.getOwner()) !== address) {
       throw new Error(`Caller is not Factory Owner`)
     }
-    if (templateIndex > (await this.getCurrentNFTTemplateCount())) {
+    if (templateIndex > (await this.getCurrentTokenTemplateCount())) {
       throw new Error(`Template index doesnt exist`)
     }
 

From db4d22b5bbd8f3cccd538ade16d45ed75f5b8d64 Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Thu, 24 Mar 2022 11:09:07 +0100
Subject: [PATCH 10/17] check correct allowance amount

---
 test/unit/pools/balancer/Pool.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/unit/pools/balancer/Pool.test.ts b/test/unit/pools/balancer/Pool.test.ts
index fb78cd36..3f503083 100644
--- a/test/unit/pools/balancer/Pool.test.ts
+++ b/test/unit/pools/balancer/Pool.test.ts
@@ -85,7 +85,7 @@ describe('Pool unit test', () => {
       contracts.erc721FactoryAddress
     )
 
-    assert(parseInt(allowCheck) >= 8000)
+    assert(parseInt(allowCheck) >= 2000)
     allowCheck = await allowance(
       web3,
       contracts.usdcAddress,

From adb8138e8906344924a73141ef6e00ca4f8e66d2 Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Thu, 24 Mar 2022 12:29:24 +0100
Subject: [PATCH 11/17] refactor script names in package.json

---
 package.json | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/package.json b/package.json
index 725c5e77..ca3ab828 100644
--- a/package.json
+++ b/package.json
@@ -27,19 +27,19 @@
     "changelog": "auto-changelog -p",
     "prepublishOnly": "npm run build",
     "mocha": "TS_NODE_PROJECT='./test/tsconfig.json' mocha --config=test/.mocharc.json --node-env=test --exit",
-    "test:ss": "npm run mocha -- 'test/unit/pools/ssContracts/SideStaking.test.ts'",
+    "test:nftfactory": "npm run mocha -- 'test/unit/factories/NftFactory.test.ts'",
+    "test:nft": "npm run mocha -- 'test/unit/tokens/Nft.test.ts'",
+    "test:datatoken": "npm run mocha -- 'test/unit/tokens/Datatoken.test.ts'",
+    "test:router": "npm run mocha -- 'test/unit/pools/Router.test.ts'",
     "test:fixed": "npm run mocha -- 'test/unit/pools/fixedRate/FixedRateExchange.test.ts'",
+    "test:ss": "npm run mocha -- 'test/unit/pools/ssContracts/SideStaking.test.ts'",
     "test:pool": "npm run mocha -- 'test/unit/pools/balancer/Pool.test.ts'",
     "test:dispenser": "npm run mocha -- 'test/unit/pools/dispenser/Dispenser.test.ts'",
-    "test:dt": "npm run mocha -- 'test/unit/tokens/Datatoken.test.ts'",
-    "test:nftDt": "npm run mocha -- 'test/unit/tokens/Nft.test.ts'",
-    "test:factory": "npm run mocha -- 'test/unit/factories/NftFactory.test.ts'",
-    "test:router": "npm run mocha -- 'test/unit/pools/Router.test.ts'",
     "test:publishAll": "npm run mocha -- 'test/integration/PublishFlows.test.ts'",
+    "test:provider": "npm run mocha -- 'test/integration/Provider.test.ts'",
     "test:unit": "npm run mocha -- 'test/unit/**/*.test.ts'",
     "test:unit:cover": "nyc --report-dir coverage/unit npm run test:unit",
     "test:integration": "npm run mocha -- 'test/integration/**/*.test.ts'",
-    "test:provider": "npm run mocha -- 'test/integration/Provider.test.ts'",
     "test:integration:cover": "nyc --report-dir coverage/integration --no-clean npm run test:integration"
   },
   "repository": {

From 71e21f56e4169ddac9cf48bef617d62b195a175f Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Thu, 24 Mar 2022 12:45:37 +0100
Subject: [PATCH 12/17] put constants inside test function

---
 test/unit/factories/NftFactory.test.ts | 38 +++++++++++++-------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index b694c723..cb47b2ae 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -20,25 +20,6 @@ import {
   PoolCreationParams
 } from '../../../src/@types'
 
-const VESTING_AMOUNT = '10000'
-const CAP_AMOUNT = '1000000'
-const DATA_TOKEN_AMOUNT = web3.utils.toWei('1')
-const NFT_NAME = '72120Bundle'
-const NFT_SYMBOL = '72Bundle'
-const NFT_TOKEN_URI = 'https://oceanprotocol.com/nft/'
-const ERC20_NAME = 'ERC20B1'
-const ERC20_SYMBOL = 'ERC20DT1Symbol'
-const RATE = '1'
-const FEE = '0.001'
-const FEE_ZERO = '0'
-
-const NFT_DATA: NftCreateData = {
-  name: NFT_NAME,
-  symbol: NFT_SYMBOL,
-  templateIndex: 1,
-  tokenURI: NFT_TOKEN_URI
-}
-
 describe('Nft Factory test', () => {
   let factoryOwner: string
   let nftOwner: string
@@ -51,6 +32,25 @@ describe('Nft Factory test', () => {
   let nftAddress: string
   let ercParams: Erc20CreateParams
 
+  const VESTING_AMOUNT = '10000'
+  const CAP_AMOUNT = '1000000'
+  const DATA_TOKEN_AMOUNT = web3.utils.toWei('1')
+  const NFT_NAME = '72120Bundle'
+  const NFT_SYMBOL = '72Bundle'
+  const NFT_TOKEN_URI = 'https://oceanprotocol.com/nft/'
+  const ERC20_NAME = 'ERC20B1'
+  const ERC20_SYMBOL = 'ERC20DT1Symbol'
+  const RATE = '1'
+  const FEE = '0.001'
+  const FEE_ZERO = '0'
+
+  const NFT_DATA: NftCreateData = {
+    name: NFT_NAME,
+    symbol: NFT_SYMBOL,
+    templateIndex: 1,
+    tokenURI: NFT_TOKEN_URI
+  }
+
   before(async () => {
     const accounts = await web3.eth.getAccounts()
     factoryOwner = accounts[0]

From e49a94c0cb06bee6103ac3eb3a47166ff8d9b996 Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Wed, 30 Mar 2022 17:36:54 +0200
Subject: [PATCH 13/17] remove abi import

---
 test/unit/factories/NftFactory.test.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index 9bab3ec8..07aaf094 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -2,7 +2,6 @@ import { assert, expect } from 'chai'
 import { AbiItem } from 'web3-utils/types'
 import { deployContracts, Addresses } from '../../TestContractHandler'
 import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
-import ERC721Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC721Template.sol/ERC721Template.json'
 import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/MockERC20Decimals.sol/MockERC20Decimals.json'
 import { web3 } from '../../config'
 import {
@@ -101,7 +100,7 @@ describe('Nft Factory test', () => {
     const nftAddress = await nftFactory.createNFT(nftOwner, NFT_DATA)
 
     // we check the created nft
-    const nftDatatoken = new Nft(web3, ERC721Template.abi as AbiItem[])
+    const nftDatatoken = new Nft(web3)
     const tokenURI = await nftDatatoken.getTokenURI(nftAddress, 1)
     assert(tokenURI === NFT_TOKEN_URI)
   })

From 4e1a79ac216b4e4c36d19fabb759572dacb41547 Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Wed, 6 Apr 2022 17:03:50 +0200
Subject: [PATCH 14/17] solve problem with NftCreateData constant

---
 test/unit/factories/NftFactory.test.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index 07aaf094..4525bbbc 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -47,7 +47,9 @@ describe('Nft Factory test', () => {
     name: NFT_NAME,
     symbol: NFT_SYMBOL,
     templateIndex: 1,
-    tokenURI: NFT_TOKEN_URI
+    tokenURI: NFT_TOKEN_URI,
+    transferable: true,
+    owner: factoryOwner
   }
 
   before(async () => {
@@ -57,6 +59,8 @@ describe('Nft Factory test', () => {
     user1 = accounts[2]
     user2 = accounts[3]
 
+    NFT_DATA.owner = factoryOwner
+
     ercParams = {
       templateIndex: 1,
       minter: nftOwner,

From 3e2efc0ef62c237795483b0eb6bc4b22bab08456 Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Thu, 7 Apr 2022 20:43:00 +0200
Subject: [PATCH 15/17] refactor ercParams const

---
 test/unit/factories/NftFactory.test.ts | 38 ++++++++++++++------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index 4525bbbc..b746e791 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -29,7 +29,6 @@ describe('Nft Factory test', () => {
   let dtAddress: string
   let dtAddress2: string
   let nftAddress: string
-  let ercParams: Erc20CreateParams
 
   const VESTING_AMOUNT = '10000'
   const CAP_AMOUNT = '1000000'
@@ -52,6 +51,18 @@ describe('Nft Factory test', () => {
     owner: factoryOwner
   }
 
+  const ERC_PARAMS: Erc20CreateParams = {
+    templateIndex: 1,
+    minter: nftOwner,
+    paymentCollector: user2,
+    mpFeeAddress: user1,
+    feeToken: ZERO_ADDRESS,
+    cap: CAP_AMOUNT,
+    feeAmount: FEE_ZERO,
+    name: ERC20_NAME,
+    symbol: ERC20_SYMBOL
+  }
+
   before(async () => {
     const accounts = await web3.eth.getAccounts()
     factoryOwner = accounts[0]
@@ -60,18 +71,9 @@ describe('Nft Factory test', () => {
     user2 = accounts[3]
 
     NFT_DATA.owner = factoryOwner
-
-    ercParams = {
-      templateIndex: 1,
-      minter: nftOwner,
-      paymentCollector: user2,
-      mpFeeAddress: user1,
-      feeToken: ZERO_ADDRESS,
-      cap: CAP_AMOUNT,
-      feeAmount: FEE_ZERO,
-      name: ERC20_NAME,
-      symbol: ERC20_SYMBOL
-    }
+    ERC_PARAMS.minter = nftOwner
+    ERC_PARAMS.paymentCollector = user2
+    ERC_PARAMS.mpFeeAddress = user1
   })
 
   it('should deploy contracts', async () => {
@@ -111,7 +113,7 @@ describe('Nft Factory test', () => {
 
   it('#createNftwithErc - should create an NFT and a Datatoken', async () => {
     // we prepare transaction parameters objects
-    const txReceipt = await nftFactory.createNftWithErc20(nftOwner, NFT_DATA, ercParams)
+    const txReceipt = await nftFactory.createNftWithErc20(nftOwner, NFT_DATA, ERC_PARAMS)
 
     // events have been emitted
     expect(txReceipt.events.NFTCreated.event === 'NFTCreated')
@@ -126,7 +128,7 @@ describe('Nft Factory test', () => {
     const currentNFTCount = await nftFactory.getCurrentNFTCount()
     const currentTokenCount = await nftFactory.getCurrentTokenCount()
 
-    await nftFactory.createNftWithErc20(nftOwner, NFT_DATA, ercParams)
+    await nftFactory.createNftWithErc20(nftOwner, NFT_DATA, ERC_PARAMS)
 
     expect((await nftFactory.getCurrentNFTCount()) === currentNFTCount + 1)
     expect((await nftFactory.getCurrentTokenCount()) === currentTokenCount + 1)
@@ -167,7 +169,7 @@ describe('Nft Factory test', () => {
     const txReceipt = await nftFactory.createNftErc20WithPool(
       nftOwner,
       NFT_DATA,
-      ercParams,
+      ERC_PARAMS,
       poolParams
     )
 
@@ -195,7 +197,7 @@ describe('Nft Factory test', () => {
     const txReceipt = await nftFactory.createNftErc20WithFixedRate(
       nftOwner,
       NFT_DATA,
-      ercParams,
+      ERC_PARAMS,
       freParams
     )
 
@@ -221,7 +223,7 @@ describe('Nft Factory test', () => {
     const txReceipt = await nftFactory.createNftErc20WithDispenser(
       nftOwner,
       NFT_DATA,
-      ercParams,
+      ERC_PARAMS,
       dispenserParams
     )
 

From 26e1cba7cb57a22e44990084503dcb7b6f61e822 Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Thu, 28 Apr 2022 16:50:00 +0200
Subject: [PATCH 16/17] simplify constants

---
 test/unit/factories/NftFactory.test.ts | 71 +++++++++++---------------
 1 file changed, 31 insertions(+), 40 deletions(-)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index b746e791..61a01bae 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -30,37 +30,28 @@ describe('Nft Factory test', () => {
   let dtAddress2: string
   let nftAddress: string
 
-  const VESTING_AMOUNT = '10000'
-  const CAP_AMOUNT = '1000000'
   const DATA_TOKEN_AMOUNT = web3.utils.toWei('1')
-  const NFT_NAME = '72120Bundle'
-  const NFT_SYMBOL = '72Bundle'
-  const NFT_TOKEN_URI = 'https://oceanprotocol.com/nft/'
-  const ERC20_NAME = 'ERC20B1'
-  const ERC20_SYMBOL = 'ERC20DT1Symbol'
-  const RATE = '1'
   const FEE = '0.001'
-  const FEE_ZERO = '0'
 
-  const NFT_DATA: NftCreateData = {
-    name: NFT_NAME,
-    symbol: NFT_SYMBOL,
+  const nftData: NftCreateData = {
+    name: '72120Bundle',
+    symbol: '72Bundle',
     templateIndex: 1,
-    tokenURI: NFT_TOKEN_URI,
+    tokenURI: 'https://oceanprotocol.com/nft/',
     transferable: true,
     owner: factoryOwner
   }
 
-  const ERC_PARAMS: Erc20CreateParams = {
+  const ercParams: Erc20CreateParams = {
     templateIndex: 1,
     minter: nftOwner,
     paymentCollector: user2,
     mpFeeAddress: user1,
     feeToken: ZERO_ADDRESS,
-    cap: CAP_AMOUNT,
-    feeAmount: FEE_ZERO,
-    name: ERC20_NAME,
-    symbol: ERC20_SYMBOL
+    cap: '1000000',
+    feeAmount: '0',
+    name: 'ERC20B1',
+    symbol: 'ERC20DT1Symbol'
   }
 
   before(async () => {
@@ -70,10 +61,10 @@ describe('Nft Factory test', () => {
     user1 = accounts[2]
     user2 = accounts[3]
 
-    NFT_DATA.owner = factoryOwner
-    ERC_PARAMS.minter = nftOwner
-    ERC_PARAMS.paymentCollector = user2
-    ERC_PARAMS.mpFeeAddress = user1
+    nftData.owner = factoryOwner
+    ercParams.minter = nftOwner
+    ercParams.paymentCollector = user2
+    ercParams.mpFeeAddress = user1
   })
 
   it('should deploy contracts', async () => {
@@ -103,17 +94,17 @@ describe('Nft Factory test', () => {
 
   it('#createNft - should create an NFT', async () => {
     // we prepare transaction parameters objects
-    const nftAddress = await nftFactory.createNFT(nftOwner, NFT_DATA)
+    const nftAddress = await nftFactory.createNFT(nftOwner, nftData)
 
     // we check the created nft
     const nftDatatoken = new Nft(web3)
     const tokenURI = await nftDatatoken.getTokenURI(nftAddress, 1)
-    assert(tokenURI === NFT_TOKEN_URI)
+    assert(tokenURI === nftData.tokenURI)
   })
 
   it('#createNftwithErc - should create an NFT and a Datatoken', async () => {
     // we prepare transaction parameters objects
-    const txReceipt = await nftFactory.createNftWithErc20(nftOwner, NFT_DATA, ERC_PARAMS)
+    const txReceipt = await nftFactory.createNftWithErc20(nftOwner, nftData, ercParams)
 
     // events have been emitted
     expect(txReceipt.events.NFTCreated.event === 'NFTCreated')
@@ -128,7 +119,7 @@ describe('Nft Factory test', () => {
     const currentNFTCount = await nftFactory.getCurrentNFTCount()
     const currentTokenCount = await nftFactory.getCurrentTokenCount()
 
-    await nftFactory.createNftWithErc20(nftOwner, NFT_DATA, ERC_PARAMS)
+    await nftFactory.createNftWithErc20(nftOwner, nftData, ercParams)
 
     expect((await nftFactory.getCurrentNFTCount()) === currentNFTCount + 1)
     expect((await nftFactory.getCurrentTokenCount()) === currentTokenCount + 1)
@@ -143,33 +134,33 @@ describe('Nft Factory test', () => {
       publisherAddress: nftOwner,
       marketFeeCollector: nftOwner,
       poolTemplateAddress: contracts.poolTemplateAddress,
-      rate: RATE,
+      rate: '1',
       baseTokenDecimals: 18,
-      vestingAmount: VESTING_AMOUNT,
+      vestingAmount: '10000',
       vestedBlocks: 2500000,
       initialBaseTokenLiquidity: '2000',
       swapFeeLiquidityProvider: FEE,
       swapFeeMarketRunner: FEE
     }
 
-    // approve VESTING_AMOUNT DAI to nftFactory
+    // approve poolParams.vestingAmount DAI to nftFactory
     const daiContract = new web3.eth.Contract(
       MockERC20.abi as AbiItem[],
       contracts.daiAddress
     )
 
     await daiContract.methods
-      .transfer(nftOwner, web3.utils.toWei(VESTING_AMOUNT))
+      .transfer(nftOwner, web3.utils.toWei(poolParams.vestingAmount))
       .send({ from: factoryOwner })
 
     await daiContract.methods
-      .approve(contracts.erc721FactoryAddress, web3.utils.toWei(VESTING_AMOUNT))
+      .approve(contracts.erc721FactoryAddress, web3.utils.toWei(poolParams.vestingAmount))
       .send({ from: nftOwner })
 
     const txReceipt = await nftFactory.createNftErc20WithPool(
       nftOwner,
-      NFT_DATA,
-      ERC_PARAMS,
+      nftData,
+      ercParams,
       poolParams
     )
 
@@ -188,7 +179,7 @@ describe('Nft Factory test', () => {
       marketFeeCollector: nftOwner,
       baseTokenDecimals: 18,
       datatokenDecimals: 18,
-      fixedRate: RATE,
+      fixedRate: '1',
       marketFee: FEE,
       allowedConsumer: user1,
       withMint: false
@@ -196,8 +187,8 @@ describe('Nft Factory test', () => {
 
     const txReceipt = await nftFactory.createNftErc20WithFixedRate(
       nftOwner,
-      NFT_DATA,
-      ERC_PARAMS,
+      nftData,
+      ercParams,
       freParams
     )
 
@@ -222,8 +213,8 @@ describe('Nft Factory test', () => {
 
     const txReceipt = await nftFactory.createNftErc20WithDispenser(
       nftOwner,
-      NFT_DATA,
-      ERC_PARAMS,
+      nftData,
+      ercParams,
       dispenserParams
     )
 
@@ -240,7 +231,7 @@ describe('Nft Factory test', () => {
     const consumer = user1 // could be different user
     const serviceIndex = 1 // dummy index
     const consumeFeeAddress = user2 // marketplace fee Collector
-    const consumeFeeAmount = FEE_ZERO // fee to be collected on top, requires approval
+    const consumeFeeAmount = '0' // fee to be collected on top, requires approval
     const consumeFeeToken = contracts.daiAddress // token address for the feeAmount, in this case DAI
 
     // we reuse a DT created in a previous test
@@ -295,7 +286,7 @@ describe('Nft Factory test', () => {
     const consumeMarketFee = {
       consumeMarketFeeAddress: ZERO_ADDRESS,
       consumeMarketFeeToken: ZERO_ADDRESS,
-      consumeMarketFeeAmount: FEE_ZERO
+      consumeMarketFeeAmount: '0'
     }
     const orders: TokenOrder[] = [
       {

From 4cfc5ad567f2bf3a74812d23001295b845855a1d Mon Sep 17 00:00:00 2001
From: "Miquel A. Cabot" <miquel.cabot@gmail.com>
Date: Mon, 16 May 2022 17:48:35 +0200
Subject: [PATCH 17/17] Use transfer() and approve() functions

---
 test/unit/factories/NftFactory.test.ts | 29 ++++++++++++++------------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/test/unit/factories/NftFactory.test.ts b/test/unit/factories/NftFactory.test.ts
index 61a01bae..bf62acbb 100644
--- a/test/unit/factories/NftFactory.test.ts
+++ b/test/unit/factories/NftFactory.test.ts
@@ -2,7 +2,6 @@ import { assert, expect } from 'chai'
 import { AbiItem } from 'web3-utils/types'
 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,
@@ -10,7 +9,9 @@ import {
   TokenOrder,
   ZERO_ADDRESS,
   signHash,
-  Nft
+  Nft,
+  transfer,
+  approve
 } from '../../../src'
 import {
   ProviderFees,
@@ -143,19 +144,21 @@ describe('Nft Factory test', () => {
       swapFeeMarketRunner: FEE
     }
 
-    // approve poolParams.vestingAmount DAI to nftFactory
-    const daiContract = new web3.eth.Contract(
-      MockERC20.abi as AbiItem[],
-      contracts.daiAddress
+    await transfer(
+      web3,
+      factoryOwner,
+      contracts.daiAddress,
+      nftOwner,
+      poolParams.vestingAmount
     )
 
-    await daiContract.methods
-      .transfer(nftOwner, web3.utils.toWei(poolParams.vestingAmount))
-      .send({ from: factoryOwner })
-
-    await daiContract.methods
-      .approve(contracts.erc721FactoryAddress, web3.utils.toWei(poolParams.vestingAmount))
-      .send({ from: nftOwner })
+    await approve(
+      web3,
+      nftOwner,
+      contracts.daiAddress,
+      contracts.erc721FactoryAddress,
+      poolParams.vestingAmount
+    )
 
     const txReceipt = await nftFactory.createNftErc20WithPool(
       nftOwner,