@gearbox-protocol/sdk 3.0.0-next.99 → 3.0.0-prevfour.10

package/lib/parsers/txParser.js

@@ -1,147 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TxParser = void 0;
-const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const addressProviderParser_1 = require("./addressProviderParser");
-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 ERC20Parser_1 = require("./ERC20Parser");
-const lidoAdapterParser_1 = require("./lidoAdapterParser");
-const lidoSTETHParser_1 = require("./lidoSTETHParser");
-const poolParser_1 = require("./poolParser");
-const priceOracleParser_1 = require("./priceOracleParser");
-const uniV2AdapterParser_1 = require("./uniV2AdapterParser");
-const uniV3AdapterParser_1 = require("./uniV3AdapterParser");
-const wstETHAdapterParser_1 = require("./wstETHAdapterParser");
-const yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
-class TxParser {
-    static parsers = {};
-    static parse(address, calldata) {
-        const parser = TxParser.getParser(address);
-        try {
-            return parser.parse(calldata);
-        }
-        catch (e) {
-            console.error(`Error while parsing ${address}`, parser, e);
-            return "Parsing error";
-        }
-    }
-    static parseToObject(address, calldata) {
-        const parser = TxParser.getParser(address);
-        return parser.parseToObject(address, calldata);
-    }
-    static getParseData(address) {
-        const parser = TxParser.getParser(address);
-        return { contract: parser.contract, adapterName: parser.adapterName };
-    }
-    static parseMultiCall(calls) {
-        return calls.map(call => TxParser.parse(call.target, call.callData.toString()));
-    }
-    static parseToObjectMultiCall(calls) {
-        return calls.map(call => TxParser.parseToObject(call.target, call.callData.toString()));
-    }
-    static addAdapters(adapters) {
-        for (let a of adapters) {
-            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}`);
-            }
-        }
-    }
-    static addContracts(network) {
-        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 === 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));
-                });
-            }
-        });
-    }
-    static addCreditFacade(creditFacade, underlying, version) {
-        TxParser._addParser(creditFacade, new creditFacadeParser_1.CreditFacadeParser(underlying, version));
-    }
-    static addTokens(network) {
-        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 = sdk_gov_1.contractsByAddress[t.toLowerCase()];
-                if (contract) {
-                    TxParser.chooseContractParser(t, contract, sdk_gov_1.contractParams[contract].type, true);
-                }
-                else {
-                    TxParser._addParser(t, new ERC20Parser_1.ERC20Parser(s));
-                }
-            }
-        });
-    }
-    static addPriceOracle(address) {
-        TxParser._addParser(address, new priceOracleParser_1.PriceOracleParser());
-    }
-    static addAddressProvider(address) {
-        TxParser._addParser(address, new addressProviderParser_1.AddressProviderParser());
-    }
-    static addCreditManager(address, version) {
-        TxParser._addParser(address, new creditManagerParser_1.CreditManagerParser(version));
-    }
-    static addPool(address, version) {
-        TxParser._addParser(address, new poolParser_1.PoolParser(version));
-    }
-    static getParser(address) {
-        const parser = TxParser.parsers[address.toLowerCase()];
-        if (!parser)
-            throw new Error(`Can't find parser for ${address}`);
-        return parser;
-    }
-    static chooseContractParser(address, contract, adapterType, isContract) {
-        const addressLC = address.toLowerCase();
-        switch (sdk_gov_1.AdapterInterface[adapterType]) {
-            case "UNISWAP_V2_ROUTER":
-                TxParser._addParser(addressLC, new uniV2AdapterParser_1.UniswapV2AdapterParser(contract, isContract));
-                break;
-            case "UNISWAP_V3_ROUTER":
-                TxParser._addParser(addressLC, new uniV3AdapterParser_1.UniswapV3AdapterParser(contract, isContract));
-                break;
-            case "CURVE_V1_EXCHANGE_ONLY":
-            case "CURVE_V1_2ASSETS":
-            case "CURVE_V1_3ASSETS":
-            case "CURVE_V1_4ASSETS":
-            case "CURVE_V1_STECRV_POOL":
-            case "CURVE_V1_WRAPPER":
-                TxParser._addParser(addressLC, new curveAdapterParser_1.CurveAdapterParser(contract, isContract));
-                break;
-            case "YEARN_V2":
-                TxParser._addParser(addressLC, new yearnV2AdapterParser_1.YearnV2AdapterParser(contract, isContract));
-                break;
-            case "CONVEX_V1_BASE_REWARD_POOL":
-                TxParser._addParser(addressLC, new convexBaseRewardPoolAdapterParser_1.ConvexBaseRewardPoolAdapterParser(contract, isContract));
-                break;
-            case "CONVEX_V1_BOOSTER":
-                TxParser._addParser(addressLC, new convexBoosterAdapterParser_1.ConvexBoosterAdapterParser(contract, isContract));
-                break;
-            case "CONVEX_V1_CLAIM_ZAP":
-                break;
-            case "LIDO_V1":
-                TxParser._addParser(addressLC, new lidoAdapterParser_1.LidoAdapterParser(contract, isContract));
-                break;
-            case "LIDO_WSTETH_V1":
-                TxParser._addParser(addressLC, new wstETHAdapterParser_1.WstETHAdapterParser(contract, isContract));
-                break;
-        }
-    }
-    static _addParser(address, parser) {
-        TxParser.parsers[address.toLowerCase()] = parser;
-    }
-}
-exports.TxParser = TxParser;

