@gearbox-protocol/sdk 1.16.15 → 1.17.0

package/lib/core/eventOrTx.d.ts

@@ -19,7 +19,7 @@ export declare abstract class EventOrTx implements Display {
     get isPending(): boolean;
     get txStatus(): TxStatus;
     compare(item: EventOrTx): number;
-    abstract toString(tokenData: Record<string, TokenData>): string;
+    abstract toString(): string;
 }
 export declare type EVMEventProps = Omit<EventOrTxProps, "txStatus"> & {
     logId?: number;

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,2 +1,4 @@
 import type * as interfaces from "./interfaces";
 export type { interfaces };
+import type * as test from "./test";
+export type { test };

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

@@ -0,0 +1,2 @@
+import type * as interfaces from "./interfaces";
+export type { interfaces };

package/lib/types/@gearbox-protocol/core-v2/contracts/test/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/@gearbox-protocol/core-v2/contracts/test/interfaces/ITokenTestSuite.d.ts

@@ -0,0 +1,148 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "../../../../../common";
+export interface ITokenTestSuiteInterface extends utils.Interface {
+    functions: {
+        "approve(address,address,address,uint256)": FunctionFragment;
+        "approve(address,address,address)": FunctionFragment;
+        "balanceOf(address,address)": FunctionFragment;
+        "burn(address,address,uint256)": FunctionFragment;
+        "mint(address,address,uint256)": FunctionFragment;
+        "topUpWETH()": FunctionFragment;
+        "topUpWETH(address,uint256)": FunctionFragment;
+        "wethToken()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "approve(address,address,address,uint256)" | "approve(address,address,address)" | "balanceOf" | "burn" | "mint" | "topUpWETH()" | "topUpWETH(address,uint256)" | "wethToken"): FunctionFragment;
+    encodeFunctionData(functionFragment: "approve(address,address,address,uint256)", values: [string, string, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "approve(address,address,address)", values: [string, string, string]): string;
+    encodeFunctionData(functionFragment: "balanceOf", values: [string, string]): string;
+    encodeFunctionData(functionFragment: "burn", values: [string, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "mint", values: [string, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "topUpWETH()", values?: undefined): string;
+    encodeFunctionData(functionFragment: "topUpWETH(address,uint256)", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "wethToken", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "approve(address,address,address,uint256)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "approve(address,address,address)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "topUpWETH()", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "topUpWETH(address,uint256)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wethToken", data: BytesLike): Result;
+    events: {};
+}
+export interface ITokenTestSuite extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: ITokenTestSuiteInterface;
+    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: {
+        "approve(address,address,address,uint256)"(token: string, holder: string, targetContract: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        "approve(address,address,address)"(token: string, holder: string, targetContract: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        balanceOf(token: string, holder: string, overrides?: CallOverrides): Promise<[BigNumber] & {
+            balance: BigNumber;
+        }>;
+        burn(token: string, from: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        mint(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        "topUpWETH()"(overrides?: PayableOverrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        "topUpWETH(address,uint256)"(onBehalfOf: string, value: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        wethToken(overrides?: CallOverrides): Promise<[string]>;
+    };
+    "approve(address,address,address,uint256)"(token: string, holder: string, targetContract: string, amount: BigNumberish, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    "approve(address,address,address)"(token: string, holder: string, targetContract: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    balanceOf(token: string, holder: string, overrides?: CallOverrides): Promise<BigNumber>;
+    burn(token: string, from: string, amount: BigNumberish, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    mint(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    "topUpWETH()"(overrides?: PayableOverrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    "topUpWETH(address,uint256)"(onBehalfOf: string, value: BigNumberish, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    wethToken(overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        "approve(address,address,address,uint256)"(token: string, holder: string, targetContract: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        "approve(address,address,address)"(token: string, holder: string, targetContract: string, overrides?: CallOverrides): Promise<void>;
+        balanceOf(token: string, holder: string, overrides?: CallOverrides): Promise<BigNumber>;
+        burn(token: string, from: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        mint(token: string, to: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        "topUpWETH()"(overrides?: CallOverrides): Promise<void>;
+        "topUpWETH(address,uint256)"(onBehalfOf: string, value: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        wethToken(overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {};
+    estimateGas: {
+        "approve(address,address,address,uint256)"(token: string, holder: string, targetContract: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        "approve(address,address,address)"(token: string, holder: string, targetContract: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        balanceOf(token: string, holder: string, overrides?: CallOverrides): Promise<BigNumber>;
+        burn(token: string, from: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        mint(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        "topUpWETH()"(overrides?: PayableOverrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        "topUpWETH(address,uint256)"(onBehalfOf: string, value: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        wethToken(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        "approve(address,address,address,uint256)"(token: string, holder: string, targetContract: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        "approve(address,address,address)"(token: string, holder: string, targetContract: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        balanceOf(token: string, holder: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        burn(token: string, from: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        mint(token: string, to: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        "topUpWETH()"(overrides?: PayableOverrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        "topUpWETH(address,uint256)"(onBehalfOf: string, value: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        wethToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/lib/types/@gearbox-protocol/core-v2/contracts/test/interfaces/ITokenTestSuite.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1 @@
+export type { ITokenTestSuite } from "./ITokenTestSuite";

package/lib/types/@gearbox-protocol/core-v2/contracts/test/interfaces/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -2,3 +2,5 @@ import type * as integrations from "./integrations";
 export type { integrations };
 import type * as interfaces from "./interfaces";
 export type { interfaces };
+import type * as test from "./test";
+export type { test };

package/lib/types/@gearbox-protocol/integrations-v2/contracts/test/config/SupportedContracts.sol/ISupportedContracts.d.ts

@@ -0,0 +1,66 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "../../../../../../common";
+export interface ISupportedContractsInterface extends utils.Interface {
+    functions: {
+        "addressOf(uint8)": FunctionFragment;
+        "contractCount()": FunctionFragment;
+        "contractIndex(address)": FunctionFragment;
+        "nameOf(uint8)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "addressOf" | "contractCount" | "contractIndex" | "nameOf"): FunctionFragment;
+    encodeFunctionData(functionFragment: "addressOf", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "contractCount", values?: undefined): string;
+    encodeFunctionData(functionFragment: "contractIndex", values: [string]): string;
+    encodeFunctionData(functionFragment: "nameOf", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "addressOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "contractCount", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "contractIndex", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "nameOf", data: BytesLike): Result;
+    events: {};
+}
+export interface ISupportedContracts extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: ISupportedContractsInterface;
+    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: {
+        addressOf(c: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+        contractCount(overrides?: CallOverrides): Promise<[BigNumber]>;
+        contractIndex(arg0: string, overrides?: CallOverrides): Promise<[number]>;
+        nameOf(c: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+    };
+    addressOf(c: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    contractCount(overrides?: CallOverrides): Promise<BigNumber>;
+    contractIndex(arg0: string, overrides?: CallOverrides): Promise<number>;
+    nameOf(c: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        addressOf(c: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        contractCount(overrides?: CallOverrides): Promise<BigNumber>;
+        contractIndex(arg0: string, overrides?: CallOverrides): Promise<number>;
+        nameOf(c: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {};
+    estimateGas: {
+        addressOf(c: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        contractCount(overrides?: CallOverrides): Promise<BigNumber>;
+        contractIndex(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
+        nameOf(c: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        addressOf(c: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        contractCount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        contractIndex(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        nameOf(c: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/lib/types/@gearbox-protocol/integrations-v2/contracts/test/config/SupportedContracts.sol/ISupportedContracts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/@gearbox-protocol/integrations-v2/contracts/test/config/SupportedContracts.sol/index.d.ts

@@ -0,0 +1 @@
+export type { ISupportedContracts } from "./ISupportedContracts";

package/lib/types/@gearbox-protocol/integrations-v2/contracts/test/config/SupportedContracts.sol/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/@gearbox-protocol/integrations-v2/contracts/test/config/index.d.ts

@@ -0,0 +1,2 @@
+import type * as supportedContractsSol from "./SupportedContracts.sol";
+export type { supportedContractsSol };

package/lib/types/@gearbox-protocol/integrations-v2/contracts/test/config/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+import type * as config from "./config";
+export type { config };
+import type * as mocks from "./mocks";
+export type { mocks };

package/lib/types/@gearbox-protocol/integrations-v2/contracts/test/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/@gearbox-protocol/integrations-v2/contracts/test/mocks/index.d.ts

@@ -0,0 +1,2 @@
+import type * as integrations from "./integrations";
+export type { integrations };

package/lib/types/@gearbox-protocol/integrations-v2/contracts/test/mocks/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });