@oceanprotocol/lib 3.4.1 → 3.4.3

package/dist/types/contracts/ve/VeAllocate.d.ts

@@ -0,0 +1,38 @@
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { ReceiptOrEstimate, AbiItem } from '../../@types';
+/**
+ * Provides an interface for veOcean contract
+ */
+export declare class VeAllocate extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem[];
+    /**
+     * set a specific percentage of veOcean to a specific nft
+     * Maximum allocated percentage is 10000, so 1% is specified as 100
+     * @param {String} amount Percentage used
+     * @param {String} nft NFT address to allocate to
+     * @param {String} chainId chainId of NFT
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    setAllocation<G extends boolean = false>(amount: string, nft: string, chainId: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * set specific percetage of veOcean to multiple nfts
+     * Maximum allocated percentage is 10000, so 1% is specified as 100
+     * @param {String[]} amount Array of percentages used
+     * @param {String[]} nft Array of NFT addresses
+     * @param {String[]} chainId Array of chainIds
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    setBatchAllocation<G extends boolean = false>(amount: string[], nft: string[], chainId: number[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** Get totalAllocation for address
+     * @param {String} userAddress user address
+     * @return {Promise<number>}
+     */
+    getTotalAllocation(userAddress: string): Promise<number>;
+    /** Get getveAllocation for address, nft, chainId
+     * @param {String} userAddress user address
+     * @param {String} nft NFT address to allocate to
+     * @param {String} chainId chainId of NFT
+     * @return {Promise<number>}
+     */
+    getVeAllocation(userAddress: string, nft: string, chainId: string): Promise<number>;
+}

package/dist/types/contracts/ve/VeFeeDistributor.d.ts

@@ -0,0 +1,29 @@
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { ReceiptOrEstimate, AbiItem } from '../../@types';
+/**
+ * Provides an interface for veOcean contract
+ */
+export declare class VeFeeDistributor extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem[];
+    /**
+     * Claim fees for `userAddress`
+     * Each call to claim look at a maximum of 50 user veOCEAN points.
+           For accounts with many veOCEAN related actions, this function
+           may need to be called more than once to claim all available
+           fees. In the `Claimed` event that fires, if `claim_epoch` is
+           less than `max_epoch`, the account may claim again
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    claim<G extends boolean = false>(estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Make multiple fee claims in a single call
+      Used to claim for many accounts at once, or to make
+           multiple claims for the same address when that address
+           has significant veOCEAN history
+     * @param {String} addresses array of addresses to claim
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    claimMany<G extends boolean = false>(addresses: string[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+}

package/dist/types/contracts/ve/VeFeeEstimate.d.ts

@@ -0,0 +1,14 @@
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { AbiItem } from '../../@types';
+/**
+ * Provides an interface for veOcean contract
+ */
+export declare class VeFeeEstimate extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem[];
+    /**
+     * estimateClaim
+     * @param {String} userAddress user address
+     * @return {Promise<string>}
+     */
+    estimateClaim(userAddress: string): Promise<string>;
+}

package/dist/types/contracts/ve/VeOcean.d.ts

