@gearbox-protocol/sdk 3.0.0-next.30 → 3.0.0-next.300

package/lib/core/rewardClaimer.d.ts

@@ -1,18 +0,0 @@
-import { NetworkType, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
-import { providers } from "ethers";
-import { MultiCall } from "../pathfinder/core";
-import { CreditAccountData } from "./creditAccount";
-import { CreditManagerData } from "./creditManager";
-export interface Rewards {
-    contract: SupportedContract;
-    rewards: Partial<Record<SupportedToken, bigint>>;
-    calls: Array<MultiCall>;
-}
-export interface AdapterWithType {
-    contractAddress: string;
-    adapter: string;
-    contract: SupportedContract;
-}
-export declare class RewardClaimer {
-    static findRewards(ca: CreditAccountData, cm: CreditManagerData, network: NetworkType, provider: providers.Provider): Promise<Array<Rewards>>;
-}

package/lib/core/rewardClaimer.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RewardClaimer = void 0;
-const rewardConvex_1 = require("./rewardConvex");
-class RewardClaimer {
-    static async findRewards(ca, cm, network, provider) {
-        return rewardConvex_1.RewardConvex.findRewards(ca, cm, network, provider);
-    }
-}
-exports.RewardClaimer = RewardClaimer;

package/lib/core/rewardConvex.d.ts

@@ -1,24 +0,0 @@
-import { MCall, NetworkType, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
-import { BigNumber, providers } from "ethers";
-import { IBaseRewardPoolInterface } from "../types/IBaseRewardPool";
-import { CreditAccountData } from "./creditAccount";
-import { CreditManagerData } from "./creditManager";
-import { AdapterWithType, Rewards } from "./rewardClaimer";
-export interface RewardDistribution {
-    adapter: string;
-    contractAddress: string;
-    contract: SupportedContract;
-    token: SupportedToken;
-}
-interface MCallPreparation {
-    calls: Array<MCall<IBaseRewardPoolInterface>>;
-    distribution: Array<RewardDistribution>;
-}
-export declare class RewardConvex {
-    static poolInterface: IBaseRewardPoolInterface;
-    static findRewards(ca: CreditAccountData, cm: CreditManagerData, network: NetworkType, provider: providers.Provider): Promise<Array<Rewards>>;
-    static findAdapters(cm: CreditManagerData): Array<AdapterWithType>;
-    static prepareMultiCalls(creditAccount: string, cm: CreditManagerData, network: NetworkType): MCallPreparation;
-    static parseResults(rewards: Array<BigNumber>, distribution: Array<RewardDistribution>): Array<Rewards>;
-}
-export {};

package/lib/core/rewardConvex.js

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RewardConvex = void 0;
-const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const apy_1 = require("../apy");
-const types_1 = require("../types");
-class RewardConvex {
-    static poolInterface = types_1.IBaseRewardPool__factory.createInterface();
-    static async findRewards(ca, cm, network, provider) {
-        const { calls, distribution } = RewardConvex.prepareMultiCalls(ca.addr, cm, network);
-        const mcalls = calls;
-        mcalls.push({
-            address: sdk_gov_1.tokenDataByNetwork[network].CVX,
-            interface: types_1.IConvexToken__factory.createInterface(),
-            method: "totalSupply()",
-        });
-        const rewards = await (0, sdk_gov_1.multicall)(mcalls, provider);
-        const totalSupply = rewards.pop();
-        const results = RewardConvex.parseResults(rewards, distribution);
-        results.forEach(r => {
-            r.rewards.CVX = (0, apy_1.getCVXMintAmount)(r.rewards.CRV || 0n, (0, sdk_gov_1.toBigInt)(totalSupply));
-        });
-        return results;
-    }
-    static findAdapters(cm) {
-        const convexPools = Object.entries(sdk_gov_1.contractParams)
-            .filter(([_, params]) => params.type === sdk_gov_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL)
-            .map(([contract]) => contract);
-        return Object.entries(cm.adapters)
-            .map(([contract, adapter]) => ({
-            adapter,
-            contractAddress: contract,
-            contract: sdk_gov_1.contractsByAddress[contract.toLowerCase()],
-        }))
-            .filter(a => convexPools.includes(a.contract));
-    }
-    static prepareMultiCalls(creditAccount, cm, network) {
-        const calls = [];
-        const distribution = [];
-        const adapters = this.findAdapters(cm);
-        for (let a of adapters) {
-            calls.push({
-                address: a.contractAddress,
-                interface: RewardConvex.poolInterface,
-                method: "earned(address)",
-                params: [creditAccount],
-            });
-            distribution.push({
-                contractAddress: a.contractAddress,
-                adapter: a.adapter,
-                contract: a.contract,
-                token: "CRV",
-            });
-            const params = sdk_gov_1.contractParams[a.contract];
-            for (let er of params.extraRewards) {
-                calls.push({
-                    address: er.poolAddress[network],
-                    interface: RewardConvex.poolInterface,
-                    method: "earned(address)",
-                    params: [creditAccount],
-                });
-                distribution.push({
-                    contractAddress: a.contractAddress,
-                    adapter: a.adapter,
-                    contract: a.contract,
-                    token: er.rewardToken,
-                });
-            }
-        }
-        return {
-            calls,
-            distribution,
-        };
-    }
-    static parseResults(rewards, distribution) {
-        const result = {};
-        const callData = RewardConvex.poolInterface.encodeFunctionData("getReward()");
-        for (let i = 0; i < rewards.length; i++) {
-            const { contract, adapter, token } = distribution[i];
-            const reward = rewards[i];
-            if (!reward.isZero()) {
-                if (!result[contract]) {
-                    result[contract] = {
-                        contract,
-                        rewards: {},
-                        calls: [
-                            {
-                                target: adapter,
-                                callData,
-                            },
-                        ],
-                    };
-                }
-                result[contract].rewards[token] = BigInt(reward.toString());
-            }
-        }
-        return Object.values(result);
-    }
-}
-exports.RewardConvex = RewardConvex;

package/lib/core/strategy.spec.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const chai_1 = require("chai");
-const contractsRegister_1 = require("../contracts/contractsRegister");
-const formatter_1 = require("../utils/formatter");
-const strategy_1 = require("./strategy");
-const lidoPayload = {
-    name: "Lido",
-    lpToken: sdk_gov_1.tokenDataByNetwork.Mainnet.STETH,
-    apy: 38434,
-    creditManagers: [contractsRegister_1.creditManagerByNetwork.Mainnet.WETH_V2],
-    unleveragableCollateral: [
-        sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-        sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
-        sdk_gov_1.tokenDataByNetwork.Mainnet.WBTC,
-    ],
-    leveragableCollateral: [],
-    baseAssets: [sdk_gov_1.tokenDataByNetwork.Mainnet.WETH],
-};
-const lidoStrategy = new strategy_1.Strategy(lidoPayload);
-const pools = {
-    "0x1": {
-        borrowRate: 27543,
-    },
-    "0x2": {
-        borrowRate: 5736,
-    },
-};
-const prices = {
-    [sdk_gov_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()]: (0, formatter_1.toBN)("1738.11830000", sdk_gov_1.PRICE_DECIMALS_POW),
-    [sdk_gov_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase()]: (0, formatter_1.toBN)("0.99941103", sdk_gov_1.PRICE_DECIMALS_POW),
-    [sdk_gov_1.tokenDataByNetwork.Mainnet.STETH.toLowerCase()]: (0, formatter_1.toBN)("1703.87588096", sdk_gov_1.PRICE_DECIMALS_POW),
-};
-const liquidationThresholds = {
-    [sdk_gov_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase()]: 9300n,
-    [sdk_gov_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()]: 8500n,
-    [sdk_gov_1.tokenDataByNetwork.Mainnet.STETH.toLowerCase()]: 9000n,
-};
-describe("Strategy test", () => {
-    it("maxAPY calculation is correct", () => {
-        const result = lidoStrategy.maxAPY(53203, 10 * Number(sdk_gov_1.LEVERAGE_DECIMALS), pools["0x1"].borrowRate);
-        (0, chai_1.expect)(result).to.be.eq(284143);
-    });
-    it("liquidationPrice calculation is correct", () => {
-        const result = strategy_1.Strategy.liquidationPrice({
-            liquidationThresholds,
-            prices,
-            borrowed: (0, formatter_1.toBN)("350", sdk_gov_1.decimals.WETH),
-            underlyingToken: sdk_gov_1.tokenDataByNetwork.Mainnet.WETH,
-            lpAmount: (0, formatter_1.toBN)("400", sdk_gov_1.decimals.STETH),
-            lpToken: sdk_gov_1.tokenDataByNetwork.Mainnet.STETH,
-        });
-        (0, chai_1.expect)(Number((0, formatter_1.toSignificant)(result, sdk_gov_1.WAD_DECIMALS_POW)).toFixed(3)).to.be.eq("0.992");
-    });
-    it("maxLeverage is correct", () => {
-        const result = strategy_1.Strategy.maxLeverage(sdk_gov_1.tokenDataByNetwork.Mainnet.STETH, [
-            { address: "0x1", liquidationThresholds },
-        ]);
-        (0, chai_1.expect)(result).to.be.eq(9 * Number(sdk_gov_1.LEVERAGE_DECIMALS));
-    });
-});

package/lib/parsers/addressProviderParser.d.ts

@@ -1,6 +0,0 @@
-import { AbstractParser } from "./abstractParser";
-import { IParser } from "./iParser";
-export declare class AddressProviderParser extends AbstractParser implements IParser {
-    constructor();
-    parse(calldata: string): string;
-}

package/lib/parsers/addressProviderParser.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddressProviderParser = void 0;
-const types_1 = require("../types");
-const abstractParser_1 = require("./abstractParser");
-class AddressProviderParser extends abstractParser_1.AbstractParser {
-    constructor() {
-        super("AddressProvider");
-        this.ifc = types_1.IAddressProvider__factory.createInterface();
-    }
-    parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
-            case "getWethToken":
-            case "getGearToken":
-            case "getLeveragedActions":
-            case "getDataCompressor":
-            case "getWETHGateway":
-            case "getPriceOracle": {
-                return `${functionName}()`;
-            }
-            default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
-        }
-    }
-}
-exports.AddressProviderParser = AddressProviderParser;

