@oceanprotocol/lib 1.1.8 → 2.0.0-next.3

package/dist/src/contracts/SmartContractWithAddress.d.ts

@@ -0,0 +1,18 @@
+import Web3 from 'web3';
+import { Contract } from 'web3-eth-contract';
+import { AbiItem } from 'web3-utils';
+import { Config } from '../config';
+import { SmartContract } from './SmartContract';
+export declare abstract class SmartContractWithAddress extends SmartContract {
+    address: string;
+    contract: Contract;
+    /**
+     * Instantiate the smart contract.
+     * @param {string} address Address of the smart contract
+     * @param {Web3} web3
+     * @param {string | number} network Network id or name
+     * @param {Config} config Configutation of the smart contract
+     * @param {AbiItem | AbiItem[]} abi ABI of the smart contract
+     */
+    constructor(address: string, web3: Web3, network?: string | number, config?: Config, abi?: AbiItem | AbiItem[]);
+}

package/dist/src/contracts/df/DfRewards.d.ts

@@ -0,0 +1,32 @@
+import { AbiItem } from 'web3-utils';
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { ReceiptOrEstimate } from '../../@types';
+/**
+ * Provides an interface for DFRewards contract
+ */
+export declare class DfRewards extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem | AbiItem[];
+    /** Get available DF Rewards for a token
+     * @param {String} userAddress user address
+     * @param {String} tokenAddress token address
+     * @return {Promise<string>}
+     */
+    getAvailableRewards(userAddress: string, tokenAddress: string): Promise<string>;
+    /**
+     * claim rewards for any address
+     * @param {String} fromUserAddress user that generates the tx
+     * @param {String} userAddress user address to claim
+     * @param {String} tokenAddress token address
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    claimRewards<G extends boolean = false>(fromUserAddress: string, userAddress: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * allocate rewards to address.  An approve must exist before calling this function.
+     * @param {String} fromUserAddress user that generates the tx
+     * @param {String[]} userAddresses array of users that will receive rewards
+     * @param {String[]} amounts array of amounts
+     * @param {String} tokenAddress token address
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    allocateRewards<G extends boolean = false>(fromUserAddress: string, userAddresses: string[], amounts: string[], tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+}

package/dist/src/contracts/df/DfStrategyV1.d.ts

@@ -0,0 +1,23 @@
+import { AbiItem } from 'web3-utils';
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { ReceiptOrEstimate } from '../../@types';
+/**
+ * Provides an interface for dfStrategyV1 contract
+ */
+export declare class DfStrategyV1 extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem | AbiItem[];
+    /** Get available DF Rewards for multiple tokens
+     * @param {String} userAddress user address
+     * @param {String} tokenAddresses array of tokens
+     * @return {Promise<string[]>}
+     */
+    getMultipleAvailableRewards(userAddress: string, tokenAddresses: string[]): Promise<string[]>;
+    /**
+     * claim multiple token rewards for any address
+     * @param {String} fromUserAddress user that generates the tx
+     * @param {String} userAddress user address to claim
+     * @param {String} tokenAddresses array of tokens
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    claimMultipleRewards<G extends boolean = false>(fromUserAddress: string, userAddress: string, tokenAddresses: string[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+}

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

@@ -0,0 +1,13 @@
+export * from './SmartContract';
+export * from './SmartContractWithAddress';
+export * from './Dispenser';
+export * from './FixedRateExchange';
+export * from './Router';
+export * from './Datatoken';
+export * from './NFT';
+export * from './NFTFactory';
+export * from './ve/VeOcean';
+export * from './ve/VeFeeDistributor';
+export * from './ve/VeAllocate';
+export * from './df/DfRewards';
+export * from './df/DfStrategyV1';

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

@@ -0,0 +1,41 @@
+import { AbiItem } from 'web3-utils';
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { ReceiptOrEstimate } from '../../@types';
+/**
+ * Provides an interface for veOcean contract
+ */
+export declare class VeAllocate extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem | AbiItem[];
+    /**
+     * set a specific percentage of veOcean to a specific nft
+     * Maximum allocated percentage is 10000, so 1% is specified as 100
+     * @param {String} userAddress user address
+     * @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>(userAddress: string, 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} userAddress user address
+     * @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>(userAddress: string, 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/src/contracts/ve/VeFeeDistributor.d.ts

@@ -0,0 +1,30 @@
+import { AbiItem } from 'web3-utils';
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { ReceiptOrEstimate } from '../../@types';
+/**
+ * Provides an interface for veOcean contract
+ */
+export declare class VeFeeDistributor extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem | 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 {String} userAddress user address
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    claim<G extends boolean = false>(userAddress: string, 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} fromUserAddress user address that sends the tx
+     * @param {String} addresses array of addresses to claim
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    claimMany<G extends boolean = false>(fromUserAddress: string, addresses: string[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+}

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

@@ -0,0 +1,69 @@
+import { AbiItem } from 'web3-utils';
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { ReceiptOrEstimate } from '../../@types';
+/**
+ * Provides an interface for veOcean contract
+ */
+export declare class VeOcean extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem | AbiItem[];
+    /**
+     * Deposit `amount` tokens for `userAddress` and lock until `unlockTime`
+     * @param {String} userAddress user address
+     * @param {String} amount Amount of tokens to be locked
+     * @param {Number} unlockTime Timestamp for unlock
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    lockTokens<G extends boolean = false>(userAddress: string, 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} fromUserAddress user address that sends the tx
+     * @param {String} toAddress user address to deposit for
+     * @param {String} amount Amount of tokens to be locked
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    depositFor<G extends boolean = false>(fromUserAddress: string, toAddress: string, amount: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Deposit `amount` additional tokens for `userAddress` without modifying the unlock time
+     * @param {String} userAddress user address that sends the tx
+     * @param {String} amount Amount of tokens to be locked
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    increaseAmount<G extends boolean = false>(userAddress: string, amount: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Extend the unlock time for `userAddress` to `unlockTime`
+     * @param {String} userAddress user address that sends the tx
+     * @param {Number} unlockTime Timestamp for new unlock time
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    increaseUnlockTime<G extends boolean = false>(userAddress: string, unlockTime: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Withdraw all tokens for `userAddress`
+     * @param {String} userAddress user address that sends the tx
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    withdraw<G extends boolean = false>(userAddress: string, 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/src/index.d.ts

@@ -1,8 +1,5 @@
-export * from './aquarius';
-export * from './pools';
-export * from './tokens';
-export * from './factories';
-export * from './models';
-export * from './utils';
 export * from './@types';
-export * from './provider';
+export * from './config';
+export * from './contracts';
+export * from './services';
+export * from './utils';

package/dist/src/{aquarius → services}/Aquarius.d.ts

@@ -1,4 +1,4 @@
-import { Asset, DDO, ValidateMetadata } from '../@types/';
+import { Asset, DDO, ValidateMetadata } from '../@types';
 export interface SearchQuery {
     from?: number;
     size?: number;
@@ -9,7 +9,7 @@ export interface SearchQuery {
     aggs?: any;
 }
 export declare class Aquarius {
-    aquariusURL: any;
+    aquariusURL: string;
     /**
      * Instantiate Aquarius
      * @param {String} aquariusURL
@@ -52,4 +52,3 @@ export declare class Aquarius {
      */
     querySearch(query: SearchQuery, signal?: AbortSignal): Promise<any>;
 }
