@oceanprotocol/lib 2.7.0 → 3.0.0-next.0

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

@@ -1,62 +1,72 @@
-import { AbiItem } from 'web3-utils';
-import { FreCreationParams, DatatokenCreateParams, DispenserCreationParams, NftCreateData, Template, TokenOrder, ReceiptOrEstimate } from '../@types';
+import { BigNumber } from 'ethers';
+import { AbiItem, FreCreationParams, DatatokenCreateParams, DispenserCreationParams, NftCreateData, Template, TokenOrder, ReceiptOrEstimate } from '../@types';
 import { SmartContractWithAddress } from './SmartContractWithAddress';
 /**
  * Provides an interface for NFT Factory contract
  */
 export declare class NftFactory extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem | AbiItem[];
+    getDefaultAbi(): AbiItem[];
     /**
-     * Create new NFT
-     * @param {String} address
-     * @param {NFTCreateData} nftData
-     * @return {Promise<string>} NFT datatoken address
+     * Create new data NFT
+     * @param {NFTCreateData} nftData The data needed to create an NFT.
+     * @param {Boolean} [estimateGas] if True, return gas estimate
+     * @return {Promise<string|BigNumber>} The transaction hash or the gas estimate.
      */
-    createNFT<G extends boolean = false>(address: string, nftData: NftCreateData, estimateGas?: G): Promise<G extends false ? string : number>;
-    /** Get Current NFT Count (NFT created)
+    createNFT<G extends boolean = false>(nftData: NftCreateData, estimateGas?: G): Promise<G extends false ? string : BigNumber>;
+    /**
+     * Get Current NFT Count (NFT created)
      * @return {Promise<number>} Number of NFT created from this factory
      */
     getCurrentNFTCount(): Promise<number>;
-    /** Get Current Datatoken Count
+    /**
+     * Get Current Datatoken Count
      * @return {Promise<number>} Number of DTs created from this factory
      */
     getCurrentTokenCount(): Promise<number>;
-    /** Get Factory Owner
+    /**
+     *  Get Factory Owner
      * @return {Promise<string>} Factory Owner address
      */
     getOwner(): Promise<string>;
-    /** Get Current NFT Template Count
+    /**
+     * Get Current NFT Template Count
      * @return {Promise<number>} Number of NFT Template added to this factory
      */
     getCurrentNFTTemplateCount(): Promise<number>;
-    /** Get Current Template  Datatoken (ERC20) Count
+    /**
+     * Get Current Template  Datatoken (ERC20) Count
      * @return {Promise<number>} Number of Datatoken Template added to this factory
      */
     getCurrentTokenTemplateCount(): Promise<number>;
-    /** Get NFT Template
-     * @param {Number} index Template index
+    /**
+     * Get NFT Template
+     * @param {number} index Template index
      * @return {Promise<Template>} Number of Template added to this factory
      */
     getNFTTemplate(index: number): Promise<Template>;
-    /** Get Datatoken (ERC20) Template
-     * @param {Number} index Template index
+    /**
+     * Get Datatoken (ERC20) Template
+     * @param {number} index Template index
      * @return {Promise<Template>} DT Template info
      */
     getTokenTemplate(index: number): Promise<Template>;
-    /** Check if Datatoken is deployed from the factory
-     * @param {String} datatoken Datatoken address we want to check
+    /**
+     * Check if Datatoken is deployed from the factory
+     * @param {String} datatoken Datatoken address to check
      * @return {Promise<Boolean>} return true if deployed from this factory
      */
     checkDatatoken(datatoken: string): Promise<Boolean>;
