@gearbox-protocol/sdk 1.22.4 → 1.23.0

package/lib/parsers/lidoAdapterParser.js

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

package/lib/parsers/lidoAdapterParser.spec.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var chai_1 = require("chai");
-var constants_1 = require("../core/constants");
-var types_1 = require("../types");
-var lidoAdapterParser_1 = require("./lidoAdapterParser");
-describe("LidoAdapterParser test", function () {
-    it("submit & submitAll function works well", function () {
-        var parser = new lidoAdapterParser_1.LidoAdapterParser("LIDO_STETH_GATEWAY", false);
-        var ifc = types_1.ILidoV1Adapter__factory.createInterface();
-        var parsed = parser.parse(ifc.encodeFunctionData("submit", [constants_1.WAD.mul(1020)]));
+const chai_1 = require("chai");
+const constants_1 = require("../core/constants");
+const types_1 = require("../types");
+const lidoAdapterParser_1 = require("./lidoAdapterParser");
+describe("LidoAdapterParser test", () => {
+    it("submit & submitAll function works well", () => {
+        let parser = new lidoAdapterParser_1.LidoAdapterParser("LIDO_STETH_GATEWAY", false);
+        const ifc = types_1.ILidoV1Adapter__factory.createInterface();
+        let parsed = parser.parse(ifc.encodeFunctionData("submit", [constants_1.WAD * 1020n]));
         (0, chai_1.expect)(parsed).to.be.eq("LidoV1Adapter[LIDO_STETH_GATEWAY].submit(amount: 1.02K [1020000000000000000000])", "Incorrect parse submit(amount)");
         parser = new lidoAdapterParser_1.LidoAdapterParser("LIDO_STETH_GATEWAY", true);
         parsed = parser.parse(ifc.encodeFunctionData("submitAll"));

package/lib/parsers/lidoOracleParser.js

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

package/lib/parsers/lidoSTETHParser.js

@@ -1,54 +1,36 @@
 "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 ethers_1 = require("ethers");
-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;
+const types_1 = require("../types");
+const formatter_1 = require("../utils/formatter");
+const abstractParser_1 = require("./abstractParser");
+class LidoSTETHParser extends abstractParser_1.AbstractParser {
+    constructor(symbol) {
+        super(`LIDO_${symbol}`);
+        this.ifc = types_1.IstETH__factory.createInterface();
     }
-    LidoSTETHParser.prototype.parse = function (calldata) {
-        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+    parse(calldata) {
+        const { functionFragment, functionName } = this.parseSelector(calldata);
         switch (functionFragment.name) {
             case "getFee":
             case "totalSupply": {
-                return "".concat(functionName, "()");
+                return `${functionName}()`;
             }
             case "balanceOf": {
-                var address = this.decodeFunctionData(functionFragment, calldata)[0];
-                return "".concat(functionName, "(").concat(address, ")");
+                const [address] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(${address})`;
             }
             case "allowance": {
-                var _b = this.decodeFunctionData(functionFragment, calldata), account = _b[0], to = _b[1];
-                return "".concat(functionName, "(account: ").concat(account, ", to: ").concat(to, ")");
+                const [account, to] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(account: ${account}, to: ${to})`;
             }
             case "approve": {
-                var _c = this.decodeFunctionData(functionFragment, calldata), spender = _c[0], amount = _c[1];
-                return "".concat(functionName, "(").concat(spender, ", [").concat(ethers_1.BigNumber.from(amount).toString(), "])");
+                const [spender, amount] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(${spender}, [${(0, formatter_1.toBigInt)(amount).toString()}])`;
             }
             default:
-                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
         }
-    };
-    return LidoSTETHParser;
-}(abstractParser_1.AbstractParser));
+    }
+}
 exports.LidoSTETHParser = LidoSTETHParser;

package/lib/parsers/multicallParser.js

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

package/lib/parsers/offchainOracleParser.js

@@ -1,41 +1,23 @@
 "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;
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class OffchainOracleParserParser extends abstractParser_1.AbstractParser {
+    constructor() {
+        super("OffchainOracleParser");
+        this.ifc = types_1.IOffchainOracle__factory.createInterface();
     }
-    OffchainOracleParserParser.prototype.parse = function (calldata) {
-        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+    parse(calldata) {
+        const { functionFragment, functionName } = this.parseSelector(calldata);
         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, ")");
+                const [srcToken, dstToken, useWrappers] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(token: ${this.tokenSymbol(srcToken)}, measured in: ${this.tokenSymbol(dstToken)}, use wrappers: ${useWrappers})`;
             }
             default:
-                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
         }
-    };
-    return OffchainOracleParserParser;
-}(abstractParser_1.AbstractParser));
+    }
+}
 exports.OffchainOracleParserParser = OffchainOracleParserParser;

package/lib/parsers/poolParser.js

@@ -1,37 +1,19 @@
 "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.PoolParser = void 0;
-var types_1 = require("../types");
-var abstractParser_1 = require("./abstractParser");
-var PoolParser = /** @class */ (function (_super) {
-    __extends(PoolParser, _super);
-    function PoolParser(version) {
-        var _this = _super.call(this, "Pool_V".concat(version)) || this;
-        _this.ifc = types_1.PoolService__factory.createInterface();
-        return _this;
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class PoolParser extends abstractParser_1.AbstractParser {
+    constructor(version) {
+        super(`Pool_V${version}`);
+        this.ifc = types_1.PoolService__factory.createInterface();
     }
-    PoolParser.prototype.parse = function (calldata) {
-        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+    parse(calldata) {
+        const { functionFragment, functionName } = this.parseSelector(calldata);
         switch (functionFragment.name) {
             default:
-                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
         }
-    };
-    return PoolParser;
-}(abstractParser_1.AbstractParser));
+    }
+}
 exports.PoolParser = PoolParser;

package/lib/parsers/priceOracleParser.js

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