@gearbox-protocol/sdk 2.1.34 → 3.0.0-next.10

package/lib/parsers/curveAdapterParser.spec.js

@@ -1,41 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
-const constants_1 = require("../core/constants");
 const types_1 = require("../types");
 const curveAdapterParser_1 = require("./curveAdapterParser");
 describe("CurveAdapterParser test", () => {
     it("stake / withdraw functions works well", () => {
         let parser = new curveAdapterParser_1.CurveAdapterParser("CURVE_FRAX_POOL", false);
         const ifc = types_1.ICurveV1_2AssetsAdapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("exchange", [0, 1, constants_1.WAD * 3n, constants_1.WAD * 32n]));
-        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].exchange(i ,j: FRAX => 3Crv, dx: 3.00 [3000000000000000000], min_dy: 32.00 [32000000000000000000])", "Curve2AssetsAdapter: Incorrect parse exchange");
-        parsed = parser.parse(ifc.encodeFunctionData("exchange_underlying", [
+        let parsed = parser.parse(ifc.encodeFunctionData("exchange(uint256,uint256,uint256,uint256)", [
             0,
             1,
-            constants_1.WAD * 3n,
-            constants_1.WAD * 32n,
+            sdk_gov_1.WAD * 3n,
+            sdk_gov_1.WAD * 32n,
         ]));
+        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].exchange(i ,j: FRAX => 3Crv, dx: 3.00 [3000000000000000000], min_dy: 32.00 [32000000000000000000])", "Curve2AssetsAdapter: Incorrect parse exchange");
+        parsed = parser.parse(ifc.encodeFunctionData("exchange_underlying(int128,int128,uint256,uint256)", [0, 1, sdk_gov_1.WAD * 3n, sdk_gov_1.WAD * 32n]));
         (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].exchange_underlying(i ,j: FRAX => DAI, dx: 3.00 [3000000000000000000], min_dy: 32.00 [32000000000000000000])", "Curve2AssetsAdapter: Incorrect parse exchange_underlying");
-        parsed = parser.parse(ifc.encodeFunctionData("add_liquidity_one_coin", [constants_1.WAD * 3n, 0, constants_1.WAD * 2n]));
+        parsed = parser.parse(ifc.encodeFunctionData("add_liquidity_one_coin", [sdk_gov_1.WAD * 3n, 0, sdk_gov_1.WAD * 2n]));
         (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].add_liquidity_one_coin(amount: 3.00 [3000000000000000000], i: FRAX, minAmount: 2.00 [2000000000000000000])", "Curve2AssetsAdapter: Incorrect parse add_liquidity_one_coin");
-        parsed = parser.parse(ifc.encodeFunctionData("add_all_liquidity_one_coin", [0, constants_1.RAY * 912n]));
+        parsed = parser.parse(ifc.encodeFunctionData("add_all_liquidity_one_coin", [0, sdk_gov_1.RAY * 912n]));
         (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].add_all_liquidity_one_coin(i: FRAX, rateMinRAY: 912.00)", "Curve2AssetsAdapter: Incorrect parse add_all_liquidity_one_coin");
-        parsed = parser.parse(ifc.encodeFunctionData("remove_all_liquidity_one_coin", [0, constants_1.RAY * 721n]));
-        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].remove_all_liquidity_one_coin(i: FRAX, rateMinRAY: 721.00)", "Curve2AssetsAdapter: Incorrect parse remove_all_liquidity_one_coin");
+        parsed = parser.parse(ifc.encodeFunctionData("remove_liquidity_one_coin(uint256,uint256,uint256)", [sdk_gov_1.WAD * 100n, 0, sdk_gov_1.WAD * 10n]));
+        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].remove_liquidity_one_coin(amount: 100.00 [100000000000000000000],i: FRAX, min_amount: 10.00 [10000000000000000000])", "Curve2AssetsAdapter: Incorrect parse remove_liquidity_one_coin");
         parsed = parser.parse(ifc.encodeFunctionData("add_liquidity", [
-            [constants_1.WAD * 100n, constants_1.WAD * 100n],
-            constants_1.WAD * 80n,
+            [sdk_gov_1.WAD * 100n, sdk_gov_1.WAD * 100n],
+            sdk_gov_1.WAD * 80n,
         ]));
         (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].add_liquidity(amounts: [FRAX: 100.00 [100000000000000000000], 3Crv: 100.00 [100000000000000000000]], minAmount: 80.00 [80000000000000000000])", "Curve2AssetsAdapter: Incorrect parse add_liquidity");
         parsed = parser.parse(ifc.encodeFunctionData("remove_liquidity", [
-            constants_1.WAD * 120n,
-            [constants_1.WAD * 100n, constants_1.WAD * 100n],
+            sdk_gov_1.WAD * 120n,
+            [sdk_gov_1.WAD * 100n, sdk_gov_1.WAD * 100n],
         ]));
         (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].remove_liquidity(amount: 120.00 [120000000000000000000], min_amounts: [FRAX: 100.00 [100000000000000000000], 3Crv: 100.00 [100000000000000000000]])", "Curve2AssetsAdapter: Incorrect parse remove_liquidity");
         parsed = parser.parse(ifc.encodeFunctionData("remove_liquidity_imbalance", [
-            [constants_1.WAD * 100n, constants_1.WAD * 100n],
-            constants_1.WAD * 80n,
+            [sdk_gov_1.WAD * 100n, sdk_gov_1.WAD * 100n],
+            sdk_gov_1.WAD * 80n,
         ]));
         (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].remove_liquidity_imbalance(amounts: [FRAX: 100.00 [100000000000000000000], 3Crv: 100.00 [100000000000000000000]], max_burn_amount: 80.00 [80000000000000000000])", "Curve2AssetsAdapter: Incorrect parse remove_liquidity_imbalance");
     });

