@gearbox-protocol/sdk 1.20.6 → 1.20.7

package/lib/core/pool.d.ts

@@ -1,4 +1,4 @@
-import { BigNumber, Signer } from "ethers";
+import { BigNumber, providers, Signer } from "ethers";
 import { ChartsPoolDataPayload, PoolDataPayload } from "../payload/pool";
 import { IPoolService } from "../types";
 export declare class PoolData {
@@ -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;
@@ -35,3 +42,4 @@ export declare class ChartsPoolData extends PoolData {
     readonly lmAPY: number;
     constructor({ expectedLiquidityInUSD, expectedLiquidityLimitInUSD, availableLiquidityInUSD, totalBorrowedInUSD, caLockedValueInUSD, uniqueLPs, dieselAPY7D, dieselAPY30D, lmAPY, ...restPayload }: ChartsPoolDataPayload);
 }
+export {};

package/lib/core/pool.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)
@@ -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;

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 };

package/lib/types/@gearbox-protocol/core-v2/contracts/interfaces/ICreditConfigurator.sol/ICreditConfigurator.d.ts

@@ -13,6 +13,7 @@ export interface ICreditConfiguratorInterface extends utils.Interface {
         "allowedContracts()": FunctionFragment;
         "creditFacade()": FunctionFragment;
         "creditManager()": FunctionFragment;
+        "forbidAdapter(address)": FunctionFragment;
         "forbidContract(address)": FunctionFragment;
         "forbidToken(address)": FunctionFragment;
         "removeContractFromUpgradeable(address)": FunctionFragment;
@@ -30,7 +31,7 @@ export interface ICreditConfiguratorInterface extends utils.Interface {
         "upgradePriceOracle()": FunctionFragment;
         "version()": FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: "addCollateralToken" | "addContractToUpgradeable" | "addEmergencyLiquidator" | "addressProvider" | "allowContract" | "allowToken" | "allowedContracts" | "creditFacade" | "creditManager" | "forbidContract" | "forbidToken" | "removeContractFromUpgradeable" | "removeEmergencyLiquidator" | "setExpirationDate" | "setFees" | "setIncreaseDebtForbidden" | "setLimitPerBlock" | "setLimits" | "setLiquidationThreshold" | "setMaxEnabledTokens" | "underlying" | "upgradeCreditConfigurator" | "upgradeCreditFacade" | "upgradePriceOracle" | "version"): FunctionFragment;
+    getFunction(nameOrSignatureOrTopic: "addCollateralToken" | "addContractToUpgradeable" | "addEmergencyLiquidator" | "addressProvider" | "allowContract" | "allowToken" | "allowedContracts" | "creditFacade" | "creditManager" | "forbidAdapter" | "forbidContract" | "forbidToken" | "removeContractFromUpgradeable" | "removeEmergencyLiquidator" | "setExpirationDate" | "setFees" | "setIncreaseDebtForbidden" | "setLimitPerBlock" | "setLimits" | "setLiquidationThreshold" | "setMaxEnabledTokens" | "underlying" | "upgradeCreditConfigurator" | "upgradeCreditFacade" | "upgradePriceOracle" | "version"): FunctionFragment;
     encodeFunctionData(functionFragment: "addCollateralToken", values: [string, BigNumberish]): string;
     encodeFunctionData(functionFragment: "addContractToUpgradeable", values: [string]): string;
     encodeFunctionData(functionFragment: "addEmergencyLiquidator", values: [string]): string;
@@ -40,6 +41,7 @@ export interface ICreditConfiguratorInterface extends utils.Interface {
     encodeFunctionData(functionFragment: "allowedContracts", values?: undefined): string;
     encodeFunctionData(functionFragment: "creditFacade", values?: undefined): string;
     encodeFunctionData(functionFragment: "creditManager", values?: undefined): string;
+    encodeFunctionData(functionFragment: "forbidAdapter", values: [string]): string;
     encodeFunctionData(functionFragment: "forbidContract", values: [string]): string;
     encodeFunctionData(functionFragment: "forbidToken", values: [string]): string;
     encodeFunctionData(functionFragment: "removeContractFromUpgradeable", values: [string]): string;
@@ -71,6 +73,7 @@ export interface ICreditConfiguratorInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: "allowedContracts", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "creditFacade", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "creditManager", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "forbidAdapter", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "forbidContract", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "forbidToken", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "removeContractFromUpgradeable", data: BytesLike): Result;
@@ -88,6 +91,7 @@ export interface ICreditConfiguratorInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: "upgradePriceOracle", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
     events: {
+        "AdapterForbidden(address)": EventFragment;
         "AddedToUpgradeable(address)": EventFragment;
         "ContractAllowed(address,address)": EventFragment;
         "ContractForbidden(address)": EventFragment;
@@ -107,6 +111,7 @@ export interface ICreditConfiguratorInterface extends utils.Interface {
         "TokenForbidden(address)": EventFragment;
         "TokenLiquidationThresholdUpdated(address,uint16)": EventFragment;
     };
+    getEvent(nameOrSignatureOrTopic: "AdapterForbidden"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "AddedToUpgradeable"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "ContractAllowed"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "ContractForbidden"): EventFragment;
@@ -126,6 +131,13 @@ export interface ICreditConfiguratorInterface extends utils.Interface {
     getEvent(nameOrSignatureOrTopic: "TokenForbidden"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "TokenLiquidationThresholdUpdated"): EventFragment;
 }
+export interface AdapterForbiddenEventObject {
+    adapter: string;
+}
+export declare type AdapterForbiddenEvent = TypedEvent<[
+    string
+], AdapterForbiddenEventObject>;
+export declare type AdapterForbiddenEventFilter = TypedEventFilter<AdapterForbiddenEvent>;
 export interface AddedToUpgradeableEventObject {
     arg0: string;
 }
@@ -298,6 +310,9 @@ export interface ICreditConfigurator extends BaseContract {
         allowedContracts(overrides?: CallOverrides): Promise<[string[]]>;
         creditFacade(overrides?: CallOverrides): Promise<[string]>;
         creditManager(overrides?: CallOverrides): Promise<[string]>;
+        forbidAdapter(adapter: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
         forbidContract(targetContract: string, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<ContractTransaction>;
@@ -362,6 +377,9 @@ export interface ICreditConfigurator extends BaseContract {
     allowedContracts(overrides?: CallOverrides): Promise<string[]>;
     creditFacade(overrides?: CallOverrides): Promise<string>;
     creditManager(overrides?: CallOverrides): Promise<string>;
+    forbidAdapter(adapter: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
     forbidContract(targetContract: string, overrides?: Overrides & {
         from?: string | Promise<string>;
     }): Promise<ContractTransaction>;
@@ -416,6 +434,7 @@ export interface ICreditConfigurator extends BaseContract {
         allowedContracts(overrides?: CallOverrides): Promise<string[]>;
         creditFacade(overrides?: CallOverrides): Promise<string>;
         creditManager(overrides?: CallOverrides): Promise<string>;
+        forbidAdapter(adapter: string, overrides?: CallOverrides): Promise<void>;
         forbidContract(targetContract: string, overrides?: CallOverrides): Promise<void>;
         forbidToken(token: string, overrides?: CallOverrides): Promise<void>;
         removeContractFromUpgradeable(addr: string, overrides?: CallOverrides): Promise<void>;
@@ -434,6 +453,8 @@ export interface ICreditConfigurator extends BaseContract {
         version(overrides?: CallOverrides): Promise<BigNumber>;
     };
     filters: {
+        "AdapterForbidden(address)"(adapter?: string | null): AdapterForbiddenEventFilter;
+        AdapterForbidden(adapter?: string | null): AdapterForbiddenEventFilter;
         "AddedToUpgradeable(address)"(arg0?: null): AddedToUpgradeableEventFilter;
         AddedToUpgradeable(arg0?: null): AddedToUpgradeableEventFilter;
         "ContractAllowed(address,address)"(protocol?: string | null, adapter?: string | null): ContractAllowedEventFilter;
@@ -491,6 +512,9 @@ export interface ICreditConfigurator extends BaseContract {
         allowedContracts(overrides?: CallOverrides): Promise<BigNumber>;
         creditFacade(overrides?: CallOverrides): Promise<BigNumber>;
         creditManager(overrides?: CallOverrides): Promise<BigNumber>;
+        forbidAdapter(adapter: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
         forbidContract(targetContract: string, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<BigNumber>;
@@ -556,6 +580,9 @@ export interface ICreditConfigurator extends BaseContract {
         allowedContracts(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         creditFacade(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         creditManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        forbidAdapter(adapter: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
         forbidContract(targetContract: string, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<PopulatedTransaction>;

package/lib/types/@gearbox-protocol/core-v2/contracts/interfaces/ICreditConfigurator.sol/ICreditConfiguratorEvents.d.ts

@@ -5,6 +5,7 @@ import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "../..
 export interface ICreditConfiguratorEventsInterface extends utils.Interface {
     functions: {};
     events: {
+        "AdapterForbidden(address)": EventFragment;
         "AddedToUpgradeable(address)": EventFragment;
         "ContractAllowed(address,address)": EventFragment;
         "ContractForbidden(address)": EventFragment;
@@ -24,6 +25,7 @@ export interface ICreditConfiguratorEventsInterface extends utils.Interface {
         "TokenForbidden(address)": EventFragment;
         "TokenLiquidationThresholdUpdated(address,uint16)": EventFragment;
     };
+    getEvent(nameOrSignatureOrTopic: "AdapterForbidden"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "AddedToUpgradeable"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "ContractAllowed"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "ContractForbidden"): EventFragment;
@@ -43,6 +45,13 @@ export interface ICreditConfiguratorEventsInterface extends utils.Interface {
     getEvent(nameOrSignatureOrTopic: "TokenForbidden"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "TokenLiquidationThresholdUpdated"): EventFragment;
 }
+export interface AdapterForbiddenEventObject {
+    adapter: string;
+}
+export declare type AdapterForbiddenEvent = TypedEvent<[
+    string
+], AdapterForbiddenEventObject>;
+export declare type AdapterForbiddenEventFilter = TypedEventFilter<AdapterForbiddenEvent>;
 export interface AddedToUpgradeableEventObject {
     arg0: string;
 }
@@ -198,6 +207,8 @@ export interface ICreditConfiguratorEvents extends BaseContract {
     functions: {};
     callStatic: {};
     filters: {
+        "AdapterForbidden(address)"(adapter?: string | null): AdapterForbiddenEventFilter;
+        AdapterForbidden(adapter?: string | null): AdapterForbiddenEventFilter;
         "AddedToUpgradeable(address)"(arg0?: null): AddedToUpgradeableEventFilter;
         AddedToUpgradeable(arg0?: null): AddedToUpgradeableEventFilter;
         "ContractAllowed(address,address)"(protocol?: string | null, adapter?: string | null): ContractAllowedEventFilter;