@gearbox-protocol/sdk 1.19.5 → 1.20.1

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

@@ -12,7 +12,13 @@ export declare class AbstractParser {
     constructor(contract: string);
     parseSelector(calldata: string): ParseSelectorResult;
     decodeFunctionData(functionFragment: FunctionFragment | string, data: BytesLike): Result;
+    encodeFunctionResult(functionFragment: FunctionFragment | string, data: Array<any>): string;
     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

@@ -18,6 +18,9 @@ var AbstractParser = /** @class */ (function () {
     AbstractParser.prototype.decodeFunctionData = function (functionFragment, data) {
         return this.ifc.decodeFunctionData(functionFragment, data);
     };
+    AbstractParser.prototype.encodeFunctionResult = function (functionFragment, data) {
+        return this.ifc.encodeFunctionResult(functionFragment, data);
+    };
     AbstractParser.prototype.tokenSymbol = function (address) {
         var symbol = token_1.tokenSymbolByAddress[address.toLowerCase()];
         if (!symbol)
@@ -27,6 +30,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,49 @@
+"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, "LIDO_".concat(symbol)) || this;
+        _this.ifc = types_1.IstETH__factory.createInterface();
+        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,15 @@ 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 parser = TxParser.getParser(address);
+        return parser.parseToObject(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 +45,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 +63,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 +141,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.5",
+  "version": "1.20.1",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",