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

package/lib/parsers/convextRewardPoolParser.d.ts

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

package/lib/parsers/creditFacadeParser.d.ts

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

package/lib/parsers/creditFacadeParser.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 creditFacadeParser_1 = require("./creditFacadeParser");
 describe("CreditFacadeParser test", () => {
@@ -10,18 +9,18 @@ describe("CreditFacadeParser test", () => {
         let parser = new creditFacadeParser_1.CreditFacadeParser("DAI");
         const ifc = types_1.ICreditFacadeExtended__factory.createInterface();
         let parsed = parser.parse(ifc.encodeFunctionData("addCollateral", [
-            constants_1.DUMB_ADDRESS,
-            token_1.tokenDataByNetwork.Mainnet.WBTC,
-            (constants_1.WAD * 444n) / 10n,
+            sdk_gov_1.DUMB_ADDRESS,
+            sdk_gov_1.tokenDataByNetwork.Mainnet.WBTC,
+            (sdk_gov_1.WAD * 444n) / 10n,
         ]));
         (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].addCollateral(onBehalf: 0xC4375B7De8af5a38a93548eb8453a498222C4fF2, token: WBTC, amount: 44.40 [44400000000000000000])", "Incorrect parse addCollateral");
-        parsed = parser.parse(ifc.encodeFunctionData("increaseDebt", [(constants_1.WAD * 414n) / 10n]));
+        parsed = parser.parse(ifc.encodeFunctionData("increaseDebt", [(sdk_gov_1.WAD * 414n) / 10n]));
         (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].increaseDebt(amount: 41.40 [41400000000000000000])", "Incorrect parse increaseDebt");
-        parsed = parser.parse(ifc.encodeFunctionData("decreaseDebt", [(constants_1.WAD * 334n) / 10n]));
+        parsed = parser.parse(ifc.encodeFunctionData("decreaseDebt", [(sdk_gov_1.WAD * 334n) / 10n]));
         (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].decreaseDebt(amount: 33.40 [33400000000000000000])", "Incorrect parse decreaseDebt");
-        parsed = parser.parse(ifc.encodeFunctionData("enableToken", [token_1.tokenDataByNetwork.Mainnet.WETH]));
+        parsed = parser.parse(ifc.encodeFunctionData("enableToken", [sdk_gov_1.tokenDataByNetwork.Mainnet.WETH]));
         (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].enableToken(token: WETH)", "Incorrect parse enableToken");
-        parsed = parser.parse(ifc.encodeFunctionData("disableToken", [token_1.tokenDataByNetwork.Mainnet.LINK]));
+        parsed = parser.parse(ifc.encodeFunctionData("disableToken", [sdk_gov_1.tokenDataByNetwork.Mainnet.LINK]));
         (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].disableToken(token: LINK)", "Incorrect parse disableToken");
     });
 });

package/lib/parsers/curveAdapterParser.d.ts

