@oceanprotocol/lib 0.20.1 → 1.0.0-next.2

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

@@ -0,0 +1,36 @@
+import { DDO } from './DDO/DDO';
+export interface AssetNft {
+    address: string;
+    name: string;
+    symbol: string;
+    owner: string;
+    state: 0 | 1 | 2 | 3 | 4;
+    created: string;
+    tokenURI: string;
+}
+export interface Purgatory {
+    state: boolean;
+    reason: string;
+}
+export interface AssetDatatoken {
+    address: string;
+    name: string;
+    symbol: string;
+    serviceId: string;
+}
+export interface AssetLastEvent {
+    tx: string;
+    block: number;
+    from: string;
+    contract: string;
+    datetime: string;
+}
+export interface Asset extends DDO {
+    nft: AssetNft;
+    datatokens: AssetDatatoken[];
+    event: AssetLastEvent;
+    stats: {
+        consume: number;
+    };
+    purgatory: Purgatory;
+}

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

@@ -1,11 +1,10 @@
-import { Metadata } from '../../ddo/interfaces/Metadata';
-import { MetadataAlgorithm } from '../../ddo/interfaces/MetadataAlgorithm';
+import { Metadata, MetadataAlgorithm } from './DDO/Metadata';
 export declare type ComputeResultType = 'algorithmLog' | 'output';
 export interface ComputeResult {
     filename: string;
     filesize: number;
     type: ComputeResultType;
-    index: number;
+    index?: number;
 }
 export interface ComputeJob {
     owner: string;
@@ -33,18 +32,23 @@ export interface ComputeOutput {
     secretStoreUri?: string;
     whitelist?: string[];
 }
-export interface ComputeInput {
+export interface ComputeAsset {
     documentId: string;
-    serviceId: number;
+    serviceId: string;
     transferTxId?: string;
+    userdata?: {
+        [key: string]: any;
+    };
 }
 export interface ComputeAlgorithm {
-    did?: string;
-    serviceIndex?: number;
+    documentId?: string;
+    serviceId?: string;
     meta?: MetadataAlgorithm;
     transferTxId?: string;
-    dataToken?: string;
-    algoCustomParameters?: {
+    algocustomdata?: {
+        [key: string]: any;
+    };
+    userdata?: {
         [key: string]: any;
     };
 }

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

@@ -0,0 +1,8 @@
+export interface Credential {
+    type: string;
+    values: string[];
+}
+export interface Credentials {
+    allow: Credential[];
+    deny: Credential[];
+}

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

@@ -0,0 +1,15 @@
+import { Service } from './Service';
+import { Metadata } from './Metadata';
+import { Credentials } from './Credentials';
+import { Event } from './Event';
+export interface DDO {
+    '@context': string[];
+    id: string;
+    version: string;
+    nftAddress: string;
+    chainId: number;
+    metadata: Metadata;
+    services: Service[];
+    credentials?: Credentials;
+    event?: Event;
+}

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

@@ -0,0 +1,7 @@
+export interface Event {
+    txid?: string;
+    block?: number;
+    from?: string;
+    contract?: string;
+    datetime?: string;
+}

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

@@ -0,0 +1,38 @@
+export interface MetadataAlgorithm {
+    language?: string;
+    version?: string;
+    rawcode?: string;
+    container: {
+        entrypoint: string;
+        image: string;
+        tag: string;
+        checksum: string;
+    };
+}
+export interface Metadata {
+    created: string;
+    updated: string;
+    name: string;
+    description: string;
+    type: 'dataset' | 'algorithm';
+    author: string;
+    license: string;
+    links?: string[];
+    tags?: string[];
+    copyrightHolder?: string;
+    contentLanguage?: string;
+    algorithm?: MetadataAlgorithm;
+    additionalInformation?: any;
+}
+export interface MetadataProof {
+    validatorAddress?: string;
+    r?: string;
+    s?: string;
+    v?: number;
+}
+export interface ValidateMetadata {
+    valid: Boolean;
+    errors?: Object;
+    hash?: string;
+    proof?: MetadataProof;
+}

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

@@ -0,0 +1,28 @@
+export interface PublisherTrustedAlgorithm {
+    did: string;
+    filesChecksum: string;
+    containerSectionChecksum: string;
+}
+export interface ServiceComputeOptions {
+    namespace: string;
+    cpu?: number;
+    gpu?: number;
+    gpuType?: string;
+    memory?: string;
+    volumeSize?: string;
+    allowRawAlgorithm: boolean;
+    allowNetworkAccess: boolean;
+    publisherTrustedAlgorithmPublishers: string[];
+    publisherTrustedAlgorithms: PublisherTrustedAlgorithm[];
+}
+export interface Service {
+    id: string;
+    type: 'access' | 'compute' | string;
+    files: string;
+    datatokenAddress: string;
+    serviceEndpoint: string;
+    timeout: number;
+    name?: string;
+    description?: string;
+    compute?: ServiceComputeOptions;
+}

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

@@ -0,0 +1,8 @@
+export interface FileMetadata {
+    type: string;
+    contentType?: string;
+    contentLength?: string;
+    index?: number;
+    url?: string;
+    method?: string;
+}

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

@@ -0,0 +1,15 @@
+export interface ProviderFees {
+    providerFeeAddress: string;
+    providerFeeToken: string;
+    providerFeeAmount: string;
+    providerData: string;
+    v: string;
+    r: string;
+    s: string;
+}
+export interface ProviderInitialize {
+    dataToken: string;
+    nonce: string;
+    computeAddress: string;
+    providerFee: ProviderFees;
+}

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

@@ -0,0 +1,8 @@
+export * from './DDO/DDO';
+export * from './Asset';
+export * from './DDO/Service';
+export * from './DDO/Credentials';
+export * from './DDO/Metadata';
+export * from './FileMetadata';
+export * from './Compute';
+export * from './Provider';

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

@@ -0,0 +1,10 @@
+import { Asset, DDO, ValidateMetadata } from '../@types/';
+export declare class Aquarius {
+    aquariusURL: any;
+    constructor(aquariusURL: string);
+    resolve(did: string, fetchMethod: any): Promise<DDO>;
+    sleep(ms: number): Promise<unknown>;
+    waitForAqua(fetchMethod: any, did: string, txid?: string): Promise<Asset>;
+    validate(fetchMethod: any, ddo: DDO): Promise<ValidateMetadata>;
+}
+export default Aquarius;

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

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

package/dist/src/factories/NFTFactory.d.ts

@@ -0,0 +1,70 @@
+import { Contract } from 'web3-eth-contract';
+import Web3 from 'web3';
+import { TransactionReceipt } from 'web3-core';
+import { AbiItem } from 'web3-utils';
+import { FreCreationParams, Erc20CreateParams, PoolCreationParams, DispenserCreationParams } from '../interfaces';
+interface Template {
+    templateAddress: string;
+    isActive: boolean;
+}
+export interface TokenOrder {
+    tokenAddress: string;
+    consumer: string;
+    serviceIndex: number;
+    providerFeeAddress: string;
+    providerFeeToken: string;
+    providerFeeAmount: string;
+    v: string;
+    r: string;
+    s: string;
+    providerData: string;
+}
+export interface NftCreateData {
+    name: string;
+    symbol: string;
+    templateIndex: number;
+    tokenURI: string;
+}
+export declare class NftFactory {
+    GASLIMIT_DEFAULT: number;
+    factory721Address: string;
+    factory721Abi: AbiItem | AbiItem[];
+    web3: Web3;
+    startBlock: number;
+    factory721: Contract;
+    constructor(factory721Address: string, web3: Web3, factory721Abi?: AbiItem | AbiItem[], startBlock?: number);
+    estGasCreateNFT(address: string, nftData: NftCreateData): Promise<string>;
+    createNFT(address: string, nftData: NftCreateData): Promise<string>;
+    getCurrentNFTCount(): Promise<number>;
+    getCurrentTokenCount(): Promise<number>;
+    getOwner(): Promise<string>;
+    getCurrentNFTTemplateCount(): Promise<number>;
+    getCurrentTokenTemplateCount(): Promise<number>;
+    getNFTTemplate(index: number): Promise<Template>;
+    getTokenTemplate(index: number): Promise<Template>;
+    checkDatatoken(datatoken: string): Promise<Boolean>;
+    checkNFT(nftAddress: string): Promise<String>;
+    estGasAddNFTTemplate(address: string, templateAddress: string): Promise<any>;
+    addNFTTemplate(address: string, templateAddress: string): Promise<TransactionReceipt>;
+    estGasDisableNFTTemplate(address: string, templateIndex: number): Promise<any>;
+    disableNFTTemplate(address: string, templateIndex: number): Promise<TransactionReceipt>;
+    estGasReactivateNFTTemplate(address: string, templateIndex: number): Promise<any>;
+    reactivateNFTTemplate(address: string, templateIndex: number): Promise<TransactionReceipt>;
+    estGasAddTokenTemplate(address: string, templateAddress: string): Promise<any>;
+    addTokenTemplate(address: string, templateAddress: string): Promise<TransactionReceipt>;
+    estGasDisableTokenTemplate(address: string, templateIndex: number): Promise<any>;
+    disableTokenTemplate(address: string, templateIndex: number): Promise<TransactionReceipt>;
+    estGasReactivateTokenTemplate(address: string, templateIndex: number): Promise<any>;
+    reactivateTokenTemplate(address: string, templateIndex: number): Promise<TransactionReceipt>;
+    estGasStartMultipleTokenOrder(address: string, orders: TokenOrder[]): Promise<any>;
+    startMultipleTokenOrder(address: string, orders: TokenOrder[]): Promise<TransactionReceipt>;
+    estGasCreateNftWithErc(address: string, nftCreateData: NftCreateData, ercParams: Erc20CreateParams): Promise<any>;
+    createNftWithErc(address: string, nftCreateData: NftCreateData, ercParams: Erc20CreateParams): Promise<TransactionReceipt>;
+    estGasCreateNftErcWithPool(address: string, nftCreateData: NftCreateData, ercParams: Erc20CreateParams, poolParams: PoolCreationParams): Promise<any>;
+    createNftErcWithPool(address: string, nftCreateData: NftCreateData, ercParams: Erc20CreateParams, poolParams: PoolCreationParams): Promise<TransactionReceipt>;
+    estGasCreateNftErcWithFixedRate(address: string, nftCreateData: NftCreateData, ercParams: Erc20CreateParams, freParams: FreCreationParams): Promise<any>;
+    createNftErcWithFixedRate(address: string, nftCreateData: NftCreateData, ercParams: Erc20CreateParams, freParams: FreCreationParams): Promise<TransactionReceipt>;
+    estGasCreateNftErcWithDispenser(address: string, nftCreateData: NftCreateData, ercParams: Erc20CreateParams, dispenserParams: DispenserCreationParams): Promise<any>;
+    createNftErcWithDispenser(address: string, nftCreateData: NftCreateData, ercParams: Erc20CreateParams, dispenserParams: DispenserCreationParams): Promise<TransactionReceipt>;
+}
+export {};

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

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

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from './pools';
+export * from './tokens';
+export * from './factories';
+export * from './models';
+export * from './utils';
+export * from './@types';
+export * from './provider';
+export * from './interfaces';

package/dist/src/interfaces/DispenserInterface.d.ts

@@ -0,0 +1,7 @@
+export interface DispenserCreationParams {
+    dispenserAddress: string;
+    maxTokens: string;
+    maxBalance: string;
+    withMint?: boolean;
+    allowedSwapper?: string;
+}

package/dist/src/interfaces/Erc20Interface.d.ts

@@ -0,0 +1,11 @@
+export interface Erc20CreateParams {
+    templateIndex: number;
+    minter: string;
+    feeManager: string;
+    mpFeeAddress: string;
+    feeToken: string;
+    feeAmount: string;
+    cap: string;
+    name?: string;
+    symbol?: string;
+}

package/dist/src/interfaces/FixedRateInterface.d.ts

@@ -0,0 +1,19 @@
+export interface FreCreationParams {
+    fixedRateAddress: string;
+    baseTokenAddress: string;
+    owner: string;
+    marketFeeCollector: string;
+    baseTokenDecimals: number;
+    dataTokenDecimals: number;
+    fixedRate: string;
+    marketFee: number;
+    withMint?: boolean;
+    allowedConsumer?: string;
+}
+export interface FreOrderParams {
+    exchangeContract: string;
+    exchangeId: string;
+    maxBaseTokenAmount: string;
+    swapMarketFee: string;
+    marketFeeAddress: string;
+}

package/dist/src/interfaces/PoolInterface.d.ts

@@ -0,0 +1,36 @@
+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: number;
+    swapFeeMarketRunner: number;
+}
+export interface CurrentFees {
+    tokens: string[];
+    amounts: string[];
+}
+export interface TokenInOutMarket {
+    tokenIn: string;
+    tokenOut: string;
+    marketFeeAddress: string;
+}
+export interface AmountsInMaxFee {
+    tokenAmountIn: string;
+    minAmountOut: string;
+    swapMarketFee: string;
+    maxPrice?: string;
+}
+export interface AmountsOutMaxFee {
+    tokenAmountOut: string;
+    maxAmountIn: string;
+    swapMarketFee: string;
+    maxPrice?: string;
+}

package/dist/src/interfaces/RouterInterface.d.ts

@@ -0,0 +1,12 @@
+export interface Operation {
+    exchangeIds: string;
+    source: string;
+    operation: number;
+    tokenIn: string;
+    amountsIn: string | number;
+    tokenOut: string;
+    amountsOut: string | number;
+    maxPrice: string | number;
+    swapMarketFee: string;
+    marketFeeAddress: string;
+}

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

@@ -0,0 +1,5 @@
+export * from './FixedRateInterface';
+export * from './PoolInterface';
+export * from './Erc20Interface';
+export * from './DispenserInterface';
+export * from './RouterInterface';

package/dist/{node → src}/models/Config.d.ts

@@ -5,27 +5,30 @@ export declare class Config {
     providerAddress?: string;
     metadataCacheUri?: string;
     providerUri?: string;
-    rbacUri?: string;
     web3Provider?: any;
     oceanTokenAddress?: string;
-    factoryAddress?: string;
-    factoryABI?: AbiItem | AbiItem[];
+    erc721FactoryAddress?: string;
+    erc721FFactoryABI?: AbiItem | AbiItem[];
     datatokensABI?: AbiItem | AbiItem[];
-    poolFactoryAddress?: string;
+    poolTemplateAddress?: string;
     poolFactoryABI?: AbiItem | AbiItem[];
     poolABI?: AbiItem | AbiItem[];
     fixedRateExchangeAddress?: string;
     fixedRateExchangeAddressABI?: AbiItem | AbiItem[];
     dispenserAddress?: string;
     dispenserABI?: AbiItem | AbiItem[];
-    metadataContractAddress?: string;
-    metadataContractABI?: AbiItem | AbiItem[];
+    opfCommunityFeeCollector?: string;
+    sideStakingAddress?: string;
     startBlock?: number;
     verbose?: boolean | LogLevel;
     authMessage?: string;
     authTokenExpiration?: number;
     parityUri?: string;
     threshold?: number;
-    requestTimeout?: number;
+    chainId: number;
+    network: string;
+    subgraphUri: string;
+    explorerUri: string;
+    oceanTokenSymbol: string;
 }
 export default Config;

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

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

package/dist/src/pools/Router.d.ts

@@ -0,0 +1,46 @@
+import { Contract } from 'web3-eth-contract';
+import Web3 from 'web3';
+import { TransactionReceipt } from 'web3-core';
+import { AbiItem } from 'web3-utils';
+import { Operation } from '../interfaces/RouterInterface';
+export declare class Router {
+    GASLIMIT_DEFAULT: number;
+    routerAddress: string;
+    RouterAbi: AbiItem | AbiItem[];
+    web3: Web3;
+    startBlock: number;
+    router: Contract;
+    constructor(routerAddress: string, web3: Web3, RouterAbi?: AbiItem | AbiItem[], startBlock?: number);
+    estGasBuyDTBatch(address: string, operations: Operation[]): Promise<any>;
+    buyDTBatch(address: string, operations: Operation[]): Promise<TransactionReceipt>;
+    isOceanTokens(address: string): Promise<boolean>;
+    isSideStaking(address: string): Promise<boolean>;
+    isFixedPrice(address: string): Promise<boolean>;
+    getOwner(): Promise<string>;
+    getNFTFactory(): Promise<string>;
+    isPoolTemplate(address: string): Promise<boolean>;
+    estGasAddOceanToken(address: string, tokenAddress: string, contractInstance?: Contract): Promise<any>;
+    addOceanToken(address: string, tokenAddress: string): Promise<TransactionReceipt>;
+    estGasRemoveOceanToken(address: string, tokenAddress: string, contractInstance?: Contract): Promise<any>;
+    removeOceanToken(address: string, tokenAddress: string): Promise<TransactionReceipt>;
+    estGasAddSSContract(address: string, tokenAddress: string): Promise<any>;
+    addSSContract(address: string, tokenAddress: string): Promise<TransactionReceipt>;
+    estGasRemoveSSContract(address: string, tokenAddress: string): Promise<any>;
+    removeSSContract(address: string, tokenAddress: string): Promise<TransactionReceipt>;
+    estGasAddFixedRateContract(address: string, tokenAddress: string): Promise<any>;
+    addFixedRateContract(address: string, tokenAddress: string): Promise<TransactionReceipt>;
+    estGasRemoveFixedRateContract(address: string, tokenAddress: string): Promise<any>;
+    removeFixedRateContract(address: string, tokenAddress: string): Promise<TransactionReceipt>;
+    estGasAddDispenserContract(address: string, tokenAddress: string): Promise<any>;
+    addDispenserContract(address: string, tokenAddress: string): Promise<TransactionReceipt>;
+    estGasRemoveDispenserContract(address: string, tokenAddress: string): Promise<any>;
+    removeDispenserContract(address: string, tokenAddress: string): Promise<TransactionReceipt>;
+    getOPFFee(baseToken: string): Promise<number>;
+    getCurrentOPFFee(): Promise<number>;
+    estGasUpdateOPFFee(address: string, newFee: number): Promise<any>;
+    updateOPFFee(address: string, newFee: number): Promise<TransactionReceipt>;
+    estGasAddPoolTemplate(address: string, templateAddress: string): Promise<any>;
+    addPoolTemplate(address: string, templateAddress: string): Promise<TransactionReceipt>;
+    estGasRemovePoolTemplate(address: string, templateAddress: string): Promise<any>;
+    removePoolTemplate(address: string, templateAddress: string): Promise<TransactionReceipt>;
+}

package/dist/src/pools/balancer/Pool.d.ts

@@ -0,0 +1,73 @@
+import Web3 from 'web3';
+import { AbiItem } from 'web3-utils/types';
+import { TransactionReceipt } from 'web3-core';
+import { Contract } from 'web3-eth-contract';
+import { Logger } from '../../utils';
+import { CurrentFees, TokenInOutMarket, AmountsInMaxFee, AmountsOutMaxFee } from '../../interfaces';
+export declare class Pool {
+    poolAbi: AbiItem | AbiItem[];
+    web3: Web3;
+    GASLIMIT_DEFAULT: number;
+    private logger;
+    constructor(web3: Web3, logger: Logger, poolAbi?: AbiItem | AbiItem[]);
+    estApprove(account: string, tokenAddress: string, spender: string, amount: string, contractInstance?: Contract): Promise<number>;
+    allowance(tokenAddress: string, owner: string, spender: string): Promise<string>;
+    approve(account: string, tokenAddress: string, spender: string, amount: string, force?: boolean): Promise<TransactionReceipt | string>;
+    sharesBalance(account: string, poolAddress: string): Promise<string>;
+    estSetSwapFee(account: string, poolAddress: string, fee: string, contractInstance?: Contract): Promise<number>;
+    setSwapFee(account: string, poolAddress: string, fee: string): Promise<TransactionReceipt>;
+    getNumTokens(poolAddress: string): Promise<string>;
+    getPoolSharesTotalSupply(poolAddress: string): Promise<string>;
+    getCurrentTokens(poolAddress: string): Promise<string[]>;
+    getFinalTokens(poolAddress: string): Promise<string[]>;
+    getController(poolAddress: string): Promise<string>;
+    getBasetoken(poolAddress: string): Promise<string>;
+    getDatatoken(poolAddress: string): Promise<string>;
+    getMarketFeeCollector(poolAddress: string): Promise<string>;
+    getOPFCollector(poolAddress: string): Promise<string>;
+    isBound(poolAddress: string, token: string): Promise<boolean>;
+    getReserve(poolAddress: string, token: string): Promise<string>;
+    isFinalized(poolAddress: string): Promise<boolean>;
+    getSwapFee(poolAddress: string): Promise<string>;
+    getNormalizedWeight(poolAddress: string, token: string): Promise<string>;
+    getDenormalizedWeight(poolAddress: string, token: string): Promise<string>;
+    getTotalDenormalizedWeight(poolAddress: string): Promise<string>;
+    getMarketFees(poolAddress: string, token: string): Promise<string>;
+    getCurrentMarketFees(poolAddress: string): Promise<CurrentFees>;
+    getCurrentOPFFees(poolAddress: string): Promise<CurrentFees>;
+    getCommunityFees(poolAddress: string, token: string): Promise<string>;
+    estCollectOPF(address: string, poolAddress: string, contractInstance?: Contract): Promise<number>;
+    collectOPF(address: string, poolAddress: string): Promise<TransactionReceipt>;
+    estCollectMarketFee(address: string, poolAddress: string, contractInstance?: Contract): Promise<number>;
+    collectMarketFee(address: string, poolAddress: string): Promise<TransactionReceipt>;
+    estUpdateMarketFeeCollector(address: string, poolAddress: string, newCollector: string, contractInstance?: Contract): Promise<number>;
+    updateMarketFeeCollector(address: string, poolAddress: string, newCollector: string): Promise<TransactionReceipt>;
+    amountToUnits(token: string, amount: string): Promise<string>;
+    unitsToAmount(token: string, amount: string): Promise<string>;
+    estSwapExactAmountIn(address: string, poolAddress: string, tokenInOutMarket: TokenInOutMarket, amountsInOutMaxFee: AmountsInMaxFee, contractInstance?: Contract): Promise<number>;
+    swapExactAmountIn(address: string, poolAddress: string, tokenInOutMarket: TokenInOutMarket, amountsInOutMaxFee: AmountsInMaxFee): Promise<TransactionReceipt>;
+    estSwapExactAmountOut(address: string, poolAddress: string, tokenInOutMarket: TokenInOutMarket, amountsInOutMaxFee: AmountsOutMaxFee, contractInstance?: Contract): Promise<number>;
+    swapExactAmountOut(account: string, poolAddress: string, tokenInOutMarket: TokenInOutMarket, amountsInOutMaxFee: AmountsOutMaxFee): Promise<TransactionReceipt>;
+    estJoinPool(address: string, poolAddress: string, poolAmountOut: string, maxAmountsIn: string[], contractInstance?: Contract): Promise<number>;
+    joinPool(address: string, poolAddress: string, poolAmountOut: string, maxAmountsIn: string[]): Promise<TransactionReceipt>;
+    estExitPool(address: string, poolAddress: string, poolAmountIn: string, minAmountsOut: string[], contractInstance?: Contract): Promise<number>;
+    exitPool(account: string, poolAddress: string, poolAmountIn: string, minAmountsOut: string[]): Promise<TransactionReceipt>;
+    estJoinswapExternAmountIn(address: string, poolAddress: string, tokenIn: string, tokenAmountIn: string, minPoolAmountOut: string, contractInstance?: Contract): Promise<number>;
+    joinswapExternAmountIn(account: string, poolAddress: string, tokenIn: string, tokenAmountIn: string, minPoolAmountOut: string): Promise<TransactionReceipt>;
+    estJoinswapPoolAmountOut(address: string, poolAddress: string, tokenIn: string, poolAmountOut: string, maxAmountIn: string, contractInstance?: Contract): Promise<number>;
+    joinswapPoolAmountOut(account: string, poolAddress: string, tokenIn: string, poolAmountOut: string, maxAmountIn: string): Promise<TransactionReceipt>;
+    estExitswapPoolAmountIn(address: string, poolAddress: string, tokenOut: string, poolAmountIn: string, minTokenAmountOut: string, contractInstance?: Contract): Promise<number>;
+    exitswapPoolAmountIn(account: string, poolAddress: string, tokenOut: string, poolAmountIn: string, minTokenAmountOut: string): Promise<TransactionReceipt>;
+    estExitswapExternAmountOut(address: string, poolAddress: string, tokenOut: string, tokenAmountOut: string, maxPoolAmountIn: string, contractInstance?: Contract): Promise<number>;
+    exitswapExternAmountOut(account: string, poolAddress: string, tokenOut: string, tokenAmountOut: string, maxPoolAmountIn: string): Promise<TransactionReceipt>;
+    getSpotPrice(poolAddress: string, tokenIn: string, tokenOut: string, swapMarketFee: string): Promise<string>;
+    getAmountInExactOut(poolAddress: string, tokenIn: string, tokenOut: string, tokenAmountOut: string, swapMarketFee: string): Promise<string>;
+    getAmountOutExactIn(poolAddress: string, tokenIn: string, tokenOut: string, tokenAmountIn: string, swapMarketFee: string): Promise<string>;
+    calcPoolOutGivenSingleIn(poolAddress: string, tokenIn: string, tokenAmountIn: string): Promise<string>;
+    calcSingleInGivenPoolOut(poolAddress: string, tokenIn: string, poolAmountOut: string): Promise<string>;
+    calcSingleOutGivenPoolIn(poolAddress: string, tokenOut: string, poolAmountIn: string): Promise<string>;
+    calcPoolInGivenSingleOut(poolAddress: string, tokenOut: string, tokenAmountOut: string): Promise<string>;
+    getSwapEventSignature(): string;
+    getJoinEventSignature(): string;
+    getExitEventSignature(): string;
+}

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

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

package/dist/src/pools/dispenser/Dispenser.d.ts

@@ -0,0 +1,37 @@
+import Web3 from 'web3';
+import { AbiItem } from 'web3-utils';
+import { Contract } from 'web3-eth-contract';
+import { TransactionReceipt } from 'web3-eth';
+import { Datatoken } from '../../tokens';
+export interface DispenserToken {
+    active: boolean;
+    owner: string;
+    maxTokens: string;
+    maxBalance: string;
+    balance: string;
+    isMinter: boolean;
+    allowedSwapper: string;
+}
+export declare class Dispenser {
+    GASLIMIT_DEFAULT: number;
+    web3: Web3;
+    dispenserAddress: string;
+    startBlock: number;
+    dispenserAbi: AbiItem | AbiItem[];
+    dispenserContract: Contract;
+    constructor(web3: Web3, dispenserAddress?: string, dispenserAbi?: AbiItem | AbiItem[], startBlock?: number);
+    status(dtAdress: string): Promise<DispenserToken>;
+    estGasCreate(dtAddress: string, address: string, maxTokens: string, maxBalance: string, allowedSwapper: string): Promise<any>;
+    create(dtAddress: string, address: string, maxTokens: string, maxBalance: string, allowedSwapper: string): Promise<TransactionReceipt>;
+    estGasActivate(dtAddress: string, maxTokens: string, maxBalance: string, address: string): Promise<any>;
+    activate(dtAddress: string, maxTokens: string, maxBalance: string, address: string): Promise<TransactionReceipt>;
+    estGasDeactivate(dtAddress: string, address: string): Promise<any>;
+    deactivate(dtAddress: string, address: string): Promise<TransactionReceipt>;
+    estGasSetAllowedSwapper(dtAddress: string, address: string, newAllowedSwapper: string): Promise<any>;
+    setAllowedSwapper(dtAddress: string, address: string, newAllowedSwapper: string): Promise<TransactionReceipt>;
+    estGasDispense(dtAddress: string, address: string, amount: string, destination: string): Promise<any>;
+    dispense(dtAddress: string, address: string, amount: string, destination: string): Promise<TransactionReceipt>;
+    estGasOwnerWithdraw(dtAddress: string, address: string): Promise<any>;
+    ownerWithdraw(dtAddress: string, address: string): Promise<TransactionReceipt>;
+    isDispensable(dtAddress: string, dataToken: Datatoken, address: string, amount?: string): Promise<Boolean>;
+}

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

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