@gearbox-protocol/sdk 1.3.4 → 1.4.0

package/lib/parsers/lidoAdapterParser.js

@@ -0,0 +1,46 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LidoAdapterParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var LidoAdapterParser = /** @class */ (function (_super) {
+    __extends(LidoAdapterParser, _super);
+    function LidoAdapterParser(contract, isContract) {
+        var _this = _super.call(this, contract) || this;
+        _this.ifc = types_1.ILidoV1Adapter__factory.createInterface();
+        if (!isContract)
+            _this.adapterName = "LidoV1Adapter";
+        return _this;
+    }
+    LidoAdapterParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "submit": {
+                var amount = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(amount: ").concat(this.formatBN(amount, "STETH"), ")");
+            }
+            case "submitAll": {
+                return "".concat(functionName, "()");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return LidoAdapterParser;
+}(abstractParser_1.AbstractParser));
+exports.LidoAdapterParser = LidoAdapterParser;

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

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

package/lib/parsers/lidoAdapterParser.spec.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var chai_1 = require("chai");
+var constants_1 = require("../core/constants");
+var types_1 = require("../types");
+var lidoAdapterParser_1 = require("./lidoAdapterParser");
+describe("LidoAdapterParser test", function () {
+    it("submit & submitAll function works well", function () {
+        var parser = new lidoAdapterParser_1.LidoAdapterParser("LIDO_STETH_GATEWAY", false);
+        var ifc = types_1.ILidoV1Adapter__factory.createInterface();
+        var parsed = parser.parse(ifc.encodeFunctionData("submit", [constants_1.WAD.mul(1020)]));
+        (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/txParser.d.ts

@@ -0,0 +1,18 @@
+import { SupportedContract } from "../contracts/contracts";
+import { NetworkType } from "../core/constants";
+import { SupportedToken } from "../tokens/token";
+import { MultiCallStruct } from "../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade";
+import { IParser } from "./iParser";
+export interface AdapterForParser {
+    adapter: string;
+    contract: string;
+}
+export declare class TxParser {
+    protected static parsers: Record<string, IParser>;
+    static parse(address: string, calldata: string): string;
+    static parseMultiCall(calls: Array<MultiCallStruct>): Array<string>;
+    static addAdapters(adapters: Array<AdapterForParser>): Promise<void>;
+    static addContracts(network: NetworkType): void;
+    static addCreditFacades(creditFacade: string, underlying: SupportedToken): void;
+    protected static addParser(address: string, contract: SupportedContract, adapterType: number, isContract: boolean): void;
+}

package/lib/parsers/txParser.js

@@ -0,0 +1,122 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxParser = void 0;
+var adapters_1 = require("../contracts/adapters");
+var contracts_1 = require("../contracts/contracts");
+var convexBaseRewardPoolAdapterParser_1 = require("./convexBaseRewardPoolAdapterParser");
+var convexBoosterAdapterParser_1 = require("./convexBoosterAdapterParser");
+var creditFacadeParser_1 = require("./creditFacadeParser");
+var curveAdapterParser_1 = require("./curveAdapterParser");
+var lidoAdapterParser_1 = require("./lidoAdapterParser");
+var uniV2AdapterParser_1 = require("./uniV2AdapterParser");
+var uniV3AdapterParser_1 = require("./uniV3AdapterParser");
+var yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
+var TxParser = /** @class */ (function () {
+    function TxParser() {
+    }
+    TxParser.parse = function (address, calldata) {
+        var parser = this.parsers[address];
+        if (!parser)
+            throw new Error("Can find parser for ".concat(address));
+        return parser.parse(calldata);
+    };
+    TxParser.parseMultiCall = function (calls) {
+        return calls.map(function (call) {
+            return TxParser.parse(call.target, call.callData.toString());
+        });
+    };
+    TxParser.addAdapters = function (adapters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, adapters_2, a, contract;
+            return __generator(this, function (_a) {
+                for (_i = 0, adapters_2 = adapters; _i < adapters_2.length; _i++) {
+                    a = adapters_2[_i];
+                    contract = contracts_1.contractsByAddress[a.contract.toLowerCase()];
+                    TxParser.addParser(a.adapter, contract, contracts_1.contractParams[contract].type, false);
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    TxParser.addContracts = function (network) {
+        for (var _i = 0, _a = Object.keys(contracts_1.contractParams); _i < _a.length; _i++) {
+            var c = _a[_i];
+            var address = contracts_1.contractsByNetwork[network][c];
+            TxParser.addParser(address, c, contracts_1.contractParams[c].type, true);
+        }
+    };
+    TxParser.addCreditFacades = function (creditFacade, underlying) {
+        this.parsers[creditFacade.toLowerCase()] = new creditFacadeParser_1.CreditFacadeParser(underlying);
+    };
+    TxParser.addParser = function (address, contract, adapterType, isContract) {
+        switch (adapters_1.AdapterInterface[adapterType]) {
+            case "UNISWAP_V2_ROUTER":
+                TxParser.parsers[address] = new uniV2AdapterParser_1.UniswapV2AdapterParser(contract, isContract);
+                break;
+            case "UNISWAP_V3_ROUTER":
+                TxParser.parsers[address] = 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.parsers[address] = new curveAdapterParser_1.CurveAdapterParser(contract, isContract);
+                break;
+            case "YEARN_V2":
+                TxParser.parsers[address] = new yearnV2AdapterParser_1.YearnV2AdapterParser(contract, isContract);
+                break;
+            case "CONVEX_V1_BASE_REWARD_POOL":
+                TxParser.parsers[address] = new convexBaseRewardPoolAdapterParser_1.ConvexBaseRewardPoolAdapterParser(contract, isContract);
+                break;
+            case "CONVEX_V1_BOOSTER":
+                TxParser.parsers[address] = new convexBoosterAdapterParser_1.ConvexBoosterAdapterParser(contract, isContract);
+                break;
+            case "CONVEX_V1_CLAIM_ZAP":
+                break;
+            case "LIDO_V1":
+                TxParser.parsers[address] = new lidoAdapterParser_1.LidoAdapterParser(contract, isContract);
+                break;
+        }
+    };
+    TxParser.parsers = {};
+    return TxParser;
+}());
+exports.TxParser = TxParser;

package/lib/parsers/uniV2AdapterParser.d.ts

@@ -0,0 +1,8 @@
+import { SupportedContract } from "../contracts/contracts";
+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

@@ -0,0 +1,73 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniswapV2AdapterParser = void 0;
+var types_1 = require("../types");
+var formatter_1 = require("../utils/formatter");
+var abstractParser_1 = require("./abstractParser");
+var UniswapV2AdapterParser = /** @class */ (function (_super) {
+    __extends(UniswapV2AdapterParser, _super);
+    function UniswapV2AdapterParser(contract, isContract) {
+        var _this = _super.call(this, contract) || this;
+        _this.ifc = types_1.IUniswapV2Adapter__factory.createInterface();
+        if (!isContract)
+            _this.adapterName = "UniswapV2Adapter";
+        return _this;
+    }
+    UniswapV2AdapterParser.prototype.parse = function (calldata) {
+        return this._parse(calldata);
+    };
+    // parseTxInfo(calldata: string): TxInfo {}
+    UniswapV2AdapterParser.prototype._parse = function (calldata) {
+        var _this = this;
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "swapExactTokensForTokens": {
+                var _b = this.decodeFunctionData(functionFragment, calldata), amountIn = _b[0], amountOutMin = _b[1], path = _b[2];
+                var pathStr = path
+                    .map(function (r) { return _this.tokenSymbol(r); })
+                    .join(" => ");
+                var tokenIn = this.tokenSymbol(path[0]);
+                var tokenOut = this.tokenSymbol(path[path.length - 1]);
+                var amountInStr = this.formatBN(amountIn, tokenIn);
+                var amountOutStr = this.formatBN(amountOutMin, tokenOut);
+                return "".concat(functionName, "(amountIn: ").concat(amountInStr, ", amountOutMin: ").concat(amountOutStr, ", path: [").concat(pathStr, "])");
+            }
+            case "swapTokensForExactTokens": {
+                var _c = this.decodeFunctionData(functionFragment, calldata), amountOut = _c[0], amountInMax = _c[1], path = _c[2];
+                var pathStr = path
+                    .map(function (r) { return _this.tokenSymbol(r); })
+                    .join(" => ");
+                var tokenIn = this.tokenSymbol(path[0]);
+                var tokenOut = this.tokenSymbol(path[path.length - 1]);
+                var amountOutStr = this.formatBN(amountOut, tokenIn);
+                var amountInMaxStr = this.formatBN(amountInMax, tokenOut);
+                return "".concat(functionName, "(amountOut: ").concat(amountOutStr, ", amountInMax: ").concat(amountInMaxStr, ", path: [").concat(pathStr, "])");
+            }
+            case "swapAllTokensForTokens": {
+                var _d = this.decodeFunctionData(functionFragment, calldata), rateMinRAY = _d[0], path = _d[1];
+                return "".concat(functionName, "(rate: ").concat((0, formatter_1.formatBN)(rateMinRAY, 27), ", path: [").concat(path
+                    .map(function (r) { return _this.tokenSymbol(r); })
+                    .join(" => "), "])");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return UniswapV2AdapterParser;
+}(abstractParser_1.AbstractParser));
+exports.UniswapV2AdapterParser = UniswapV2AdapterParser;

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

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

package/lib/parsers/uniV2AdapterParser.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var chai_1 = require("chai");
+var ethers_1 = require("ethers");
+var constants_1 = require("../core/constants");
+var token_1 = require("../tokens/token");
+var types_1 = require("../types");
+var uniV2AdapterParser_1 = require("./uniV2AdapterParser");
+describe("UniswapV2AdapterParser test", function () {
+    it("swap functions works well", function () {
+        var parser = new uniV2AdapterParser_1.UniswapV2AdapterParser("UNISWAP_V2_ROUTER", false);
+        var ifc = types_1.IUniswapV2Adapter__factory.createInterface();
+        var parsed = parser.parse(ifc.encodeFunctionData("swapExactTokensForTokens", [
+            constants_1.WAD.mul(180000),
+            ethers_1.BigNumber.from(1e6).mul(45),
+            [
+                token_1.tokenDataByNetwork.Mainnet.DAI,
+                token_1.tokenDataByNetwork.Mainnet.WETH,
+                token_1.tokenDataByNetwork.Mainnet.USDC,
+            ],
+            constants_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", [
+            ethers_1.BigNumber.from(1e6).mul(234500),
+            constants_1.WAD.mul(17700),
+            [
+                token_1.tokenDataByNetwork.Mainnet.USDC,
+                token_1.tokenDataByNetwork.Mainnet.DAI,
+                token_1.tokenDataByNetwork.Mainnet.FRAX,
+            ],
+            constants_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.mul(3240),
+            [
+                token_1.tokenDataByNetwork.Mainnet.USDC,
+                token_1.tokenDataByNetwork.Mainnet.DAI,
+                token_1.tokenDataByNetwork.Mainnet.FRAX,
+            ],
+            45033,
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapAllTokensForTokens(rate: 3.24K, path: [USDC => DAI => FRAX])", "Incorrect parse swapAllTokensForTokens");
+    });
+});

package/lib/parsers/uniV3AdapterParser.d.ts

@@ -0,0 +1,9 @@
+import { SupportedContract } from "../contracts/contracts";
+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

@@ -0,0 +1,99 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniswapV3AdapterParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var UniswapV3AdapterParser = /** @class */ (function (_super) {
+    __extends(UniswapV3AdapterParser, _super);
+    function UniswapV3AdapterParser(contract, isContract) {
+        var _this = _super.call(this, contract) || this;
+        _this.ifc = types_1.IUniswapV3Adapter__factory.createInterface();
+        if (!isContract)
+            _this.adapterName = "UniswapV3Adapter";
+        return _this;
+    }
+    UniswapV3AdapterParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "exactInputSingle": {
+                var _b = this.decodeFunctionData(functionFragment, calldata)[0], tokenIn = _b[0], tokenOut = _b[1], fee = _b[2], amountIn = _b[5], amountOutMinimum = _b[6];
+                var tokenInSym = this.tokenSymbol(tokenIn);
+                var tokenOutSym = this.tokenSymbol(tokenOut);
+                var amountInStr = this.formatBN(amountIn, tokenIn);
+                var amountOutMinimumStr = this.formatBN(amountOutMinimum, tokenOut);
+                return "".concat(functionName, "(amountIn: ").concat(amountInStr, ", amountOutMinimum: ").concat(amountOutMinimumStr, ",  path: ").concat(tokenInSym, " ==(fee: ").concat(fee, ")==> ").concat(tokenOutSym, ")");
+            }
+            case "exactInput": {
+                var _c = this.decodeFunctionData(functionFragment, calldata).params, amountIn = _c.amountIn, amountOutMinimum = _c.amountOutMinimum, path = _c.path;
+                var pathStr = this.trackInputPath(path);
+                var amountInStr = this.formatBN(amountIn, this.tokenSymbol("0x".concat(path.replace("0x", "").slice(0, 40))));
+                var amountOutMinimumStr = this.formatBN(amountOutMinimum, this.tokenSymbol("0x".concat(path.slice(-40, path.length))));
+                return "".concat(functionName, "(amountIn: ").concat(amountInStr, ", amountOutMinimum: ").concat(amountOutMinimumStr, ",  path: ").concat(pathStr);
+            }
+            case "exactOutput": {
+                var _d = this.decodeFunctionData(functionFragment, calldata).params, amountInMaximum = _d.amountInMaximum, amountOut = _d.amountOut, path = _d.path;
+                var pathStr = this.trackOutputPath(path);
+                var amountInMaximumStr = this.formatBN(amountInMaximum, this.tokenSymbol("0x".concat(path.slice(-40, path.length))));
+                var amountOutStr = this.formatBN(amountOut, this.tokenSymbol("0x".concat(path.replace("0x", "").slice(0, 40))));
+                return "".concat(functionName, "(amountInMaximum: ").concat(amountInMaximumStr, ", amountOut: ").concat(amountOutStr, ",  path: ").concat(pathStr);
+            }
+            case "exactOutputSingle": {
+                var _e = this.decodeFunctionData(functionFragment, calldata)[0], tokenIn = _e[0], tokenOut = _e[1], fee = _e[2], amountOut = _e[5], amountInMaximum = _e[6];
+                var tokenInSym = this.tokenSymbol(tokenIn);
+                var tokenOutSym = this.tokenSymbol(tokenOut);
+                var amountInMaximumStr = this.formatBN(amountInMaximum, tokenInSym);
+                var amountOutStr = this.formatBN(amountOut, tokenOutSym);
+                return "".concat(functionName, "(amountInMaximum: ").concat(amountInMaximumStr, ", amountOut: ").concat(amountOutStr, ",  path: ").concat(tokenInSym, " ==(fee: ").concat(fee, ")==> ").concat(tokenOutSym, ")");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    UniswapV3AdapterParser.prototype.trackInputPath = function (path) {
+        var result = "";
+        var pointer = path.startsWith("0x") ? 2 : 0;
+        while (pointer <= path.length - 40) {
+            var from = "0x".concat(path.slice(pointer, pointer + 40)).toLowerCase();
+            result += this.tokenSymbol(from) || from;
+            pointer += 40;
+            if (pointer > path.length - 6)
+                return result;
+            var fee = parseInt(path.slice(pointer, pointer + 6), 16);
+            pointer += 6;
+            result += " ==(fee: ".concat(fee, ")==> ");
+        }
+        return result;
+    };
+    UniswapV3AdapterParser.prototype.trackOutputPath = function (path) {
+        var result = "";
+        var pointer = path.length;
+        while (pointer >= 40) {
+            pointer -= 40;
+            var from = "0x".concat(path.slice(pointer, pointer + 40));
+            result += this.tokenSymbol(from) || from;
+            if (pointer < 6)
+                return result;
+            pointer -= 6;
+            var fee = parseInt(path.slice(pointer, pointer + 6), 16);
+            result += " ==(fee: ".concat(fee, ")==> ");
+        }
+        return result;
+    };
+    return UniswapV3AdapterParser;
+}(abstractParser_1.AbstractParser));
+exports.UniswapV3AdapterParser = UniswapV3AdapterParser;

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

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

package/lib/parsers/uniV3AdapterParser.spec.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var solidity_1 = require("@ethersproject/solidity");
+var chai_1 = require("chai");
+var ethers_1 = require("ethers");
+var constants_1 = require("../core/constants");
+var token_1 = require("../tokens/token");
+var types_1 = require("../types");
+var uniV3AdapterParser_1 = require("./uniV3AdapterParser");
+var pathToUniV3Path = function (path) {
+    var pathWithFees = [];
+    var types = [];
+    path.forEach(function (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", function () {
+    it("swap functions works well", function () {
+        var parser = new uniV3AdapterParser_1.UniswapV3AdapterParser("UNISWAP_V3_ROUTER", false);
+        var ifc = types_1.IUniswapV3Adapter__factory.createInterface();
+        var parsed = parser.parse(ifc.encodeFunctionData("exactInputSingle", [
+            {
+                tokenIn: token_1.tokenDataByNetwork.Goerli["1INCH"],
+                tokenOut: token_1.tokenDataByNetwork.Goerli["3Crv"],
+                fee: 3000,
+                recipient: constants_1.DUMB_ADDRESS,
+                deadline: 12300,
+                amountIn: constants_1.WAD.mul(1299000),
+                amountOutMinimum: constants_1.WAD.mul(10200),
+                sqrtPriceLimitX96: 0,
+            },
+        ]));
+        (0, chai_1.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("exactInput", [
+            {
+                path: pathToUniV3Path([
+                    token_1.tokenDataByNetwork.Mainnet.AAVE,
+                    token_1.tokenDataByNetwork.Mainnet.LINK,
+                    token_1.tokenDataByNetwork.Mainnet.USDC,
+                ]),
+                recipient: constants_1.DUMB_ADDRESS,
+                deadline: 1232131,
+                amountIn: constants_1.WAD.mul(12399),
+                amountOutMinimum: ethers_1.BigNumber.from(1e6).mul(122),
+            },
+        ]));
+        (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("exactOutputSingle", [
+            {
+                tokenIn: token_1.tokenDataByNetwork.Goerli["1INCH"],
+                tokenOut: token_1.tokenDataByNetwork.Goerli.USDC,
+                fee: 10000,
+                recipient: constants_1.DUMB_ADDRESS,
+                deadline: 12300,
+                amountInMaximum: constants_1.WAD.mul(149).div(1000),
+                amountOut: 102e6,
+                sqrtPriceLimitX96: 0,
+            },
+        ]));
+        (0, chai_1.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([
+                    token_1.tokenDataByNetwork.Mainnet.AAVE,
+                    token_1.tokenDataByNetwork.Mainnet.LINK,
+                    token_1.tokenDataByNetwork.Mainnet.USDC,
+                ]),
+                recipient: constants_1.DUMB_ADDRESS,
+                deadline: 1232131,
+                amountInMaximum: 123e6,
+                amountOut: constants_1.WAD.mul(122),
+            },
+        ]));
+        (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/yearnAdapterParser.spec.d.ts

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

package/lib/parsers/yearnAdapterParser.spec.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var chai_1 = require("chai");
+var constants_1 = require("../core/constants");
+var yearn_1 = require("../types/factories/contracts/interfaces/adapters/yearn");
+var yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
+describe("YearnV2AdapterParser test", function () {
+    it("deposit / withdraw functions works well", function () {
+        var parser = new yearnV2AdapterParser_1.YearnV2AdapterParser("YEARN_CURVE_STETH_VAULT", false);
+        var ifc = yearn_1.IYearnV2Adapter__factory.createInterface();
+        var 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.mul(19000)]));
+        (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.mul(19000),
+            constants_1.DUMB_ADDRESS,
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000], address: ".concat(constants_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.mul(19000)]));
+        (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.mul(19000),
+            constants_1.DUMB_ADDRESS,
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ".concat(constants_1.DUMB_ADDRESS, ")"), "Incorrect parse withdraw(amount,address)");
+        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256,address,uint256)", [
+            constants_1.WAD.mul(19000),
+            constants_1.DUMB_ADDRESS,
+            555,
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ".concat(constants_1.DUMB_ADDRESS, ", maxLoss: 555)"), "Incorrect parse withdraw(amount,address,uint256)");
+    });
+});

package/lib/parsers/yearnV2AdapterParser.d.ts

@@ -0,0 +1,7 @@
+import { SupportedContract } from "../contracts/contracts";
+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;
+}

package/lib/parsers/yearnV2AdapterParser.js

@@ -0,0 +1,54 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YearnV2AdapterParser = void 0;
+var contracts_1 = require("../contracts/contracts");
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var YearnV2AdapterParser = /** @class */ (function (_super) {
+    __extends(YearnV2AdapterParser, _super);
+    function YearnV2AdapterParser(contract, isContract) {
+        var _this = _super.call(this, contract) || this;
+        _this.ifc = types_1.IYVault__factory.createInterface();
+        if (!isContract)
+            _this.adapterName = "YearnV2Adapter";
+        return _this;
+    }
+    YearnV2AdapterParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "deposit":
+            case "withdraw":
+            case "deposit(uint256)":
+            case "withdraw(uint256)":
+            case "withdraw(uint256,address,uint256)": {
+                var _b = this.decodeFunctionData(functionFragment, calldata), amount = _b[0], address = _b[1], maxLoss = _b[2];
+                var yvSym = this.tokenSymbol(contracts_1.contractsByNetwork.Mainnet[this.contract]);
+                var amountStr = amount
+                    ? "amount: ".concat(this.formatBN(amount, yvSym))
+                    : "";
+                var addressStr = address ? ", address: ".concat(address) : "";
+                var maxLossStr = maxLoss ? ", maxLoss: ".concat(maxLoss) : "";
+                return "".concat(functionName, "(").concat(amountStr).concat(addressStr).concat(maxLossStr, ")");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return YearnV2AdapterParser;
+}(abstractParser_1.AbstractParser));
+exports.YearnV2AdapterParser = YearnV2AdapterParser;