@gearbox-protocol/sdk 1.8.8 → 1.8.10

package/lib/contracts/contractsRegister.js

@@ -38,6 +38,7 @@ exports.deployedContracts = {
     "0xF0A7BE2EB39bBbd55fc5597F93E01f62A790e587": "USDC",
     "0x560F2aa70003af4A69Bc79bB3c40955d396305aE": "WETH",
     "0x9f07160C42d5d8325E3Aa50e0075Ef3A8E4DcA9B": "WBTC",
+    "0xd720fe603eb3d954a8586433e78f02e248eae4c0": "wstETH",
 };
 var contractNames = Object.entries(contracts_1.contractsByAddress).reduce(function (acc, _a) {
     var _b;

package/lib/index.d.ts

@@ -32,7 +32,7 @@ export * from "./utils/math";
 export * from "./utils/validate";
 export * from "./apy";
 export { AdapterInterface } from "./contracts/adapters";
-export { getContractName } from "./contracts/contractsRegister";
+export * from "./contracts/contractsRegister";
 export * from "./core/history";
 export * from "./parsers/txParser";
 export * from "./pathfinder/core";

package/lib/index.js

@@ -14,7 +14,7 @@ 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 });
-exports.callRepeater = exports.swapKeyValue = exports.objectEntries = exports.keyToLowercase = exports.getUnderlyingToken = exports.getPoolTokens = exports.TokenType = exports.getContractName = exports.AdapterInterface = void 0;
+exports.callRepeater = exports.swapKeyValue = exports.objectEntries = exports.keyToLowercase = exports.getUnderlyingToken = exports.getPoolTokens = exports.TokenType = exports.AdapterInterface = void 0;
 __exportStar(require("./contracts/contracts"), exports);
 __exportStar(require("./contracts/protocols"), exports);
 __exportStar(require("./core/adapter"), exports);
@@ -51,8 +51,7 @@ __exportStar(require("./utils/validate"), exports);
 __exportStar(require("./apy"), exports);
 var adapters_1 = require("./contracts/adapters");
 Object.defineProperty(exports, "AdapterInterface", { enumerable: true, get: function () { return adapters_1.AdapterInterface; } });
-var contractsRegister_1 = require("./contracts/contractsRegister");
-Object.defineProperty(exports, "getContractName", { enumerable: true, get: function () { return contractsRegister_1.getContractName; } });
+__exportStar(require("./contracts/contractsRegister"), exports);
 __exportStar(require("./core/history"), exports);
 __exportStar(require("./parsers/txParser"), exports);
 __exportStar(require("./pathfinder/core"), exports);

package/lib/pathfinder/pathOptions.d.ts

@@ -1,4 +1,6 @@
 import { BigNumberish } from "ethers";