@@ -0,0 +1,68 @@
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { ReceiptOrEstimate, AbiItem } from '../../@types';
+/**
+ * Provides an interface for veOcean contract
+ */
+export declare class VeOcean extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem[];
+    /**
+     * Deposit `amount` tokens for `userAddress` and lock until `unlockTime`
+     * @param {String} amount Amount of tokens to be locked
+     * @param {Number} unlockTime Timestamp for unlock
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    lockTokens<G extends boolean = false>(amount: string, unlockTime: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Deposit `amount` tokens for `toAddress` and add to the existing lock
+     * Anyone (even a smart contract) can deposit for someone else, but cannot extend their locktime and deposit for a brand new user
+     * @param {String} toAddress user address to deposit for
+     * @param {String} amount Amount of tokens to be locked
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    depositFor<G extends boolean = false>(toAddress: string, amount: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Deposit `amount` additional tokens for `userAddress` without modifying the unlock time
+     * @param {String} amount Amount of tokens to be locked
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    increaseAmount<G extends boolean = false>(amount: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Extend the unlock time for `userAddress` to `unlockTime`
+     * @param {Number} unlockTime Timestamp for new unlock time
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    increaseUnlockTime<G extends boolean = false>(unlockTime: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Withdraw all tokens for `userAddress`
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    withdraw<G extends boolean = false>(estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** Get voting power for address
+     * @param {String} userAddress user address
+     * @return {Promise<number>}
+     */
+    getVotingPower(userAddress: string): Promise<number>;
+    /** Get locked balance
+     * @param {String} userAddress user address
+     * @return {Promise<string>}
+     */
+    getLockedAmount(userAddress: string): Promise<string>;
+    /** Get untilLock for address
+     * @param {String} userAddress user address
+     * @return {Promise<number>}
+     */
+    lockEnd(userAddress: string): Promise<number>;
+    /** Get total supply
+     * @return {Promise<number>}
+     */
+    totalSupply(): Promise<string>;
+    /** Get token
+     * @return {Promise<string>}
+     */
+    getToken(): Promise<string>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './@types';
+export * from './config';
+export * from './contracts';
+export * from './services';
+export * from './utils';

package/dist/types/services/Aquarius.d.ts

@@ -0,0 +1,53 @@
+import { Asset, DDO, ValidateMetadata } from '../@types';
+export interface SearchQuery {
+    from?: number;
+    size?: number;
+    query: any;
+    sort?: {
+        [jsonPath: string]: string;
+    };
+    aggs?: any;
+}
+export declare class Aquarius {
+    aquariusURL: string;
+    /**
+     * Instantiate Aquarius
+     * @param {String} aquariusURL
+     */
+    constructor(aquariusURL: string);
+    /** Resolves a DID
+     * @param {string} did DID of the asset.
+     * @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<Asset>} 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>;
+    /**
+     * Search over the DDOs using a query.
+     * @param {string} did DID of the asset
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<QueryResult>}
+     */
+    getAssetMetadata(did: string, signal?: AbortSignal): Promise<any>;
+    /**
+     * Search over the DDOs using a query.
+     * @param  {SearchQuery} query Query to filter the DDOs.
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<QueryResult>}
+     */
+    querySearch(query: SearchQuery, signal?: AbortSignal): Promise<any>;
+}

package/dist/types/services/Provider.d.ts