-export default Aquarius;

package/dist/src/{provider → services}/Provider.d.ts

@@ -1,16 +1,5 @@
 import Web3 from 'web3';
-import { FileInfo, ComputeJob, ComputeOutput, ComputeAlgorithm, ComputeAsset, ComputeEnvironment, ProviderInitialize, ProviderComputeInitializeResults } from '../@types/';
-export interface HttpCallback {
-    (httpMethod: string, url: string, body: string, header: any): Promise<any>;
-}
-export interface ServiceEndpoint {
-    serviceName: string;
-    method: string;
-    urlPath: string;
-}
-export interface UserCustomParameters {
-    [key: string]: any;
-}
+import { FileInfo, ComputeJob, ComputeOutput, ComputeAlgorithm, ComputeAsset, ComputeEnvironment, ProviderInitialize, ProviderComputeInitializeResults, ServiceEndpoint, UserCustomParameters } from '../@types';
 export declare class Provider {
     /**
      * Returns the provider endpoints
@@ -149,6 +138,9 @@ export declare class Provider {
      * @return {Promise<boolean>} string
      */
     isValidProvider(url: string, signal?: AbortSignal): Promise<boolean>;
+    private noZeroX;
+    private zeroXTransformer;
+    private inputMatch;
+    private getData;
 }
 export declare const ProviderInstance: Provider;
