@curvefi/api 1.25.2 → 2.2.0

package/lib/index.d.ts

@@ -1,6 +1,6 @@
 import { ethers } from "ethers";
 import { Networkish } from "@ethersproject/networks";
-import { Pool } from "./pools";
+import { PoolTemplate } from "./pools";
 declare function init(providerType: 'JsonRpc' | 'Web3' | 'Infura' | 'Alchemy', providerSettings: {
     url?: string;
     privateKey?: string;
@@ -24,81 +24,65 @@ declare function setCustomFeeData(customFeeData: {
 }): void;
 declare const curve: {
     init: typeof init;
+    chainId: number;
+    signerAddress: string;
+    setCustomFeeData: typeof setCustomFeeData;
     fetchFactoryPools: typeof fetchFactoryPools;
     fetchCryptoFactoryPools: typeof fetchCryptoFactoryPools;
     getPoolList: () => string[];
     getFactoryPoolList: () => string[];
     getCryptoFactoryPoolList: () => string[];
+    getUserPoolList: (address?: string | undefined) => Promise<string[]>;
+    PoolTemplate: typeof PoolTemplate;
+    getPool: (poolId: string) => PoolTemplate;
     getUsdRate: (coin: string) => Promise<number>;
     getTVL: (chainId?: number) => Promise<number>;
-    setCustomFeeData: typeof setCustomFeeData;
-    signerAddress: string;
-    chainId: number;
-    Pool: typeof Pool;
-    getBalances: (coins: string[], ...addresses: string[] | string[][]) => Promise<string[] | import("./interfaces").DictInterface<string[]>>;
+    getBalances: (coins: string[], ...addresses: string[] | string[][]) => Promise<string[] | import("./interfaces").IDict<string[]>>;
     getAllowance: (coins: string[], address: string, spender: string) => Promise<string[]>;
-    hasAllowance: (coins: string[], amounts: string[], address: string, spender: string) => Promise<boolean>;
-    ensureAllowance: (coins: string[], amounts: string[], spender: string) => Promise<string[]>;
-    getBestPoolAndOutput: (inputCoin: string, outputCoin: string, amount: string) => Promise<{
-        poolName: string;
-        poolAddress: string;
-        output: string;
-    }>;
-    exchangeExpected: (inputCoin: string, outputCoin: string, amount: string) => Promise<string>;
-    exchangeIsApproved: (inputCoin: string, outputCoin: string, amount: string) => Promise<boolean>;
-    exchangeApprove: (inputCoin: string, outputCoin: string, amount: string) => Promise<string[]>;
-    exchange: (inputCoin: string, outputCoin: string, amount: string, maxSlippage?: number) => Promise<string>;
-    crossAssetExchangeAvailable: (inputCoin: string, outputCoin: string) => Promise<boolean>;
-    crossAssetExchangeOutputAndSlippage: (inputCoin: string, outputCoin: string, amount: string) => Promise<{
-        slippage: number;
-        output: string;
-    }>;
-    crossAssetExchangeExpected: (inputCoin: string, outputCoin: string, amount: string) => Promise<string>;
-    crossAssetExchangeIsApproved: (inputCoin: string, amount: string) => Promise<boolean>;
-    crossAssetExchangeApprove: (inputCoin: string, amount: string) => Promise<string[]>;
-    crossAssetExchange: (inputCoin: string, outputCoin: string, amount: string, maxSlippage?: number) => Promise<string>;
-    getUserPoolList: (address?: string | undefined) => Promise<string[]>;
-    getBestRouteAndOutput: (inputCoin: string, outputCoin: string, amount: string) => Promise<{
-        route: import("./interfaces").IRouteStep[];
-        output: string;
-    }>;
-    routerExchangeExpected: (inputCoin: string, outputCoin: string, amount: string) => Promise<string>;
-    routerExchangeIsApproved: (inputCoin: string, amount: string) => Promise<boolean>;
-    routerExchangeApprove: (inputCoin: string, amount: string) => Promise<string[]>;
-    routerExchange: (inputCoin: string, outputCoin: string, amount: string, maxSlippage?: number) => Promise<string>;
+    hasAllowance: (coins: string[], amounts: (string | number)[], address: string, spender: string) => Promise<boolean>;
+    ensureAllowance: (coins: string[], amounts: (string | number)[], spender: string) => Promise<string[]>;
     estimateGas: {
-        ensureAllowance: (coins: string[], amounts: string[], spender: string) => Promise<number>;
-        exchangeApprove: (inputCoin: string, outputCoin: string, amount: string) => Promise<number>;
-        exchange: (inputCoin: string, outputCoin: string, amount: string, maxSlippage?: number) => Promise<number>;
-        crossAssetExchangeApprove: (inputCoin: string, amount: string) => Promise<number>;
-        crossAssetExchange: (inputCoin: string, outputCoin: string, amount: string, maxSlippage?: number) => Promise<number>;
-        routerExchangeApprove: (inputCoin: string, amount: string) => Promise<number>;
-        routerExchange: (inputCoin: string, outputCoin: string, amount: string) => Promise<number>;
+        ensureAllowance: (coins: string[], amounts: (string | number)[], spender: string) => Promise<number>;
     };
     boosting: {
-        getCrv: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces").DictInterface<string>>;
-        getLockedAmountAndUnlockTime: (...addresses: string[] | string[][]) => Promise<import("./interfaces").DictInterface<{
+        getCrv: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces").IDict<string>>;
+        getLockedAmountAndUnlockTime: (...addresses: string[] | string[][]) => Promise<import("./interfaces").IDict<{
             lockedAmount: string;
             unlockTime: number;
         }> | {
             lockedAmount: string;
             unlockTime: number;
         }>;
-        getVeCrv: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces").DictInterface<string>>;
-        getVeCrvPct: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces").DictInterface<string>>;
-        isApproved: (amount: string) => Promise<boolean>;
-        approve: (amount: string) => Promise<string[]>;
-        createLock: (amount: string, days: number) => Promise<string>;
-        increaseAmount: (amount: string) => Promise<string>;
+        getVeCrv: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces").IDict<string>>;
+        getVeCrvPct: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces").IDict<string>>;
+        isApproved: (amount: string | number) => Promise<boolean>;
+        approve: (amount: string | number) => Promise<string[]>;
+        createLock: (amount: string | number, days: number) => Promise<string>;
+        increaseAmount: (amount: string | number) => Promise<string>;
         increaseUnlockTime: (days: number) => Promise<string>;
         withdrawLockedCrv: () => Promise<string>;
         estimateGas: {
-            approve: (amount: string) => Promise<number>;
-            createLock: (amount: string, days: number) => Promise<number>;
-            increaseAmount: (amount: string) => Promise<number>;
+            approve: (amount: string | number) => Promise<number>;
+            createLock: (amount: string | number, days: number) => Promise<number>;
+            increaseAmount: (amount: string | number) => Promise<number>;
             increaseUnlockTime: (days: number) => Promise<number>;
             withdrawLockedCrv: () => Promise<number>;
         };
     };
+    router: {
+        getBestRouteAndOutput: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<{
+            route: import("./interfaces").IRouteStep[];
+            output: string;
+        }>;
+        expected: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<string>;
+        priceImpact: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<string>;
+        isApproved: (inputCoin: string, amount: string | number) => Promise<boolean>;
+        approve: (inputCoin: string, amount: string | number) => Promise<string[]>;
+        swap: (inputCoin: string, outputCoin: string, amount: string | number, slippage?: number) => Promise<string>;
+        estimateGas: {
+            approve: (inputCoin: string, amount: string | number) => Promise<number>;
+            swap: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<number>;
+        };
+    };
 };
 export default curve;

package/lib/index.js

@@ -37,9 +37,11 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var pools_1 = require("./pools");
+var utils_1 = require("./pools/utils");
+var router_1 = require("./router");
 var curve_1 = require("./curve");
 var boosting_1 = require("./boosting");
-var utils_1 = require("./utils");
+var utils_2 = require("./utils");
 function init(providerType, providerSettings, options) {
     if (options === void 0) { options = {}; }
     return __awaiter(this, void 0, void 0, function () {
@@ -88,46 +90,25 @@ function setCustomFeeData(customFeeData) {
 }
 var curve = {
     init: init,
+    chainId: 0,
+    signerAddress: '',
+    setCustomFeeData: setCustomFeeData,
     fetchFactoryPools: fetchFactoryPools,
     fetchCryptoFactoryPools: fetchCryptoFactoryPools,
     getPoolList: utils_1.getPoolList,
     getFactoryPoolList: utils_1.getFactoryPoolList,
     getCryptoFactoryPoolList: utils_1.getCryptoFactoryPoolList,
-    getUsdRate: utils_1.getUsdRate,
-    getTVL: utils_1.getTVL,
-    setCustomFeeData: setCustomFeeData,
-    signerAddress: '',
-    chainId: 0,
-    Pool: pools_1.Pool,
-    getBalances: utils_1.getBalances,
-    getAllowance: utils_1.getAllowance,
-    hasAllowance: utils_1.hasAllowance,
-    ensureAllowance: utils_1.ensureAllowance,
-    getBestPoolAndOutput: pools_1.getBestPoolAndOutput,
-    exchangeExpected: pools_1.exchangeExpected,
-    exchangeIsApproved: pools_1.exchangeIsApproved,
-    exchangeApprove: pools_1.exchangeApprove,
-    exchange: pools_1.exchange,
-    crossAssetExchangeAvailable: pools_1.crossAssetExchangeAvailable,
-    crossAssetExchangeOutputAndSlippage: pools_1.crossAssetExchangeOutputAndSlippage,
-    crossAssetExchangeExpected: pools_1.crossAssetExchangeExpected,
-    crossAssetExchangeIsApproved: pools_1.crossAssetExchangeIsApproved,
-    crossAssetExchangeApprove: pools_1.crossAssetExchangeApprove,
-    crossAssetExchange: pools_1.crossAssetExchange,
-    getUserPoolList: pools_1.getUserPoolList,
-    getBestRouteAndOutput: pools_1.getBestRouteAndOutput,
-    routerExchangeExpected: pools_1.routerExchangeExpected,
-    routerExchangeIsApproved: pools_1.routerExchangeIsApproved,
-    routerExchangeApprove: pools_1.routerExchangeApprove,
-    routerExchange: pools_1.routerExchange,
+    getUserPoolList: utils_1.getUserPoolList,
+    PoolTemplate: pools_1.PoolTemplate,
+    getPool: pools_1.getPool,
+    getUsdRate: utils_2.getUsdRate,
+    getTVL: utils_2.getTVL,
+    getBalances: utils_2.getBalances,
+    getAllowance: utils_2.getAllowance,
+    hasAllowance: utils_2.hasAllowance,
+    ensureAllowance: utils_2.ensureAllowance,
     estimateGas: {
-        ensureAllowance: utils_1.ensureAllowanceEstimateGas,
-        exchangeApprove: pools_1.exchangeApproveEstimateGas,
-        exchange: pools_1.exchangeEstimateGas,
-        crossAssetExchangeApprove: pools_1.crossAssetExchangeApproveEstimateGas,
-        crossAssetExchange: pools_1.crossAssetExchangeEstimateGas,
-        routerExchangeApprove: pools_1.routerExchangeApproveEstimateGas,
-        routerExchange: pools_1.routerExchangeEstimateGas,
+        ensureAllowance: utils_2.ensureAllowanceEstimateGas,
     },
     boosting: {
         getCrv: boosting_1.getCrv,
@@ -148,5 +129,17 @@ var curve = {
             withdrawLockedCrv: boosting_1.withdrawLockedCrvEstimateGas,
         },
     },
+    router: {
+        getBestRouteAndOutput: router_1.getBestRouteAndOutput,
+        expected: router_1.swapExpected,
+        priceImpact: router_1.swapPriceImpact,
+        isApproved: router_1.swapIsApproved,
+        approve: router_1.swapApprove,
+        swap: router_1.swap,
+        estimateGas: {
+            approve: router_1.swapApproveEstimateGas,
+            swap: router_1.swapEstimateGas,
+        },
+    },
 };
 exports.default = curve;

package/lib/interfaces.d.ts

@@ -1,8 +1,42 @@
 import { Contract, ethers } from "ethers";
 import { Contract as MulticallContract, Provider as MulticallProvider } from "ethcall";
-export interface DictInterface<T> {
+export interface IDict<T> {
     [index: string]: T;
 }
+export declare type INetworkName = "ethereum" | "polygon" | "avalanche";
+export declare type REFERENCE_ASSET = 'USD' | 'EUR' | 'BTC' | 'ETH' | 'LINK' | 'CRYPTO' | 'OTHER';
+export interface IPoolData {
+    name: string;
+    full_name: string;
+    symbol: string;
+    reference_asset: REFERENCE_ASSET;
+    swap_address: string;
+    token_address: string;
+    gauge_address: string;
+    deposit_address?: string;
+    sCurveRewards_address?: string;
+    reward_contract?: string;
+    is_plain?: boolean;
+    is_lending?: boolean;
+    is_meta?: boolean;
+    is_crypto?: boolean;
+    is_fake?: boolean;
+    is_factory?: boolean;
+    base_pool?: string;
+    underlying_coins: string[];
+    wrapped_coins: string[];
+    underlying_coin_addresses: string[];
+    wrapped_coin_addresses: string[];
+    underlying_decimals: number[];
+    wrapped_decimals: number[];
+    use_lending?: boolean[];
+    reward_tokens?: string[];
+    reward_decimals?: number[];
+    swap_abi: any;
+    gauge_abi: any;
+    deposit_abi?: any;
+    sCurveRewards_abi?: any;
+}
 export interface ICurve {
     provider: ethers.providers.Web3Provider | ethers.providers.JsonRpcProvider;
     multicallProvider: MulticallProvider;
@@ -28,65 +62,16 @@ export interface ICurve {
         maxFeePerGas?: number | ethers.BigNumber;
         maxPriorityFeePerGas?: number | ethers.BigNumber;
     };
-    constants: DictInterface<any>;
-}
-export declare type REFERENCE_ASSET = 'USD' | 'EUR' | 'BTC' | 'ETH' | 'LINK' | 'CRYPTO' | 'OTHER';
-export interface PoolDataInterface {
-    name: string;
-    full_name: string;
-    symbol: string;
-    reference_asset: REFERENCE_ASSET;
-    N_COINS: number;
-    underlying_decimals: number[];
-    decimals: number[];
-    tethered?: boolean[];
-    use_lending: boolean[];
-    is_plain: boolean[];
-    has_eth?: boolean;
-    is_aave?: boolean;
-    is_new_underlying?: boolean;
-    old_swap_address?: string;
-    swap_address: string;
-    token_address: string;
-    gauge_address: string;
-    old_token_address?: string;
-    migration_address?: string;
-    deposit_address?: string;
-    underlying_coins: string[];
-    coins: string[];
-    underlying_coin_addresses: string[];
-    coin_addresses: string[];
-    swap_abi: any;
-    gauge_abi: any;
-    deposit_abi?: any;
-    old_swap_abi?: any;
-    is_meta?: boolean;
-    is_fake?: boolean;
-    is_crypto?: boolean;
-    meta_N?: number;
-    meta_decimals?: number[];
-    meta_coin_decimals?: number[];
-    meta_wrapped_decimals?: number[];
-    base_pool?: string;
-    meta_coin_addresses?: string[];
-    all_coin_addresses?: string[];
-    is_factory?: boolean;
-    is_plain_factory?: boolean;
-    is_meta_factory?: boolean;
-    is_crypto_factory?: boolean;
-    adapter_abi?: any;
-    old_adapter_address?: string;
-    adapter_biconomy_address?: string;
-    adapter_address?: string;
-    migration_abi?: any;
-    sCurveRewards_abi?: any;
-    sCurveRewards_address?: string;
-    aRewards_abi?: any;
-    aRewards_address?: string;
-    reward_token?: string;
-    reward_tokens?: string[];
-    pool_type?: string;
-    reward_contract?: string;
+    constants: {
+        NETWORK_NAME: INetworkName;
+        ALIASES: IDict<string>;
+        POOLS_DATA: IDict<IPoolData>;
+        FACTORY_POOLS_DATA: IDict<IPoolData>;
+        CRYPTO_FACTORY_POOLS_DATA: IDict<IPoolData>;
+        COINS: IDict<string>;
+        DECIMALS: IDict<number>;
+        GAUGES: string[];
+    };
 }
 export interface ICoinFromPoolDataApi {
     address: string;
@@ -117,34 +102,17 @@ export interface IPoolDataFromApi {
     gaugeRewards?: IReward[];
     usdTotal: number;
 }
+export interface ISubgraphPoolData {
+    address: string;
+    volumeUSD: number;
+    latestDailyApy: number;
+    latestWeeklyApy: number;
+}
 export interface IExtendedPoolDataFromApi {
     poolData: IPoolDataFromApi[];
     tvl?: number;
     tvlAll: number;
 }
-export interface IPoolStats {
-    volume: number;
-    apy: {
-        day: number;
-        week: number;
-        month: number;
-        total: number;
-    };
-}
-export interface IStats {
-    [index: string]: IPoolStats;
-}
-export interface ISinglePoolSwapData {
-    poolName: string;
-    poolAddress: string;
-    i: number;
-    j: number;
-    swapType: 1 | 2 | 3 | 4 | 5;
-    swapAddress: string;
-}
-export interface ISinglePoolSwapDataAndOutput extends ISinglePoolSwapData {
-    _output: ethers.BigNumber;
-}
 export interface IRouteStep {
     poolId: string;
     poolAddress: string;

package/lib/pools/PoolTemplate.d.ts

@@ -0,0 +1,212 @@
+import { IDict, IReward } from '../interfaces';
+export declare class PoolTemplate {
+    id: string;
+    name: string;
+    fullName: string;
+    symbol: string;
+    referenceAsset: string;
+    address: string;
+    lpToken: string;
+    gauge: string;
+    zap: string | null;
+    rewardContract: string | null;
+    isPlain: boolean;
+    isLending: boolean;
+    isMeta: boolean;
+    isCrypto: boolean;
+    isFake: boolean;
+    isFactory: boolean;
+    isMetaFactory: boolean;
+    basePool: string;
+    underlyingCoins: string[];
+    wrappedCoins: string[];
+    underlyingCoinAddresses: string[];
+    wrappedCoinAddresses: string[];
+    underlyingDecimals: number[];
+    wrappedDecimals: number[];
+    useLending: boolean[];
+    rewardTokens: string[];
+    estimateGas: {
+        depositApprove: (amounts: (number | string)[]) => Promise<number>;
+        deposit: (amounts: (number | string)[]) => Promise<number>;
+        depositWrappedApprove: (amounts: (number | string)[]) => Promise<number>;
+        depositWrapped: (amounts: (number | string)[]) => Promise<number>;
+        stakeApprove: (lpTokenAmount: number | string) => Promise<number>;
+        stake: (lpTokenAmount: number | string) => Promise<number>;
+        unstake: (lpTokenAmount: number | string) => Promise<number>;
+        claimCrv: () => Promise<number>;
+        claimRewards: () => Promise<number>;
+        depositAndStakeApprove: (amounts: (number | string)[]) => Promise<number>;
+        depositAndStake: (amounts: (number | string)[]) => Promise<number>;
+        depositAndStakeWrappedApprove: (amounts: (number | string)[]) => Promise<number>;
+        depositAndStakeWrapped: (amounts: (number | string)[]) => Promise<number>;
+        withdrawApprove: (lpTokenAmount: number | string) => Promise<number>;
+        withdraw: (lpTokenAmount: number | string) => Promise<number>;
+        withdrawWrapped: (lpTokenAmount: number | string) => Promise<number>;
+        withdrawImbalanceApprove: (amounts: (number | string)[]) => Promise<number>;
+        withdrawImbalance: (amounts: (number | string)[]) => Promise<number>;
+        withdrawImbalanceWrapped: (amounts: (number | string)[]) => Promise<number>;
+        withdrawOneCoinApprove: (lpTokenAmount: number | string, coin: string | number) => Promise<number>;
+        withdrawOneCoin: (lpTokenAmount: number | string, coin: string | number) => Promise<number>;
+        withdrawOneCoinWrapped: (lpTokenAmount: number | string, coin: string | number) => Promise<number>;
+        swapApprove: (inputCoin: string | number, amount: number | string) => Promise<number>;
+        swap: (inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage: number) => Promise<number>;
+        swapWrappedApprove: (inputCoin: string | number, amount: number | string) => Promise<number>;
+        swapWrapped: (inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage: number) => Promise<number>;
+    };
+    stats: {
+        parameters: () => Promise<{
+            virtualPrice: string;
+            fee: string;
+            adminFee: string;
+            A: string;
+            future_A?: string;
+            initial_A?: string;
+            future_A_time?: number;
+            initial_A_time?: number;
+            gamma?: string;
+        }>;
+        underlyingBalances: () => Promise<string[]>;
+        wrappedBalances: () => Promise<string[]>;
+        totalLiquidity: (useApi?: boolean) => Promise<string>;
+        volume: () => Promise<string>;
+        baseApy: () => Promise<{
+            day: string;
+            week: string;
+        }>;
+        tokenApy: () => Promise<[baseApy: string, boostedApy: string]>;
+        rewardsApy: () => Promise<IReward[]>;
+    };
+    wallet: {
+        balances: (...addresses: string[] | string[][]) => Promise<IDict<IDict<string>> | IDict<string>>;
+        lpTokenBalances: (...addresses: string[] | string[][]) => Promise<IDict<IDict<string>> | IDict<string>>;
+        underlyingCoinBalances: (...addresses: string[] | string[][]) => Promise<IDict<IDict<string>> | IDict<string>>;
+        wrappedCoinBalances: (...addresses: string[] | string[][]) => Promise<IDict<IDict<string>> | IDict<string>>;
+        allCoinBalances: (...addresses: string[] | string[][]) => Promise<IDict<IDict<string>> | IDict<string>>;
+    };
+    constructor(id: string);
+    private statsParameters;
+    private statsWrappedBalances;
+    private statsUnderlyingBalances;
+    private statsTotalLiquidity;
+    private statsVolume;
+    private statsBaseApy;
+    private statsTokenApy;
+    private statsRewardsApy;
+    private _calcLpTokenAmount;
+    private calcLpTokenAmount;
+    private calcLpTokenAmountWrapped;
+    depositBalancedAmounts(): Promise<string[]>;
+    depositExpected(amounts: (number | string)[]): Promise<string>;
+    depositBonus(amounts: (number | string)[]): Promise<string>;
+    depositIsApproved(amounts: (number | string)[]): Promise<boolean>;
+    private depositApproveEstimateGas;
+    depositApprove(amounts: (number | string)[]): Promise<string[]>;
+    private depositEstimateGas;
+    deposit(amounts: (number | string)[], slippage?: number): Promise<string>;
+    depositWrappedBalancedAmounts(): Promise<string[]>;
+    depositWrappedExpected(amounts: (number | string)[]): Promise<string>;
+    depositWrappedBonus(amounts: (number | string)[]): Promise<string>;
+    depositWrappedIsApproved(amounts: (number | string)[]): Promise<boolean>;
+    private depositWrappedApproveEstimateGas;
+    depositWrappedApprove(amounts: (number | string)[]): Promise<string[]>;
+    private depositWrappedEstimateGas;
+    depositWrapped(amounts: (number | string)[], slippage?: number): Promise<string>;
+    stakeIsApproved(lpTokenAmount: number | string): Promise<boolean>;
+    private stakeApproveEstimateGas;
+    stakeApprove(lpTokenAmount: number | string): Promise<string[]>;
+    private stakeEstimateGas;
+    stake(lpTokenAmount: number | string): Promise<string>;
+    private unstakeEstimateGas;
+    unstake(lpTokenAmount: number | string): Promise<string>;
+    claimableCrv(address?: string): Promise<string>;
+    claimCrvEstimateGas(): Promise<number>;
+    claimCrv(): Promise<string>;
+    claimableRewards(address?: string): Promise<{
+        token: string;
+        symbol: string;
+        amount: string;
+    }[]>;
+    claimRewardsEstimateGas(): Promise<number>;
+    claimRewards(): Promise<string>;
+    depositAndStakeExpected(amounts: (number | string)[]): Promise<string>;
+    depositAndStakeBonus(amounts: (number | string)[]): Promise<string>;
+    depositAndStakeIsApproved(amounts: (number | string)[]): Promise<boolean>;
+    private depositAndStakeApproveEstimateGas;
+    depositAndStakeApprove(amounts: (number | string)[]): Promise<string[]>;
+    private depositAndStakeEstimateGas;
+    depositAndStake(amounts: (number | string)[]): Promise<string>;
+    depositAndStakeWrappedExpected(amounts: (number | string)[]): Promise<string>;
+    depositAndStakeWrappedBonus(amounts: (number | string)[]): Promise<string>;
+    depositAndStakeWrappedIsApproved(amounts: (number | string)[]): Promise<boolean>;
+    private depositAndStakeWrappedApproveEstimateGas;
+    depositAndStakeWrappedApprove(amounts: (number | string)[]): Promise<string[]>;
+    private depositAndStakeWrappedEstimateGas;
+    depositAndStakeWrapped(amounts: (number | string)[]): Promise<string>;
+    private _depositAndStake;
+    withdrawExpected(lpTokenAmount: number | string): Promise<string[]>;
+    withdrawIsApproved(lpTokenAmount: number | string): Promise<boolean>;
+    private withdrawApproveEstimateGas;
+    withdrawApprove(lpTokenAmount: number | string): Promise<string[]>;
+    private withdrawEstimateGas;
+    withdraw(lpTokenAmount: number | string, slippage?: number): Promise<string>;
+    withdrawWrappedExpected(lpTokenAmount: number | string): Promise<string[]>;
+    private withdrawWrappedEstimateGas;
+    withdrawWrapped(lpTokenAmount: number | string, slippage?: number): Promise<string>;
+    withdrawImbalanceExpected(amounts: (number | string)[]): Promise<string>;
+    withdrawImbalanceBonus(amounts: (number | string)[]): Promise<string>;
+    withdrawImbalanceIsApproved(amounts: (number | string)[]): Promise<boolean>;
+    private withdrawImbalanceApproveEstimateGas;
+    withdrawImbalanceApprove(amounts: (number | string)[]): Promise<string[]>;
+    private withdrawImbalanceEstimateGas;
+    withdrawImbalance(amounts: (number | string)[], slippage?: number): Promise<string>;
+    withdrawImbalanceWrappedExpected(amounts: (number | string)[]): Promise<string>;
+    withdrawImbalanceWrappedBonus(amounts: (number | string)[]): Promise<string>;
+    private withdrawImbalanceWrappedEstimateGas;
+    withdrawImbalanceWrapped(amounts: (number | string)[], slippage?: number): Promise<string>;
+    private _withdrawOneCoinExpected;
+    withdrawOneCoinExpected(lpTokenAmount: number | string, coin: string | number): Promise<string>;
+    withdrawOneCoinBonus(lpTokenAmount: number | string, coin: string | number): Promise<string>;
+    withdrawOneCoinIsApproved(lpTokenAmount: number | string): Promise<boolean>;
+    private withdrawOneCoinApproveEstimateGas;
+    withdrawOneCoinApprove(lpTokenAmount: number | string): Promise<string[]>;
+    private withdrawOneCoinEstimateGas;
+    withdrawOneCoin(lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
+    private _withdrawOneCoinWrappedExpected;
+    withdrawOneCoinWrappedExpected(lpTokenAmount: number | string, coin: string | number): Promise<string>;
+    withdrawOneCoinWrappedBonus(lpTokenAmount: number | string, coin: string | number): Promise<string>;
+    private withdrawOneCoinWrappedEstimateGas;
+    withdrawOneCoinWrapped(lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
+    private walletBalances;
+    private walletLpTokenBalances;
+    private walletUnderlyingCoinBalances;
+    private walletWrappedCoinBalances;
+    private walletAllCoinBalances;
+    private _swapExpected;
+    swapExpected(inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<string>;
+    swapPriceImpact(inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<string>;
+    private _swapContractAddress;
+    swapIsApproved(inputCoin: string | number, amount: number | string): Promise<boolean>;
+    private swapApproveEstimateGas;
+    swapApprove(inputCoin: string | number, amount: number | string): Promise<string[]>;
+    private swapEstimateGas;
+    swap(inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
+    private _swapWrappedExpected;
+    swapWrappedExpected(inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<string>;
+    swapWrappedPriceImpact(inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<string>;
+    swapWrappedIsApproved(inputCoin: string | number, amount: number | string): Promise<boolean>;
+    private swapWrappedApproveEstimateGas;
+    swapWrappedApprove(inputCoin: string | number, amount: number | string): Promise<string[]>;
+    private swapWrappedEstimateGas;
+    swapWrapped(inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
+    gaugeMaxBoostedDeposit: (...addresses: string[]) => Promise<IDict<string>>;
+    gaugeOptimalDeposits: (...accounts: string[]) => Promise<IDict<string>>;
+    boost: (address: string) => Promise<string>;
+    private _getCoinIdx;
+    private _getRates;
+    private _balances;
+    private _underlyingPrices;
+    private _wrappedPrices;
+    private _withdrawCryptoBonus;
+    private _withdrawBonus;
+}