@oceanprotocol/lib 0.20.1 → 1.0.0-next.2

package/dist/node/metadatacache/MetadataCache.d.ts

@@ -1,41 +0,0 @@
-import { DDO } from '../ddo/DDO';
-import DID from '../ocean/DID';
-import { Logger } from '../utils';
-import { WebServiceConnector } from '../ocean/utils/WebServiceConnector';
-import { Metadata, ValidateMetadata } from '../ddo/interfaces';
-export interface SearchQuery {
-    from?: number;
-    size?: number;
-    query: {
-        match?: {
-            [property: string]: string | number | boolean | Record<string, string | number | boolean>;
-        };
-        query_string?: {
-            [property: string]: string | number | string[] | number[] | boolean;
-        };
-        simple_query_string?: {
-            [property: string]: string | number | string[] | number[] | boolean;
-        };
-    };
-    sort?: {
-        [jsonPath: string]: string;
-    };
-}
-export declare class MetadataCache {
-    fetch: WebServiceConnector;
-    private logger;
-    private metadataCacheUri;
-    private get url();
-    constructor(metadataCacheUri: string, logger: Logger, requestTimeout?: number);
-    getVersionInfo(): Promise<any>;
-    getAccessUrl(accessToken: any, payload: any): Promise<string>;
-    queryMetadata(query: SearchQuery): Promise<any>;
-    encryptDDO(ddo: any): Promise<any>;
-    validateMetadata(metadata: Metadata | DDO): Promise<ValidateMetadata>;
-    retrieveDDO(did: DID | string, metadataServiceEndpoint?: string): Promise<DDO>;
-    retrieveDDOByUrl(metadataServiceEndpoint?: string): Promise<DDO>;
-    getServiceEndpoint(did: DID): string;
-    getURI(): string;
-    sleep(ms: number): Promise<unknown>;
-    waitForAqua(did: string, txid?: string): Promise<void>;
-}

package/dist/node/metadatacache/OnChainMetaData.d.ts

@@ -1,31 +0,0 @@
-import { DDO } from '../ddo/DDO';
-import { TransactionReceipt } from 'web3-core';
-import { Contract } from 'web3-eth-contract';
-import { AbiItem } from 'web3-utils/types';
-import Web3 from 'web3';
-import { Logger } from '../utils';
-import { ConfigHelperConfig } from '../utils/ConfigHelper';
-import { MetadataCache } from '../metadatacache/MetadataCache';
-export interface rawMetadata {
-    flags: number;
-    data: any;
-}
-export declare class OnChainMetadata {
-    GASLIMIT_DEFAULT: number;
-    DDOContractAddress: string;
-    DDOContractABI: AbiItem | AbiItem[];
-    web3: Web3;
-    DDOContract: Contract;
-    private logger;
-    metadataCache: MetadataCache;
-    private config;
-    constructor(web3: Web3, logger: Logger, DDOContractAddress: string, DDOContractABI: AbiItem | AbiItem[], metadataCache: MetadataCache, config?: ConfigHelperConfig);
-    compressDDO(data: any): Promise<string>;
-    publish(did: string, ddo: DDO, consumerAccount: string, encrypt?: boolean, validate?: boolean): Promise<TransactionReceipt>;
-    update(did: string, ddo: DDO, consumerAccount: string, encrypt?: boolean, validate?: boolean): Promise<TransactionReceipt>;
-    prepareRawData(ddo: DDO, encrypt?: boolean): Promise<rawMetadata>;
-    publishRaw(did: string, flags: any, data: any, consumerAccount: string): Promise<TransactionReceipt>;
-    updateRaw(did: string, flags: any, data: any, consumerAccount: string): Promise<TransactionReceipt>;
-    transferOwnership(did: string, newOwner: string, consumerAccount: string): Promise<TransactionReceipt>;
-    getHex(message: any): string;
-}

package/dist/node/ocean/Account.d.ts

