add create with dispenser

package.json

@@ -30,7 +30,7 @@
     "test:dispenser": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/pools/dispenser/Dispenser.test.ts'",
     "test:dt": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/Datatoken.test.ts'",
     "test:nftDt": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/NFT.test.ts'",
-    "test:factory": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/NFTFactory.test.ts'",
+    "test:factory": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/NftFactory.test.ts'",
     "test:router": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/pools/Router.test.ts'",
     "test:unit": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/**/*.test.ts'",
     "test:unit:cover": "nyc --report-dir coverage/unit npm run test:unit",

src/factories/NFTFactory.ts

@@ -11,7 +11,12 @@ import {
   getErcCreationParams,
   getPoolCreationParams
 } from '../utils'
-import { FreCreationParams, Erc20CreateParams, PoolCreationParams } from '../interfaces'
+import {
+  FreCreationParams,
+  Erc20CreateParams,
+  PoolCreationParams,
+  DispenserCreationParams
+} from '../interfaces'
 
 interface Template {
   templateAddress: string
@@ -750,4 +755,70 @@ export class NftFactory {
 
     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 dispenserParams input data for Dispenser Creation
+   * @return {Promise<TransactionReceipt>} transaction receipt
+   */
+  public async estGasCreateNftErcWithDispenser(
+    address: string,
+    nftCreateData: NftCreateData,
+    ercParams: Erc20CreateParams,
+    dispenserParams: DispenserCreationParams
+  ): Promise<any> {
+    const gasLimitDefault = this.GASLIMIT_DEFAULT
+    let estGas
+
+    const ercCreateData = getErcCreationParams(ercParams)
+
+    try {
+      estGas = await this.factory721.methods
+        .createNftErcWithDispenser(nftCreateData, ercCreateData, dispenserParams)
+        .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
+    } catch (e) {
+      estGas = gasLimitDefault
+      LoggerInstance.error('Failed to estimate gas for createNftErcWithDispenser', e)
+    }
+    return estGas
+  }
+
+  /**
+   * @dev createNftErcWithDispenser
+   *      Creates a new NFT, then a ERC20, then a Dispenser, all in one call
+   *      Use this carefully, because if Dispenser 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 dispenserParams input data for Dispenser Creation
+   *  @return {Promise<TransactionReceipt>} transaction receipt
+   */
+  public async createNftErcWithDispenser(
+    address: string,
+    nftCreateData: NftCreateData,
+    ercParams: Erc20CreateParams,
+    dispenserParams: DispenserCreationParams
+  ): Promise<TransactionReceipt> {
+    const ercCreateData = getErcCreationParams(ercParams)
+
+    const estGas = await this.estGasCreateNftErcWithDispenser(
+      address,
+      nftCreateData,
+      ercParams,
+      dispenserParams
+    )
+
+    // Invoke createToken function of the contract
+    const trxReceipt = await this.factory721.methods
+      .createNftErcWithDispenser(nftCreateData, ercCreateData, dispenserParams)
+      .send({
+        from: address,
+        gas: estGas + 1,
+        gasPrice: await getFairGasPrice(this.web3)
+      })
+
+    return trxReceipt
+  }
 }

src/interfaces/DispenserInterface.ts

@@ -1,6 +1,7 @@
 export interface DispenserCreationParams {
-  maxTokens: string
-  maxBalance: string
+  dispenserAddress: string
+  maxTokens: string // how many tokens cand be dispensed when someone requests . If maxTokens=2 then someone can't request 3 in one tx
+  maxBalance: string // how many dt the user has in it's wallet before the dispenser will not dispense dt
   withMint?: boolean // true if we want to allow the dispenser to be a minter
   allowedSwapper?: string // only account that can ask tokens. set address(0) if not required
 }

src/utils/ConfigHelper.ts

@@ -2,7 +2,7 @@ import Config from '../models/Config'
 import fs from 'fs'
 import { homedir } from 'os'
 // eslint-disable-next-line import/no-named-default
-import { default as DefaultContractsAddresses } from '@oceanprotocol/contracts/addresses/address.json'
+import { default as DefaultContractsAddresses } from '@oceanprotocol/contracts/address.json'
 import LoggerInstance from './Logger'
 
 const configHelperNetworksBase: Config = {

src/utils/Constants.ts

@@ -0,0 +1 @@
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'

src/utils/index.ts

@@ -5,3 +5,4 @@ export * from './ContractParams'
 export * from './FetchHelper'
 export * from './ConfigHelper'
 export * from './DdoHelpers'
+export * from './Constants'

test/unit/NftFactory.test.ts

@@ -17,6 +17,7 @@ import {
   Erc20CreateParams,
   PoolCreationParams
 } from '../../src/interfaces'
+import { ZERO_ADDRESS } from '../../src/utils'
 
 const web3 = new Web3('http://127.0.0.1:8545')
 
@@ -294,6 +295,51 @@ describe('Nft Factory test', () => {
     dtAddress2 = txReceipt.events.TokenCreated.returnValues.newTokenAddress
   })
 
+  it('#createNftErcWithDispenser- should create an NFT, a datatoken and create a Dispenser', async () => {
+    // we prepare transaction parameters objects
+    const nftData: NftCreateData = {
+      name: '72120Bundle',
+      symbol: '72Bundle',
+      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 dispenserParams = {
+      dispenserAddress: contracts.dispenserAddress,
+      maxTokens: web3.utils.toWei('1'),
+      maxBalance: web3.utils.toWei('1'),
+      withMint: true,
+      allowedSwapper: ZERO_ADDRESS
+    }
+
+    const txReceipt = await nftFactory.createNftErcWithDispenser(
+      contracts.accounts[0],
+      nftData,
+      ercParams,
+      dispenserParams
+    )
+
+    // EVENTS HAVE BEEN EMITTED
+    expect(txReceipt.events.NFTCreated.event === 'NFTCreated')
+    expect(txReceipt.events.TokenCreated.event === 'TokenCreated')
+    expect(txReceipt.events.DispenserCreated.event === 'DispenserCreated')
+
+    // 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')