@gearbox-protocol/sdk 1.22.3 → 1.23.0

package/lib/parsers/txParser.js

@@ -1,96 +1,88 @@
 "use strict";
 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 poolParser_1 = require("./poolParser");
-var priceOracleParser_1 = require("./priceOracleParser");
-var uniV2AdapterParser_1 = require("./uniV2AdapterParser");
-var uniV3AdapterParser_1 = require("./uniV3AdapterParser");
-var wstETHAdapterParser_1 = require("./wstETHAdapterParser");
-var yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
-var TxParser = /** @class */ (function () {
-    function TxParser() {
-    }
-    TxParser.parse = function (address, calldata) {
-        var parser = TxParser.getParser(address);
+const adapters_1 = require("../contracts/adapters");
+const contracts_1 = require("../contracts/contracts");
+const token_1 = require("../tokens/token");
+const mappers_1 = require("../utils/mappers");
+const addressProviderParser_1 = require("./addressProviderParser");
+const airdropDistributorParser_1 = require("./airdropDistributorParser");
+const convexBaseRewardPoolAdapterParser_1 = require("./convexBaseRewardPoolAdapterParser");
+const convexBoosterAdapterParser_1 = require("./convexBoosterAdapterParser");
+const convextRewardPoolParser_1 = require("./convextRewardPoolParser");
+const creditFacadeParser_1 = require("./creditFacadeParser");
+const creditManagerParser_1 = require("./creditManagerParser");
+const curveAdapterParser_1 = require("./curveAdapterParser");
+const dataCompressorParser_1 = require("./dataCompressorParser");
+const ERC20Parser_1 = require("./ERC20Parser");
+const lidoAdapterParser_1 = require("./lidoAdapterParser");
+const lidoOracleParser_1 = require("./lidoOracleParser");
+const lidoSTETHParser_1 = require("./lidoSTETHParser");
+const multicallParser_1 = require("./multicallParser");
+const offchainOracleParser_1 = require("./offchainOracleParser");
+const poolParser_1 = require("./poolParser");
+const priceOracleParser_1 = require("./priceOracleParser");
+const uniV2AdapterParser_1 = require("./uniV2AdapterParser");
+const uniV3AdapterParser_1 = require("./uniV3AdapterParser");
+const wstETHAdapterParser_1 = require("./wstETHAdapterParser");
+const yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
+class TxParser {
+    static parsers = {};
+    static parse(address, calldata) {
+        const parser = TxParser.getParser(address);
         return parser.parse(calldata);
-    };
-    TxParser.parseToObject = function (address, calldata) {
-        var parser = TxParser.getParser(address);
+    }
+    static parseToObject(address, calldata) {
+        const parser = TxParser.getParser(address);
         return parser.parseToObject(address, calldata);
-    };
-    TxParser.getParseData = function (address) {
-        var parser = TxParser.getParser(address);
+    }
+    static getParseData(address) {
+        const parser = TxParser.getParser(address);
         return { contract: parser.contract, adapterName: parser.adapterName };
-    };
-    TxParser.parseMultiCall = function (calls) {
-        return calls.map(function (call) {
-            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()];
+    }
+    static parseMultiCall(calls) {
+        return calls.map(call => TxParser.parse(call.target, call.callData.toString()));
+    }
+    static parseToObjectMultiCall(calls) {
+        return calls.map(call => TxParser.parseToObject(call.target, call.callData.toString()));
+    }
+    static addAdapters(adapters) {
+        for (let a of adapters) {
+            const contract = contracts_1.contractsByAddress[a.contract.toLowerCase()];
             if (contract && contracts_1.contractParams[contract]) {
                 TxParser.chooseContractParser(a.adapter, contract, contracts_1.contractParams[contract].type, false);
             }
             else {
-                console.error("Unknown address: ".concat(contract, " at ").concat(a.contract));
+                console.error(`Unknown address: ${contract} at ${a.contract}`);
             }
         }
-    };
-    TxParser.addContracts = function (network) {
-        (0, mappers_1.objectEntries)(contracts_1.contractParams).forEach(function (_a) {
-            var contract = _a[0], contractData = _a[1];
-            var address = contracts_1.contractsByNetwork[network][contract];
+    }
+    static addContracts(network) {
+        (0, mappers_1.objectEntries)(contracts_1.contractParams).forEach(([contract, contractData]) => {
+            const 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];
+                contractData.extraRewards.forEach(r => {
+                    const 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];
+                const extraAddress = contractData.oracle[network];
                 TxParser._addParser(extraAddress, new lidoOracleParser_1.LidoOracleParser());
             }
         });
-    };
-    TxParser.addCreditFacade = function (creditFacade, underlying) {
+    }
+    static addCreditFacade(creditFacade, 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];
+    }
+    static addTokens(network) {
+        (0, mappers_1.objectEntries)(token_1.tokenDataByNetwork[network]).forEach(([s, t]) => {
             if (s === "STETH") {
                 TxParser._addParser(t, new lidoSTETHParser_1.LidoSTETHParser(s));
             }
             else {
-                var contract = contracts_1.contractsByAddress[t.toLowerCase()];
+                const contract = contracts_1.contractsByAddress[t.toLowerCase()];
                 if (contract) {
                     TxParser.chooseContractParser(t, contract, contracts_1.contractParams[contract].type, true);
                 }
@@ -99,39 +91,39 @@ var TxParser = /** @class */ (function () {
                 }
             }
         });
-    };
-    TxParser.addOffchainOracleParser = function (address) {
+    }
+    static addOffchainOracleParser(address) {
         TxParser._addParser(address, new offchainOracleParser_1.OffchainOracleParserParser());
-    };
-    TxParser.addPriceOracle = function (address) {
+    }
+    static addPriceOracle(address) {
         TxParser._addParser(address, new priceOracleParser_1.PriceOracleParser());
-    };
-    TxParser.addDataCompressor = function (address) {
+    }
+    static addDataCompressor(address) {
         TxParser._addParser(address, new dataCompressorParser_1.DataCompressorParser());
-    };
-    TxParser.addAddressProvider = function (address) {
+    }
+    static addAddressProvider(address) {
         TxParser._addParser(address, new addressProviderParser_1.AddressProviderParser());
-    };
-    TxParser.addMulticall = function (address) {
+    }
+    static addMulticall(address) {
         TxParser._addParser(address, new multicallParser_1.MulticallParser());
-    };
-    TxParser.addAirdropDistributor = function (address) {
+    }
+    static addAirdropDistributor(address) {
         TxParser._addParser(address, new airdropDistributorParser_1.AirdropDistributorParser());
-    };
-    TxParser.addCreditManager = function (address, version) {
+    }
+    static addCreditManager(address, version) {
         TxParser._addParser(address, new creditManagerParser_1.CreditManagerParser(version));
-    };
-    TxParser.addPool = function (address, version) {
+    }
+    static addPool(address, version) {
         TxParser._addParser(address, new poolParser_1.PoolParser(version));
-    };
-    TxParser.getParser = function (address) {
-        var parser = TxParser.parsers[address.toLowerCase()];
+    }
+    static getParser(address) {
+        const parser = TxParser.parsers[address.toLowerCase()];
         if (!parser)
-            throw new Error("Can find parser for ".concat(address));
+            throw new Error(`Can find parser for ${address}`);
         return parser;
-    };
-    TxParser.chooseContractParser = function (address, contract, adapterType, isContract) {
-        var addressLC = address.toLowerCase();
+    }
+    static chooseContractParser(address, contract, adapterType, isContract) {
+        const addressLC = address.toLowerCase();
         switch (adapters_1.AdapterInterface[adapterType]) {
             case "UNISWAP_V2_ROUTER":
                 TxParser._addParser(addressLC, new uniV2AdapterParser_1.UniswapV2AdapterParser(contract, isContract));
@@ -165,11 +157,9 @@ var TxParser = /** @class */ (function () {
                 TxParser._addParser(addressLC, new wstETHAdapterParser_1.WstETHAdapterParser(contract, isContract));
                 break;
         }
-    };
-    TxParser._addParser = function (address, parser) {
+    }
+    static _addParser(address, parser) {
         TxParser.parsers[address.toLowerCase()] = parser;
-    };
-    TxParser.parsers = {};
-    return TxParser;
-}());
+    }
+}
 exports.TxParser = TxParser;

package/lib/parsers/uniV2AdapterParser.js

@@ -1,73 +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.UniswapV2AdapterParser = void 0;
-var types_1 = require("../types");
-var formatter_1 = require("../utils/formatter");
-var abstractParser_1 = require("./abstractParser");
-var UniswapV2AdapterParser = /** @class */ (function (_super) {
-    __extends(UniswapV2AdapterParser, _super);
-    function UniswapV2AdapterParser(contract, isContract) {
-        var _this = _super.call(this, contract) || this;
-        _this.ifc = types_1.IUniswapV2Adapter__factory.createInterface();
+const types_1 = require("../types");
+const formatter_1 = require("../utils/formatter");
+const abstractParser_1 = require("./abstractParser");
+class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.ifc = types_1.IUniswapV2Adapter__factory.createInterface();
         if (!isContract)
-            _this.adapterName = "UniswapV2Adapter";
-        return _this;
+            this.adapterName = "UniswapV2Adapter";
     }
-    UniswapV2AdapterParser.prototype.parse = function (calldata) {
+    parse(calldata) {
         return this._parse(calldata);
-    };
-    // parseTxInfo(calldata: string): TxInfo {}
-    UniswapV2AdapterParser.prototype._parse = function (calldata) {
-        var _this = this;
-        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+    }
+    _parse(calldata) {
+        const { functionFragment, functionName } = this.parseSelector(calldata);
         switch (functionFragment.name) {
             case "swapExactTokensForTokens": {
-                var _b = this.decodeFunctionData(functionFragment, calldata), amountIn = _b[0], amountOutMin = _b[1], path = _b[2];
-                var pathStr = path
-                    .map(function (r) { return _this.tokenSymbol(r); })
+                const [amountIn, amountOutMin, path] = this.decodeFunctionData(functionFragment, calldata);
+                const pathStr = path
+                    .map(r => this.tokenSymbol(r))
                     .join(" => ");
-                var tokenIn = this.tokenSymbol(path[0]);
-                var tokenOut = this.tokenSymbol(path[path.length - 1]);
-                var amountInStr = this.formatBN(amountIn, tokenIn);
-                var amountOutStr = this.formatBN(amountOutMin, tokenOut);
-                return "".concat(functionName, "(amountIn: ").concat(amountInStr, ", amountOutMin: ").concat(amountOutStr, ", path: [").concat(pathStr, "])");
+                const tokenIn = this.tokenSymbol(path[0]);
+                const tokenOut = this.tokenSymbol(path[path.length - 1]);
+                const amountInStr = this.formatBN(amountIn, tokenIn);
+                const amountOutStr = this.formatBN(amountOutMin, tokenOut);
+                return `${functionName}(amountIn: ${amountInStr}, amountOutMin: ${amountOutStr}, path: [${pathStr}])`;
             }
             case "swapTokensForExactTokens": {
-                var _c = this.decodeFunctionData(functionFragment, calldata), amountOut = _c[0], amountInMax = _c[1], path = _c[2];
-                var pathStr = path
-                    .map(function (r) { return _this.tokenSymbol(r); })
+                const [amountOut, amountInMax, path] = this.decodeFunctionData(functionFragment, calldata);
+                const pathStr = path
+                    .map(r => this.tokenSymbol(r))
                     .join(" => ");
-                var tokenIn = this.tokenSymbol(path[0]);
-                var tokenOut = this.tokenSymbol(path[path.length - 1]);
-                var amountOutStr = this.formatBN(amountOut, tokenIn);
-                var amountInMaxStr = this.formatBN(amountInMax, tokenOut);
-                return "".concat(functionName, "(amountOut: ").concat(amountOutStr, ", amountInMax: ").concat(amountInMaxStr, ", path: [").concat(pathStr, "])");
+                const tokenIn = this.tokenSymbol(path[0]);
+                const tokenOut = this.tokenSymbol(path[path.length - 1]);
+                const amountOutStr = this.formatBN(amountOut, tokenIn);
+                const amountInMaxStr = this.formatBN(amountInMax, tokenOut);
+                return `${functionName}(amountOut: ${amountOutStr}, amountInMax: ${amountInMaxStr}, path: [${pathStr}])`;
             }
             case "swapAllTokensForTokens": {
-                var _d = this.decodeFunctionData(functionFragment, calldata), rateMinRAY = _d[0], path = _d[1];
-                return "".concat(functionName, "(rate: ").concat((0, formatter_1.formatBN)(rateMinRAY, 27), ", path: [").concat(path
-                    .map(function (r) { return _this.tokenSymbol(r); })
-                    .join(" => "), "])");
+                const [rateMinRAY, path] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(rate: ${(0, formatter_1.formatBN)(rateMinRAY, 27)}, path: [${path
+                    .map(r => this.tokenSymbol(r))
+                    .join(" => ")}])`;
             }
             default:
-                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
         }
-    };
-    return UniswapV2AdapterParser;
-}(abstractParser_1.AbstractParser));
+    }
+}
 exports.UniswapV2AdapterParser = UniswapV2AdapterParser;

package/lib/parsers/uniV2AdapterParser.spec.js

@@ -1,18 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var chai_1 = require("chai");
-var ethers_1 = require("ethers");
-var constants_1 = require("../core/constants");
-var token_1 = require("../tokens/token");
-var types_1 = require("../types");
-var uniV2AdapterParser_1 = require("./uniV2AdapterParser");
-describe("UniswapV2AdapterParser test", function () {
-    it("swap functions works well", function () {
-        var parser = new uniV2AdapterParser_1.UniswapV2AdapterParser("UNISWAP_V2_ROUTER", false);
-        var ifc = types_1.IUniswapV2Adapter__factory.createInterface();
-        var parsed = parser.parse(ifc.encodeFunctionData("swapExactTokensForTokens", [
-            constants_1.WAD.mul(180000),
-            ethers_1.BigNumber.from(1e6).mul(45),
+const chai_1 = require("chai");
+const constants_1 = require("../core/constants");
+const token_1 = require("../tokens/token");
+const types_1 = require("../types");
+const uniV2AdapterParser_1 = require("./uniV2AdapterParser");
+describe("UniswapV2AdapterParser test", () => {
+    it("swap functions works well", () => {
+        let parser = new uniV2AdapterParser_1.UniswapV2AdapterParser("UNISWAP_V2_ROUTER", false);
+        const ifc = types_1.IUniswapV2Adapter__factory.createInterface();
+        let parsed = parser.parse(ifc.encodeFunctionData("swapExactTokensForTokens", [
+            constants_1.WAD * 180000n,
+            BigInt(1e6) * 45n,
             [
                 token_1.tokenDataByNetwork.Mainnet.DAI,
                 token_1.tokenDataByNetwork.Mainnet.WETH,
@@ -23,8 +22,8 @@ describe("UniswapV2AdapterParser test", function () {
         ]));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapExactTokensForTokens(amountIn: 180.00K [180000000000000000000000], amountOutMin: 45.00 [45000000], path: [DAI => WETH => USDC])", "Incorrect parse swapExactTokensForTokens");
         parsed = parser.parse(ifc.encodeFunctionData("swapTokensForExactTokens", [
-            ethers_1.BigNumber.from(1e6).mul(234500),
-            constants_1.WAD.mul(17700),
+            BigInt(1e6) * 234500n,
+            constants_1.WAD * 17700n,
             [
                 token_1.tokenDataByNetwork.Mainnet.USDC,
                 token_1.tokenDataByNetwork.Mainnet.DAI,
@@ -35,7 +34,7 @@ describe("UniswapV2AdapterParser test", function () {
         ]));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapTokensForExactTokens(amountOut: 234.50K [234500000000], amountInMax: 17.70K [17700000000000000000000], path: [USDC => DAI => FRAX])", "Incorrect parse swapTokensForExactTokens");
         parsed = parser.parse(ifc.encodeFunctionData("swapAllTokensForTokens", [
-            constants_1.RAY.mul(3240),
+            constants_1.RAY * 3240n,
             [
                 token_1.tokenDataByNetwork.Mainnet.USDC,
                 token_1.tokenDataByNetwork.Mainnet.DAI,

package/lib/parsers/uniV3AdapterParser.js

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