@gearbox-protocol/sdk 1.19.4 → 1.20.0

package/lib/apy/convexAPY.js

@@ -151,6 +151,6 @@ function calculateConvexAPY(_a) {
         return extraAPY;
     });
     var extraAPYTotal = extraAPRs.reduce(function (acc, apy) { return acc.add(apy); }, ethers_1.BigNumber.from(0));
-    var baseApyWAD = curveAPY[underlying];
+    var baseApyWAD = curveAPY[underlying].base;
     return baseApyWAD.add(crvAPY).add(cvxAPY).add(extraAPYTotal);
 }

package/lib/apy/curveAPY.d.ts

@@ -1,11 +1,12 @@
 import { BigNumber } from "ethers";
 import { CurveLPToken } from "../tokens/curveLP";
-declare type CurveAPYTokens = CurveLPToken;
-export declare type CurveAPYResult = Record<CurveAPYTokens, BigNumber>;
-export declare function getCurveAPY(): Promise<[CurveAPYResult, GEARCurveAPY]>;
-interface GEARCurveAPY {
+import { GearboxToken } from "../tokens/gear";
+declare type CurveAPYTokens = CurveLPToken | GearboxToken;
+interface CurveAPY {
     base: BigNumber;
     crv: BigNumber;
-    gear: BigNumber;
+    gauge: Array<[string, BigNumber]>;
 }
+export declare type CurveAPYResult = Record<CurveAPYTokens, CurveAPY>;
+export declare function getCurveAPY(): Promise<CurveAPYResult>;
 export {};

package/lib/apy/curveAPY.js

@@ -35,6 +35,15 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -52,57 +61,77 @@ var APY_DICTIONARY = {
     LUSD3CRV: "33",
     crvPlain3andSUSD: "15",
     steCRV: "14",
-    crvFRAX: "44", // 0xDcEF968d416a41Cdac0ED8702fAC8128A64241A2
+    crvFRAX: "44",
+    GEAR: "factory-crypto-192", // 0x0e9b5b092cad6f1c5e6bc7f89ffe1abb5c95f1c2
 };
 var CRV_APY_RESPONSE_DECIMALS = 100;
-var ZERO = ethers_1.BigNumber.from(0);
-// const MAIN = "https://api.curve.fi/api/getPools/ethereum/main";
+var ZERO = {
+    base: ethers_1.BigNumber.from(0),
+    crv: ethers_1.BigNumber.from(0),
+    gauge: [],
+};
 // const CRYPTO = "https://api.curve.fi/api/getPools/ethereum/crypto";
 // const FACTORY = "https://api.curve.fi/api/getPools/ethereum/factory";
 var CURVE_FACTORY_CRYPTO_URL = "https://api.curve.fi/api/getPools/ethereum/factory-crypto";
+var CURVE_MAIN_URL = "https://api.curve.fi/api/getPools/ethereum/main";
 var CURVE_APY_URL = "https://www.convexfinance.com/api/curve-apys";
 function getCurveAPY() {
     return __awaiter(this, void 0, void 0, function () {
-        var _a, apyData, poolDataResp, apys_1, curveAPY, gearAPY, e_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
+        var _a, apyData, factoryCrypto, main, apys_1, _b, factoryCryptoPoolData, _c, mainPoolData, poolDataByID_1, curveAPY, e_1;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
-                    _b.trys.push([0, 3, , 4]);
+                    _d.trys.push([0, 2, , 3]);
                     return [4 /*yield*/, Promise.all([
                             axios_1.default.get(CURVE_APY_URL),
                             axios_1.default.get(CURVE_FACTORY_CRYPTO_URL),
+                            axios_1.default.get(CURVE_MAIN_URL),
                         ])];
                 case 1:
-                    _a = _b.sent(), apyData = _a[0].data, poolDataResp = _a[1].data;
+                    _a = _d.sent(), apyData = _a[0].data, factoryCrypto = _a[1].data, main = _a[2].data;
                     apys_1 = (apyData || {}).apys;
+                    _b = ((factoryCrypto === null || factoryCrypto === void 0 ? void 0 : factoryCrypto.data) || {}).poolData, factoryCryptoPoolData = _b === void 0 ? [] : _b;
+                    _c = ((main === null || main === void 0 ? void 0 : main.data) || {}).poolData, mainPoolData = _c === void 0 ? [] : _c;
+                    poolDataByID_1 = Object.fromEntries(__spreadArray(__spreadArray([], factoryCryptoPoolData.map(function (p) { return [p.id, p]; }), true), mainPoolData.map(function (p) { return [p.id, p]; }), true));
                     curveAPY = (0, mappers_1.objectEntries)(APY_DICTIONARY).reduce(function (acc, _a) {
                         var curveSymbol = _a[0], poolId = _a[1];
-                        var baseApy = (apys_1[poolId] || {}).baseApy;
+                        var _b = apys_1[poolId] || {}, baseApy = _b.baseApy, crvApy = _b.crvApy;
                         if (baseApy === undefined)
                             console.warn("No base apy for: ".concat(curveSymbol, ", ").concat(poolId));
-                        acc[curveSymbol] = curveAPYToBn(baseApy || 0);
+                        var pool = poolDataByID_1[poolId];
+                        var _c = (pool || {}).gaugeRewards, gaugeRewards = _c === void 0 ? [] : _c;
+                        if (pool === undefined)
+                            console.warn("No pool data for: ".concat(curveSymbol, ", ").concat(poolId));
+                        var extraRewards = gaugeRewards.map(function (_a) {
+                            var _b = _a.apy, apy = _b === void 0 ? 0 : _b, symbol = _a.symbol;
+                            return [
+                                symbol.toLowerCase(),
+                                curveAPYToBn(apy),
+                            ];
+                        });
+                        var maxCrv = (pool === null || pool === void 0 ? void 0 : pool.gaugeCrvApy.length) > 0 ? Math.max.apply(Math, pool.gaugeCrvApy) : crvApy;
+                        acc[curveSymbol] = {
+                            base: curveAPYToBn(baseApy || 0),
+                            crv: curveAPYToBn(maxCrv || 0),
+                            gauge: extraRewards,
+                        };
                         return acc;
                     }, {});
-                    return [4 /*yield*/, getGEARCurveAPY(apys_1, poolDataResp)];
+                    return [2 /*return*/, curveAPY];
                 case 2:
-                    gearAPY = _b.sent();
-                    return [2 /*return*/, [curveAPY, gearAPY]];
-                case 3:
-                    e_1 = _b.sent();
+                    e_1 = _d.sent();
                     console.error(e_1);
-                    return [2 /*return*/, [
-                            {
-                                "3Crv": ZERO,
-                                crvFRAX: ZERO,
-                                FRAX3CRV: ZERO,
-                                gusd3CRV: ZERO,
-                                LUSD3CRV: ZERO,
-                                crvPlain3andSUSD: ZERO,
-                                steCRV: ZERO,
-                            },
-                            { base: ZERO, crv: ZERO, gear: ZERO },
-                        ]];
-                case 4: return [2 /*return*/];
+                    return [2 /*return*/, {
+                            "3Crv": ZERO,
+                            crvFRAX: ZERO,
+                            FRAX3CRV: ZERO,
+                            gusd3CRV: ZERO,
+                            LUSD3CRV: ZERO,
+                            crvPlain3andSUSD: ZERO,
+                            steCRV: ZERO,
+                            GEAR: ZERO,
+                        }];
+                case 3: return [2 /*return*/];
             }
         });
     });