package/lib/parsers/convexBaseRewardPoolAdapterParser.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/parsers/convexBaseRewardPoolAdapterParser.spec.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const chai_1 = require("chai");
-const types_1 = require("../types");
-const convexBaseRewardPoolAdapterParser_1 = require("./convexBaseRewardPoolAdapterParser");
-describe("ConvexV1BaseRewardPoolAdapterParser test", () => {
-    it("stake / withdraw functions works well", () => {
-        let parser = new convexBaseRewardPoolAdapterParser_1.ConvexBaseRewardPoolAdapterParser("CONVEX_FRAX3CRV_POOL", false);
-        const ifc = types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("stake", [(sdk_gov_1.WAD * 199n) / 10n]));
-        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].stake(amount: 19.90 [19900000000000000000])", "Incorrect parse stake");
-        parsed = parser.parse(ifc.encodeFunctionData("stakeAll"));
-        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].stakeAll()", "Incorrect parse stakeAll");
-        parsed = parser.parse(ifc.encodeFunctionData("withdraw", [(sdk_gov_1.WAD * 199n) / 1000n, false]));
-        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].withdraw(amount: 0.19 [199000000000000000], claim: false)", "Incorrect parse withdraw");
-        parsed = parser.parse(ifc.encodeFunctionData("withdrawAndUnwrap", [(sdk_gov_1.WAD * 2n) / 1000n, true]));
-        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].withdrawAndUnwrap(amount: 0.002 [2000000000000000], claim: true)", "Incorrect parse withdrawAndUnwrap");
-        parsed = parser.parse(ifc.encodeFunctionData("withdrawAll", [false]));
-        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].withdrawAll(claim: false)", "Incorrect parse withdrawAll");
-        parsed = parser.parse(ifc.encodeFunctionData("withdrawAllAndUnwrap", [true]));
-        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].withdrawAllAndUnwrap(claim: true)", "Incorrect parse withdrawAllAndUnwrap");
-    });
-});