@@ -1,16 +0,0 @@
-import { Instantiable, InstantiableConfig } from '../Instantiable.abstract';
-export default class Account extends Instantiable {
-    private id;
-    private password?;
-    private token?;
-    constructor(id?: string, config?: InstantiableConfig);
-    getId(): string;
-    setId(id: string): void;
-    setPassword(password: string): void;
-    getPassword(): string;
-    getTokenBalance(TokenAdress: string): Promise<string>;
-    getTokenDecimals(TokenAdress: string): Promise<number>;
-    getOceanBalance(): Promise<string>;
-    getTokenSymbol(TokenAdress: string): Promise<string>;
-    getEtherBalance(): Promise<string>;
-}

package/dist/node/ocean/Accounts.d.ts

@@ -1,9 +0,0 @@
-import Account from './Account';
-import { Instantiable, InstantiableConfig } from '../Instantiable.abstract';
-export declare class Accounts extends Instantiable {
-    static getInstance(config: InstantiableConfig): Promise<Accounts>;
-    list(): Promise<Account[]>;
-    getTokenBalance(TokenAddress: string, account: Account): Promise<string>;
-    getOceanBalance(account: Account): Promise<string>;
-    getEtherBalance(account: Account): Promise<string>;
-}

package/dist/node/ocean/Assets.d.ts

@@ -1,56 +0,0 @@
-import { DDO } from '../ddo/DDO';
-import { Metadata } from '../ddo/interfaces/Metadata';
-import { Service, ServiceAccess, ServiceCustomParameter, ServiceCustomParametersRequired } from '../ddo/interfaces/Service';
-import { SearchQuery } from '../metadatacache/MetadataCache';
-import { EditableMetadata } from '../ddo/interfaces/EditableMetadata';
-import Account from './Account';
-import { SubscribablePromise } from '../utils';
-import { Instantiable, InstantiableConfig } from '../Instantiable.abstract';
-import { UserCustomParameters } from '../provider/Provider';
-import { TransactionReceipt } from 'web3-core';
-import { Consumable } from '../ddo/interfaces/Consumable';
-export declare enum CreateProgressStep {
-    CreatingDataToken = 0,
-    DataTokenCreated = 1,
-    EncryptingFiles = 2,
-    FilesEncrypted = 3,
-    StoringDdo = 4,
-    DdoStored = 5
-}
-export declare enum OrderProgressStep {
-    TransferDataToken = 0
-}
-export interface Order {
-    dtAddress: string;
-    amount: string;
-    timestamp: number;
-    transactionHash: string;
-    consumer: string;
-    payer: string;
-    did?: string;
-    serviceId?: number;
-    serviceType?: string;
-}
-export declare class Assets extends Instantiable {
-    static getInstance(config: InstantiableConfig): Promise<Assets>;
-    create(metadata: Metadata, publisher: Account, services?: Service[], dtAddress?: string, cap?: string, name?: string, symbol?: string, providerUri?: string): SubscribablePromise<CreateProgressStep, DDO>;
-    resolve(did: string): Promise<DDO>;
-    editMetadata(ddo: DDO, newMetadata: EditableMetadata): Promise<DDO>;
-    updateCredentials(ddo: DDO, credentialType: string, allowList: string[], denyList: string[]): Promise<DDO>;
-    checkCredential(ddo: DDO, credentialType: string, value: string): Consumable;
-    publishDdo(ddo: DDO, consumerAccount: string, encrypt?: boolean): Promise<TransactionReceipt>;
-    updateMetadata(ddo: DDO, consumerAccount: string): Promise<TransactionReceipt>;
-    editServiceTimeout(ddo: DDO, serviceIndex: number, timeout: number): Promise<DDO>;
-    creator(asset: DDO | string): Promise<string>;
-    getServiceByType(asset: DDO | string, serviceType: string): Promise<Service>;
-    getServiceByIndex(asset: DDO | string, serviceIndex: number): Promise<Service>;
-    query(query: SearchQuery): Promise<any>;
-    createAccessServiceAttributes(creator: Account, cost: string, datePublished: string, timeout?: number, providerUri?: string, requiredParameters?: ServiceCustomParametersRequired): Promise<ServiceAccess>;
-    initialize(asset: DDO | string, serviceType: string, consumerAddress: string, serviceIndex: number, serviceEndpoint: string, userCustomParameters?: UserCustomParameters): Promise<any>;
-    order(asset: DDO | string, serviceType: string, payerAddress: string, serviceIndex?: number, mpAddress?: string, consumerAddress?: string, userCustomParameters?: UserCustomParameters, authService?: string, searchPreviousOrders?: boolean): Promise<string>;
-    download(asset: DDO | string, txId: string, tokenAddress: string, consumerAccount: Account, destination: string): Promise<string | true>;
-    simpleDownload(dtAddress: string, serviceEndpoint: string, txId: string, account: string): Promise<string>;
-    getOrderHistory(account: Account, serviceType?: string, fromBlock?: number): Promise<Order[]>;
-    isConsumable(ddo: DDO, consumer?: string, credentialsType?: string, authService?: string): Promise<Consumable>;
-    isUserCustomParametersValid(serviceCustomParameters: ServiceCustomParameter[], userCustomParameters?: UserCustomParameters): Promise<boolean>;
-}

