@gearbox-protocol/sdk 1.3.2 → 1.4.0

package/lib/core/constants.d.ts

@@ -22,3 +22,4 @@ export declare const timeRanges: Record<string, number>;
 export declare const LEVERAGE_DECIMALS = 100;
 export declare const SLIPPAGE_DECIMALS = 100;
 export declare const ADDRESS_0X0 = "0x0000000000000000000000000000000000000000";
+export declare const DUMB_ADDRESS = "0xC4375B7De8af5a38a93548eb8453a498222C4fF2";

package/lib/core/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ADDRESS_0X0 = exports.SLIPPAGE_DECIMALS = exports.LEVERAGE_DECIMALS = exports.timeRanges = exports.UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD = exports.LIQUIDATION_DISCOUNTED_SUM = exports.PERCENTAGE_FACTOR = exports.PERCENTAGE_DECIMALS = exports.SECONDS_PER_YEAR = exports.PRICE_DECIMALS = exports.PRICE_DECIMALS_POW = exports.WAD = exports.WAD_DECIMALS_POW = exports.halfRAY = exports.RAY = exports.RAY_DECIMALS_POW = exports.getNetworkType = exports.HARDHAT_NETWORK = exports.LOCAL_NETWORK = exports.GOERLI_NETWORK = exports.MAINNET_NETWORK = exports.MAX_INT = void 0;
+exports.DUMB_ADDRESS = exports.ADDRESS_0X0 = exports.SLIPPAGE_DECIMALS = exports.LEVERAGE_DECIMALS = exports.timeRanges = exports.UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD = exports.LIQUIDATION_DISCOUNTED_SUM = exports.PERCENTAGE_FACTOR = exports.PERCENTAGE_DECIMALS = exports.SECONDS_PER_YEAR = exports.PRICE_DECIMALS = exports.PRICE_DECIMALS_POW = exports.WAD = exports.WAD_DECIMALS_POW = exports.halfRAY = exports.RAY = exports.RAY_DECIMALS_POW = exports.getNetworkType = exports.HARDHAT_NETWORK = exports.LOCAL_NETWORK = exports.GOERLI_NETWORK = exports.MAINNET_NETWORK = exports.MAX_INT = void 0;
 var ethers_1 = require("ethers");
 exports.MAX_INT = ethers_1.BigNumber.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 exports.MAINNET_NETWORK = 1;
