diff --git a/src/factories/NftFactory.ts b/src/factories/NftFactory.ts
new file mode 100644
index 00000000..aa87a7c4
--- /dev/null
+++ b/src/factories/NftFactory.ts
@@ -0,0 +1,758 @@
+import { Contract } from 'web3-eth-contract'
+import Web3 from 'web3'
+import { TransactionReceipt } from 'web3-core'
+import { AbiItem } from 'web3-utils'
+import defaultFactory721Abi from '@oceanprotocol/contracts/artifacts/contracts/ERC721Factory.sol/ERC721Factory.json'
+import {
+  LoggerInstance,
+  getFairGasPrice,
+  generateDtName,
+  getFreCreationParams,
+  getErcCreationParams,
+  getPoolCreationParams
+} from '../utils'
+import { FreCreationParams, Erc20CreateParams, PoolCreationParams } from '../interfaces'
+
+interface Template {
+  templateAddress: string
+  isActive: boolean
+}
+
+export interface TokenOrder {
+  tokenAddress: string
+  consumer: string
+  amount: string | number
+  serviceIndex: number
+  providerFeeAddress: string
+  providerFeeToken: string
+  providerFeeAmount: string
+}
+
+export interface NftCreateData {
+  name: string
+  symbol: string
+  templateIndex: number
+  tokenURI: string
+}
+
+/**
+ * Provides an interface for NFT Factory contract
+ */
+export class NftFactory {
+  public GASLIMIT_DEFAULT = 1000000
+  public factory721Address: string
+  public factory721Abi: AbiItem | AbiItem[]
+  public web3: Web3
+  public startBlock: number
+  public factory721: Contract
+
+  /**
+   * Instantiate DataTokens.
+   * @param {String} factory721Address
+   * @param {AbiItem | AbiItem[]} factory721ABI
+   * @param {Web3} web3
+   */
+  constructor(
+    factory721Address: string,
+    web3: Web3,
+    factory721Abi?: AbiItem | AbiItem[],
+    startBlock?: number
+  ) {
+    this.factory721Address = factory721Address
+    this.factory721Abi = factory721Abi || (defaultFactory721Abi.abi as AbiItem[])
+    this.web3 = web3
+    this.startBlock = startBlock || 0
+    this.factory721 = new this.web3.eth.Contract(
+      this.factory721Abi,
+      this.factory721Address
+    )
+  }
+
+  /**
+   * Get estimated gas cost for deployERC721Contract value
+   * @param {String} address
+   * @param {String} nftData
+   * @return {Promise<string>} NFT datatoken address
+   */
+  public async estGasCreateNFT(address: string, nftData: NftCreateData): Promise<string> {
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await this.factory721.methods
+        .deployERC721Contract(
+          nftData.name,
+          nftData.symbol,
+          nftData.templateIndex,
+          '0x0000000000000000000000000000000000000000',
+          nftData.tokenURI
+        )
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * Create new NFT
+   * @param {String} address
+   * @param {NFTCreateData} nftData
+   * @return {Promise<string>} NFT datatoken address
+   */
+  public async createNFT(address: string, nftData: NftCreateData): Promise<string> {
+    if (!nftData.templateIndex) nftData.templateIndex = 1
+
+    if (!nftData.name || !nftData.symbol) {
+      const { name, symbol } = generateDtName()
+      nftData.name = name
+      nftData.symbol = symbol
+    }
+
+    const estGas = await this.estGasCreateNFT(address, nftData)
+
+    // Invoke createToken function of the contract
+    const trxReceipt = await this.factory721.methods
+      .deployERC721Contract(
+        nftData.name,
+        nftData.symbol,
+        nftData.templateIndex,
+        '0x0000000000000000000000000000000000000000',
+        nftData.tokenURI
+      )
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    let tokenAddress = null
+    try {
+      tokenAddress = trxReceipt.events.NFTCreated.returnValues[0]
+    } catch (e) {
+      LoggerInstance.error(`ERROR: Failed to create datatoken : ${e.message}`)
+    }
+    return tokenAddress
+  }
+
+  /** Get Current NFT Count (NFT created)
+   * @return {Promise<number>} Number of NFT created from this factory
+   */
+  public async getCurrentNFTCount(): Promise<number> {
+    const trxReceipt = await this.factory721.methods.getCurrentNFTCount().call()
+    return trxReceipt
+  }
+
+  /** Get Current Datatoken Count
+   * @return {Promise<number>} Number of DTs created from this factory
+   */
+  public async getCurrentTokenCount(): Promise<number> {
+    const trxReceipt = await this.factory721.methods.getCurrentTokenCount().call()
+    return trxReceipt
+  }
+
+  /** Get Factory Owner
+   * @return {Promise<string>} Factory Owner address
+   */
+  public async getOwner(): Promise<string> {
+    const trxReceipt = await this.factory721.methods.owner().call()
+    return trxReceipt
+  }
+
+  /** Get Current NFT Template Count
+   * @return {Promise<number>} Number of NFT Template added to this factory
+   */
+  public async getCurrentNFTTemplateCount(): Promise<number> {
+    const count = await this.factory721.methods.getCurrentNFTTemplateCount().call()
+    return count
+  }
+
+  /** Get Current Template  Datatoken (ERC20) Count
+   * @return {Promise<number>} Number of ERC20 Template added to this factory
+   */
+  public async getCurrentTokenTemplateCount(): Promise<number> {
+    const count = await this.factory721.methods.getCurrentTemplateCount().call()
+    return count
+  }
+
+  /** Get NFT Template
+   * @param {Number} index Template index
+   * @return {Promise<Template>} Number of Template added to this factory
+   */
+  public async getNFTTemplate(index: number): Promise<Template> {
+    const template = await this.factory721.methods.getNFTTemplate(index).call()
+    return template
+  }
+
+  /** Get Datatoken(erc20) Template
+   * @param {Number} index Template index
+   * @return {Promise<Template>} DT Template info
+   */
+  public async getTokenTemplate(index: number): Promise<Template> {
+    const template = await this.factory721.methods.getTokenTemplate(index).call()
+    return template
+  }
+
+  /** Check if ERC20 is deployed from the factory
+   * @param {String} datatoken Datatoken address we want to check
+   * @return {Promise<Boolean>} return true if deployed from this factory
+   */
+  public async checkDatatoken(datatoken: string): Promise<Boolean> {
+    const isDeployed = await this.factory721.methods.erc20List(datatoken).call()
+    return isDeployed
+  }
+
+  /** Check if  NFT is deployed from the factory
+   * @param {String} nftAddress nftAddress address we want to check
+   * @return {Promise<String>} return address(0) if it's not, or the nftAddress if true
+   */
+  public async checkNFT(nftAddress: string): Promise<String> {
+    const confirmAddress = await this.factory721.methods.erc721List(nftAddress).call()
+    return confirmAddress
+  }
+
+  /**
+   * Estimate gas cost for add721TokenTemplate method
+   * @param {String} address
+   * @param {String} templateAddress template address to add
+   * @return {Promise<TransactionReceipt>}
+   */
+  public async estGasAddNFTTemplate(
+    address: string,
+    templateAddress: string
+  ): Promise<any> {
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await this.factory721.methods
+        .add721TokenTemplate(templateAddress)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * Add a new erc721 token template - only factory Owner
+   * @param {String} address
+   * @param {String} templateAddress template address to add
+   * @return {Promise<TransactionReceipt>}
+   */
+  public async addNFTTemplate(
+    address: string,
+    templateAddress: string
+  ): Promise<TransactionReceipt> {
+    if ((await this.getOwner()) !== address) {
+      throw new Error(`Caller is not Factory Owner`)
+    }
+
+    const estGas = await this.estGasAddNFTTemplate(address, templateAddress)
+
+    // Invoke add721TokenTemplate function of the contract
+    const trxReceipt = await this.factory721.methods
+      .add721TokenTemplate(templateAddress)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for disable721TokenTemplate method
+   * @param {String} address
+   * @param {Number} templateIndex index of the template we want to disable
+   * @return {Promise<TransactionReceipt>} current token template count
+   */
+  public async estGasDisableNFTTemplate(
+    address: string,
+    templateIndex: number
+  ): Promise<any> {
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await this.factory721.methods
+        .disable721TokenTemplate(templateIndex)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * Disable token template - only factory Owner
+   * @param {String} address
+   * @param {Number} templateIndex index of the template we want to disable
+   * @return {Promise<TransactionReceipt>} current token template count
+   */
+  public async disableNFTTemplate(
+    address: string,
+    templateIndex: number
+  ): Promise<TransactionReceipt> {
+    if ((await this.getOwner()) !== address) {
+      throw new Error(`Caller is not Factory Owner`)
+    }
+
+    const estGas = await this.estGasDisableNFTTemplate(address, templateIndex)
+
+    // Invoke createToken function of the contract
+    const trxReceipt = await this.factory721.methods
+      .disable721TokenTemplate(templateIndex)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   * Reactivate a previously disabled token template - only factory Owner
+   * @param {String} address
+   * @param {Number} templateIndex index of the template we want to reactivate
+   * @return {Promise<TransactionReceipt>} current token template count
+   */
+  public async estGasReactivateNFTTemplate(
+    address: string,
+    templateIndex: number
+  ): Promise<any> {
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await this.factory721.methods
+        .reactivate721TokenTemplate(templateIndex)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * Reactivate a previously disabled token template - only factory Owner
+   * @param {String} address
+   * @param {Number} templateIndex index of the template we want to reactivate
+   * @return {Promise<TransactionReceipt>} current token template count
+   */
+  public async reactivateNFTTemplate(
+    address: string,
+    templateIndex: number
+  ): Promise<TransactionReceipt> {
+    if ((await this.getOwner()) !== address) {
+      throw new Error(`Caller is not Factory Owner`)
+    }
+
+    const estGas = await this.estGasReactivateNFTTemplate(address, templateIndex)
+
+    // Invoke createToken function of the contract
+    const trxReceipt = await this.factory721.methods
+      .reactivate721TokenTemplate(templateIndex)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for addTokenTemplate method
+   * @param {String} address
+   * @param {String} templateAddress template address to add
+   * @return {Promise<TransactionReceipt>}
+   */
+  public async estGasAddTokenTemplate(
+    address: string,
+    templateAddress: string
+  ): Promise<any> {
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await this.factory721.methods
+        .addTokenTemplate(templateAddress)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+
+    return estGas
+  }
+
+  /**
+   * Add a new erc721 token template - only factory Owner
+   * @param {String} address
+   * @param {String} templateAddress template address to add
+   * @return {Promise<TransactionReceipt>}
+   */
+  public async addTokenTemplate(
+    address: string,
+    templateAddress: string
+  ): Promise<TransactionReceipt> {
+    if ((await this.getOwner()) !== address) {
+      throw new Error(`Caller is not Factory Owner`)
+    }
+
+    const estGas = await this.estGasAddTokenTemplate(address, templateAddress)
+
+    // Invoke createToken function of the contract
+    const trxReceipt = await this.factory721.methods
+      .addTokenTemplate(templateAddress)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for disableTokenTemplate method
+   * @param {String} address
+   * @param {Number} templateIndex index of the template we want to disable
+   * @return {Promise<TransactionReceipt>} current token template count
+   */
+  public async estGasDisableTokenTemplate(
+    address: string,
+    templateIndex: number
+  ): Promise<any> {
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await this.factory721.methods
+        .disableTokenTemplate(templateIndex)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * Disable token template - only factory Owner
+   * @param {String} address
+   * @param {Number} templateIndex index of the template we want to disable
+   * @return {Promise<TransactionReceipt>} current token template count
+   */
+  public async disableTokenTemplate(
+    address: string,
+    templateIndex: number
+  ): Promise<TransactionReceipt> {
+    if ((await this.getOwner()) !== address) {
+      throw new Error(`Caller is not Factory Owner`)
+    }
+
+    const estGas = await this.estGasDisableTokenTemplate(address, templateIndex)
+
+    // Invoke createToken function of the contract
+    const trxReceipt = await this.factory721.methods
+      .disableTokenTemplate(templateIndex)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for reactivateTokenTemplate method
+   * @param {String} address
+   * @param {Number} templateIndex index of the template we want to reactivate
+   * @return {Promise<TransactionReceipt>} current token template count
+   */
+  public async estGasReactivateTokenTemplate(
+    address: string,
+    templateIndex: number
+  ): Promise<any> {
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await this.factory721.methods
+        .reactivateTokenTemplate(templateIndex)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * Reactivate a previously disabled token template - only factory Owner
+   * @param {String} address
+   * @param {Number} templateIndex index of the template we want to reactivate
+   * @return {Promise<TransactionReceipt>} current token template count
+   */
+  public async reactivateTokenTemplate(
+    address: string,
+    templateIndex: number
+  ): Promise<TransactionReceipt> {
+    if ((await this.getOwner()) !== address) {
+      throw new Error(`Caller is not Factory Owner`)
+    }
+
+    const estGas = await this.estGasReactivateTokenTemplate(address, templateIndex)
+
+    // Invoke createToken function of the contract
+    const trxReceipt = await this.factory721.methods
+      .reactivateTokenTemplate(templateIndex)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /** Estimate gas cost for startMultipleTokenOrder method
+   * @param address Caller address
+   * @param orders an array of struct tokenOrder
+   * @return {Promise<TransactionReceipt>} transaction receipt
+   */
+  public async estGasStartMultipleTokenOrder(
+    address: string,
+    orders: TokenOrder[]
+  ): Promise<any> {
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await this.factory721.methods
+        .startMultipleTokenOrder(orders)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * @dev startMultipleTokenOrder
+   *      Used as a proxy to order multiple services
+   *      Users can have inifinite approvals for fees for factory instead of having one approval/ erc20 contract
+   *      Requires previous approval of all :
+   *          - consumeFeeTokens
+   *          - publishMarketFeeTokens
+   *          - erc20 datatokens
+   * @param address Caller address
+   * @param orders an array of struct tokenOrder
+   * @return {Promise<TransactionReceipt>} transaction receipt
+   */
+  public async startMultipleTokenOrder(
+    address: string,
+    orders: TokenOrder[]
+  ): Promise<TransactionReceipt> {
+    const estGas = await this.estGasStartMultipleTokenOrder(address, orders)
+
+    // Invoke createToken function of the contract
+    const trxReceipt = await this.factory721.methods
+      .startMultipleTokenOrder(orders)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for createNftWithErc method
+   * @param address Caller address
+   * @param _NftCreateData input data for nft creation
+   * @param _ErcCreateData input data for erc20 creation
+   *  @return {Promise<TransactionReceipt>} transaction receipt
+   */
+
+  public async estGasCreateNftWithErc(
+    address: string,
+    nftCreateData: NftCreateData,
+    ercParams: Erc20CreateParams
+  ): Promise<any> {
+    // Get estimated gas value
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      const ercCreateData = getErcCreationParams(ercParams, this.web3)
+      estGas = await this.factory721.methods
+        .createNftWithErc(nftCreateData, ercCreateData)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * @dev createNftWithErc
+   *      Creates a new NFT, then a ERC20,all in one call
+   * @param address Caller address
+   * @param _NftCreateData input data for nft creation
+   * @param _ErcCreateData input data for erc20 creation
+   * @return {Promise<TransactionReceipt>} transaction receipt
+   */
+
+  public async createNftWithErc(
+    address: string,
+    nftCreateData: NftCreateData,
+    ercParams: Erc20CreateParams
+  ): Promise<TransactionReceipt> {
+    const ercCreateData = getErcCreationParams(ercParams, this.web3)
+
+    const estGas = await this.estGasCreateNftWithErc(
+      address,
+      nftCreateData,
+      ercCreateData
+    )
+
+    // Invoke createToken function of the contract
+    const trxReceipt = await this.factory721.methods
+      .createNftWithErc(nftCreateData, ercCreateData)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for createNftErcWithPool method
+   * @param address Caller address
+   * @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 estGasCreateNftErcWithPool(
+    address: string,
+    nftCreateData: NftCreateData,
+    ercParams: Erc20CreateParams,
+    poolParams: PoolCreationParams
+  ): Promise<any> {
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      const ercCreateData = getErcCreationParams(ercParams, this.web3)
+      const poolData = getPoolCreationParams(poolParams, this.web3)
+      estGas = await this.factory721.methods
+        .createNftErcWithPool(nftCreateData, ercCreateData, poolData)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * @dev createNftErcWithPool
+   *      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 ercParams input data for ERC20 Creation
+   * @param poolParams input data for Pool Creation
+   * @return {Promise<TransactionReceipt>} transaction receipt
+   */
+  public async createNftErcWithPool(
+    address: string,
+    nftCreateData: NftCreateData,
+    ercParams: Erc20CreateParams,
+    poolParams: PoolCreationParams
+  ): Promise<TransactionReceipt> {
+    const estGas = await this.estGasCreateNftErcWithPool(
+      address,
+      nftCreateData,
+      ercParams,
+      poolParams
+    )
+    const ercCreateData = getErcCreationParams(ercParams, this.web3)
+    const poolData = getPoolCreationParams(poolParams, this.web3)
+
+    // Invoke createToken function of the contract
+    const trxReceipt = await this.factory721.methods
+      .createNftErcWithPool(nftCreateData, ercCreateData, poolData)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /** Estimate gas cost for createNftErcWithFixedRate method
+   * @param address Caller address
+   * @param nftCreateData input data for NFT Creation
+   * @param ercParams input data for ERC20 Creation
+   * @param freParams input data for FixedRate Creation
+   * @return {Promise<TransactionReceipt>} transaction receipt
+   */
+  public async estGasCreateNftErcWithFixedRate(
+    address: string,
+    nftCreateData: NftCreateData,
+    ercParams: Erc20CreateParams,
+    freParams: FreCreationParams
+  ): Promise<any> {
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+
+    const ercCreateData = getErcCreationParams(ercParams, this.web3)
+
+    const fixedData = getFreCreationParams(freParams, this.web3)
+
+    try {
+      estGas = await this.factory721.methods
+        .createNftErcWithFixedRate(nftCreateData, ercCreateData, fixedData)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * @dev createNftErcWithFixedRate
+   *      Creates a new NFT, then a ERC20, then a FixedRateExchange, all in one call
+   *      Use this carefully, because if Fixed Rate creation fails, you are still going to pay a lot of gas
+   * @param address Caller address
+   * @param nftCreateData input data for NFT Creation
+   * @param ercParams input data for ERC20 Creation
+   * @param freParams input data for FixedRate Creation
+   *  @return {Promise<TransactionReceipt>} transaction receipt
+   */
+  public async createNftErcWithFixedRate(
+    address: string,
+    nftCreateData: NftCreateData,
+    ercParams: Erc20CreateParams,
+    freParams: FreCreationParams
+  ): Promise<TransactionReceipt> {
+    const ercCreateData = getErcCreationParams(ercParams, this.web3)
+    const fixedData = getFreCreationParams(freParams, this.web3)
+
+    const estGas = await this.estGasCreateNftErcWithFixedRate(
+      address,
+      nftCreateData,
+      ercParams,
+      freParams
+    )
+
+    // Invoke createToken function of the contract
+    const trxReceipt = await this.factory721.methods
+      .createNftErcWithFixedRate(nftCreateData, ercCreateData, fixedData)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+}
diff --git a/src/tokens/Nft.ts b/src/tokens/Nft.ts
new file mode 100644
index 00000000..1c6f6859
--- /dev/null
+++ b/src/tokens/Nft.ts
@@ -0,0 +1,1024 @@
+import Web3 from 'web3'
+import { AbiItem } from 'web3-utils'
+import { TransactionReceipt } from 'web3-eth'
+import defaultNftAbi from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC721Template.sol/ERC721Template.json'
+import { LoggerInstance, getFairGasPrice, generateDtName } from '../utils'
+import { Contract } from 'web3-eth-contract'
+
+/**
+ * ERC721 ROLES
+ */
+interface Roles {
+  manager: boolean
+  deployErc20: boolean
+  updateMetadata: boolean
+  store: boolean
+}
+
+export class Nft {
+  public GASLIMIT_DEFAULT = 1000000
+  public factory721Address: string
+  public factory721Abi: AbiItem | AbiItem[]
+  public nftAbi: AbiItem | AbiItem[]
+  public web3: Web3
+  public startBlock: number
+
+  constructor(web3: Web3, nftAbi?: AbiItem | AbiItem[], startBlock?: number) {
+    this.nftAbi = nftAbi || (defaultNftAbi.abi as AbiItem[])
+    this.web3 = web3
+    this.startBlock = startBlock || 0
+  }
+
+  /**
+   *  Estimate gas cost for createERC20 token creation
+   * @param {String} nftAddress ERC721 addreess
+   * @param {String} address User address
+   * @param {String} minter User set as initial minter for the ERC20
+   * @param {String} feeManager initial feeManager for this DT
+   * @param {String} mpFeeAddress Consume marketplace fee address
+   * @param {String} feeToken address of the token marketplace wants to add fee on top
+   * @param {String} feeAmount amount of feeToken to be transferred to mpFeeAddress on top, will be converted to WEI
+   * @param {String} cap Maximum cap (Number) - will be converted to wei
+   * @param {String} name Token name
+   * @param {String} symbol Token symbol
+   * @param {Number} templateIndex NFT template index
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async estGasCreateErc20(
+    nftAddress: string,
+    address: string,
+    minter: string,
+    feeManager: string,
+    mpFeeAddress: string,
+    feeToken: string,
+    feeAmount: string,
+    cap: string,
+    name?: string,
+    symbol?: string,
+    templateIndex?: number,
+    contractInstance?: Contract
+  ): Promise<any> {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .createERC20(
+          templateIndex,
+          [name, symbol],
+          [minter, feeManager, mpFeeAddress, feeToken],
+          [this.web3.utils.toWei(cap), this.web3.utils.toWei(feeAmount)],
+          []
+        )
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * Create new ERC20 datatoken - only user with ERC20Deployer permission can succeed
+   * @param {String} nftAddress ERC721 addreess
+   * @param {String} address User address
+   * @param {String} minter User set as initial minter for the ERC20
+   * @param {String} feeManager initial feeManager for this DT
+   * @param {String} mpFeeAddress Consume marketplace fee address
+   * @param {String} feeToken address of the token marketplace wants to add fee on top
+   * @param {String} feeAmount amount of feeToken to be transferred to mpFeeAddress on top, will be converted to WEI
+   * @param {String} cap Maximum cap (Number) - will be converted to wei
+   * @param {String} name Token name
+   * @param {String} symbol Token symbol
+   * @param {Number} templateIndex NFT template index
+   * @return {Promise<string>} ERC20 datatoken address
+   */
+  public async createErc20(
+    nftAddress: string,
+    address: string,
+    minter: string,
+    feeManager: string,
+    mpFeeAddress: string,
+    feeToken: string,
+    feeAmount: string,
+    cap: string,
+    name?: string,
+    symbol?: string,
+    templateIndex?: number
+  ): Promise<string> {
+    if (!templateIndex) templateIndex = 1
+
+    // Generate name & symbol if not present
+    if (!name || !symbol) {
+      ;({ name, symbol } = generateDtName())
+    }
+
+    // Create 721contract object
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    const estGas = await this.estGasCreateErc20(
+      nftAddress,
+      address,
+      minter,
+      feeManager,
+      mpFeeAddress,
+      feeToken,
+      feeAmount,
+      cap,
+      name,
+      symbol,
+      templateIndex,
+      nftContract
+    )
+
+    // Call createERC20 token function of the contract
+    const trxReceipt = await nftContract.methods
+      .createERC20(
+        templateIndex,
+        [name, symbol],
+        [minter, feeManager, mpFeeAddress, feeToken],
+        [this.web3.utils.toWei(cap), this.web3.utils.toWei(feeAmount)],
+        []
+      )
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    let tokenAddress = null
+    try {
+      tokenAddress = trxReceipt.events.TokenCreated.returnValues[0]
+    } catch (e) {
+      LoggerInstance.error(`ERROR: Failed to create datatoken : ${e.message}`)
+    }
+    return tokenAddress
+  }
+
+  /**
+   * Estimate gas cost for add manager call
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Owner adress
+   * @param {String} manager User adress which is going to be assing manager
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async estGasAddManager(
+    nftAddress: string,
+    address: string,
+    manager: string,
+    contractInstance?: Contract
+  ) {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .addManager(manager)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * Add Manager for NFT Contract (only NFT Owner can succeed)
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Owner adress
+   * @param {String} manager User adress which is going to be assing manager
+   * @return {Promise<TransactionReceipt>} trxReceipt
+   */
+  public async addManager(nftAddress: string, address: string, manager: string) {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    if ((await this.getNftOwner(nftAddress)) !== address) {
+      throw new Error(`Caller is not NFT Owner`)
+    }
+
+    const estGas = await this.estGasAddManager(nftAddress, address, manager, nftContract)
+
+    // Invoke addManager function of the contract
+    const trxReceipt = await nftContract.methods.addManager(manager).send({
+      from: address,
+      gas: estGas + 1,
+      gasPrice: await getFairGasPrice(this.web3)
+    })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for removeManager method
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Owner adress
+   * @param {String} manager User adress which is going to be removed as manager
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async estGasRemoveManager(
+    nftAddress: string,
+    address: string,
+    manager: string,
+    contractInstance?: Contract
+  ) {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .removeManager(manager)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * Removes a specific manager for NFT Contract (only NFT Owner can succeed)
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Owner adress
+   * @param {String} manager User adress which is going to be removed as manager
+   * @return {Promise<TransactionReceipt>} trxReceipt
+   */
+  public async removeManager(nftAddress: string, address: string, manager: string) {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    if ((await this.getNftOwner(nftAddress)) !== address) {
+      throw new Error(`Caller is not NFT Owner`)
+    }
+
+    const estGas = await this.estGasRemoveManager(
+      nftAddress,
+      address,
+      manager,
+      nftContract
+    )
+
+    // Invoke removeManager function of the contract
+    const trxReceipt = await nftContract.methods.removeManager(manager).send({
+      from: address,
+      gas: estGas + 1,
+      gasPrice: await getFairGasPrice(this.web3)
+    })
+
+    return trxReceipt
+  }
+
+  /**
+   *  Estimate gas cost for addToCreateERC20List method
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Manager adress
+   * @param {String} erc20Deployer User adress which is going to have erc20Deployer permission
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async estGasAddErc20Deployer(
+    nftAddress: string,
+    address: string,
+    erc20Deployer: string,
+    contractInstance?: Contract
+  ): Promise<any> {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .addToCreateERC20List(erc20Deployer)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+
+    return estGas
+  }
+
+  /**
+   * Add ERC20Deployer permission - only Manager can succeed
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Manager adress
+   * @param {String} erc20Deployer User adress which is going to have erc20Deployer permission
+   * @return {Promise<TransactionReceipt>} trxReceipt
+   */
+  public async addErc20Deployer(
+    nftAddress: string,
+    address: string,
+    erc20Deployer: string
+  ): Promise<TransactionReceipt> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    // if ((await this.getNFTPermissions(nftAddress, address)).manager !== true) {
+    //   throw new Error(`Caller is not Manager`)
+    // }
+
+    // Estimate gas for addToCreateERC20List method
+    const estGas = await this.estGasAddErc20Deployer(
+      nftAddress,
+      address,
+      erc20Deployer,
+      nftContract
+    )
+
+    // Invoke addToCreateERC20List function of the contract
+    const trxReceipt = await nftContract.methods
+      .addToCreateERC20List(erc20Deployer)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for removeFromCreateERC20List method
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Manager adress
+   * @param {String} erc20Deployer Address of the user to be revoked ERC20Deployer Permission
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async estGasRemoveErc20Deployer(
+    nftAddress: string,
+    address: string,
+    erc20Deployer: string,
+    contractInstance?: Contract
+  ): Promise<any> {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .removeFromCreateErc20List(erc20Deployer)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+
+    return estGas
+  }
+
+  /**
+   * Remove ERC20Deployer permission - only Manager can succeed
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Manager adress
+   * @param {String} erc20Deployer Address of the user to be revoked ERC20Deployer Permission
+   * @return {Promise<TransactionReceipt>} trxReceipt
+   */
+  public async removeErc20Deployer(
+    nftAddress: string,
+    address: string,
+    erc20Deployer: string
+  ): Promise<TransactionReceipt> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    // if ((await this.getNFTPermissions(nftAddress, address)).manager !== true) {
+    //   throw new Error(`Caller is not Manager`)
+    // }
+
+    const estGas = await this.estGasRemoveErc20Deployer(
+      nftAddress,
+      address,
+      erc20Deployer,
+      nftContract
+    )
+
+    // Call removeFromCreateERC20List function of the contract
+    const trxReceipt = await nftContract.methods
+      .removeFromCreateERC20List(erc20Deployer)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for addToMetadataList method
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Manager adress
+   * @param {String} metadataUpdater User adress which is going to have Metadata Updater permission
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async estGasAddMetadataUpdater(
+    nftAddress: string,
+    address: string,
+    metadataUpdater: string,
+    contractInstance?: Contract
+  ): Promise<any> {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .addToMetadataList(metadataUpdater)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * Add Metadata Updater permission - only Manager can succeed
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Manager adress
+   * @param {String} metadataUpdater User adress which is going to have Metadata Updater permission
+   * @return {Promise<TransactionReceipt>} trxReceipt
+   */
+  public async addMetadataUpdater(
+    nftAddress: string,
+    address: string,
+    metadataUpdater: string
+  ): Promise<TransactionReceipt> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    // if ((await this.getNFTPermissions(nftAddress, address)).manager !== true) {
+    //   throw new Error(`Caller is not Manager`)
+    // }
+
+    const estGas = await this.estGasAddMetadataUpdater(
+      nftAddress,
+      address,
+      metadataUpdater,
+      nftContract
+    )
+
+    // Call addToMetadataList function of the contract
+    const trxReceipt = await nftContract.methods.addToMetadataList(metadataUpdater).send({
+      from: address,
+      gas: estGas + 1,
+      gasPrice: await getFairGasPrice(this.web3)
+    })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for removeFromMetadataList method
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Manager adress
+   * @param {String} metadataUpdater Address of the user to be revoked Metadata updater Permission
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async esGasRemoveMetadataUpdater(
+    nftAddress: string,
+    address: string,
+    metadataUpdater: string,
+    contractInstance?: Contract
+  ): Promise<any> {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .removeFromMetadataList(metadataUpdater)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+
+    return estGas
+  }
+
+  /**
+   * Remove Metadata Updater permission - only Manager can succeed
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Manager adress
+   * @param {String} metadataUpdater Address of the user to be revoked Metadata updater Permission
+   * @return {Promise<TransactionReceipt>} trxReceipt
+   */
+  public async removeMetadataUpdater(
+    nftAddress: string,
+    address: string,
+    metadataUpdater: string
+  ): Promise<TransactionReceipt> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    // if ((await this.getNFTPermissions(nftAddress, address)).manager !== true) {
+    //   throw new Error(`Caller is not Manager`)
+    // }
+
+    const estGas = await this.esGasRemoveMetadataUpdater(
+      nftAddress,
+      address,
+      metadataUpdater,
+      nftContract
+    )
+
+    // Call removeFromMetadataList function of the contract
+    const trxReceipt = await nftContract.methods
+      .removeFromMetadataList(metadataUpdater)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for addTo725StoreList method
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Manager adress
+   * @param {String} storeUpdater User adress which is going to have Store Updater permission
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async estGasAddStoreUpdater(
+    nftAddress: string,
+    address: string,
+    storeUpdater: string,
+    contractInstance?: Contract
+  ): Promise<any> {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .addTo725StoreList(storeUpdater)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * Add Store Updater permission - only Manager can succeed
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Manager adress
+   * @param {String} storeUpdater User adress which is going to have Store Updater permission
+   * @return {Promise<TransactionReceipt>} trxReceipt
+   */
+  public async addStoreUpdater(
+    nftAddress: string,
+    address: string,
+    storeUpdater: string
+  ): Promise<TransactionReceipt> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    // if ((await this.getNFTPermissions(nftAddress, address)).manager !== true) {
+    //   throw new Error(`Caller is not Manager`)
+    // }
+
+    const estGas = await this.estGasAddStoreUpdater(
+      nftAddress,
+      address,
+      storeUpdater,
+      nftContract
+    )
+
+    // Call addTo725StoreList function of the contract
+    const trxReceipt = await nftContract.methods.addTo725StoreList(storeUpdater).send({
+      from: address,
+      gas: estGas + 1,
+      gasPrice: await getFairGasPrice(this.web3)
+    })
+
+    return trxReceipt
+  }
+
+  /**
+   *  Estimate gas cost for removeFrom725StoreList method
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Manager adress
+   * @param {String} storeUpdater Address of the user to be revoked Store Updater Permission
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async estGasRemoveStoreUpdater(
+    nftAddress: string,
+    address: string,
+    storeUpdater: string,
+    contractInstance?: Contract
+  ): Promise<any> {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .removeFrom725StoreList(storeUpdater)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * Remove Store Updater permission - only Manager can succeed
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Manager adress
+   * @param {String} storeUpdater Address of the user to be revoked Store Updater Permission
+   * @return {Promise<TransactionReceipt>} trxReceipt
+   */
+  public async removeStoreUpdater(
+    nftAddress: string,
+    address: string,
+    storeUpdater: string
+  ): Promise<TransactionReceipt> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    // if ((await this.getNFTPermissions(nftAddress, address)).manager !== true) {
+    //   throw new Error(`Caller is not Manager`)
+    // }
+
+    const estGas = await this.estGasRemoveStoreUpdater(
+      nftAddress,
+      address,
+      storeUpdater,
+      nftContract
+    )
+
+    // Call removeFrom725StoreList function of the contract
+    const trxReceipt = await nftContract.methods
+      .removeFrom725StoreList(storeUpdater)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   *  Estimate gas cost for cleanPermissions method
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Owner adress
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async estGasCleanPermissions(
+    nftAddress: string,
+    address: string,
+    contractInstance?: Contract
+  ): Promise<any> {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .cleanPermissions()
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+    return estGas
+  }
+
+  /**
+   * This function allows to remove all ROLES at erc721 level: Managers, ERC20Deployer, MetadataUpdater, StoreUpdater
+   * Even NFT Owner has to readd himself as Manager
+   * Permissions at erc20 level stay.
+   * Only NFT Owner  can call it.
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address NFT Owner adress
+   * @return {Promise<TransactionReceipt>} trxReceipt
+   */
+
+  public async cleanPermissions(
+    nftAddress: string,
+    address: string
+  ): Promise<TransactionReceipt> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    if ((await this.getNftOwner(nftAddress)) !== address) {
+      throw new Error(`Caller is not NFT Owner`)
+    }
+
+    const estGas = await this.estGasCleanPermissions(nftAddress, address, nftContract)
+
+    // Call cleanPermissions function of the contract
+    const trxReceipt = await nftContract.methods.cleanPermissions().send({
+      from: address,
+      gas: estGas + 1,
+      gasPrice: await getFairGasPrice(this.web3)
+    })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for transfer NFT method
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} nftOwner Current NFT Owner adress
+   * @param {String} nftReceiver User which will receive the NFT, will also be set as Manager
+   * @param {Number} tokenId The id of the token to be transfered
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async estGasTransferNft(
+    nftAddress: string,
+    nftOwner: string,
+    nftReceiver: string,
+    tokenId: number,
+    contractInstance?: Contract
+  ): Promise<any> {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .transferFrom(nftOwner, nftReceiver, tokenId)
+        .estimateGas({ from: nftOwner }, (err, estGas) =>
+          err ? gasLimitDefault : estGas
+        )
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+
+    return estGas
+  }
+
+  /**
+   * Transfers the NFT
+   * will clean all permissions both on erc721 and erc20 level.
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} nftOwner Current NFT Owner adress
+   * @param {String} nftReceiver User which will receive the NFT, will also be set as Manager
+   * @param {Number} tokenId The id of the token to be transfered
+   * @return {Promise<TransactionReceipt>} trxReceipt
+   */
+  public async transferNft(
+    nftAddress: string,
+    nftOwner: string,
+    nftReceiver: string,
+    tokenId?: number
+  ): Promise<TransactionReceipt> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    if ((await this.getNftOwner(nftAddress)) !== nftOwner) {
+      throw new Error(`Caller is not NFT Owner`)
+    }
+
+    const tokenIdentifier = tokenId || 1
+
+    const estGas = await this.estGasTransferNft(
+      nftAddress,
+      nftOwner,
+      nftReceiver,
+      tokenIdentifier,
+      nftContract
+    )
+
+    // Call transferFrom function of the contract
+    const trxReceipt = await nftContract.methods
+      .transferFrom(nftOwner, nftReceiver, tokenIdentifier)
+      .send({
+        from: nftOwner,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for safeTransfer NFT method
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} nftOwner Current NFT Owner adress
+   * @param {String} nftReceiver User which will receive the NFT, will also be set as Manager
+   * @param {Number} tokenId The id of the token to be transfered
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async estGasSafeTransferNft(
+    nftAddress: string,
+    nftOwner: string,
+    nftReceiver: string,
+    tokenId: number,
+    contractInstance?: Contract
+  ): Promise<any> {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .safeTransferFrom(nftOwner, nftReceiver, tokenId)
+        .estimateGas({ from: nftOwner }, (err, estGas) =>
+          err ? gasLimitDefault : estGas
+        )
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+
+    return estGas
+  }
+
+  /**
+   * safeTransferNFT Used for transferring the NFT, can be used by an approved relayer
+   * will clean all permissions both on erc721 and erc20 level.
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} nftOwner Current NFT Owner adress
+   * @param {String} nftReceiver User which will receive the NFT, will also be set as Manager
+   * @param {Number} tokenId The id of the token to be transfered
+   * @return {Promise<TransactionReceipt>} trxReceipt
+   */
+  public async safeTransferNft(
+    nftAddress: string,
+    nftOwner: string,
+    nftReceiver: string,
+    tokenId?: number
+  ): Promise<TransactionReceipt> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    if ((await this.getNftOwner(nftAddress)) !== nftOwner) {
+      throw new Error(`Caller is not NFT Owner`)
+    }
+
+    const tokenIdentifier = tokenId || 1
+
+    const estGas = await this.estGasSafeTransferNft(
+      nftAddress,
+      nftOwner,
+      nftReceiver,
+      tokenIdentifier,
+      nftContract
+    )
+
+    // Call transferFrom function of the contract
+    const trxReceipt = await nftContract.methods
+      .safeTransferFrom(nftOwner, nftReceiver, tokenIdentifier)
+      .send({
+        from: nftOwner,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /**
+   * Estimate gas cost for setMetadata  method
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} nftOwner Current NFT Owner adress
+   * @param {String} nftReceiver User which will receive the NFT, will also be set as Manager
+   * @param {Number} tokenId The id of the token to be transfered
+   * @param {Contract} nftContract optional contract instance
+   * @return {Promise<any>}
+   */
+  public async estGasSetMetadata(
+    nftAddress: string,
+    nftOwner: string,
+    metadataState: number,
+    metaDataDecryptorUrl: string,
+    metaDataDecryptorAddress: string,
+    flags: string,
+    data: string,
+    metadataHash: string,
+    contractInstance?: Contract
+  ): Promise<any> {
+    const nftContract =
+      contractInstance || new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+    try {
+      estGas = await nftContract.methods
+        .setMetaData(
+          metadataState,
+          metaDataDecryptorUrl,
+          metaDataDecryptorAddress,
+          flags,
+          data,
+          metadataHash
+        )
+        .estimateGas({ from: nftOwner }, (err, estGas) =>
+          err ? gasLimitDefault : estGas
+        )
+    } catch (e) {
+      estGas = gasLimitDefault
+    }
+
+    return estGas
+  }
+
+  /**
+   * safeTransferNFT Used for transferring the NFT, can be used by an approved relayer
+   * will clean all permissions both on erc721 and erc20 level.
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address Caller address NFT Owner adress
+   * @param {String} nftReceiver User which will receive the NFT, will also be set as Manager
+   * @param {Number} tokenId The id of the token to be transfered
+   * @return {Promise<TransactionReceipt>} trxReceipt
+   */
+  public async setMetadata(
+    nftAddress: string,
+    address: string,
+    metadataState: number,
+    metaDataDecryptorUrl: string,
+    metaDataDecryptorAddress: string,
+    flags: string,
+    data: string,
+    metadataHash: string
+  ): Promise<TransactionReceipt> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+
+    // if (!(await this.getNFTPermissions(nftAddress, address)).updateMetadata) {
+    //   throw new Error(`Caller is not NFT Owner`)
+    // }
+
+    const estGas = await this.estGasSetMetadata(
+      nftAddress,
+      address,
+      metadataState,
+      metaDataDecryptorUrl,
+      metaDataDecryptorAddress,
+      flags,
+      data,
+      metadataHash,
+      nftContract
+    )
+
+    // Call transferFrom function of the contract
+    const trxReceipt = await nftContract.methods
+      .setMetaData(
+        metadataState,
+        metaDataDecryptorUrl,
+        metaDataDecryptorAddress,
+        flags,
+        data,
+        metadataHash
+      )
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
+
+  /** Get Owner
+   * @param {String} nftAddress erc721 contract adress
+   * @return {Promise<string>} string
+   */
+  public async getNftOwner(nftAddress: string): Promise<string> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+    const trxReceipt = await nftContract.methods.ownerOf(1).call()
+    return trxReceipt
+  }
+
+  /** Get users NFT Permissions
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address user adress
+   * @return {Promise<Roles>}
+   */
+  public async getNftPermissions(nftAddress: string, address: string): Promise<Roles> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+    const roles = await nftContract.methods.getPermissions(address).call()
+    return roles
+  }
+
+  /** Get users ERC20Deployer role
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} address user adress
+   * @return {Promise<Roles>}
+   */
+  public async isErc20Deployer(nftAddress: string, address: string): Promise<boolean> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+    const isERC20Deployer = await nftContract.methods.isERC20Deployer(address).call()
+    return isERC20Deployer
+  }
+
+  /** Gets data at a given `key`
+   * @param {String} nftAddress erc721 contract adress
+   * @param {String} key the key which value to retrieve
+   * @return {Promise<string>} The data stored at the key
+   */
+  public async getData(nftAddress: string, key: string): Promise<string> {
+    const nftContract = new this.web3.eth.Contract(this.nftAbi, nftAddress)
+    const data = await nftContract.methods.getData(key).call()
+    return data
+  }
+}
diff --git a/test/unit/NftFactory.test.ts b/test/unit/NftFactory.test.ts
new file mode 100644
index 00000000..9d9386c2
--- /dev/null
+++ b/test/unit/NftFactory.test.ts
@@ -0,0 +1,385 @@
+import { assert, expect } from 'chai'
+import { AbiItem } from 'web3-utils/types'
+import { TestContractHandler } from '../TestContractHandler'
+import Web3 from 'web3'
+import ERC721Factory from '@oceanprotocol/contracts/artifacts/contracts/ERC721Factory.sol/ERC721Factory.json'
+import ERC721Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC721Template.sol/ERC721Template.json'
+import SideStaking from '@oceanprotocol/contracts/artifacts/contracts/pools/ssContracts/SideStaking.sol/SideStaking.json'
+import Router from '@oceanprotocol/contracts/artifacts/contracts/pools/FactoryRouter.sol/FactoryRouter.json'
+import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
+import Dispenser from '@oceanprotocol/contracts/artifacts/contracts/pools/dispenser/Dispenser.sol/Dispenser.json'
+import FixedRate from '@oceanprotocol/contracts/artifacts/contracts/pools/fixedRate/FixedRateExchange.sol/FixedRateExchange.json'
+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 { NftFactory, NftCreateData, TokenOrder } from '../../src/factories/NftFactory'
+import {
+  FreCreationParams,
+  Erc20CreateParams,
+  PoolCreationParams
+} from '../../src/interfaces'
+
+const web3 = new Web3('http://127.0.0.1:8545')
+
+describe('Nft Factory test', () => {
+  let factoryOwner: string
+  let nftOwner: string
+  let user1: string
+  let user2: string
+  let user3: string
+  let contracts: TestContractHandler
+  let nftFactory: NftFactory
+  let dtAddress: string
+  let dtAddress2: string
+  let nftAddress: string
+
+  it('should deploy contracts', async () => {
+    contracts = new TestContractHandler(
+      web3,
+      ERC721Template.abi as AbiItem[],
+      ERC20Template.abi as AbiItem[],
+      PoolTemplate.abi as AbiItem[],
+      ERC721Factory.abi as AbiItem[],
+      Router.abi as AbiItem[],
+      SideStaking.abi as AbiItem[],
+      FixedRate.abi as AbiItem[],
+      Dispenser.abi as AbiItem[],
+      OPFCommunityFeeCollector.abi as AbiItem[],
+
+      ERC721Template.bytecode,
+      ERC20Template.bytecode,
+      PoolTemplate.bytecode,
+      ERC721Factory.bytecode,
+      Router.bytecode,
+      SideStaking.bytecode,
+      FixedRate.bytecode,
+      Dispenser.bytecode,
+      OPFCommunityFeeCollector.bytecode
+    )
+    await contracts.getAccounts()
+    factoryOwner = contracts.accounts[0]
+    nftOwner = contracts.accounts[1]
+    user1 = contracts.accounts[2]
+    user2 = contracts.accounts[3]
+    user3 = contracts.accounts[4]
+
+    await contracts.deployContracts(factoryOwner, Router.abi as AbiItem[])
+
+    console.log(
+      'address',
+      contracts.factory721Address,
+      contracts.poolTemplateAddress,
+      contracts.routerAddress,
+      contracts.fixedRateAddress,
+      contracts.dispenserAddress,
+      contracts.sideStakingAddress,
+      contracts.template721Address,
+      contracts.template20Address
+    )
+    const daiContract = new web3.eth.Contract(
+      contracts.MockERC20.options.jsonInterface,
+      contracts.daiAddress
+    )
+    await daiContract.methods
+      .approve(contracts.factory721Address, web3.utils.toWei('10000'))
+      .send({ from: contracts.accounts[0] })
+  })
+
+  it('should initiate NFTFactory instance', async () => {
+    nftFactory = new NftFactory(contracts.factory721Address, web3)
+  })
+
+  it('#getCurrentNFTCount - should return actual nft count (0)', async () => {
+    const nftCount = await nftFactory.getCurrentNFTCount()
+    expect(nftCount).to.equal('0')
+  })
+
+  it('#getCurrentTokenCount - should return actual token count (0)', async () => {
+    const tokenCount = await nftFactory.getCurrentTokenCount()
+    expect(tokenCount).to.equal('0')
+  })
+  it('#getOwner - should return actual owner', async () => {
+    const owner = await nftFactory.getOwner()
+    assert(owner === contracts.accounts[0])
+  })
+  it('#getCurrentNFTTemplateCount - should return actual nft template count (1)', async () => {
+    const nftTemplateCount = await nftFactory.getCurrentNFTTemplateCount()
+    expect(nftTemplateCount).to.equal('1')
+  })
+  it('#getCurrentTokenTemplateCount - should return actual token template count (1)', async () => {
+    const tokenTemplateCount = await nftFactory.getCurrentTokenTemplateCount()
+    expect(tokenTemplateCount).to.equal('1')
+  })
+  it('#getNFTTemplate - should return NFT template struct', async () => {
+    const nftTemplate = await nftFactory.getNFTTemplate(1)
+    assert(nftTemplate.isActive === true)
+    assert(nftTemplate.templateAddress === contracts.template721Address)
+  })
+  it('#getTokenTemplate - should return Token template struct', async () => {
+    const tokenTemplate = await nftFactory.getTokenTemplate(1)
+    assert(tokenTemplate.isActive === true)
+    assert(tokenTemplate.templateAddress === contracts.template20Address)
+  })
+  it('#addNFTTemplate - should add NFT template if factory owner', async () => {
+    await nftFactory.addNFTTemplate(contracts.accounts[0], contracts.fixedRateAddress) // contracts.fixedRateAddress it's just a dummy contract in this case
+    const nftTemplateCount = await nftFactory.getCurrentNFTTemplateCount()
+    expect(nftTemplateCount).to.equal('2')
+    const nftTemplate = await nftFactory.getNFTTemplate(2)
+    assert(nftTemplate.isActive === true)
+    assert(nftTemplate.templateAddress === contracts.fixedRateAddress)
+  })
+  it('#disableNFTTemplate - should disable NFT template if factory owner', async () => {
+    let nftTemplate = await nftFactory.getNFTTemplate(2)
+    assert(nftTemplate.isActive === true)
+    await nftFactory.disableNFTTemplate(contracts.accounts[0], 2) // owner disables template index = 2
+
+    nftTemplate = await nftFactory.getNFTTemplate(2)
+    assert(nftTemplate.isActive === false)
+  })
+  it('#reactivateNFTTemplate - should disable NFT template if factory owner', async () => {
+    let nftTemplate = await nftFactory.getNFTTemplate(2)
+    assert(nftTemplate.isActive === false)
+    await nftFactory.reactivateNFTTemplate(contracts.accounts[0], 2) // owner reactivates template index = 2
+
+    nftTemplate = await nftFactory.getNFTTemplate(2)
+    assert(nftTemplate.isActive === true)
+  })
+  it('#addTokenTemplate - should add Datatoken template if factory owner', async () => {
+    await nftFactory.addTokenTemplate(contracts.accounts[0], contracts.fixedRateAddress) // contracts.fixedRateAddress it's just a dummy contract in this case
+    const tokenTemplateCount = await nftFactory.getCurrentTokenTemplateCount()
+    expect(tokenTemplateCount).to.equal('2')
+    const nftTemplate = await nftFactory.getTokenTemplate(2)
+    assert(nftTemplate.isActive === true)
+    assert(nftTemplate.templateAddress === contracts.fixedRateAddress)
+  })
+
+  it('#disableTokenTemplate - should disable Token template if factory owner', async () => {
+    let tokenTemplate = await nftFactory.getTokenTemplate(2)
+    assert(tokenTemplate.isActive === true)
+    await nftFactory.disableTokenTemplate(contracts.accounts[0], 2) // owner disables template index = 2
+
+    tokenTemplate = await nftFactory.getTokenTemplate(2)
+    assert(tokenTemplate.isActive === false)
+  })
+  it('#reactivateTokenTemplate - should disable Token template if factory owner', async () => {
+    let tokenTemplate = await nftFactory.getTokenTemplate(2)
+    assert(tokenTemplate.isActive === false)
+    await nftFactory.reactivateTokenTemplate(contracts.accounts[0], 2) // owner reactivates template index = 2
+
+    tokenTemplate = await nftFactory.getTokenTemplate(2)
+    assert(tokenTemplate.isActive === true)
+  })
+
+  it('#createNftwithErc - should create an NFT and a Datatoken ', async () => {
+    // we prepare transaction parameters objects
+    const nftData: NftCreateData = {
+      name: '72120Bundle',
+      symbol: '72Bundle',
+      templateIndex: 1,
+      tokenURI: 'https://oceanprotocol.com/nft/'
+    }
+
+    const ercParams: Erc20CreateParams = {
+      templateIndex: 1,
+      minter: contracts.accounts[0],
+      feeManager: user3,
+      mpFeeAddress: user2,
+      feeToken: '0x0000000000000000000000000000000000000000',
+      cap: '10000',
+      feeAmount: '0',
+      name: 'ERC20B1',
+      symbol: 'ERC20DT1Symbol'
+    }
+
+    const txReceipt = await nftFactory.createNftWithErc(
+      contracts.accounts[0],
+      nftData,
+      ercParams
+    )
+
+    // EVENTS HAVE BEEN EMITTED
+    expect(txReceipt.events.NFTCreated.event === 'NFTCreated')
+    expect(txReceipt.events.TokenCreated.event === 'TokenCreated')
+
+    // stored for later use in startMultipleTokenOrder test
+    nftAddress = txReceipt.events.NFTCreated.returnValues.newTokenAddress
+    dtAddress = txReceipt.events.TokenCreated.returnValues.newTokenAddress
+  })
+
+  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',
+      templateIndex: 1,
+      tokenURI: 'https://oceanprotocol.com/nft/'
+    }
+
+    const ercParams: Erc20CreateParams = {
+      templateIndex: 1,
+      minter: user2,
+      feeManager: user3,
+      mpFeeAddress: user2,
+      feeToken: '0x0000000000000000000000000000000000000000',
+      cap: '1000000',
+      feeAmount: '0',
+      name: 'ERC20B1',
+      symbol: 'ERC20DT1Symbol'
+    }
+
+    const poolParams: PoolCreationParams = {
+      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 txReceipt = await nftFactory.createNftErcWithPool(
+      contracts.accounts[0],
+      nftData,
+      ercParams,
+      poolParams
+    )
+
+    // EVENTS HAVE BEEN EMITTED
+    expect(txReceipt.events.NFTCreated.event === 'NFTCreated')
+    expect(txReceipt.events.TokenCreated.event === 'TokenCreated')
+    expect(txReceipt.events.NewPool.event === 'NewPool')
+  })
+
+  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',
+      templateIndex: 1,
+      tokenURI: 'https://oceanprotocol.com/nft/'
+    }
+
+    const ercParams: Erc20CreateParams = {
+      templateIndex: 1,
+      minter: contracts.accounts[0],
+      feeManager: user3,
+      mpFeeAddress: user2,
+      feeToken: '0x0000000000000000000000000000000000000000',
+      cap: '1000000',
+      feeAmount: '0',
+      name: 'ERC20B1',
+      symbol: 'ERC20DT1Symbol'
+    }
+
+    const freParams: FreCreationParams = {
+      fixedRateAddress: contracts.fixedRateAddress,
+      baseTokenAddress: contracts.daiAddress,
+      owner: contracts.accounts[0],
+      marketFeeCollector: contracts.accounts[0],
+      baseTokenDecimals: 18,
+      dataTokenDecimals: 18,
+      fixedRate: '1',
+      marketFee: 1e15,
+      allowedConsumer: contracts.accounts[0],
+      withMint: false
+    }
+
+    const txReceipt = await nftFactory.createNftErcWithFixedRate(
+      contracts.accounts[0],
+      nftData,
+      ercParams,
+      freParams
+    )
+
+    // EVENTS HAVE BEEN EMITTED
+    expect(txReceipt.events.NFTCreated.event === 'NFTCreated')
+    expect(txReceipt.events.TokenCreated.event === 'TokenCreated')
+    expect(txReceipt.events.NewFixedRate.event === 'NewFixedRate')
+
+    // stored for later use in startMultipleTokenOrder test
+    dtAddress2 = txReceipt.events.TokenCreated.returnValues.newTokenAddress
+  })
+
+  it('#startMultipleTokenOrder- should succed to start multiple orders', async () => {
+    const consumer = user2 // could be different user
+    const dtAmount = web3.utils.toWei('1')
+    const serviceIndex = 1 // dummy index
+    const consumeFeeAddress = user3 // 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')
+
+    // dt owner mint dtAmount to user2
+    await dtContract.methods.mint(user2, dtAmount).send({ from: contracts.accounts[0] })
+
+    // user2 approves NFTFactory to move his dtAmount
+    await dtContract.methods
+      .approve(contracts.factory721Address, dtAmount)
+      .send({ from: user2 })
+
+    // 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')
+
+    // dt owner mint dtAmount to user2
+    await dtContract2.methods.mint(user2, dtAmount).send({ from: contracts.accounts[0] })
+    // user2 approves NFTFactory to move his dtAmount
+    await dtContract2.methods
+      .approve(contracts.factory721Address, dtAmount)
+      .send({ from: user2 })
+
+    // 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)
+
+    const orders: TokenOrder[] = [
+      {
+        tokenAddress: dtAddress,
+        consumer: consumer,
+        amount: dtAmount,
+        serviceIndex: serviceIndex,
+        providerFeeAddress: consumeFeeAddress,
+        providerFeeToken: consumeFeeToken,
+        providerFeeAmount: consumeFeeAmount
+      },
+      {
+        tokenAddress: dtAddress2,
+        consumer: consumer,
+        amount: dtAmount,
+        serviceIndex: serviceIndex,
+        providerFeeAddress: consumeFeeAddress,
+        providerFeeToken: consumeFeeToken,
+        providerFeeAmount: consumeFeeAmount
+      }
+    ]
+
+    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')
+  })
+
+  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(nftAddress)) === false)
+  })
+
+  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(nftAddress)) === nftAddress)
+  })
+})
diff --git a/test/unit/tokens/Nft.test.ts b/test/unit/tokens/Nft.test.ts
new file mode 100644
index 00000000..424ba910
--- /dev/null
+++ b/test/unit/tokens/Nft.test.ts
@@ -0,0 +1,300 @@
+import { assert } from 'chai'
+import Web3 from 'web3'
+import PoolTemplate from '@oceanprotocol/contracts/artifacts/contracts/pools/balancer/BPool.sol/BPool.json'
+import ERC721Factory from '@oceanprotocol/contracts/artifacts/contracts/ERC721Factory.sol/ERC721Factory.json'
+import ERC721Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC721Template.sol/ERC721Template.json'
+import SideStaking from '@oceanprotocol/contracts/artifacts/contracts/pools/ssContracts/SideStaking.sol/SideStaking.json'
+import Router from '@oceanprotocol/contracts/artifacts/contracts/pools/FactoryRouter.sol/FactoryRouter.json'
+import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
+import Dispenser from '@oceanprotocol/contracts/artifacts/contracts/pools/dispenser/Dispenser.sol/Dispenser.json'
+import FixedRate from '@oceanprotocol/contracts/artifacts/contracts/pools/fixedRate/FixedRateExchange.sol/FixedRateExchange.json'
+import OPFCollector from '@oceanprotocol/contracts/artifacts/contracts/communityFee/OPFCommunityFeeCollector.sol/OPFCommunityFeeCollector.json'
+import { TestContractHandler } from '../../TestContractHandler'
+import { NftFactory, NftCreateData } from '../../../src/factories/NftFactory'
+import { Nft } from '../../../src/tokens/NFT'
+import { AbiItem } from 'web3-utils'
+
+const web3 = new Web3('http://127.0.0.1:8545')
+
+describe('NFT', () => {
+  let nftOwner: string
+  let user1: string
+  let user2: string
+  let user3: string
+  let contractHandler: TestContractHandler
+  let nftDatatoken: Nft
+  let nftFactory: NftFactory
+  let nftAddress: string
+
+  const nftName = 'NFTName'
+  const nftSymbol = 'NFTSymbol'
+  const publishMarketFeeAdress = '0xeE9300b7961e0a01d9f0adb863C7A227A07AaD75'
+  const oceanAddress = '0x967da4048cd07ab37855c090aaf366e4ce1b9f48'
+
+  it('should deploy contracts', async () => {
+    contractHandler = new TestContractHandler(
+      web3,
+      ERC721Template.abi as AbiItem[],
+      ERC20Template.abi as AbiItem[],
+      PoolTemplate.abi as AbiItem[],
+      ERC721Factory.abi as AbiItem[],
+      Router.abi as AbiItem[],
+      SideStaking.abi as AbiItem[],
+      FixedRate.abi as AbiItem[],
+      Dispenser.abi as AbiItem[],
+      OPFCollector.abi as AbiItem[],
+
+      ERC721Template.bytecode,
+      ERC20Template.bytecode,
+      PoolTemplate.bytecode,
+      ERC721Factory.bytecode,
+      Router.bytecode,
+      SideStaking.bytecode,
+      FixedRate.bytecode,
+      Dispenser.bytecode,
+      OPFCollector.bytecode
+    )
+    await contractHandler.getAccounts()
+    nftOwner = contractHandler.accounts[0]
+    user1 = contractHandler.accounts[1]
+    user2 = contractHandler.accounts[2]
+    user3 = contractHandler.accounts[3]
+    await contractHandler.deployContracts(nftOwner, Router.abi as AbiItem[])
+  })
+
+  it('should initialize NFTFactory instance and create a new NFT', async () => {
+    nftFactory = new NftFactory(
+      contractHandler.factory721Address,
+      web3,
+      ERC721Factory.abi as AbiItem[]
+    )
+    const nftData: NftCreateData = {
+      name: nftName,
+      symbol: nftSymbol,
+      templateIndex: 1,
+      tokenURI: 'https://oceanprotocol.com/nft/'
+    }
+
+    nftAddress = await nftFactory.createNFT(nftOwner, nftData)
+    nftDatatoken = new Nft(web3, ERC721Template.abi as AbiItem[])
+  })
+
+  it('#createERC20 - should create a new ERC20 DT from NFT contract', async () => {
+    const erc20Address = await nftDatatoken.createErc20(
+      nftAddress,
+      nftOwner,
+      nftOwner,
+      user1,
+      user2,
+      '0x0000000000000000000000000000000000000000',
+      '0',
+      '10000',
+      nftName,
+      nftSymbol,
+      1
+    )
+    assert(erc20Address !== null)
+  })
+
+  // Manager
+  it('#addManager - should add a new Manager', async () => {
+    assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).manager === false)
+
+    await nftDatatoken.addManager(nftAddress, nftOwner, user1)
+
+    assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).manager === true)
+  })
+
+  it('#addManager - should fail to add a new Manager, if NOT NFT Owner', async () => {
+    try {
+      await nftDatatoken.addManager(nftAddress, user1, user1)
+    } catch (e) {
+      assert(e.message === 'Caller is not NFT Owner')
+    }
+  })
+
+  it('#removeManager - should remove a Manager', async () => {
+    assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).manager === true)
+
+    await nftDatatoken.removeManager(nftAddress, nftOwner, user1)
+
+    assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).manager === false)
+  })
+
+  it('#removeManager - should fail to remove a new Manager, if NOT NFT Owner', async () => {
+    try {
+      await nftDatatoken.removeManager(nftAddress, user1, nftOwner)
+    } catch (e) {
+      assert(e.message === 'Caller is not NFT Owner')
+    }
+  })
+
+  // ERC20Deployer
+  it('#addERC20Deployer -should add ERC20deployer if Manager', async () => {
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === false)
+
+    await nftDatatoken.addErc20Deployer(nftAddress, nftOwner, user1)
+
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === true)
+  })
+
+  it('#addERC20Deployer - should fail to add ERC20deployer if NOT Manager', async () => {
+    try {
+      await nftDatatoken.addErc20Deployer(nftAddress, user1, user1)
+    } catch (e) {
+      assert(
+        e.message ===
+          'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: NOT MANAGER'
+      )
+    }
+  })
+
+  it('#removeERC20Deployer - remove ERC20deployer if Manager', async () => {
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === true)
+
+    await nftDatatoken.removeErc20Deployer(nftAddress, nftOwner, user1)
+
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === false)
+  })
+
+  it('#removeERC20Deployer - should fail and remove ERC20deployer if NOT Manager', async () => {
+    try {
+      await nftDatatoken.removeErc20Deployer(nftAddress, user1, user1)
+    } catch (e) {
+      assert(
+        e.message ===
+          'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: Not enough permissions to remove from ERC20List'
+      )
+    }
+  })
+
+  //  MetadataUpdate
+  it('#addMetadataUpdate - should add to remove Metadata Updater if Manager', async () => {
+    assert(
+      (await nftDatatoken.getNftPermissions(nftAddress, user1)).updateMetadata === false
+    )
+
+    await nftDatatoken.addMetadataUpdater(nftAddress, nftOwner, user1)
+
+    assert(
+      (await nftDatatoken.getNftPermissions(nftAddress, user1)).updateMetadata === true
+    )
+  })
+
+  it('#addMetadataUpdate - should fail to add Metadata Updater if NOT Manager', async () => {
+    try {
+      await nftDatatoken.addMetadataUpdater(nftAddress, user1, user1)
+    } catch (e) {
+      assert(
+        e.message ===
+          'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: NOT MANAGER'
+      )
+    }
+  })
+
+  it('#removeMetadataUpdate - remove Metadata Updater if Manager', async () => {
+    assert(
+      (await nftDatatoken.getNftPermissions(nftAddress, user1)).updateMetadata === true
+    )
+
+    await nftDatatoken.removeMetadataUpdater(nftAddress, nftOwner, user1)
+
+    assert(
+      (await nftDatatoken.getNftPermissions(nftAddress, user1)).updateMetadata === false
+    )
+  })
+
+  it('#removeMetadataUpdate - should fail to remove Metadata Updater if NOT Manager', async () => {
+    try {
+      await nftDatatoken.removeMetadataUpdater(nftAddress, user1, user1)
+    } catch (e) {
+      assert(
+        e.message ===
+          'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: Not enough permissions to remove from metadata list'
+      )
+    }
+  })
+
+  // StoreUpdater
+  it('#addStoreUpdater - should add to remove Store Updater if Manager', async () => {
+    assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).store === false)
+
+    await nftDatatoken.addStoreUpdater(nftAddress, nftOwner, user1)
+
+    assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).store === true)
+  })
+
+  it('#addStoreUpdater - should fail to add Store Updater if NOT Manager', async () => {
+    try {
+      await nftDatatoken.addStoreUpdater(nftAddress, user1, user1)
+    } catch (e) {
+      assert(
+        e.message ===
+          'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: NOT MANAGER'
+      )
+    }
+  })
+
+  it('#removeStoreUpdater - remove Metadata Updater if Manager', async () => {
+    assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).store === true)
+
+    await nftDatatoken.removeStoreUpdater(nftAddress, nftOwner, user1)
+
+    assert((await nftDatatoken.getNftPermissions(nftAddress, user1)).store === false)
+  })
+
+  it('#removeStoreUpdater - should fail to remove Metadata Updater if NOT Manager', async () => {
+    try {
+      await nftDatatoken.removeStoreUpdater(nftAddress, user1, user1)
+    } catch (e) {
+      assert(
+        e.message ===
+          'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: Not enough permissions to remove from 725StoreList'
+      )
+    }
+  })
+
+  // Transfer test
+  it('#transferNFT - should fail to transfer the NFT and clean all permissions, if NOT NFT Owner', async () => {
+    assert((await nftDatatoken.getNftOwner(nftAddress)) !== user1)
+
+    try {
+      await nftDatatoken.transferNft(nftAddress, user1, user1, 1)
+    } catch (e) {
+      assert(e.message === 'Caller is not NFT Owner')
+    }
+  })
+
+  it('#transferNFT - should transfer the NFT and clean all permissions, set new owner as manager', async () => {
+    await nftDatatoken.addManager(nftAddress, nftOwner, user2)
+    await nftDatatoken.addErc20Deployer(nftAddress, user2, user1)
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === true)
+
+    assert((await nftDatatoken.getNftOwner(nftAddress)) === nftOwner)
+    await nftDatatoken.transferNft(nftAddress, nftOwner, user1, 1)
+    assert((await nftDatatoken.getNftOwner(nftAddress)) === user1)
+
+    // console.log(await nftDatatoken.isErc20Deployer(nftAddress, user1))
+    // assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === false)
+  })
+
+  // Clear permisions
+  it('#cleanPermissions - should fail to cleanPermissions if NOT NFTOwner', async () => {
+    try {
+      await nftDatatoken.cleanPermissions(nftAddress, user1)
+    } catch (e) {
+      assert(e.message === 'Caller is not NFT Owner')
+    }
+  })
+
+  it('#cleanPermissions - should cleanPermissions if NFTOwner', async () => {
+    await nftDatatoken.addManager(nftAddress, user1, user1)
+    await nftDatatoken.addErc20Deployer(nftAddress, user1, user2)
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user2)) === true)
+
+    await nftDatatoken.cleanPermissions(nftAddress, user1)
+
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user2)) === false)
+    assert((await nftDatatoken.getNftPermissions(nftAddress, nftOwner)).manager === false)
+  })
+})