package/dist/node/ocean/AssetsCredential.d.ts

@@ -1,6 +0,0 @@
-import { DDO } from '../ddo/DDO';
-import { Credentials, CredentialAction } from '../ddo/interfaces/Credentials';
-export declare function checkCredentialExist(credentials: Credentials, credentialType: string, credentialAction: CredentialAction): boolean;
-export declare function removeCredentialDetail(ddo: DDO, credentialType: string, credentialAction: CredentialAction): DDO;
-export declare function updateCredentialDetail(ddo: DDO, credentialType: string, list: string[], credentialAction: CredentialAction): DDO;
-export declare function addCredentialDetail(ddo: DDO, credentialType: string, list: string[], credentialAction: CredentialAction): DDO;

package/dist/node/ocean/Compute.d.ts

@@ -1,75 +0,0 @@
-import { DDO } from '../ddo/DDO';
-import { ServiceComputePrivacy, ServiceCompute, publisherTrustedAlgorithm, ServiceCustomParametersRequired } from '../ddo/interfaces/Service';
-import Account from './Account';
-import { SubscribablePromise } from '../utils';
-import { Instantiable, InstantiableConfig } from '../Instantiable.abstract';
-import { ComputeOutput, ComputeJob, ComputeInput, ComputeAlgorithm } from './interfaces/Compute';
-import { UserCustomParameters } from '../provider/Provider';
-export declare enum OrderProgressStep {
-    TransferDataToken = 0
-}
-export interface Cluster {
-    type: string;
-    url: string;
-}
-export interface Container {
-    image: string;
-    tag: string;
-    checksum: string;
-}
-export interface Server {
-    serverId: string;
-    serverType: string;
-    cost: string;
-    cpu: string;
-    gpu: string;
-    memory: string;
-    disk: string;
-    maxExecutionTime: number;
-}
-export declare const ComputeJobStatus: Readonly<{
-    WarmingUp: number;
-    Started: number;
-    ConfiguringVolumes: number;
-    ProvisioningSuccess: number;
-    DataProvisioningFailed: number;
-    AlgorithmProvisioningFailed: number;
-    RunningAlgorithm: number;
-    FilteringResults: number;
-    PublishingResult: number;
-    Completed: number;
-    Stopped: number;
-    Deleted: number;
-}>;
-export declare class Compute extends Instantiable {
-    static getInstance(config: InstantiableConfig): Promise<Compute>;
-    getComputeAddress(did: string, serviceIndex?: number): Promise<string>;
-    start(asset: DDO | string, txId: string, tokenAddress: string, consumerAccount: Account, algorithm: ComputeAlgorithm, output?: ComputeOutput, serviceIndex?: string, serviceType?: string, additionalInputs?: ComputeInput[]): Promise<ComputeJob>;
-    stop(consumerAccount: Account, asset: DDO | string, jobId: string): Promise<ComputeJob>;
-    delete(consumerAccount: Account, asset: DDO | string, jobId: string): Promise<ComputeJob>;
-    status(consumerAccount: Account, did?: string, ddo?: DDO, service?: ServiceCompute, jobId?: string, txId?: string): Promise<ComputeJob[]>;
-    getResult(consumerAccount: Account, jobId: string, index: number, destination: string, did?: string, ddo?: DDO, service?: ServiceCompute): Promise<any>;
-    createServerAttributes(serverId: string, serverType: string, cost: string, cpu: string, gpu: string, memory: string, disk: string, maxExecutionTime: number): Server;
-    createContainerAttributes(image: string, tag: string, checksum: string): Container;
-    createClusterAttributes(type: string, url: string): Cluster;
-    createProviderAttributes(type: string, description: string, cluster: Cluster, containers: Container[], servers: Server[]): {
-        type: string;
-        description: string;
-        environment: {
-            cluster: Cluster;
-            supportedServers: Server[];
-            supportedContainers: Container[];
-        };
-    };
-    createComputeService(consumerAccount: Account, cost: string, datePublished: string, providerAttributes: any, computePrivacy?: ServiceComputePrivacy, timeout?: number, providerUri?: string, requiredCustomParameters?: ServiceCustomParametersRequired): ServiceCompute;
-    private checkOutput;
-    isOrderable(dataset: DDO | string, serviceIndex: number, algorithm: ComputeAlgorithm, algorithmDDO?: DDO): Promise<boolean>;
-    orderAsset(consumerAccount: string, dataset: DDO | string, serviceIndex: number, algorithm: ComputeAlgorithm, mpAddress?: string, computeAddress?: string, userCustomParameters?: UserCustomParameters, authService?: string, searchPreviousOrders?: boolean): SubscribablePromise<OrderProgressStep, string>;
-    orderAlgorithm(asset: DDO | string, serviceType: string, payerAddress: string, serviceIndex?: number, mpAddress?: string, consumerAddress?: string, userCustomParameters?: UserCustomParameters, authService?: string, searchPreviousOrders?: boolean): Promise<string>;
-    editComputePrivacy(ddo: DDO, serviceIndex: number, computePrivacy: ServiceComputePrivacy): Promise<DDO>;
-    toggleAllowAllPublishedAlgorithms(ddo: DDO, serviceIndex: number, newState: boolean): Promise<DDO>;
-    createPublisherTrustedAlgorithmfromDID(did: string, ddo?: DDO): Promise<publisherTrustedAlgorithm>;
-    addTrustedAlgorithmtoAsset(ddo: DDO, serviceIndex: number, algoDid: string): Promise<DDO>;
-    isAlgorithmTrusted(ddo: DDO, serviceIndex: number, algoDid: string): Promise<boolean>;
-    removeTrustedAlgorithmFromAsset(ddo: DDO, serviceIndex: number, algoDid: string): Promise<DDO>;
-}

