@oceanprotocol/lib 1.0.0-next.5 → 1.0.0-next.9

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

@@ -0,0 +1,4 @@
+export interface DownloadResponse {
+    data: ArrayBuffer;
+    filename: string;
+}

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

@@ -5,4 +5,5 @@ export interface FileMetadata {
     index?: number;
     url?: string;
     method?: string;
+    valid?: boolean;
 }

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

@@ -2,13 +2,14 @@ export interface ProviderFees {
     providerFeeAddress: string;
     providerFeeToken: string;
     providerFeeAmount: string;
-    providerData: string;
     v: string;
     r: string;
     s: string;
+    providerData: string;
+    validUntil: string;
 }
 export interface ProviderInitialize {
-    dataToken: string;
+    datatoken: string;
     nonce: string;
     computeAddress: string;
     providerFee: ProviderFees;

package/dist/src/aquarius/Aquarius.d.ts

@@ -2,9 +2,9 @@ import { Asset, DDO, ValidateMetadata } from '../@types/';
 export declare class Aquarius {
     aquariusURL: any;
     constructor(aquariusURL: string);
-    resolve(did: string, fetchMethod: any): Promise<DDO>;
+    resolve(did: string, signal?: AbortSignal): Promise<Asset>;
     sleep(ms: number): Promise<unknown>;
-    waitForAqua(fetchMethod: any, did: string, txid?: string): Promise<Asset>;
-    validate(fetchMethod: any, ddo: DDO): Promise<ValidateMetadata>;
+    waitForAqua(did: string, txid?: string, signal?: AbortSignal): Promise<Asset>;
+    validate(ddo: DDO, signal?: AbortSignal): Promise<ValidateMetadata>;
 }
 export default Aquarius;

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

@@ -3,6 +3,8 @@ import Web3 from 'web3';
 import { TransactionReceipt } from 'web3-core';
 import { AbiItem } from 'web3-utils';
 import { FreCreationParams, Erc20CreateParams, PoolCreationParams, DispenserCreationParams } from '../interfaces';
+import { Config } from '../models/index.js';
+import { ProviderFees } from '../@types/index.js';
 interface Template {
     templateAddress: string;
     isActive: boolean;
@@ -10,14 +12,9 @@ interface Template {
 export interface TokenOrder {
     tokenAddress: string;
     consumer: string;
+    ammount: string;
     serviceIndex: number;
-    providerFeeAddress: string;
-    providerFeeToken: string;
-    providerFeeAmount: string;
-    v: string;
-    r: string;
-    s: string;
-    providerData: string;
+    _providerFees: ProviderFees;
 }
 export interface NftCreateData {
     name: string;
@@ -30,9 +27,9 @@ export declare class NftFactory {
     factory721Address: string;
     factory721Abi: AbiItem | AbiItem[];
     web3: Web3;
-    startBlock: number;
+    config: Config;
     factory721: Contract;
-    constructor(factory721Address: string, web3: Web3, factory721Abi?: AbiItem | AbiItem[], startBlock?: number);
+    constructor(factory721Address: string, web3: Web3, factory721Abi?: AbiItem | AbiItem[], config?: Config);
     estGasCreateNFT(address: string, nftData: NftCreateData): Promise<string>;
     createNFT(address: string, nftData: NftCreateData): Promise<string>;
     getCurrentNFTCount(): Promise<number>;

package/dist/src/interfaces/Erc721Interface.d.ts

@@ -0,0 +1,12 @@
+import { MetadataProof } from '../@types';
+export interface MetadataAndTokenURI {
+    metaDataState: number;
+    metaDataDecryptorUrl: string;
+    metaDataDecryptorAddress: string;
+    flags: string;
+    data: string;
+    metaDataHash: string;
+    tokenId: number;
+    tokenURI: string;
+    metadataProofs: MetadataProof[];
+}

package/dist/src/interfaces/FixedRateInterface.d.ts

@@ -4,7 +4,7 @@ export interface FreCreationParams {
     owner: string;
     marketFeeCollector: string;
     baseTokenDecimals: number;
-    dataTokenDecimals: number;
+    datatokenDecimals: number;
     fixedRate: string;
     marketFee: number;
     withMint?: boolean;

package/dist/src/interfaces/PoolInterface.d.ts

@@ -1,15 +1,15 @@
 export interface PoolCreationParams {
     ssContract: string;
-    basetokenAddress: string;
-    basetokenSender: string;
+    baseTokenAddress: string;
+    baseTokenSender: string;
     publisherAddress: string;
     marketFeeCollector: string;
     poolTemplateAddress: string;
     rate: string;
-    basetokenDecimals: number;
+    baseTokenDecimals: number;
     vestingAmount: string;
     vestedBlocks: number;
-    initialBasetokenLiquidity: string;
+    initialBaseTokenLiquidity: string;
     swapFeeLiquidityProvider: number;
     swapFeeMarketRunner: number;
 }

package/dist/src/models/Config.d.ts

@@ -30,5 +30,9 @@ export declare class Config {
     subgraphUri: string;
     explorerUri: string;
     oceanTokenSymbol: string;
+    transactionBlockTimeout: number;
+    transactionConfirmationBlocks: number;
+    transactionPollingTimeout: number;
+    gasFeeMultiplier: number;
 }
 export default Config;

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

@@ -3,14 +3,15 @@ import Web3 from 'web3';
 import { TransactionReceipt } from 'web3-core';
 import { AbiItem } from 'web3-utils';
 import { Operation } from '../interfaces/RouterInterface';
+import { Config } from '../models/index.js';
 export declare class Router {
     GASLIMIT_DEFAULT: number;
     routerAddress: string;
     RouterAbi: AbiItem | AbiItem[];
     web3: Web3;
-    startBlock: number;
+    config: Config;
     router: Contract;
-    constructor(routerAddress: string, web3: Web3, RouterAbi?: AbiItem | AbiItem[], startBlock?: number);
+    constructor(routerAddress: string, web3: Web3, RouterAbi?: AbiItem | AbiItem[], config?: Config);
     estGasBuyDTBatch(address: string, operations: Operation[]): Promise<any>;
     buyDTBatch(address: string, operations: Operation[]): Promise<TransactionReceipt>;
     isOceanTokens(address: string): Promise<boolean>;
@@ -35,10 +36,10 @@ export declare class Router {
     addDispenserContract(address: string, tokenAddress: string): Promise<TransactionReceipt>;
     estGasRemoveDispenserContract(address: string, tokenAddress: string): Promise<any>;
     removeDispenserContract(address: string, tokenAddress: string): Promise<TransactionReceipt>;
-    getOPFFee(baseToken: string): Promise<number>;
-    getCurrentOPFFee(): Promise<number>;
-    estGasUpdateOPFFee(address: string, newFee: number): Promise<any>;
-    updateOPFFee(address: string, newFee: number): Promise<TransactionReceipt>;
+    getOPCFee(baseToken: string): Promise<number>;
+    getCurrentOPCFee(): Promise<number>;
+    estGasUpdateOPCFee(address: string, newSwapOceanFee: number, newSwapNonOceanFee: number, newConsumeFee: number, newProviderFee: number): Promise<any>;
+    updateOPCFee(address: string, newSwapOceanFee: number, newSwapNonOceanFee: number, newConsumeFee: number, newProviderFee: number): Promise<TransactionReceipt>;
     estGasAddPoolTemplate(address: string, templateAddress: string): Promise<any>;
     addPoolTemplate(address: string, templateAddress: string): Promise<TransactionReceipt>;
     estGasRemovePoolTemplate(address: string, templateAddress: string): Promise<any>;

package/dist/src/pools/balancer/Pool.d.ts

@@ -4,15 +4,14 @@ import { TransactionReceipt } from 'web3-core';
 import { Contract } from 'web3-eth-contract';
 import { Logger } from '../../utils';
 import { CurrentFees, TokenInOutMarket, AmountsInMaxFee, AmountsOutMaxFee } from '../../interfaces';
+import { Config } from '../../models';
 export declare class Pool {
     poolAbi: AbiItem | AbiItem[];
     web3: Web3;
     GASLIMIT_DEFAULT: number;
     private logger;
-    constructor(web3: Web3, logger: Logger, poolAbi?: AbiItem | AbiItem[]);
-    estApprove(account: string, tokenAddress: string, spender: string, amount: string, contractInstance?: Contract): Promise<number>;
-    allowance(tokenAddress: string, owner: string, spender: string): Promise<string>;
-    approve(account: string, tokenAddress: string, spender: string, amount: string, force?: boolean): Promise<TransactionReceipt | string>;
+    private config;
+    constructor(web3: Web3, logger: Logger, poolAbi?: AbiItem | AbiItem[], config?: Config);
     sharesBalance(account: string, poolAddress: string): Promise<string>;
     estSetSwapFee(account: string, poolAddress: string, fee: string, contractInstance?: Contract): Promise<number>;
     setSwapFee(account: string, poolAddress: string, fee: string): Promise<TransactionReceipt>;
@@ -21,10 +20,10 @@ export declare class Pool {
     getCurrentTokens(poolAddress: string): Promise<string[]>;
     getFinalTokens(poolAddress: string): Promise<string[]>;
     getController(poolAddress: string): Promise<string>;
-    getBasetoken(poolAddress: string): Promise<string>;
+    getBaseToken(poolAddress: string): Promise<string>;
     getDatatoken(poolAddress: string): Promise<string>;
     getMarketFeeCollector(poolAddress: string): Promise<string>;
-    getOPFCollector(poolAddress: string): Promise<string>;
+    getOPCCollector(poolAddress: string): Promise<string>;
     isBound(poolAddress: string, token: string): Promise<boolean>;
     getReserve(poolAddress: string, token: string): Promise<string>;
     isFinalized(poolAddress: string): Promise<boolean>;
@@ -34,16 +33,14 @@ export declare class Pool {
     getTotalDenormalizedWeight(poolAddress: string): Promise<string>;
     getMarketFees(poolAddress: string, token: string): Promise<string>;
     getCurrentMarketFees(poolAddress: string): Promise<CurrentFees>;
-    getCurrentOPFFees(poolAddress: string): Promise<CurrentFees>;
+    getCurrentOPCFees(poolAddress: string): Promise<CurrentFees>;
     getCommunityFees(poolAddress: string, token: string): Promise<string>;
-    estCollectOPF(address: string, poolAddress: string, contractInstance?: Contract): Promise<number>;
-    collectOPF(address: string, poolAddress: string): Promise<TransactionReceipt>;
+    estCollectOPC(address: string, poolAddress: string, contractInstance?: Contract): Promise<number>;
+    collectOPC(address: string, poolAddress: string): Promise<TransactionReceipt>;
     estCollectMarketFee(address: string, poolAddress: string, contractInstance?: Contract): Promise<number>;
     collectMarketFee(address: string, poolAddress: string): Promise<TransactionReceipt>;
     estUpdateMarketFeeCollector(address: string, poolAddress: string, newCollector: string, contractInstance?: Contract): Promise<number>;
     updateMarketFeeCollector(address: string, poolAddress: string, newCollector: string): Promise<TransactionReceipt>;
-    amountToUnits(token: string, amount: string): Promise<string>;
-    unitsToAmount(token: string, amount: string): Promise<string>;
     estSwapExactAmountIn(address: string, poolAddress: string, tokenInOutMarket: TokenInOutMarket, amountsInOutMaxFee: AmountsInMaxFee, contractInstance?: Contract): Promise<number>;
     swapExactAmountIn(address: string, poolAddress: string, tokenInOutMarket: TokenInOutMarket, amountsInOutMaxFee: AmountsInMaxFee): Promise<TransactionReceipt>;
     estSwapExactAmountOut(address: string, poolAddress: string, tokenInOutMarket: TokenInOutMarket, amountsInOutMaxFee: AmountsOutMaxFee, contractInstance?: Contract): Promise<number>;

package/dist/src/pools/dispenser/Dispenser.d.ts

@@ -3,6 +3,7 @@ import { AbiItem } from 'web3-utils';
 import { Contract } from 'web3-eth-contract';
 import { TransactionReceipt } from 'web3-eth';
 import { Datatoken } from '../../tokens';
+import { Config } from '../../models/index.js';
 export interface DispenserToken {
     active: boolean;
     owner: string;
@@ -16,10 +17,10 @@ export declare class Dispenser {
     GASLIMIT_DEFAULT: number;
     web3: Web3;
     dispenserAddress: string;
-    startBlock: number;
+    config: Config;
     dispenserAbi: AbiItem | AbiItem[];
     dispenserContract: Contract;
-    constructor(web3: Web3, dispenserAddress?: string, dispenserAbi?: AbiItem | AbiItem[], startBlock?: number);
+    constructor(web3: Web3, dispenserAddress?: string, dispenserAbi?: AbiItem | AbiItem[], config?: Config);
     status(dtAdress: string): Promise<DispenserToken>;
     estGasCreate(dtAddress: string, address: string, maxTokens: string, maxBalance: string, allowedSwapper: string): Promise<any>;
     create(dtAddress: string, address: string, maxTokens: string, maxBalance: string, allowedSwapper: string): Promise<TransactionReceipt>;
@@ -33,5 +34,5 @@ export declare class Dispenser {
     dispense(dtAddress: string, address: string, amount: string, destination: string): Promise<TransactionReceipt>;
     estGasOwnerWithdraw(dtAddress: string, address: string): Promise<any>;
     ownerWithdraw(dtAddress: string, address: string): Promise<TransactionReceipt>;
-    isDispensable(dtAddress: string, dataToken: Datatoken, address: string, amount?: string): Promise<Boolean>;
+    isDispensable(dtAddress: string, datatoken: Datatoken, address: string, amount?: string): Promise<Boolean>;
 }

package/dist/src/pools/fixedRate/FixedRateExchange.d.ts

@@ -2,10 +2,11 @@ import { TransactionReceipt } from 'web3-core';
 import { Contract } from 'web3-eth-contract';
 import { AbiItem } from 'web3-utils/types';
 import Web3 from 'web3';
+import { Config } from '../../models/index.js';
 export interface FixedPriceExchange {
     active: boolean;
     exchangeOwner: string;
-    dataToken: string;
+    datatoken: string;
     baseToken: string;
     fixedRate: string;
     dtDecimals: string;
@@ -19,7 +20,7 @@ export interface FixedPriceExchange {
     exchangeId?: string;
 }
 export interface FeesInfo {
-    opfFee: string;
+    opcFee: string;
     marketFee: string;
     marketFeeCollector: string;
     marketFeeAvailable: string;
@@ -30,7 +31,7 @@ export interface FixedPriceSwap {
     exchangeId: string;
     caller: string;
     baseTokenAmount: string;
-    dataTokenAmount: string;
+    datatokenAmount: string;
 }
 export declare enum FixedRateCreateProgressStep {
     CreatingExchange = 0,
@@ -44,16 +45,16 @@ export declare class FixedRateExchange {
     fixedRateContract: Contract;
     web3: Web3;
     contract: Contract;
-    startBlock: number;
+    config: Config;
     ssAbi: AbiItem | AbiItem[];
-    constructor(web3: Web3, fixedRateAddress: string, fixedRateExchangeAbi?: AbiItem | AbiItem[], oceanAddress?: string, startBlock?: number);
+    constructor(web3: Web3, fixedRateAddress: string, fixedRateExchangeAbi?: AbiItem | AbiItem[], oceanAddress?: string, config?: Config);
     amountToUnits(token: string, amount: string): Promise<string>;
     unitsToAmount(token: string, amount: string): Promise<string>;
-    generateExchangeId(basetoken: string, dataToken: string, owner: string): Promise<string>;
-    estBuyDT(account: string, datatokenAddress: string, dtAmount: string, maxBasetokenAmount: string, contractInstance?: Contract): Promise<number>;
-    buyDT(address: string, exchangeId: string, datatokenAmount: string, maxBasetokenAmount: string): Promise<TransactionReceipt>;
-    estSellDT(account: string, datatokenAddress: string, dtAmount: string, maxBasetokenAmount: string, contractInstance?: Contract): Promise<number>;
-    sellDT(address: string, exchangeId: string, datatokenAmount: string, minBasetokenAmount: string): Promise<TransactionReceipt>;
+    generateExchangeId(baseToken: string, datatoken: string, owner: string): Promise<string>;
+    estBuyDT(account: string, datatokenAddress: string, dtAmount: string, maxBaseTokenAmount: string, contractInstance?: Contract): Promise<number>;
+    buyDT(address: string, exchangeId: string, datatokenAmount: string, maxBaseTokenAmount: string): Promise<TransactionReceipt>;
+    estSellDT(account: string, datatokenAddress: string, dtAmount: string, maxBaseTokenAmount: string, contractInstance?: Contract): Promise<number>;
+    sellDT(address: string, exchangeId: string, datatokenAmount: string, minBaseTokenAmount: string): Promise<TransactionReceipt>;
     getNumberOfExchanges(): Promise<number>;
     estSetRate(account: string, exchangeId: string, newRate: string, contractInstance?: Contract): Promise<number>;
     setRate(address: string, exchangeId: string, newRate: string): Promise<TransactionReceipt>;
@@ -67,8 +68,8 @@ export declare class FixedRateExchange {
     getDTSupply(exchangeId: string): Promise<string>;
     getBTSupply(exchangeId: string): Promise<string>;
     getAllowedSwapper(exchangeId: string): Promise<string>;
-    getAmountBTIn(exchangeId: string, dataTokenAmount: string): Promise<string>;
-    getAmountBTOut(exchangeId: string, dataTokenAmount: string): Promise<string>;
+    getAmountBTIn(exchangeId: string, datatokenAmount: string): Promise<string>;
+    getAmountBTOut(exchangeId: string, datatokenAmount: string): Promise<string>;
     getExchange(exchangeId: string): Promise<FixedPriceExchange>;
     getFeesInfo(exchangeId: string): Promise<FeesInfo>;
     getExchanges(): Promise<string[]>;
@@ -85,7 +86,7 @@ export declare class FixedRateExchange {
     collectMarketFee(address: string, exchangeId: string): Promise<TransactionReceipt>;
     estCollectOceanFee(account: string, exchangeId: string, contractInstance?: Contract): Promise<number>;
     collectOceanFee(address: string, exchangeId: string): Promise<TransactionReceipt>;
-    getOPFCollector(): Promise<string>;
+    getOPCCollector(): Promise<string>;
     getRouter(): Promise<string>;
     getExchangeOwner(exchangeId: string): Promise<string>;
     estUpdateMarketFee(account: string, exchangeId: string, newMarketFee: string, contractInstance?: Contract): Promise<number>;

package/dist/src/pools/ssContracts/SideStaking.d.ts

@@ -2,19 +2,21 @@ import Web3 from 'web3';
 import { AbiItem } from 'web3-utils/types';
 import { TransactionReceipt } from 'web3-core';
 import { Contract } from 'web3-eth-contract';
+import { Config } from '../../models';
 export declare class SideStaking {
     ssAbi: AbiItem | AbiItem[];
     web3: Web3;
     GASLIMIT_DEFAULT: number;
-    constructor(web3: Web3, ssAbi?: AbiItem | AbiItem[]);
+    config: Config;
+    constructor(web3: Web3, ssAbi?: AbiItem | AbiItem[], config?: Config);
     amountToUnits(token: string, amount: string): Promise<string>;
     unitsToAmount(token: string, amount: string): Promise<string>;
-    getDataTokenCirculatingSupply(ssAddress: string, datatokenAddress: string): Promise<string>;
-    getDataTokenCurrentCirculatingSupply(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getDatatokenCirculatingSupply(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getDatatokenCurrentCirculatingSupply(ssAddress: string, datatokenAddress: string): Promise<string>;
     getPublisherAddress(ssAddress: string, datatokenAddress: string): Promise<string>;
-    getBasetoken(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getBaseToken(ssAddress: string, datatokenAddress: string): Promise<string>;
     getPoolAddress(ssAddress: string, datatokenAddress: string): Promise<string>;
-    getBasetokenBalance(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getBaseTokenBalance(ssAddress: string, datatokenAddress: string): Promise<string>;
     getDatatokenBalance(ssAddress: string, datatokenAddress: string): Promise<string>;
     getvestingEndBlock(ssAddress: string, datatokenAddress: string): Promise<string>;
     getvestingAmount(ssAddress: string, datatokenAddress: string): Promise<string>;

package/dist/src/provider/Provider.d.ts

@@ -1,5 +1,9 @@
 import Web3 from 'web3';
 import { FileMetadata, ComputeJob, ComputeOutput, ComputeAlgorithm, ComputeAsset, ProviderInitialize } from '../@types/';
+import { DownloadResponse } from '../@types/DownloadResponse';
+export interface HttpCallback {
+    (httpMethod: string, url: string, body: string, header: any): Promise<any>;
+}
 export interface ServiceEndpoint {
     serviceName: string;
     method: string;
@@ -12,20 +16,20 @@ export declare class Provider {
     getEndpoints(providerUri: string): Promise<any>;
     getEndpointURL(servicesEndpoints: ServiceEndpoint[], serviceName: string): ServiceEndpoint;
     getServiceEndpoints(providerEndpoint: string, endpoints: any): Promise<ServiceEndpoint[]>;
-    getNonce(providerUri: string, consumerAddress: string, fetchMethod: any, providerEndpoints?: any, serviceEndpoints?: ServiceEndpoint[]): Promise<string>;
+    getNonce(providerUri: string, consumerAddress: string, signal?: AbortSignal, providerEndpoints?: any, serviceEndpoints?: ServiceEndpoint[]): Promise<string>;
     createSignature(web3: Web3, accountId: string, agreementId: string): Promise<string>;
     createHashSignature(web3: Web3, accountId: string, message: string): Promise<string>;
-    encrypt(data: any, providerUri: string, postMethod: any): Promise<any>;
-    checkDidFiles(did: string, serviceId: number, providerUri: string, fetchMethod: any): Promise<FileMetadata[]>;
-    checkFileUrl(url: string, providerUri: string, fetchMethod: any): Promise<FileMetadata[]>;
-    initialize(did: string, serviceId: string, fileIndex: number, consumerAddress: string, providerUri: string, getMethod: any, userCustomParameters?: UserCustomParameters, computeEnv?: string): Promise<ProviderInitialize>;
+    encrypt(data: any, providerUri: string, signal?: AbortSignal): Promise<string>;
+    checkDidFiles(did: string, serviceId: number, providerUri: string, signal?: AbortSignal): Promise<FileMetadata[]>;
+    checkFileUrl(url: string, providerUri: string, signal?: AbortSignal): Promise<FileMetadata[]>;
+    initialize(did: string, serviceId: string, fileIndex: number, consumerAddress: string, providerUri: string, signal?: AbortSignal, userCustomParameters?: UserCustomParameters, computeEnv?: string, validUntil?: number): Promise<ProviderInitialize>;
     getDownloadUrl(did: string, accountId: string, serviceId: string, fileIndex: number, transferTxId: string, providerUri: string, web3: Web3, userCustomParameters?: UserCustomParameters): Promise<any>;
-    computeStart(providerUri: string, web3: Web3, fetchMethod: any, consumerAddress: string, computeEnv: string, dataset: ComputeAsset, algorithm: ComputeAlgorithm, additionalDatasets?: ComputeAsset[], output?: ComputeOutput): Promise<ComputeJob | ComputeJob[]>;
-    computeStop(did: string, consumerAddress: string, jobId: string, providerUri: string, web3: Web3, fetchMethod: any): Promise<ComputeJob | ComputeJob[]>;
-    computeStatus(providerUri: string, fetchMethod: any, jobId?: string, did?: string, consumerAddress?: string): Promise<ComputeJob | ComputeJob[]>;
-    computeResult(jobId: string, index: number, destination: string, accountId: string, providerUri: string, web3: Web3, fetchMethod: any): Promise<any>;
-    computeDelete(did: string, consumerAddress: string, jobId: string, providerUri: string, web3: Web3, fetchMethod: any): Promise<ComputeJob | ComputeJob[]>;
-    isValidProvider(url: string, fetchMethod: any): Promise<boolean>;
+    computeStart(providerUri: string, web3: Web3, consumerAddress: string, computeEnv: string, dataset: ComputeAsset, algorithm: ComputeAlgorithm, signal?: AbortSignal, additionalDatasets?: ComputeAsset[], output?: ComputeOutput): Promise<ComputeJob | ComputeJob[]>;
+    computeStop(did: string, consumerAddress: string, jobId: string, providerUri: string, web3: Web3, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
+    computeStatus(providerUri: string, signal?: AbortSignal, jobId?: string, did?: string, consumerAddress?: string): Promise<ComputeJob | ComputeJob[]>;
+    computeResult(jobId: string, index: number, accountId: string, providerUri: string, web3: Web3, signal?: AbortSignal): Promise<DownloadResponse | void>;
+    computeDelete(did: string, consumerAddress: string, jobId: string, providerUri: string, web3: Web3, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
+    isValidProvider(url: string, signal?: AbortSignal): Promise<boolean>;
 }
 export declare const ProviderInstance: Provider;
 export default ProviderInstance;

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

@@ -4,6 +4,8 @@ import { TransactionReceipt } from 'web3-eth';
 import { Contract } from 'web3-eth-contract';
 import { FreOrderParams, FreCreationParams } from '../interfaces';
 import { Nft } from './NFT';
+import { Config } from '../models/index.js';
+import { ProviderFees } from '../@types/Provider.js';
 interface Roles {
     minter: boolean;
     paymentManager: boolean;
@@ -11,13 +13,8 @@ interface Roles {
 export interface OrderParams {
     consumer: string;
     serviceIndex: number;
-    providerFeeAddress: string;
-    providerFeeToken: string;
-    providerFeeAmount: string;
-    v: string;
-    r: string;
-    s: string;
-    providerData: string;
+    ammount: string;
+    _providerFees: ProviderFees;
 }
 export interface DispenserParams {
     maxTokens: string;
@@ -32,9 +29,9 @@ export declare class Datatoken {
     datatokensAbi: AbiItem | AbiItem[];
     datatokensEnterpriseAbi: AbiItem | AbiItem[];
     web3: Web3;
-    startBlock: number;
+    config: Config;
     nft: Nft;
-    constructor(web3: Web3, datatokensAbi?: AbiItem | AbiItem[], datatokensEnterpriseAbi?: AbiItem | AbiItem[], startBlock?: number);
+    constructor(web3: Web3, datatokensAbi?: AbiItem | AbiItem[], datatokensEnterpriseAbi?: AbiItem | AbiItem[], config?: Config);
     estGasApprove(dtAddress: string, spender: string, amount: string, address: string, contractInstance?: Contract): Promise<any>;
     approve(dtAddress: string, spender: string, amount: string, address: string): Promise<TransactionReceipt>;
     estGasMint(dtAddress: string, address: string, amount: string, toAddress?: string, contractInstance?: Contract): Promise<any>;
@@ -57,8 +54,8 @@ export declare class Datatoken {
     transfer(dtAddress: string, toAddress: string, amount: string, address: string): Promise<TransactionReceipt>;
     estGasTransfer(dtAddress: string, toAddress: string, amount: string, address: string, contractInstance?: Contract): Promise<any>;
     transferWei(dtAddress: string, toAddress: string, amount: string, address: string): Promise<TransactionReceipt>;
-    estGasStartOrder(dtAddress: string, address: string, consumer: string, serviceIndex: number, providerFeeAddress: string, providerFeeToken: string, providerFeeAmount: string, v: string, r: string, s: string, providerDatas: string, contractInstance?: Contract): Promise<any>;
-    startOrder(dtAddress: string, address: string, consumer: string, serviceIndex: number, providerFeeAddress: string, providerFeeToken: string, providerFeeAmount: string, v: string, r: string, s: string, providerDatas: string): Promise<TransactionReceipt>;
+    estGasStartOrder(dtAddress: string, address: string, consumer: string, serviceIndex: number, providerFees: ProviderFees, contractInstance?: Contract): Promise<any>;
+    startOrder(dtAddress: string, address: string, consumer: string, serviceIndex: number, providerFees: ProviderFees): Promise<TransactionReceipt>;
     estGasBuyFromFreAndOrder(dtAddress: string, address: string, orderParams: OrderParams, freParams: FreOrderParams, contractInstance?: Contract): Promise<any>;
     buyFromFreAndOrder(dtAddress: string, address: string, orderParams: OrderParams, freParams: FreOrderParams): Promise<TransactionReceipt>;
     estGasBuyFromDispenserAndOrder(dtAddress: string, address: string, orderParams: OrderParams, dispenserContract: string, contractInstance?: Contract): Promise<any>;
@@ -72,6 +69,6 @@ export declare class Datatoken {
     getDecimals(dtAddress: string): Promise<string>;
     getNFTAddress(dtAddress: string): Promise<string>;
     isERC20Deployer(dtAddress: string, address: string): Promise<boolean>;
-    balance(dataTokenAddress: string, address: string): Promise<string>;
+    balance(datatokenAddress: string, address: string): Promise<string>;
 }
 export {};

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

@@ -3,6 +3,8 @@ import { AbiItem } from 'web3-utils';
 import { TransactionReceipt } from 'web3-eth';
 import { Contract } from 'web3-eth-contract';
 import { MetadataProof } from '../../src/@types';
+import { Config } from '../models/index.js';
+import { MetadataAndTokenURI } from '../interfaces/Erc721Interface';
 interface Roles {
     manager: boolean;
     deployERC20: boolean;
@@ -16,7 +18,8 @@ export declare class Nft {
     nftAbi: AbiItem | AbiItem[];
     web3: Web3;
     startBlock: number;
-    constructor(web3: Web3, nftAbi?: AbiItem | AbiItem[], startBlock?: number);
+    config: Config;
+    constructor(web3: Web3, nftAbi?: AbiItem | AbiItem[], config?: Config);
     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>;
     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>;
     estGasAddManager(nftAddress: string, address: string, manager: string, contractInstance?: Contract): Promise<any>;
@@ -41,8 +44,10 @@ export declare class Nft {
     transferNft(nftAddress: string, nftOwner: string, nftReceiver: string, tokenId?: number): Promise<TransactionReceipt>;
     estGasSafeTransferNft(nftAddress: string, nftOwner: string, nftReceiver: string, tokenId: number, contractInstance?: Contract): Promise<any>;
     safeTransferNft(nftAddress: string, nftOwner: string, nftReceiver: string, tokenId?: number): Promise<TransactionReceipt>;
-    estGasSetMetadata(nftAddress: string, metadataUpdater: string, metadataState: number, metaDataDecryptorUrl: string, metaDataDecryptorAddress: string, flags: string, data: string, metadataHash: string, metadataProofs?: MetadataProof[], contractInstance?: Contract): Promise<any>;
-    setMetadata(nftAddress: string, address: string, metadataState: number, metaDataDecryptorUrl: string, metaDataDecryptorAddress: string, flags: string, data: string, metadataHash: string, metadataProofs?: MetadataProof[]): Promise<TransactionReceipt>;
+    estGasSetMetadata(nftAddress: string, metadataUpdater: string, metadataState: number, metadataDecryptorUrl: string, metadataDecryptorAddress: string, flags: string, data: string, metadataHash: string, metadataProofs?: MetadataProof[], contractInstance?: Contract): Promise<any>;
+    setMetadata(nftAddress: string, address: string, metadataState: number, metadataDecryptorUrl: string, metadataDecryptorAddress: string, flags: string, data: string, metadataHash: string, metadataProofs?: MetadataProof[]): Promise<TransactionReceipt>;
+    estGasSetMetadataAndTokenURI(nftAddress: string, metadataUpdater: string, metadataAndTokenURI: MetadataAndTokenURI, contractInstance?: Contract): Promise<any>;
+    setMetadataAndTokenURI(nftAddress: string, metadataUpdater: string, metadataAndTokenURI: MetadataAndTokenURI): Promise<TransactionReceipt>;
     estGasSetMetadataState(nftAddress: string, metadataUpdater: string, metadataState: number, contractInstance?: Contract): Promise<any>;
     setMetadataState(nftAddress: string, address: string, metadataState: number): Promise<TransactionReceipt>;
     estSetTokenURI(nftAddress: string, address: string, data: string): Promise<any>;

package/dist/src/utils/ConfigHelper.d.ts

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

package/dist/src/utils/Constants.d.ts

@@ -1 +1,2 @@
 export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const GASLIMIT_DEFAULT = 1000000;

package/dist/src/utils/ContractUtils.d.ts

@@ -0,0 +1,11 @@
+import Web3 from 'web3';
+import { Contract } from 'web3-eth-contract';
+import { Erc20CreateParams, FreCreationParams, PoolCreationParams } from '../interfaces';
+import { Config } from '../models';
+export declare function setContractDefaults(contract: Contract, config: Config): Contract;
+export declare function getFairGasPrice(web3: Web3, config: Config): Promise<string>;
+export declare function getErcCreationParams(ercParams: Erc20CreateParams): any;
+export declare function getFreCreationParams(freParams: FreCreationParams): any;
+export declare function getPoolCreationParams(poolParams: PoolCreationParams): any;
+export declare function unitsToAmount(web3: Web3, token: string, amount: string): Promise<string>;
+export declare function amountToUnits(web3: Web3, token: string, amount: string): Promise<string>;

package/dist/src/utils/FetchHelper.d.ts

@@ -1,5 +1,6 @@
+import { DownloadResponse } from '../@types/DownloadResponse';
 export declare function fetchData(url: string, opts: RequestInit): Promise<Response>;
-export declare function downloadFile(url: string, destination?: string, index?: number): Promise<string>;
+export declare function downloadFileBrowser(url: string): Promise<void>;
+export declare function downloadFile(url: string, index?: number): Promise<DownloadResponse>;
 export declare function getData(url: string): Promise<Response>;
 export declare function postData(url: string, payload: BodyInit): Promise<Response>;
-export declare function crossFetchGeneric(method: string, url: string, body: string, headers: any): Promise<Response>;

package/dist/src/utils/TokenUtils.d.ts

@@ -0,0 +1,7 @@
+import { Contract } from 'web3-eth-contract';
+import { TransactionReceipt } from 'web3-core';
+import Web3 from 'web3';
+export declare function estApprove(web3: Web3, account: string, tokenAddress: string, spender: string, amount: string, contractInstance?: Contract): Promise<number>;
+export declare function approve(web3: Web3, account: string, tokenAddress: string, spender: string, amount: string, force?: boolean): Promise<TransactionReceipt | string>;
+export declare function allowance(web3: Web3, tokenAddress: string, account: string, spender: string): Promise<string>;
+export declare function balance(web3: Web3, tokenAddress: string, account: string): Promise<string>;

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

@@ -1,9 +1,9 @@
 export * from './Logger';
-export * from './GasUtils';
 export * from './DatatokenName';
-export * from './ContractParams';
+export * from './ContractUtils';
 export * from './FetchHelper';
 export * from './ConfigHelper';
 export * from './DdoHelpers';
 export * from './Constants';
 export * from './SignatureUtils';
+export * from './TokenUtils';

package/dist/src/utils/minAbi.d.ts

@@ -0,0 +1,2 @@
+import { AbiItem } from 'web3-utils/types';
+export declare const minAbi: AbiItem[];

package/docs/beginners_guide.md

@@ -166,10 +166,10 @@ The process of creating and deploying the ERC20 datatokens has been automated by
 
 ```Javascript
 const Web3 = require("web3");
-const { Ocean, DataTokens } = require("@oceanprotocol/lib");
+const { Ocean, Datatokens } = require("@oceanprotocol/lib");
  
-const { factoryABI } = require("@oceanprotocol/contracts/artifacts/DTFactory.json");
-const { datatokensABI } = require("@oceanprotocol/contracts/artifacts/DataTokenTemplate.json");
+const { factoryABI } = require("@oceanprotocol/contracts/artifacts/contracts/DTFactory.json");
+const { datatokensABI } = require("@oceanprotocol/contracts/artifacts/contracts/DatatokenTemplate.json");
 const { config, contracts, urls } = require("./config");
  
 const init = async () => {
@@ -180,7 +180,7 @@ const init = async () => {
  const alice = accounts[0].id;
  console.log('Alice account address:', alice)
  
- const datatoken = new DataTokens(
+ const datatoken = new Datatokens(
    contracts.DTFactory,
    factoryABI,
    datatokensABI,