added interfaces for fixedRate and Dispenser

src/datatokens/Datatoken.ts

@@ -30,6 +30,25 @@ export interface FreParams {
   maxBaseTokenAmount: string
 }
 
+export interface FixedRateParams {
+  baseTokenAddress: string
+  owner: string
+  marketFeeCollector: string
+  baseTokenDecimals: number
+  dataTokenDecimals: number
+  fixedRate: string
+  marketFee: number
+  withMint?: boolean // add FixedPriced contract as minter if withMint == true
+  allowedConsumer?: string //  only account that consume the exhchange
+}
+
+export interface DispenserParams {
+  maxTokens: string
+  maxBalance: string
+  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
+}
+
 export class Datatoken {
   public GASLIMIT_DEFAULT = 1000000
   public factoryAddress: string
@@ -161,13 +180,7 @@ export class Datatoken {
    * @param {String} dtAddress Datatoken address
    * @param {String} address Caller address
    * @param {String} fixedPriceAddress
-   * @param {String} baseTokenAddress
+   * @param {FixedRateParams} fixedRateParams
-   * @param {String} marketFeeCollector
-   * @param {String} baseTokenDecimals
-   * @param {String} dataTokenDecimals
-   * @param {String} fixedRate
-   * @param {String} marketFee
-   * @param {String} withMint
    * @param {Contract} contractInstance optional contract instance
    * @return {Promise<any>}
    */
@@ -175,26 +188,36 @@ export class Datatoken {
     dtAddress: string,
     address: string,
     fixedPriceAddress: string,
-    baseTokenAddress: string,
+    fixedRateParams: FixedRateParams,
-    marketFeeCollector: string,
-    baseTokenDecimals: number,
-    dataTokenDecimals: number,
-    fixedRate: String,
-    marketFee: number,
-    withMint: number,
     contractInstance?: Contract
   ): Promise<any> {
     const dtContract =
       contractInstance || new this.web3.eth.Contract(this.datatokensABI, dtAddress)
 
     const gasLimitDefault = this.GASLIMIT_DEFAULT
+
+    if (!fixedRateParams.allowedConsumer)
+      fixedRateParams.allowedConsumer = '0x0000000000000000000000000000000000000000'
+    const withMint = fixedRateParams.withMint ? 1 : 0
+
     let estGas
     try {
       estGas = await dtContract.methods
         .createFixedRate(
           fixedPriceAddress,
-          [baseTokenAddress, address, marketFeeCollector],
+          [
-          [baseTokenDecimals, dataTokenDecimals, fixedRate, marketFee, withMint]
+            fixedRateParams.baseTokenAddress,
+            address,
+            fixedRateParams.marketFeeCollector,
+            fixedRateParams.allowedConsumer
+          ],
+          [
+            fixedRateParams.baseTokenDecimals,
+            fixedRateParams.dataTokenDecimals,
+            fixedRateParams.fixedRate,
+            fixedRateParams.marketFee,
+            withMint
+          ]
         )
         .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
     } catch (e) {
@@ -209,42 +232,29 @@ export class Datatoken {
    * @param {String} dtAddress Datatoken address
    * @param {String} address Caller address
    * @param {String} fixedPriceAddress
-   * @param {String} baseTokenAddress
+   * @param {FixedRateParams} fixedRateParams
-   * @param {String} marketFeeCollector
-   * @param {String} baseTokenDecimals
-   * @param {String} dataTokenDecimals
-   * @param {String} fixedRate
-   * @param {String} marketFee
-   * @param {String} withMint
    * @return {Promise<TransactionReceipt>} transactionId
    */
   public async createFixedRate(
     dtAddress: string,
     address: string,
     fixedPriceAddress: string,
-    baseTokenAddress: string,
+    fixedRateParams: FixedRateParams
-    marketFeeCollector: string,
-    baseTokenDecimals: number,
-    dataTokenDecimals: number,
-    fixedRate: String,
-    marketFee: number,
-    withMint: number
   ): Promise<TransactionReceipt> {
     const dtContract = new this.web3.eth.Contract(this.datatokensABI, dtAddress)
 
+    if (!fixedRateParams.allowedConsumer)
+      fixedRateParams.allowedConsumer = '0x0000000000000000000000000000000000000000'
+
+    const withMint = fixedRateParams.withMint ? 1 : 0
+
     // should check ERC20Deployer role using erc721 level ..
 
     const estGas = await this.estGasCreateFixedRate(
       dtAddress,
       address,
       fixedPriceAddress,
-      baseTokenAddress,
+      fixedRateParams,
-      marketFeeCollector,
-      baseTokenDecimals,
-      dataTokenDecimals,
-      fixedRate,
-      marketFee,
-      withMint,
       dtContract
     )
 
@@ -253,12 +263,18 @@ export class Datatoken {
       .createFixedRate(
         fixedPriceAddress,
         [
-          baseTokenAddress,
+          fixedRateParams.baseTokenAddress,
-          address,
+          fixedRateParams.owner,
-          marketFeeCollector,
+          fixedRateParams.marketFeeCollector,
-          '0x0000000000000000000000000000000000000000'
+          fixedRateParams.allowedConsumer
         ],
-        [baseTokenDecimals, dataTokenDecimals, fixedRate, marketFee, withMint]
+        [
+          fixedRateParams.baseTokenDecimals,
+          fixedRateParams.dataTokenDecimals,
+          fixedRateParams.fixedRate,
+          fixedRateParams.marketFee,
+          withMint
+        ]
       )
       .send({
         from: address,
@@ -272,32 +288,37 @@ export class Datatoken {
    * Estimate gas cost for createDispenser method
    * @param {String} dtAddress Datatoken address
    * @param {String} address Caller address
-   * @param {String} dispenser ispenser contract address
+   * @param {String} dispenserAddress ispenser contract address
-   * @param {String} maxTokens max tokens to dispense
+   * @param {String} dispenserParams
-   * @param {String} maxBalance max balance of requester
-   * @param {Boolean} withMint true if we want to allow the dispenser to be a minter
-   * @param {String} allowedSwapper  only account that can ask tokens. set address(0) if not required
    * @param {Contract} contractInstance optional contract instance
    * @return {Promise<any>}
    */
   public async estGasCreateDispenser(
     dtAddress: string,
     address: string,
-    dispenser: string,
+    dispenserAddress: string,
-    maxTokens: string,
+    dispenserParams: DispenserParams,
-    maxBalance: string,
-    withMint: Boolean,
-    allowedSwapper: string,
     contractInstance?: Contract
   ): Promise<any> {
     const dtContract =
       contractInstance || new this.web3.eth.Contract(this.datatokensABI, dtAddress)
 
+    if (!dispenserParams.allowedSwapper)
+      dispenserParams.allowedSwapper = '0x0000000000000000000000000000000000000000'
+
+    if (!dispenserParams.withMint) dispenserParams.withMint = false
+
     const gasLimitDefault = this.GASLIMIT_DEFAULT
     let estGas
     try {
       estGas = await dtContract.methods
-        .createDispenser(dispenser, maxTokens, maxBalance, withMint, allowedSwapper)
+        .createDispenser(
+          dispenserAddress,
+          dispenserParams.maxTokens,
+          dispenserParams.maxBalance,
+          dispenserParams.withMint,
+          dispenserParams.allowedSwapper
+        )
         .estimateGas({ from: address }, (err, estGas) => (err ? gasLimitDefault : estGas))
     } catch (e) {
       estGas = gasLimitDefault
@@ -310,40 +331,42 @@ export class Datatoken {
    * Creates a new Dispenser
    * @param {String} dtAddress Datatoken address
    * @param {String} address Caller address
-   * @param {String} dispenser ispenser contract address
+   * @param {String} dispenserAddress ispenser contract address
-   * @param {String} maxTokens max tokens to dispense
+   * @param {String} dispenserParams
-   * @param {String} maxBalance max balance of requester
-   * @param {Boolean} withMint true if we want to allow the dispenser to be a minter
-   * @param {String} allowedSwapper  only account that can ask tokens. set address(0) if not required
    * @return {Promise<TransactionReceipt>} transactionId
    */
   public async createDispenser(
     dtAddress: string,
     address: string,
-    dispenser: string,
+    dispenserAddress: string,
-    maxTokens: string,
+    dispenserParams: DispenserParams
-    maxBalance: string,
-    withMint: Boolean,
-    allowedSwapper: string
   ): Promise<TransactionReceipt> {
     const dtContract = new this.web3.eth.Contract(this.datatokensABI, dtAddress)
 
+    if (!dispenserParams.allowedSwapper)
+      dispenserParams.allowedSwapper = '0x0000000000000000000000000000000000000000'
+
+    if (!dispenserParams.withMint) dispenserParams.withMint = false
+
     // should check ERC20Deployer role using erc721 level ..
 
     const estGas = await this.estGasCreateDispenser(
       dtAddress,
       address,
-      dispenser,
+      dispenserAddress,
-      maxTokens,
+      dispenserParams,
-      maxBalance,
-      withMint,
-      allowedSwapper,
       dtContract
     )
 
     // Call createFixedRate contract method
     const trxReceipt = await dtContract.methods
-      .createDispenser(dispenser, maxTokens, maxBalance, withMint, allowedSwapper)
+      .createDispenser(
+        dispenserAddress,
+        dispenserParams.maxTokens,
+        dispenserParams.maxBalance,
+        dispenserParams.withMint,
+        dispenserParams.allowedSwapper
+      )
       .send({
         from: address,
         gas: estGas + 1,

test/unit/Datatoken.test.ts

@@ -14,7 +14,14 @@ import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/M
 
 import { TestContractHandler } from '../TestContractHandler'
 import { NFTFactory } from '../../src/factories/NFTFactory'
-import { Datatoken, NFTDatatoken, OrderParams, FreParams } from '../../src/datatokens'
+import {
+  Datatoken,
+  NFTDatatoken,
+  OrderParams,
+  FreParams,
+  FixedRateParams,
+  DispenserParams
+} from '../../src/datatokens'
 import { AbiItem } from 'web3-utils'
 import { LoggerInstance } from '../../src/utils'
 
@@ -145,17 +152,20 @@ describe('Datatoken', () => {
   })
 
   it('#createFixedRate - should create FRE for the erc20 dt', async () => {
+    const freParams: FixedRateParams = {
+      baseTokenAddress: contractHandler.daiAddress,
+      owner: nftOwner,
+      marketFeeCollector: nftOwner,
+      baseTokenDecimals: 18,
+      dataTokenDecimals: 18,
+      fixedRate: web3.utils.toWei('1'),
+      marketFee: 1e15
+    }
     const fre = await datatoken.createFixedRate(
       datatokenAddress,
       nftOwner,
       contractHandler.fixedRateAddress,
-      contractHandler.daiAddress,
+      freParams
-      nftOwner,
-      18,
-      18,
-      web3.utils.toWei('1'),
-      1e15,
-      1
     )
     assert(fre !== null)
     fixedRateAddress = fre.events.NewFixedRate.address
@@ -163,14 +173,16 @@ describe('Datatoken', () => {
   })
 
   it('#createDispenser - method creates a dispenser for the erc20DT', async () => {
+    const dispenserParams: DispenserParams = {
+      maxTokens: '10',
+      maxBalance: '100'
+    }
+
     const dispenser = await datatoken.createDispenser(
       datatokenAddress,
       nftOwner,
       contractHandler.dispenserAddress,
-      '10',
+      dispenserParams
-      '100',
-      true,
-      user1
     )
     assert(dispenser !== null)
   })

test/unit/pools/Router.test.ts

@@ -215,7 +215,11 @@ describe('Router unit test', () => {
       ]
     }
 
-    const nftFactory = new NFTFactory(contracts.factory721Address, web3, LoggerInstance)
+    const nftFactory = new NFTFactory(
+      contracts.factory721Address,
+      web3,
+      ERC721Factory.abi as AbiItem[]
+    )
 
     const txReceipt = await nftFactory.createNftErcWithPool(
       contracts.accounts[0],

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

@@ -172,7 +172,11 @@ describe('Pool unit test', () => {
         ]
       }
 
-      const nftFactory = new NFTFactory(contracts.factory721Address, web3, LoggerInstance)
+      const nftFactory = new NFTFactory(
+        contracts.factory721Address,
+        web3,
+        ERC721Factory.abi as AbiItem[]
+      )
 
       const txReceipt = await nftFactory.createNftErcWithPool(
         contracts.accounts[0],
@@ -619,7 +623,11 @@ describe('Pool unit test', () => {
         ]
       }
 
-      const nftFactory = new NFTFactory(contracts.factory721Address, web3, LoggerInstance)
+      const nftFactory = new NFTFactory(
+        contracts.factory721Address,
+        web3,
+        ERC721Factory.abi as AbiItem[]
+      )
 
       const txReceipt = await nftFactory.createNftErcWithPool(
         contracts.accounts[0],