package/dist/node/ocean/DID.d.ts

@@ -1,8 +0,0 @@
-export default class DID {
-    static parse(didString: string | DID): DID;
-    static generate(dataTokenAddress: string): DID;
-    private id;
-    private constructor();
-    getDid(): string;
-    getId(): string;
-}

package/dist/node/ocean/EventAccessControl.d.ts

@@ -1,9 +0,0 @@
-import { Instantiable, InstantiableConfig } from '../Instantiable.abstract';
-export declare class EventAccessControl extends Instantiable {
-    private baseUrl;
-    static getInstance(config: InstantiableConfig): Promise<EventAccessControl>;
-    setBaseUrl(url: string): Promise<void>;
-    get url(): string;
-    private getIsPermitArgs;
-    isPermit(component: string, eventType: string, authService: string, credentials: string, credentialsType: string, did?: string): Promise<boolean>;
-}

package/dist/node/ocean/Ocean.d.ts

@@ -1,34 +0,0 @@
-import { Accounts } from './Accounts';
-import { Assets } from './Assets';
-import { Versions } from './Versions';
-import { OceanUtils } from './utils/Utils';
-import { MetadataCache } from '../metadatacache/MetadataCache';
-import { OnChainMetadata } from '../metadatacache/OnChainMetaData';
-import { Provider } from '../provider/Provider';
-import { DataTokens } from '../datatokens/Datatokens';
-import { Network } from '../datatokens/Network';
-import { Config } from '../models/Config';
-import { Instantiable } from '../Instantiable.abstract';
-import { Compute } from './Compute';
-import { OceanPool } from '../balancer/OceanPool';
-import { OceanFixedRateExchange } from '../exchange/FixedRateExchange';
-import { OceanDispenser } from '../dispenser/Dispenser';
-import { EventAccessControl } from './EventAccessControl';
-export declare class Ocean extends Instantiable {
-    static getInstance(config: Config): Promise<Ocean>;
-    network: Network;
-    provider: Provider;
-    eventAccessControl: EventAccessControl;
-    web3Provider: any;
-    metadataCache: MetadataCache;
-    onChainMetadata: OnChainMetadata;
-    accounts: Accounts;
-    assets: Assets;
-    compute: Compute;
-    datatokens: DataTokens;
-    pool: OceanPool;
-    fixedRateExchange: OceanFixedRateExchange;
-    OceanDispenser: OceanDispenser;
-    versions: Versions;
-    utils: OceanUtils;
-}