@@ -111,30 +140,3 @@ exports.getCurveAPY = getCurveAPY;
 function curveAPYToBn(baseApy) {
     return (0, formatter_1.toBN)((baseApy / CRV_APY_RESPONSE_DECIMALS).toString(), constants_1.WAD_DECIMALS_POW);
 }
-var POOL_DICTIONARY = {
-    GEAR: "factory-crypto-192", // 0x0e9b5b092cad6f1c5e6bc7f89ffe1abb5c95f1c2
-};
-function getGEARCurveAPY(apys, poolDataResp) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, poolData, gearPool, _b, gaugeRewards, gearGauge, _c, gearApy, _d, baseApy, crvApy, base, crv, gear;
-        return __generator(this, function (_e) {
-            _a = ((poolDataResp === null || poolDataResp === void 0 ? void 0 : poolDataResp.data) || {}).poolData, poolData = _a === void 0 ? [] : _a;
-            gearPool = poolData.find(function (p) { return p.id === POOL_DICTIONARY.GEAR; });
-            if (gearPool === undefined)
-                console.warn("No GEAR pool found");
-            _b = (gearPool || {}).gaugeRewards, gaugeRewards = _b === void 0 ? [] : _b;
-            console.log("GEAR POOL", gaugeRewards);
-            gearGauge = gaugeRewards.find(function (g) { return g.symbol.toLowerCase() === "gear"; });
-            if (gearGauge === undefined)
-                console.warn("No GEAR gauge found");
-            _c = (gearGauge || {}).apy, gearApy = _c === void 0 ? 0 : _c;
-            _d = apys[POOL_DICTIONARY.GEAR] || {}, baseApy = _d.baseApy, crvApy = _d.crvApy;
-            if (baseApy === undefined)
-                console.warn("No base apy for: GEAR, ".concat(POOL_DICTIONARY.GEAR));
-            base = curveAPYToBn(baseApy || 0);
-            crv = curveAPYToBn(crvApy || 0);
-            gear = curveAPYToBn(gearApy || 0);
-            return [2 /*return*/, { base: base, crv: crv, gear: gear }];
-        });
-    });
-}

