@oceanprotocol/lib 4.0.3 → 4.1.1

package/dist/types/@types/Compute.d.ts

@@ -132,3 +132,12 @@ export interface ComputeAlgorithm {
         [key: string]: any;
     };
 }
+export interface ComputePayment {
+    chainId: number;
+    token: string;
+    maxJobDuration: number;
+}
+export interface ValidationResponse {
+    isValid: boolean;
+    message: string;
+}

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

@@ -19,9 +19,18 @@ export interface ProviderComputeInitialize {
     validOrder?: string;
     providerFee?: ProviderFees;
 }
+export interface ProviderComputeInitializePayment {
+    escrowAddress: string;
+    chainId: number;
+    payee: string;
+    token: string;
+    amount: number;
+    minLockSeconds: number;
+}
 export interface ProviderComputeInitializeResults {
     algorithm?: ProviderComputeInitialize;
     datasets?: ProviderComputeInitialize[];
+    payment?: ProviderComputeInitializePayment;
 }
 export interface ServiceEndpoint {
     serviceName: string;

package/dist/types/contracts/Datatoken.d.ts

@@ -257,6 +257,15 @@ export declare class Datatoken extends SmartContract {
      * @return {Promise<String>} balance  Number of datatokens. Will be converted from wei
      */
     balance(datatokenAddress: string, address: string): Promise<string>;
+    /**
+     * Get Address Allowance for datatoken
+     * @param {String} dtAddress Datatoken adress
+     * @param {String} owner owner adress
+     * @param {String} spender spender adress
+     * @param {Number} decimals numer of token decimals, default 18
+     * @return {Promise<String>} allowance  Number of datatokens. Will be converted from wei
+     */
+    allowance(datatokenAddress: string, owner: string, spender: string, decimals?: number): Promise<string>;
     /**
      * Allows to set the fee required by the publisherMarket
      * only publishMarketFeeAddress can call it

package/dist/types/contracts/Escrow.d.ts

@@ -0,0 +1,93 @@
+import { Signer } from 'ethers';
+import { AbiItem, ReceiptOrEstimate, ValidationResponse } from '../@types';
+import { Config } from '../config';
+import { SmartContractWithAddress } from './SmartContractWithAddress';
+export declare class EscrowContract extends SmartContractWithAddress {
+    abiEnterprise: AbiItem[];
+    getDefaultAbi(): AbiItem[];
+    /**
+     * Instantiate AccessList class
+     * @param {string} address The contract address.
+     * @param {Signer} signer The signer object.
+     * @param {string | number} [network] Network id or name
+     * @param {Config} [config] The configuration object.
+     * @param {AbiItem[]} [abi] ABI array of the smart contract
+     * @param {AbiItem[]} abiEnterprise Enterprise ABI array of the smart contract
+     */
+    constructor(address: string, signer: Signer, network?: string | number, config?: Config, abi?: AbiItem[]);
+    /**
+     * Get Funds
+     * @return {Promise<any>} Funds
+     */
+    getFunds(token: string): Promise<any>;
+    /**
+     * Get User Funds
+     * @return {Promise<any>} User funds
+     */
+    getUserFunds(payer: string, token: string): Promise<any>;
+    /**
+     * Get Locks
+     * @return {Promise<[]>} Locks
+     */
+    getLocks(token: string, payer: string, payee: string): Promise<any[]>;
+    /**
+     * Get Authorizations
+     * @return {Promise<[]>} Authorizations
+     */
+    getAuthorizations(token: string, payer: string, payee: string): Promise<any[]>;
+    /**
+     * Checks funds for escrow payment.
+     * Does authorization when needed.
+     * Does deposit when needed.
+     * @param {String} token as payment token for escrow
+     * @param {String} consumerAddress as consumerAddress for that environment
+     * @param {String} amountToDeposit wanted amount for escrow lock deposit. If this is
+     * not provided and funds for escrow are 0 -> fallback to maxLockedAmount, else
+     * use balance of payment token.
+     * @param {String} maxLockedAmount amount necessary to be paid for starting compute job,
+     * returned from initialize compute payment and used for authorize if needed.
+     * @param {String} maxLockSeconds max seconds to lock the payment,
+     * returned from initialize compute payment and used for authorize if needed.
+     * @param {String} maxLockCounts max lock counts,
+     * returned from initialize compute payment and used for authorize if needed.
+     * @return {Promise<ValidationResponse>} validation response
+     */
+    verifyFundsForEscrowPayment(token: string, consumerAddress: string, amountToDeposit?: string, maxLockedAmount?: string, maxLockSeconds?: string, maxLockCounts?: string): Promise<ValidationResponse>;
+    /**
+     * Deposit funds
+     * @param {String} token Token address
+     * @param {String} amount amount
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>} returns the transaction receipt or the estimateGas value
+     */
+    deposit<G extends boolean = false>(token: string, amount: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Withdraw funds
+     * @param {String[]} tokens Array of token addresses
+     * @param {String[]} amounts Array of token amounts
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>} returns the transaction receipt or the estimateGas value
+     */
+    withdraw<G extends boolean = false>(tokens: string[], amounts: string[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Authorize locks
+     * @param {String} token Token address
+     * @param {String} payee,
+     * @param {String} maxLockedAmount,
+     * @param {String} maxLockSeconds,
+     * @param {String} maxLockCounts,
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>} returns the transaction receipt or the estimateGas value
+     */
+    authorize<G extends boolean = false>(token: string, payee: string, maxLockedAmount: string, maxLockSeconds: string, maxLockCounts: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Cancel expired locks
+     * @param {String} jobId Job ID with hash
+     * @param {String} token Token address
+     * @param {String} payee, Payee address for the compute job,
+     * @param {String} payer, Payer address for the compute job
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>} returns the transaction receipt or the estimateGas value
+     */
+    cancelExpiredLocks<G extends boolean = false>(jobIds: string[], tokens: string[], payers: string[], payees: string[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+}

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

@@ -18,3 +18,4 @@ export * from './df/DfStrategyV1.js';
 export * from './Datatoken4.js';
 export * from './AccessList.js';
 export * from './AccessListFactory.js';
+export * from './Escrow.js';

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

@@ -97,18 +97,19 @@ export declare class Provider {
      * @param {AbortSignal} signal abort signal
      * @return {Promise<ProviderComputeInitialize>} ProviderComputeInitialize data
      */
-    initializeComputeV1(assets: ComputeAsset[], algorithm: ComputeAlgorithm, computeEnv: string, validUntil: number, providerUri: string, accountId: string, signal?: AbortSignal): Promise<ProviderComputeInitializeResults>;
+    initializeComputeV1(assets: ComputeAsset[], algorithm: ComputeAlgorithm, computeEnv: string, providerUri: string, accountId: string, chainId: number, token: string, maxJobDuration: number, signal?: AbortSignal): Promise<ProviderComputeInitializeResults>;
     /** 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 {string} token The payment token address.
      * @param {number} validUntil  The job expiration date.
      * @param {string} providerUri The provider URI.
      * @param {Signer} signer caller address
      * @param {AbortSignal} signal abort signal
      * @return {Promise<ProviderComputeInitialize>} ProviderComputeInitialize data
      */
-    initializeCompute(assets: ComputeAsset[], algorithm: ComputeAlgorithm, computeEnv: string, validUntil: number, providerUri: string, signer: Signer, signal?: AbortSignal): Promise<ProviderComputeInitializeResults>;
+    initializeCompute(assets: ComputeAsset[], algorithm: ComputeAlgorithm, computeEnv: string, token: string, validUntil: number, providerUri: string, signer: Signer, resources: ComputeResourceRequest[], signal?: AbortSignal): Promise<ProviderComputeInitializeResults>;
     /**
      * Gets the download URL.
      * @param {string} did - The DID.
@@ -141,14 +142,15 @@ export declare class Provider {
      * @param {string} computeEnv The compute environment.
      * @param {ComputeAsset} datasets The dataset to start compute on + additionalDatasets (the additional datasets if that is the case)
      * @param {ComputeAlgorithm} algorithm The algorithm to start compute with.
+     * @param {number} maxJobDuration The compute job max execution time.
+     * @param {string} token The token address for compute payment.
      * @param {ComputeResourceRequest} resources The resources to start compute job with.
      * @param {chainId} chainId The chain used to do payments
      * @param {ComputeOutput} output The compute job output settings.
-     * @param {boolean} freeEnvironment is it a free environment? uses different route
      * @param {AbortSignal} signal abort signal
      * @return {Promise<ComputeJob | ComputeJob[]>} The compute job or jobs.
      */
-    computeStart(providerUri: string, consumer: Signer, computeEnv: string, datasets: ComputeAsset[], algorithm: ComputeAlgorithm, resources?: ComputeResourceRequest[], chainId?: number, // network used by payment (only for payed compute jobs)
+    computeStart(providerUri: string, consumer: Signer, computeEnv: string, datasets: ComputeAsset[], algorithm: ComputeAlgorithm, maxJobDuration: number, token: string, resources: ComputeResourceRequest[], chainId?: number, // network used by payment (only for payed compute jobs)
     output?: ComputeOutput, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
     /** Instruct the provider to start a FREE compute job (new C2D V2)
      * @param {string} providerUri The provider URI.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oceanprotocol/lib",
   "source": "./src/index.ts",
-  "version": "4.0.3",
+  "version": "4.1.1",
   "description": "JavaScript client library for Ocean Protocol",
   "main": "./dist/lib.cjs",
   "umd:main": "dist/lib.umd.js",
@@ -57,7 +57,7 @@
   },
   "dependencies": {
     "@oasisprotocol/sapphire-paratime": "^1.3.2",
-    "@oceanprotocol/contracts": "^2.2.0",
+    "@oceanprotocol/contracts": "^2.3.0",
     "@oceanprotocol/ddo-js": "^0.0.8",
     "@rdfjs/dataset": "^2.0.2",
     "@rdfjs/formats-common": "^3.1.0",