package/dist/node/ocean/OceanAuth.d.ts

@@ -1,15 +0,0 @@
-import Account from './Account';
-import { Instantiable, InstantiableConfig } from '../Instantiable.abstract';
-export declare class OceanAuth extends Instantiable {
-    static getInstance(config: InstantiableConfig): Promise<OceanAuth>;
-    get(account: Account): Promise<string>;
-    check(token: string): Promise<string>;
-    store(account: Account): Promise<void>;
-    restore(account: Account): Promise<string>;
-    isStored(account: Account): Promise<boolean>;
-    private writeToken;
-    private readToken;
-    private getLocalStorage;
-    private getMessage;
-    private getExpiration;
-}

package/dist/node/ocean/Versions.d.ts

@@ -1,25 +0,0 @@
-import { Instantiable, InstantiableConfig } from '../Instantiable.abstract';
-export declare enum OceanPlatformTechStatus {
-    Loading = "Loading",
-    Unknown = "Unknown",
-    Stopped = "Stopped",
-    Working = "Working"
-}
-export interface OceanPlatformTech {
-    name: string;
-    version?: string;
-    commit?: string;
-    status: OceanPlatformTechStatus;
-}
-export interface OceanPlatformVersions {
-    lib: OceanPlatformTech;
-    metadataCache: OceanPlatformTech;
-    provider: OceanPlatformTech;
-    status: {
-        ok: boolean;
-    };
-}
-export declare class Versions extends Instantiable {
-    static getInstance(config: InstantiableConfig): Promise<Versions>;
-    get(): Promise<OceanPlatformVersions>;
-}

package/dist/node/ocean/utils/SignatureUtils.d.ts

@@ -1,13 +0,0 @@
-import Web3 from 'web3';
-import { Logger } from '../../utils';
-import { Account } from '../../lib';
-export declare class SignatureUtils {
-    private web3;
-    private logger;
-    constructor(web3: Web3, logger: Logger);
-    signText(text: string, publicKey: string, password?: string): Promise<string>;
-    signWithHash(text: string, publicKey: string, password?: string): Promise<string>;
-    verifyText(text: string, signature: string): Promise<string>;
-    getHash(message: string): Promise<string>;
-    signForAquarius(message: string, account: Account): Promise<string>;
-}

package/dist/node/ocean/utils/Utils.d.ts

@@ -1,8 +0,0 @@
-import { Instantiable, InstantiableConfig } from '../../Instantiable.abstract';
-import { SignatureUtils } from './SignatureUtils';
-import { WebServiceConnector } from './WebServiceConnector';
-export declare class OceanUtils extends Instantiable {
-    static getInstance(config: InstantiableConfig): Promise<OceanUtils>;
-    signature: SignatureUtils;
-    fetch: WebServiceConnector;
-}

package/dist/node/ocean/utils/WebServiceConnector.d.ts

@@ -1,16 +0,0 @@
-import { Response } from 'node-fetch';
-import { Logger } from '../../utils';
-export declare class WebServiceConnector {
-    logger: Logger;
-    requestTimeout: number;
-    constructor(logger: Logger, requestTimeout?: number);
-    post(url: string, payload: BodyInit): Promise<Response>;
-    postWithOctet(url: string, payload: BodyInit): Promise<Response>;
-    postWithHeaders(url: string, payload: BodyInit, headers: any): Promise<Response>;
-    get(url: string): Promise<Response>;
-    put(url: string, payload: BodyInit): Promise<Response>;
-    delete(url: string, payload?: BodyInit): Promise<Response>;
-    downloadFile(url: string, destination?: string, index?: number): Promise<string>;
-    downloadFileBrowser(url: string): Promise<void>;
-    private fetch;
-}

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