@@ -41,3 +41,5 @@ exports.timeRanges = {
 exports.LEVERAGE_DECIMALS = 100;
 exports.SLIPPAGE_DECIMALS = 100;
 exports.ADDRESS_0X0 = "0x0000000000000000000000000000000000000000";
+// Used in tests
+exports.DUMB_ADDRESS = "0xC4375B7De8af5a38a93548eb8453a498222C4fF2";

package/lib/index.d.ts

@@ -29,6 +29,7 @@ export * from "./apy";
 export { AdapterInterface } from "./contracts/adapters";
 export { getContractName } from "./contracts/contractsRegister";
 export * from "./core/history";
+export * from "./parsers/txParser";
 export * from "./pathfinder/tradeTypes";
 export * from "./strategies/convex";
 export * from "./strategies/creditFacade";
@@ -40,6 +41,7 @@ export * from "./strategies/yearn";
 export * from "./tokens/connectors";
 export * from "./tokens/convex";
 export * from "./tokens/curveLP";
+export * from "./tokens/decimals";
 export * from "./tokens/gear";
 export * from "./tokens/normal";
 export * from "./tokens/token";

package/lib/index.js

@@ -49,6 +49,7 @@ Object.defineProperty(exports, "AdapterInterface", { enumerable: true, get: func
 var contractsRegister_1 = require("./contracts/contractsRegister");
 Object.defineProperty(exports, "getContractName", { enumerable: true, get: function () { return contractsRegister_1.getContractName; } });
 __exportStar(require("./core/history"), exports);
+__exportStar(require("./parsers/txParser"), exports);
 __exportStar(require("./pathfinder/tradeTypes"), exports);
 __exportStar(require("./strategies/convex"), exports);
 __exportStar(require("./strategies/creditFacade"), exports);
@@ -60,6 +61,7 @@ __exportStar(require("./strategies/yearn"), exports);
 __exportStar(require("./tokens/connectors"), exports);
 __exportStar(require("./tokens/convex"), exports);
 __exportStar(require("./tokens/curveLP"), exports);
+__exportStar(require("./tokens/decimals"), exports);
 __exportStar(require("./tokens/gear"), exports);
 __exportStar(require("./tokens/normal"), exports);
 __exportStar(require("./tokens/token"), exports);

package/lib/parsers/abstractParser.d.ts

@@ -0,0 +1,18 @@
+import { FunctionFragment, Result } from "@ethersproject/abi";
+import { BigNumberish, BytesLike, utils } from "ethers";
+import { SupportedToken } from "../tokens/token";
+interface ParseSelectorResult {
+    functionFragment: FunctionFragment;
+    functionName: string;
+}
+export declare class AbstractParser {
+    readonly contract: string;
+    protected ifc: utils.Interface;
+    adapterName: string;
+    constructor(contract: string);
+    parseSelector(calldata: string): ParseSelectorResult;
+    decodeFunctionData(functionFragment: FunctionFragment | string, data: BytesLike): Result;
+    tokenSymbol(address: string): SupportedToken;
+    formatBN(amount: BigNumberish, token: SupportedToken): string;
+}
+export {};

package/lib/parsers/abstractParser.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractParser = void 0;
+var ethers_1 = require("ethers");
+var decimals_1 = require("../tokens/decimals");
+var token_1 = require("../tokens/token");
+var formatter_1 = require("../utils/formatter");
+var AbstractParser = /** @class */ (function () {
+    function AbstractParser(contract) {
+        this.contract = contract;
+        this.adapterName = "Contract";
+    }
+    AbstractParser.prototype.parseSelector = function (calldata) {
+        var functionFragment = this.ifc.getFunction(ethers_1.utils.hexDataSlice(calldata, 0, 4));
+        var functionName = "".concat(this.adapterName, "[").concat(this.contract, "].").concat(functionFragment.name);
+        return { functionFragment: functionFragment, functionName: functionName };
+    };
+    AbstractParser.prototype.decodeFunctionData = function (functionFragment, data) {
+        return this.ifc.decodeFunctionData(functionFragment, data);
+    };
+    AbstractParser.prototype.tokenSymbol = function (address) {
+        var symbol = token_1.tokenSymbolByAddress[address.toLowerCase()];
+        if (!symbol)
+            throw new Error("Unknown token: ".concat(address));
+        return symbol;
+    };
+    AbstractParser.prototype.formatBN = function (amount, token) {
+        return "".concat((0, formatter_1.formatBN)(amount, decimals_1.decimals[token]), " [").concat(ethers_1.BigNumber.from(amount).toString(), "]");
+    };
+    return AbstractParser;
+}());
+exports.AbstractParser = AbstractParser;

package/lib/parsers/convexBaseRewardPoolAdapterParser.d.ts

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

package/lib/parsers/convexBaseRewardPoolAdapterParser.js

@@ -0,0 +1,60 @@
+"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.ConvexBaseRewardPoolAdapterParser = void 0;
+var contracts_1 = require("../contracts/contracts");
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var ConvexBaseRewardPoolAdapterParser = /** @class */ (function (_super) {
+    __extends(ConvexBaseRewardPoolAdapterParser, _super);
+    function ConvexBaseRewardPoolAdapterParser(contract, isContract) {
+        var _this = _super.call(this, contract) || this;
+        _this.ifc = types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface();
+        if (!isContract)
+            _this.adapterName = "ConvexV1BaseRewardPoolAdapter";
+        return _this;
+    }
+    ConvexBaseRewardPoolAdapterParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "stake":
+            case "stakeAll": {
+                var amount = this.decodeFunctionData(functionFragment, calldata)[0];
+                var amountStr = amount ? "amount: ".concat(this.formatAmount(amount)) : "";
+                return "".concat(functionName, "(").concat(amountStr, ")");
+            }
+            case "withdraw":
+            case "withdrawAndUnwrap": {
+                var _b = this.decodeFunctionData(functionFragment, calldata), amount = _b[0], claim = _b[1];
+                return "".concat(functionName, "(amount: ").concat(this.formatAmount(amount), ", claim: ").concat(claim, ")");
+            }
+            case "withdrawAll":
+            case "withdrawAllAndUnwrap": {
+                var claim = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(claim: ").concat(claim, ")");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    ConvexBaseRewardPoolAdapterParser.prototype.formatAmount = function (amount) {
+        return this.formatBN(amount, contracts_1.contractParams[this.contract]
+            .stakedToken);
+    };
+    return ConvexBaseRewardPoolAdapterParser;
+}(abstractParser_1.AbstractParser));
+exports.ConvexBaseRewardPoolAdapterParser = ConvexBaseRewardPoolAdapterParser;

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

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

package/lib/parsers/convexBaseRewardPoolAdapterParser.spec.js

@@ -0,0 +1,24 @@
+"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 convexBaseRewardPoolAdapterParser_1 = require("./convexBaseRewardPoolAdapterParser");
+describe("ConvexV1BaseRewardPoolAdapterParser test", function () {
+    it("stake / withdraw functions works well", function () {
+        var parser = new convexBaseRewardPoolAdapterParser_1.ConvexBaseRewardPoolAdapterParser("CONVEX_FRAX3CRV_POOL", false);
+        var ifc = types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface();
+        var parsed = parser.parse(ifc.encodeFunctionData("stake", [constants_1.WAD.mul(199).div(10)]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].stake(amount: 19.90 [19900000000000000000])", "Incorrect parse stake");
+        parsed = parser.parse(ifc.encodeFunctionData("stakeAll"));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].stakeAll()", "Incorrect parse stakeAll");
+        parsed = parser.parse(ifc.encodeFunctionData("withdraw", [constants_1.WAD.mul(199).div(1000), false]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].withdraw(amount: 0.19 [199000000000000000], claim: false)", "Incorrect parse withdraw");
+        parsed = parser.parse(ifc.encodeFunctionData("withdrawAndUnwrap", [constants_1.WAD.mul(2).div(1000), true]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].withdrawAndUnwrap(amount: 0.002 [2000000000000000], claim: true)", "Incorrect parse withdrawAndUnwrap");
+        parsed = parser.parse(ifc.encodeFunctionData("withdrawAll", [false]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].withdrawAll(claim: false)", "Incorrect parse withdrawAll");
+        parsed = parser.parse(ifc.encodeFunctionData("withdrawAllAndUnwrap", [true]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].withdrawAllAndUnwrap(claim: true)", "Incorrect parse withdrawAllAndUnwrap");
+    });
+});

package/lib/parsers/convexBoosterAdapterParser.d.ts

@@ -0,0 +1,10 @@
+import { BigNumberish } from "ethers";
+import { SupportedContract } from "../contracts/contracts";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class ConvexBoosterAdapterParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: string): string;
+    formatAmount(amount: BigNumberish, pid: number): string;
+    formatPid(pid: number): string;
+}

package/lib/parsers/convexBoosterAdapterParser.js

@@ -0,0 +1,62 @@
+"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.ConvexBoosterAdapterParser = void 0;
+var convex_1 = require("../tokens/convex");
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var ConvexBoosterAdapterParser = /** @class */ (function (_super) {
+    __extends(ConvexBoosterAdapterParser, _super);
+    function ConvexBoosterAdapterParser(contract, isContract) {
+        var _this = _super.call(this, contract) || this;
+        _this.ifc = types_1.IConvexV1BoosterAdapter__factory.createInterface();
+        if (!isContract)
+            _this.adapterName = "ConvexV1BoosterAdapter";
+        return _this;
+    }
+    ConvexBoosterAdapterParser.prototype.parse = function (calldata) {
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "deposit": {
+                var _b = this.decodeFunctionData(functionFragment, calldata), pid = _b[0], amount = _b[1], stake = _b[2];
+                return "".concat(functionName, "(pid: ").concat(this.formatPid(pid), ", amount: ").concat(this.formatAmount(amount, pid), ", stake: ").concat(stake, ")");
+            }
+            case "depositAll": {
+                var _c = this.decodeFunctionData(functionFragment, calldata), pid = _c[0], stake = _c[1];
+                return "".concat(functionName, "(pid: ").concat(this.formatPid(pid), ", stake: ").concat(stake, ")");
+            }
+            case "withdraw": {
+                var _d = this.decodeFunctionData(functionFragment, calldata), pid = _d[0], amount = _d[1];
+                return "".concat(functionName, "(pid: ").concat(this.formatPid(pid), ", amount: ").concat(this.formatAmount(amount, pid), ")");
+            }
+            case "withdrawAll": {
+                var pid = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(pid: ").concat(this.formatPid(pid), ")");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    ConvexBoosterAdapterParser.prototype.formatAmount = function (amount, pid) {
+        return this.formatBN(amount, convex_1.convexLpTokenByPid[pid]);
+    };
+    ConvexBoosterAdapterParser.prototype.formatPid = function (pid) {
+        return "".concat(pid, " [").concat(convex_1.convexPoolByPid[pid], "]");
+    };
+    return ConvexBoosterAdapterParser;
+}(abstractParser_1.AbstractParser));
+exports.ConvexBoosterAdapterParser = ConvexBoosterAdapterParser;

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

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

package/lib/parsers/convexBoosterAdapterParser.spec.js

@@ -0,0 +1,20 @@
+"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 convexBoosterAdapterParser_1 = require("./convexBoosterAdapterParser");
+describe("ConvexV1BaseRewardPoolAdapterParser test", function () {
+    it("stake / withdraw functions works well", function () {
+        var parser = new convexBoosterAdapterParser_1.ConvexBoosterAdapterParser("CONVEX_BOOSTER", false);
+        var ifc = types_1.IConvexV1BoosterAdapter__factory.createInterface();
+        var parsed = parser.parse(ifc.encodeFunctionData("deposit", [9, constants_1.WAD.mul(19999), false]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BoosterAdapter[CONVEX_BOOSTER].deposit(pid: 9 [CONVEX_3CRV_POOL], amount: 19.99K [19999000000000000000000], stake: false)", "Incorrect parse deposit");
+        parsed = parser.parse(ifc.encodeFunctionData("depositAll", [32, true]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BoosterAdapter[CONVEX_BOOSTER].depositAll(pid: 32 [CONVEX_FRAX3CRV_POOL], stake: true)", "Incorrect parse depositAll");
+        parsed = parser.parse(ifc.encodeFunctionData("withdraw", [9, constants_1.WAD.mul(555).div(10)]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BoosterAdapter[CONVEX_BOOSTER].withdraw(pid: 9 [CONVEX_3CRV_POOL], amount: 55.50 [55500000000000000000])", "Incorrect parse withdraw");
+        parsed = parser.parse(ifc.encodeFunctionData("withdrawAll", [32]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BoosterAdapter[CONVEX_BOOSTER].withdrawAll(pid: 32 [CONVEX_FRAX3CRV_POOL])", "Incorrect parse withdrawAll");
+    });
+});

package/lib/parsers/creditFacadeParser.d.ts

@@ -0,0 +1,9 @@
+import { BigNumberish } from "ethers";
+import { SupportedToken } from "../tokens/token";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class CreditFacadeParser extends AbstractParser implements IParser {
+    constructor(token: SupportedToken);
+    parse(calldata: string): string;
+    formatAmount(amount: BigNumberish): string;
+}

package/lib/parsers/creditFacadeParser.js

@@ -0,0 +1,66 @@
+"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.CreditFacadeParser = void 0;
+var types_1 = require("../types");
+var abstractParser_1 = require("./abstractParser");
+var CreditFacadeParser = /** @class */ (function (_super) {
+    __extends(CreditFacadeParser, _super);
+    function CreditFacadeParser(token) {
+        var _this = _super.call(this, token) || this;
+        _this.ifc = types_1.ICreditFacadeExtended__factory.createInterface();
+        _this.adapterName = "CreditFacade";
+        return _this;
+    }
+    CreditFacadeParser.prototype.parse = function (calldata) {
+        var _this = this;
+        var _a = this.parseSelector(calldata), functionFragment = _a.functionFragment, functionName = _a.functionName;
+        switch (functionFragment.name) {
+            case "addCollateral": {
+                var _b = this.decodeFunctionData(functionFragment, calldata), onBehalf = _b[0], token = _b[1], amount = _b[2];
+                return "".concat(functionName, "(onBehalf: ").concat(onBehalf, ", token: ").concat(this.tokenSymbol(token), ", amount: ").concat(this.formatAmount(amount), ")");
+            }
+            case "increaseDebt":
+            case "decreaseDebt": {
+                var amount = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(amount: ").concat(this.formatAmount(amount), ")");
+            }
+            case "enableToken":
+            case "disableToken": {
+                var address = this.decodeFunctionData(functionFragment, calldata)[0];
+                return "".concat(functionName, "(token: ").concat(this.tokenSymbol(address), ")");
+            }
+            case "revertIfReceivedLessThan": {
+                var balances = this.decodeFunctionData(functionFragment, calldata)[0];
+                var balancesStr = balances
+                    .map(function (b) {
+                    var symbol = _this.tokenSymbol(b.token);
+                    return "".concat(symbol, ": ").concat(_this.formatBN(b.balance, symbol));
+                })
+                    .join(", ");
+                return "".concat(functionName, "(").concat(balancesStr, ")");
+            }
+            default:
+                return "".concat(functionName, ": Unknown operation ").concat(functionFragment.name, " with calldata ").concat(calldata);
+        }
+    };
+    CreditFacadeParser.prototype.formatAmount = function (amount) {
+        return this.formatBN(amount, this.contract);
+    };
+    return CreditFacadeParser;
+}(abstractParser_1.AbstractParser));
+exports.CreditFacadeParser = CreditFacadeParser;

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

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

package/lib/parsers/creditFacadeParser.spec.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var chai_1 = require("chai");
+var constants_1 = require("../core/constants");
+var token_1 = require("../tokens/token");
+var types_1 = require("../types");
+var creditFacadeParser_1 = require("./creditFacadeParser");
+describe("CreditFacadeParser test", function () {
+    it("all functions works well", function () {
+        var parser = new creditFacadeParser_1.CreditFacadeParser("DAI");
+        var ifc = types_1.ICreditFacadeExtended__factory.createInterface();
+        var parsed = parser.parse(ifc.encodeFunctionData("addCollateral", [
+            constants_1.DUMB_ADDRESS,
+            token_1.tokenDataByNetwork.Mainnet.WBTC,
+            constants_1.WAD.mul(444).div(10),
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].addCollateral(onBehalf: 0xC4375B7De8af5a38a93548eb8453a498222C4fF2, token: WBTC, amount: 44.40 [44400000000000000000])", "Incorrect parse addCollateral");
+        parsed = parser.parse(ifc.encodeFunctionData("increaseDebt", [constants_1.WAD.mul(414).div(10)]));
+        (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].increaseDebt(amount: 41.40 [41400000000000000000])", "Incorrect parse increaseDebt");
+        parsed = parser.parse(ifc.encodeFunctionData("decreaseDebt", [constants_1.WAD.mul(334).div(10)]));
+        (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].decreaseDebt(amount: 33.40 [33400000000000000000])", "Incorrect parse decreaseDebt");
+        parsed = parser.parse(ifc.encodeFunctionData("enableToken", [token_1.tokenDataByNetwork.Mainnet.WETH]));
+        (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].enableToken(token: WETH)", "Incorrect parse enableToken");
+        parsed = parser.parse(ifc.encodeFunctionData("disableToken", [token_1.tokenDataByNetwork.Mainnet.LINK]));
+        (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].disableToken(token: LINK)", "Incorrect parse disableToken");
+    });
+});

package/lib/parsers/curveAdapterParser.d.ts

@@ -0,0 +1,12 @@
+import { BigNumberish } from "ethers";
+import { SupportedContract } from "../contracts/contracts";
+import { SupportedToken } from "../tokens/token";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class CurveAdapterParser extends AbstractParser implements IParser {
+    protected lpToken: SupportedToken;
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: string): string;
+    getTokenByIndex(index: number): SupportedToken;
+    convertAmounts(amounts: Array<BigNumberish>): string;
+}

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;
+}