@@ -0,0 +1,197 @@
+import { Signer } from 'ethers';
+import { Arweave, FileInfo, ComputeJob, ComputeOutput, ComputeAlgorithm, ComputeAsset, ComputeEnvironment, ProviderInitialize, ProviderComputeInitializeResults, ServiceEndpoint, UrlFile, UserCustomParameters, Ipfs, Smartcontract, GraphqlQuery } from '../@types';
+export declare class Provider {
+    /**
+     * Returns the provider endpoints
+     * @param {string} providerUri - the provider url
+     * @return {Promise<any>}
+     */
+    getEndpoints(providerUri: string): Promise<any>;
+    /**
+     * This function returns the endpoint URL for a given service name.
+     * @param {ServiceEndpoint[]} servicesEndpoints - The array of service endpoints
+     * @param {string} serviceName - The name of the service
+     * @returns {ServiceEndpoint} The endpoint URL for the given service name
+     */
+    getEndpointURL(servicesEndpoints: ServiceEndpoint[], serviceName: string): ServiceEndpoint;
+    /**
+     * This function returns an array of service endpoints for a given provider endpoint.
+     * @param {string} providerEndpoint - The provider endpoint
+     * @param {any} endpoints - The endpoints object
+     * @returns {ServiceEndpoint[]} An array of service endpoints
+     */
+    getServiceEndpoints(providerEndpoint: string, endpoints: any): Promise<ServiceEndpoint[]>;
+    /**
+     * Get current nonce from the provider.
+     * @param {string} providerUri provider uri address
+     * @param {string} consumerAddress Publisher address
+     * @param {AbortSignal} signal abort signal
+     * @param {string} providerEndpoints Identifier of the asset to be registered in ocean
+     * @param {string} serviceEndpoints document description object (DDO)=
+     * @return {Promise<string>} urlDetails
+     */
+    getNonce(providerUri: string, consumerAddress: string, signal?: AbortSignal, providerEndpoints?: any, serviceEndpoints?: ServiceEndpoint[]): Promise<number>;
+    /**
+     * Sign a provider request with a signer.
+     * @param {Signer} signer - The signer to use.
+     * @param {string} message - The message to sign.
+     * @returns {Promise<string>} A promise that resolves with the signature.
+     */
+    signProviderRequest(signer: Signer, message: string): Promise<string>;
+    /**
+     * Encrypt data using the Provider's own symmetric key
+     * @param {string} data data in json format that needs to be sent , it can either be a DDO or a File array
+     * @param {number} chainId network's id so provider can choose the corresponding Signer object
+     * @param {string} providerUri provider uri address
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<string>} urlDetails
+     */
+    encrypt(data: any, chainId: number, providerUri: string, signal?: AbortSignal): Promise<string>;
+    /**
+     * Get file details for a given DID and service ID.
+     * @param {string} did - The DID to check.
+     * @param {string} serviceId - The service ID to check.
+     * @param {string} providerUri - The URI of the provider.
+     * @param {boolean} [withChecksum=false] - Whether or not to include a checksum.
+     * @param {AbortSignal} [signal] - An optional abort signal.
+     * @returns {Promise<FileInfo[]>} A promise that resolves with an array of file info objects.
+     */
+    checkDidFiles(did: string, serviceId: string, providerUri: string, withChecksum?: boolean, signal?: AbortSignal): Promise<FileInfo[]>;
+    /**
+     * Get File details (if possible)
+     * @param {UrlFile | Arweave | Ipfs | GraphqlQuery | Smartcontract} file one of the supported file structures
+     * @param {string} providerUri uri of the provider that will be used to check the file
+     * @param {boolean} [withChecksum=false] - Whether or not to include a checksum.
+     * @param {AbortSignal} [signal] - An optional abort signal.
+     * @returns {Promise<FileInfo[]>} A promise that resolves with an array of file info objects.
+     */
+    getFileInfo(file: UrlFile | Arweave | Ipfs | GraphqlQuery | Smartcontract, providerUri: string, withChecksum?: boolean, signal?: AbortSignal): Promise<FileInfo[]>;
+    /**
+     * Returns compute environments from a provider.
+     * @param {string} providerUri - The URI of the provider.
+     * @param {AbortSignal} [signal] - An optional abort signal.
+     * @returns {Promise<{[chainId: number]: ComputeEnvironment[]}>} A promise that resolves with an object containing compute environments for each chain ID.
+     */
+    getComputeEnvironments(providerUri: string, signal?: AbortSignal): Promise<{
+        [chainId: number]: ComputeEnvironment[];
+    }>;
+    /**
+     * Initializes the provider for a service request.
+     * @param {string} did - The asset DID .
+     * @param {string} serviceId - The asset service ID.
+     * @param {number} fileIndex - The file index.
+     * @param {string} consumerAddress - The consumer address.
+     * @param {string} providerUri - The URI of the provider.
+     * @param {AbortSignal} [signal] - The abort signal if any.
+     * @param {UserCustomParameters} [userCustomParameters] - The custom parameters if any.
+     * @param {string} [computeEnv] - The compute environment if any.
+     * @param {number} [validUntil] - The validity time if any.
+     * @returns {Promise<ProviderInitialize>} A promise that resolves with ProviderInitialize response.
+     */
+    initialize(did: string, serviceId: string, fileIndex: number, consumerAddress: string, providerUri: string, signal?: AbortSignal, userCustomParameters?: UserCustomParameters, computeEnv?: string, validUntil?: number): Promise<ProviderInitialize>;
+    /** Initializes the provider for a compute request.
+     * @param {ComputeAsset[]} assets The datasets array to initialize compute request.
+     * @param {ComputeAlgorithmber} algorithm The algorithm to use.
+     * @param {string} computeEnv The compute environment.
+     * @param {number} validUntil  The job expiration date.
+     * @param {string} providerUri The provider URI.
+     * @param {string} accountId caller address
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<ProviderComputeInitialize>} ProviderComputeInitialize data
+     */
+    initializeCompute(assets: ComputeAsset[], algorithm: ComputeAlgorithm, computeEnv: string, validUntil: number, providerUri: string, accountId: string, signal?: AbortSignal): Promise<ProviderComputeInitializeResults>;
+    /**
+     * Gets the download URL.
+     * @param {string} did - The DID.
+     * @param {string} serviceId - The service ID.
+     * @param {number} fileIndex - The file index.
+     * @param {string} transferTxId - The transfer transaction ID.
+     * @param {string} providerUri - The provider URI.
+     * @param {Signer} signer - The signer.
+     * @param {UserCustomParameters} userCustomParameters - The user custom parameters.
+     * @returns {Promise<any>} The download URL.
+     */
+    getDownloadUrl(did: string, serviceId: string, fileIndex: number, transferTxId: string, providerUri: string, signer: Signer, userCustomParameters?: UserCustomParameters): Promise<any>;
+    /** Instruct the provider to start a compute job
+     * @param {string} providerUri The provider URI.
+     * @param {Signer} signer The consumer signer object.
+     * @param {string} computeEnv The compute environment.
+     * @param {ComputeAsset} dataset The dataset to start compute on
+     * @param {ComputeAlgorithm} algorithm The algorithm to start compute with.
+     * @param {AbortSignal} signal abort signal
+     * @param {ComputeAsset[]} additionalDatasets The additional datasets if that is the case.
+     * @param {ComputeOutput} output The compute job output settings.
+     * @return {Promise<ComputeJob | ComputeJob[]>} The compute job or jobs.
+     */
+    computeStart(providerUri: string, consumer: Signer, computeEnv: string, dataset: ComputeAsset, algorithm: ComputeAlgorithm, signal?: AbortSignal, additionalDatasets?: ComputeAsset[], output?: ComputeOutput): Promise<ComputeJob | ComputeJob[]>;
+    /** Instruct the provider to Stop the execution of a to stop a compute job.
+     * @param {string} did the asset did
+     * @param {string} consumerAddress The consumer address.
+     * @param {string} jobId the compute job id
+     * @param {string} providerUri The provider URI.
+     * @param {Signer} signer The consumer signer object.
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<ComputeJob | ComputeJob[]>}
+     */
+    computeStop(did: string, consumerAddress: string, jobId: string, providerUri: string, signer: Signer, agreementId?: string, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
+    /** Get compute status for a specific jobId/documentId/owner.
+     * @param {string} providerUri The URI of the provider we want to query
+     * @param {string} consumerAddress The consumer ethereum address
+     * @param {string} jobId The ID of a compute job.
+     * @param {string} agreementId The ID of the service agreement (tx id)
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<ComputeJob | ComputeJob[]>}
+     */
+    computeStatus(providerUri: string, consumerAddress: string, jobId?: string, agreementId?: string, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
+    /** Get compute result url
+     * @param {string} providerUri The URI of the provider we want to query
+     * @param {Signer} consumer consumer Signer wallet object
+     * @param {string} jobId The ID of a compute job.
+     * @param {number} index Result index
+     * @return {Promise<string>}
+     */
+    getComputeResultUrl(providerUri: string, consumer: Signer, jobId: string, index: number): Promise<string>;
+    /** Deletes a compute job.
+     * @param {string} did asset did
+     * @param {Signer} consumer consumer Signer wallet object
+     * @param {string} jobId the compute job ID
+     * @param {string} providerUri The URI of the provider we want to query
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<ComputeJob | ComputeJob[]>}
+     */
+    computeDelete(did: string, consumer: Signer, jobId: string, providerUri: string, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
+    /** Check for a valid provider at URL
+     * @param {String} url provider uri address
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<boolean>} valid or not
+     */
+    isValidProvider(url: string, signal?: AbortSignal): Promise<boolean>;
+    /**
+     * Private method that removes the leading 0x from a string.
+     * @param {string} input - The input string.
+     * @returns The transformed string.
+     */
+    private noZeroX;
+    /**
+     * Private method that removes the leading 0x from a string.
+     * @param {string} input - The input string.
+     * @param {boolean} zeroOutput - Whether to include 0x in the output if the input is valid and zeroOutput is true.
+     * @returns The transformed string.
+     */
+    private zeroXTransformer;
+    /**
+     * Private method that matches an input string against a regular expression and returns the first capture group.
+     * @param {string} input - The input string to match.
+     * @param {RegExp} regexp - The regular expression to match against.
+     * @param {string} conversorName - The name of the method calling this function.
+     * @returns An object with two properties: `valid` (a boolean indicating whether the input matched the regular expression) and `output` (the first capture group of the match, or the original input if there was no match).
+     */
+    private inputMatch;
+    /**
+     * Private method that fetches data from a URL using the GET method.
+     * @param {string} url - The URL to fetch data from.
+     * @returns A Promise that resolves to a Response object.
+     */
+    private getData;
+}
+export declare const ProviderInstance: Provider;

package/dist/types/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Aquarius';
+export * from './Provider';

package/dist/types/utils/Assets.d.ts

@@ -0,0 +1,56 @@
+import { Signer } from 'ethers';
+import { Aquarius } from '../services/Aquarius';
+export declare const DEVELOPMENT_CHAIN_ID = 8996;
+export declare function useOasisSDK(network: string | number): boolean;
+/**
+ * Get the artifacts address from the address.json file
+ * either from the env or from the ocean-contracts dir
+ * @returns data or null
+ */
+export declare function getOceanArtifactsAdresses(): any;
+/**
+ * Get the artifacts address from the address.json file, for the given chain
+ * either from the env or from the ocean-contracts dir, safer than above, because sometimes the network name
+ * is mispeled, best example "optimism_sepolia" vs "optimism-sepolia"
+ * @returns data or null
+ */
+export declare function getOceanArtifactsAdressesByChainId(chain: number): any;
+/**
+ * Use this function to accurately calculate the template index, and also checking if the template is active
+ * @param owner the signer account
+ * @param nftContractAddress the nft contract address, usually artifactsAddresses.ERC721Factory
+ * @param template the template ID or template address (from smart contract getId() function)
+ * @returns index of the template on the list
+ */
+export declare function calculateActiveTemplateIndex(owner: Signer, nftContractAddress: string, // addresses.ERC721Factory,
+template: string | number): Promise<number>;
+/**
+ *
+ * @param name asset name
+ * @param symbol asse symbol
+ * @param owner owner address
+ * @param assetUrl asset url, if present and confidential evm, add it to token create params
+ * @param templateIDorAddress either template address or id
+ * @param ddo ddo
+ * @param encryptDDO encrypt or not?
+ * @param providerUrl the provider URL
+ * @param providerFeeToken the provider fee token
+ * @param aquariusInstance aquarius, could be node instance url
+ * @param allowAccessList?: string,
+ * @param denyAccessList?: string
+ * @returns ddo id as string
+ */
+export declare function createAsset(name: string, symbol: string, owner: Signer, assetUrl: any, // files object
+templateIDorAddress: string | number, // If string, it's template address , otherwise, it's templateId
+ddo: any, encryptDDO: boolean, // default is true
+providerUrl: string, providerFeeToken: string, aquariusInstance: Aquarius, accessListFactory?: string, // access list factory address
+allowAccessList?: string, // allow list address
+denyAccessList?: string): Promise<string>;
+/**
+ * deploy new access list factory if needed
+ * @param accessListFactory accessListFactory address
+ * @param owner owner account
+ * @param addressesList list of addresses to deploy
+ * @returns accessListFactory address
+ */
+export declare function createAccessListFactory(accessListFactory: string, owner: Signer, addressesList?: string[]): Promise<any>;

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

@@ -0,0 +1,4 @@
+export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const GASLIMIT_DEFAULT = 1000000;
+export declare const MAX_UINT_256 = "115792089237316195423570985008687907853269984665640564039457584007913129639934";
+export declare const FEE_HISTORY_NOT_SUPPORTED = "Returned error: Method eth_feeHistory not supported.";

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

@@ -0,0 +1,46 @@
+import { Signer, providers, Contract, ContractFunction, BigNumber } from 'ethers';
+import { Config } from '../config';
+export declare function setContractDefaults(contract: Contract, config: Config): Contract;
+/**
+ * Asynchronous function that returns a fair gas price based on the current gas price and a multiplier.
+ * @param {Signer} signer - The signer object to use for fetching the current gas price.
+ * @param {number} gasFeeMultiplier - The multiplier to apply to the current gas price. If not provided, the current gas price is returned as a string.
+ * @returns A Promise that resolves to a string representation of the fair gas price.
+ */
+export declare function getFairGasPrice(signer: Signer, gasFeeMultiplier: number): Promise<string>;
+/**
+ * Asynchronous function that returns the number of decimal places for a given token.
+ * @param {Signer} signer - The signer object to use for fetching the token decimals.
+ * @param {string} token - The address of the token contract.
+ * @returns A Promise that resolves to the number of decimal places for the token.
+ */
+export declare function getTokenDecimals(signer: Signer, token: string): Promise<any>;
+/**
+ * Converts an amount of units to tokens
+ * @param {Signer} signer -  The signer object to use.
+ * @param {string} token - The token to convert
+ * @param {string} amount - The amount of units to convert
+ * @param {number} [tokenDecimals] - The number of decimals in the token
+ * @returns {Promise<string>} - The converted amount in tokens
+ */
+export declare function unitsToAmount(signer: Signer, token: string, amount: string, tokenDecimals?: number): Promise<string>;
+/**
+ * Converts an amount of tokens to units
+ * @param {Signer} signer -  The signer object to use.
+ * @param {string} token - The token to convert
+ * @param {string} amount - The amount of tokens to convert
+ * @param {number} [tokenDecimals] - The number of decimals of the token
+ * @returns {Promise<string>} - The converted amount in units
+ */
+export declare function amountToUnits(signer: Signer, token: string, amount: string, tokenDecimals?: number): Promise<string>;
+export declare function getEventFromTx(txReceipt: any, eventName: any): any;
+/**
+ * Send the transation on chain
+ * @param {BigNumber} estGas estimated gas for the transaction
+ * @param {Signer} signer signer object
+ * @param {number} gasFeeMultiplier number represinting the multiplier we apply to gas fees
+ * @param {Function} functionToSend function that we need to send
+ * @param {...any[]} args arguments of the function
+ * @return {Promise<any>} transaction receipt
+ */
+export declare function sendTx(estGas: BigNumber, signer: Signer, gasFeeMultiplier: number, functionToSend: ContractFunction, ...args: any[]): Promise<providers.TransactionResponse>;

package/dist/types/utils/DatatokenName.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This function generates a datatoken name and symbol from a given word list.
+ * @param {Object} [wordList] - An object containing an array of nouns and adjectives.
+ * @param {string[]} [wordList.nouns] - An array of nouns.
+ * @param {string[]} [wordList.adjectives] - An array of adjectives.
+ * @returns {Object} Returns an object containing the generated name and symbol. Produces e.g. "Endemic Jellyfish Token" & "ENDJEL-45"
+ */
+export declare function generateDtName(wordList?: {
+    nouns: string[];
+    adjectives: string[];
+}): {
+    name: string;
+    symbol: string;
+};

package/dist/types/utils/DdoHelpers.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generates a valid DID
+ * @param {string} nftAddress - The NFT address
+ * @param {number} chainId - The chain ID
+ * @returns {string} - The DID
+ */
+export declare function generateDid(nftAddress: string, chainId: number): string;
+/**
+ * Returns the SHA256 hash of the input data
+ * @param {any} data - The input data
+ * @returns {string} - The SHA256 hash of the input data
+ */
+export declare function getHash(data: any): string;

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

@@ -0,0 +1,14 @@
+import { DownloadResponse } from '../@types';
+/**
+ * Triggers  a file download from the specified URL when called from a browser context.
+ * @param {string} url - The URL of the file to download
+ * @returns {Promise<void>} - A Promise that resolves when the file has been downloaded
+ */
+export declare function downloadFileBrowser(url: string): void;
+/**
+ * Triggers  a file download from the specified URL when called from a browser context.
+ * @param {string} url - The URL of the file to download
+ * @param {number} [index] - The file index
+ * @returns {Promise<void>} - A Promise that resolves when the file has been downloaded
+ */
+export declare function downloadFile(url: string, index?: number): Promise<DownloadResponse>;

package/dist/types/utils/General.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simple blocking sleep function
+ * @param {number} ms - Number of miliseconds to wait
+ */
+export declare function sleep(ms: number): Promise<unknown>;

package/dist/types/utils/Logger.d.ts

@@ -0,0 +1,19 @@
+export declare enum LogLevel {
+    None = -1,
+    Error = 0,
+    Warn = 1,
+    Log = 2,
+    Verbose = 3
+}
+export declare class Logger {
+    private logLevel?;
+    constructor(logLevel?: LogLevel);
+    setLevel(logLevel: LogLevel): void;
+    bypass(...args: any[]): void;
+    debug(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    private dispatch;
+}
+export declare const LoggerInstance: Logger;

package/dist/types/utils/OrderUtils.d.ts

@@ -0,0 +1,20 @@
+import { Signer } from 'ethers';
+import { Datatoken, Config, Asset, ConsumeMarketFee, ProviderFees } from '../index';
+/**
+ * Orders an asset based on the specified pricing schema and configuration.
+ * @param {Asset} asset - The asset to be ordered.
+ * @param {Signer} consumerAccount - The signer account of the consumer.
+ * @param {Config} config - The configuration settings.
+ * @param {Datatoken} datatoken - The Datatoken instance.
+ * @param {string} [providerUrl] - Optional the consumer address
+ * @param {string} [consumerAccount] - Optional the consumer address
+ * @param {ConsumeMarketFee} [consumeMarketOrderFee] - Optional consume market fee.
+ *  @param {ProviderFees} [providerFees] - Optional provider fees
+ * @param {string} [consumeMarketFixedSwapFee='0'] - Fixed swap fee for consuming the market.
+ * @param {number} [datatokenIndex=0] - Index of the datatoken within the asset.
+ * @param {number} [serviceIndex=0] - Index of the service within the asset.
+ * @param {number} [fixedRateIndex=0] - Index of the fixed rate within the pricing schema.
+ * @returns {Promise<void>} - A promise that resolves when the asset order process is completed.
+ * @throws {Error} If the pricing schema is not supported or if required indexes are invalid.
+ */
+export declare function orderAsset(asset: Asset, consumerAccount: Signer, config: Config, datatoken: Datatoken, providerUrl?: string, consumerAddress?: string, consumeMarketOrderFee?: ConsumeMarketFee, providerFees?: ProviderFees, consumeMarketFixedSwapFee?: string, datatokenIndex?: number, serviceIndex?: number, fixedRateIndex?: number): Promise<import("@ethersproject/abstract-provider").TransactionResponse>;

package/dist/types/utils/ProviderErrors.d.ts

@@ -0,0 +1 @@
+export declare function getErrorMessage(err: string): string;

package/dist/types/utils/SignatureUtils.d.ts

@@ -0,0 +1,12 @@
+import { Signer } from 'ethers';
+/**
+ * Signs the hash of a message using the provided signer.
+ * @param {Signer} signer - The signer to use for signing the hash.
+ * @param {string} message - The message to sign.
+ * @returns {Promise<string>} - A Promise that resolves to the signature of the hash of the message.
+ */
+export declare function signHash(signer: Signer, message: string): Promise<{
+    v: string;
+    r: string;
+    s: string;
+}>;