@@ -1,56 +0,0 @@
-import Account from '../ocean/Account';
-import { Instantiable, InstantiableConfig } from '../Instantiable.abstract';
-import { File } from '../ddo/interfaces/File';
-import { ComputeJob, ComputeInput, ComputeOutput, ComputeAlgorithm } from '../ocean/interfaces/Compute';
-import { DDO } from '../ddo/DDO';
-import DID from '../ocean/DID';
-export interface ServiceEndpoint {
-    serviceName: string;
-    method: string;
-    urlPath: string;
-}
-export interface ComputeLimits {
-    algoTimeLimit?: string;
-    storageExpiry?: string;
-}
-export interface UserCustomParameters {
-    [key: string]: any;
-}
-export declare class Provider extends Instantiable {
-    nonce: string;
-    private baseUrl;
-    servicesEndpoints: ServiceEndpoint[];
-    computeAddress: string;
-    providerAddress: string;
-    providerVersion: string;
-    computeLimits: ComputeLimits;
-    static getInstance(config: InstantiableConfig): Promise<Provider>;
-    setBaseUrl(url: string): Promise<boolean>;
-    get url(): string;
-    getServiceEndpoints(): Promise<ServiceEndpoint[]>;
-    getEndpointURL(serviceName: string): ServiceEndpoint;
-    createSignature(account: Account, agreementId: string): Promise<string>;
-    createHashSignature(account: Account, message: string): Promise<string>;
-    encrypt(did: string, document: any, account: Account): Promise<string>;
-    fileinfo(url: string): Promise<File[]>;
-    isFileConsumable(did: DID, serviceIndex: number): Promise<boolean>;
-    getNonce(consumerAddress: string): Promise<string>;
-    initialize(asset: DDO | string, serviceIndex: number, serviceType: string, consumerAddress: string, userCustomParameters?: UserCustomParameters): Promise<string>;
-    download(did: string, txId: string, tokenAddress: string, serviceType: string, serviceIndex: string, destination: string, account: Account, files: File[], index?: number, userCustomParameters?: UserCustomParameters): Promise<any>;
-    computeStart(did: string, consumerAccount: Account, algorithm: ComputeAlgorithm, output?: ComputeOutput, txId?: string, serviceIndex?: string, serviceType?: string, tokenAddress?: string, additionalInputs?: ComputeInput[], userCustomParameters?: UserCustomParameters): Promise<ComputeJob | ComputeJob[]>;
-    computeStop(did: string, consumerAccount: Account, jobId: string): Promise<ComputeJob | ComputeJob[]>;
-    computeDelete(did: string, consumerAccount: Account, jobId: string): Promise<ComputeJob | ComputeJob[]>;
-    computeStatus(did: string, consumerAccount: Account, jobId?: string, txId?: string): Promise<ComputeJob | ComputeJob[]>;
-    computeResult(jobId: string, index: number, destination: string, account: Account): Promise<any>;
-    getInitializeEndpoint(): ServiceEndpoint;
-    getNonceEndpoint(): ServiceEndpoint;
-    getEncryptEndpoint(): ServiceEndpoint;
-    getFileinfoEndpoint(): ServiceEndpoint;
-    getComputeStartEndpoint(): ServiceEndpoint;
-    getComputeStopEndpoint(): ServiceEndpoint;
-    getComputeStatusEndpoint(): ServiceEndpoint;
-    getComputeDeleteEndpoint(): ServiceEndpoint;
-    getComputeResultEndpoint(): ServiceEndpoint;
-    getDownloadEndpoint(): ServiceEndpoint;
-    isValidProvider(url: string): Promise<boolean>;
-}

package/dist/node/utils/AssetResolverHelper.d.ts