package/lib/core/creditManager.js

@@ -77,7 +77,8 @@ var CreditManagerData = /** @class */ (function () {
         this.liquidationDiscount = payload.liquidationDiscount;
         this.feeLiquidationExpired = payload.feeLiquidationExpired;
         this.liquidationDiscountExpired = payload.liquidationDiscountExpired;
-        if (this.creditFacade !== "") {
+        txParser_1.TxParser.addCreditManager(this.address, this.version);
+        if (this.creditFacade !== "" && this.creditFacade !== constants_1.ADDRESS_0X0) {
             txParser_1.TxParser.addCreditFacade(this.creditFacade, token_1.tokenSymbolByAddress[this.underlyingToken]);
             txParser_1.TxParser.addAdapters(payload.adapters.map(function (a) { return ({
                 adapter: a.adapter,

package/lib/parsers/ERC20Parser.d.ts

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

package/lib/parsers/ERC20Parser.js

@@ -0,0 +1,53 @@
+"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.ERC20Parser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var ERC20Parser = /** @class */ (function (_super) {
+    __extends(ERC20Parser, _super);
+    function ERC20Parser(symbol) {
+        var _this = _super.call(this, symbol) || this;
+        _this.adapterName = "Token";
+        _this.ifc = types_1.IERC20__factory.createInterface();
+        return _this;
+    }
+    ERC20Parser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "totalSupply": {
+                return "".concat(functionName);
+            }
+            case "balanceOf": {
+                var address = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(").concat(address, ")");
+            }
+            case "allowance": {
+                var _b = this.decodeFunctionData(functionFragment, calldata), account = _b[0], to = _b[1];
+                return "".concat(functionName, "(account: ").concat(account, ", to: ").concat(to, ")");
+            }
+            case "approve": {
+                var spender = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(").concat(spender, ")");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return ERC20Parser;
+}(abstractParser_1.AbstractParser));
+exports.ERC20Parser = ERC20Parser;

package/lib/parsers/abstractParser.d.ts

@@ -14,5 +14,10 @@ export declare class AbstractParser {
     decodeFunctionData(functionFragment: FunctionFragment | string, data: BytesLike): Result;
     tokenSymbol(address: string): SupportedToken;
     formatBN(amount: BigNumberish, token: SupportedToken): string;
+    parseToObject(address: string, calldata: string): {
+        address: string;
+        functionFragment: FunctionFragment;
+        args: Result;
+    };
 }
 export {};

package/lib/parsers/abstractParser.js

@@ -27,6 +27,15 @@ var AbstractParser = /** @class */ (function () {
     AbstractParser.prototype.formatBN = function (amount, token) {
         return "".concat((0, formatter_1.formatBN)(amount, decimals_1.decimals[token]), " [").concat(ethers_1.BigNumber.from(amount).toString(), "]");
     };
+    AbstractParser.prototype.parseToObject = function (address, calldata) {
+        var functionFragment = this.parseSelector(calldata).functionFragment;
+        var args = this.decodeFunctionData(functionFragment, calldata);
+        return {
+            address: address,
+            functionFragment: functionFragment,
+            args: args,
+        };
+    };
     return AbstractParser;
 }());
 exports.AbstractParser = AbstractParser;

package/lib/parsers/addressProviderParser.d.ts

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

package/lib/parsers/addressProviderParser.js

@@ -0,0 +1,45 @@
+"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.AddressProviderParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var AddressProviderParser = /** @class */ (function (_super) {
+    __extends(AddressProviderParser, _super);
+    function AddressProviderParser() {
+        var _this = _super.call(this, "AddressProvider") || this;
+        _this.ifc = types_1.IAddressProvider__factory.createInterface();
+        return _this;
+    }
+    AddressProviderParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "getWethToken":
+            case "getGearToken":
+            case "getLeveragedActions":
+            case "getDataCompressor":
+            case "getWETHGateway":
+            case "getPriceOracle": {
+                return "".concat(functionName);
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return AddressProviderParser;
+}(abstractParser_1.AbstractParser));
+exports.AddressProviderParser = AddressProviderParser;

package/lib/parsers/airdropDistributorParser.d.ts

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

package/lib/parsers/airdropDistributorParser.js

@@ -0,0 +1,40 @@
+"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.AirdropDistributorParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var AirdropDistributorParser = /** @class */ (function (_super) {
+    __extends(AirdropDistributorParser, _super);
+    function AirdropDistributorParser() {
+        var _this = _super.call(this, "AirdropDistributor") || this;
+        _this.ifc = types_1.IAirdropDistributor__factory.createInterface();
+        return _this;
+    }
+    AirdropDistributorParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "merkleRoot": {
+                return "".concat(functionName);
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return AirdropDistributorParser;
+}(abstractParser_1.AbstractParser));
+exports.AirdropDistributorParser = AirdropDistributorParser;

package/lib/parsers/convexBaseRewardPoolAdapterParser.js

@@ -47,6 +47,10 @@ var ConvexBaseRewardPoolAdapterParser = /** @class */ (function (_super) {
                 var claim = this.decodeFunctionData(functionFragment, calldata)[0];
                 return "".concat(functionName, "(claim: ").concat(claim, ")");
             }
+            case "rewardRate":
+                return "".concat(functionName);
+            case "totalSupply":
+                return "".concat(functionName);
             default:
                 return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
         }

package/lib/parsers/convextRewardPoolParser.d.ts

@@ -0,0 +1,7 @@
+import { NormalToken } from "../tokens/normal";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class ConvexRewardPoolParser extends AbstractParser implements IParser {
+    constructor(token: NormalToken);
+    parse(calldata: string): string;
+}

package/lib/parsers/convextRewardPoolParser.js

@@ -0,0 +1,39 @@
+"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.ConvexRewardPoolParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var ConvexRewardPoolParser = /** @class */ (function (_super) {
+    __extends(ConvexRewardPoolParser, _super);
+    function ConvexRewardPoolParser(token) {
+        var _this = _super.call(this, "ConvexRewardPool_".concat(token)) || this;
+        _this.ifc = types_1.IBaseRewardPool__factory.createInterface();
+        return _this;
+    }
+    ConvexRewardPoolParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "rewardRate":
+                return "".concat(functionName);
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return ConvexRewardPoolParser;
+}(abstractParser_1.AbstractParser));
+exports.ConvexRewardPoolParser = ConvexRewardPoolParser;

package/lib/parsers/creditManagerParser.d.ts

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

package/lib/parsers/creditManagerParser.js

@@ -0,0 +1,43 @@
+"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.CreditManagerParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var CreditManagerParser = /** @class */ (function (_super) {
+    __extends(CreditManagerParser, _super);
+    function CreditManagerParser(version) {
+        var _this = _super.call(this, "CreditManager_V".concat(version)) || this;
+        _this.ifc =
+            version === 1
+                ? types_1.ICreditManager__factory.createInterface()
+                : types_1.ICreditManagerV2__factory.createInterface();
+        return _this;
+    }
+    CreditManagerParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "creditConfigurator": {
+                return "".concat(functionName);
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return CreditManagerParser;
+}(abstractParser_1.AbstractParser));
+exports.CreditManagerParser = CreditManagerParser;

package/lib/parsers/curveAdapterParser.js

@@ -94,6 +94,24 @@ var CurveAdapterParser = /** @class */ (function (_super) {
                 var _h = this.decodeFunctionData(functionFragment, calldata), amounts = _h[0], maxBurnAmount = _h[1];
                 return "".concat(functionName, "(amounts: [").concat(this.convertAmounts(amounts), "], max_burn_amount: ").concat(this.formatBN(maxBurnAmount, this.lpToken), ")");
             }
+            case "totalSupply": {
+                return "".concat(functionName);
+            }
+            case "balances": {
+                var i = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(").concat(this.getTokenByIndex(i), ")");
+            }
+            case "balanceOf": {
+                var address = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(").concat(address, ")");
+            }
+            case "get_virtual_price": {
+                return "".concat(functionName);
+            }
+            case "allowance": {
+                var _j = this.decodeFunctionData(functionFragment, calldata), account = _j[0], to = _j[1];
+                return "".concat(functionName, "(account: ").concat(account, ", to: ").concat(to, ")");
+            }
             default:
                 return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
         }

package/lib/parsers/dataCompressorParser.d.ts

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

package/lib/parsers/dataCompressorParser.js

@@ -0,0 +1,41 @@
+"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.DataCompressorParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var DataCompressorParser = /** @class */ (function (_super) {
+    __extends(DataCompressorParser, _super);
+    function DataCompressorParser() {
+        var _this = _super.call(this, "DataCompressor") || this;
+        _this.ifc = types_1.IDataCompressor__factory.createInterface();
+        return _this;
+    }
+    DataCompressorParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "getPoolsList":
+            case "getCreditManagersList": {
+                return "".concat(functionName);
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return DataCompressorParser;
+}(abstractParser_1.AbstractParser));
+exports.DataCompressorParser = DataCompressorParser;

package/lib/parsers/iParser.d.ts

@@ -1,3 +1,9 @@
+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/lidoOracleParser.d.ts

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

package/lib/parsers/lidoOracleParser.js

@@ -0,0 +1,39 @@
+"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.LidoOracleParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var LidoOracleParser = /** @class */ (function (_super) {
+    __extends(LidoOracleParser, _super);
+    function LidoOracleParser() {
+        var _this = _super.call(this, "LidoOracle") || this;
+        _this.ifc = types_1.ILidoOracle__factory.createInterface();
+        return _this;
+    }
+    LidoOracleParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "getLastCompletedReportDelta":
+                return "".concat(functionName);
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return LidoOracleParser;
+}(abstractParser_1.AbstractParser));
+exports.LidoOracleParser = LidoOracleParser;