@@ -1,6 +1,5 @@
+import { SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
 import { BigNumberish } from "ethers";
-import { SupportedContract } from "../contracts/contracts";
-import { SupportedToken } from "../tokens/token";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class CurveAdapterParser extends AbstractParser implements IParser {

package/lib/parsers/curveAdapterParser.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CurveAdapterParser = void 0;
-const contracts_1 = require("../contracts/contracts");
+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");
@@ -10,7 +10,7 @@ class CurveAdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
         let contractName = "";
-        const nCoins = contracts_1.contractParams[contract].tokens.length;
+        const nCoins = sdk_gov_1.contractParams[contract].tokens.length;
         switch (nCoins) {
             case 2:
                 this.ifc = types_1.ICurveV1_2AssetsAdapter__factory.createInterface();
@@ -27,7 +27,7 @@ class CurveAdapterParser extends abstractParser_1.AbstractParser {
             default:
                 throw new Error(`Unsupported curve contract ${contract}`);
         }
-        this.lpToken = contracts_1.contractParams[contract].lpToken;
+        this.lpToken = sdk_gov_1.contractParams[contract].lpToken;
         if (!isContract)
             this.adapterName = contractName;
     }
@@ -101,11 +101,11 @@ class CurveAdapterParser extends abstractParser_1.AbstractParser {
         }
     }
     getTokenByIndex(index) {
-        return contracts_1.contractParams[this.contract]
+        return sdk_gov_1.contractParams[this.contract]
             .tokens[index];
     }
     getUnderlyingTokenByIndex(index) {
-        return contracts_1.contractParams[this.contract]
+        return sdk_gov_1.contractParams[this.contract]
             .underlyings[index];
     }
     convertAmounts(amounts) {

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]));
+        let parsed = parser.parse(ifc.encodeFunctionData("exchange", [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(i ,j: FRAX => 3Crv, dx: 3.00 [3000000000000000000], min_dy: 32.00 [32000000000000000000])", "Curve2AssetsAdapter: Incorrect parse exchange");
         parsed = parser.parse(ifc.encodeFunctionData("exchange_underlying", [
             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_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]));
+        parsed = parser.parse(ifc.encodeFunctionData("remove_all_liquidity_one_coin", [0, sdk_gov_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("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/txParser.d.ts

@@ -1,6 +1,4 @@
-import { SupportedContract } from "../contracts/contracts";
-import { NetworkType } from "../core/chains";
-import { SupportedToken } from "../tokens/token";
+import { NetworkType, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
 import { MultiCallStruct } from "../types/@gearbox-protocol/router/contracts/interfaces/IClosePathResolver";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";

package/lib/parsers/txParser.js

@@ -1,10 +1,7 @@
 "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");
@@ -48,9 +45,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,16 +55,16 @@ 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) {
+            if (contractData.type === sdk_gov_1.AdapterInterface.LIDO_V1) {
                 const extraAddress = contractData.oracle[network];
                 TxParser._addParser(extraAddress, new lidoOracleParser_1.LidoOracleParser());
             }
@@ -77,14 +74,14 @@ class TxParser {
         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));
@@ -124,7 +121,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.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/pathOptions.d.ts

@@ -1,6 +1,5 @@
+import { CurveLPToken, NetworkType } from "@gearbox-protocol/sdk-gov";
 import { BigNumberish } from "ethers";
-import { NetworkType } from "../core/chains";
-import { CurveLPToken } from "../tokens/curveLP";
 export interface PathOption {
     target: string;
     option: number;

package/lib/pathfinder/pathOptions.js

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PathOptionFactory = void 0;
-const contracts_1 = require("../contracts/contracts");
-const convex_1 = require("../tokens/convex");
-const curveLP_1 = require("../tokens/curveLP");
-const token_1 = require("../tokens/token");
-const yearn_1 = require("../tokens/yearn");
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const formatter_1 = require("../utils/formatter");
 class PathOptionFactory {
     static generatePathOptions(balances, loopsInTx) {
@@ -13,9 +9,9 @@ class PathOptionFactory {
         const network = PathOptionFactory.detectNetwork(Object.keys(balances)[0]);
         const initPO = curvePools.map(symbol => {
             return {
-                target: token_1.tokenDataByNetwork[network][symbol],
+                target: sdk_gov_1.tokenDataByNetwork[network][symbol],
                 option: 0,
-                totalOptions: contracts_1.contractParams[curveLP_1.curveTokens[symbol].pool]
+                totalOptions: sdk_gov_1.contractParams[sdk_gov_1.curveTokens[symbol].pool]
                     .tokens.length,
             };
         });
@@ -33,27 +29,27 @@ class PathOptionFactory {
         return result;
     }
     static getCurvePools(balances) {
-        const curveSymbols = Object.keys(curveLP_1.curveTokens);
+        const curveSymbols = Object.keys(sdk_gov_1.curveTokens);
         const curvePools = Object.entries(balances)
             .filter(([, balance]) => (0, formatter_1.toBigInt)(balance) > 1)
-            .map(([token]) => token_1.tokenSymbolByAddress[token.toLowerCase()])
+            .map(([token]) => sdk_gov_1.tokenSymbolByAddress[token.toLowerCase()])
             .filter(symbol => curveSymbols.includes(symbol));
-        const yearnCurveTokens = Object.entries(yearn_1.yearnTokens)
+        const yearnCurveTokens = Object.entries(sdk_gov_1.yearnTokens)
             .filter(([, data]) => curveSymbols.includes(data.underlying))
             .map(([token]) => token);
         const curvePoolsFromYearn = Object.entries(balances)
             .filter(([, balance]) => (0, formatter_1.toBigInt)(balance) > 1)
-            .map(([token]) => token_1.tokenSymbolByAddress[token.toLowerCase()])
+            .map(([token]) => sdk_gov_1.tokenSymbolByAddress[token.toLowerCase()])
             .filter(symbol => yearnCurveTokens.includes(symbol))
-            .map(symbol => yearn_1.yearnTokens[symbol].underlying);
-        const convexCurveTokens = Object.entries(convex_1.convexTokens)
+            .map(symbol => sdk_gov_1.yearnTokens[symbol].underlying);
+        const convexCurveTokens = Object.entries(sdk_gov_1.convexTokens)
             .filter(([, data]) => curveSymbols.includes(data.underlying))
             .map(([token]) => token);
         const curvePoolsFromConvex = Object.entries(balances)
             .filter(([, balance]) => (0, formatter_1.toBigInt)(balance) > 1)
-            .map(([token]) => token_1.tokenSymbolByAddress[token.toLowerCase()])
+            .map(([token]) => sdk_gov_1.tokenSymbolByAddress[token.toLowerCase()])
             .filter(symbol => convexCurveTokens.includes(symbol))
-            .map(symbol => convex_1.convexTokens[symbol].underlying);
+            .map(symbol => sdk_gov_1.convexTokens[symbol].underlying);
         const curveSet = new Set([
             ...curvePools,
             ...curvePoolsFromYearn,
@@ -74,7 +70,7 @@ class PathOptionFactory {
         throw new Error("Path options overflow");
     }
     static detectNetwork(underlying) {
-        return token_1.tokenDataByNetwork.Mainnet[token_1.tokenSymbolByAddress[underlying.toLowerCase()]].toLowerCase() === underlying.toLowerCase()
+        return sdk_gov_1.tokenDataByNetwork.Mainnet[sdk_gov_1.tokenSymbolByAddress[underlying.toLowerCase()]].toLowerCase() === underlying.toLowerCase()
             ? "Mainnet"
             : "Arbitrum";
     }