@gearbox-protocol/sdk 1.3.3 → 1.5.0

package/lib/parsers/curveAdapterParser.js

@@ -0,0 +1,106 @@
+"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.CurveAdapterParser = void 0;
+var contracts_1 = require("../contracts/contracts");
+var types_1 = require("../types");
+var formatter_1 = require("../utils/formatter");
+var abstractParser_1 = require("./abstractParser");
+var CurveAdapterParser = /** @class */ (function (_super) {
+    __extends(CurveAdapterParser, _super);
+    function CurveAdapterParser(contract, isContract) {
+        var _this = _super.call(this, contract) || this;
+        var contractName = "";
+        var nCoins = contracts_1.contractParams[contract].tokens.length;
+        switch (nCoins) {
+            case 2:
+                _this.ifc = types_1.ICurveV1_2AssetsAdapter__factory.createInterface();
+                contractName = "Curve2AssetsAdapter";
+                break;
+            case 3:
+                _this.ifc = types_1.ICurveV1_3AssetsAdapter__factory.createInterface();
+                contractName = "Curve3AssetsAdapter";
+                break;
+            case 4:
+                _this.ifc = types_1.ICurveV1_4AssetsAdapter__factory.createInterface();
+                contractName = "Curve4AssetsAdapter";
+                break;
+            default:
+                throw new Error("Unsupported curve contract ".concat(contract));
+        }
+        _this.lpToken = contracts_1.contractParams[contract].lpToken;
+        if (!isContract)
+            _this.adapterName = contractName;
+        return _this;
+    }
+    CurveAdapterParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "exchange":
+            case "exchange_underlying": {
+                var _b = this.decodeFunctionData(functionFragment, calldata), i = _b[0], j = _b[1], dx = _b[2], min_dy = _b[3];
+                var iSym = this.getTokenByIndex(i);
+                var jSym = this.getTokenByIndex(j);
+                return "".concat(functionName, "(i ,j: ").concat(iSym, " => ").concat(jSym, ", dx: ").concat(this.formatBN(dx, iSym), ", min_dy: ").concat(this.formatBN(min_dy, jSym), ")");
+            }
+            case "exchange_all":
+            case "exchange_all_underlying": {
+                var _c = this.decodeFunctionData(functionFragment, calldata), i = _c[0], j = _c[1], rateMinRAY = _c[2];
+                return "".concat(functionName, "(i: ").concat(this.getTokenByIndex(i), ", j: ").concat(this.getTokenByIndex(j), ", rateMinRAY: ").concat((0, formatter_1.formatBN)(rateMinRAY, 27));
+            }
+            case "add_liquidity_one_coin": {
+                var _d = this.decodeFunctionData(functionFragment, calldata), amount = _d[0], i = _d[1], minAmount = _d[2];
+                var iSym = this.getTokenByIndex(i);
+                return "".concat(functionName, "(amount: ").concat(this.formatBN(amount, iSym), ", i: ").concat(iSym, ", minAmount: ").concat(this.formatBN(minAmount, this.lpToken), ")");
+            }
+            case "add_all_liquidity_one_coin":
+            case "remove_all_liquidity_one_coin": {
+                var _e = this.decodeFunctionData(functionFragment, calldata), i = _e[0], rateMinRAY = _e[1];
+                return "".concat(functionName, "(i: ").concat(this.getTokenByIndex(i), ", rateMinRAY: ").concat((0, formatter_1.formatBN)(rateMinRAY, 27), ")");
+            }
+            case "add_liquidity": {
+                var _f = this.decodeFunctionData(functionFragment, calldata), amounts = _f[0], minAmount = _f[1];
+                return "".concat(functionName, "(amounts: [").concat(this.convertAmounts(amounts), "], minAmount: ").concat(this.formatBN(minAmount, this.lpToken), ")");
+            }
+            case "remove_liquidity": {
+                var _g = this.decodeFunctionData(functionFragment, calldata), amount = _g[0], min_amounts = _g[1];
+                return "".concat(functionName, "(amount: ").concat(this.formatBN(amount, this.lpToken), ", min_amounts: [").concat(this.convertAmounts(min_amounts), "])");
+            }
+            case "remove_liquidity_imbalance": {
+                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), ")");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    CurveAdapterParser.prototype.getTokenByIndex = function (index) {
+        return contracts_1.contractParams[this.contract]
+            .tokens[index];
+    };
+    CurveAdapterParser.prototype.convertAmounts = function (amounts) {
+        var _this = this;
+        return amounts
+            .map(function (a, coin) {
+            var sym = _this.getTokenByIndex(coin);
+            return "".concat(sym, ": ").concat(_this.formatBN(a, sym));
+        })
+            .join(", ");
+    };
+    return CurveAdapterParser;
+}(abstractParser_1.AbstractParser));
+exports.CurveAdapterParser = CurveAdapterParser;

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

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

package/lib/parsers/curveAdapterParser.spec.js

