diff --git a/src/factories/NFTFactory.ts b/src/factories/NFTFactory.ts
index f9144cf1..c650d68c 100644
--- a/src/factories/NFTFactory.ts
+++ b/src/factories/NFTFactory.ts
@@ -660,9 +660,9 @@ export class NFTFactory {
   /**
    * Estimate gas cost for createNftErcWithPool method
    * @param address Caller address
-   * @param _NftCreateData input data for NFT Creation
+   * @param nftCreateData input data for NFT Creation
    * @param ercParams input data for ERC20 Creation
-   * @param _PoolData input data for Pool Creation
+   * @param poolParams input data for Pool Creation
    * @return {Promise<TransactionReceipt>} transaction receipt
    */
   public async estGasCreateNftErcWithPool(
@@ -690,9 +690,9 @@ export class NFTFactory {
    *      Creates a new NFT, then a ERC20, then a Pool, all in one call
    *      Use this carefully, because if Pool creation fails, you are still going to pay a lot of gas
    * @param address Caller address
-   * @param _NftCreateData input data for NFT Creation
-   * @param _ErcCreateData input data for ERC20 Creation
-   * @param _PoolData input data for Pool Creation
+   * @param nftCreateData input data for NFT Creation
+   * @param ercParams input data for ERC20 Creation
+   * @param poolParams input data for Pool Creation
    * @return {Promise<TransactionReceipt>} transaction receipt
    */
   public async createNftErcWithPool(
@@ -710,6 +710,10 @@ export class NFTFactory {
       poolData
     )
 
+    console.log('estGas', estGas)
+    console.log('ercCreateData', ercCreateData)
+    console.log('poolData', poolData)
+
     // Invoke createToken function of the contract
     const trxReceipt = await this.factory721.methods
       .createNftErcWithPool(nftCreateData, ercCreateData, poolData)
@@ -810,7 +814,7 @@ export class NFTFactory {
         this.web3.utils.toWei(ercParams.cap),
         this.web3.utils.toWei(ercParams.feeAmount)
       ],
-      bytes: []
+      bytess: []
     }
   }
 
@@ -821,7 +825,7 @@ export class NFTFactory {
 
     return {
       fixedPriceAddress: freParams.fixedRateAddress,
-      address: [
+      addresses: [
         freParams.baseTokenAddress,
         freParams.owner,
         freParams.marketFeeCollector,
@@ -839,17 +843,6 @@ export class NFTFactory {
 
   getPoolCreationParams(poolParams: PoolParams): any {
     return {
-      ssParams: [
-        this.web3.utils.toWei(poolParams.rate),
-        poolParams.basetokenDecimals,
-        this.web3.utils.toWei(poolParams.vestingAmount),
-        poolParams.vestedBlocks,
-        this.web3.utils.toWei(poolParams.initialBasetokenLiquidity)
-      ],
-      swapFees: [
-        poolParams.swapFeeLiquidityProvider,
-        poolParams.swapFeeMarketPlaceRunner
-      ],
       addresses: [
         poolParams.ssContract,
         poolParams.basetokenAddress,
@@ -857,7 +850,15 @@ export class NFTFactory {
         poolParams.publisherAddress,
         poolParams.marketFeeCollector,
         poolParams.poolTemplateAddress
-      ]
+      ],
+      ssParams: [
+        this.web3.utils.toWei(poolParams.rate),
+        poolParams.basetokenDecimals,
+        this.web3.utils.toWei(poolParams.vestingAmount),
+        poolParams.vestedBlocks,
+        this.web3.utils.toWei(poolParams.initialBasetokenLiquidity)
+      ],
+      swapFees: [poolParams.swapFeeLiquidityProvider, poolParams.swapFeeMarketPlaceRunner]
     }
   }
 }
diff --git a/test/unit/NFTFactory.test.ts b/test/unit/NFTFactory.test.ts
index b5ad8a0b..40ae216e 100644
--- a/test/unit/NFTFactory.test.ts
+++ b/test/unit/NFTFactory.test.ts
@@ -261,7 +261,7 @@ 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 = {
+    const nftData: NFTCreateData = {
       name: '72120Bundle',
       symbol: '72Bundle',
       templateIndex: 1,
@@ -270,7 +270,7 @@ describe('NFT Factory test', () => {
 
     const ercParams: ErcCreateParams = {
       templateIndex: 1,
-      minter: contracts.accounts[0],,
+      minter: contracts.accounts[0],
       feeManager: user3,
       mpFeeAddress: user2,
       feeToken: '0x0000000000000000000000000000000000000000',
@@ -280,9 +280,8 @@ describe('NFT Factory test', () => {
       symbol: 'ERC20DT1Symbol'
     }
 
-
     const freParams: FixedRateParams = {
-      fixedRateAddress:contracts.fixedRateAddress,
+      fixedRateAddress: contracts.fixedRateAddress,
       baseTokenAddress: contracts.daiAddress,
       owner: contracts.accounts[0],
       marketFeeCollector: contracts.accounts[0],
@@ -372,6 +371,7 @@ describe('NFT Factory test', () => {
     expect(await dtContract.methods.balanceOf(user2).call()).to.equal('0')
     expect(await dtContract2.methods.balanceOf(user2).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)
diff --git a/test/unit/pools/Router.test.ts b/test/unit/pools/Router.test.ts
index 6783b061..cd9eb8bb 100644
--- a/test/unit/pools/Router.test.ts
+++ b/test/unit/pools/Router.test.ts
@@ -13,8 +13,14 @@ import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/M
 import OPFCommunityFeeCollector from '@oceanprotocol/contracts/artifacts/contracts/communityFee/OPFCommunityFeeCollector.sol/OPFCommunityFeeCollector.json'
 import PoolTemplate from '@oceanprotocol/contracts/artifacts/contracts/pools/balancer/BPool.sol/BPool.json'
 import { LoggerInstance } from '../../../src/utils'
-import { NFTFactory } from '../../../src/factories/NFTFactory'
+import {
+  NFTFactory,
+  NFTCreateData,
+  ErcCreateParams,
+  PoolParams
+} from '../../../src/factories/NFTFactory'
 import { Router } from '../../../src/pools/Router'
+import { BigNumber } from 'bignumber.js'
 const { keccak256 } = require('@ethersproject/keccak256')
 const web3 = new Web3('http://127.0.0.1:8545')
 const communityCollector = '0xeE9300b7961e0a01d9f0adb863C7A227A07AaD75'
@@ -172,45 +178,39 @@ describe('Router unit test', () => {
 
     // CREATE A FIRST POOL
     // we prepare transaction parameters objects
-    const nftData = {
+    const nftData: NFTCreateData = {
       name: '72120Bundle',
       symbol: '72Bundle',
       templateIndex: 1,
       baseURI: 'https://oceanprotocol.com/nft/'
     }
-    const ercData = {
+
+    const ercParams: ErcCreateParams = {
       templateIndex: 1,
-      strings: ['ERC20B1', 'ERC20DT1Symbol'],
-      addresses: [
-        contracts.accounts[0],
-        user3,
-        contracts.accounts[0],
-        '0x0000000000000000000000000000000000000000'
-      ],
-      uints: [web3.utils.toWei('1000000'), 0],
-      bytess: []
+      minter: contracts.accounts[0],
+      feeManager: user3,
+      mpFeeAddress: contracts.accounts[0],
+      feeToken: '0x0000000000000000000000000000000000000000',
+      cap: '1000000',
+      feeAmount: '0',
+      name: 'ERC20B1',
+      symbol: 'ERC20DT1Symbol'
     }
 
-    const poolData = {
-      addresses: [
-        contracts.sideStakingAddress,
-        contracts.daiAddress,
-        contracts.factory721Address,
-        contracts.accounts[0],
-        contracts.accounts[0],
-        contracts.poolTemplateAddress
-      ],
-      ssParams: [
-        web3.utils.toWei('1'), // rate
-        18, // basetokenDecimals
-        web3.utils.toWei('10000'),
-        2500000, // vested blocks
-        web3.utils.toWei('2000') // baseToken initial pool liquidity
-      ],
-      swapFees: [
-        1e15, //
-        1e15
-      ]
+    const poolParams: PoolParams = {
+      ssContract: contracts.sideStakingAddress,
+      basetokenAddress: contracts.daiAddress,
+      basetokenSender: contracts.factory721Address,
+      publisherAddress: contracts.accounts[0],
+      marketFeeCollector: contracts.accounts[0],
+      poolTemplateAddress: contracts.poolTemplateAddress,
+      rate: '1',
+      basetokenDecimals: 18,
+      vestingAmount: '10000',
+      vestedBlocks: 2500000,
+      initialBasetokenLiquidity: '2000',
+      swapFeeLiquidityProvider: 1e15,
+      swapFeeMarketPlaceRunner: 1e15
     }
 
     const nftFactory = new NFTFactory(
@@ -222,8 +222,8 @@ describe('Router unit test', () => {
     const txReceipt = await nftFactory.createNftErcWithPool(
       contracts.accounts[0],
       nftData,
-      ercData,
-      poolData
+      ercParams,
+      poolParams
     )
 
     const erc20Token = txReceipt.events.TokenCreated.returnValues.newTokenAddress
@@ -231,52 +231,46 @@ describe('Router unit test', () => {
 
     // CREATE A SECOND POOL
 
-    const nftData2 = {
+    const nftData2: NFTCreateData = {
       name: '72120Bundle2',
       symbol: '72Bundle2',
       templateIndex: 1,
       baseURI: 'https://oceanprotocol.com/nft2/'
     }
-    const ercData2 = {
+
+    const ercParams2: ErcCreateParams = {
       templateIndex: 1,
-      strings: ['ERC20B12', 'ERC20DT1Symbol2'],
-      addresses: [
-        contracts.accounts[0],
-        user3,
-        contracts.accounts[0],
-        '0x0000000000000000000000000000000000000000'
-      ],
-      uints: [web3.utils.toWei('1000000'), 0],
-      bytess: []
+      minter: contracts.accounts[0],
+      feeManager: user3,
+      mpFeeAddress: contracts.accounts[0],
+      feeToken: '0x0000000000000000000000000000000000000000',
+      cap: '1000000',
+      feeAmount: '0',
+      name: 'ERC20B12',
+      symbol: 'ERC20DT1Symbol2'
     }
 
-    const poolData2 = {
-      addresses: [
-        contracts.sideStakingAddress,
-        contracts.daiAddress,
-        contracts.factory721Address,
-        contracts.accounts[0],
-        contracts.accounts[0],
-        contracts.poolTemplateAddress
-      ],
-      ssParams: [
-        web3.utils.toWei('1'), // rate
-        18, // basetokenDecimals
-        web3.utils.toWei('10000'),
-        2500000, // vested blocks
-        web3.utils.toWei('2000') // baseToken initial pool liquidity
-      ],
-      swapFees: [
-        1e15, //
-        1e15
-      ]
+    const poolParams2: PoolParams = {
+      ssContract: contracts.sideStakingAddress,
+      basetokenAddress: contracts.daiAddress,
+      basetokenSender: contracts.factory721Address,
+      publisherAddress: contracts.accounts[0],
+      marketFeeCollector: contracts.accounts[0],
+      poolTemplateAddress: contracts.poolTemplateAddress,
+      rate: '1',
+      basetokenDecimals: 18,
+      vestingAmount: '10000',
+      vestedBlocks: 2500000,
+      initialBasetokenLiquidity: '2000',
+      swapFeeLiquidityProvider: 1e15,
+      swapFeeMarketPlaceRunner: 1e15
     }
 
     const txReceipt2 = await nftFactory.createNftErcWithPool(
       contracts.accounts[0],
       nftData2,
-      ercData2,
-      poolData2
+      ercParams2,
+      poolParams2
     )
 
     const erc20Token2 = txReceipt2.events.TokenCreated.returnValues.newTokenAddress
diff --git a/test/unit/pools/balancer/Pool.test.ts b/test/unit/pools/balancer/Pool.test.ts
index 0885dd9b..5fc094d5 100644
--- a/test/unit/pools/balancer/Pool.test.ts
+++ b/test/unit/pools/balancer/Pool.test.ts
@@ -15,7 +15,12 @@ import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/M
 import PoolTemplate from '@oceanprotocol/contracts/artifacts/contracts/pools/balancer/BPool.sol/BPool.json'
 import OPFCollector from '@oceanprotocol/contracts/artifacts/contracts/communityFee/OPFCommunityFeeCollector.sol/OPFCommunityFeeCollector.json'
 import { LoggerInstance } from '../../../../src/utils'
-import { NFTFactory } from '../../../../src/factories/NFTFactory'
+import {
+  NFTFactory,
+  NFTCreateData,
+  ErcCreateParams,
+  PoolParams
+} from '../../../../src/factories/NFTFactory'
 import { Pool } from '../../../../src/pools/balancer/Pool'
 const { keccak256 } = require('@ethersproject/keccak256')
 const web3 = new Web3('http://127.0.0.1:8545')
@@ -129,47 +134,41 @@ describe('Pool unit test', () => {
     it('#create a pool', async () => {
       // CREATE A POOL
       // we prepare transaction parameters objects
-      const nftData = {
+      const nftData: NFTCreateData = {
         name: '72120Bundle',
         symbol: '72Bundle',
         templateIndex: 1,
         baseURI: 'https://oceanprotocol.com/nft/'
       }
-      const ercData = {
+
+      const ercParams: ErcCreateParams = {
         templateIndex: 1,
-        strings: ['ERC20B1', 'ERC20DT1Symbol'],
-        addresses: [
-          contracts.accounts[0],
-          user3,
-          contracts.accounts[0],
-          '0x0000000000000000000000000000000000000000'
-        ],
-        uints: [web3.utils.toWei('1000000'), 0],
-        bytess: []
+        minter: contracts.accounts[0],
+        feeManager: user3,
+        mpFeeAddress: contracts.accounts[0],
+        feeToken: '0x0000000000000000000000000000000000000000',
+        cap: '1000000',
+        feeAmount: '0',
+        name: 'ERC20B1',
+        symbol: 'ERC20DT1Symbol'
       }
 
       const basetokenInitialLiq = await pool.amountToUnits(contracts.daiAddress, '2000')
 
-      const poolData = {
-        addresses: [
-          contracts.sideStakingAddress,
-          contracts.daiAddress,
-          contracts.factory721Address,
-          contracts.accounts[0],
-          contracts.accounts[0],
-          contracts.poolTemplateAddress
-        ],
-        ssParams: [
-          web3.utils.toWei('1'), // rate
-          18, // basetokenDecimals
-          web3.utils.toWei('10000'),
-          2500000, // vested blocks
-          web3.utils.toWei('2000') // baseToken initial pool liquidity
-        ],
-        swapFees: [
-          1e15, //
-          1e15
-        ]
+      const poolParams: PoolParams = {
+        ssContract: contracts.sideStakingAddress,
+        basetokenAddress: contracts.daiAddress,
+        basetokenSender: contracts.factory721Address,
+        publisherAddress: contracts.accounts[0],
+        marketFeeCollector: contracts.accounts[0],
+        poolTemplateAddress: contracts.poolTemplateAddress,
+        rate: '1',
+        basetokenDecimals: 18,
+        vestingAmount: '10000',
+        vestedBlocks: 2500000,
+        initialBasetokenLiquidity: '2000',
+        swapFeeLiquidityProvider: 1e15,
+        swapFeeMarketPlaceRunner: 1e15
       }
 
       const nftFactory = new NFTFactory(
@@ -181,8 +180,8 @@ describe('Pool unit test', () => {
       const txReceipt = await nftFactory.createNftErcWithPool(
         contracts.accounts[0],
         nftData,
-        ercData,
-        poolData
+        ercParams,
+        poolParams
       )
 
       erc20Token = txReceipt.events.TokenCreated.returnValues.newTokenAddress
@@ -579,48 +578,44 @@ describe('Pool unit test', () => {
     it('#create a pool', async () => {
       // CREATE A POOL
       // we prepare transaction parameters objects
-      const nftData = {
+      const nftData: NFTCreateData = {
         name: '72120Bundle',
         symbol: '72Bundle',
         templateIndex: 1,
         baseURI: 'https://oceanprotocol.com/nft/'
       }
-      const ercData = {
+
+      const ercParams: ErcCreateParams = {
         templateIndex: 1,
-        strings: ['ERC20B1', 'ERC20DT1Symbol'],
-        addresses: [
-          contracts.accounts[0],
-          user3,
-          contracts.accounts[0],
-          '0x0000000000000000000000000000000000000000'
-        ],
-        uints: [web3.utils.toWei('1000000'), 0],
-        bytess: []
+        minter: contracts.accounts[0],
+        feeManager: user3,
+        mpFeeAddress: contracts.accounts[0],
+        feeToken: '0x0000000000000000000000000000000000000000',
+        cap: '1000000',
+        feeAmount: '0',
+        name: 'ERC20B1',
+        symbol: 'ERC20DT1Symbol'
       }
+
       const basetokenInitialLiq = Number(
         await pool.amountToUnits(contracts.usdcAddress, '2000')
       )
       console.log(basetokenInitialLiq.toString())
-      const poolData = {
-        addresses: [
-          contracts.sideStakingAddress,
-          contracts.usdcAddress,
-          contracts.factory721Address,
-          contracts.accounts[0],
-          contracts.accounts[0],
-          contracts.poolTemplateAddress
-        ],
-        ssParams: [
-          web3.utils.toWei('1'), // rate
-          await usdcContract.methods.decimals().call(), // basetokenDecimals
-          web3.utils.toWei('10000'),
-          2500000, // vested blocks
-          basetokenInitialLiq // baseToken initial pool liquidity
-        ],
-        swapFees: [
-          1e15, //
-          1e15
-        ]
+
+      const poolParams: PoolParams = {
+        ssContract: contracts.sideStakingAddress,
+        basetokenAddress: contracts.usdcAddress,
+        basetokenSender: contracts.factory721Address,
+        publisherAddress: contracts.accounts[0],
+        marketFeeCollector: contracts.accounts[0],
+        poolTemplateAddress: contracts.poolTemplateAddress,
+        rate: '1',
+        basetokenDecimals: await usdcContract.methods.decimals().call(),
+        vestingAmount: '10000',
+        vestedBlocks: 2500000,
+        initialBasetokenLiquidity: basetokenInitialLiq.toString(),
+        swapFeeLiquidityProvider: 1e15,
+        swapFeeMarketPlaceRunner: 1e15
       }
 
       const nftFactory = new NFTFactory(
@@ -632,8 +627,8 @@ describe('Pool unit test', () => {
       const txReceipt = await nftFactory.createNftErcWithPool(
         contracts.accounts[0],
         nftData,
-        ercData,
-        poolData
+        ercParams,
+        poolParams
       )
 
       erc20Token = txReceipt.events.TokenCreated.returnValues.newTokenAddress