+import { NetworkType } from "../core/constants";
+import { CurveLPToken } from "../tokens/curveLP";
 export interface PathOption {
     target: string;
     option: number;
@@ -7,5 +9,7 @@ export interface PathOption {
 export declare type PathOptionSerie = Array<PathOption>;
 export declare class PathOptionFactory {
     static generatePathOptions(balances: Record<string, BigNumberish>, loopsInTx: number): Array<PathOptionSerie>;
+    static getCurvePools(balances: Record<string, BigNumberish>): Array<CurveLPToken>;
     static next(path: PathOptionSerie): PathOptionSerie;
+    static detectNetwork(underlying: string): NetworkType;
 }

package/lib/pathfinder/pathOptions.js

@@ -23,25 +23,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PathOptionFactory = void 0;
 var ethers_1 = require("ethers");
 var contracts_1 = require("../contracts/contracts");
+var convex_1 = require("../tokens/convex");
 var curveLP_1 = require("../tokens/curveLP");
 var token_1 = require("../tokens/token");
+var yearn_1 = require("../tokens/yearn");
 var PathOptionFactory = /** @class */ (function () {
     function PathOptionFactory() {
     }
     PathOptionFactory.generatePathOptions = function (balances, loopsInTx) {
-        var curveSymbols = Object.keys(curveLP_1.curveTokens);
-        var initPO = Object.entries(balances)
-            .filter(function (_a) {
-            var token = _a[0], balance = _a[1];
-            return ethers_1.BigNumber.from(balance).gt(1) &&
-                curveSymbols.includes(token_1.tokenSymbolByAddress[token.toLowerCase()]);
-        })
-            .map(function (_a) {
-            var target = _a[0];
+        var curvePools = PathOptionFactory.getCurvePools(balances);
+        var network = PathOptionFactory.detectNetwork(Object.keys(balances)[0]);
+        var initPO = curvePools.map(function (symbol) {
             return {
-                target: target,
+                target: token_1.tokenDataByNetwork[network][symbol],
                 option: 0,
-                totalOptions: contracts_1.contractParams[curveLP_1.curveTokens[token_1.tokenSymbolByAddress[target.toLowerCase()]].pool].tokens.length,
+                totalOptions: contracts_1.contractParams[curveLP_1.curveTokens[symbol].pool]
+                    .tokens.length,
             };
         });
         var totalLoops = initPO.reduce(function (acc, item) { return acc * item.totalOptions; }, 1);
@@ -57,6 +54,61 @@ var PathOptionFactory = /** @class */ (function () {
         }
         return result;
     };
+    PathOptionFactory.getCurvePools = function (balances) {
+        var curveSymbols = Object.keys(curveLP_1.curveTokens);
+        var curvePools = Object.entries(balances)
+            .filter(function (_a) {
+            var balance = _a[1];
+            return ethers_1.BigNumber.from(balance).gt(1);
+        })
+            .map(function (_a) {
+            var token = _a[0];
+            return token_1.tokenSymbolByAddress[token.toLowerCase()];
+        })
+            .filter(function (symbol) { return curveSymbols.includes(symbol); });
+        var yearnCurveTokens = Object.entries(yearn_1.yearnTokens)
+            .filter(function (_a) {
+            var data = _a[1];
+            return curveSymbols.includes(data.underlying);
+        })
+            .map(function (_a) {
+            var token = _a[0];
+            return token;
+        });
+        var curvePoolsFromYearn = Object.entries(balances)
+            .filter(function (_a) {
+            var balance = _a[1];
+            return ethers_1.BigNumber.from(balance).gt(1);
+        })
+            .map(function (_a) {
+            var token = _a[0];
+            return token_1.tokenSymbolByAddress[token.toLowerCase()];
+        })
+            .filter(function (symbol) { return yearnCurveTokens.includes(symbol); })
+            .map(function (symbol) { return yearn_1.yearnTokens[symbol].underlying; });
+        var convexCurveTokens = Object.entries(convex_1.convexTokens)
+            .filter(function (_a) {
+            var data = _a[1];
+            return curveSymbols.includes(data.underlying);
+        })
+            .map(function (_a) {
+            var token = _a[0];
+            return token;
+        });
+        var curvePoolsFromConvex = Object.entries(balances)
+            .filter(function (_a) {
+            var balance = _a[1];
+            return ethers_1.BigNumber.from(balance).gt(1);
+        })
+            .map(function (_a) {
+            var token = _a[0];
+            return token_1.tokenSymbolByAddress[token.toLowerCase()];
+        })
+            .filter(function (symbol) { return convexCurveTokens.includes(symbol); })
+            .map(function (symbol) { return convex_1.convexTokens[symbol].underlying; });
+        var curveSet = new Set(__spreadArray(__spreadArray(__spreadArray([], curvePools, true), curvePoolsFromYearn, true), curvePoolsFromConvex, true));
+        return Array.from(curveSet.values());
+    };
     PathOptionFactory.next = function (path) {
         var newPath = __spreadArray([], path, true);
         for (var i = path.length - 1; i >= 0; i--) {
@@ -69,6 +121,11 @@ var PathOptionFactory = /** @class */ (function () {
         }
         throw new Error("Path options overflow");
     };
+    PathOptionFactory.detectNetwork = function (underlying) {
+        return token_1.tokenDataByNetwork.Mainnet[token_1.tokenSymbolByAddress[underlying.toLowerCase()]].toLowerCase() === underlying.toLowerCase()
+            ? "Mainnet"
+            : "Goerli";
+    };
     return PathOptionFactory;
 }());
 exports.PathOptionFactory = PathOptionFactory;

package/lib/pathfinder/pathOptions.spec.js

@@ -87,4 +87,57 @@ describe("PathOptionFactory test", function () {
             (0, chai_1.expect)(expected).to.be.eql(result[i]);
         }
     });
+    it(" getCurvePools works correctly", function () {
+        var _a, _b, _c, _d, _e;
+        var balances = (_a = {},
+            _a[token_1.tokenDataByNetwork.Mainnet["1INCH"]] = 100,
+            _a[token_1.tokenDataByNetwork.Mainnet["3Crv"]] = 200,
+            _a[token_1.tokenDataByNetwork.Mainnet.USDC] = 200,
+            _a[token_1.tokenDataByNetwork.Mainnet.FRAX3CRV] = 200,
+            _a[token_1.tokenDataByNetwork.Mainnet.LUSD3CRV] = 200,
+            _a);
+        var expectedCurvePools = [
+            "3Crv",
+            "FRAX3CRV",
+            "LUSD3CRV",
+        ];
+        (0, chai_1.expect)(pathOptions_1.PathOptionFactory.getCurvePools(balances)).to.be.eql(expectedCurvePools);
+        balances = (_b = {},
+            _b[token_1.tokenDataByNetwork.Mainnet["1INCH"]] = 100,
+            _b[token_1.tokenDataByNetwork.Mainnet["3Crv"]] = 200,
+            _b[token_1.tokenDataByNetwork.Mainnet.USDC] = 200,
+            _b[token_1.tokenDataByNetwork.Mainnet.yvCurve_FRAX] = 200,
+            _b[token_1.tokenDataByNetwork.Mainnet.yvCurve_stETH] = 200,
+            _b);
+        expectedCurvePools = ["3Crv", "FRAX3CRV", "steCRV"];
+        (0, chai_1.expect)(pathOptions_1.PathOptionFactory.getCurvePools(balances)).to.be.eql(expectedCurvePools);
+        balances = (_c = {},
+            _c[token_1.tokenDataByNetwork.Mainnet["1INCH"]] = 100,
+            _c[token_1.tokenDataByNetwork.Mainnet.USDC] = 200,
+            _c[token_1.tokenDataByNetwork.Mainnet.cvx3Crv] = 200,
+            _c[token_1.tokenDataByNetwork.Mainnet.cvxFRAX3CRV] = 200,
+            _c);
+        expectedCurvePools = ["3Crv", "FRAX3CRV"];
+        (0, chai_1.expect)(pathOptions_1.PathOptionFactory.getCurvePools(balances)).to.be.eql(expectedCurvePools);
+        balances = (_d = {},
+            _d[token_1.tokenDataByNetwork.Mainnet.wstETH] = 100,
+            _d[token_1.tokenDataByNetwork.Mainnet.USDC] = 200,
+            _d[token_1.tokenDataByNetwork.Mainnet.stkcvx3Crv] = 200,
+            _d[token_1.tokenDataByNetwork.Mainnet.stkcvxFRAX3CRV] = 200,
+            _d);
+        expectedCurvePools = ["3Crv", "FRAX3CRV"];
+        (0, chai_1.expect)(pathOptions_1.PathOptionFactory.getCurvePools(balances)).to.be.eql(expectedCurvePools);
+        balances = (_e = {},
+            _e[token_1.tokenDataByNetwork.Mainnet["3Crv"]] = 100,
+            _e[token_1.tokenDataByNetwork.Mainnet.USDC] = 200,
+            _e[token_1.tokenDataByNetwork.Mainnet.stkcvx3Crv] = 200,
+            _e[token_1.tokenDataByNetwork.Mainnet.cvx3Crv] = 200,
+            _e[token_1.tokenDataByNetwork.Mainnet.yvCurve_stETH] = 200,
+            _e);
+        expectedCurvePools = ["3Crv", "steCRV"];
+        (0, chai_1.expect)(pathOptions_1.PathOptionFactory.getCurvePools(balances)).to.be.eql(expectedCurvePools);
+    });
+    it("detectNetwork works correctly", function () {
+        (0, chai_1.expect)(pathOptions_1.PathOptionFactory.detectNetwork(token_1.tokenDataByNetwork.Mainnet["1INCH"])).to.be.eq("Mainnet");
+    });
 });

package/lib/types/contracts/integrations/lido/IwstETHGateway.sol/IwstETHGateWay.d.ts

@@ -0,0 +1,66 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, 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 IwstETHGateWayInterface extends utils.Interface {
+    functions: {
+        "addLiquidity(uint256,address,uint256)": FunctionFragment;
+        "removeLiquidity(uint256,address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "addLiquidity" | "removeLiquidity"): FunctionFragment;
+    encodeFunctionData(functionFragment: "addLiquidity", values: [BigNumberish, string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "removeLiquidity", values: [BigNumberish, string]): string;
+    decodeFunctionResult(functionFragment: "addLiquidity", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "removeLiquidity", data: BytesLike): Result;
+    events: {};
+}
+export interface IwstETHGateWay extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IwstETHGateWayInterface;
+    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: {
+        addLiquidity(amount: BigNumberish, onBehalfOf: string, referralCode: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        removeLiquidity(amount: BigNumberish, to: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+    };
+    addLiquidity(amount: BigNumberish, onBehalfOf: string, referralCode: BigNumberish, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    removeLiquidity(amount: BigNumberish, to: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        addLiquidity(amount: BigNumberish, onBehalfOf: string, referralCode: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        removeLiquidity(amount: BigNumberish, to: string, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    filters: {};
+    estimateGas: {
+        addLiquidity(amount: BigNumberish, onBehalfOf: string, referralCode: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        removeLiquidity(amount: BigNumberish, to: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        addLiquidity(amount: BigNumberish, onBehalfOf: string, referralCode: BigNumberish, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        removeLiquidity(amount: BigNumberish, to: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/lib/types/contracts/integrations/lido/IwstETHGateway.sol/IwstETHGateWay.js

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

package/lib/types/contracts/integrations/lido/IwstETHGateway.sol/index.d.ts

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

package/lib/types/contracts/integrations/lido/IwstETHGateway.sol/index.js

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

package/lib/types/contracts/integrations/lido/index.d.ts

@@ -2,4 +2,6 @@ import type * as istEthSol from "./IstETH.sol";
 export type { istEthSol };
 import type * as iwstEthSol from "./IwstETH.sol";
 export type { iwstEthSol };
+import type * as iwstEthGatewaySol from "./IwstETHGateway.sol";
+export type { iwstEthGatewaySol };
 export type { ILidoOracle } from "./ILidoOracle";

package/lib/types/contracts/interfaces/adapters/lido/IwstETHV1Adapter.d.ts

@@ -14,6 +14,7 @@ export interface IwstETHV1AdapterInterface extends utils.Interface {
         "getStETHByWstETH(uint256)": FunctionFragment;
         "getWstETHByStETH(uint256)": FunctionFragment;
         "name()": FunctionFragment;
+        "stETH()": FunctionFragment;
         "stEthPerToken()": FunctionFragment;
         "symbol()": FunctionFragment;
         "targetContract()": FunctionFragment;
@@ -24,7 +25,7 @@ export interface IwstETHV1AdapterInterface extends utils.Interface {
         "wrap(uint256)": FunctionFragment;
         "wrapAll()": FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: "_gearboxAdapterType" | "_gearboxAdapterVersion" | "allowance" | "balanceOf" | "creditFacade" | "creditManager" | "decimals" | "getStETHByWstETH" | "getWstETHByStETH" | "name" | "stEthPerToken" | "symbol" | "targetContract" | "tokensPerStEth" | "totalSupply" | "unwrap" | "unwrapAll" | "wrap" | "wrapAll"): FunctionFragment;
+    getFunction(nameOrSignatureOrTopic: "_gearboxAdapterType" | "_gearboxAdapterVersion" | "allowance" | "balanceOf" | "creditFacade" | "creditManager" | "decimals" | "getStETHByWstETH" | "getWstETHByStETH" | "name" | "stETH" | "stEthPerToken" | "symbol" | "targetContract" | "tokensPerStEth" | "totalSupply" | "unwrap" | "unwrapAll" | "wrap" | "wrapAll"): FunctionFragment;
     encodeFunctionData(functionFragment: "_gearboxAdapterType", values?: undefined): string;
     encodeFunctionData(functionFragment: "_gearboxAdapterVersion", values?: undefined): string;
     encodeFunctionData(functionFragment: "allowance", values: [string, string]): string;
@@ -35,6 +36,7 @@ export interface IwstETHV1AdapterInterface extends utils.Interface {
     encodeFunctionData(functionFragment: "getStETHByWstETH", values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: "getWstETHByStETH", values: [BigNumberish]): string;
     encodeFunctionData(functionFragment: "name", values?: undefined): string;
+    encodeFunctionData(functionFragment: "stETH", values?: undefined): string;
     encodeFunctionData(functionFragment: "stEthPerToken", values?: undefined): string;
     encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
     encodeFunctionData(functionFragment: "targetContract", values?: undefined): string;
@@ -54,6 +56,7 @@ export interface IwstETHV1AdapterInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: "getStETHByWstETH", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "getWstETHByStETH", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "stETH", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "stEthPerToken", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "targetContract", data: BytesLike): Result;
@@ -90,6 +93,7 @@ export interface IwstETHV1Adapter extends BaseContract {
         getStETHByWstETH(_wstETHAmount: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
         getWstETHByStETH(_stETHAmount: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
         name(overrides?: CallOverrides): Promise<[string]>;
+        stETH(overrides?: CallOverrides): Promise<[string]>;
         stEthPerToken(overrides?: CallOverrides): Promise<[BigNumber]>;
         symbol(overrides?: CallOverrides): Promise<[string]>;
         targetContract(overrides?: CallOverrides): Promise<[string]>;
@@ -118,6 +122,7 @@ export interface IwstETHV1Adapter extends BaseContract {
     getStETHByWstETH(_wstETHAmount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
     getWstETHByStETH(_stETHAmount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
     name(overrides?: CallOverrides): Promise<string>;
+    stETH(overrides?: CallOverrides): Promise<string>;
     stEthPerToken(overrides?: CallOverrides): Promise<BigNumber>;
     symbol(overrides?: CallOverrides): Promise<string>;
     targetContract(overrides?: CallOverrides): Promise<string>;
@@ -146,6 +151,7 @@ export interface IwstETHV1Adapter extends BaseContract {
         getStETHByWstETH(_wstETHAmount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
         getWstETHByStETH(_stETHAmount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
         name(overrides?: CallOverrides): Promise<string>;
+        stETH(overrides?: CallOverrides): Promise<string>;
         stEthPerToken(overrides?: CallOverrides): Promise<BigNumber>;
         symbol(overrides?: CallOverrides): Promise<string>;
         targetContract(overrides?: CallOverrides): Promise<string>;
@@ -168,6 +174,7 @@ export interface IwstETHV1Adapter extends BaseContract {
         getStETHByWstETH(_wstETHAmount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
         getWstETHByStETH(_stETHAmount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
         name(overrides?: CallOverrides): Promise<BigNumber>;
+        stETH(overrides?: CallOverrides): Promise<BigNumber>;
         stEthPerToken(overrides?: CallOverrides): Promise<BigNumber>;
         symbol(overrides?: CallOverrides): Promise<BigNumber>;
         targetContract(overrides?: CallOverrides): Promise<BigNumber>;
@@ -197,6 +204,7 @@ export interface IwstETHV1Adapter extends BaseContract {
         getStETHByWstETH(_wstETHAmount: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         getWstETHByStETH(_stETHAmount: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        stETH(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         stEthPerToken(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         targetContract(overrides?: CallOverrides): Promise<PopulatedTransaction>;

package/lib/types/contracts/pathfinder/interfaces/IPathFinder.d.ts

@@ -111,12 +111,10 @@ export interface IPathFinderInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
     events: {
         "PathFinderComponentUpdate(uint8,address)": EventFragment;
-        "ResolverComponentUpdateFailed(address)": EventFragment;
         "ResolverUpdate(uint8,uint8,uint8)": EventFragment;
         "TokenTypeUpdate(address,uint8)": EventFragment;
     };
     getEvent(nameOrSignatureOrTopic: "PathFinderComponentUpdate"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "ResolverComponentUpdateFailed"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "ResolverUpdate"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "TokenTypeUpdate"): EventFragment;
 }
@@ -129,13 +127,6 @@ export declare type PathFinderComponentUpdateEvent = TypedEvent<[
     string
 ], PathFinderComponentUpdateEventObject>;
 export declare type PathFinderComponentUpdateEventFilter = TypedEventFilter<PathFinderComponentUpdateEvent>;
-export interface ResolverComponentUpdateFailedEventObject {
-    arg0: string;
-}
-export declare type ResolverComponentUpdateFailedEvent = TypedEvent<[
-    string
-], ResolverComponentUpdateFailedEventObject>;
-export declare type ResolverComponentUpdateFailedEventFilter = TypedEventFilter<ResolverComponentUpdateFailedEvent>;
 export interface ResolverUpdateEventObject {
     arg0: number;
     arg1: number;
@@ -228,8 +219,6 @@ export interface IPathFinder extends BaseContract {
     filters: {
         "PathFinderComponentUpdate(uint8,address)"(arg0?: BigNumberish | null, arg1?: string | null): PathFinderComponentUpdateEventFilter;
         PathFinderComponentUpdate(arg0?: BigNumberish | null, arg1?: string | null): PathFinderComponentUpdateEventFilter;
-        "ResolverComponentUpdateFailed(address)"(arg0?: null): ResolverComponentUpdateFailedEventFilter;
-        ResolverComponentUpdateFailed(arg0?: null): ResolverComponentUpdateFailedEventFilter;
         "ResolverUpdate(uint8,uint8,uint8)"(arg0?: BigNumberish | null, arg1?: BigNumberish | null, arg2?: BigNumberish | null): ResolverUpdateEventFilter;
         ResolverUpdate(arg0?: BigNumberish | null, arg1?: BigNumberish | null, arg2?: BigNumberish | null): ResolverUpdateEventFilter;
         "TokenTypeUpdate(address,uint8)"(arg0?: string | null, arg1?: BigNumberish | null): TokenTypeUpdateEventFilter;

package/lib/types/contracts/pathfinder/interfaces/IWrapper.d.ts

@@ -0,0 +1,152 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, 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 declare type SwapTaskStruct = {
+    swapOperation: BigNumberish;
+    creditAccount: string;
+    tokenIn: string;
+    tokenOut: string;
+    connectors: string[];
+    amount: BigNumberish;
+    slippage: BigNumberish;
+    externalSlippage: boolean;
+};
+export declare type SwapTaskStructOutput = [
+    number,
+    string,
+    string,
+    string,
+    string[],
+    BigNumber,
+    BigNumber,
+    boolean
+] & {
+    swapOperation: number;
+    creditAccount: string;
+    tokenIn: string;
+    tokenOut: string;
+    connectors: string[];
+    amount: BigNumber;
+    slippage: BigNumber;
+    externalSlippage: boolean;
+};
+export declare type MultiCallStruct = {
+    target: string;
+    callData: BytesLike;
+};
+export declare type MultiCallStructOutput = [string, string] & {
+    target: string;
+    callData: string;
+};
+export declare type SwapQuoteStruct = {
+    multiCall: MultiCallStruct;
+    amount: BigNumberish;
+    found: boolean;
+    gasUsage: BigNumberish;
+};
+export declare type SwapQuoteStructOutput = [
+    MultiCallStructOutput,
+    BigNumber,
+    boolean,
+    BigNumber
+] & {
+    multiCall: MultiCallStructOutput;
+    amount: BigNumber;
+    found: boolean;
+    gasUsage: BigNumber;
+};
+export interface IWrapperInterface extends utils.Interface {
+    functions: {
+        "getComponentId()": FunctionFragment;
+        "unwrap((uint8,address,address,address,address[],uint256,uint256,bool),address)": FunctionFragment;
+        "unwrapsTo(address,address)": FunctionFragment;
+        "version()": FunctionFragment;
+        "wrap((uint8,address,address,address,address[],uint256,uint256,bool),address)": FunctionFragment;
+        "wrapsTo(address,address)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "getComponentId" | "unwrap" | "unwrapsTo" | "version" | "wrap" | "wrapsTo"): FunctionFragment;
+    encodeFunctionData(functionFragment: "getComponentId", values?: undefined): string;
+    encodeFunctionData(functionFragment: "unwrap", values: [SwapTaskStruct, string]): string;
+    encodeFunctionData(functionFragment: "unwrapsTo", values: [string, string]): string;
+    encodeFunctionData(functionFragment: "version", values?: undefined): string;
+    encodeFunctionData(functionFragment: "wrap", values: [SwapTaskStruct, string]): string;
+    encodeFunctionData(functionFragment: "wrapsTo", values: [string, string]): string;
+    decodeFunctionResult(functionFragment: "getComponentId", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unwrap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "unwrapsTo", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wrap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "wrapsTo", data: BytesLike): Result;
+    events: {};
+}
+export interface IWrapper extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: IWrapperInterface;
+    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: {
+        getComponentId(overrides?: CallOverrides): Promise<[number]>;
+        unwrap(swapTask: SwapTaskStruct, adapter: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        unwrapsTo(token: string, adapter: string, overrides?: CallOverrides): Promise<[string]>;
+        version(overrides?: CallOverrides): Promise<[BigNumber]>;
+        wrap(swapTask: SwapTaskStruct, adapter: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        wrapsTo(token: string, adapter: string, overrides?: CallOverrides): Promise<[string]>;
+    };
+    getComponentId(overrides?: CallOverrides): Promise<number>;
+    unwrap(swapTask: SwapTaskStruct, adapter: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    unwrapsTo(token: string, adapter: string, overrides?: CallOverrides): Promise<string>;
+    version(overrides?: CallOverrides): Promise<BigNumber>;
+    wrap(swapTask: SwapTaskStruct, adapter: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    wrapsTo(token: string, adapter: string, overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        getComponentId(overrides?: CallOverrides): Promise<number>;
+        unwrap(swapTask: SwapTaskStruct, adapter: string, overrides?: CallOverrides): Promise<SwapQuoteStructOutput>;
+        unwrapsTo(token: string, adapter: string, overrides?: CallOverrides): Promise<string>;
+        version(overrides?: CallOverrides): Promise<BigNumber>;
+        wrap(swapTask: SwapTaskStruct, adapter: string, overrides?: CallOverrides): Promise<SwapQuoteStructOutput>;
+        wrapsTo(token: string, adapter: string, overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {};
+    estimateGas: {
+        getComponentId(overrides?: CallOverrides): Promise<BigNumber>;
+        unwrap(swapTask: SwapTaskStruct, adapter: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        unwrapsTo(token: string, adapter: string, overrides?: CallOverrides): Promise<BigNumber>;
+        version(overrides?: CallOverrides): Promise<BigNumber>;
+        wrap(swapTask: SwapTaskStruct, adapter: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        wrapsTo(token: string, adapter: string, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        getComponentId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        unwrap(swapTask: SwapTaskStruct, adapter: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        unwrapsTo(token: string, adapter: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        version(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        wrap(swapTask: SwapTaskStruct, adapter: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        wrapsTo(token: string, adapter: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/lib/types/contracts/pathfinder/interfaces/IWrapper.js

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

package/lib/types/contracts/pathfinder/interfaces/index.d.ts

@@ -11,3 +11,4 @@ export type { IPathFinderComponent } from "./IPathFinderComponent";
 export type { IPathResolver } from "./IPathResolver";
 export type { ISwapAggregator } from "./ISwapAggregator";
 export type { ISwapper } from "./ISwapper";
+export type { IWrapper } from "./IWrapper";