package/lib/parsers/lidoSTETHParser.d.ts

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

@@ -0,0 +1,50 @@
+"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.LidoSTETHParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var LidoSTETHParser = /** @class */ (function (_super) {
+    __extends(LidoSTETHParser, _super);
+    function LidoSTETHParser(symbol) {
+        var _this = _super.call(this, symbol) || this;
+        _this.ifc = types_1.IstETH__factory.createInterface();
+        _this.adapterName = "TokenLido";
+        return _this;
+    }
+    LidoSTETHParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "getFee":
+            case "totalSupply": {
+                return "".concat(functionName);
+            }
+            case "balanceOf": {
+                var address = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(").concat(address, ")");
+            }
+            case "allowance": {
+                var _b = this.decodeFunctionData(functionFragment, calldata), account = _b[0], to = _b[1];
+                return "".concat(functionName, "(account: ").concat(account, ", to: ").concat(to, ")");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return LidoSTETHParser;
+}(abstractParser_1.AbstractParser));
+exports.LidoSTETHParser = LidoSTETHParser;

package/lib/parsers/multicallParser.d.ts

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

package/lib/parsers/multicallParser.js

@@ -0,0 +1,48 @@
+"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.MulticallParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var MulticallParser = /** @class */ (function (_super) {
+    __extends(MulticallParser, _super);
+    function MulticallParser() {
+        var _this = _super.call(this, "Multicall") || this;
+        _this.ifc = types_1.Multicall2__factory.createInterface();
+        return _this;
+    }
+    MulticallParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "aggregate": {
+                var calls = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, ": ").concat(calls);
+            }
+            case "getBlockNumber": {
+                return "".concat(functionName);
+            }
+            case "getEthBalance": {
+                var account = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(").concat(account, ")");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return MulticallParser;
+}(abstractParser_1.AbstractParser));
+exports.MulticallParser = MulticallParser;

