@curvefi/api 2.66.29 → 2.66.31

package/lib/cached.d.ts

@@ -1,5 +1,6 @@
 import { IDict, IExtendedPoolDataFromApi, INetworkName, IPoolType } from "./interfaces.js";
 export declare const _getPoolsFromApi: (network: INetworkName, poolType: IPoolType, isLiteChain?: boolean) => Promise<IExtendedPoolDataFromApi>;
-export declare const _getAllPoolsFromApi: (network: INetworkName, isLiteChain?: boolean) => Promise<IExtendedPoolDataFromApi[]>;
-export declare const _getUsdPricesFromApi: () => Promise<IDict<number>>;
-export declare const _getCrvApyFromApi: () => Promise<IDict<[number, number]>>;
+export declare const _setPoolsFromApi: (network: INetworkName, isLiteChain: boolean, data: Record<IPoolType, IExtendedPoolDataFromApi>) => void;
+export declare const _getAllPoolsFromApi: (network: INetworkName, isLiteChain: boolean) => Promise<IExtendedPoolDataFromApi[]>;
+export declare const _getUsdPricesFromApi: (network: INetworkName, isLiteChain: boolean) => Promise<IDict<number>>;
+export declare const _getCrvApyFromApi: (network: INetworkName, isLiteChain: boolean) => Promise<IDict<[number, number]>>;

package/lib/cached.js

@@ -7,39 +7,83 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import memoize from "memoizee";
-import { uncached_getAllPoolsFromApi, createCrvApyDict, createUsdPricesDict } from './external-api.js';
-import { curve } from "./curve";
+import { createCrvApyDict, createUsdPricesDict, uncached_getAllPoolsFromApi } from './external-api.js';
 /**
- * This function is used to cache the data fetched from the API and the data derived from it.
- * Note: do not expose this function to the outside world, instead encapsulate it in a function that returns the data you need.
+ * Memoizes a function that returns a promise.
+ * Custom function instead of `memoizee` because we want to be able to set the cache manually based on server data.
+ * @param fn The function that returns a promise and will be memoized
+ * @param maxAge The maximum age of the cache in milliseconds
+ * @param createKey A function that creates a key for the cache based on the arguments passed to the function
+ * @returns A memoized `fn` function that includes a `set` method to set the cache manually
  */
-const _getCachedData = memoize((network, isLiteChain) => __awaiter(void 0, void 0, void 0, function* () {
-    const poolsDict = yield uncached_getAllPoolsFromApi(network, isLiteChain);
+const memoize = (fn, { maxAge, createKey = (list) => list.toString(), }) => {
+    const cache = {};
+    const timeouts = {};
+    const setCache = (key, promise) => {
+        if (promise) {
+            cache[key] = promise;
+        }
+        else if (key in cache) {
+            delete cache[key];
+        }
+        if (key in timeouts) {
+            clearTimeout(timeouts[key]);
+            delete timeouts[key];
+        }
+    };
+    const scheduleCleanup = (key) => timeouts[key] = setTimeout(() => {
+        delete timeouts[key];
+        delete cache[key];
+    }, maxAge);
+    const cachedFn = (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        const key = createKey(args);
+        if (key in cache) {
+            return cache[key];
+        }
+        const promise = fn(...args);
+        setCache(key, promise);
+        try {
+            const result = yield promise;
+            scheduleCleanup(key);
+            return result;
+        }
+        catch (e) {
+            delete cache[key];
+            throw e;
+        }
+    });
+    cachedFn.set = (result, ...args) => {
+        const key = createKey(args);
+        setCache(key, Promise.resolve(result));
+        scheduleCleanup(key);
+    };
+    return cachedFn;
+};
+const createCache = (poolsDict) => {
     const poolLists = Object.values(poolsDict);
     const usdPrices = createUsdPricesDict(poolLists);
     const crvApy = createCrvApyDict(poolLists);
     return { poolsDict, poolLists, usdPrices, crvApy };
-}), {
-    promise: true,
-    maxAge: 5 * 60 * 1000, // 5m
-    primitive: true,
-});
+};
+/**
+ * This function is used to cache the data fetched from the API and the data derived from it.
+ * Note: do not expose this function to the outside world, instead encapsulate it in a function that returns the data you need.
+ */
+const _getCachedData = memoize((network, isLiteChain) => __awaiter(void 0, void 0, void 0, function* () { return createCache(yield uncached_getAllPoolsFromApi(network, isLiteChain)); }), { maxAge: 1000 * 60 * 5 /* 5 minutes */ });
 export const _getPoolsFromApi = (network_1, poolType_1, ...args_1) => __awaiter(void 0, [network_1, poolType_1, ...args_1], void 0, function* (network, poolType, isLiteChain = false) {
     const { poolsDict } = yield _getCachedData(network, isLiteChain);
     return poolsDict[poolType];
 });