package/lib/parsers/convexBoosterAdapterParser.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/parsers/convexBoosterAdapterParser.spec.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const chai_1 = require("chai");
-const types_1 = require("../types");
-const convexBoosterAdapterParser_1 = require("./convexBoosterAdapterParser");
-describe("ConvexV1BaseRewardPoolAdapterParser test", () => {
-    it("stake / withdraw functions works well", () => {
-        let parser = new convexBoosterAdapterParser_1.ConvexBoosterAdapterParser("CONVEX_BOOSTER", false);
-        const ifc = types_1.IConvexV1BoosterAdapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("deposit", [9, sdk_gov_1.WAD * 19999n, false]));
-        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BoosterAdapter[CONVEX_BOOSTER].deposit(pid: 9 [CONVEX_3CRV_POOL], amount: 19.99K [19999000000000000000000], stake: false)", "Incorrect parse deposit");
-        parsed = parser.parse(ifc.encodeFunctionData("depositAll", [32, true]));
-        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BoosterAdapter[CONVEX_BOOSTER].depositAll(pid: 32 [CONVEX_FRAX3CRV_POOL], stake: true)", "Incorrect parse depositAll");
-        parsed = parser.parse(ifc.encodeFunctionData("withdraw", [9, (sdk_gov_1.WAD * 555n) / 10n]));
-        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BoosterAdapter[CONVEX_BOOSTER].withdraw(pid: 9 [CONVEX_3CRV_POOL], amount: 55.50 [55500000000000000000])", "Incorrect parse withdraw");
-        parsed = parser.parse(ifc.encodeFunctionData("withdrawAll", [32]));
-        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BoosterAdapter[CONVEX_BOOSTER].withdrawAll(pid: 32 [CONVEX_FRAX3CRV_POOL])", "Incorrect parse withdrawAll");
-    });
-});