-export default ProviderInstance;

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

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

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

@@ -1,2 +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/src/utils/ContractUtils.d.ts

@@ -1,13 +1,9 @@
 import Web3 from 'web3';
 import { Contract } from 'web3-eth-contract';
-import { Erc20CreateParams, FreCreationParams, FreOrderParams, PoolCreationParams } from '../@types';
-import { Config } from '../models';
+import { Config } from '../config';
+import { TransactionReceipt } from 'web3-core';
 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 getFreOrderParams(web3: Web3, freParams: FreOrderParams): Promise<any>;
-export declare function getFreCreationParams(freParams: FreCreationParams): any;
-export declare function getPoolCreationParams(web3: Web3, poolParams: PoolCreationParams): Promise<any>;
+export declare function getFairGasPrice(web3: Web3, gasFeeMultiplier: number): Promise<string>;
 export declare function unitsToAmount(web3: Web3, token: string, amount: string, tokenDecimals?: number): Promise<string>;
 export declare function amountToUnits(web3: Web3, token: string, amount: string, tokenDecimals?: number): Promise<string>;
 /**
@@ -17,4 +13,14 @@ export declare function amountToUnits(web3: Web3, token: string, amount: string,
  * @param {...any[]} args arguments of the function
  * @return {Promise<number>} gas cost of the function
  */
-export declare function estimateGas(from: string, functionToEstimateGas: Function, ...args: any[]): Promise<any>;
+export declare function calculateEstimatedGas(from: string, functionToEstimateGas: Function, ...args: any[]): Promise<number>;
+/**
+ * Send the transation on chain
+ * @param {string} from account that calls the function
+ * @param {any} estGas estimated gas for the transaction
+ * @param {Web3} web3 web3 objcet
+ * @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(from: string, estGas: number, web3: Web3, gasFeeMultiplier: number, functionToSend: Function, ...args: any[]): Promise<TransactionReceipt>;

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

@@ -1,2 +1,2 @@
-export declare function generateDid(erc721Address: string, chainId: number): string;
+export declare function generateDid(nftAddress: string, chainId: number): string;
 export declare function getHash(data: any): string;

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

@@ -1,6 +1,3 @@
-import { DownloadResponse } from '../@types/DownloadResponse';
-export declare function fetchData(url: string, opts: RequestInit): Promise<Response>;
+import { DownloadResponse } from '../@types';
 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>;

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

@@ -17,4 +17,3 @@ export declare class Logger {
     private dispatch;
 }
 export declare const LoggerInstance: Logger;
-export default LoggerInstance;

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

@@ -1,27 +1,16 @@
-import { Contract } from 'web3-eth-contract';
-import { TransactionReceipt } from 'web3-core';
 import Web3 from 'web3';
-/**
- * Estimate gas cost for approval function
- * @param {String} account
- * @param {String} tokenAddress
- * @param {String} spender
- * @param {String} amount
- * @param {String} force
- * @param {Contract} contractInstance optional contract instance
- * @return {Promise<number>}
- */
-export declare function estApprove(web3: Web3, account: string, tokenAddress: string, spender: string, amount: string, contractInstance?: Contract): Promise<number>;
+import { Config } from '../config';
+import { ReceiptOrEstimate } from '../@types';
 /**
  * Approve spender to spent amount tokens
  * @param {String} account
  * @param {String} tokenAddress
  * @param {String} spender
- * @param {String} amount amount of ERC20 tokens (always expressed as wei)
+ * @param {String} amount amount of ERC20 Datatokens (always expressed as wei)
  * @param {boolean} force  if true, will overwrite any previous allowence. Else, will check if allowence is enough and will not send a transaction if it's not needed
  * @param {number} tokenDecimals optional number of decimals of the token
  */