package/lib/parsers/uniV2AdapterParser.d.ts

@@ -1,8 +0,0 @@
-import { SupportedContract } from "@gearbox-protocol/sdk-gov";
-import { AbstractParser } from "./abstractParser";
-import { IParser } from "./iParser";
-export declare class UniswapV2AdapterParser extends AbstractParser implements IParser {
-    constructor(contract: SupportedContract, isContract: boolean);
-    parse(calldata: string): string;
-    protected _parse(calldata: string): string;
-}

package/lib/parsers/uniV2AdapterParser.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniswapV2AdapterParser = void 0;
-const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const types_1 = require("../types");
-const abstractParser_1 = require("./abstractParser");
-class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
-    constructor(contract, isContract) {
-        super(contract);
-        this.ifc = types_1.IUniswapV2Adapter__factory.createInterface();
-        if (!isContract)
-            this.adapterName = "UniswapV2Adapter";
-    }
-    parse(calldata) {
-        return this._parse(calldata);
-    }
-    _parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
-            case "swapExactTokensForTokens": {
-                const [amountIn, amountOutMin, path] = this.decodeFunctionData(functionFragment, calldata);
-                const pathStr = path
-                    .map(r => this.tokenSymbol(r))
-                    .join(" => ");
-                const tokenIn = this.tokenSymbol(path[0]);
-                const tokenOut = this.tokenSymbol(path[path.length - 1]);
-                const amountInStr = this.formatBN(amountIn, tokenIn);
-                const amountOutStr = this.formatBN(amountOutMin, tokenOut);
-                return `${functionName}(amountIn: ${amountInStr}, amountOutMin: ${amountOutStr}, path: [${pathStr}])`;
-            }
-            case "swapTokensForExactTokens": {
-                const [amountOut, amountInMax, path] = this.decodeFunctionData(functionFragment, calldata);
-                const pathStr = path
-                    .map(r => this.tokenSymbol(r))
-                    .join(" => ");
-                const tokenIn = this.tokenSymbol(path[0]);
-                const tokenOut = this.tokenSymbol(path[path.length - 1]);
-                const amountOutStr = this.formatBN(amountOut, tokenIn);
-                const amountInMaxStr = this.formatBN(amountInMax, tokenOut);
-                return `${functionName}(amountOut: ${amountOutStr}, amountInMax: ${amountInMaxStr}, path: [${pathStr}])`;
-            }
-            case "swapDiffTokensForTokens": {
-                const [leftoverAmount, rateMinRAY, path] = this.decodeFunctionData(functionFragment, calldata);
-                const tokenIn = this.tokenSymbol(path[0]);
-                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, tokenIn)}, rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)}, path: [${path
-                    .map(r => this.tokenSymbol(r))
-                    .join(" => ")}])`;
-            }
-            default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
-        }
-    }
-}
-exports.UniswapV2AdapterParser = UniswapV2AdapterParser;

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

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

package/lib/parsers/uniV2AdapterParser.spec.js

@@ -1,47 +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 uniV2AdapterParser_1 = require("./uniV2AdapterParser");
-describe("UniswapV2AdapterParser test", () => {
-    it("swap functions works well", () => {
-        let parser = new uniV2AdapterParser_1.UniswapV2AdapterParser("UNISWAP_V2_ROUTER", false);
-        const ifc = types_1.IUniswapV2Adapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("swapExactTokensForTokens", [
-            sdk_gov_1.WAD * 180000n,
-            BigInt(1e6) * 45n,
-            [
-                sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.WETH,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-            ],
-            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,
-            sdk_gov_1.WAD * 17700n,
-            [
-                sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX,
-            ],
-            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("swapDiffTokensForTokens", [
-            BigInt(1e6) * 234500n,
-            sdk_gov_1.RAY * 3240n,
-            [
-                sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX,
-            ],
-            45033,
-        ]));
-        (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapDiffTokensForTokens(leftoverAmount: 234.50K [234500000000], rate: 3.24K, path: [USDC => DAI => FRAX])", "Incorrect parse swapDiffTokensForTokens");
-    });
-});

package/lib/parsers/uniV3AdapterParser.d.ts

@@ -1,9 +0,0 @@
-import { SupportedContract } from "@gearbox-protocol/sdk-gov";
-import { AbstractParser } from "./abstractParser";
-import { IParser } from "./iParser";
-export declare class UniswapV3AdapterParser extends AbstractParser implements IParser {
-    constructor(contract: SupportedContract, isContract: boolean);
-    parse(calldata: string): string;
-    trackInputPath(path: string): string;
-    trackOutputPath(path: string): string;
-}

package/lib/parsers/uniV3AdapterParser.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniswapV3AdapterParser = void 0;
-const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const types_1 = require("../types");
-const abstractParser_1 = require("./abstractParser");
-class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
-    constructor(contract, isContract) {
-        super(contract);
-        this.ifc = types_1.IUniswapV3Adapter__factory.createInterface();
-        if (!isContract)
-            this.adapterName = "UniswapV3Adapter";
-    }
-    parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
-            case "exactInputSingle": {
-                const [[tokenIn, tokenOut, fee, , , amountIn, amountOutMinimum]] = this.decodeFunctionData(functionFragment, calldata);
-                const tokenInSym = this.tokenSymbol(tokenIn);
-                const tokenOutSym = this.tokenSymbol(tokenOut);
-                const amountInStr = this.formatBN(amountIn, tokenIn);
-                const amountOutMinimumStr = this.formatBN(amountOutMinimum, tokenOut);
-                return `${functionName}(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
-            }
-            case "exactDiffInputSingle": {
-                const { params: { tokenIn, tokenOut, fee, leftoverAmount, rateMinRAY }, } = this.decodeFunctionData(functionFragment, calldata);
-                const tokenInSym = this.tokenSymbol(tokenIn);
-                const tokenOutSym = this.tokenSymbol(tokenOut);
-                const leftoverAmountStr = this.formatBN(leftoverAmount, tokenIn);
-                return `${functionName}(leftoverAmount: ${leftoverAmountStr}, rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
-            }
-            case "exactInput": {
-                const { params: { amountIn, amountOutMinimum, path }, } = this.decodeFunctionData(functionFragment, calldata);
-                const pathStr = this.trackInputPath(path);
-                const amountInStr = this.formatBN(amountIn, this.tokenSymbol(`0x${path.replace("0x", "").slice(0, 40)}`));
-                const amountOutMinimumStr = this.formatBN(amountOutMinimum, this.tokenSymbol(`0x${path.slice(-40, path.length)}`));
-                return `${functionName}(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${pathStr}`;
-            }
-            case "exactDiffInput": {
-                const { params: { leftoverAmount, rateMinRAY, path }, } = this.decodeFunctionData(functionFragment, calldata);
-                const leftoverAmountStr = this.formatBN(leftoverAmount, this.tokenSymbol(`0x${path.replace("0x", "").slice(0, 40)}`));
-                const pathStr = this.trackInputPath(path);
-                return `${functionName}(leftoverAmount: ${leftoverAmountStr}, rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)},  path: ${pathStr}`;
-            }
-            case "exactOutput": {
-                const { params: { amountInMaximum, amountOut, path }, } = this.decodeFunctionData(functionFragment, calldata);
-                const pathStr = this.trackOutputPath(path);
-                const amountInMaximumStr = this.formatBN(amountInMaximum, this.tokenSymbol(`0x${path.slice(-40, path.length)}`));
-                const amountOutStr = this.formatBN(amountOut, this.tokenSymbol(`0x${path.replace("0x", "").slice(0, 40)}`));
-                return `${functionName}(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${pathStr}`;
-            }
-            case "exactOutputSingle": {
-                const [[tokenIn, tokenOut, fee, , , amountOut, amountInMaximum]] = this.decodeFunctionData(functionFragment, calldata);
-                const tokenInSym = this.tokenSymbol(tokenIn);
-                const tokenOutSym = this.tokenSymbol(tokenOut);
-                const amountInMaximumStr = this.formatBN(amountInMaximum, tokenInSym);
-                const amountOutStr = this.formatBN(amountOut, tokenOutSym);
-                return `${functionName}(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
-            }
-            default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
-        }
-    }
-    trackInputPath(path) {
-        let result = "";
-        let pointer = path.startsWith("0x") ? 2 : 0;
-        while (pointer <= path.length - 40) {
-            const from = `0x${path.slice(pointer, pointer + 40)}`.toLowerCase();
-            result += this.tokenSymbol(from) || from;
-            pointer += 40;
-            if (pointer > path.length - 6)
-                return result;
-            const fee = parseInt(path.slice(pointer, pointer + 6), 16);
-            pointer += 6;
-            result += ` ==(fee: ${fee})==> `;
-        }
-        return result;
-    }
-    trackOutputPath(path) {
-        let result = "";
-        let pointer = path.length;
-        while (pointer >= 40) {
-            pointer -= 40;
-            const from = `0x${path.slice(pointer, pointer + 40)}`;
-            result += this.tokenSymbol(from) || from;
-            if (pointer < 6)
-                return result;
-            pointer -= 6;
-            const fee = parseInt(path.slice(pointer, pointer + 6), 16);
-            result += ` ==(fee: ${fee})==> `;
-        }
-        return result;
-    }
-}
-exports.UniswapV3AdapterParser = UniswapV3AdapterParser;

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

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