package/lib/parsers/lidoAdapterParser.d.ts

@@ -1,4 +1,4 @@
-import { SupportedContract } from "../contracts/contracts";
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class LidoAdapterParser extends AbstractParser implements IParser {

package/lib/parsers/lidoAdapterParser.spec.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
-const constants_1 = require("../core/constants");
 const types_1 = require("../types");
 const lidoAdapterParser_1 = require("./lidoAdapterParser");
 describe("LidoAdapterParser test", () => {
     it("submit & submitAll function works well", () => {
         let parser = new lidoAdapterParser_1.LidoAdapterParser("LIDO_STETH_GATEWAY", false);
         const ifc = types_1.ILidoV1Adapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("submit", [constants_1.WAD * 1020n]));
+        let parsed = parser.parse(ifc.encodeFunctionData("submit", [sdk_gov_1.WAD * 1020n]));
         (0, chai_1.expect)(parsed).to.be.eq("LidoV1Adapter[LIDO_STETH_GATEWAY].submit(amount: 1.02K [1020000000000000000000])", "Incorrect parse submit(amount)");
         parser = new lidoAdapterParser_1.LidoAdapterParser("LIDO_STETH_GATEWAY", true);
         parsed = parser.parse(ifc.encodeFunctionData("submitAll"));

package/lib/parsers/lidoSTETHParser.d.ts

@@ -1,4 +1,4 @@
-import { SupportedToken } from "../tokens/token";
+import { SupportedToken } from "@gearbox-protocol/sdk-gov";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class LidoSTETHParser extends AbstractParser implements IParser {

package/lib/parsers/lidoSTETHParser.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LidoSTETHParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
 const abstractParser_1 = require("./abstractParser");
 class LidoSTETHParser extends abstractParser_1.AbstractParser {
     constructor(symbol) {
@@ -26,7 +26,7 @@ class LidoSTETHParser extends abstractParser_1.AbstractParser {
             }
             case "approve": {
                 const [spender, amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(${spender}, [${(0, formatter_1.toBigInt)(amount).toString()}])`;
+                return `${functionName}(${spender}, [${(0, sdk_gov_1.toBigInt)(amount).toString()}])`;
             }
             default:
                 return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;

package/lib/parsers/poolParser.js

@@ -6,7 +6,7 @@ const abstractParser_1 = require("./abstractParser");
 class PoolParser extends abstractParser_1.AbstractParser {
     constructor(version) {
         super(`Pool_V${version}`);
-        this.ifc = types_1.PoolService__factory.createInterface();
+        this.ifc = types_1.IPoolService__factory.createInterface();
     }
     parse(calldata) {
         const { functionFragment, functionName } = this.parseSelector(calldata);

package/lib/parsers/priceOracleParser.js

@@ -6,7 +6,7 @@ const abstractParser_1 = require("./abstractParser");
 class PriceOracleParser extends abstractParser_1.AbstractParser {
     constructor() {
         super("PriceOracle");
-        this.ifc = types_1.IPriceOracleV2__factory.createInterface();
+        this.ifc = types_1.IPriceOracleBase__factory.createInterface();
     }
     parse(calldata) {
         const { functionFragment, functionName } = this.parseSelector(calldata);

package/lib/parsers/txParser.d.ts

@@ -1,7 +1,5 @@
-import { SupportedContract } from "../contracts/contracts";
-import { NetworkType } from "../core/chains";
-import { SupportedToken } from "../tokens/token";
-import { MultiCallStruct } from "../types/@gearbox-protocol/router/contracts/interfaces/IClosePathResolver";
+import { NetworkType, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { MultiCall } from "../pathfinder/core";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export interface AdapterForParser {
@@ -17,26 +15,22 @@ export declare class TxParser {
     static parse(address: string, calldata: string): string;
     static parseToObject(address: string, calldata: string): {
         address: string;
-        functionFragment: import("@ethersproject/abi").FunctionFragment;
+        functionFragment: import("ethers/lib/utils").FunctionFragment;
         args: any;
     };
     static getParseData(address: string): ParseData;
-    static parseMultiCall(calls: Array<MultiCallStruct>): Array<string>;
-    static parseToObjectMultiCall(calls: Array<MultiCallStruct>): {
+    static parseMultiCall(calls: Array<MultiCall>): Array<string>;
+    static parseToObjectMultiCall(calls: Array<MultiCall>): {
         address: string;
-        functionFragment: import("@ethersproject/abi").FunctionFragment;
+        functionFragment: import("ethers/lib/utils").FunctionFragment;
         args: any;
     }[];
     static addAdapters(adapters: Array<AdapterForParser>): void;
     static addContracts(network: NetworkType): void;
     static addCreditFacade(creditFacade: string, underlying: SupportedToken): void;
     static addTokens(network: NetworkType): void;
-    static addOffchainOracleParser(address: string): void;
     static addPriceOracle(address: string): void;
-    static addDataCompressor(address: string): void;
     static addAddressProvider(address: string): void;
-    static addMulticall(address: string): void;
-    static addAirdropDistributor(address: string): void;
     static addCreditManager(address: string, version: number): void;
     static addPool(address: string, version: number): void;
     static getParser(address: string): IParser & AbstractParser;

package/lib/parsers/txParser.js

@@ -1,25 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxParser = void 0;
-const adapters_1 = require("../contracts/adapters");
-const contracts_1 = require("../contracts/contracts");
-const token_1 = require("../tokens/token");
-const mappers_1 = require("../utils/mappers");
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const addressProviderParser_1 = require("./addressProviderParser");
-const airdropDistributorParser_1 = require("./airdropDistributorParser");
 const convexBaseRewardPoolAdapterParser_1 = require("./convexBaseRewardPoolAdapterParser");
 const convexBoosterAdapterParser_1 = require("./convexBoosterAdapterParser");
 const convextRewardPoolParser_1 = require("./convextRewardPoolParser");
 const creditFacadeParser_1 = require("./creditFacadeParser");
 const creditManagerParser_1 = require("./creditManagerParser");
 const curveAdapterParser_1 = require("./curveAdapterParser");
-const dataCompressorParser_1 = require("./dataCompressorParser");
 const ERC20Parser_1 = require("./ERC20Parser");
 const lidoAdapterParser_1 = require("./lidoAdapterParser");
-const lidoOracleParser_1 = require("./lidoOracleParser");
 const lidoSTETHParser_1 = require("./lidoSTETHParser");
-const multicallParser_1 = require("./multicallParser");
-const offchainOracleParser_1 = require("./offchainOracleParser");
 const poolParser_1 = require("./poolParser");
 const priceOracleParser_1 = require("./priceOracleParser");
 const uniV2AdapterParser_1 = require("./uniV2AdapterParser");
@@ -48,9 +40,9 @@ class TxParser {
     }
     static addAdapters(adapters) {
         for (let a of adapters) {
-            const contract = contracts_1.contractsByAddress[a.contract.toLowerCase()];
-            if (contract && contracts_1.contractParams[contract]) {
-                TxParser.chooseContractParser(a.adapter, contract, contracts_1.contractParams[contract].type, false);
+            const contract = sdk_gov_1.contractsByAddress[a.contract.toLowerCase()];
+            if (contract && sdk_gov_1.contractParams[contract]) {
+                TxParser.chooseContractParser(a.adapter, contract, sdk_gov_1.contractParams[contract].type, false);
             }
             else {
                 console.error(`Unknown address: ${contract} at ${a.contract}`);
@@ -58,33 +50,29 @@ class TxParser {
         }
     }
     static addContracts(network) {
-        mappers_1.TypedObjectUtils.entries(contracts_1.contractParams).forEach(([contract, contractData]) => {
-            const address = contracts_1.contractsByNetwork[network][contract];
+        sdk_gov_1.TypedObjectUtils.entries(sdk_gov_1.contractParams).forEach(([contract, contractData]) => {
+            const address = sdk_gov_1.contractsByNetwork[network][contract];
             TxParser.chooseContractParser(address, contract, contractData.type, true);
-            if (contractData.type === adapters_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL) {
+            if (contractData.type === sdk_gov_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL) {
                 contractData.extraRewards.forEach(r => {
                     const extraAddress = r.poolAddress[network];
                     TxParser._addParser(extraAddress, new convextRewardPoolParser_1.ConvexRewardPoolParser(r.rewardToken));
                 });
             }
-            if (contractData.type === adapters_1.AdapterInterface.LIDO_V1) {
-                const extraAddress = contractData.oracle[network];
-                TxParser._addParser(extraAddress, new lidoOracleParser_1.LidoOracleParser());
-            }
         });
     }
     static addCreditFacade(creditFacade, underlying) {
         TxParser._addParser(creditFacade, new creditFacadeParser_1.CreditFacadeParser(underlying));
     }
     static addTokens(network) {
-        mappers_1.TypedObjectUtils.entries(token_1.tokenDataByNetwork[network]).forEach(([s, t]) => {
+        sdk_gov_1.TypedObjectUtils.entries(sdk_gov_1.tokenDataByNetwork[network]).forEach(([s, t]) => {
             if (s === "STETH") {
                 TxParser._addParser(t, new lidoSTETHParser_1.LidoSTETHParser(s));
             }
             else {
-                const contract = contracts_1.contractsByAddress[t.toLowerCase()];
+                const contract = sdk_gov_1.contractsByAddress[t.toLowerCase()];
                 if (contract) {
-                    TxParser.chooseContractParser(t, contract, contracts_1.contractParams[contract].type, true);
+                    TxParser.chooseContractParser(t, contract, sdk_gov_1.contractParams[contract].type, true);
                 }
                 else {
                     TxParser._addParser(t, new ERC20Parser_1.ERC20Parser(s));
@@ -92,24 +80,12 @@ class TxParser {
             }
         });
     }
-    static addOffchainOracleParser(address) {
-        TxParser._addParser(address, new offchainOracleParser_1.OffchainOracleParserParser());
-    }
     static addPriceOracle(address) {
         TxParser._addParser(address, new priceOracleParser_1.PriceOracleParser());
     }
-    static addDataCompressor(address) {
-        TxParser._addParser(address, new dataCompressorParser_1.DataCompressorParser());
-    }
     static addAddressProvider(address) {
         TxParser._addParser(address, new addressProviderParser_1.AddressProviderParser());
     }
-    static addMulticall(address) {
-        TxParser._addParser(address, new multicallParser_1.MulticallParser());
-    }
-    static addAirdropDistributor(address) {
-        TxParser._addParser(address, new airdropDistributorParser_1.AirdropDistributorParser());
-    }
     static addCreditManager(address, version) {
         TxParser._addParser(address, new creditManagerParser_1.CreditManagerParser(version));
     }
@@ -124,7 +100,7 @@ class TxParser {
     }
     static chooseContractParser(address, contract, adapterType, isContract) {
         const addressLC = address.toLowerCase();
-        switch (adapters_1.AdapterInterface[adapterType]) {
+        switch (sdk_gov_1.AdapterInterface[adapterType]) {
             case "UNISWAP_V2_ROUTER":
                 TxParser._addParser(addressLC, new uniV2AdapterParser_1.UniswapV2AdapterParser(contract, isContract));
                 break;

package/lib/parsers/uniV2AdapterParser.d.ts

@@ -1,4 +1,4 @@
-import { SupportedContract } from "../contracts/contracts";
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class UniswapV2AdapterParser extends AbstractParser implements IParser {

package/lib/parsers/uniV2AdapterParser.spec.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
-const constants_1 = require("../core/constants");
-const token_1 = require("../tokens/token");
 const types_1 = require("../types");
 const uniV2AdapterParser_1 = require("./uniV2AdapterParser");
 describe("UniswapV2AdapterParser test", () => {
@@ -10,35 +9,35 @@ describe("UniswapV2AdapterParser test", () => {
         let parser = new uniV2AdapterParser_1.UniswapV2AdapterParser("UNISWAP_V2_ROUTER", false);
         const ifc = types_1.IUniswapV2Adapter__factory.createInterface();
         let parsed = parser.parse(ifc.encodeFunctionData("swapExactTokensForTokens", [
-            constants_1.WAD * 180000n,
+            sdk_gov_1.WAD * 180000n,
             BigInt(1e6) * 45n,
             [
-                token_1.tokenDataByNetwork.Mainnet.DAI,
-                token_1.tokenDataByNetwork.Mainnet.WETH,
-                token_1.tokenDataByNetwork.Mainnet.USDC,
+                sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
+                sdk_gov_1.tokenDataByNetwork.Mainnet.WETH,
+                sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
             ],
-            constants_1.DUMB_ADDRESS,
+            sdk_gov_1.DUMB_ADDRESS,
             45000,
         ]));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapExactTokensForTokens(amountIn: 180.00K [180000000000000000000000], amountOutMin: 45.00 [45000000], path: [DAI => WETH => USDC])", "Incorrect parse swapExactTokensForTokens");
         parsed = parser.parse(ifc.encodeFunctionData("swapTokensForExactTokens", [
             BigInt(1e6) * 234500n,
-            constants_1.WAD * 17700n,
+            sdk_gov_1.WAD * 17700n,
             [
-                token_1.tokenDataByNetwork.Mainnet.USDC,
-                token_1.tokenDataByNetwork.Mainnet.DAI,
-                token_1.tokenDataByNetwork.Mainnet.FRAX,
+                sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
+                sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX,
             ],
-            constants_1.DUMB_ADDRESS,
+            sdk_gov_1.DUMB_ADDRESS,
             45033,
         ]));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapTokensForExactTokens(amountOut: 234.50K [234500000000], amountInMax: 17.70K [17700000000000000000000], path: [USDC => DAI => FRAX])", "Incorrect parse swapTokensForExactTokens");
         parsed = parser.parse(ifc.encodeFunctionData("swapAllTokensForTokens", [
-            constants_1.RAY * 3240n,
+            sdk_gov_1.RAY * 3240n,
             [
-                token_1.tokenDataByNetwork.Mainnet.USDC,
-                token_1.tokenDataByNetwork.Mainnet.DAI,
-                token_1.tokenDataByNetwork.Mainnet.FRAX,
+                sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
+                sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX,
             ],
             45033,
         ]));

package/lib/parsers/uniV3AdapterParser.d.ts

@@ -1,4 +1,4 @@
-import { SupportedContract } from "../contracts/contracts";
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class UniswapV3AdapterParser extends AbstractParser implements IParser {

package/lib/parsers/uniV3AdapterParser.spec.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const solidity_1 = require("@ethersproject/solidity");
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
-const constants_1 = require("../core/constants");
-const token_1 = require("../tokens/token");
 const types_1 = require("../types");
 const uniV3AdapterParser_1 = require("./uniV3AdapterParser");
 const pathToUniV3Path = (path) => {
@@ -61,13 +60,13 @@ describe("UniswapV3AdapterParser test", () => {
         parsed = parser.parse(ifc.encodeFunctionData("exactInput", [
             {
                 path: pathToUniV3Path([
-                    token_1.tokenDataByNetwork.Mainnet.AAVE,
-                    token_1.tokenDataByNetwork.Mainnet.LINK,
-                    token_1.tokenDataByNetwork.Mainnet.USDC,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
                 ]),
-                recipient: constants_1.DUMB_ADDRESS,
+                recipient: sdk_gov_1.DUMB_ADDRESS,
                 deadline: 1232131,
-                amountIn: constants_1.WAD * 12399n,
+                amountIn: sdk_gov_1.WAD * 12399n,
                 amountOutMinimum: BigInt(1e6) * 122n,
             },
         ]));
@@ -75,11 +74,11 @@ describe("UniswapV3AdapterParser test", () => {
         parsed = parser.parse(ifc.encodeFunctionData("exactAllInput", [
             {
                 path: pathToUniV3Path([
-                    token_1.tokenDataByNetwork.Mainnet.AAVE,
-                    token_1.tokenDataByNetwork.Mainnet.LINK,
-                    token_1.tokenDataByNetwork.Mainnet.USDC,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
                 ]),
-                rateMinRAY: constants_1.RAY * 1200n,
+                rateMinRAY: sdk_gov_1.RAY * 1200n,
                 deadline: 1232131,
             },
         ]));
@@ -105,14 +104,14 @@ describe("UniswapV3AdapterParser test", () => {
         parsed = parser.parse(ifc.encodeFunctionData("exactOutput", [
             {
                 path: pathToUniV3Path([
-                    token_1.tokenDataByNetwork.Mainnet.AAVE,
-                    token_1.tokenDataByNetwork.Mainnet.LINK,
-                    token_1.tokenDataByNetwork.Mainnet.USDC,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
                 ]),
-                recipient: constants_1.DUMB_ADDRESS,
+                recipient: sdk_gov_1.DUMB_ADDRESS,
                 deadline: 1232131,
                 amountInMaximum: 123e6,
-                amountOut: constants_1.WAD * 122n,
+                amountOut: sdk_gov_1.WAD * 122n,
             },
         ]));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactOutput(amountInMaximum: 123.00 [123000000], amountOut: 122.00 [122000000000000000000],  path: USDC ==(fee: 3000)==> LINK ==(fee: 3000)==> AAVE", "Incorrect parse swapExactTokensForTokens");

package/lib/parsers/wstETHAdapterParser.d.ts

@@ -1,4 +1,4 @@
-import { SupportedContract } from "../contracts/contracts";
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class WstETHAdapterParser extends AbstractParser implements IParser {

package/lib/parsers/wstETHAdapterParser.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WstETHAdapterParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
 const abstractParser_1 = require("./abstractParser");
 class WstETHAdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
@@ -40,7 +40,7 @@ class WstETHAdapterParser extends abstractParser_1.AbstractParser {
             }
             case "approve": {
                 const [spender, amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(${spender}, [${(0, formatter_1.toBigInt)(amount).toString()}])`;
+                return `${functionName}(${spender}, [${(0, sdk_gov_1.toBigInt)(amount).toString()}])`;
             }
             default:
                 return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;

package/lib/parsers/wstETHAdapterParser.spec.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
-const constants_1 = require("../core/constants");
 const types_1 = require("../types");
 const wstETHAdapterParser_1 = require("./wstETHAdapterParser");
 describe("WstETHAdapterParser test", () => {
@@ -13,9 +13,9 @@ describe("WstETHAdapterParser test", () => {
         parsed = parser.parse(ifc.encodeFunctionData("unwrapAll"));
         (0, chai_1.expect)(parsed).to.be.eq("wstETHAdapter[LIDO_WSTETH].unwrapAll()", "Incorrect parse unwrapAll()");
         parser = new wstETHAdapterParser_1.WstETHAdapterParser("LIDO_WSTETH", true);
-        parsed = parser.parse(ifc.encodeFunctionData("wrap", [constants_1.WAD * 1020n]));
+        parsed = parser.parse(ifc.encodeFunctionData("wrap", [sdk_gov_1.WAD * 1020n]));
         (0, chai_1.expect)(parsed).to.be.eq("Contract[LIDO_WSTETH].wrap(amount: 1.02K [1020000000000000000000])", "Incorrect parse wrap(amount)");
-        parsed = parser.parse(ifc.encodeFunctionData("unwrap", [constants_1.WAD * 1020n]));
+        parsed = parser.parse(ifc.encodeFunctionData("unwrap", [sdk_gov_1.WAD * 1020n]));
         (0, chai_1.expect)(parsed).to.be.eq("Contract[LIDO_WSTETH].unwrap(amount: 1.02K [1020000000000000000000])", "Incorrect parse unwrap(amount)");
     });
 });

package/lib/parsers/yearnAdapterParser.spec.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
-const constants_1 = require("../core/constants");
 const types_1 = require("../types");
 const yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
 describe("YearnV2AdapterParser test", () => {
@@ -10,27 +10,27 @@ describe("YearnV2AdapterParser test", () => {
         const ifc = types_1.IYearnV2Adapter__factory.createInterface();
         let parsed = parser.parse(ifc.encodeFunctionData("deposit()"));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit()", "Incorrect parse deposit()");
-        parsed = parser.parse(ifc.encodeFunctionData("deposit(uint256)", [constants_1.WAD * 19000n]));
+        parsed = parser.parse(ifc.encodeFunctionData("deposit(uint256)", [sdk_gov_1.WAD * 19000n]));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000])", "Incorrect parse deposit(amount)");
         parsed = parser.parse(ifc.encodeFunctionData("deposit(uint256,address)", [
-            constants_1.WAD * 19000n,
-            constants_1.DUMB_ADDRESS,
+            sdk_gov_1.WAD * 19000n,
+            sdk_gov_1.DUMB_ADDRESS,
         ]));
-        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000], address: ${constants_1.DUMB_ADDRESS})`, "Incorrect parse deposit(amount,address)");
+        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000], address: ${sdk_gov_1.DUMB_ADDRESS})`, "Incorrect parse deposit(amount,address)");
         parsed = parser.parse(ifc.encodeFunctionData("withdraw()"));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw()", "Incorrect parse withdraw()");
-        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256)", [constants_1.WAD * 19000n]));
+        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256)", [sdk_gov_1.WAD * 19000n]));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000])", "Incorrect parse withdraw(amount)");
         parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256,address)", [
-            constants_1.WAD * 19000n,
-            constants_1.DUMB_ADDRESS,
+            sdk_gov_1.WAD * 19000n,
+            sdk_gov_1.DUMB_ADDRESS,
         ]));