-    /** Check if  NFT is deployed from the factory
-     * @param {String} nftAddress nftAddress address we want to check
+    /**
+     * Check if  NFT is deployed from the factory
+     * @param {String} nftAddress nftAddress address to check
      * @return {Promise<String>} return address(0) if it's not, or the nftAddress if true
      */
     checkNFT(nftAddress: string): Promise<String>;
     /**
      * Add a new NFT token template - only factory Owner
-     * @param {String} address
+     * @param {String} address caller address
      * @param {String} templateAddress template address to add
+     * @param {Boolean} [estimateGas] if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
     addNFTTemplate<G extends boolean = false>(address: string, templateAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
@@ -64,6 +74,7 @@ export declare class NftFactory extends SmartContractWithAddress {
      * Disable token template - only factory Owner
      * @param {String} address
      * @param {Number} templateIndex index of the template we want to disable
+     * @param {Boolean} estimateGas if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>} current token template count
      */
     disableNFTTemplate<G extends boolean = false>(address: string, templateIndex: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
@@ -71,74 +82,84 @@ export declare class NftFactory extends SmartContractWithAddress {
      * Reactivate a previously disabled token template - only factory Owner
      * @param {String} address
      * @param {Number} templateIndex index of the template we want to reactivate
+     * @param {Boolean} estimateGas if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>} current token template count
      */
     reactivateNFTTemplate<G extends boolean = false>(address: string, templateIndex: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /**
      * Add a new NFT token template - only factory Owner
-     * @param {String} address
+     * @param {String} address caller address
      * @param {String} templateAddress template address to add
+     * @param {Boolean} estimateGas if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
     addTokenTemplate<G extends boolean = false>(address: string, templateAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /**
      * Disable token template - only factory Owner
-     * @param {String} address
+     * @param {String} address caller address
      * @param {Number} templateIndex index of the template we want to disable
+     * @param {Boolean} estimateGas if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>} current token template count
      */
     disableTokenTemplate<G extends boolean = false>(address: string, templateIndex: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /**
      * Reactivate a previously disabled token template - only factory Owner
-     * @param {String} address
+     * @param {String} address caller address
      * @param {Number} templateIndex index of the template we want to reactivate
+     * @param {Boolean} estimateGas if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>} current token template count
      */
     reactivateTokenTemplate<G extends boolean = false>(address: string, templateIndex: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /**
-     * @dev startMultipleTokenOrder
      *      Used as a proxy to order multiple services
      *      Users can have inifinite approvals for fees for factory instead of having one approval/ Datatoken contract
      *      Requires previous approval of all :
      *          - consumeFeeTokens
      *          - publishMarketFeeTokens
      *          - ERC20 Datatokens
-     * @param address Caller address
-     * @param orders an array of struct tokenOrder
+     * @param {TokenOrder[]} orders array of of orders
+     * @param {Boolean} [estimateGas] if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>} transaction receipt
      */
-    startMultipleTokenOrder<G extends boolean = false>(address: string, orders: TokenOrder[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    startMultipleTokenOrder<G extends boolean = false>(orders: TokenOrder[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /**
-     * @dev createNftWithDatatoken
-     *      Creates a new NFT, then a Datatoken,all in one call
-     * @param address Caller address
-     * @param _NftCreateData input data for nft creation
-     * @param _ErcCreateData input data for Datatoken creation
+     *  Creates a new NFT, then a datatoken,all in one call
+     * @param {NftCreateData} nftCreateData - The data required to create an NFT.
+     * @param {DatatokenCreateParams} dtParams - The parameters required to create a datatoken.
+     * @param {boolean} [estimateGas] - Whether to return only estimate gas or not.
      * @return {Promise<ReceiptOrEstimate>} transaction receipt
      */
-    createNftWithDatatoken<G extends boolean = false>(address: string, nftCreateData: NftCreateData, dtParams: DatatokenCreateParams, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-    /**
-     * @dev createNftWithDatatokenWithFixedRate
-     *      Creates a new NFT, then a Datatoken, then a FixedRateExchange, all in one call
-     *      Use this carefully, because if Fixed Rate creation fails, you are still going to pay a lot of gas
-     * @param address Caller address
-     * @param nftCreateData input data for NFT Creation
-     * @param dtParams input data for Datatoken Creation
-     * @param freParams input data for FixedRate Creation
-     *  @return {Promise<TransactionReceipt>} transaction receipt
-     */
-    createNftWithDatatokenWithFixedRate<G extends boolean = false>(address: string, nftCreateData: NftCreateData, dtParams: DatatokenCreateParams, freParams: FreCreationParams, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-    /**
-     * @dev createNftWithDatatokenWithDispenser
-     *      Creates a new NFT, then a Datatoken, then a Dispenser, all in one call
-     *      Use this carefully, because if Dispenser creation fails, you are still going to pay a lot of gas
-     * @param address Caller address
-     * @param nftCreateData input data for NFT Creation
-     * @param dtParams input data for Datatoken Creation
-     * @param dispenserParams input data for Dispenser Creation
-     *  @return {Promise<TransactionReceipt>} transaction receipt
-     */
-    createNftWithDatatokenWithDispenser<G extends boolean = false>(address: string, nftCreateData: NftCreateData, dtParams: DatatokenCreateParams, dispenserParams: DispenserCreationParams, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    createNftWithDatatoken<G extends boolean = false>(nftCreateData: NftCreateData, dtParams: DatatokenCreateParams, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Creates an NFT with a datatoken with a fixed rate  all in one call.
+     * be aware if Fixed Rate creation fails, you are still going to pay a lot of gas
+     * @param {NftCreateData} nftCreateData - The data required to create an NFT.
+     * @param {DatatokenCreateParams} dtParams - The parameters required to create a datatoken.
+     * @param {FreCreationParams} freParams - The parameters required to create a fixed-rate exchange contract.
+     * @param {boolean} [estimateGas] - Whether to return only estimate gas or not.
+     * @returns {Promis<ReceiptOrEstimate<G>>}
+     */
+    createNftWithDatatokenWithFixedRate<G extends boolean = false>(nftCreateData: NftCreateData, dtParams: DatatokenCreateParams, freParams: FreCreationParams, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Creates an NFT with a datatoken with a dispenser in one call.
+     * Be aware if Fixed Rate creation fails, you are still going to pay a lot of gas
+     * @param {NftCreateData} nftCreateData - The data required to create an NFT.
+     * @param {DatatokenCreateParams} dtParams - The parameters required to create a datatoken.
+     * @param {DispenserCreationParams} dispenserParams - The parameters required to create a dispenser contract.
+     * @param {boolean} [estimateGas] - Whether to estimate gas or not.
+     * @returns {Promis<ReceiptOrEstimate<G>>}
+     */
+    createNftWithDatatokenWithDispenser<G extends boolean = false>(nftCreateData: NftCreateData, dtParams: DatatokenCreateParams, dispenserParams: DispenserCreationParams, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Gets the parameters required to create an ERC20 token.
+     * @param {DatatokenCreateParams} dtParams - The parameters required to create a datatoken.
+     * @returns {Promise<any>}
+     */
     private getErcCreationParams;
+    /**
+     * Gets the parameters required to create a fixed-rate exchange contract.
+     * @param {FreCreationParams} freParams - The parameters required to create a fixed-rate exchange contract.
+     * @returns {Promise<any> }
+     */
     private getFreCreationParams;
 }

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

@@ -1,31 +1,39 @@
-import { AbiItem } from 'web3-utils';
-import { Operation, ReceiptOrEstimate } from '../@types';
+import { Operation, ReceiptOrEstimate, AbiItem } from '../@types';
 import { SmartContractWithAddress } from './SmartContractWithAddress';
 /**
  * Provides an interface for FactoryRouter contract
  */
 export declare class Router extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem | AbiItem[];
+    getDefaultAbi(): AbiItem[];
     /**
-     * buyDatatokenBatch
-     * @param {String} address
-     * @param {Operation} operations Operations objects array
+     * * Buys a batch of datatokens.
+     * one single call to buy multiple DT for multiple assets.
+     * require tokenIn approvals for router from user. (except for dispenser operations)
+     * @param {Operation[]} operations - The operations to execute.
+     * @param {boolean} [estimateGas=false] - Whether to return only the estimate gas or not.
      * @return {Promise<ReceiptOrEstimate>} Transaction receipt
      */
-    buyDatatokenBatch<G extends boolean = false>(address: string, operations: Operation[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-    /** Check if a token is on approved tokens list, if true opfFee is lower in pools with that token/DT
+    buyDatatokenBatch<G extends boolean = false>(operations: Operation[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Checks if a token is on approved tokens list,
+     * if true opfFee is lower in pools with that token/DT
+     * @param {string} address - The address of the token to check.
      * @return {Promise<boolean>} true if is on the list.
      */
     isApprovedToken(address: string): Promise<boolean>;
-    /** Check if an address is a Fixed Rate contract.
+    /**
+     * Check if an address is a Fixed Rate contract.
+     * @param {string} address - The address of the fixed rate exchange to check.
      * @return {Promise<boolean>} true if is a Fixed Rate contract
      */
     isFixedPrice(address: string): Promise<boolean>;
-    /** Get Router Owner
+    /**
+     * Get Router Owner
      * @return {Promise<string>} Router Owner address
      */
     getOwner(): Promise<string>;
-    /** Get NFT Factory address
+    /**
+     * Get NFT Factory address
      * @return {Promise<string>} NFT Factory address
      */
     getNFTFactory(): Promise<string>;
@@ -33,41 +41,47 @@ export declare class Router extends SmartContractWithAddress {
      * Adds a token to the list of tokens with reduced fees
      * @param {String} address caller address
      * @param {String} tokenAddress token address to add
+     * @param {Boolean} [estimateGas] if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
     addApprovedToken<G extends boolean = false>(address: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /**
      * Removes a token if exists from the list of tokens with reduced fees
-     * @param {String} address
-     * @param {String} tokenAddress address to remove
+     * @param {String} address caller address
+     * @param {String} tokenAddress token address to remove
+     * @param {Boolean} [estimateGas] if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
     removeApprovedToken<G extends boolean = false>(address: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /**
      * Adds an address to the list of fixed rate contracts
-     * @param {String} address
+     * @param {String} address caller address
      * @param {String} tokenAddress contract address to add
+     * @param {Boolean} [estimateGas] if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
     addFixedRateContract<G extends boolean = false>(address: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /**
      * Removes an address from the list of fixed rate contracts
-     * @param {String} address
+     * @param {String} address caller address
      * @param {String} tokenAddress contract address to add
+     * @param {Boolean} [estimateGas] if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
     removeFixedRateContract<G extends boolean = false>(address: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /**
      * Adds an address to the list of dispensers
-     * @param {String} address
+     * @param {String} address caller address
      * @param {String} tokenAddress contract address to add
+     * @param {Boolean} estimateGas if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
     addDispenserContract<G extends boolean = false>(address: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /**
      * Removes an address from the list of dispensers
-     * @param {String} address
+     * @param {String} address caller address
      * @param {String} tokenAddress address Contract to be removed
+     * @param {Boolean} estimateGas if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
     removeDispenserContract<G extends boolean = false>(address: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
@@ -81,11 +95,12 @@ export declare class Router extends SmartContractWithAddress {
     getCurrentOPCFee(): Promise<number>;
     /**
      * Updates OP Community Fees
-     * @param {String} address
+     * @param {String} address caller address
      * @param {number} newSwapOceanFee Amount charged for swapping with ocean approved tokens
      * @param {number} newSwapNonOceanFee Amount charged for swapping with non ocean approved tokens
      * @param {number} newConsumeFee Amount charged from consumeFees
      * @param {number} newProviderFee Amount charged for providerFees
+     * @param {Boolean} estimateGas if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
     updateOPCFee<G extends boolean = false>(address: string, newSwapOceanFee: number, newSwapNonOceanFee: number, newConsumeFee: number, newProviderFee: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;

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

@@ -1,22 +1,45 @@
-import Web3 from 'web3';
-import { Contract } from 'web3-eth-contract';
-import { AbiItem } from 'web3-utils';
+import { Signer, Contract } from 'ethers';
+import { AbiItem } from '../@types';
 import { Config } from '../config';
 export declare abstract class SmartContract {
-    web3: Web3;
+    signer: Signer;
     config: Config;
-    abi: AbiItem | AbiItem[];
-    abstract getDefaultAbi(): AbiItem | AbiItem[];
+    abi: AbiItem[];
+    abstract getDefaultAbi(): any;
     /**
      * Instantiate 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
+     * @param {Signer} signer The signer object.
+     * @param {string | number} [network] Network id or name
+     * @param {Config} [config] The configuration object.
+     * @param {AbiItem[]} [abi] ABI array of the smart contract
+     */
+    constructor(signer: Signer, network?: string | number, config?: Config, abi?: AbiItem[]);
+    /**
+     * Converts an amount of tokens to units
+     * @param {string} token - The token to convert
+     * @param {string} amount - The amount of tokens to convert
+     * @param {number} [tokenDecimals] - The number of decimals of the token
+     * @returns {Promise<string>} - The converted amount in units
      */
-    constructor(web3: Web3, network?: string | number, config?: Config, abi?: AbiItem | AbiItem[]);
     protected amountToUnits(token: string, amount: string, tokenDecimals?: number): Promise<string>;
+    /**
+     * Converts an amount of units to tokens
+     * @param {string} token - The token to convert
+     * @param {string} amount - The amount of units to convert
+     * @param {number} [tokenDecimals] - The number of decimals in the token
+     * @returns {Promise<string>} - The converted amount in tokens
+     */
     protected unitsToAmount(token: string, amount: string, tokenDecimals?: number): Promise<string>;
+    /**
+     * Retruns the gas price
+     * @returns {Promise<string>} - The fair gas price
+     */
     protected getFairGasPrice(): Promise<string>;
-    protected getContract(address: string, account?: string, abi?: AbiItem | AbiItem[]): Contract;
+    /**
+     * Returns a contract instance for the given address
+     * @param {string} address - The address of the contract
+     * @param {AbiItem[]} [abi] - The ABI of the contract
+     * @returns {Contract} - The contract instance
+     */
+    protected getContract(address: string, abi?: AbiItem[]): Contract;
 }

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

@@ -1,6 +1,5 @@
-import Web3 from 'web3';
-import { Contract } from 'web3-eth-contract';
-import { AbiItem } from 'web3-utils';
+import { Signer, Contract } from 'ethers';
+import { AbiItem } from '../@types';
 import { Config } from '../config';
 import { SmartContract } from './SmartContract';
 export declare abstract class SmartContractWithAddress extends SmartContract {
@@ -8,11 +7,11 @@ export declare abstract class SmartContractWithAddress extends SmartContract {
     contract: Contract;
     /**
      * Instantiate the smart contract.
-     * @param {string} address Address of the smart contract
-     * @param {Web3} web3
+     * @param {string} address The address of the contract.
+     * @param {Signer} signer The signer object.
      * @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
+     * @param {Config} config The configuration object.
+     * @param {AbiItem[]} abi ABI array of the smart contract
      */
-    constructor(address: string, web3: Web3, network?: string | number, config?: Config, abi?: AbiItem | AbiItem[]);
+    constructor(address: string, signer: Signer, network?: string | number, config?: Config, abi?: AbiItem[]);
 }

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

@@ -1,11 +1,10 @@
-import { AbiItem } from 'web3-utils';
 import { SmartContractWithAddress } from '../SmartContractWithAddress';
-import { ReceiptOrEstimate } from '../../@types';
+import { AbiItem, ReceiptOrEstimate } from '../../@types';
 /**
  * Provides an interface for DFRewards contract
  */
 export declare class DfRewards extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem | AbiItem[];
+    getDefaultAbi(): AbiItem[];
     /** Get available DF Rewards for a token
      * @param {String} userAddress user address
      * @param {String} tokenAddress token address
@@ -14,19 +13,19 @@ export declare class DfRewards extends SmartContractWithAddress {
     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
+     * @param {Boolean} estimateGas if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
-    claimRewards<G extends boolean = false>(fromUserAddress: string, userAddress: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    claimRewards<G extends boolean = false>(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
+     * @param {Boolean} estimateGas if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
-    allocateRewards<G extends boolean = false>(fromUserAddress: string, userAddresses: string[], amounts: string[], tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    allocateRewards<G extends boolean = false>(userAddresses: string[], amounts: string[], tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
 }

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

@@ -1,11 +1,10 @@
-import { AbiItem } from 'web3-utils';
 import { SmartContractWithAddress } from '../SmartContractWithAddress';
-import { ReceiptOrEstimate } from '../../@types';
+import { ReceiptOrEstimate, AbiItem } from '../../@types';
 /**
  * Provides an interface for dfStrategyV1 contract
  */
 export declare class DfStrategyV1 extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem | AbiItem[];
+    getDefaultAbi(): AbiItem[];
     /** Get available DF Rewards for multiple tokens
      * @param {String} userAddress user address
      * @param {String} tokenAddresses array of tokens
@@ -14,10 +13,9 @@ export declare class DfStrategyV1 extends SmartContractWithAddress {
     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>>;
+    claimMultipleRewards<G extends boolean = false>(userAddress: string, tokenAddresses: string[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
 }

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

@@ -1,31 +1,28 @@
-import { AbiItem } from 'web3-utils';
 import { SmartContractWithAddress } from '../SmartContractWithAddress';
-import { ReceiptOrEstimate } from '../../@types';
+import { ReceiptOrEstimate, AbiItem } from '../../@types';
 /**
  * Provides an interface for veOcean contract
  */
 export declare class VeAllocate extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem | AbiItem[];
+    getDefaultAbi(): AbiItem[];
     /**
      * set a specific percentage of veOcean to a specific nft
      * Maximum allocated percentage is 10000, so 1% is specified as 100
-     * @param {String} 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>>;
+    setAllocation<G extends boolean = false>(amount: string, nft: string, chainId: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /**
      * set specific percetage of veOcean to multiple nfts
      * Maximum allocated percentage is 10000, so 1% is specified as 100
-     * @param {String} 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>>;
+    setBatchAllocation<G extends boolean = false>(amount: string[], nft: string[], chainId: number[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /** Get totalAllocation for address
      * @param {String} userAddress user address
      * @return {Promise<number>}

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

@@ -1,11 +1,10 @@
-import { AbiItem } from 'web3-utils';
 import { SmartContractWithAddress } from '../SmartContractWithAddress';
-import { ReceiptOrEstimate } from '../../@types';
+import { ReceiptOrEstimate, AbiItem } from '../../@types';
 /**
  * Provides an interface for veOcean contract
  */
 export declare class VeFeeDistributor extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem | AbiItem[];
+    getDefaultAbi(): AbiItem[];
     /**
      * Claim fees for `userAddress`
      * Each call to claim look at a maximum of 50 user veOCEAN points.
@@ -13,18 +12,18 @@ export declare class VeFeeDistributor extends SmartContractWithAddress {
            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
+     * @param {Boolean} estimateGas if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
-    claim<G extends boolean = false>(userAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    claim<G extends boolean = false>(estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
     /**
      * Make multiple fee claims in a single call
       Used to claim for many accounts at once, or to make
            multiple claims for the same address when that address
            has significant veOCEAN history
-     * @param {String} fromUserAddress user address that sends the tx
      * @param {String} addresses array of addresses to claim
+     * @param {Boolean} estimateGas if True, return gas estimate
      * @return {Promise<ReceiptOrEstimate>}
      */
-    claimMany<G extends boolean = false>(fromUserAddress: string, addresses: string[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    claimMany<G extends boolean = false>(addresses: string[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
 }

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

@@ -1,10 +1,10 @@
-import { AbiItem } from 'web3-utils';
 import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { AbiItem } from '../../@types';
 /**
  * Provides an interface for veOcean contract
  */
 export declare class VeFeeEstimate extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem | AbiItem[];
+    getDefaultAbi(): AbiItem[];
     /**
      * estimateClaim
      * @param {String} userAddress user address