package/lib/parsers/offchainOracleParser.d.ts

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

package/lib/parsers/offchainOracleParser.js

@@ -0,0 +1,41 @@
+"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.OffchainOracleParserParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var OffchainOracleParserParser = /** @class */ (function (_super) {
+    __extends(OffchainOracleParserParser, _super);
+    function OffchainOracleParserParser() {
+        var _this = _super.call(this, "OffchainOracleParser") || this;
+        _this.ifc = types_1.IOffchainOracle__factory.createInterface();
+        return _this;
+    }
+    OffchainOracleParserParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "getRate": {
+                var _b = this.decodeFunctionData(functionFragment, calldata), srcToken = _b[0], dstToken = _b[1], useWrappers = _b[2];
+                return "".concat(functionName, "(token: ").concat(this.tokenSymbol(srcToken), ", measured in: ").concat(this.tokenSymbol(dstToken), ", use wrappers: ").concat(useWrappers, ")");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return OffchainOracleParserParser;
+}(abstractParser_1.AbstractParser));
+exports.OffchainOracleParserParser = OffchainOracleParserParser;

package/lib/parsers/priceOracleParser.d.ts

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,41 @@
+"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.PriceOracleParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var PriceOracleParser = /** @class */ (function (_super) {
+    __extends(PriceOracleParser, _super);
+    function PriceOracleParser() {
+        var _this = _super.call(this, "PriceOracle") || this;
+        _this.ifc = types_1.IPriceOracleV2__factory.createInterface();
+        return _this;
+    }
+    PriceOracleParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "getPrice": {
+                var token = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(").concat(this.tokenSymbol(token), ")");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    return PriceOracleParser;
+}(abstractParser_1.AbstractParser));
+exports.PriceOracleParser = PriceOracleParser;

