@oceanprotocol/lib 1.1.7 → 2.0.0-next.2

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

@@ -0,0 +1,212 @@
+import { AbiItem } from 'web3-utils/types';
+import { PriceAndFees, FeesInfo, FixedPriceExchange, ReceiptOrEstimate } from '../@types';
+import { SmartContractWithAddress } from './SmartContractWithAddress';
+export declare class FixedRateExchange extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem | AbiItem[];
+    /**
+     * Creates unique exchange identifier.
+     * @param {String} baseToken baseToken contract address
+     * @param {String} datatoken Datatoken contract address
+     * @return {Promise<string>} exchangeId
+     */
+    generateExchangeId(baseToken: string, datatoken: string): Promise<string>;
+    /**
+     * Atomic swap
+     * @param {String} exchangeId ExchangeId
+     * @param {String} datatokenAmount Amount of datatokens
+     * @param {String} maxBaseTokenAmount max amount of baseToken we want to pay for datatokenAmount
+     * @param {String} address User address
+     * @param {String} consumeMarketAddress consumeMarketAddress
+     * @param {String} consumeMarketFee consumeMarketFee in fraction
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    buyDatatokens<G extends boolean = false>(address: string, exchangeId: string, datatokenAmount: string, maxBaseTokenAmount: string, consumeMarketAddress?: string, consumeMarketFee?: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Sell datatokenAmount while expecting at least minBaseTokenAmount
+     * @param {String} exchangeId ExchangeId
+     * @param {String} datatokenAmount Amount of datatokens
+     * @param {String} minBaseTokenAmount min amount of baseToken we want to receive back
+     * @param {String} address User address
+     * @param {String} consumeMarketAddress consumeMarketAddress
+     * @param {String} consumeMarketFee consumeMarketFee in fraction
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    sellDatatokens<G extends boolean = false>(address: string, exchangeId: string, datatokenAmount: string, minBaseTokenAmount: string, consumeMarketAddress?: string, consumeMarketFee?: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Gets total number of exchanges
+     * @param {String} exchangeId ExchangeId
+     * @param {Number} datatokenAmount Amount of datatokens
+     * @return {Promise<Number>} no of available exchanges
+     */
+    getNumberOfExchanges(): Promise<number>;
+    /**
+     * Set new rate
+     * @param {String} exchangeId ExchangeId
+     * @param {String} newRate New rate
+     * @param {String} address User account
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    setRate<G extends boolean = false>(address: string, exchangeId: string, newRate: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Sets a new allowedSwapper
+     * @param {String} exchangeId ExchangeId
+     * @param {String} newAllowedSwapper newAllowedSwapper (set address zero if we want to remove allowed swapper)
+     * @param {String} address User account
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    setAllowedSwapper<G extends boolean = false>(address: string, exchangeId: string, newAllowedSwapper: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Activate an exchange
+     * @param {String} exchangeId ExchangeId
+     * @param {String} address User address
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    activate<G extends boolean = false>(address: string, exchangeId: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Deactivate an exchange
+     * @param {String} exchangeId ExchangeId
+     * @param {String} address User address
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    deactivate<G extends boolean = false>(address: string, exchangeId: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Get Rate
+     * @param {String} exchangeId ExchangeId
+     * @return {Promise<string>} Rate (converted from wei)
+     */
+    getRate(exchangeId: string): Promise<string>;
+    /**
+     * Get Datatoken Supply in the exchange
+     * @param {String} exchangeId ExchangeId
+     * @return {Promise<string>}  dt supply formatted
+     */
+    getDatatokenSupply(exchangeId: string): Promise<string>;
+    /**
+     * Get BaseToken Supply in the exchange
+     * @param {String} exchangeId ExchangeId
+     * @return {Promise<string>} dt supply formatted
+     */
+    getBasetokenSupply(exchangeId: string): Promise<string>;
+    /**
+     * Get Allower Swapper (if set this is the only account which can use this exchange, else is set at address(0))
+     * @param {String} exchangeId ExchangeId
+     * @return {Promise<string>} address of allowedSwapper
+     */
+    getAllowedSwapper(exchangeId: string): Promise<string>;
+    /**
+     * calcBaseInGivenDatatokensOut - Calculates how many base tokens are needed to get specified amount of datatokens
+     * @param {String} exchangeId ExchangeId
+     * @param {string} datatokenAmount Amount of datatokens user wants to buy
+     * @param {String} consumeMarketFee consumeMarketFee in fraction
+     * @return {Promise<PriceAndFees>} how many base tokens are needed and fees
+     */
+    calcBaseInGivenDatatokensOut(exchangeId: string, datatokenAmount: string, consumeMarketFee?: string): Promise<PriceAndFees>;
+    /**
+     * getBTOut - returns amount in baseToken that user will receive for datatokenAmount sold
+     * @param {String} exchangeId ExchangeId
+     * @param {Number} datatokenAmount Amount of datatokens
+     * @param {String} consumeMarketFee consumeMarketFee in fraction
+     * @return {Promise<string>} Amount of baseTokens user will receive
+     */
+    getAmountBasetokensOut(exchangeId: string, datatokenAmount: string, consumeMarketFee?: string): Promise<string>;
+    /**
+     * Get exchange details
+     * @param {String} exchangeId ExchangeId
+     * @return {Promise<FixedPricedExchange>} Exchange details
+     */
+    getExchange(exchangeId: string): Promise<FixedPriceExchange>;
+    /**
+     * Get fee details for an exchange
+     * @param {String} exchangeId ExchangeId
+     * @return {Promise<FixedPricedExchange>} Exchange details
+     */
+    getFeesInfo(exchangeId: string): Promise<FeesInfo>;
+    /**
+     * Get all exchanges
+     * @param {String} exchangeId ExchangeId
+     * @return {Promise<String[]>} Exchanges list
+     */
+    getExchanges(): Promise<string[]>;
+    /**
+     * Check if an exchange is active
+     * @param {String} exchangeId ExchangeId
+     * @return {Promise<Boolean>} Result
+     */
+    isActive(exchangeId: string): Promise<boolean>;
+    /**
+     * Activate minting option for fixed rate contract
+     * @param {String} exchangeId ExchangeId
+     * @param {String} address User address
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    activateMint<G extends boolean = false>(address: string, exchangeId: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Deactivate minting for fixed rate
+     * @param {String} exchangeId ExchangeId
+     * @param {String} address User address
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    deactivateMint<G extends boolean = false>(address: string, exchangeId: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Collect BaseTokens in the contract (anyone can call this, funds are sent to Datatoken.paymentCollector)
+     * @param {String} address User address
+     * @param {String} exchangeId ExchangeId
+     * @param {String} amount amount to be collected
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    collectBasetokens<G extends boolean = false>(address: string, exchangeId: string, amount: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Collect datatokens in the contract (anyone can call this, funds are sent to Datatoken.paymentCollector)
+     * @param {String} address User address
+     * @param {String} exchangeId ExchangeId
+     * @param {String} amount amount to be collected
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    collectDatatokens<G extends boolean = false>(address: string, exchangeId: string, amount: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Collect market fee and send it to marketFeeCollector (anyone can call it)
+     * @param {String} exchangeId ExchangeId
+     * @param {String} address User address
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    collectMarketFee<G extends boolean = false>(address: string, exchangeId: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Collect ocean fee and send it to OPF collector (anyone can call it)
+     * @param {String} exchangeId ExchangeId
+     * @param {String} address User address
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    collectOceanFee<G extends boolean = false>(address: string, exchangeId: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Get OPF Collector of fixed rate contract
+     * @return {String}
+     */
+    getOPCCollector(): Promise<string>;
+    /**
+     * Get Router address set in fixed rate contract
+     * @return {String}
+     */
+    getRouter(): Promise<string>;
+    /**
+     * Get Exchange Owner given an exchangeId
+     * @param {String} exchangeId ExchangeId
+     * @return {String} return exchange owner
+     */
+    getExchangeOwner(exchangeId: string): Promise<string>;
+    /**
+     * Set new market fee, only market fee collector can update it
+     * @param {String} address user address
+     * @param {String} exchangeId ExchangeId
+     * @param {String} newMarketFee New market fee
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    updateMarketFee<G extends boolean = false>(address: string, exchangeId: string, newMarketFee: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Set new market fee collector, only market fee collector can update it
+     * @param {String} address user address
+     * @param {String} exchangeId ExchangeId
+     * @param {String} newMarketFeeCollector New market fee collector
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    updateMarketFeeCollector<G extends boolean = false>(address: string, exchangeId: string, newMarketFeeCollector: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+}

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

@@ -0,0 +1,197 @@
+import { AbiItem } from 'web3-utils';
+import { TransactionReceipt } from 'web3-eth';
+import { MetadataProof, MetadataAndTokenURI, NftRoles, ReceiptOrEstimate } from '../@types';
+import { SmartContract } from './SmartContract';
+export declare class Nft extends SmartContract {
+    getDefaultAbi(): AbiItem | AbiItem[];
+    /**
+     * Create new ERC20 Datatoken - only user with DatatokenDeployer permission can succeed
+     * @param {String} nftAddress NFT address
+     * @param {String} address User address
+     * @param {String} minter User set as initial minter for the Datatoken
+     * @param {String} paymentCollector initial paymentCollector 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
+     */
+    createDatatoken<G extends boolean = false>(nftAddress: string, address: string, minter: string, paymentCollector: string, mpFeeAddress: string, feeToken: string, feeAmount: string, cap: string, name?: string, symbol?: string, templateIndex?: number, estimateGas?: G): Promise<G extends false ? string : number>;
+    /**
+     * Add Manager for NFT Contract (only NFT Owner can succeed)
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address NFT Owner adress
+     * @param {String} manager User adress which is going to be assing manager
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    addManager<G extends boolean = false>(nftAddress: string, address: string, manager: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Removes a specific manager for NFT Contract (only NFT Owner can succeed)
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address NFT Owner adress
+     * @param {String} manager User adress which is going to be removed as manager
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    removeManager<G extends boolean = false>(nftAddress: string, address: string, manager: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Add DatatokenDeployer permission - only Manager can succeed
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address NFT Manager adress
+     * @param {String} datatokenDeployer User adress which is going to have DatatokenDeployer permission
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    addDatatokenDeployer<G extends boolean = false>(nftAddress: string, address: string, datatokenDeployer: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Remove DatatokenDeployer permission - only Manager can succeed
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address NFT Manager adress
+     * @param {String} datatokenDeployer Address of the user to be revoked DatatokenDeployer Permission
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    removeDatatokenDeployer<G extends boolean = false>(nftAddress: string, address: string, datatokenDeployer: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Add Metadata Updater permission - only Manager can succeed
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address NFT Manager adress
+     * @param {String} metadataUpdater User adress which is going to have Metadata Updater permission
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    addMetadataUpdater<G extends boolean = false>(nftAddress: string, address: string, metadataUpdater: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Remove Metadata Updater permission - only Manager can succeed
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address NFT Manager adress
+     * @param {String} metadataUpdater Address of the user to be revoked Metadata updater Permission
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    removeMetadataUpdater<G extends boolean = false>(nftAddress: string, address: string, metadataUpdater: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Add Store Updater permission - only Manager can succeed
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address NFT Manager adress
+     * @param {String} storeUpdater User adress which is going to have Store Updater permission
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    addStoreUpdater<G extends boolean = false>(nftAddress: string, address: string, storeUpdater: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Remove Store Updater permission - only Manager can succeed
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address NFT Manager adress
+     * @param {String} storeUpdater Address of the user to be revoked Store Updater Permission
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    removeStoreUpdater<G extends boolean = false>(nftAddress: string, address: string, storeUpdater: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * This function allows to remove all ROLES at NFT level: Managers, DatatokenDeployer, MetadataUpdater, StoreUpdater
+     * Even NFT Owner has to readd himself as Manager
+     * Permissions at Datatoken level stay.
+     * Only NFT Owner  can call it.
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address NFT Owner adress
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    cleanPermissions<G extends boolean = false>(nftAddress: string, address: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Transfers the NFT
+     * will clean all permissions both on NFT and Datatoken level.
+     * @param {String} nftAddress NFT contract address
+     * @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<ReceiptOrEstimate>} trxReceipt
+     */
+    transferNft<G extends boolean = false>(nftAddress: string, nftOwner: string, nftReceiver: string, tokenId?: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * safeTransferNFT Used for transferring the NFT, can be used by an approved relayer
+     * will clean all permissions both on NFT and Datatoken level.
+     * @param {String} nftAddress NFT contract address
+     * @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<ReceiptOrEstimate>} trxReceipt
+     */
+    safeTransferNft<G extends boolean = false>(nftAddress: string, nftOwner: string, nftReceiver: string, tokenId?: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Creates or update Metadata cached by Aquarius. Also, updates the METADATA_DECRYPTOR key
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address Caller address NFT Owner adress
+     * @param {String} address Caller address NFT Owner adress
+     * @param {String} address Caller address NFT Owner adress
+     * @param {String} address Caller address NFT Owner adress
+     * @param {String} address Caller address NFT Owner adress
+     * @param {String} address Caller address NFT Owner adress
+     * @param {String} address Caller address NFT Owner adress
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    setMetadata<G extends boolean = false>(nftAddress: string, address: string, metadataState: number, metadataDecryptorUrl: string, metadataDecryptorAddress: string, flags: string, data: string, metadataHash: string, metadataProofs?: MetadataProof[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     *  Helper function to improve UX sets both MetaData & TokenURI in one tx
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address Caller address
+     * @param {MetadataAndTokenURI} metadataAndTokenURI metaDataAndTokenURI object
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    setMetadataAndTokenURI<G extends boolean = false>(nftAddress: string, metadataUpdater: string, metadataAndTokenURI: MetadataAndTokenURI, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * setMetadataState Used for updating the metadata State
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address Caller address => metadata updater
+     * @param {Number} metadataState new metadata state
+     * @return {Promise<ReceiptOrEstimate>} trxReceipt
+     */
+    setMetadataState<G extends boolean = false>(nftAddress: string, address: string, metadataState: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** set TokenURI on an nft
+     * @param nftAddress NFT contract address
+     * @param address user adress
+     * @param data input data for TokenURI
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    setTokenURI<G extends boolean = false>(nftAddress: string, address: string, data: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** Get Owner
+     * @param {String} nftAddress NFT contract address
+     * @return {Promise<string>} string
+     */
+    getNftOwner(nftAddress: string): Promise<string>;
+    /** Get users NFT Permissions
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address user adress
+     * @return {Promise<NftRoles>}
+     */
+    getNftPermissions(nftAddress: string, address: string): Promise<NftRoles>;
+    /** Get users Metadata, return Metadata details
+     * @param {String} nftAddress NFT contract address
+     * @return {Promise<Objecta>}
+     */
+    getMetadata(nftAddress: string): Promise<Object>;
+    /** Get users DatatokenDeployer role
+     * @param {String} nftAddress NFT contract address
+     * @param {String} address user adress
+     * @return {Promise<boolean>}
+     */
+    isDatatokenDeployer(nftAddress: string, address: string): Promise<boolean>;
+    /** setData
+     * This function allows to store data with a preset key (keccak256(ERC20Address)) into NFT 725 Store
+     * only ERC20Deployer can succeed
+     * @param nftAddress erc721 contract adress
+     * @param address user adress
+     * @param key Key of the data to be stored into 725Y standard
+     * @param value Data to be stored into 725Y standard
+     * @return {Promise<ReceiptOrEstimate>} transactionId
+     */
+    setData(nftAddress: string, address: string, key: string, value: string): Promise<TransactionReceipt>;
+    /** Gets data at a given `key`
+     * @param {String} nftAddress NFT contract address
+     * @param {String} key the key which value to retrieve
+     * @return {Promise<string>} The data stored at the key
+     */
+    getData(nftAddress: string, key: string): Promise<string>;
+    /** Gets data at a given `key`
+     * @param {String} nftAddress NFT contract address
+     * @param {String} id
+     * @return {Promise<string>} The data stored at the key
+     */
+    getTokenURI(nftAddress: string, id: number): Promise<string>;
+}

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

@@ -0,0 +1,144 @@
+import { AbiItem } from 'web3-utils';
+import { FreCreationParams, DatatokenCreateParams, DispenserCreationParams, NftCreateData, Template, TokenOrder, ReceiptOrEstimate } from '../@types';
+import { SmartContractWithAddress } from './SmartContractWithAddress';
+/**
+ * Provides an interface for NFT Factory contract
+ */
+export declare class NftFactory extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem | AbiItem[];
+    /**
+     * Create new NFT
+     * @param {String} address
+     * @param {NFTCreateData} nftData
+     * @return {Promise<string>} NFT datatoken address
+     */
+    createNFT<G extends boolean = false>(address: string, nftData: NftCreateData, estimateGas?: G): Promise<G extends false ? string : number>;
+    /** Get Current NFT Count (NFT created)
+     * @return {Promise<number>} Number of NFT created from this factory
+     */
+    getCurrentNFTCount(): Promise<number>;
+    /** Get Current Datatoken Count
+     * @return {Promise<number>} Number of DTs created from this factory
+     */
+    getCurrentTokenCount(): Promise<number>;
+    /** Get Factory Owner
+     * @return {Promise<string>} Factory Owner address
+     */
+    getOwner(): Promise<string>;
+    /** Get Current NFT Template Count
+     * @return {Promise<number>} Number of NFT Template added to this factory
+     */
+    getCurrentNFTTemplateCount(): Promise<number>;
+    /** Get Current Template  Datatoken (ERC20) Count
+     * @return {Promise<number>} Number of Datatoken Template added to this factory
+     */
+    getCurrentTokenTemplateCount(): Promise<number>;
+    /** Get NFT Template
+     * @param {Number} index Template index
+     * @return {Promise<Template>} Number of Template added to this factory
+     */
+    getNFTTemplate(index: number): Promise<Template>;
+    /** Get Datatoken (ERC20) Template
+     * @param {Number} index Template index
+     * @return {Promise<Template>} DT Template info
+     */
+    getTokenTemplate(index: number): Promise<Template>;
+    /** Check if Datatoken is deployed from the factory
+     * @param {String} datatoken Datatoken address we want to check
+     * @return {Promise<Boolean>} return true if deployed from this factory
+     */
+    checkDatatoken(datatoken: string): Promise<Boolean>;
+    /** 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
+     */
+    checkNFT(nftAddress: string): Promise<String>;
+    /**
+     * Add a new NFT token template - only factory Owner
+     * @param {String} address
+     * @param {String} templateAddress template address to add
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    addNFTTemplate<G extends boolean = false>(address: string, templateAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Disable token template - only factory Owner
+     * @param {String} address
+     * @param {Number} templateIndex index of the template we want to disable
+     * @return {Promise<ReceiptOrEstimate>} current token template count
+     */
+    disableNFTTemplate<G extends boolean = false>(address: string, templateIndex: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * 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<ReceiptOrEstimate>} current token template count
+     */
+    reactivateNFTTemplate<G extends boolean = false>(address: string, templateIndex: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Add a new NFT token template - only factory Owner
+     * @param {String} address
+     * @param {String} templateAddress template address to add
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    addTokenTemplate<G extends boolean = false>(address: string, templateAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Disable token template - only factory Owner
+     * @param {String} address
+     * @param {Number} templateIndex index of the template we want to disable
+     * @return {Promise<ReceiptOrEstimate>} current token template count
+     */
+    disableTokenTemplate<G extends boolean = false>(address: string, templateIndex: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * 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<ReceiptOrEstimate>} current token template count
+     */
+    reactivateTokenTemplate<G extends boolean = false>(address: string, templateIndex: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * @dev startMultipleTokenOrder
+     *      Used as a proxy to order multiple services
+     *      Users can have inifinite approvals for fees for factory instead of having one approval/ Datatoken contract
+     *      Requires previous approval of all :
+     *          - consumeFeeTokens
+     *          - publishMarketFeeTokens
+     *          - ERC20 Datatokens
+     * @param address Caller address
+     * @param orders an array of struct tokenOrder
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    startMultipleTokenOrder<G extends boolean = false>(address: string, orders: TokenOrder[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * @dev createNftWithDatatoken
+     *      Creates a new NFT, then a Datatoken,all in one call
+     * @param address Caller address
+     * @param _NftCreateData input data for nft creation
+     * @param _ErcCreateData input data for Datatoken creation
+     * @return {Promise<ReceiptOrEstimate>} transaction receipt
+     */
+    createNftWithDatatoken<G extends boolean = false>(address: string, nftCreateData: NftCreateData, dtParams: DatatokenCreateParams, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * @dev createNftWithDatatokenWithFixedRate
+     *      Creates a new NFT, then a Datatoken, 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 dtParams input data for Datatoken Creation
+     * @param freParams input data for FixedRate Creation
+     *  @return {Promise<TransactionReceipt>} transaction receipt
+     */
+    createNftWithDatatokenWithFixedRate<G extends boolean = false>(address: string, nftCreateData: NftCreateData, dtParams: DatatokenCreateParams, freParams: FreCreationParams, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * @dev createNftWithDatatokenWithDispenser
+     *      Creates a new NFT, then a Datatoken, 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 dtParams input data for Datatoken Creation
+     * @param dispenserParams input data for Dispenser Creation
+     *  @return {Promise<TransactionReceipt>} transaction receipt
+     */
+    createNftWithDatatokenWithDispenser<G extends boolean = false>(address: string, nftCreateData: NftCreateData, dtParams: DatatokenCreateParams, dispenserParams: DispenserCreationParams, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    private getErcCreationParams;
+    private getFreCreationParams;
+}

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

@@ -0,0 +1,92 @@
+import { AbiItem } from 'web3-utils';
+import { Operation, ReceiptOrEstimate } from '../@types';
+import { SmartContractWithAddress } from './SmartContractWithAddress';
+/**
+ * Provides an interface for FactoryRouter contract
+ */
+export declare class Router extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem | AbiItem[];
+    /**
+     * buyDatatokenBatch
+     * @param {String} address
+     * @param {Operation} operations Operations objects array
+     * @return {Promise<ReceiptOrEstimate>} Transaction receipt
+     */
+    buyDatatokenBatch<G extends boolean = false>(address: string, operations: Operation[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** Check if a token is on approved tokens list, if true opfFee is lower in pools with that token/DT
+     * @return {Promise<boolean>} true if is on the list.
+     */
+    isApprovedToken(address: string): Promise<boolean>;
+    /** Check if an address is a Fixed Rate contract.
+     * @return {Promise<boolean>} true if is a Fixed Rate contract
+     */
+    isFixedPrice(address: string): Promise<boolean>;
+    /** Get Router Owner
+     * @return {Promise<string>} Router Owner address
+     */
+    getOwner(): Promise<string>;
+    /** Get NFT Factory address
+     * @return {Promise<string>} NFT Factory address
+     */
+    getNFTFactory(): Promise<string>;
+    /**
+     * Adds a token to the list of tokens with reduced fees
+     * @param {String} address caller address
+     * @param {String} tokenAddress token address to add
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    addApprovedToken<G extends boolean = false>(address: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Removes a token if exists from the list of tokens with reduced fees
+     * @param {String} address
+     * @param {String} tokenAddress address to remove
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    removeApprovedToken<G extends boolean = false>(address: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Adds an address to the list of fixed rate contracts
+     * @param {String} address
+     * @param {String} tokenAddress contract address to add
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    addFixedRateContract<G extends boolean = false>(address: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Removes an address from the list of fixed rate contracts
+     * @param {String} address
+     * @param {String} tokenAddress contract address to add
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    removeFixedRateContract<G extends boolean = false>(address: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Adds an address to the list of dispensers
+     * @param {String} address
+     * @param {String} tokenAddress contract address to add
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    addDispenserContract<G extends boolean = false>(address: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Removes an address from the list of dispensers
+     * @param {String} address
+     * @param {String} tokenAddress address Contract to be removed
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    removeDispenserContract<G extends boolean = false>(address: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** Get OPF Fee per token
+     * @return {Promise<number>} OPC fee for a specific baseToken
+     */
+    getOPCFee(baseToken: string): Promise<number>;
+    /** Get Current OPF Fee
+     * @return {Promise<number>} OPF fee
+     */
+    getCurrentOPCFee(): Promise<number>;
+    /**
+     * Updates OP Community Fees
+     * @param {String} address
+     * @param {number} newSwapOceanFee Amount charged for swapping with ocean approved tokens
+     * @param {number} newSwapNonOceanFee Amount charged for swapping with non ocean approved tokens
+     * @param {number} newConsumeFee Amount charged from consumeFees
+     * @param {number} newProviderFee Amount charged for providerFees
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    updateOPCFee<G extends boolean = false>(address: string, newSwapOceanFee: number, newSwapNonOceanFee: number, newConsumeFee: number, newProviderFee: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+}

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

@@ -0,0 +1,22 @@
+import Web3 from 'web3';
+import { Contract } from 'web3-eth-contract';
+import { AbiItem } from 'web3-utils';
+import { Config } from '../config';
+export declare abstract class SmartContract {
+    web3: Web3;
+    config: Config;
+    abi: AbiItem | AbiItem[];
+    abstract getDefaultAbi(): AbiItem | AbiItem[];
+    /**
+     * Instantiate the smart contract.
+     * @param {Web3} web3
+     * @param {string | number} network Network id or name
+     * @param {Config} config Configutation of the smart contract
+     * @param {AbiItem | AbiItem[]} abi ABI of the smart contract
+     */
+    constructor(web3: Web3, network?: string | number, config?: Config, abi?: AbiItem | AbiItem[]);
+    protected amountToUnits(token: string, amount: string, tokenDecimals?: number): Promise<string>;
+    protected unitsToAmount(token: string, amount: string, tokenDecimals?: number): Promise<string>;
+    protected getFairGasPrice(): Promise<string>;
+    protected getContract(address: string, account?: string, abi?: AbiItem | AbiItem[]): Contract;
+}