@gearbox-protocol/sdk 1.20.6 → 1.20.8

package/lib/core/{pool.d.ts → pool/data.d.ts}

@@ -1,6 +1,6 @@
-import { BigNumber, Signer } from "ethers";
-import { ChartsPoolDataPayload, PoolDataPayload } from "../payload/pool";
-import { IPoolService } from "../types";
+import { BigNumber, providers, Signer } from "ethers";
+import { ChartsPoolDataPayload, PoolDataPayload } from "../../payload/pool";
+import { IPoolService } from "../../types";
 export declare class PoolData {
     readonly id: string;
     readonly address: string;
@@ -22,6 +22,13 @@ export declare class PoolData {
     readonly isPaused: boolean;
     constructor(payload: PoolDataPayload);
     getContractETH(signer: Signer): IPoolService;
+    static calculateBorrowRate({ modelAddress, provider, expectedLiquidity, availableLiquidity, }: calculateBorrowRateProps): Promise<BigNumber>;
+}
+interface calculateBorrowRateProps {
+    modelAddress: string;
+    provider: providers.Provider;
+    expectedLiquidity: BigNumber;
+    availableLiquidity: BigNumber;
 }
 export declare class ChartsPoolData extends PoolData {
     readonly expectedLiquidityInUSD: number;
@@ -33,5 +40,7 @@ export declare class ChartsPoolData extends PoolData {
     readonly depositAPY7D: number;
     readonly depositAPY30D: number;
     readonly lmAPY: number;
+    readonly utilization: number;
     constructor({ expectedLiquidityInUSD, expectedLiquidityLimitInUSD, availableLiquidityInUSD, totalBorrowedInUSD, caLockedValueInUSD, uniqueLPs, dieselAPY7D, dieselAPY30D, lmAPY, ...restPayload }: ChartsPoolDataPayload);
 }
+export {};

package/lib/core/{pool.js → pool/data.js}

@@ -25,6 +25,42 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -39,9 +75,9 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChartsPoolData = exports.PoolData = void 0;
 var ethers_1 = require("ethers");
-var types_1 = require("../types");
-var formatter_1 = require("../utils/formatter");
-var constants_1 = require("./constants");
+var types_1 = require("../../types");
+var formatter_1 = require("../../utils/formatter");
+var constants_1 = require("../constants");
 var PoolData = /** @class */ (function () {
     function PoolData(payload) {
         this.isPaused = false;
@@ -67,6 +103,16 @@ var PoolData = /** @class */ (function () {
     PoolData.prototype.getContractETH = function (signer) {
         return types_1.IPoolService__factory.connect(this.address, signer);
     };
+    PoolData.calculateBorrowRate = function (_a) {
+        var modelAddress = _a.modelAddress, provider = _a.provider, expectedLiquidity = _a.expectedLiquidity, availableLiquidity = _a.availableLiquidity;
+        return __awaiter(this, void 0, void 0, function () {
+            var model;
+            return __generator(this, function (_b) {
+                model = types_1.IInterestRateModel__factory.connect(modelAddress, provider);
+                return [2 /*return*/, model.calcBorrowRate(expectedLiquidity, availableLiquidity)];
+            });
+        });
+    };
     return PoolData;
 }());
 exports.PoolData = PoolData;
@@ -86,6 +132,11 @@ var ChartsPoolData = /** @class */ (function (_super) {
         _this.depositAPY30D = dieselAPY30D / constants_1.PERCENTAGE_DECIMALS;
         _this.caLockedValueInUSD = caLockedValueInUSD;
         _this.lmAPY = lmAPY / constants_1.PERCENTAGE_FACTOR;
+        _this.utilization =
+            ethers_1.BigNumber.from(v1Props.totalBorrowed)
+                .mul(constants_1.PERCENTAGE_FACTOR)
+                .div(ethers_1.BigNumber.from(v1Props.expectedLiquidity))
+                .toNumber() / constants_1.PERCENTAGE_DECIMALS;
         return _this;
     }
     return ChartsPoolData;

package/lib/core/pool/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./data";
+export * from "./operation";

package/lib/core/pool/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./data"), exports);
+__exportStar(require("./operation"), exports);

package/lib/core/pool/operation.d.ts

@@ -0,0 +1,29 @@
+import { BigNumber } from "ethers";
+import { TokenData } from "../../tokens/tokenData";
+export interface BasePoolOperation {
+    amount: string;
+    pool: string;
+    session_id: string;
+    timestamp: number;
+    tx_hash: string;
+    user: string;
+}
+export declare abstract class AbstractPoolOperation {
+    readonly txHash: string;
+    readonly date: string;
+    readonly timestamp: number;
+    readonly user: string;
+    readonly sessionId: string;
+    readonly pool: string;
+    readonly amount: BigNumber;
+    constructor(opts: BasePoolOperation);
+    abstract toString(token: TokenData): string;
+}
+export declare type PoolOperationResponse = BasePoolOperation & {
+    event: string;
+};
+export declare class PoolOperation extends AbstractPoolOperation {
+    readonly event: string;
+    constructor(ops: PoolOperationResponse);
+    toString(token: TokenData): string;
+}

package/lib/core/pool/operation.js

@@ -0,0 +1,48 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolOperation = exports.AbstractPoolOperation = void 0;
+var ethers_1 = require("ethers");
+var moment_1 = require("moment");
+var contractsRegister_1 = require("../../contracts/contractsRegister");
+var formatter_1 = require("../../utils/formatter");
+var AbstractPoolOperation = /** @class */ (function () {
+    function AbstractPoolOperation(opts) {
+        this.txHash = opts.tx_hash;
+        this.amount = ethers_1.BigNumber.from(opts.amount);
+        this.pool = opts.pool;
+        this.sessionId = opts.session_id;
+        this.user = opts.user;
+        this.timestamp = opts.timestamp;
+        this.date = (0, moment_1.unix)(opts.timestamp).format("Do MMM YYYY");
+    }
+    return AbstractPoolOperation;
+}());
+exports.AbstractPoolOperation = AbstractPoolOperation;
+var PoolOperation = /** @class */ (function (_super) {
+    __extends(PoolOperation, _super);
+    function PoolOperation(ops) {
+        var _this = _super.call(this, ops) || this;
+        _this.event = ops.event;
+        return _this;
+    }
+    PoolOperation.prototype.toString = function (token) {
+        return "".concat(this.event, " ").concat((0, formatter_1.formatBN)(ethers_1.BigNumber.from(this.amount), token.decimals), " ").concat((0, contractsRegister_1.getContractName)(this.pool));
+    };
+    return PoolOperation;
+}(AbstractPoolOperation));
+exports.PoolOperation = PoolOperation;

package/lib/core/rewardConvex.spec.js

@@ -80,7 +80,6 @@ describe("RewardConvex test", function () {
             },
         ];
         var result = rewardConvex_1.RewardConvex.prepareMultiCalls(CREDIT_ACCOUNT, cm, "Mainnet");
-        console.log(result);
         (0, chai_1.expect)(result).to.be.eql({ calls: calls, distribution: distribution });
     });
     it("parseResults parse data correctly", function () {

package/lib/pathfinder/pathfinder.d.ts

@@ -1,5 +1,4 @@
-import { Provider } from "@ethersproject/abstract-provider";
-import { BigNumberish, Signer } from "ethers";
+import { BigNumberish, providers, Signer } from "ethers";
 import { NetworkType } from "../core/chains";
 import { CreditAccountData } from "../core/creditAccount";
 import { CreditManagerData } from "../core/creditManager";
@@ -16,7 +15,7 @@ export declare class PathFinder {
     network: NetworkType;
     static connectors: Array<SupportedToken>;
     protected readonly _connectors: Array<string>;
-    constructor(address: string, provider: Signer | Provider, network?: NetworkType, connectors?: Array<SupportedToken>);
+    constructor(address: string, provider: Signer | providers.Provider, network?: NetworkType, connectors?: Array<SupportedToken>);
     findAllSwaps(creditAccount: CreditAccountData, swapOperation: SwapOperation, tokenIn: SupportedToken | string, tokenOut: SupportedToken | string, amount: BigNumberish, slippage: number): Promise<Array<PathFinderResult>>;
     findOneTokenPath(creditAccount: CreditAccountData, tokenIn: SupportedToken | string, tokenOut: SupportedToken | string, amount: BigNumberish, slippage: number): Promise<PathFinderResult>;
     /**

package/lib/types/@chainlink/contracts/src/v0.8/interfaces/AggregatorInterface.d.ts

@@ -0,0 +1,106 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "../../../../../common";
+export interface AggregatorInterfaceInterface extends utils.Interface {
+    functions: {
+        "getAnswer(uint256)": FunctionFragment;
+        "getTimestamp(uint256)": FunctionFragment;
+        "latestAnswer()": FunctionFragment;
+        "latestRound()": FunctionFragment;
+        "latestTimestamp()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "getAnswer" | "getTimestamp" | "latestAnswer" | "latestRound" | "latestTimestamp"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getAnswer", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getTimestamp", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "latestAnswer", values?: undefined): string;
+    encodeFunctionData(functionFragment: "latestRound", values?: undefined): string;
+    encodeFunctionData(functionFragment: "latestTimestamp", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "getAnswer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "latestAnswer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "latestRound", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "latestTimestamp", data: BytesLike): Result;
+    events: {
+        "AnswerUpdated(int256,uint256,uint256)": EventFragment;
+        "NewRound(uint256,address,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "AnswerUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "NewRound"): EventFragment;
+}
+export interface AnswerUpdatedEventObject {
+    current: BigNumber;
+    roundId: BigNumber;
+    updatedAt: BigNumber;
+}
+export declare type AnswerUpdatedEvent = TypedEvent<[
+    BigNumber,
+    BigNumber,
+    BigNumber
+], AnswerUpdatedEventObject>;
+export declare type AnswerUpdatedEventFilter = TypedEventFilter<AnswerUpdatedEvent>;
+export interface NewRoundEventObject {
+    roundId: BigNumber;
+    startedBy: string;
+    startedAt: BigNumber;
+}
+export declare type NewRoundEvent = TypedEvent<[
+    BigNumber,
+    string,
+    BigNumber
+], NewRoundEventObject>;
+export declare type NewRoundEventFilter = TypedEventFilter<NewRoundEvent>;
+export interface AggregatorInterface extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: AggregatorInterfaceInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        getAnswer(roundId: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
+        getTimestamp(roundId: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
+        latestAnswer(overrides?: CallOverrides): Promise<[BigNumber]>;
+        latestRound(overrides?: CallOverrides): Promise<[BigNumber]>;
+        latestTimestamp(overrides?: CallOverrides): Promise<[BigNumber]>;
+    };
+    getAnswer(roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+    getTimestamp(roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+    latestAnswer(overrides?: CallOverrides): Promise<BigNumber>;
+    latestRound(overrides?: CallOverrides): Promise<BigNumber>;
+    latestTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+    callStatic: {
+        getAnswer(roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        getTimestamp(roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        latestAnswer(overrides?: CallOverrides): Promise<BigNumber>;
+        latestRound(overrides?: CallOverrides): Promise<BigNumber>;
+        latestTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    filters: {
+        "AnswerUpdated(int256,uint256,uint256)"(current?: BigNumberish | null, roundId?: BigNumberish | null, updatedAt?: null): AnswerUpdatedEventFilter;
+        AnswerUpdated(current?: BigNumberish | null, roundId?: BigNumberish | null, updatedAt?: null): AnswerUpdatedEventFilter;
+        "NewRound(uint256,address,uint256)"(roundId?: BigNumberish | null, startedBy?: string | null, startedAt?: null): NewRoundEventFilter;
+        NewRound(roundId?: BigNumberish | null, startedBy?: string | null, startedAt?: null): NewRoundEventFilter;
+    };
+    estimateGas: {
+        getAnswer(roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        getTimestamp(roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        latestAnswer(overrides?: CallOverrides): Promise<BigNumber>;
+        latestRound(overrides?: CallOverrides): Promise<BigNumber>;
+        latestTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        getAnswer(roundId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getTimestamp(roundId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        latestAnswer(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        latestRound(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        latestTimestamp(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/lib/types/@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.d.ts

@@ -0,0 +1,218 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "../../../../../common";
+export interface AggregatorV2V3InterfaceInterface extends utils.Interface {
+    functions: {
+        "decimals()": FunctionFragment;
+        "description()": FunctionFragment;
+        "getAnswer(uint256)": FunctionFragment;
+        "getRoundData(uint80)": FunctionFragment;
+        "getTimestamp(uint256)": FunctionFragment;
+        "latestAnswer()": FunctionFragment;
+        "latestRound()": FunctionFragment;
+        "latestRoundData()": FunctionFragment;
+        "latestTimestamp()": FunctionFragment;
+        "version()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "decimals" | "description" | "getAnswer" | "getRoundData" | "getTimestamp" | "latestAnswer" | "latestRound" | "latestRoundData" | "latestTimestamp" | "version"): FunctionFragment;
+    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
+    encodeFunctionData(functionFragment: "description", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getAnswer", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getRoundData", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getTimestamp", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "latestAnswer", values?: undefined): string;
+    encodeFunctionData(functionFragment: "latestRound", values?: undefined): string;
+    encodeFunctionData(functionFragment: "latestRoundData", values?: undefined): string;
+    encodeFunctionData(functionFragment: "latestTimestamp", values?: undefined): string;
+    encodeFunctionData(functionFragment: "version", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "description", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAnswer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getRoundData", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "latestAnswer", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "latestRound", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "latestRoundData", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "latestTimestamp", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
+    events: {
+        "AnswerUpdated(int256,uint256,uint256)": EventFragment;
+        "NewRound(uint256,address,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "AnswerUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "NewRound"): EventFragment;
+}
+export interface AnswerUpdatedEventObject {
+    current: BigNumber;
+    roundId: BigNumber;
+    updatedAt: BigNumber;
+}
+export declare type AnswerUpdatedEvent = TypedEvent<[
+    BigNumber,
+    BigNumber,
+    BigNumber
+], AnswerUpdatedEventObject>;
+export declare type AnswerUpdatedEventFilter = TypedEventFilter<AnswerUpdatedEvent>;
+export interface NewRoundEventObject {
+    roundId: BigNumber;
+    startedBy: string;
+    startedAt: BigNumber;
+}
+export declare type NewRoundEvent = TypedEvent<[
+    BigNumber,
+    string,
+    BigNumber
+], NewRoundEventObject>;
+export declare type NewRoundEventFilter = TypedEventFilter<NewRoundEvent>;
+export interface AggregatorV2V3Interface extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: AggregatorV2V3InterfaceInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        decimals(overrides?: CallOverrides): Promise<[number]>;
+        description(overrides?: CallOverrides): Promise<[string]>;
+        getAnswer(roundId: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
+        getRoundData(_roundId: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            roundId: BigNumber;
+            answer: BigNumber;
+            startedAt: BigNumber;
+            updatedAt: BigNumber;
+            answeredInRound: BigNumber;
+        }>;
+        getTimestamp(roundId: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
+        latestAnswer(overrides?: CallOverrides): Promise<[BigNumber]>;
+        latestRound(overrides?: CallOverrides): Promise<[BigNumber]>;
+        latestRoundData(overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            roundId: BigNumber;
+            answer: BigNumber;
+            startedAt: BigNumber;
+            updatedAt: BigNumber;
+            answeredInRound: BigNumber;
+        }>;
+        latestTimestamp(overrides?: CallOverrides): Promise<[BigNumber]>;
+        version(overrides?: CallOverrides): Promise<[BigNumber]>;
+    };
+    decimals(overrides?: CallOverrides): Promise<number>;
+    description(overrides?: CallOverrides): Promise<string>;
+    getAnswer(roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+    getRoundData(_roundId: BigNumberish, overrides?: CallOverrides): Promise<[
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber
+    ] & {
+        roundId: BigNumber;
+        answer: BigNumber;
+        startedAt: BigNumber;
+        updatedAt: BigNumber;
+        answeredInRound: BigNumber;
+    }>;
+    getTimestamp(roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+    latestAnswer(overrides?: CallOverrides): Promise<BigNumber>;
+    latestRound(overrides?: CallOverrides): Promise<BigNumber>;
+    latestRoundData(overrides?: CallOverrides): Promise<[
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber,
+        BigNumber
+    ] & {
+        roundId: BigNumber;
+        answer: BigNumber;
+        startedAt: BigNumber;
+        updatedAt: BigNumber;
+        answeredInRound: BigNumber;
+    }>;
+    latestTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+    version(overrides?: CallOverrides): Promise<BigNumber>;
+    callStatic: {
+        decimals(overrides?: CallOverrides): Promise<number>;
+        description(overrides?: CallOverrides): Promise<string>;
+        getAnswer(roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        getRoundData(_roundId: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            roundId: BigNumber;
+            answer: BigNumber;
+            startedAt: BigNumber;
+            updatedAt: BigNumber;
+            answeredInRound: BigNumber;
+        }>;
+        getTimestamp(roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        latestAnswer(overrides?: CallOverrides): Promise<BigNumber>;
+        latestRound(overrides?: CallOverrides): Promise<BigNumber>;
+        latestRoundData(overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber,
+            BigNumber,
+            BigNumber,
+            BigNumber
+        ] & {
+            roundId: BigNumber;
+            answer: BigNumber;
+            startedAt: BigNumber;
+            updatedAt: BigNumber;
+            answeredInRound: BigNumber;
+        }>;
+        latestTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+        version(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    filters: {
+        "AnswerUpdated(int256,uint256,uint256)"(current?: BigNumberish | null, roundId?: BigNumberish | null, updatedAt?: null): AnswerUpdatedEventFilter;
+        AnswerUpdated(current?: BigNumberish | null, roundId?: BigNumberish | null, updatedAt?: null): AnswerUpdatedEventFilter;
+        "NewRound(uint256,address,uint256)"(roundId?: BigNumberish | null, startedBy?: string | null, startedAt?: null): NewRoundEventFilter;
+        NewRound(roundId?: BigNumberish | null, startedBy?: string | null, startedAt?: null): NewRoundEventFilter;
+    };
+    estimateGas: {
+        decimals(overrides?: CallOverrides): Promise<BigNumber>;
+        description(overrides?: CallOverrides): Promise<BigNumber>;
+        getAnswer(roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        getRoundData(_roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        getTimestamp(roundId: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        latestAnswer(overrides?: CallOverrides): Promise<BigNumber>;
+        latestRound(overrides?: CallOverrides): Promise<BigNumber>;
+        latestRoundData(overrides?: CallOverrides): Promise<BigNumber>;
+        latestTimestamp(overrides?: CallOverrides): Promise<BigNumber>;
+        version(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        decimals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        description(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getAnswer(roundId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getRoundData(_roundId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getTimestamp(roundId: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        latestAnswer(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        latestRound(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        latestRoundData(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        latestTimestamp(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        version(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/lib/types/@chainlink/contracts/src/v0.8/interfaces/index.d.ts

@@ -1 +1,3 @@
+export type { AggregatorInterface } from "./AggregatorInterface";
+export type { AggregatorV2V3Interface } from "./AggregatorV2V3Interface";
 export type { AggregatorV3Interface } from "./AggregatorV3Interface";

package/lib/types/@gearbox-protocol/core-v2/contracts/index.d.ts

@@ -1,4 +1,6 @@
 import type * as interfaces from "./interfaces";
 export type { interfaces };
+import type * as pool from "./pool";
+export type { pool };
 import type * as test from "./test";
 export type { test };