-        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ${constants_1.DUMB_ADDRESS})`, "Incorrect parse withdraw(amount,address)");
+        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ${sdk_gov_1.DUMB_ADDRESS})`, "Incorrect parse withdraw(amount,address)");
         parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256,address,uint256)", [
-            constants_1.WAD * 19000n,
-            constants_1.DUMB_ADDRESS,
+            sdk_gov_1.WAD * 19000n,
+            sdk_gov_1.DUMB_ADDRESS,
             555,
         ]));
-        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ${constants_1.DUMB_ADDRESS}, maxLoss: 555)`, "Incorrect parse withdraw(amount,address,uint256)");
+        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ${sdk_gov_1.DUMB_ADDRESS}, maxLoss: 555)`, "Incorrect parse withdraw(amount,address,uint256)");
     });
 });

package/lib/parsers/yearnV2AdapterParser.d.ts

@@ -1,4 +1,4 @@
-import { SupportedContract } from "../contracts/contracts";
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class YearnV2AdapterParser extends AbstractParser implements IParser {

package/lib/parsers/yearnV2AdapterParser.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YearnV2AdapterParser = void 0;
-const contracts_1 = require("../contracts/contracts");
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const types_1 = require("../types");
 const abstractParser_1 = require("./abstractParser");
 class YearnV2AdapterParser extends abstractParser_1.AbstractParser {
@@ -20,7 +20,7 @@ class YearnV2AdapterParser extends abstractParser_1.AbstractParser {
             case "withdraw(uint256)":
             case "withdraw(uint256,address,uint256)": {
                 const [amount, address, maxLoss] = this.decodeFunctionData(functionFragment, calldata);
-                const yvSym = this.tokenSymbol(contracts_1.contractsByNetwork.Mainnet[this.contract]);
+                const yvSym = this.tokenSymbol(sdk_gov_1.contractsByNetwork.Mainnet[this.contract]);
                 const amountStr = amount
                     ? `amount: ${this.formatBN(amount, yvSym)}`
                     : "";

package/lib/pathfinder/core.d.ts

@@ -1,12 +1,12 @@
+import { ExcludeArrayProps } from "@gearbox-protocol/sdk-gov";
+import { MultiCallStructOutput, SwapTaskStructOutput } from "../types/IRouter";
 export declare enum SwapOperation {
     EXACT_INPUT = 0,
     EXACT_INPUT_ALL = 1,
     EXACT_OUTPUT = 2
 }
-export interface MultiCall {
-    target: string;
-    callData: string;
-}
+export type MultiCall = ExcludeArrayProps<MultiCallStructOutput>;
+export type SwapTask = ExcludeArrayProps<SwapTaskStructOutput>;
 export interface PathFinderResult {
     amount: bigint;
     calls: Array<MultiCall>;

package/lib/pathfinder/pathOptions.d.ts

@@ -1,15 +1,15 @@
-import { BigNumberish } from "ethers";
-import { NetworkType } from "../core/chains";
-import { CurveLPToken } from "../tokens/curveLP";
+import { CurveLPToken, NetworkType } from "@gearbox-protocol/sdk-gov";
+import { CaTokenBalance } from "../payload/creditAccount";
 export interface PathOption {
     target: string;
     option: number;
     totalOptions: number;
 }
 export type PathOptionSerie = Array<PathOption>;
+export type BalanceInterface = Pick<CaTokenBalance, "balance">;
 export declare class PathOptionFactory {
-    static generatePathOptions(balances: Record<string, BigNumberish>, loopsInTx: number): Array<PathOptionSerie>;
-    static getCurvePools(balances: Record<string, BigNumberish>): Array<CurveLPToken>;
+    static generatePathOptions(balances: Record<string, BalanceInterface>, loopsInTx: number): Array<PathOptionSerie>;
+    static getCurvePools(balances: Record<string, BalanceInterface>): Array<CurveLPToken>;
     static next(path: PathOptionSerie): PathOptionSerie;
     static detectNetwork(underlying: string): NetworkType;
 }