@oceanprotocol/lib 1.0.0-next.1 → 1.0.0-next.13

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

@@ -0,0 +1,119 @@
+import { DDO } from './DDO/DDO';
+export interface AssetNft {
+    /**
+     * Contract address of the deployed ERC721 NFT contract.
+     * @type {string}
+     */
+    address: string;
+    /**
+     * Name of NFT set in contract.
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Symbol of NFT set in contract.
+     * @type {string}
+     */
+    symbol: string;
+    /**
+     * ETH account address of the NFT owner.
+     * @type {string}
+     */
+    owner: string;
+    /**
+     * State of the asset reflecting the NFT contract value.
+     * 0	Active.
+     * 1	End-of-life.
+     * 2	Deprecated (by another asset).
+     * 3	Revoked by publisher.
+     * 4	Ordering is temporary disabled.
+     * @type {number}
+     */
+    state: 0 | 1 | 2 | 3 | 4;
+    /**
+     * Contains the date of NFT creation.
+     * @type {string}
+     */
+    created: string;
+    /**
+     * NFT token URI.
+     * @type {string}
+     */
+    tokenURI: string;
+}
+export interface Purgatory {
+    /**
+     * If `true`, asset is in purgatory.
+     * @type {boolean}
+     */
+    state: boolean;
+    /**
+     * If asset is in purgatory, contains the reason for being there as defined in `list-purgatory`.
+     * @type {string}
+     */
+    reason: string;
+}
+export interface AssetDatatoken {
+    /**
+     * Contract address of the deployed ERC20 contract.
+     * @type {string}
+     */
+    address: string;
+    /**
+     * Name of NFT set in contract.
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Symbol of NFT set in contract.
+     * @type {string}
+     */
+    symbol: string;
+    /**
+     * ID of the service the datatoken is attached to.
+     * @type {string}
+     */
+    serviceId: string;
+}
+export interface AssetLastEvent {
+    tx: string;
+    block: number;
+    from: string;
+    contract: string;
+    datetime: string;
+}
+export interface Asset extends DDO {
+    /**
+     * Contains information about the ERC721 NFT contract which represents the intellectual property of the publisher.
+     * @type {string}
+     */
+    nft: AssetNft;
+    /**
+     * Contains information about the ERC20 datatokens attached to asset services.
+     * @type {string}
+     */
+    datatokens: AssetDatatoken[];
+    /**
+     * Contains information about the last transaction that created or updated the DDO.
+     * @type {string}
+     */
+    event: AssetLastEvent;
+    /**
+     * The stats section contains different statistics fields.
+     * @type {string}
+     */
+    stats: {
+        /**
+         * How often an asset was consumed, meaning how often it was either downloaded or used as part of a compute job.
+         * @type {string}
+         */
+        consume: number;
+    };
+    /**
+     * Contains information about an asset's purgatory status defined in
+     * [`list-purgatory`](https://github.com/oceanprotocol/list-purgatory).
+     * Marketplace interfaces are encouraged to prevent certain user actions like adding liquidity on assets in purgatory.
+     * @type {Purgatory}
+     */
+    purgatory: Purgatory;
+}

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

@@ -1,5 +1,22 @@
 import { Metadata, MetadataAlgorithm } from './DDO/Metadata';
 export declare type ComputeResultType = 'algorithmLog' | 'output';