package/lib/parsers/txParser.d.ts

@@ -15,12 +15,31 @@ interface ParseData {
 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("@ethersproject/abi").FunctionFragment;
+        args: any;
+    };
     static getParseData(address: string): ParseData;
     static parseMultiCall(calls: Array<MultiCallStruct>): Array<string>;
+    static parseToObjectMultiCall(calls: Array<MultiCallStruct>): {
+        address: string;
+        functionFragment: import("@ethersproject/abi").FunctionFragment;
+        args: any;
+    }[];
     static addAdapters(adapters: Array<AdapterForParser>): void;
     static addContracts(network: NetworkType): void;
     static addCreditFacade(creditFacade: string, underlying: SupportedToken): void;
+    static addTokens(network: NetworkType): void;
+    static addOffchainOracleParser(address: string): void;
+    static addPriceOracle(address: string): void;
+    static addDataCompressor(address: string): void;
+    static addAddressProvider(address: string): void;
+    static addMulticall(address: string): void;
+    static addAirdropDistributor(address: string): void;
+    static addCreditManager(address: string, version: number): void;
     static getParser(address: string): IParser & AbstractParser;
-    protected static addParser(address: string, contract: SupportedContract, adapterType: number, isContract: boolean): void;
+    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

@@ -3,11 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxParser = void 0;
 var adapters_1 = require("../contracts/adapters");
 var contracts_1 = require("../contracts/contracts");
+var token_1 = require("../tokens/token");
+var mappers_1 = require("../utils/mappers");
+var addressProviderParser_1 = require("./addressProviderParser");
+var airdropDistributorParser_1 = require("./airdropDistributorParser");
 var convexBaseRewardPoolAdapterParser_1 = require("./convexBaseRewardPoolAdapterParser");
 var convexBoosterAdapterParser_1 = require("./convexBoosterAdapterParser");
+var convextRewardPoolParser_1 = require("./convextRewardPoolParser");
 var creditFacadeParser_1 = require("./creditFacadeParser");
+var creditManagerParser_1 = require("./creditManagerParser");
 var curveAdapterParser_1 = require("./curveAdapterParser");
+var dataCompressorParser_1 = require("./dataCompressorParser");
+var ERC20Parser_1 = require("./ERC20Parser");
 var lidoAdapterParser_1 = require("./lidoAdapterParser");
+var lidoOracleParser_1 = require("./lidoOracleParser");
+var lidoSTETHParser_1 = require("./lidoSTETHParser");
+var multicallParser_1 = require("./multicallParser");
+var offchainOracleParser_1 = require("./offchainOracleParser");
+var priceOracleParser_1 = require("./priceOracleParser");
 var uniV2AdapterParser_1 = require("./uniV2AdapterParser");
 var uniV3AdapterParser_1 = require("./uniV3AdapterParser");
 var wstETHAdapterParser_1 = require("./wstETHAdapterParser");
