@gearbox-protocol/sdk 3.0.0-next.99 → 3.0.0-vfour.2

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

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

package/lib/parsers/curveAdapterParser.spec.js

@@ -1,46 +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_diff_liquidity_one_coin", [
-            sdk_gov_1.WAD * 3n,
-            0,
-            sdk_gov_1.RAY * 912n,
-        ]));
-        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].add_diff_liquidity_one_coin(leftoverAmount: 3.00 [3000000000000000000], i: FRAX, rateMinRAY: 912.00)", "Curve2AssetsAdapter: Incorrect parse add_diff_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/iParser.d.ts

@@ -1,9 +0,0 @@
-import { FunctionFragment } from "ethers/lib/utils";
-export interface IParser {
-    parse: (calldata: string) => string;
-    parseToObject?: (address: string, calldata: string) => {
-        address: string;
-        functionFragment: FunctionFragment;
-        args: any;
-    };
-}

package/lib/parsers/iParser.js

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

package/lib/parsers/lidoAdapterParser.d.ts

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

package/lib/parsers/lidoAdapterParser.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LidoAdapterParser = void 0;
-const types_1 = require("../types");
-const abstractParser_1 = require("./abstractParser");
-class LidoAdapterParser extends abstractParser_1.AbstractParser {
-    constructor(contract, isContract) {
-        super(contract);
-        this.ifc = types_1.ILidoV1Adapter__factory.createInterface();
-        if (!isContract)
-            this.adapterName = "LidoV1Adapter";
-    }
-    parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
-            case "submit": {
-                const [amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(amount: ${this.formatBN(amount, "STETH")})`;
-            }
-            case "submitDiff": {
-                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
-            }
-            default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
-        }
-    }
-}
-exports.LidoAdapterParser = LidoAdapterParser;

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("submitDiff", [sdk_gov_1.WAD * 1020n]));
-        (0, chai_1.expect)(parsed).to.be.eq("Contract[LIDO_STETH_GATEWAY].submitDiff(leftoverAmount: 1.02K [1020000000000000000000])", "Incorrect parse submitDiff(leftoverAmount)");
-    });
-});

package/lib/parsers/lidoSTETHParser.d.ts

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

package/lib/parsers/lidoSTETHParser.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LidoSTETHParser = void 0;
-const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const types_1 = require("../types");
-const abstractParser_1 = require("./abstractParser");
-class LidoSTETHParser extends abstractParser_1.AbstractParser {
-    constructor(symbol) {
-        super(`LIDO_${symbol}`);
-        this.ifc = types_1.IstETH__factory.createInterface();
-    }
-    parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
-            case "getFee":
-            case "totalSupply": {
-                return `${functionName}()`;
-            }
-            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.LidoSTETHParser = LidoSTETHParser;

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;

package/lib/parsers/priceOracleParser.d.ts

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

package/lib/parsers/priceOracleParser.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PriceOracleParser = void 0;
-const types_1 = require("../types");
-const abstractParser_1 = require("./abstractParser");
-class PriceOracleParser extends abstractParser_1.AbstractParser {
-    constructor() {
-        super("PriceOracle");
-        this.ifc = types_1.IPriceOracleBase__factory.createInterface();
-    }
-    parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
-            case "getPrice": {
-                const [token] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(${this.tokenSymbol(token)})`;
-            }
-            default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
-        }
-    }
-}
-exports.PriceOracleParser = PriceOracleParser;

package/lib/parsers/txParser.d.ts

@@ -1,40 +0,0 @@
-import { NetworkType, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
-import { MultiCall } from "../pathfinder/core";
-import { AbstractParser } from "./abstractParser";
-import { IParser } from "./iParser";
-export interface AdapterForParser {
-    adapter: string;
-    contract: string;
-}
-interface ParseData {
-    contract: string;
-    adapterName: string;
-}
-export declare class TxParser {
-    protected static parsers: Record<string, IParser & AbstractParser>;
-    static parse(address: string, calldata: string): string;
-    static parseToObject(address: string, calldata: string): {
-        address: string;
-        functionFragment: import("ethers/lib/utils").FunctionFragment;
-        args: any;
-    };
-    static getParseData(address: string): ParseData;
-    static parseMultiCall(calls: Array<MultiCall>): Array<string>;
-    static parseToObjectMultiCall(calls: Array<MultiCall>): {
-        address: string;
-        functionFragment: import("ethers/lib/utils").FunctionFragment;
-        args: any;
-    }[];
-    static addAdapters(adapters: Array<AdapterForParser>): void;
-    static addContracts(network: NetworkType): void;
-    static addCreditFacade(creditFacade: string, underlying: SupportedToken, version: number): void;
-    static addTokens(network: NetworkType): void;
-    static addPriceOracle(address: string): void;
-    static addAddressProvider(address: string): void;
-    static addCreditManager(address: string, version: number): void;
-    static addPool(address: string, version: number): void;
-    static getParser(address: string): IParser & AbstractParser;
-    protected static chooseContractParser(address: string, contract: SupportedContract, adapterType: number, isContract: boolean): void;
-    protected static _addParser(address: string, parser: IParser & AbstractParser): void;
-}
-export {};

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 {};