package/lib/parsers/uniV3AdapterParser.spec.js

@@ -1,120 +0,0 @@
-"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 types_1 = require("../types");
-const uniV3AdapterParser_1 = require("./uniV3AdapterParser");
-const pathToUniV3Path = (path) => {
-    const pathWithFees = [];
-    const types = [];
-    path.forEach((p, num) => {
-        pathWithFees.push(p);
-        types.push("address");
-        if (num !== path.length - 1) {
-            pathWithFees.push(3000);
-            types.push("uint24");
-        }
-    });
-    return (0, solidity_1.pack)(types, pathWithFees);
-};
-describe("UniswapV3AdapterParser test", () => {
-    it("swap functions works well", () => {
-        let parser = new uniV3AdapterParser_1.UniswapV3AdapterParser("UNISWAP_V3_ROUTER", false);
-        const ifc = types_1.IUniswapV3Adapter__factory.createInterface();
-        let parsed;
-        // let parsed = parser.parse(
-        //   ifc.encodeFunctionData("exactInputSingle", [
-        //     {
-        //       tokenIn: tokenDataByNetwork.Arbitrum["1INCH"],
-        //       tokenOut: tokenDataByNetwork.Arbitrum["3Crv"],
-        //       fee: 3000,
-        //       recipient: DUMB_ADDRESS,
-        //       deadline: 12300,
-        //       amountIn: WAD * 1299000n,
-        //       amountOutMinimum: WAD * 10200n,
-        //       sqrtPriceLimitX96: 0,
-        //     },
-        //   ]),
-        // );
-        // expect(parsed).to.be.eq(
-        //   "UniswapV3Adapter[UNISWAP_V3_ROUTER].exactInputSingle(amountIn: 1.29M [1299000000000000000000000], amountOutMinimum: 10.20K [10200000000000000000000],  path: 1INCH ==(fee: 3000)==> 3Crv)",
-        //   "Incorrect parse swapExactTokensForTokens",
-        // );
-        // parsed = parser.parse(
-        //   ifc.encodeFunctionData("exactAllInputSingle", [
-        //     {
-        //       tokenIn: tokenDataByNetwork.Arbitrum["1INCH"],
-        //       tokenOut: tokenDataByNetwork.Arbitrum["3Crv"],
-        //       fee: 3000,
-        //       deadline: 12300,
-        //       rateMinRAY: RAY * 1200n,
-        //       sqrtPriceLimitX96: 0,
-        //     },
-        //   ]),
-        // );
-        // expect(parsed).to.be.eq(
-        //   "UniswapV3Adapter[UNISWAP_V3_ROUTER].exactAllInputSingle(rate: 1.20K,  path: 1INCH ==(fee: 3000)==> 3Crv)",
-        //   "Incorrect parse swapExactTokensForTokens",
-        // );
-        parsed = parser.parse(ifc.encodeFunctionData("exactInput", [
-            {
-                path: pathToUniV3Path([
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-                ]),
-                recipient: sdk_gov_1.DUMB_ADDRESS,
-                deadline: 1232131,
-                amountIn: sdk_gov_1.WAD * 12399n,
-                amountOutMinimum: BigInt(1e6) * 122n,
-            },
-        ]));
-        (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactInput(amountIn: 12.39K [12399000000000000000000], amountOutMinimum: 122.00 [122000000],  path: AAVE ==(fee: 3000)==> LINK ==(fee: 3000)==> USDC", "Incorrect parse swapExactTokensForTokens");
-        parsed = parser.parse(ifc.encodeFunctionData("exactDiffInput", [
-            {
-                path: pathToUniV3Path([
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-                ]),
-                leftoverAmount: sdk_gov_1.WAD * 12399n,
-                rateMinRAY: sdk_gov_1.RAY * 1200n,
-                deadline: 1232131,
-            },
-        ]));
-        (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactDiffInput(leftoverAmount: 12.39K [12399000000000000000000], rate: 1.20K,  path: AAVE ==(fee: 3000)==> LINK ==(fee: 3000)==> USDC", "Incorrect parse swapExactTokensForTokens");
-        // parsed = parser.parse(
-        //   ifc.encodeFunctionData("exactOutputSingle", [
-        //     {
-        //       tokenIn: tokenDataByNetwork.Arbitrum["1INCH"],
-        //       tokenOut: tokenDataByNetwork.Arbitrum.USDC,
-        //       fee: 10000,
-        //       recipient: DUMB_ADDRESS,
-        //       deadline: 12300,
-        //       amountInMaximum: (WAD * 149n) / 1000n,
-        //       amountOut: 102e6,
-        //       sqrtPriceLimitX96: 0,
-        //     },
-        //   ]),
-        // );
-        // expect(parsed).to.be.eq(
-        //   "UniswapV3Adapter[UNISWAP_V3_ROUTER].exactOutputSingle(amountInMaximum: 0.14 [149000000000000000], amountOut: 102.00 [102000000],  path: 1INCH ==(fee: 10000)==> USDC)",
-        //   "Incorrect parse swapExactTokensForTokens",
-        // );
-        parsed = parser.parse(ifc.encodeFunctionData("exactOutput", [
-            {
-                path: pathToUniV3Path([
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-                ]),
-                recipient: sdk_gov_1.DUMB_ADDRESS,
-                deadline: 1232131,
-                amountInMaximum: 123e6,
-                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,7 +0,0 @@
-import { SupportedContract } from "@gearbox-protocol/sdk-gov";
-import { AbstractParser } from "./abstractParser";
-import { IParser } from "./iParser";
-export declare class WstETHAdapterParser extends AbstractParser implements IParser {
-    constructor(contract: SupportedContract, isContract: boolean);
-    parse(calldata: string): string;
-}

package/lib/parsers/wstETHAdapterParser.js

@@ -1,52 +0,0 @@
-"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 abstractParser_1 = require("./abstractParser");
-class WstETHAdapterParser extends abstractParser_1.AbstractParser {
-    constructor(contract, isContract) {
-        super(contract);
-        this.ifc = !isContract
-            ? types_1.IwstETHV1Adapter__factory.createInterface()
-            : types_1.IwstETH__factory.createInterface();
-        if (!isContract)
-            this.adapterName = "wstETHAdapter";
-    }
-    parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
-            case "wrap": {
-                const [amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(amount: ${this.formatBN(amount, "STETH")})`;
-            }
-            case "wrapDiff": {
-                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
-            }
-            case "unwrap": {
-                const [amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(amount: ${this.formatBN(amount, "wstETH")})`;
-            }
-            case "unwrapDiff": {
-                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
-            }
-            case "balanceOf": {
-                const [address] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(${address})`;
-            }
-            case "allowance": {
-                const [account, to] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(account: ${account}, to: ${to})`;
-            }
-            case "approve": {
-                const [spender, amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(${spender}, [${(0, sdk_gov_1.toBigInt)(amount).toString()}])`;
-            }
-            default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
-        }
-    }
-}
-exports.WstETHAdapterParser = WstETHAdapterParser;

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

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

package/lib/parsers/wstETHAdapterParser.spec.js

@@ -1,21 +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 wstETHAdapterParser_1 = require("./wstETHAdapterParser");
-describe("WstETHAdapterParser test", () => {
-    it("wrap / unwrap function works well", () => {
-        let parser = new wstETHAdapterParser_1.WstETHAdapterParser("LIDO_WSTETH", false);
-        const ifc = types_1.IwstETHV1Adapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("wrapDiff", [sdk_gov_1.WAD * 1020n]));
-        (0, chai_1.expect)(parsed).to.be.eq("wstETHAdapter[LIDO_WSTETH].wrapDiff(leftoverAmount: 1.02K [1020000000000000000000])", "Incorrect parse wrapDiff()");
-        parsed = parser.parse(ifc.encodeFunctionData("unwrapDiff", [sdk_gov_1.WAD * 1020n]));
-        (0, chai_1.expect)(parsed).to.be.eq("wstETHAdapter[LIDO_WSTETH].unwrapDiff(leftoverAmount: 1.02K [1020000000000000000000])", "Incorrect parse unwrapDiff()");
-        parser = new wstETHAdapterParser_1.WstETHAdapterParser("LIDO_WSTETH", true);
-        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", [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.d.ts

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

package/lib/parsers/yearnAdapterParser.spec.js

@@ -1,36 +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 yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
-describe("YearnV2AdapterParser test", () => {
-    it("deposit / withdraw functions works well", () => {
-        let parser = new yearnV2AdapterParser_1.YearnV2AdapterParser("YEARN_CURVE_STETH_VAULT", false);
-        const ifc = types_1.IYearnV2Adapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("depositDiff", [sdk_gov_1.WAD * 19000n]));
-        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].depositDiff(leftoverAmount: 19.00K [19000000000000000000000])", "Incorrect parse depositDiff");
-        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)", [
-            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: ${sdk_gov_1.DUMB_ADDRESS})`, "Incorrect parse deposit(amount,address)");
-        parsed = parser.parse(ifc.encodeFunctionData("withdrawDiff", [sdk_gov_1.WAD * 19000n]));
-        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdrawDiff(leftoverAmount: 19.00K [19000000000000000000000])", "Incorrect parse withdrawDiff");
-        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)", [
-            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: ${sdk_gov_1.DUMB_ADDRESS})`, "Incorrect parse withdraw(amount,address)");
-        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256,address,uint256)", [
-            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: ${sdk_gov_1.DUMB_ADDRESS}, maxLoss: 555)`, "Incorrect parse withdraw(amount,address,uint256)");
-    });
-});

package/lib/parsers/yearnV2AdapterParser.d.ts

@@ -1,7 +0,0 @@
-import { SupportedContract } from "@gearbox-protocol/sdk-gov";
-import { AbstractParser } from "./abstractParser";
-import { IParser } from "./iParser";
-export declare class YearnV2AdapterParser extends AbstractParser implements IParser {
-    constructor(contract: SupportedContract, isContract: boolean);
-    parse(calldata: string): string;
-}