+export interface ComputeEnvironment {
+    id: string;
+    cpuNumber: number;
+    cpuType: string;
+    gpuNumber: number;
+    gpuType: string;
+    ramGB: number;
+    diskGB: number;
+    priceMin: number;
+    desc: string;
+    currentJobs: number;
+    maxJobs: number;
+    consumerAddress: string;
+    storageExpiry: number;
+    maxJobDuration: number;
+    lastSeen: number;
+}
 export interface ComputeResult {
     filename: string;
     filesize: number;

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

@@ -0,0 +1,58 @@
+import { Service } from './Service';
+import { Metadata } from './Metadata';
+import { Credentials } from './Credentials';
+import { Event } from './Event';
+/**
+ * DID Descriptor Object.
+ * Contains metadata about the asset, and define access in at least one service.
+ */
+export interface DDO {
+    /**
+     * Contexts used for validation.
+     * @type {string[]}
+     */
+    '@context': string[];
+    /**
+     * DID, descentralized ID.
+     * Computed as sha256(address of ERC721 contract + chainId)
+     * @type {string}
+     */
+    id: string;
+    /**
+     * Version information in SemVer notation
+     * referring to the DDO spec version
+     * @type {string}
+     */
+    version: string;
+    /**
+     * NFT contract address
+     * @type {string}
+     */
+    nftAddress: string;
+    /**
+     * ChainId of the network the DDO was published to.
+     * @type {number}
+     */
+    chainId: number;
+    /**
+     * Stores an object describing the asset.
+     * @type {Metadata}
+     */
+    metadata: Metadata;
+    /**
+     * Stores an array of services defining access to the asset.
+     * @type {Service[]}
+     */
+    services: Service[];
+    /**
+     * Describes the credentials needed to access a dataset
+     * in addition to the services definition.
+     * @type {Credentials}
+     */
+    credentials?: Credentials;
+    /**
+     * Describes the event of last metadata event
+     * @type {Event}
+     */
+    event?: Event;
+}

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

@@ -0,0 +1,27 @@
+export interface Event {
+    /**
+     * TX id of the last create/update
+     * @type {string}
+     */
+    txid?: string;
+    /**
+     * Block of txid
+     * @type {number}
+     */
+    block?: number;
+    /**
+     * Sender of tx
+     * @type {String}
+     */
+    from?: string;
+    /**
+     * Contract
+     * @type {String}
+     */
+    contract?: string;
+    /**
+     * datetime of tx
+     * @type {String}
+     */
+    datetime?: string;
+}

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

@@ -0,0 +1,126 @@
+export interface MetadataAlgorithm {
+    /**
+     * Language used to implement the software.
+     * @type {string}
+     */
+    language?: string;
+    /**
+     * Version of the software preferably in SemVer notation.
+     * @type {string}
+     */
+    version?: string;
+    /**
+     * Rawcode
+     * @type {string}
+     */
+    rawcode?: string;
+    /**
+     * Object describing the Docker container image.
+     * @type {Object}
+     */
+    container: {
+        /**
+         * The command to execute, or script to run inside the Docker image.
+         * @type {string}
+         */
+        entrypoint: string;
+        /**
+         * Name of the Docker image.
+         * @type {string}
+         */
+        image: string;
+        /**
+         * Tag of the Docker image.
+         * @type {string}
+         */
+        tag: string;
+        /**
+         * Checksum of the Docker image.
+         * @type {string}
+         */
+        checksum: string;
+    };
+}
+export interface Metadata {
+    /**
+     * Contains the date of publishing in ISO Date Time
+     * @type {string}
+     */
+    created: string;
+    /**
+     * Contains the the date of last update in ISO Date Time
+     * @type {string}
+     */
+    updated: string;
+    /**
+     * Descriptive name or title of the asset.
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Details of what the resource is.
+     * @type {string}
+     */
+    description: string;
+    /**
+     * Asset type. Includes "dataset" (e.g. csv file), "algorithm" (e.g. Python script).
+     * Each type needs a different subset of metadata attributes.
+     * @type {'dataset' | 'algorithm'}
+     */
+    type: 'dataset' | 'algorithm';
+    /**
+     * Name of the entity generating this data (e.g. Tfl, Disney Corp, etc.).
+     * @type {string}
+     */
+    author: string;
+    /**
+     * Short name referencing the license of the asset.
+     * If it’s not specified, the following value will be added: “No License Specified”.
+     * @type {string}
+     */
+    license: string;
+    /**
+     * Mapping of URL strings for data samples, or links to find out more information.
+     * Links may be to either a URL or another asset.
+     * @type {string[]}
+     */
+    links?: string[];
+    /**
+     * Mapping of URL strings for data samples, or links to find out more information.
+     * Links may be to either a URL or another asset.
+     * @type {string[]}
+     */
+    tags?: string[];
+    /**
+     * The party holding the legal copyright. Empty by default.
+     * @type {string}
+     */
+    copyrightHolder?: string;
+    /**
+     *The language of the content. Use one of the language codes from the IETF BCP 47 standard
+     * @type {string}
+     */
+    contentLanguage?: string;
+    /**
+     * Information about asset of typealgorithm
+     * @type {MetadataAlgorithm}
+     */
+    algorithm?: MetadataAlgorithm;
+    /**
+     * Stores additional information, this is customizable by publisher
+     * @type {any}
+     */
+    additionalInformation?: any;
+}
+export interface MetadataProof {
+    validatorAddress?: string;
+    r?: string;
+    s?: string;
+    v?: number;
+}
+export interface ValidateMetadata {
+    valid: Boolean;
+    errors?: Object;
+    hash?: string;
+    proof?: MetadataProof;
+}

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

@@ -0,0 +1,124 @@
+export interface PublisherTrustedAlgorithm {
+    /**
+     * The DID of the algorithm which is trusted by the publisher.
+     * @type {string}
+     */
+    did: string;
+    /**
+     * Hash of algorithm’s files section.
+     * @type {string}
+     */
+    filesChecksum: string;
+    /**
+     * Hash of algorithm’s metadata.algorithm.container section.
+     * @type {string}
+     */
+    containerSectionChecksum: string;
+}
+export interface ServiceComputeOptions {
+    /**
+     * Namespaced used for the compute job.
+     * @type {string}
+     */
+    namespace: string;
+    /**
+     * Maximum number of CPUs allocated for a job
+     * @type {number}
+     */
+    cpu?: number;
+    /**
+     * Maximum number of GPUs allocated for a job
+     * @type {number}
+     */
+    gpu?: number;
+    /**
+     * Type of GPU (if any)
+     * @type {string}
+     */
+    gpuType?: string;
+    /**
+     * Maximum amount of memory allocated for a job.
+     * You can express memory as a plain integer or as a fixed-point number using one of these suffixes: E, P, T, G, M, k.
+     * You can also use the power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.
+     * For example, the following represent roughly the same value: 128974848, 129e6, 129M, 123Mi
+     * @type {string}
+     */
+    memory?: string;
+    /**
+     * Amount of disk space allocated.
+     * You can express it as a plain integer or as a fixed-point number using one of these suffixes: E, P, T, G, M, k.
+     * You can also use the power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.
+     * @type {string}
+     */
+    volumeSize?: string;
+    /**
+     * If true, any passed raw text will be allowed to run.
+     * Useful for an algorithm drag & drop use case, but increases risk of data escape through malicious user input.
+     * Should be false by default in all implementations.
+     * @type {boolean}
+     */
+    allowRawAlgorithm: boolean;
+    /**
+     * If true, the algorithm job will have network access.
+     * @type {boolean}
+     */
+    allowNetworkAccess: boolean;
+    /**
+     * If empty, then any published algorithm is allowed.
+     * Otherwise, only published algorithms by some publishers are allowed
+     * @type {string[]}
+     */
+    publisherTrustedAlgorithmPublishers: string[];
+    /**
+     * If empty, then any published algorithm is allowed. (see below)
+     * @type {PublisherTrustedAlgorithm[]}
+     */
+    publisherTrustedAlgorithms: PublisherTrustedAlgorithm[];
+}
+export interface Service {
+    /**
+     * Unique ID
+     * @type {string}
+     */
+    id: string;
+    /**
+     * Type of service (access, compute, wss.
+     * @type {string}
+     */
+    type: 'access' | 'compute' | string;
+    /**
+     * Encrypted file URLs.
+     * @type {string}
+     */
+    files: string;
+    /**
+     * Datatoken address
+     * @type {string}
+     */
+    datatokenAddress: string;
+    /**
+     * Provider URL (schema + host).
+     * @type {string}
+     */
+    serviceEndpoint: string;
+    /**
+     * Describing how long the service can be used after consumption is initiated.
+     * @type {number}
+     */
+    timeout: number;
+    /**
+     * Service friendly name
+     * @type {string}
+     */
+    name?: string;
+    /**
+     * Service description
+     * @type {string}
+     */
+    description?: string;
+    /**
+     * If service is of typecompute, holds information about the compute-related privacy settings & resources.
+     * @type {ServiceComputeOptions}
+     */
+    compute?: ServiceComputeOptions;
+}

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

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

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

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

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

@@ -0,0 +1,38 @@
+export interface FileMetadata {
+    /**
+     * File URL.
+     * @type {string}
+     */
+    type: string;
+    /**
+     * File format, if applicable.
+     * @type {string}
+     * @example "text/csv"
+     */
+    contentType?: string;
+    /**
+     * File content length.
+     * @type {[type]}
+     */
+    contentLength?: string;
+    /**
+     * File index.
+     * @type {number}
+     */
+    index?: number;
+    /**
+     * File URL.
+     * @type {string}
+     */
+    url?: string;
+    /**
+     * HTTP method used
+     * @type {string}
+     */
+    method?: string;
+    /**
+     * check if file exists
+     * @type {boolean}
+     */
+    valid?: boolean;
+}

package/dist/src/{src/interfaces/FixedRateInterface.d.ts → @types/FixedPrice.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/{src/interfaces/PoolInterface.d.ts → @types/Pool.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/{src/@types → @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/@types/Router.d.ts

@@ -0,0 +1,59 @@
+export interface Operation {
+    /**
+     * used only for FixedRate or Dispenser, but needs to be filled even for pool
+     * @type {string}
+     */
+    exchangeIds: string;
+    /**
+     * pool Address
+     * @type {string}
+     */
+    source: string;
+    /**
+     * operation:
+     * 0 - swapExactAmountIn
+     * 1 - swapExactAmountOut
+     * 2 - FixedRateExchange
+     * 3 - Dispenser
+     * @type {number}
+     */
+    operation: number;
+    /**
+     * token in address
+     * @type {string}
+     */
+    tokenIn: string;
+    /**
+     * when swapExactAmountIn is EXACT amount IN
+     * expressed in Wei
+     * @type {string | number}
+     */
+    amountsIn: string | number;
+    /**
+     * token out address
+     * @type {string}
+     */
+    tokenOut: string;
+    /**
+     * when swapExactAmountIn is MIN amount OUT
+     * expressed in Wei
+     * @type {string | number}
+     */
+    amountsOut: string | number;
+    /**
+     * max price (only for pools)
+     * expressed in Wei
+     * @type {string | number}
+     */
+    maxPrice: string | number;
+    /**
+     * swap fee amount
+     * @type {string}
+     */
+    swapMarketFee: string;
+    /**
+     * market fee address to receive fees
+     * @type {string}
+     */
+    marketFeeAddress: string;
+}

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

@@ -6,3 +6,9 @@ export * from './DDO/Metadata';
 export * from './FileMetadata';
 export * from './Compute';
 export * from './Provider';
+export * from './FixedPrice';
+export * from './Pool';
+export * from './Erc20';
+export * from './Erc721';
+export * from './Dispenser';
+export * from './Router';

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

@@ -0,0 +1,32 @@
+import { Asset, DDO, ValidateMetadata } from '../@types/';
+export declare class Aquarius {
+    aquariusURL: any;
+    /**
+     * Instantiate Aquarius
+     * @param {String} aquariusURL
+     */
+    constructor(aquariusURL: string);
+    /** Resolves a DID
+     * @param {string} did
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<Asset>} Asset
+     */
+    resolve(did: string, signal?: AbortSignal): Promise<Asset>;
+    /**
+     * Blocks until Aqua will cache the did (or the update for that did) or timeouts
+     
+     * @param {string} did DID of the asset.
+     * @param {string} txid used when the did exists and we expect an update with that txid.
+       * @param {AbortSignal} signal abort signal
+     * @return {Promise<DDO>} DDO of the asset.
+     */
+    waitForAqua(did: string, txid?: string, signal?: AbortSignal): Promise<Asset>;
+    /**
+     * Validate DDO content
+     * @param {DDO} ddo DID Descriptor Object content.
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<ValidateMetadata>}.
+     */
+    validate(ddo: DDO, signal?: AbortSignal): Promise<ValidateMetadata>;
+}
+export default Aquarius;