-export declare function approve(web3: Web3, account: string, tokenAddress: string, spender: string, amount: string, force?: boolean, tokenDecimals?: number): Promise<TransactionReceipt | string>;
+export declare function approve<G extends boolean = false>(web3: Web3, config: Config, account: string, tokenAddress: string, spender: string, amount: string, force?: boolean, tokenDecimals?: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
 /**
  * Approve spender to spent amount tokens
  * @param {String} account
@@ -30,29 +19,18 @@ export declare function approve(web3: Web3, account: string, tokenAddress: strin
  * @param {String} amount amount of ERC20 tokens (always expressed as wei)
  * @param {boolean} force  if true, will overwrite any previous allowence. Else, will check if allowence is enough and will not send a transaction if it's not needed
  */
-export declare function approveWei(web3: Web3, account: string, tokenAddress: string, spender: string, amount: string, force?: boolean): Promise<TransactionReceipt | string>;
-/**
- * Estimate gas cost for transfer function
- * @param {String} account
- * @param {String} tokenAddress
- * @param {String} recipient
- * @param {String} amount
- * @param {String} force
- * @param {Contract} contractInstance optional contract instance
- * @return {Promise<number>}
- */
-export declare function estTransfer(web3: Web3, account: string, tokenAddress: string, recipient: string, amount: string, contractInstance?: Contract): Promise<number>;
+export declare function approveWei<G extends boolean = false>(web3: Web3, config: Config, account: string, tokenAddress: string, spender: string, amount: string, force?: boolean, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
 /**
  * Moves amount tokens from the caller’s account to recipient.
  * @param {String} account
  * @param {String} tokenAddress
  * @param {String} recipient
- * @param {String} amount amount of ERC20 tokens (not as wei)
+ * @param {String} amount amount of ERC20 Datatokens (not as wei)
  * @param {String} force  if true, will overwrite any previous allowence. Else, will check if allowence is enough and will not send a transaction if it's not needed
  */
-export declare function transfer(web3: Web3, account: string, tokenAddress: string, recipient: string, amount: string): Promise<TransactionReceipt | string>;
+export declare function transfer<G extends boolean = false>(web3: Web3, config: Config, account: string, tokenAddress: string, recipient: string, amount: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
 /**
- * Get Allowance for any erc20
+ * Get Allowance for any Datatoken
  * @param {Web3} web3
  * @param {String } tokenAdress
  * @param {String} account
@@ -61,24 +39,24 @@ export declare function transfer(web3: Web3, account: string, tokenAddress: stri
  */
 export declare function allowance(web3: Web3, tokenAddress: string, account: string, spender: string, tokenDecimals?: number): Promise<string>;
 /**
- * Get Allowance for any erc20
+ * Get balance for any Datatoken
  * @param {Web3} web3
- * @param {String } tokenAdress
- * @param {String} account
+ * @param {String} tokenAdress
+ * @param {String} owner
  * @param {String} spender
+ * @param {number} tokenDecimals optional number of decimals of the token
  */
-export declare function allowanceWei(web3: Web3, tokenAddress: string, account: string, spender: string, tokenDecimals?: number): Promise<string>;
+export declare function balance(web3: Web3, tokenAddress: string, account: string, tokenDecimals?: number): Promise<string>;
 /**
- * Get balance for any erc20
+ * Get Allowance for any erc20
  * @param {Web3} web3
  * @param {String} tokenAdress
- * @param {String} owner
+ * @param {String} account
  * @param {String} spender
- * @param {number} tokenDecimals optional number of decimals of the token
  */
-export declare function balance(web3: Web3, tokenAddress: string, account: string, tokenDecimals?: number): Promise<string>;
+export declare function allowanceWei(web3: Web3, tokenAddress: string, account: string, spender: string, tokenDecimals?: number): Promise<string>;
 /**
- * Get decimals for any erc20
+ * Get decimals for any Datatoken
  * @param {Web3} web3
  * @param {String} tokenAdress
  * @return {Promise<number>} Number of decimals of the token

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

@@ -1,11 +1,10 @@
-export * from './Logger';
-export * from './DatatokenName';
+export * from './Constants';
 export * from './ContractUtils';
-export * from './FetchHelper';
-export * from './ConfigHelper';
+export * from './DatatokenName';
 export * from './DdoHelpers';
-export * from './Constants';
+export * from './FetchHelper';
+export * from './General';
+export * from './Logger';
+export * from './minAbi';
 export * from './SignatureUtils';
 export * from './TokenUtils';
-export * from './General';
-export * from './PoolHelpers';

package/dist/test/TestContractHandler.d.ts

@@ -1,16 +1,16 @@
 import Web3 from 'web3';
 export interface Addresses {
     opfCommunityFeeCollectorAddress: string;
-    poolTemplateAddress: string;
-    erc20TemplateAddress: string;
-    erc721TemplateAddress: string;
+    datatokenTemplateAddress: string;
+    nftTemplateAddress: string;
     oceanAddress: string;
     routerAddress: string;
     sideStakingAddress: string;
     fixedRateAddress: string;
     dispenserAddress: string;
-    erc721FactoryAddress: string;
+    nftFactoryAddress: string;
     daiAddress: string;
     usdcAddress: string;
+    poolTemplateAddress: string;
 }
 export declare const deployContracts: (web3: Web3, owner: string) => Promise<Addresses>;

package/dist/test/config.d.ts

@@ -1,5 +1,5 @@
 import Web3 from 'web3';
 export declare const GAS_PRICE = "3000000000";
 export declare const web3: Web3;
-export declare const getTestConfig: (web3: Web3) => Promise<import("../src").Config>;
+export declare const getTestConfig: (web3: Web3) => Promise<import("../src/config").Config>;
 export declare const getAddresses: () => any;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oceanprotocol/lib",
   "source": "./src/index.ts",
-  "version": "1.1.8",
+  "version": "2.0.0-next.3",
   "description": "JavaScript client library for Ocean Protocol",
   "main": "./dist/lib.js",
   "umd:main": "dist/lib.umd.js",
@@ -27,25 +27,12 @@
     "changelog": "auto-changelog -p",
     "prepublishOnly": "npm run build",
     "mocha": "TS_NODE_PROJECT='./test/tsconfig.json' mocha --config=test/.mocharc.json --node-env=test --exit",
-    "test:nftfactory": "npm run mocha -- 'test/unit/factories/NftFactory.test.ts'",
-    "test:nft": "npm run mocha -- 'test/unit/tokens/Nft.test.ts'",
-    "test:datatoken": "npm run mocha -- 'test/unit/tokens/Datatoken.test.ts'",
-    "test:router": "npm run mocha -- 'test/unit/pools/Router.test.ts'",
-    "test:fixed": "npm run mocha -- 'test/unit/pools/fixedRate/FixedRateExchange.test.ts'",
-    "test:ss": "npm run mocha -- 'test/unit/pools/ssContracts/SideStaking.test.ts'",
-    "test:pool": "npm run mocha -- 'test/unit/pools/balancer/Pool.test.ts'",
-    "test:dispenser": "npm run mocha -- 'test/unit/pools/dispenser/Dispenser.test.ts'",
-    "test:publishAll": "npm run mocha -- 'test/integration/PublishFlows.test.ts'",
-    "test:examples": "npm run mocha -- 'test/integration/CodeExamples.test.ts'",
-    "test:provider": "npm run mocha -- 'test/integration/Provider.test.ts'",
     "test:unit": "npm run mocha -- 'test/unit/**/*.test.ts'",
     "test:unit:cover": "nyc --report-dir coverage/unit --exclude 'src/@types/**/*' npm run test:unit",
     "test:integration": "npm run mocha -- 'test/integration/**/*.test.ts'",
-    "test:compute": "npm run mocha -- 'test/integration/ComputeFlow.test.ts'",
-    "test:integration:cover": "nyc --report-dir coverage/integration --exclude 'src/@types/**/*' --no-clean npm run test:integration",
-    "create:guide": "chmod +x ./scripts/createCodeExamples.sh && ./scripts/createCodeExamples.sh",
-    "create:guide:mac": "chmod +x ./scripts/createCodeExamples-mac.sh && ./scripts/createCodeExamples-mac.sh",
-    "commit:guide": "chmod +x scripts/commitChanges.sh && scripts/commitChanges.sh"
+    "test:integration:cover": "nyc --report-dir coverage/integration --no-clean npm run test:integration",
+    "create:guide": "./scripts/createCodeExamples.sh",
+    "commit:guide": "./scripts/commitChanges.sh"
   },
   "repository": {
     "type": "git",
@@ -62,7 +49,7 @@
     "web3": "^1.7.4"
   },
   "dependencies": {
-    "@oceanprotocol/contracts": "^1.0.0",
+    "@oceanprotocol/contracts": "^1.1.3",
     "bignumber.js": "^9.0.2",
     "cross-fetch": "^3.1.5",
     "crypto-js": "^4.1.1",
@@ -96,7 +83,7 @@
     "nyc": "^15.1.0",
     "ora": "5.4.1",
     "prettier": "^2.7.1",
-    "release-it": "^15.1.1",
+    "release-it": "^15.4.0",
     "source-map-support": "^0.5.19",
     "ts-node": "^10.8.2",
     "ts-node-register": "^1.0.0",

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

@@ -1,45 +0,0 @@
-export interface PoolCreationParams {
-    ssContract: string;
-    baseTokenAddress: string;
-    baseTokenSender: string;
-    publisherAddress: string;
-    marketFeeCollector: string;
-    poolTemplateAddress: string;
-    rate: string;
-    baseTokenDecimals: number;
-    vestingAmount: string;
-    vestedBlocks: number;
-    initialBaseTokenLiquidity: string;
-    swapFeeLiquidityProvider: string;
-    swapFeeMarketRunner: string;
-}
-export interface CurrentFees {
-    tokens: string[];
-    amounts: string[];
-}
-export interface TokenInOutMarket {
-    tokenIn: string;
-    tokenOut: string;
-    marketFeeAddress: string;
-    tokenInDecimals?: number;
-    tokenOutDecimals?: number;
-}
-export interface AmountsInMaxFee {
-    tokenAmountIn: string;
-    minAmountOut: string;
-    swapMarketFee: string;
-    maxPrice?: string;
-}
-export interface AmountsOutMaxFee {
-    tokenAmountOut: string;
-    maxAmountIn: string;
-    swapMarketFee: string;
-    maxPrice?: string;
-}
-export interface PoolPriceAndFees {
-    tokenAmount: string;
-    liquidityProviderSwapFeeAmount: string;
-    oceanFeeAmount: string;
-    publishMarketSwapFeeAmount: string;
-    consumeMarketSwapFeeAmount: string;
-}

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

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