@oceanprotocol/lib 0.20.2 → 1.0.0-next.0

package/dist/node/src/pools/fixedRate/FixedRateExchange.d.ts

@@ -0,0 +1,95 @@
+import { TransactionReceipt } from 'web3-core';
+import { Contract } from 'web3-eth-contract';
+import { AbiItem } from 'web3-utils/types';
+import Web3 from 'web3';
+export interface FixedPriceExchange {
+    active: boolean;
+    exchangeOwner: string;
+    dataToken: string;
+    baseToken: string;
+    fixedRate: string;
+    dtDecimals: string;
+    btDecimals: string;
+    dtBalance: string;
+    btBalance: string;
+    dtSupply: string;
+    btSupply: string;
+    withMint: boolean;
+    allowedSwapper: string;
+    exchangeId?: string;
+}
+export interface FeesInfo {
+    opfFee: string;
+    marketFee: string;
+    marketFeeCollector: string;
+    marketFeeAvailable: string;
+    oceanFeeAvailable: string;
+    exchangeId: string;
+}
+export interface FixedPriceSwap {
+    exchangeId: string;
+    caller: string;
+    baseTokenAmount: string;
+    dataTokenAmount: string;
+}
+export declare enum FixedRateCreateProgressStep {
+    CreatingExchange = 0,
+    ApprovingDatatoken = 1
+}
+export declare class FixedRateExchange {
+    GASLIMIT_DEFAULT: number;
+    oceanAddress: string;
+    fixedRateAddress: string;
+    fixedRateExchangeAbi: AbiItem | AbiItem[];
+    fixedRateContract: Contract;
+    web3: Web3;
+    contract: Contract;
+    startBlock: number;
+    ssAbi: AbiItem | AbiItem[];
+    constructor(web3: Web3, fixedRateAddress: string, fixedRateExchangeAbi?: AbiItem | AbiItem[], oceanAddress?: string, startBlock?: number);
+    amountToUnits(token: string, amount: string): Promise<string>;
+    unitsToAmount(token: string, amount: string): Promise<string>;
+    generateExchangeId(basetoken: string, dataToken: string, owner: string): Promise<string>;
+    estBuyDT(account: string, datatokenAddress: string, dtAmount: string, maxBasetokenAmount: string, contractInstance?: Contract): Promise<number>;
+    buyDT(address: string, exchangeId: string, datatokenAmount: string, maxBasetokenAmount: string): Promise<TransactionReceipt>;
+    estSellDT(account: string, datatokenAddress: string, dtAmount: string, maxBasetokenAmount: string, contractInstance?: Contract): Promise<number>;
+    sellDT(address: string, exchangeId: string, datatokenAmount: string, minBasetokenAmount: string): Promise<TransactionReceipt>;
+    getNumberOfExchanges(): Promise<number>;
+    estSetRate(account: string, exchangeId: string, newRate: string, contractInstance?: Contract): Promise<number>;
+    setRate(address: string, exchangeId: string, newRate: string): Promise<TransactionReceipt>;
+    estSetAllowedSwapper(account: string, exchangeId: string, newAllowedSwapper: string, contractInstance?: Contract): Promise<number>;
+    setAllowedSwapper(address: string, exchangeId: string, newAllowedSwapper: string): Promise<TransactionReceipt>;
+    estActivate(account: string, exchangeId: string, contractInstance?: Contract): Promise<number>;
+    activate(address: string, exchangeId: string): Promise<TransactionReceipt>;
+    estDeactivate(account: string, exchangeId: string, contractInstance?: Contract): Promise<number>;
+    deactivate(address: string, exchangeId: string): Promise<TransactionReceipt>;
+    getRate(exchangeId: string): Promise<string>;
+    getDTSupply(exchangeId: string): Promise<string>;
+    getBTSupply(exchangeId: string): Promise<string>;
+    getAllowedSwapper(exchangeId: string): Promise<string>;
+    getAmountBTIn(exchangeId: string, dataTokenAmount: string): Promise<string>;
+    getAmountBTOut(exchangeId: string, dataTokenAmount: string): Promise<string>;
+    getExchange(exchangeId: string): Promise<FixedPriceExchange>;
+    getFeesInfo(exchangeId: string): Promise<FeesInfo>;
+    getExchanges(): Promise<string[]>;
+    isActive(exchangeId: string): Promise<boolean>;
+    estActivateMint(account: string, exchangeId: string, contractInstance?: Contract): Promise<number>;
+    activateMint(address: string, exchangeId: string): Promise<TransactionReceipt>;
+    estDeactivateMint(account: string, exchangeId: string, contractInstance?: Contract): Promise<number>;
+    deactivateMint(address: string, exchangeId: string): Promise<TransactionReceipt>;
+    estCollectBT(account: string, exchangeId: string, contractInstance?: Contract): Promise<number>;
+    collectBT(address: string, exchangeId: string): Promise<TransactionReceipt>;
+    estCollectDT(account: string, exchangeId: string, contractInstance?: Contract): Promise<number>;
+    collectDT(address: string, exchangeId: string): Promise<TransactionReceipt>;
+    estCollectMarketFee(account: string, exchangeId: string, contractInstance?: Contract): Promise<number>;
+    collectMarketFee(address: string, exchangeId: string): Promise<TransactionReceipt>;
+    estCollectOceanFee(account: string, exchangeId: string, contractInstance?: Contract): Promise<number>;
+    collectOceanFee(address: string, exchangeId: string): Promise<TransactionReceipt>;
+    getOPFCollector(): Promise<string>;
+    getRouter(): Promise<string>;
+    getExchangeOwner(exchangeId: string): Promise<string>;
+    estUpdateMarketFee(account: string, exchangeId: string, newMarketFee: string, contractInstance?: Contract): Promise<number>;
+    updateMarketFee(address: string, exchangeId: string, newMarketFee: string): Promise<TransactionReceipt>;
+    estUpdateMarketFeeCollector(account: string, exchangeId: string, newMarketFeeCollector: string, contractInstance?: Contract): Promise<number>;
+    updateMarketFeeCollector(address: string, exchangeId: string, newMarketFeeCollector: string): Promise<TransactionReceipt>;
+}