@@ -1,8 +0,0 @@
-import { DDO } from '../ddo/DDO';
-import { Ocean } from '../ocean/Ocean';
-export interface AssetResolved {
-    did: string;
-    ddo: DDO;
-}
-export declare function isDdo(arg: any): arg is DDO;
-export declare function assetResolve(asset: DDO | string, ocean: Ocean): Promise<AssetResolved>;

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

@@ -1,17 +0,0 @@
-import Config from '../models/Config';
-export interface ConfigHelperConfig extends Config {
-    networkId: number;
-    network: string;
-    subgraphUri: string;
-    explorerUri: string;
-    oceanTokenSymbol: string;
-    transactionBlockTimeout: number;
-    transactionConfirmationBlocks: number;
-    transactionPollingTimeout: number;
-    gasFeeMultiplier: number;
-}
-export declare const configHelperNetworks: ConfigHelperConfig[];
-export declare class ConfigHelper {
-    getAddressesFromEnv(network: string): Partial<ConfigHelperConfig>;
-    getConfig(network: string | number, infuraProjectId?: string): Config;
-}

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

@@ -1,5 +0,0 @@
-import Web3 from 'web3';
-import { Contract } from 'web3-eth-contract';
-import { ConfigHelperConfig } from './ConfigHelper';
-export declare function getFairGasPrice(web3: Web3, config: ConfigHelperConfig): Promise<string>;
-export declare function setContractDefaults(contract: Contract, config: ConfigHelperConfig): Contract;

package/dist/node/utils/ConversionTypeHelpers.d.ts

@@ -1,8 +0,0 @@
-export declare const zeroX: (input: string) => string;
-export declare const noZeroX: (input: string) => string;
-export declare function zeroXTransformer(input: string, zeroOutput: boolean): string;
-export declare const didPrefixed: (input: string) => string;
-export declare const noDidPrefixed: (input: string) => string;
-export declare function didTransformer(input: string, prefixOutput: boolean): string;
-export declare const didZeroX: (input: string) => string;
-export declare const didNoZeroX: (input: string) => string;

package/dist/node/utils/GeneratorHelpers.d.ts

@@ -1 +0,0 @@
-export declare function generateId(length?: number): string;

package/dist/node/utils/PromiseResolver.d.ts

@@ -1,3 +0,0 @@
-export declare const objectPromiseAll: (obj: {
-    [key: string]: Promise<any>;
-}) => Promise<any>;

package/dist/node/utils/SubscribableObserver.d.ts

@@ -1,12 +0,0 @@
-export declare class SubscribableObserver<T, P> {
-    completed: boolean;
-    private subscriptions;
-    subscribe(onNext?: (next: T) => void, onComplete?: (complete: P) => void, onError?: (error: any) => void): {
-        unsubscribe: () => boolean;
-    };
-    next(next?: T): void;
-    complete(resolve?: P): void;
-    error(error?: any): void;
-    private emit;
-    private unsubscribe;
-}

package/dist/node/utils/SubscribablePromise.d.ts

@@ -1,14 +0,0 @@
-import { SubscribableObserver } from './SubscribableObserver';
-export declare class SubscribablePromise<T extends any, P extends any> {
-    private observer;
-    private promise;
-    constructor(executor: (observer: SubscribableObserver<T, P>) => void | Promise<P>);
-    subscribe(onNext: (next: T) => void): {
-        unsubscribe: () => boolean;
-    };
-    next(onNext: (next: T) => void): this;
-    then(onfulfilled?: (value: P) => any, onrejected?: (error: any) => any): Promise<any> & this;
-    catch(onrejected?: (error: any) => any): Promise<any> & this;
-    finally(onfinally?: () => any): Promise<P> & this;
-    private init;
-}

package/dist/node/utils/Timeout.d.ts

@@ -1 +0,0 @@
-export default function timeoutSignal(timeout: number): any;

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

@@ -1,9 +0,0 @@
-export * from './PromiseResolver';
-export * from './Logger';
-export * from './ConversionTypeHelpers';
-export * from './GeneratorHelpers';
-export * from './SubscribablePromise';
-export * from './SubscribableObserver';
-export * from './ContractUtils';
-export * from './AssetResolverHelper';
-export * from './Datatokens';