package/lib/parsers/creditFacadeParser.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/parsers/creditFacadeParser.spec.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const chai_1 = require("chai");
-const types_1 = require("../types");
-const creditFacadeParser_1 = require("./creditFacadeParser");
-describe("CreditFacadeParser test", () => {
-    it("all functions works well", () => {
-        let parser = new creditFacadeParser_1.CreditFacadeParser("DAI", 1);
-        const ifc = types_1.ICreditFacadeV2Extended__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("addCollateral", [
-            sdk_gov_1.tokenDataByNetwork.Mainnet.WBTC,
-            (sdk_gov_1.WAD * 444n) / 10n,
-        ]));
-        (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].addCollateral(token: WBTC, amount: 44.40 [44400000000000000000])", "Incorrect parse addCollateral");
-        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", [(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", [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", [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.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/parsers/curveAdapterParser.spec.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const chai_1 = require("chai");
-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(uint256,uint256,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(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", [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, 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_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", [
-            [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", [
-            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", [
-            [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.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/parsers/lidoAdapterParser.spec.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const chai_1 = require("chai");
-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", [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"));
-        (0, chai_1.expect)(parsed).to.be.eq("Contract[LIDO_STETH_GATEWAY].submitAll()", "Incorrect parse submitAll()");
-    });
-});

package/lib/parsers/poolParser.d.ts

@@ -1,6 +0,0 @@
-import { AbstractParser } from "./abstractParser";
-import { IParser } from "./iParser";
-export declare class PoolParser extends AbstractParser implements IParser {
-    constructor(version: number);
-    parse(calldata: string): string;
-}

package/lib/parsers/poolParser.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PoolParser = void 0;
-const types_1 = require("../types");
-const abstractParser_1 = require("./abstractParser");
-class PoolParser extends abstractParser_1.AbstractParser {
-    constructor(version) {
-        super(`Pool_V${version}`);
-        this.ifc = types_1.IPoolService__factory.createInterface();
-    }
-    parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
-            default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
-        }
-    }
-}
-exports.PoolParser = PoolParser;