package/dist/node/src/pools/fixedRate/index.d.ts

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

package/dist/node/src/pools/index.d.ts

@@ -0,0 +1,3 @@
+export * from './balancer';
+export * from './dispenser';
+export * from './fixedRate';

package/dist/node/src/pools/ssContracts/SideStaking.d.ts

@@ -0,0 +1,28 @@
+import Web3 from 'web3';
+import { AbiItem } from 'web3-utils/types';
+import { TransactionReceipt } from 'web3-core';
+import { Contract } from 'web3-eth-contract';
+export declare class SideStaking {
+    ssAbi: AbiItem | AbiItem[];
+    web3: Web3;
+    GASLIMIT_DEFAULT: number;
+    constructor(web3: Web3, ssAbi?: AbiItem | AbiItem[]);
+    amountToUnits(token: string, amount: string): Promise<string>;
+    unitsToAmount(token: string, amount: string): Promise<string>;
+    getDataTokenCirculatingSupply(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getDataTokenCurrentCirculatingSupply(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getPublisherAddress(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getBasetoken(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getPoolAddress(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getBasetokenBalance(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getDatatokenBalance(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getvestingEndBlock(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getvestingAmount(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getvestingLastBlock(ssAddress: string, datatokenAddress: string): Promise<string>;
+    getvestingAmountSoFar(ssAddress: string, datatokenAddress: string): Promise<string>;
+    estGetVesting(account: string, ssAddress: string, datatokenAddress: string, contractInstance?: Contract): Promise<number>;
+    getVesting(account: string, ssAddress: string, datatokenAddress: string): Promise<TransactionReceipt>;
+    estSetPoolSwapFee(account: string, ssAddress: string, datatokenAddress: string, poolAddress: string, swapFee: number, contractInstance?: Contract): Promise<number>;
+    setPoolSwapFee(account: string, ssAddress: string, datatokenAddress: string, poolAddress: string, swapFee: number): Promise<TransactionReceipt>;
+    getRouter(ssAddress: string): Promise<string>;
+}

package/dist/node/src/pools/ssContracts/index.d.ts

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

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

@@ -0,0 +1,31 @@
+import Web3 from 'web3';
+import { FileMetadata, ComputeJob, ComputeOutput, ComputeAlgorithm, ComputeAsset, ProviderInitialize } from '../@types/';
+export interface ServiceEndpoint {
+    serviceName: string;
+    method: string;
+    urlPath: string;
+}
+export interface UserCustomParameters {
+    [key: string]: any;
+}
+export declare class Provider {
+    getEndpoints(providerUri: string): Promise<any>;
+    getEndpointURL(servicesEndpoints: ServiceEndpoint[], serviceName: string): ServiceEndpoint;
+    getServiceEndpoints(providerEndpoint: string, endpoints: any): Promise<ServiceEndpoint[]>;
+    getNonce(providerUri: string, consumerAddress: string, fetchMethod: any, providerEndpoints?: any, serviceEndpoints?: ServiceEndpoint[]): Promise<string>;
+    createSignature(web3: Web3, accountId: string, agreementId: string): Promise<string>;
+    createHashSignature(web3: Web3, accountId: string, message: string): Promise<string>;
+    encrypt(data: any, providerUri: string, postMethod: any): Promise<any>;
+    checkDidFiles(did: string, serviceId: number, providerUri: string, fetchMethod: any): Promise<FileMetadata[]>;
+    checkFileUrl(url: string, providerUri: string, fetchMethod: any): Promise<FileMetadata[]>;
+    initialize(did: string, serviceId: string, fileIndex: number, consumerAddress: string, providerUri: string, getMethod: any, userCustomParameters?: UserCustomParameters, computeEnv?: string): Promise<ProviderInitialize>;
+    getDownloadUrl(did: string, accountId: string, serviceId: string, fileIndex: number, transferTxId: string, providerUri: string, web3: Web3, userCustomParameters?: UserCustomParameters): Promise<any>;
+    computeStart(providerUri: string, web3: Web3, fetchMethod: any, consumerAddress: string, computeEnv: string, dataset: ComputeAsset, algorithm: ComputeAlgorithm, additionalDatasets?: ComputeAsset[], output?: ComputeOutput): Promise<ComputeJob | ComputeJob[]>;
+    computeStop(did: string, consumerAddress: string, jobId: string, providerUri: string, web3: Web3, fetchMethod: any): Promise<ComputeJob | ComputeJob[]>;
+    computeStatus(providerUri: string, fetchMethod: any, jobId?: string, did?: string, consumerAddress?: string): Promise<ComputeJob | ComputeJob[]>;
+    computeResult(jobId: string, index: number, destination: string, accountId: string, providerUri: string, web3: Web3, fetchMethod: any): Promise<any>;
+    computeDelete(did: string, consumerAddress: string, jobId: string, providerUri: string, web3: Web3, fetchMethod: any): Promise<ComputeJob | ComputeJob[]>;
+    isValidProvider(url: string, fetchMethod: any): Promise<boolean>;
+}
+export declare const ProviderInstance: Provider;
+export default ProviderInstance;

package/dist/node/src/provider/index.d.ts

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

package/dist/node/src/tokens/Datatoken.d.ts

@@ -0,0 +1,77 @@
+import Web3 from 'web3';
+import { AbiItem } from 'web3-utils';
+import { TransactionReceipt } from 'web3-eth';
+import { Contract } from 'web3-eth-contract';
+import { FreOrderParams, FreCreationParams } from '../interfaces';
+import { Nft } from './NFT';
+interface Roles {
+    minter: boolean;
+    paymentManager: boolean;
+}
+export interface OrderParams {
+    consumer: string;
+    serviceIndex: number;
+    providerFeeAddress: string;
+    providerFeeToken: string;
+    providerFeeAmount: string;
+    v: string;
+    r: string;
+    s: string;
+    providerData: string;
+}
+export interface DispenserParams {
+    maxTokens: string;
+    maxBalance: string;
+    withMint?: boolean;
+    allowedSwapper?: string;
+}
+export declare class Datatoken {
+    GASLIMIT_DEFAULT: number;
+    factoryAddress: string;
+    factoryABI: AbiItem | AbiItem[];
+    datatokensAbi: AbiItem | AbiItem[];
+    datatokensEnterpriseAbi: AbiItem | AbiItem[];
+    web3: Web3;
+    startBlock: number;
+    nft: Nft;
+    constructor(web3: Web3, datatokensAbi?: AbiItem | AbiItem[], datatokensEnterpriseAbi?: AbiItem | AbiItem[], startBlock?: number);
+    estGasApprove(dtAddress: string, spender: string, amount: string, address: string, contractInstance?: Contract): Promise<any>;
+    approve(dtAddress: string, spender: string, amount: string, address: string): Promise<TransactionReceipt>;
+    estGasMint(dtAddress: string, address: string, amount: string, toAddress?: string, contractInstance?: Contract): Promise<any>;
+    estGasCreateFixedRate(dtAddress: string, address: string, fixedRateParams: FreCreationParams, contractInstance?: Contract): Promise<any>;
+    createFixedRate(dtAddress: string, address: string, fixedRateParams: FreCreationParams): Promise<TransactionReceipt>;
+    estGasCreateDispenser(dtAddress: string, address: string, dispenserAddress: string, dispenserParams: DispenserParams, contractInstance?: Contract): Promise<any>;
+    createDispenser(dtAddress: string, address: string, dispenserAddress: string, dispenserParams: DispenserParams): Promise<TransactionReceipt>;
+    mint(dtAddress: string, address: string, amount: string, toAddress?: string): Promise<TransactionReceipt>;
+    estGasAddMinter(dtAddress: string, address: string, minter: string, contractInstance?: Contract): Promise<any>;
+    addMinter(dtAddress: string, address: string, minter: string): Promise<TransactionReceipt>;
+    estGasRemoveMinter(dtAddress: string, address: string, minter: string, contractInstance?: Contract): Promise<any>;
+    removeMinter(dtAddress: string, address: string, minter: string): Promise<TransactionReceipt>;
+    estGasAddPaymentManager(dtAddress: string, address: string, paymentManager: string, contractInstance?: Contract): Promise<any>;
+    addPaymentManager(dtAddress: string, address: string, paymentManager: string): Promise<TransactionReceipt>;
+    estGasRemovePaymentManager(dtAddress: string, address: string, paymentManager: string, contractInstance?: Contract): Promise<any>;
+    removePaymentManager(dtAddress: string, address: string, paymentManager: string): Promise<TransactionReceipt>;
+    estGasSetPaymentCollector(dtAddress: string, address: string, paymentCollector: string, contractInstance?: Contract): Promise<any>;
+    setPaymentCollector(dtAddress: string, address: string, paymentCollector: string): Promise<TransactionReceipt>;
+    getPaymentCollector(dtAddress: string): Promise<string>;
+    transfer(dtAddress: string, toAddress: string, amount: string, address: string): Promise<TransactionReceipt>;
+    estGasTransfer(dtAddress: string, toAddress: string, amount: string, address: string, contractInstance?: Contract): Promise<any>;
+    transferWei(dtAddress: string, toAddress: string, amount: string, address: string): Promise<TransactionReceipt>;
+    estGasStartOrder(dtAddress: string, address: string, consumer: string, serviceIndex: number, providerFeeAddress: string, providerFeeToken: string, providerFeeAmount: string, v: string, r: string, s: string, providerDatas: string, contractInstance?: Contract): Promise<any>;
+    startOrder(dtAddress: string, address: string, consumer: string, serviceIndex: number, providerFeeAddress: string, providerFeeToken: string, providerFeeAmount: string, v: string, r: string, s: string, providerDatas: string): Promise<TransactionReceipt>;
+    estGasBuyFromFreAndOrder(dtAddress: string, address: string, orderParams: OrderParams, freParams: FreOrderParams, contractInstance?: Contract): Promise<any>;
+    buyFromFreAndOrder(dtAddress: string, address: string, orderParams: OrderParams, freParams: FreOrderParams): Promise<TransactionReceipt>;
+    estGasBuyFromDispenserAndOrder(dtAddress: string, address: string, orderParams: OrderParams, dispenserContract: string, contractInstance?: Contract): Promise<any>;
+    buyFromDispenserAndOrder(dtAddress: string, address: string, orderParams: OrderParams, dispenserContract: string): Promise<TransactionReceipt>;
+    estGasSetData(dtAddress: string, address: string, value: string, contractInstance?: Contract): Promise<any>;
+    setData(dtAddress: string, address: string, value: string): Promise<TransactionReceipt>;
+    estGasCleanPermissions(dtAddress: string, address: string, contractInstance?: Contract): Promise<any>;
+    cleanPermissions(dtAddress: string, address: string): Promise<TransactionReceipt>;
+    getDTPermissions(dtAddress: string, address: string): Promise<Roles>;
+    getCap(dtAddress: string): Promise<string>;
+    getDecimals(dtAddress: string): Promise<string>;
+    getNFTAddress(dtAddress: string): Promise<string>;
+    isERC20Deployer(dtAddress: string, address: string): Promise<boolean>;
+    balance(dataTokenAddress: string, address: string): Promise<string>;
+}
+export {};

package/dist/node/src/tokens/NFT.d.ts

@@ -0,0 +1,57 @@
+import Web3 from 'web3';
+import { AbiItem } from 'web3-utils';
+import { TransactionReceipt } from 'web3-eth';
+import { Contract } from 'web3-eth-contract';
+import { MetadataProof } from '../../src/@types';
+interface Roles {
+    manager: boolean;
+    deployERC20: boolean;
+    updateMetadata: boolean;
+    store: boolean;
+}
+export declare class Nft {
+    GASLIMIT_DEFAULT: number;
+    factory721Address: string;
+    factory721Abi: AbiItem | AbiItem[];
+    nftAbi: AbiItem | AbiItem[];
+    web3: Web3;
+    startBlock: number;
+    constructor(web3: Web3, nftAbi?: AbiItem | AbiItem[], startBlock?: number);
+    estGasCreateErc20(nftAddress: string, address: string, minter: string, feeManager: string, mpFeeAddress: string, feeToken: string, feeAmount: string, cap: string, name?: string, symbol?: string, templateIndex?: number, contractInstance?: Contract): Promise<any>;
+    createErc20(nftAddress: string, address: string, minter: string, feeManager: string, mpFeeAddress: string, feeToken: string, feeAmount: string, cap: string, name?: string, symbol?: string, templateIndex?: number): Promise<string>;
+    estGasAddManager(nftAddress: string, address: string, manager: string, contractInstance?: Contract): Promise<any>;
+    addManager(nftAddress: string, address: string, manager: string): Promise<any>;
+    estGasRemoveManager(nftAddress: string, address: string, manager: string, contractInstance?: Contract): Promise<any>;
+    removeManager(nftAddress: string, address: string, manager: string): Promise<any>;
+    estGasAddErc20Deployer(nftAddress: string, address: string, erc20Deployer: string, contractInstance?: Contract): Promise<any>;
+    addErc20Deployer(nftAddress: string, address: string, erc20Deployer: string): Promise<TransactionReceipt>;
+    estGasRemoveErc20Deployer(nftAddress: string, address: string, erc20Deployer: string, contractInstance?: Contract): Promise<any>;
+    removeErc20Deployer(nftAddress: string, address: string, erc20Deployer: string): Promise<TransactionReceipt>;
+    estGasAddMetadataUpdater(nftAddress: string, address: string, metadataUpdater: string, contractInstance?: Contract): Promise<any>;
+    addMetadataUpdater(nftAddress: string, address: string, metadataUpdater: string): Promise<TransactionReceipt>;
+    esGasRemoveMetadataUpdater(nftAddress: string, address: string, metadataUpdater: string, contractInstance?: Contract): Promise<any>;
+    removeMetadataUpdater(nftAddress: string, address: string, metadataUpdater: string): Promise<TransactionReceipt>;
+    estGasAddStoreUpdater(nftAddress: string, address: string, storeUpdater: string, contractInstance?: Contract): Promise<any>;
+    addStoreUpdater(nftAddress: string, address: string, storeUpdater: string): Promise<TransactionReceipt>;
+    estGasRemoveStoreUpdater(nftAddress: string, address: string, storeUpdater: string, contractInstance?: Contract): Promise<any>;
+    removeStoreUpdater(nftAddress: string, address: string, storeUpdater: string): Promise<TransactionReceipt>;
+    estGasCleanPermissions(nftAddress: string, address: string, contractInstance?: Contract): Promise<any>;
+    cleanPermissions(nftAddress: string, address: string): Promise<TransactionReceipt>;
+    estGasTransferNft(nftAddress: string, nftOwner: string, nftReceiver: string, tokenId: number, contractInstance?: Contract): Promise<any>;
+    transferNft(nftAddress: string, nftOwner: string, nftReceiver: string, tokenId?: number): Promise<TransactionReceipt>;
+    estGasSafeTransferNft(nftAddress: string, nftOwner: string, nftReceiver: string, tokenId: number, contractInstance?: Contract): Promise<any>;
+    safeTransferNft(nftAddress: string, nftOwner: string, nftReceiver: string, tokenId?: number): Promise<TransactionReceipt>;
+    estGasSetMetadata(nftAddress: string, metadataUpdater: string, metadataState: number, metaDataDecryptorUrl: string, metaDataDecryptorAddress: string, flags: string, data: string, metadataHash: string, metadataProofs?: MetadataProof[], contractInstance?: Contract): Promise<any>;
+    setMetadata(nftAddress: string, address: string, metadataState: number, metaDataDecryptorUrl: string, metaDataDecryptorAddress: string, flags: string, data: string, metadataHash: string, metadataProofs?: MetadataProof[]): Promise<TransactionReceipt>;
+    estGasSetMetadataState(nftAddress: string, metadataUpdater: string, metadataState: number, contractInstance?: Contract): Promise<any>;
+    setMetadataState(nftAddress: string, address: string, metadataState: number): Promise<TransactionReceipt>;
+    estSetTokenURI(nftAddress: string, address: string, data: string): Promise<any>;
+    setTokenURI(nftAddress: string, address: string, data: string): Promise<any>;
+    getNftOwner(nftAddress: string): Promise<string>;
+    getNftPermissions(nftAddress: string, address: string): Promise<Roles>;
+    getMetadata(nftAddress: string): Promise<Object>;
+    isErc20Deployer(nftAddress: string, address: string): Promise<boolean>;
+    getData(nftAddress: string, key: string): Promise<string>;
+    getTokenURI(nftAddress: string, id: number): Promise<string>;
+}
+export {};

package/dist/node/src/tokens/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Datatoken';
+export * from './NFT';

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

@@ -0,0 +1,6 @@
+import Config from '../models/Config';
+export declare const configHelperNetworks: Config[];
+export declare class ConfigHelper {
+    getAddressesFromEnv(network: string): Partial<Config>;
+    getConfig(network: string | number, infuraProjectId?: string): Config;
+}

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

@@ -0,0 +1 @@
+export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";

package/dist/node/src/utils/ContractParams.d.ts

@@ -0,0 +1,4 @@
+import { Erc20CreateParams, FreCreationParams, PoolCreationParams } from '../interfaces';
+export declare function getErcCreationParams(ercParams: Erc20CreateParams): any;
+export declare function getFreCreationParams(freParams: FreCreationParams): any;
+export declare function getPoolCreationParams(poolParams: PoolCreationParams): any;

package/dist/node/src/utils/ConversionTypeHelper.d.ts

@@ -0,0 +1,3 @@
+export declare const zeroX: (input: string) => string;
+export declare const noZeroX: (input: string) => string;
+export declare function zeroXTransformer(input: string, zeroOutput: boolean): string;

package/dist/node/{utils/Datatokens.d.ts → src/utils/DatatokenName.d.ts}

@@ -1,4 +1,4 @@
-export declare function generateDatatokenName(wordList?: {
+export declare function generateDtName(wordList?: {
     nouns: string[];
     adjectives: string[];
 }): {

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

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

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

@@ -0,0 +1,5 @@
+export declare function fetchData(url: string, opts: RequestInit): Promise<Response>;
+export declare function downloadFile(url: string, destination?: string, index?: number): Promise<string>;
+export declare function getData(url: string): Promise<Response>;
+export declare function postData(url: string, payload: BodyInit): Promise<Response>;
+export declare function crossFetchGeneric(method: string, url: string, body: string, headers: any): Promise<Response>;

package/dist/node/src/utils/GasUtils.d.ts

@@ -0,0 +1,2 @@
+import Web3 from 'web3';
+export declare function getFairGasPrice(web3: Web3): Promise<string>;

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

@@ -0,0 +1,8 @@
+import Web3 from 'web3';
+export declare function signText(web3: Web3, text: string, publicKey: string, password?: string): Promise<string>;
+export declare function signHash(web3: Web3, message: string, address: string): Promise<{
+    v: string;
+    r: string;
+    s: string;
+}>;
+export declare function signWithHash(web3: Web3, text: string, publicKey: string, password?: string): Promise<string>;

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

@@ -0,0 +1,9 @@
+export * from './Logger';
+export * from './GasUtils';
+export * from './DatatokenName';
+export * from './ContractParams';
+export * from './FetchHelper';
+export * from './ConfigHelper';
+export * from './DdoHelpers';
+export * from './Constants';
+export * from './SignatureUtils';

package/docs/beginners_guide.md

@@ -168,8 +168,8 @@ The process of creating and deploying the ERC20 datatokens has been automated by
 const Web3 = require("web3");
 const { Ocean, DataTokens } = require("@oceanprotocol/lib");
  
-const factoryABI = require("@oceanprotocol/contracts/artifacts/DTFactory.json").abi;
-const datatokensABI = require("@oceanprotocol/contracts/artifacts/DataTokenTemplate.json").abi;
+const { factoryABI } = require("@oceanprotocol/contracts/artifacts/DTFactory.json");
+const { datatokensABI } = require("@oceanprotocol/contracts/artifacts/DataTokenTemplate.json");
 const { config, contracts, urls } = require("./config");
  
 const init = async () => {

package/docs/quickstart_simple.md

@@ -114,8 +114,8 @@ Now open the `index.js` file in your text editor. Enter the following code and s
 const Web3 = require("web3");
 const { Ocean, DataTokens } = require("@oceanprotocol/lib");
 
-const factoryABI = require("@oceanprotocol/contracts/artifacts/DTFactory.json").abi;
-const datatokensABI = require("@oceanprotocol/contracts/artifacts/DataTokenTemplate.json").abi;
+const { factoryABI } = require("@oceanprotocol/contracts/artifacts/DTFactory.json");
+const { datatokensABI } = require("@oceanprotocol/contracts/artifacts/DataTokenTemplate.json");
 const { config, contracts, urls } = require("./config");
 
 

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@oceanprotocol/lib",
   "source": "./src/index.ts",
-  "version": "0.20.2",
+  "version": "1.0.0-next.0",
   "description": "JavaScript client library for Ocean Protocol",
   "main": "./dist/node/lib.js",
   "exports": "./dist/node/lib.js",
   "module": "./dist/node/lib.module.js",
-  "typings": "./dist/node/lib.d.ts",
+  "typings": "./dist/node/index.d.ts",
   "umd:main": "dist/node/lib.umd.js",
   "unpkg": "./dist/node/lib.cjs2.min.js",
   "scripts": {
@@ -24,7 +24,15 @@
     "release": "release-it --non-interactive",
     "changelog": "auto-changelog -p",
     "prepublishOnly": "npm run build",
-    "test": "npm run lint && npm run test:unit:cover && npm run test:integration:cover",
+    "test:ss": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/pools/ssContracts/SideStaking.test.ts'",
+    "test:fixed": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/pools/fixedRate/FixedRateExchange.test.ts'",
+    "test:pool": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/pools/balancer/Pool.test.ts'",
+    "test:dispenser": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/pools/dispenser/Dispenser.test.ts'",
+    "test:dt": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/tokens/Datatoken.test.ts'",
+    "test:nftDt": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/Nft.test.ts'",
+    "test:factory": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/NftFactory.test.ts'",
+    "test:router": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/pools/Router.test.ts'",
+    "test:publishAll": "mocha --config=test/integration/.mocharc.json --node-env=test --exit 'test/integration/PublishFlows.test.ts'",
     "test:unit": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/**/*.test.ts'",
     "test:unit:cover": "nyc --report-dir coverage/unit npm run test:unit",
     "test:integration": "mocha --config=test/integration/.mocharc.json --node-env=test --exit 'test/integration/**/*.test.ts'",
@@ -45,27 +53,23 @@
     "web3": ">=1.3.5"
   },
   "dependencies": {
-    "@ethereum-navigator/navigator": "^0.5.3",
-    "@oceanprotocol/contracts": "^0.6.9",
+    "bignumber.js": "^9.0.2",
     "cross-fetch": "^3.1.4",
     "crypto-js": "^4.0.0",
     "decimal.js": "^10.2.1",
     "fs": "0.0.1-security",
-    "lzma": "^2.3.2",
-    "node-abort-controller": "^2.0.0",
     "save-file": "^2.3.1",
-    "uuid": "^8.3.2",
-    "web3": "^1.6.1",
-    "web3-core": "^1.5.3",
-    "web3-eth-contract": "^1.5.2"
+    "web3": ">=1.3.5",
+    "web3-core": "^1.6.1",
+    "web3-eth-contract": "^1.6.1"
   },
   "devDependencies": {
-    "@truffle/hdwallet-provider": "^2.0.0",
-    "@types/chai": "^4.3.0",
+    "@truffle/hdwallet-provider": "^1.5.1",
+    "@types/chai": "^4.2.19",
     "@types/chai-spies": "^1.0.3",
-    "@types/crypto-js": "^4.1.0",
+    "@types/crypto-js": "^4.0.1",
     "@types/mocha": "^9.0.0",
-    "@types/node": "^17.0.7",
+    "@types/node": "^16.10.3",
     "@types/node-fetch": "^3.0.3",
     "@typescript-eslint/eslint-plugin": "^4.33.0",
     "@typescript-eslint/parser": "^4.33.0",
@@ -78,17 +82,17 @@
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^4.0.0",
     "microbundle": "^0.14.2",
-    "mocha": "^9.1.3",
-    "mock-local-storage": "^1.1.19",
+    "mocha": "^9.1.2",
+    "mock-local-storage": "^1.1.17",
     "nyc": "^15.1.0",
     "ora": "5.4.1",
-    "prettier": "^2.5.1",
-    "release-it": "^14.11.8",
-    "source-map-support": "^0.5.21",
-    "ts-node": "^10.4.0",
+    "prettier": "^2.3.1",
+    "release-it": "^14.12.1",
+    "source-map-support": "^0.5.19",
+    "ts-node": "^10.0.0",
     "ts-node-register": "^1.0.0",
-    "typedoc": "0.22.10",
-    "typescript": "^4.5.4"
+    "typedoc": "0.22.5",
+    "typescript": "^4.3.4"
   },
   "nyc": {
     "include": [

package/dist/node/Instantiable.abstract.d.ts

@@ -1,25 +0,0 @@
-import Web3 from 'web3';
-import Config from './models/Config';
-import { Logger } from './utils';
-import { Ocean } from './ocean/Ocean';
-export interface InstantiableConfig {
-    ocean: Ocean;
-    config?: Config;
-    web3?: Web3;
-    logger?: Logger;
-}
-export declare function generateIntantiableConfigFromConfig(config: Config): Partial<InstantiableConfig>;
-export declare abstract class Instantiable {
-    protected get ocean(): Ocean;
-    protected get web3(): Web3;
-    protected get config(): Config;
-    protected get logger(): Logger;
-    protected get instanceConfig(): InstantiableConfig;
-    static getInstance(...args: any[]): Promise<any>;
-    protected static setInstanceConfig<T extends Instantiable>(instance: T, { ocean, config, web3, logger }: InstantiableConfig): void;
-    private _ocean;
-    private _web3;
-    private _config;
-    private _logger;
-    protected setInstanceConfig(config: InstantiableConfig): void;
-}

package/dist/node/balancer/OceanPool.d.ts

@@ -1,95 +0,0 @@
-import Web3 from 'web3';
-import { AbiItem } from 'web3-utils/types';
-import { TransactionReceipt } from 'web3-core';
-import { Pool } from './Pool';
-import { SubscribablePromise, Logger } from '../utils';
-import { ConfigHelperConfig } from '../utils/ConfigHelper';
-declare type PoolTransactionType = 'swap' | 'join' | 'exit';
-export interface PoolDetails {
-    poolAddress: string;
-    tokens: string[];
-}
-export interface PoolShare {
-    poolAddress: string;
-    shares: string;
-    did: string;
-}
-export interface TokensReceived {
-    dtAmount: string;
-    oceanAmount: string;
-}
-export interface PoolTransaction {
-    poolAddress: string;
-    dtAddress: string;
-    caller: string;
-    transactionHash: string;
-    blockNumber: number;
-    timestamp: number;
-    tokenIn?: string;
-    tokenOut?: string;
-    tokenAmountIn?: string;
-    tokenAmountOut?: string;
-    type: PoolTransactionType;
-}
-export declare enum PoolCreateProgressStep {
-    CreatingPool = 0,
-    ApprovingDatatoken = 1,
-    ApprovingOcean = 2,
-    SetupPool = 3
-}
-export declare class OceanPool extends Pool {
-    oceanAddress: string;
-    dtAddress: string;
-    startBlock: number;
-    constructor(web3: Web3, logger: Logger, factoryABI?: AbiItem | AbiItem[], poolABI?: AbiItem | AbiItem[], factoryAddress?: string, oceanAddress?: string, config?: ConfigHelperConfig);
-    create(account: string, dtAddress: string, dtAmount: string, dtWeight: string, oceanAmount: string, fee: string): SubscribablePromise<PoolCreateProgressStep, TransactionReceipt>;
-    getDTAddress(poolAddress: string): Promise<string>;
-    getOceanReserve(poolAddress: string): Promise<string>;
-    getDTReserve(poolAddress: string): Promise<string>;
-    getMaxBuyQuantity(poolAddress: string, tokenAddress: string): Promise<string>;
-    getOceanMaxBuyQuantity(poolAddress: string): Promise<string>;
-    getDTMaxBuyQuantity(poolAddress: string): Promise<string>;
-    calcInGivenOut(poolAddress: string, tokenInAddress: string, tokenOutAddress: string, tokenOutAmount: string): Promise<string>;
-    calcOutGivenIn(poolAddress: string, tokenInAddress: string, tokenOutAddress: string, tokenInAmount: string): Promise<string>;
-    calcPoolOutGivenSingleIn(poolAddress: string, tokenInAddress: string, tokenInAmount: string): Promise<string>;
-    calcSingleInGivenPoolOut(poolAddress: string, tokenInAddress: string, poolShares: string): Promise<string>;
-    calcSingleOutGivenPoolIn(poolAddress: string, tokenOutAddress: string, poolShares: string): Promise<string>;
-    calcPoolInGivenSingleOut(poolAddress: string, tokenOutAddress: string, tokenOutAmount: string): Promise<string>;
-    getPoolSharesRequiredToRemoveDT(poolAddress: string, dtAmount: string): Promise<string>;
-    getDTRemovedforPoolShares(poolAddress: string, poolShares: string): Promise<string>;
-    getPoolSharesRequiredToRemoveOcean(poolAddress: string, oceanAmount: string): Promise<string>;
-    getOceanRemovedforPoolShares(poolAddress: string, poolShares: string): Promise<string>;
-    getTokensRemovedforPoolShares(poolAddress: string, poolShares: string): Promise<TokensReceived>;
-    getDTMaxAddLiquidity(poolAddress: string): Promise<string>;
-    getOceanMaxAddLiquidity(poolAddress: string): Promise<string>;
-    getMaxAddLiquidity(poolAddress: string, tokenAddress: string): Promise<string>;
-    getMaxRemoveLiquidity(poolAddress: string, tokenAddress: string): Promise<string>;
-    getDTMaxRemoveLiquidity(poolAddress: string): Promise<string>;
-    getOceanMaxRemoveLiquidity(poolAddress: string): Promise<string>;
-    buyDT(account: string, poolAddress: string, dtAmountWanted: string, maxOceanAmount: string, maxPrice?: string): Promise<TransactionReceipt>;
-    buyDTWithExactOcean(account: string, poolAddress: string, minimumdtAmountWanted: string, oceanAmount: string, maxPrice?: string): Promise<TransactionReceipt>;
-    sellDT(account: string, poolAddress: string, dtAmount: string, oceanAmountWanted: string, maxPrice?: string): Promise<TransactionReceipt>;
-    addDTLiquidity(account: string, poolAddress: string, amount: string): Promise<TransactionReceipt>;
-    removeDTLiquidity(account: string, poolAddress: string, amount: string, maximumPoolShares: string): Promise<TransactionReceipt>;
-    addOceanLiquidity(account: string, poolAddress: string, amount: string): Promise<TransactionReceipt>;
-    removeOceanLiquidityWithMinimum(account: string, poolAddress: string, poolShares: string, minOcean: string): Promise<TransactionReceipt>;
-    removeOceanLiquidity(account: string, poolAddress: string, amount: string, maximumPoolShares: string): Promise<TransactionReceipt>;
-    removePoolLiquidity(account: string, poolAddress: string, poolShares: string, minDT?: string, minOcean?: string): Promise<TransactionReceipt>;
-    getDTPrice(poolAddress: string): Promise<string>;
-    searchPoolforDT(dtAddress: string): Promise<string[]>;
-    getOceanNeeded(poolAddress: string, dtRequired: string): Promise<string>;
-    getOceanReceived(poolAddress: string, dtAmount: string): Promise<string>;
-    getDTReceived(poolAddress: string, oceanAmount: string): Promise<string>;
-    getDTNeeded(poolAddress: string, OceanRequired: string): Promise<string>;
-    getPoolsbyCreator(account?: string): Promise<PoolDetails[]>;
-    private getResult;
-    getPoolSharesByAddress(account: string): Promise<PoolShare[]>;
-    getPoolDetails(poolAddress: string): Promise<PoolDetails>;
-    getPoolLogs(poolAddress: string, startBlock?: number, account?: string): Promise<PoolTransaction[]>;
-    getAllPoolLogs(account: string): Promise<PoolTransaction[]>;
-    private getEventData;
-    private computeSlippage;
-    computeBuySlippage(poolAddress: string, oceanAmount: string): Promise<string>;
-    computeSellSlippage(poolAddress: string, dtAmount: string): Promise<string>;
-}
-export {};