@@ -16,11 +29,16 @@ var TxParser = /** @class */ (function () {
     function TxParser() {
     }
     TxParser.parse = function (address, calldata) {
-        var parser = this.getParser(address);
+        var parser = TxParser.getParser(address);
         return parser.parse(calldata);
     };
+    TxParser.parseToObject = function (address, calldata) {
+        var _a;
+        var parser = TxParser.getParser(address);
+        return (_a = parser.parseToObject) === null || _a === void 0 ? void 0 : _a.call(parser, address, calldata);
+    };
     TxParser.getParseData = function (address) {
-        var parser = this.getParser(address);
+        var parser = TxParser.getParser(address);
         return { contract: parser.contract, adapterName: parser.adapterName };
     };
     TxParser.parseMultiCall = function (calls) {
@@ -28,12 +46,17 @@ var TxParser = /** @class */ (function () {
             return TxParser.parse(call.target, call.callData.toString());
         });
     };
+    TxParser.parseToObjectMultiCall = function (calls) {
+        return calls.map(function (call) {
+            return TxParser.parseToObject(call.target, call.callData.toString());
+        });
+    };
     TxParser.addAdapters = function (adapters) {
         for (var _i = 0, adapters_2 = adapters; _i < adapters_2.length; _i++) {
             var a = adapters_2[_i];
             var contract = contracts_1.contractsByAddress[a.contract.toLowerCase()];
             if (contract && contracts_1.contractParams[contract]) {
-                TxParser.addParser(a.adapter, contract, contracts_1.contractParams[contract].type, false);
+                TxParser.chooseContractParser(a.adapter, contract, contracts_1.contractParams[contract].type, false);
             }
             else {
                 console.error("Unknown address: ".concat(contract, " at ").concat(a.contract));
@@ -41,29 +64,77 @@ var TxParser = /** @class */ (function () {
         }
     };
     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);
-        }
+        (0, mappers_1.objectEntries)(contracts_1.contractParams).forEach(function (_a) {
+            var contract = _a[0], contractData = _a[1];
+            var address = contracts_1.contractsByNetwork[network][contract];
+            TxParser.chooseContractParser(address, contract, contractData.type, true);
+            if (contractData.type === adapters_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL) {
+                contractData.extraRewards.forEach(function (r) {
+                    var extraAddress = r.poolAddress[network];
+                    TxParser._addParser(extraAddress, new convextRewardPoolParser_1.ConvexRewardPoolParser(r.rewardToken));
+                });
+            }
+            if (contractData.type === adapters_1.AdapterInterface.LIDO_V1) {
+                var extraAddress = contractData.oracle[network];
+                TxParser._addParser(extraAddress, new lidoOracleParser_1.LidoOracleParser());
+            }
+        });
     };
     TxParser.addCreditFacade = function (creditFacade, underlying) {
-        this.parsers[creditFacade.toLowerCase()] = new creditFacadeParser_1.CreditFacadeParser(underlying);
+        TxParser._addParser(creditFacade, new creditFacadeParser_1.CreditFacadeParser(underlying));
+    };
+    TxParser.addTokens = function (network) {
+        (0, mappers_1.objectEntries)(token_1.tokenDataByNetwork[network]).forEach(function (_a) {
+            var s = _a[0], t = _a[1];
+            if (s === "STETH") {
+                TxParser._addParser(t, new lidoSTETHParser_1.LidoSTETHParser(s));
+            }
+            else {
+                var contract = contracts_1.contractsByAddress[t.toLowerCase()];
+                if (contract) {
+                    TxParser.chooseContractParser(t, contract, contracts_1.contractParams[contract].type, true);
+                }
+                else {
+                    TxParser._addParser(t, new ERC20Parser_1.ERC20Parser(s));
+                }
+            }
+        });
+    };
+    TxParser.addOffchainOracleParser = function (address) {
+        TxParser._addParser(address, new offchainOracleParser_1.OffchainOracleParserParser());
+    };
+    TxParser.addPriceOracle = function (address) {
+        TxParser._addParser(address, new priceOracleParser_1.PriceOracleParser());
+    };
+    TxParser.addDataCompressor = function (address) {
+        TxParser._addParser(address, new dataCompressorParser_1.DataCompressorParser());
+    };
+    TxParser.addAddressProvider = function (address) {
+        TxParser._addParser(address, new addressProviderParser_1.AddressProviderParser());
+    };
+    TxParser.addMulticall = function (address) {
+        TxParser._addParser(address, new multicallParser_1.MulticallParser());
+    };
+    TxParser.addAirdropDistributor = function (address) {
+        TxParser._addParser(address, new airdropDistributorParser_1.AirdropDistributorParser());
+    };
+    TxParser.addCreditManager = function (address, version) {
+        TxParser._addParser(address, new creditManagerParser_1.CreditManagerParser(version));
     };
     TxParser.getParser = function (address) {
-        var parser = this.parsers[address.toLowerCase()];
+        var parser = TxParser.parsers[address.toLowerCase()];
         if (!parser)
             throw new Error("Can find parser for ".concat(address));
         return parser;
     };
-    TxParser.addParser = function (address, contract, adapterType, isContract) {
+    TxParser.chooseContractParser = function (address, contract, adapterType, isContract) {
         var addressLC = address.toLowerCase();
         switch (adapters_1.AdapterInterface[adapterType]) {
             case "UNISWAP_V2_ROUTER":
-                TxParser.parsers[addressLC] = new uniV2AdapterParser_1.UniswapV2AdapterParser(contract, isContract);
+                TxParser._addParser(addressLC, new uniV2AdapterParser_1.UniswapV2AdapterParser(contract, isContract));
                 break;
             case "UNISWAP_V3_ROUTER":
-                TxParser.parsers[addressLC] = new uniV3AdapterParser_1.UniswapV3AdapterParser(contract, isContract);
+                TxParser._addParser(addressLC, new uniV3AdapterParser_1.UniswapV3AdapterParser(contract, isContract));
                 break;
             case "CURVE_V1_EXCHANGE_ONLY":
             case "CURVE_V1_2ASSETS":
@@ -71,27 +142,30 @@ var TxParser = /** @class */ (function () {
             case "CURVE_V1_4ASSETS":
             case "CURVE_V1_STECRV_POOL":
             case "CURVE_V1_WRAPPER":
-                TxParser.parsers[addressLC] = new curveAdapterParser_1.CurveAdapterParser(contract, isContract);
+                TxParser._addParser(addressLC, new curveAdapterParser_1.CurveAdapterParser(contract, isContract));
                 break;
             case "YEARN_V2":
-                TxParser.parsers[addressLC] = new yearnV2AdapterParser_1.YearnV2AdapterParser(contract, isContract);
+                TxParser._addParser(addressLC, new yearnV2AdapterParser_1.YearnV2AdapterParser(contract, isContract));
                 break;
             case "CONVEX_V1_BASE_REWARD_POOL":
-                TxParser.parsers[addressLC] = new convexBaseRewardPoolAdapterParser_1.ConvexBaseRewardPoolAdapterParser(contract, isContract);
+                TxParser._addParser(addressLC, new convexBaseRewardPoolAdapterParser_1.ConvexBaseRewardPoolAdapterParser(contract, isContract));
                 break;
             case "CONVEX_V1_BOOSTER":
-                TxParser.parsers[addressLC] = new convexBoosterAdapterParser_1.ConvexBoosterAdapterParser(contract, isContract);
+                TxParser._addParser(addressLC, new convexBoosterAdapterParser_1.ConvexBoosterAdapterParser(contract, isContract));
                 break;
             case "CONVEX_V1_CLAIM_ZAP":
                 break;
             case "LIDO_V1":
-                TxParser.parsers[addressLC] = new lidoAdapterParser_1.LidoAdapterParser(contract, isContract);
+                TxParser._addParser(addressLC, new lidoAdapterParser_1.LidoAdapterParser(contract, isContract));
                 break;
             case "LIDO_WSTETH_V1":
-                TxParser.parsers[addressLC] = new wstETHAdapterParser_1.WstETHAdapterParser(contract, isContract);
+                TxParser._addParser(addressLC, new wstETHAdapterParser_1.WstETHAdapterParser(contract, isContract));
                 break;
         }
     };
+    TxParser._addParser = function (address, parser) {
+        TxParser.parsers[address.toLowerCase()] = parser;
+    };
     TxParser.parsers = {};
     return TxParser;
 }());

package/lib/parsers/wstETHAdapterParser.js

@@ -44,6 +44,14 @@ var WstETHAdapterParser = /** @class */ (function (_super) {
             case "unwrapAll": {
                 return "".concat(functionName, "()");
             }
+            case "balanceOf": {
+                var address = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(").concat(address, ")");
+            }
+            case "allowance": {
+                var _b = this.decodeFunctionData(functionFragment, calldata), account = _b[0], to = _b[1];
+                return "".concat(functionName, "(account: ").concat(account, ", to: ").concat(to, ")");
+            }
             default:
                 return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
         }

package/lib/parsers/yearnV2AdapterParser.js

@@ -45,6 +45,17 @@ var YearnV2AdapterParser = /** @class */ (function (_super) {
                 var maxLossStr = maxLoss ? ", maxLoss: ".concat(maxLoss) : "";
                 return "".concat(functionName, "(").concat(amountStr).concat(addressStr).concat(maxLossStr, ")");
             }
+            case "pricePerShare": {
+                return "".concat(functionName);
+            }
+            case "balanceOf": {
+                var address = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(").concat(address, ")");
+            }
+            case "allowance": {
+                var _c = this.decodeFunctionData(functionFragment, calldata), account = _c[0], to = _c[1];
+                return "".concat(functionName, "(account: ").concat(account, ", to: ").concat(to, ")");
+            }
             default:
                 return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "1.19.4",
+  "version": "1.20.0",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",