-export const _getAllPoolsFromApi = (network_1, ...args_1) => __awaiter(void 0, [network_1, ...args_1], void 0, function* (network, isLiteChain = false) {
+export const _setPoolsFromApi = (network, isLiteChain, data) => _getCachedData.set(createCache(data), network, isLiteChain);
+export const _getAllPoolsFromApi = (network, isLiteChain) => __awaiter(void 0, void 0, void 0, function* () {
     const { poolLists } = yield _getCachedData(network, isLiteChain);
     return poolLists;
 });
-export const _getUsdPricesFromApi = () => __awaiter(void 0, void 0, void 0, function* () {
-    const network = curve.constants.NETWORK_NAME;
-    const { usdPrices } = yield _getCachedData(network, false);
+export const _getUsdPricesFromApi = (network, isLiteChain) => __awaiter(void 0, void 0, void 0, function* () {
+    const { usdPrices } = yield _getCachedData(network, isLiteChain);
     return usdPrices;
 });
-export const _getCrvApyFromApi = () => __awaiter(void 0, void 0, void 0, function* () {
-    const network = curve.constants.NETWORK_NAME;
-    const { crvApy } = yield _getCachedData(network, false);
+export const _getCrvApyFromApi = (network, isLiteChain) => __awaiter(void 0, void 0, void 0, function* () {
+    const { crvApy } = yield _getCachedData(network, isLiteChain);
     return crvApy;
 });

package/lib/constants/utils.d.ts

@@ -1,6 +1,19 @@
 import { IDict, IPoolData } from "../interfaces.js";
+import { BigNumberish, Numeric } from "ethers";
+import { Curve } from "../curve";
+export declare const formatUnits: (value: BigNumberish, unit?: string | Numeric) => string;
+export declare const parseUnits: (value: string, unit?: string | Numeric) => bigint;
 export declare const lowerCasePoolDataAddresses: (poolsData: IDict<IPoolData>) => IDict<IPoolData>;
 export declare const extractDecimals: (poolsData: IDict<IPoolData>) => IDict<number>;
-export declare const extractGauges: (poolsData: IDict<IPoolData>) => string[];
+export declare function extractGauges(this: Curve, poolsData: IDict<IPoolData>): string[];
 export declare const lowerCaseValues: (dict: IDict<string>) => IDict<string>;
 export declare const lowerCaseKeys: (dict: IDict<any>) => IDict<any>;
+/**
+ * Memoizes a method of an object by binding it to this when needed.
+ * The memoized method will cache the result for 5 minutes.
+ * @param obj The object to which the method belongs.
+ * @param name The name of the method to memoize. It must be unique within the object.
+ * @param method The method to memoize. It must be a function that returns a Promise.
+ * @returns The memoized method.
+ */
+export declare const memoizeMethod: <Obj extends object, Method extends (this: Obj, ...params: any[]) => Promise<unknown>>(obj: Obj, name: string, method: Method) => Method;

package/lib/constants/utils.js

@@ -1,4 +1,7 @@
-import { curve } from "../curve.js";
+import { ethers } from "ethers";
+import memoize from "memoizee";
+export const formatUnits = (value, unit) => ethers.formatUnits(value, unit);
+export const parseUnits = (value, unit) => ethers.parseUnits(value, unit);
 export const lowerCasePoolDataAddresses = (poolsData) => {
     for (const poolId in poolsData) {
         if (!Object.prototype.hasOwnProperty.call(poolsData, poolId))
@@ -37,20 +40,32 @@ export const extractDecimals = (poolsData) => {
     }
     return DECIMALS;
 };
-export const extractGauges = (poolsData) => {
+export function extractGauges(poolsData) {
     const GAUGES = [];
     for (const poolData of Object.values(poolsData)) {
-        if (poolData.gauge_address === curve.constants.ZERO_ADDRESS)
+        if (poolData.gauge_address === this.constants.ZERO_ADDRESS)
             continue;
         GAUGES.push(poolData.gauge_address);
     }
     return GAUGES;
-};
+}
 export const lowerCaseValues = (dict) => {
-    // @ts-ignore
     return Object.fromEntries(Object.entries(dict).map((entry) => [entry[0], entry[1].toLowerCase()]));
 };
 export const lowerCaseKeys = (dict) => {
-    // @ts-ignore
     return Object.fromEntries(Object.entries(dict).map((entry) => [entry[0].toLowerCase(), entry[1]]));
 };
+/**
+ * Memoizes a method of an object by binding it to this when needed.
+ * The memoized method will cache the result for 5 minutes.
+ * @param obj The object to which the method belongs.
+ * @param name The name of the method to memoize. It must be unique within the object.
+ * @param method The method to memoize. It must be a function that returns a Promise.
+ * @returns The memoized method.
+ */
+export const memoizeMethod = (obj, name, method) => {
+    if (!(name in obj)) {
+        obj[name] = memoize(method.bind(obj), { promise: true, maxAge: 5 * 60 * 1000 /* 5m */ });
+    }
+    return obj[name];
+};

package/lib/curve.d.ts

@@ -1,6 +1,6 @@
-import { ethers, Contract, Networkish, BigNumberish, Numeric, BrowserProvider, JsonRpcProvider, Signer } from "ethers";
-import { Provider as MulticallProvider, Contract as MulticallContract } from "@curvefi/ethcall";
-import { IPoolData, IDict, ICurve, IChainId, IFactoryPoolType, Abi, INetworkConstants } from "./interfaces";
+import { BigNumberish, BrowserProvider, Contract, ethers, JsonRpcProvider, Networkish, Numeric, Signer } from "ethers";
+import { Contract as MulticallContract, Provider as MulticallProvider } from "@curvefi/ethcall";
+import { IPoolData, IDict, ICurve, IChainId, IFactoryPoolType, Abi, INetworkConstants, IPoolType, IExtendedPoolDataFromApi } from "./interfaces";
 export declare const OLD_CHAINS: number[];
 export declare const memoizedContract: () => (address: string, abi: any, provider: BrowserProvider | JsonRpcProvider | Signer) => Contract;
 export declare const memoizedMulticallContract: () => (address: string, abi: any) => MulticallContract;
@@ -9,7 +9,7 @@ export type ContractItem = {
     multicallContract: MulticallContract;
     abi: Abi;
 };
-declare class Curve implements ICurve {
+export declare class Curve implements ICurve {
     provider: ethers.BrowserProvider | ethers.JsonRpcProvider;
     isNoRPC: boolean;
     multicallProvider: MulticallProvider;
@@ -50,6 +50,7 @@ declare class Curve implements ICurve {
         maxFeePerGas?: number;
         maxPriorityFeePerGas?: number;
         chainId?: number;
+        poolsData?: Record<IPoolType, IExtendedPoolDataFromApi>;
     }): Promise<void>;
     initContract: (address: string, abi: any, provider: BrowserProvider | JsonRpcProvider | Signer) => Contract;
     initMulticallContract: (address: string, abi: any) => MulticallContract;
@@ -96,4 +97,3 @@ declare class Curve implements ICurve {
     getIsLiteChain: () => boolean;
 }
 export declare const curve: Curve;
-export {};

package/lib/curve.js

@@ -7,10 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { ethers, Contract, AbstractProvider, } from "ethers";
-import { Provider as MulticallProvider, Contract as MulticallContract } from "@curvefi/ethcall";
+import { AbstractProvider, Contract, ethers, } from "ethers";
+import { Contract as MulticallContract, Provider as MulticallProvider } from "@curvefi/ethcall";
 import { NETWORK_CONSTANTS } from "./constants/network_constants.js";
-import { STABLE_FACTORY_CONSTANTS, CRYPTO_FACTORY_CONSTANTS } from "./constants/factory/index.js";
+import { CRYPTO_FACTORY_CONSTANTS, STABLE_FACTORY_CONSTANTS } from "./constants/factory/index.js";
 import { getFactoryPoolData } from "./factory/factory.js";
 import { getFactoryPoolsDataFromApi } from "./factory/factory-api.js";
 import { getCryptoFactoryPoolData } from "./factory/factory-crypto.js";
@@ -47,12 +47,13 @@ import gasOracleABI from './constants/abis/gas_oracle_optimism.json' with { type
 import gasOracleBlobABI from './constants/abis/gas_oracle_optimism_blob.json' with { type: 'json' };
 import votingProposalABI from './constants/abis/voting_proposal.json' with { type: 'json' };
 import circulatingSupplyABI from './constants/abis/circulating_supply.json' with { type: 'json' };
-import rootGaugeFactoryABI from "./constants/abis/gauge_factory/root_gauge_factory.json" with { type: 'json' };
-import { lowerCasePoolDataAddresses, extractDecimals, extractGauges } from "./constants/utils.js";
+import rootGaugeFactoryABI from "./constants/abis/gauge_factory/root_gauge_factory.json" with { type: "json" };
+import { extractDecimals, extractGauges, formatUnits, lowerCasePoolDataAddresses, parseUnits, } from "./constants/utils.js";
 import { _getHiddenPools } from "./external-api.js";
 import { L2Networks } from "./constants/L2Networks.js";
 import { getTwocryptoFactoryPoolData } from "./factory/factory-twocrypto.js";
 import { getNetworkConstants } from "./utils.js";
+import { _setPoolsFromApi } from "./cached";
 export const OLD_CHAINS = [1, 10, 56, 100, 137, 250, 1284, 2222, 8453, 42161, 42220, 43114, 1313161554]; // these chains have non-ng pools
 export const memoizedContract = () => {
     const cache = {};
@@ -80,7 +81,7 @@ export const memoizedMulticallContract = () => {
         }
     };
 };
-class Curve {
+export class Curve {
     constructor() {
         this.initContract = memoizedContract();
         this.initMulticallContract = memoizedMulticallContract();
@@ -322,15 +323,12 @@ class Curve {
         this.getIsLiteChain = () => {
             return this.isLiteChain;
         };
-        // @ts-ignore
         this.provider = null;
-        // @ts-ignore
         this.signer = null;
         this.isNoRPC = false;
         this.signerAddress = '';
         this.chainId = 1;
         this.isLiteChain = false;
-        // @ts-ignore
         this.multicallProvider = null;
         this.contracts = {};
         this.feeData = {};
@@ -363,14 +361,11 @@ class Curve {
         return __awaiter(this, arguments, void 0, function* (providerType, providerSettings, options = {} // gasPrice in Gwei
         ) {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-            // @ts-ignore
             this.provider = null;
-            // @ts-ignore
             this.signer = null;
             this.isNoRPC = false;
             this.signerAddress = '';
             this.chainId = 1;
-            // @ts-ignore
             this.multicallProvider = null;
             this.contracts = {};
             this.feeData = {};
@@ -422,7 +417,7 @@ class Curve {
                     try {
                         this.signer = yield this.provider.getSigner();
                     }
-                    catch (e) {
+                    catch (_l) {
                         this.signer = null;
                     }
                 }
@@ -459,7 +454,7 @@ class Curve {
             console.log("CURVE-JS IS CONNECTED TO NETWORK:", { name: network.name.toUpperCase(), chainId: Number(network.chainId) });
             this.chainId = Number(network.chainId) === 133 || Number(network.chainId) === 31337 ? 1 : Number(network.chainId);
             this.isLiteChain = !(this.chainId in NETWORK_CONSTANTS);
-            const network_constants = yield getNetworkConstants(this.chainId);
+            const network_constants = yield getNetworkConstants.call(this, this.chainId);
             this.constants.NATIVE_TOKEN = network_constants.NATIVE_COIN;
             this.constants.NETWORK_NAME = network_constants.NAME;
             this.constants.ALIASES = network_constants.ALIASES;
@@ -473,7 +468,7 @@ class Curve {
             this.constants.DECIMALS = extractDecimals(Object.assign(Object.assign({}, this.constants.POOLS_DATA), this.constants.LLAMMAS_DATA));
             this.constants.DECIMALS[this.constants.NATIVE_TOKEN.address] = 18;
             this.constants.DECIMALS[this.constants.NATIVE_TOKEN.wrappedAddress] = 18;
-            this.constants.GAUGES = extractGauges(this.constants.POOLS_DATA);
+            this.constants.GAUGES = extractGauges.call(this, this.constants.POOLS_DATA);
             if (this.isLiteChain) {
                 this.constants.API_CONSTANTS = network_constants.API_CONSTANTS;
             }
@@ -499,7 +494,7 @@ class Curve {
                 try {
                     this.signerAddress = yield this.signer.getAddress();
                 }
-                catch (err) {
+                catch (_m) {
                     this.signer = null;
                 }
             }
@@ -507,6 +502,9 @@ class Curve {
                 this.signerAddress = '';
             }
             this.feeData = { gasPrice: options.gasPrice, maxFeePerGas: options.maxFeePerGas, maxPriorityFeePerGas: options.maxPriorityFeePerGas };
+            if (options.poolsData) {
+                _setPoolsFromApi(this.constants.NETWORK_NAME, this.isLiteChain, options.poolsData);
+            }
             yield this.updateFeeData();
             for (const pool of Object.values(Object.assign(Object.assign({}, this.constants.POOLS_DATA), this.constants.LLAMMAS_DATA))) {
                 this.setContract(pool.swap_address, pool.swap_abi);
@@ -619,25 +617,15 @@ class Curve {
                 const curveInstance = this;
                 curveInstance.setContract(curveInstance.constants.ALIASES.gas_oracle, gasOracleABI);
                 curveInstance.setContract(curveInstance.constants.ALIASES.gas_oracle_blob, gasOracleBlobABI);
-                // @ts-ignore
-                if (AbstractProvider.prototype.originalEstimate) {
-                    // @ts-ignore
+                if ('originalEstimate' in AbstractProvider.prototype) {
                     AbstractProvider.prototype.estimateGas = AbstractProvider.prototype.originalEstimate;
                 }
                 const originalEstimate = AbstractProvider.prototype.estimateGas;
-                const oldEstimate = function (arg) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        // @ts-ignore
-                        const originalEstimateFunc = originalEstimate.bind(this);
-                        const gas = yield originalEstimateFunc(arg);
-                        return gas;
-                    });
-                };
+                const oldEstimate = originalEstimate.bind(this);
                 //Override
                 const newEstimate = function (arg) {
                     return __awaiter(this, void 0, void 0, function* () {
-                        // @ts-ignore
-                        const L2EstimateGas = originalEstimate.bind(this);
+                        const L2EstimateGas = oldEstimate;
                         const L1GasUsed = yield curveInstance.contracts[curveInstance.constants.ALIASES.gas_oracle_blob].contract.getL1GasUsed(arg.data);
                         const L1Fee = yield curveInstance.contracts[curveInstance.constants.ALIASES.gas_oracle_blob].contract.getL1Fee(arg.data);
                         curveInstance.L1WeightedGasPrice = Number(L1Fee) / Number(L1GasUsed);
@@ -645,15 +633,11 @@ class Curve {
                         return [L2GasUsed, L1GasUsed];
                     });
                 };
-                // @ts-ignore
                 AbstractProvider.prototype.estimateGas = newEstimate;
-                // @ts-ignore
                 AbstractProvider.prototype.originalEstimate = oldEstimate;
             }
             else {
-                // @ts-ignore
-                if (AbstractProvider.prototype.originalEstimate) {
-                    // @ts-ignore
+                if ('originalEstimate' in AbstractProvider.prototype) {
                     AbstractProvider.prototype.estimateGas = AbstractProvider.prototype.originalEstimate;
                 }
             }
@@ -686,22 +670,21 @@ class Curve {
     _filterHiddenPools(pools) {
         return __awaiter(this, void 0, void 0, function* () {
             const hiddenPools = (yield _getHiddenPools())[this.constants.NETWORK_NAME] || [];
-            // @ts-ignore
             return Object.fromEntries(Object.entries(pools).filter(([id]) => !hiddenPools.includes(id)));
         });
     }
     _updateDecimalsAndGauges(pools) {
         this.constants.DECIMALS = Object.assign(Object.assign({}, this.constants.DECIMALS), extractDecimals(pools));
-        this.constants.GAUGES = [...this.constants.GAUGES, ...extractGauges(pools)];
+        this.constants.GAUGES = [...this.constants.GAUGES, ...extractGauges.call(this, pools)];
     }
     setCustomFeeData(customFeeData) {
         this.feeData = Object.assign(Object.assign({}, this.feeData), customFeeData);
     }
     formatUnits(value, unit) {
-        return ethers.formatUnits(value, unit);
+        return formatUnits(value, unit);
     }
     parseUnits(value, unit) {
-        return ethers.parseUnits(value, unit);
+        return parseUnits(value, unit);
     }
     updateFeeData() {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/dao.d.ts

@@ -1,47 +1,48 @@
-import { IGaugeUserVote, IVotingGauge, IDaoProposalListItem, IDaoProposalUserListItem, IDaoProposal, TVoteType } from './interfaces';
-export declare const crvSupplyStats: () => Promise<{
+import { type Curve } from "./curve.js";
+import { IDaoProposal, IDaoProposalListItem, IDaoProposalUserListItem, IGaugeUserVote, IVotingGauge, TVoteType } from './interfaces';
+export declare function crvSupplyStats(this: Curve): Promise<{
     circulating: string;
     locked: string;
     total: string;
     veCrv: string;
     averageLockTime: string;
 }>;
-export declare const userCrv: (address?: string) => Promise<string>;
-export declare const userVeCrv: (address?: string) => Promise<{
+export declare function userCrv(this: Curve, address?: string): Promise<string>;
+export declare function userVeCrv(this: Curve, address?: string): Promise<{
     veCrv: string;
     veCrvPct: string;
     lockedCrv: string;
     unlockTime: number;
 }>;
-export declare const crvLockIsApproved: (amount: number | string) => Promise<boolean>;
-export declare const crvLockApproveEstimateGas: (amount: number | string) => Promise<number | number[]>;
-export declare const crvLockApprove: (amount: number | string) => Promise<string[]>;
+export declare function crvLockIsApproved(this: Curve, amount: number | string): Promise<boolean>;
+export declare function crvLockApproveEstimateGas(this: Curve, amount: number | string): Promise<number | number[]>;
+export declare function crvLockApprove(this: Curve, amount: number | string): Promise<string[]>;
 export declare const calcCrvUnlockTime: (days: number | string, start?: number | string) => number;
-export declare const createCrvLockEstimateGas: (amount: number | string, days: number | string) => Promise<number | number[]>;
-export declare const createCrvLock: (amount: number | string, days: number | string) => Promise<string>;
-export declare const increaseCrvLockedAmountEstimateGas: (amount: number | string) => Promise<number | number[]>;
-export declare const increaseCrvLockedAmount: (amount: number | string) => Promise<string>;
-export declare const increaseCrvUnlockTimeEstimateGas: (days: number | string) => Promise<number | number[]>;
-export declare const increaseCrvUnlockTime: (days: number | string) => Promise<string>;
-export declare const withdrawLockedCrvEstimateGas: () => Promise<number | number[]>;
-export declare const withdrawLockedCrv: () => Promise<string>;
-export declare const claimableFees: (address?: string) => Promise<string>;
-export declare const claimFeesEstimateGas: (address?: string) => Promise<number | number[]>;
-export declare const claimFees: (address?: string) => Promise<string>;
-export declare const getVotingGaugeList: () => Promise<IVotingGauge[]>;
-export declare const userGaugeVotes: (address?: string) => Promise<{
+export declare function createCrvLockEstimateGas(this: Curve, amount: number | string, days: number | string): Promise<number | number[]>;
+export declare function createCrvLock(this: Curve, amount: number | string, days: number | string): Promise<string>;
+export declare function increaseCrvLockedAmountEstimateGas(this: Curve, amount: number | string): Promise<number | number[]>;
+export declare function increaseCrvLockedAmount(this: Curve, amount: number | string): Promise<string>;
+export declare function increaseCrvUnlockTimeEstimateGas(this: Curve, days: number | string): Promise<number | number[]>;
+export declare function increaseCrvUnlockTime(this: Curve, days: number | string): Promise<string>;
+export declare function withdrawLockedCrvEstimateGas(this: Curve): Promise<number | number[]>;
+export declare function withdrawLockedCrv(this: Curve): Promise<string>;
+export declare function claimableFees(this: Curve, address?: string): Promise<string>;
+export declare function claimFeesEstimateGas(this: Curve, address?: string): Promise<number | number[]>;
+export declare function claimFees(this: Curve, address?: string): Promise<string>;
+export declare function getVotingGaugeList(this: Curve): Promise<IVotingGauge[]>;
+export declare function userGaugeVotes(this: Curve, address?: string): Promise<{
     gauges: IGaugeUserVote[];
     powerUsed: string;
     veCrvUsed: string;
 }>;
-export declare const voteForGaugeNextTime: (gauge: string) => Promise<number>;
-export declare const voteForGaugeEstimateGas: (gauge: string, power: number | string) => Promise<number | number[]>;
-export declare const voteForGauge: (gauge: string, power: number | string) => Promise<string>;
-export declare const getProposalList: () => Promise<IDaoProposalListItem[]>;
-export declare const getProposal: (type: "PARAMETER" | "OWNERSHIP", id: number) => Promise<IDaoProposal>;
-export declare const userProposalVotes: (address?: string) => Promise<IDaoProposalUserListItem[]>;
-export declare const voteForProposalEstimateGas: (type: TVoteType, id: number, support: boolean) => Promise<number | number[]>;
-export declare const voteForProposal: (type: TVoteType, id: number, support: boolean) => Promise<string>;
-export declare const executeVoteEstimateGas: (type: TVoteType, id: number) => Promise<number | number[]>;
-export declare const executeVote: (type: TVoteType, id: number) => Promise<string>;
-export declare const isCanVoteExecute: (type: TVoteType, id: number) => Promise<boolean>;
+export declare function voteForGaugeNextTime(this: Curve, gauge: string): Promise<number>;
+export declare function voteForGaugeEstimateGas(this: Curve, gauge: string, power: number | string): Promise<number | number[]>;
+export declare function voteForGauge(this: Curve, gauge: string, power: number | string): Promise<string>;
+export declare function getProposalList(this: Curve): Promise<IDaoProposalListItem[]>;
+export declare function getProposal(this: Curve, type: "PARAMETER" | "OWNERSHIP", id: number): Promise<IDaoProposal>;
+export declare function userProposalVotes(this: Curve, address?: string): Promise<IDaoProposalUserListItem[]>;
+export declare function voteForProposalEstimateGas(this: Curve, type: TVoteType, id: number, support: boolean): Promise<number | number[]>;
+export declare function voteForProposal(this: Curve, type: TVoteType, id: number, support: boolean): Promise<string>;
+export declare function executeVoteEstimateGas(this: Curve, type: TVoteType, id: number): Promise<number | number[]>;
+export declare function executeVote(this: Curve, type: TVoteType, id: number): Promise<string>;
+export declare function isCanVoteExecute(this: Curve, type: TVoteType, id: number): Promise<boolean>;