@oceanprotocol/lib 1.1.8 → 2.0.0-next.0

package/dist/src/@types/Asset.d.ts

@@ -1,4 +1,4 @@
-import { DDO } from './DDO/DDO';
+import { DDO } from '.';
 export interface AssetNft {
     /**
      * Contract address of the deployed ERC721 NFT contract.
@@ -55,7 +55,7 @@ export interface Purgatory {
 }
 export interface AssetDatatoken {
     /**
-     * Contract address of the deployed ERC20 contract.
+     * Contract address of the deployed Datatoken contract.
      * @type {string}
      */
     address: string;
@@ -89,7 +89,7 @@ export interface Asset extends DDO {
      */
     nft: AssetNft;
     /**
-     * Contains information about the ERC20 datatokens attached to asset services.
+     * Contains information about the ERC20 Datatokens attached to asset services.
      * @type {string}
      */
     datatokens: AssetDatatoken[];
@@ -112,7 +112,7 @@ export interface Asset extends DDO {
     /**
      * Contains information about an asset's purgatory status defined in
      * [`list-purgatory`](https://github.com/oceanprotocol/list-purgatory).
-     * Marketplace interfaces are encouraged to prevent certain user actions like adding liquidity on assets in purgatory.
+     * Marketplace interfaces are encouraged to prevent certain user actions like downloading on assets in purgatory.
      * @type {Purgatory}
      */
     purgatory: Purgatory;

package/dist/src/@types/Compute.d.ts

@@ -1,4 +1,4 @@
-import { Metadata, MetadataAlgorithm } from './DDO/Metadata';
+import { Metadata, MetadataAlgorithm } from '.';
 export declare type ComputeResultType = 'algorithmLog' | 'output' | 'configrationLog' | 'publishLog';
 export interface ComputeEnvironment {
     id: string;

package/dist/src/@types/DDO/DDO.d.ts

@@ -1,7 +1,4 @@
-import { Service } from './Service';
-import { Metadata } from './Metadata';
-import { Credentials } from './Credentials';
-import { Event } from './Event';
+import { Service, Metadata, Credentials, Event } from '..';
 /**
  * DID Descriptor Object.
  * Contains metadata about the asset, and define access in at least one service.
@@ -14,7 +11,7 @@ export interface DDO {
     '@context': string[];
     /**
      * DID, descentralized ID.
-     * Computed as sha256(address of ERC721 contract + chainId)
+     * Computed as sha256(address of NFT contract + chainId)
      * @type {string}
      */
     id: string;

package/dist/src/@types/{Erc20.d.ts → Datatoken.d.ts}

@@ -1,4 +1,5 @@
-export interface Erc20CreateParams {
+import { ProviderFees } from '.';
+export interface DatatokenCreateParams {
     templateIndex: number;
     minter: string;
     paymentCollector: string;
@@ -19,3 +20,19 @@ export interface PublishingMarketFee {
     publishMarketFeeToken: string;
     publishMarketFeeAmount: string;
 }
+export interface DatatokenRoles {
+    minter: boolean;
+    paymentManager: boolean;
+}
+export interface OrderParams {
+    consumer: string;
+    serviceIndex: number;
+    _providerFee: ProviderFees;
+    _consumeMarketFee: ConsumeMarketFee;
+}
+export interface DispenserParams {
+    maxTokens: string;
+    maxBalance: string;
+    withMint?: boolean;
+    allowedSwapper?: string;
+}

package/dist/src/@types/Dispenser.d.ts

@@ -5,3 +5,12 @@ export interface DispenserCreationParams {
     withMint?: boolean;
     allowedSwapper?: string;
 }
+export interface DispenserToken {
+    active: boolean;
+    owner: string;
+    maxTokens: string;
+    maxBalance: string;
+    balance: string;
+    isMinter: boolean;
+    allowedSwapper: string;
+}

package/dist/src/@types/FixedPrice.d.ts

@@ -25,3 +25,27 @@ export interface PriceAndFees {
     marketFeeAmount: string;
     consumeMarketFeeAmount: string;
 }
+export interface FixedPriceExchange {
+    active: boolean;
+    exchangeOwner: string;
+    datatoken: string;
+    baseToken: string;
+    fixedRate: string;
+    dtDecimals: string;
+    btDecimals: string;
+    dtBalance: string;
+    btBalance: string;
+    dtSupply: string;
+    btSupply: string;
+    withMint: boolean;
+    allowedSwapper: string;
+    exchangeId?: string;
+}
+export interface FeesInfo {
+    opcFee: string;
+    marketFee: string;
+    marketFeeCollector: string;
+    marketFeeAvailable: string;
+    oceanFeeAvailable: string;
+    exchangeId: string;
+}

package/dist/src/@types/{Erc721.d.ts → NFT.d.ts}

@@ -10,3 +10,9 @@ export interface MetadataAndTokenURI {
     tokenURI: string;
     metadataProofs?: MetadataProof[];
 }
+export interface NftRoles {
+    manager: boolean;
+    deployERC20: boolean;
+    updateMetadata: boolean;
+    store: boolean;
+}

package/dist/src/@types/NFTFactory.d.ts

@@ -0,0 +1,20 @@
+import { ConsumeMarketFee, ProviderFees } from '.';
+export interface Template {
+    templateAddress: string;
+    isActive: boolean;
+}
+export interface TokenOrder {
+    tokenAddress: string;
+    consumer: string;
+    serviceIndex: number;
+    _providerFee: ProviderFees;
+    _consumeMarketFee: ConsumeMarketFee;
+}
+export interface NftCreateData {
+    name: string;
+    symbol: string;
+    templateIndex: number;
+    tokenURI: string;
+    transferable: boolean;
+    owner: string;
+}

package/dist/src/@types/Provider.d.ts

@@ -23,3 +23,11 @@ export interface ProviderComputeInitializeResults {
     algorithm?: ProviderComputeInitialize;
     datasets?: ProviderComputeInitialize[];
 }
+export interface ServiceEndpoint {
+    serviceName: string;
+    method: string;
+    urlPath: string;
+}
+export interface UserCustomParameters {
+    [key: string]: any;
+}

package/dist/src/@types/ReturnTypes.d.ts

@@ -0,0 +1,2 @@
+import { TransactionReceipt } from 'web3-core';
+export declare type ReceiptOrEstimate<G extends boolean = false> = G extends false ? TransactionReceipt : number;

package/dist/src/@types/Router.d.ts

@@ -1,6 +1,6 @@
 export interface Operation {
     /**
-     * used only for FixedRate or Dispenser, but needs to be filled even for pool
+     * used for FixedRate or Dispenser
      * @type {string}
      */
     exchangeIds: string;

package/dist/src/@types/index.d.ts

@@ -1,15 +1,18 @@
-export * from './DDO/DDO';
-export * from './Asset';
-export * from './DDO/Service';
 export * from './DDO/Credentials';
+export * from './DDO/DDO';
+export * from './DDO/Event';
 export * from './DDO/Metadata';
+export * from './DDO/Service';
+export * from './Asset';
 export * from './File';
 export * from './FileInfo';
 export * from './Compute';
-export * from './Provider';
-export * from './FixedPrice';
-export * from './Pool';
-export * from './Erc20';
-export * from './Erc721';
+export * from './Datatoken';
 export * from './Dispenser';
+export * from './DownloadResponse';
+export * from './FixedPrice';
+export * from './NFT';
+export * from './NFTFactory';
+export * from './Provider';
 export * from './Router';
+export * from './ReturnTypes';

package/dist/src/{models → config}/Config.d.ts

@@ -1,5 +1,5 @@
-import { LogLevel } from '../utils/Logger';
 import { AbiItem } from 'web3-utils/types';
+import { LogLevel } from '../utils';
 export declare class Config {
     /**
      * Ethereum node URL.
@@ -35,32 +35,12 @@ export declare class Config {
      * Factory address
      * @type {string}
      */
-    erc721FactoryAddress?: string;
-    /**
-     * Factory ABI
-     * @type {string}
-     */
-    erc721FFactoryABI?: AbiItem | AbiItem[];
+    nftFactoryAddress?: string;
     /**
      * datatokens ABI
      * @type {string}
      */
     datatokensABI?: AbiItem | AbiItem[];
-    /**
-     * Pool Template address
-     * @type {string}
-     */
-    poolTemplateAddress?: string;
-    /**
-     * Pool Factory ABI
-     * @type {string}
-     */
-    poolFactoryABI?: AbiItem | AbiItem[];
-    /**
-     * Pool ABI
-     * @type {string}
-     */
-    poolABI?: AbiItem | AbiItem[];
     /**
      * FixedRateExchangeAddress
      * @type {string}
@@ -163,4 +143,3 @@ export declare class Config {
      */
     gasFeeMultiplier: number;
 }
-export default Config;

package/dist/src/{utils → config}/ConfigHelper.d.ts

@@ -1,4 +1,4 @@
-import Config from '../models/Config';
+import { Config } from '.';
 export declare const configHelperNetworks: Config[];
 export declare class ConfigHelper {
     getAddressesFromEnv(network: string, customAddresses?: any): Partial<Config>;

package/dist/src/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Config';
+export * from './ConfigHelper';

package/dist/src/contracts/Datatoken.d.ts

@@ -0,0 +1,232 @@
+import Web3 from 'web3';
+import { AbiItem } from 'web3-utils';
+import { TransactionReceipt } from 'web3-eth';
+import { ConsumeMarketFee, FreOrderParams, FreCreationParams, ProviderFees, PublishingMarketFee, DispenserParams, OrderParams, DatatokenRoles, ReceiptOrEstimate } from '../@types';
+import { Nft } from './NFT';
+import { Config } from '../config';
+import { SmartContract } from './SmartContract';
+export declare class Datatoken extends SmartContract {
+    abiEnterprise: AbiItem | AbiItem[];
+    nft: Nft;
+    getDefaultAbi(): AbiItem | AbiItem[];
+    /**
+     * Instantiate ERC20 Datatokens
+     * @param {AbiItem | AbiItem[]} datatokensAbi
+     * @param {Web3} web3
+     */
+    constructor(web3: Web3, network?: string | number, config?: Config, abi?: AbiItem | AbiItem[], abiEnterprise?: AbiItem | AbiItem[]);
+    /**
+     * Approve
+     * @param {String} dtAddress Datatoken address
+     * @param {String} spender Spender address
+     * @param {string} amount Number of datatokens, as number. Will be converted to wei
+     * @param {String} address User adress
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    approve<G extends boolean = false>(dtAddress: string, spender: string, amount: string, address: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Creates a new FixedRateExchange setup.
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address Caller address
+     * @param {String} fixedPriceAddress
+     * @param {FixedRateParams} fixedRateParams
+     * @return {Promise<ReceiptOrEstimate>} transactionId
+     */
+    createFixedRate<G extends boolean = false>(dtAddress: string, address: string, fixedRateParams: FreCreationParams, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Creates a new Dispenser
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address Caller address
+     * @param {String} dispenserAddress ispenser contract address
+     * @param {String} dispenserParams
+     * @return {Promise<ReceiptOrEstimate>} transactionId
+     */
+    createDispenser<G extends boolean = false>(dtAddress: string, address: string, dispenserAddress: string, dispenserParams: DispenserParams, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Mint
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address Minter address
+     * @param {String} amount Number of datatokens, as number. Will be converted to wei
+     * @param {String} toAddress only if toAddress is different from the minter
+     * @return {Promise<ReceiptOrEstimate>} transactionId
+     */
+    mint<G extends boolean = false>(dtAddress: string, address: string, amount: string, toAddress?: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Add Minter for an ERC20 Datatoken
+     * only DatatokenDeployer can succeed
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address User address
+     * @param {String} minter User which is going to be a Minter
+     * @return {Promise<ReceiptOrEstimate>} transactionId
+     */
+    addMinter<G extends boolean = false>(dtAddress: string, address: string, minter: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Revoke Minter permission for an ERC20 Datatoken
+     * only DatatokenDeployer can succeed
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address User address
+     * @param {String} minter User which will be removed from Minter permission
+     * @param {Contract} contractInstance optional contract instance
+     * @return {Promise<any>}
+     */
+    removeMinter<G extends boolean = false>(dtAddress: string, address: string, minter: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Add addPaymentManager (can set who's going to collect fee when consuming orders)
+     * only DatatokenDeployer can succeed
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address User address
+     * @param {String} paymentManager User which is going to be a Minter
+     * @return {Promise<ReceiptOrEstimate>} transactionId
+     */
+    addPaymentManager<G extends boolean = false>(dtAddress: string, address: string, paymentManager: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Revoke paymentManager permission for an ERC20 Datatoken
+     * only DatatokenDeployer can succeed
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address User address
+     * @param {String} paymentManager User which will be removed from paymentManager permission
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    removePaymentManager<G extends boolean = false>(dtAddress: string, address: string, paymentManager: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * This function allows to set a new PaymentCollector (receives DT when consuming)
+     * If not set the paymentCollector is the NFT Owner
+     * only NFT owner can call
+     * @param dtAddress datatoken address
+     * @param address Caller address
+     * @param paymentCollector User to be set as new payment collector
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    setPaymentCollector<G extends boolean = false>(dtAddress: string, address: string, paymentCollector: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** getPaymentCollector - It returns the current paymentCollector
+     * @param dtAddress datatoken address
+     * @return {Promise<string>}
+     */
+    getPaymentCollector(dtAddress: string): Promise<string>;
+    /**
+     * Transfer as number from address to toAddress
+     * @param {String} dtAddress Datatoken address
+     * @param {String} toAddress Receiver address
+     * @param {String} amount Number of datatokens, as number. To be converted to wei.
+     * @param {String} address User adress
+     * @return {Promise<ReceiptOrEstimate>} transactionId
+     */
+    transfer(dtAddress: string, toAddress: string, amount: string, address: string): Promise<TransactionReceipt>;
+    /**
+     * Transfer in wei from address to toAddress
+     * @param {String} dtAddress Datatoken address
+     * @param {String} toAddress Receiver address
+     * @param {String} amount Number of datatokens, as number. Expressed as wei
+     * @param {String} address User adress
+     * @return {Promise<ReceiptOrEstimate>} transactionId
+     */
+    transferWei<G extends boolean = false>(dtAddress: string, toAddress: string, amount: string, address: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** Start Order: called by payer or consumer prior ordering a service consume on a marketplace.
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address User address which calls
+     * @param {String} consumer Consumer Address
+     * @param {Number} serviceIndex  Service index in the metadata
+     * @param {providerFees} providerFees provider fees
+     * @param {consumeMarketFee} ConsumeMarketFee consume market fees
+     * @return {Promise<ReceiptOrEstimate>} string
+     */
+    startOrder<G extends boolean = false>(dtAddress: string, address: string, consumer: string, serviceIndex: number, providerFees: ProviderFees, consumeMarketFee?: ConsumeMarketFee, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** Reuse Order: called by payer or consumer having a valid order, but with expired provider access.
+     * Pays the provider fee again, but it will not require a new datatoken payment
+     * Requires previous approval of provider fee.
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address User address which calls
+     * @param {String} orderTxId previous valid order
+     * @param {providerFees} providerFees provider fees
+     * @return {Promise<ReceiptOrEstimate>} string
+     */
+    reuseOrder<G extends boolean = false>(dtAddress: string, address: string, orderTxId: string, providerFees: ProviderFees, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** Buys 1 DT from the FRE and then startsOrder, while burning that DT
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address User address which calls
+     * @param {OrderParams} orderParams Consumer Address
+     * @param {FreParams} freParams Amount of tokens that is going to be transfered
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    buyFromFreAndOrder<G extends boolean = false>(dtAddress: string, address: string, orderParams: OrderParams, freParams: FreOrderParams, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** Gets DT from dispenser and then startsOrder, while burning that DT
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address User address which calls
+     * @param {OrderParams} orderParams
+     * @param {String} dispenserContract
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    buyFromDispenserAndOrder<G extends boolean = false>(dtAddress: string, address: string, orderParams: OrderParams, dispenserContract: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** setData
+     * This function allows to store data with a preset key (keccak256(dtAddress)) into NFT 725 Store
+     * only DatatokenDeployer can succeed
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address User address
+     * @param {String} value Data to be stored into 725Y standard
+     * @return {Promise<ReceiptOrEstimate>} transactionId
+     */
+    setData<G extends boolean = false>(dtAddress: string, address: string, value: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Clean Datatoken level Permissions (minters, paymentManager and reset the paymentCollector) for an ERC20 Datatoken
+     * Only NFT Owner (at 721 level) can call it.
+     * @param dtAddress Datatoken address where we want to clean permissions
+     * @param address User adress
+     * @return {Promise<ReceiptOrEstimate>} transactionId
+     */
+    cleanPermissions<G extends boolean = false>(dtAddress: string, address: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** Returns ERC20 Datatoken user's permissions for a datatoken
+     * @param {String} dtAddress Datatoken adress
+     * @param {String} address user adress
+     * @return {Promise<DatatokenRoles>}
+     */
+    getPermissions(dtAddress: string, address: string): Promise<DatatokenRoles>;
+    /** Returns the Datatoken capital
+     * @param {String} dtAddress Datatoken adress
+     * @return {Promise<string>}
+     */
+    getCap(dtAddress: string): Promise<string>;
+    /** It returns the token decimals, how many supported decimal points
+     * @param {String} dtAddress Datatoken adress
+     * @return {Promise<number>}
+     */
+    getDecimals(dtAddress: string): Promise<string>;
+    /** It returns the token decimals, how many supported decimal points
+     * @param {String} dtAddress Datatoken adress
+     * @return {Promise<number>}
+     */
+    getNFTAddress(dtAddress: string): Promise<string>;
+    /**  Returns true if address has deployERC20 role
+     * @param {String} dtAddress Datatoken adress
+     * @param {String} dtAddress Datatoken adress
+     * @return {Promise<boolean>}
+     */
+    isDatatokenDeployer(dtAddress: string, address: string): Promise<boolean>;
+    /**
+     * Get Address Balance for datatoken
+     * @param {String} dtAddress Datatoken adress
+     * @param {String} address user adress
+     * @return {Promise<String>} balance  Number of datatokens. Will be converted from wei
+     */
+    balance(datatokenAddress: string, address: string): Promise<string>;
+    /**
+     * @dev setPublishingMarketFee
+     *      Only publishMarketFeeAddress can call it
+     *      This function allows to set the fee required by the publisherMarket
+     * @param {string} datatokenAddress Datatoken adress
+     * @param {string} publishMarketFeeAddress  new publish Market Fee Address
+     * @param {string} publishMarketFeeToken new publish Market Fee Token
+     * @param {string} publishMarketFeeAmount new fee amount
+     * @param {String} address user adress
+     */
+    setPublishingMarketFee<G extends boolean = false>(datatokenAddress: string, publishMarketFeeAddress: string, publishMarketFeeToken: string, publishMarketFeeAmount: string, address: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * @dev getPublishingMarketFee
+     *      Get publishingMarket Fee
+     *      This function allows to get the current fee set by the publishing market
+     * @param {String} datatokenAddress Datatoken adress
+     * @param {String} address user adress
+     * @return {Promise<PublishingMarketFee>} Current fee set by the publishing market
+     */
+    getPublishingMarketFee(datatokenAddress: string, address: string): Promise<PublishingMarketFee>;
+    private getFreOrderParams;
+}

package/dist/src/contracts/Dispenser.d.ts

@@ -0,0 +1,73 @@
+import { AbiItem } from 'web3-utils';
+import { Datatoken } from './Datatoken';
+import { SmartContractWithAddress } from './SmartContractWithAddress';
+import { DispenserToken, ReceiptOrEstimate } from '../@types';
+export declare class Dispenser extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem | AbiItem[];
+    /**
+     * Get information about a datatoken dispenser
+     * @param {String} dtAddress
+     * @return {Promise<FixedPricedExchange>} Exchange details
+     */
+    status(dtAdress: string): Promise<DispenserToken>;
+    /**
+     * Creates a new Dispenser
+     * @param {String} dtAddress Datatoken address
+     * @param {String} address Owner address
+     * @param {String} maxTokens max tokens to dispense
+     * @param {String} maxBalance max balance of requester
+     * @param {String} allowedSwapper  only account that can ask tokens. set address(0) if not required
+     * @return {Promise<ReceiptOrEstimate>} transactionId
+     */
+    create<G extends boolean = false>(dtAddress: string, address: string, maxTokens: string, maxBalance: string, allowedSwapper: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Activates a new dispener.
+     * @param {String} dtAddress refers to datatoken address.
+     * @param {Number} maxTokens max amount of tokens to dispense
+     * @param {Number} maxBalance max balance of user. If user balance is >, then dispense will be rejected
+     * @param {String} address User address (must be owner of the datatoken)
+     * @return {Promise<ReceiptOrEstimate>} TransactionReceipt
+     */
+    activate<G extends boolean = false>(dtAddress: string, maxTokens: string, maxBalance: string, address: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Deactivate an existing dispenser.
+     * @param {String} dtAddress refers to datatoken address.
+     * @param {String} address User address (must be owner of the datatoken)
+     * @return {Promise<ReceiptOrEstimate>} TransactionReceipt
+     */
+    deactivate<G extends boolean = false>(dtAddress: string, address: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Sets a new allowedSwapper.
+     * @param {String} dtAddress refers to datatoken address.
+     * @param {String} address User address (must be owner of the datatoken)
+     * @param {String} newAllowedSwapper refers to the new allowedSwapper
+     * @return {Promise<ReceiptOrEstimate>} TransactionReceipt
+     */
+    setAllowedSwapper<G extends boolean = false>(dtAddress: string, address: string, newAllowedSwapper: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Dispense datatokens to caller.
+     * The dispenser must be active, hold enough DT (or be able to mint more)
+     * and respect maxTokens/maxBalance requirements
+     * @param {String} dtAddress refers to datatoken address.
+     * @param {String} address User address
+     * @param {String} amount amount of datatokens required.
+     * @param {String} destination who will receive the tokens
+     * @return {Promise<ReceiptOrEstimate>} TransactionReceipt
+     */
+    dispense<G extends boolean = false>(dtAddress: string, address: string, amount: string, destination: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Withdraw all tokens from the dispenser
+     * @param {String} dtAddress refers to datatoken address.
+     * @param {String} address User address (must be owner of the dispenser)
+     * @return {Promise<ReceiptOrEstimate>} TransactionReceipt
+     */
+    ownerWithdraw<G extends boolean = false>(dtAddress: string, address: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Check if tokens can be dispensed
+     * @param {String} dtAddress
+     * @param {String} address User address that will receive datatokens
+     * @param {String} amount amount of datatokens required.
+     * @return {Promise<Boolean>}
+     */
+    isDispensable(dtAddress: string, datatoken: Datatoken, address: string, amount?: string): Promise<Boolean>;
+}