@@ -0,0 +1,49 @@
+"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 curveAdapterParser_1 = require("./curveAdapterParser");
+describe("CurveAdapterParser test", function () {
+    it("stake / withdraw functions works well", function () {
+        var parser = new curveAdapterParser_1.CurveAdapterParser("CURVE_FRAX_POOL", false);
+        var ifc = types_1.ICurveV1_2AssetsAdapter__factory.createInterface();
+        var parsed = parser.parse(ifc.encodeFunctionData("exchange", [0, 1, constants_1.WAD.mul(3), constants_1.WAD.mul(32)]));
+        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].exchange(i ,j: FRAX => 3Crv, dx: 3.00 [3000000000000000000], min_dy: 32.00 [32000000000000000000])", "Curve2AssetsAdapter: Incorrect parse exchange");
+        parsed = parser.parse(ifc.encodeFunctionData("exchange_underlying", [
+            0,
+            1,
+            constants_1.WAD.mul(3),
+            constants_1.WAD.mul(32),
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].exchange_underlying(i ,j: FRAX => 3Crv, dx: 3.00 [3000000000000000000], min_dy: 32.00 [32000000000000000000])", "Curve2AssetsAdapter: Incorrect parse exchange_underlying");
+        parsed = parser.parse(ifc.encodeFunctionData("add_liquidity_one_coin", [
+            constants_1.WAD.mul(3),
+            0,
+            constants_1.WAD.mul(2),
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].add_liquidity_one_coin(amount: 3.00 [3000000000000000000], i: FRAX, minAmount: 2.00 [2000000000000000000])", "Curve2AssetsAdapter: Incorrect parse add_liquidity_one_coin");
+        parsed = parser.parse(ifc.encodeFunctionData("add_all_liquidity_one_coin", [0, constants_1.RAY.mul(912)]));
+        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].add_all_liquidity_one_coin(i: FRAX, rateMinRAY: 912.00)", "Curve2AssetsAdapter: Incorrect parse add_all_liquidity_one_coin");
+        parsed = parser.parse(ifc.encodeFunctionData("remove_all_liquidity_one_coin", [
+            0,
+            constants_1.RAY.mul(721),
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].remove_all_liquidity_one_coin(i: FRAX, rateMinRAY: 721.00)", "Curve2AssetsAdapter: Incorrect parse remove_all_liquidity_one_coin");
+        parsed = parser.parse(ifc.encodeFunctionData("add_liquidity", [
+            [constants_1.WAD.mul(100), constants_1.WAD.mul(100)],
+            constants_1.WAD.mul(80),
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].add_liquidity(amounts: [FRAX: 100.00 [100000000000000000000], 3Crv: 100.00 [100000000000000000000]], minAmount: 80.00 [80000000000000000000])", "Curve2AssetsAdapter: Incorrect parse add_liquidity");
+        parsed = parser.parse(ifc.encodeFunctionData("remove_liquidity", [
+            constants_1.WAD.mul(120),
+            [constants_1.WAD.mul(100), constants_1.WAD.mul(100)],
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].remove_liquidity(amount: 120.00 [120000000000000000000], min_amounts: [FRAX: 100.00 [100000000000000000000], 3Crv: 100.00 [100000000000000000000]])", "Curve2AssetsAdapter: Incorrect parse remove_liquidity");
+        parsed = parser.parse(ifc.encodeFunctionData("remove_liquidity_imbalance", [
+            [constants_1.WAD.mul(100), constants_1.WAD.mul(100)],
+            constants_1.WAD.mul(80),
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].remove_liquidity_imbalance(amounts: [FRAX: 100.00 [100000000000000000000], 3Crv: 100.00 [100000000000000000000]], max_burn_amount: 80.00 [80000000000000000000])", "Curve2AssetsAdapter: Incorrect parse remove_liquidity_imbalance");
+    });
+});

package/lib/parsers/iParser.d.ts

@@ -0,0 +1,3 @@
+export interface IParser {
+    parse: (calldata: string) => string;
+}

package/lib/parsers/lidoAdapterParser.d.ts

@@ -0,0 +1,7 @@
+import { SupportedContract } from "../contracts/contracts";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class LidoAdapterParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: string): string;
+}

package/lib/parsers/lidoAdapterParser.js

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

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

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

package/lib/parsers/lidoAdapterParser.spec.js

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

package/lib/parsers/txParser.d.ts

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

package/lib/parsers/txParser.js

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

package/lib/parsers/uniV2AdapterParser.d.ts

@@ -0,0 +1,8 @@
+import { SupportedContract } from "../contracts/contracts";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class UniswapV2AdapterParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: string): string;
+    protected _parse(calldata: string): string;
+}

package/lib/parsers/uniV2AdapterParser.js

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

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

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

package/lib/parsers/uniV2AdapterParser.spec.js

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

package/lib/parsers/uniV3AdapterParser.d.ts

@@ -0,0 +1,9 @@
+import { SupportedContract } from "../contracts/contracts";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class UniswapV3AdapterParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: string): string;
+    trackInputPath(path: string): string;
+    trackOutputPath(path: string): string;
+}

package/lib/parsers/uniV3AdapterParser.js

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

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

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