@gearbox-protocol/sdk 1.3.4 → 1.5.1

package/lib/core/trade.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trade = void 0;
+var ethers_1 = require("ethers");
+var tradeTypes_1 = require("../pathfinder/tradeTypes");
+var formatter_1 = require("../utils/formatter");
+var adapter_1 = require("./adapter");
+var constants_1 = require("./constants");
+var Trade = /** @class */ (function () {
+    function Trade(_a) {
+        var tradePath = _a.tradePath, adapter = _a.adapter;
+        this.helper = adapter;
+        this.tradePath = tradePath;
+        this.swapType = tradeTypes_1.SwapType.ExactInput;
+        this.expectedAmount = ethers_1.BigNumber.from(0);
+        this.rate = ethers_1.BigNumber.from(0);
+        this.tokenFrom = "";
+        this.tokenTo = "";
+        this.operationName = "";
+    }
+    Trade.connect = function (_a) {
+        var tradePath = _a.tradePath, adapter = _a.adapter;
+        return new Trade({
+            tradePath: tradePath,
+            adapter: adapter,
+            swapType: tradeTypes_1.SwapType.ExactInput,
+            expectedAmount: ethers_1.BigNumber.from(0),
+            rate: ethers_1.BigNumber.from(0),
+            tokenFrom: "",
+            tokenTo: "",
+            operationName: "",
+        });
+    };
+    Trade.prototype.getName = function () {
+        return this.helper.name;
+    };
+    Trade.prototype.getAdapterInterface = function () {
+        return this.helper.adapterInterface;
+    };
+    Trade.prototype.getContractAddress = function () {
+        return this.helper.contractAddress;
+    };
+    Trade.prototype.getAdapterAddress = function () {
+        return this.helper.adapterAddress;
+    };
+    Trade.prototype.execute = function (slippage, signer) {
+        return this.helper.execute({ tradePath: this.tradePath, slippage: slippage, signer: signer });
+    };
+    Trade.prototype.toString = function (tokenData) {
+        var result = this.helper.type === adapter_1.AdapterType.Swap
+            ? "Swap "
+            : "".concat(this.operationName || "Farm", " ");
+        var fromToken = tokenData[this.tokenFrom];
+        var toToken = tokenData[this.tokenTo];
+        result += "".concat((0, formatter_1.formatBN)(this.tradePath.amount, fromToken.decimals), " ").concat(fromToken.symbol, " \u21D2 ").concat((0, formatter_1.formatBN)(this.expectedAmount, toToken.decimals), " ").concat(toToken.symbol, " on ").concat(this.helper.name);
+        return result;
+    };
+    Trade.prototype.getFromAmount = function (slippage) {
+        return this.expectedAmount
+            .mul(constants_1.PERCENTAGE_FACTOR)
+            .div(constants_1.PERCENTAGE_FACTOR + slippage);
+    };
+    Trade.prototype.getToAmount = function (slippage) {
+        return this.expectedAmount
+            .mul(constants_1.PERCENTAGE_FACTOR + slippage)
+            .div(constants_1.PERCENTAGE_FACTOR);
+    };
+    return Trade;
+}());
+exports.Trade = Trade;

package/lib/core/wcOperation.d.ts

@@ -0,0 +1,54 @@
+import type { TransactionRequest } from "@ethersproject/abstract-provider";
+import { BigNumber, BytesLike } from "ethers";
+import { FunctionFragment } from "ethers/lib/utils";
+export declare type TxType = "unsupported" | "swap" | "approve" | "lp";
+export declare type LpOperationType = "withdraw" | "deposit";
+export interface RawTransaction {
+    id: number;
+    method: "eth_sendTransaction";
+    params: [TransactionRequest];
+}
+export interface TxInfo {
+    from?: string;
+    to?: string;
+    amountFrom?: BigNumber;
+    amountTo?: BigNumber;
+    functionFragment: FunctionFragment;
+}
+export declare class SwapOperation {
+    readonly id: number;
+    operation?: string;
+    from?: string;
+    to?: string;
+    amountFrom?: BigNumber;
+    amountTo?: BigNumber;
+    tx?: TransactionRequest;
+    raw: RawTransaction;
+    kind: TxType;
+    protected calldata?: BytesLike;
+    isPending: boolean;
+    farm?: string;
+    lpOperationType?: LpOperationType;
+    static tokens: Record<string, boolean>;
+    constructor(raw: RawTransaction, kind: TxType);
+    static NewSwapOperation(params: {
+        adapter: string;
+        operation: string;
+        from: string;
+        to: string;
+        amountFrom: BigNumber;
+        amountTo: BigNumber;
+        raw: RawTransaction;
+    }): SwapOperation;
+    static NewLPOperation(params: {
+        adapter: string;
+        operation: string;
+        from: string;
+        amountFrom: BigNumber;
+        farm: string;
+        type: LpOperationType;
+        raw: RawTransaction;
+    }): SwapOperation;
+    static NewUnsupportedOperation(raw: RawTransaction): SwapOperation;
+    static NewApproveOperation(creditManager: string, raw: RawTransaction, token: string): SwapOperation;
+}

package/lib/core/wcOperation.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapOperation = void 0;
+var types_1 = require("../types");
+var SwapOperation = /** @class */ (function () {
+    function SwapOperation(raw, kind) {
+        this.id = raw.id;
+        this.raw = raw;
+        this.kind = kind;
+        this.isPending = false;
+    }
+    SwapOperation.NewSwapOperation = function (params) {
+        var _a, _b;
+        var newOperation = new SwapOperation(params.raw, "swap");
+        newOperation.operation = params.operation;
+        newOperation.from = params.from;
+        newOperation.to = params.to;
+        newOperation.amountFrom = params.amountFrom;
+        newOperation.amountTo = params.amountTo;
+        newOperation.raw = params.raw;
+        newOperation.calldata = (_b = (_a = params.raw) === null || _a === void 0 ? void 0 : _a.params[0]) === null || _b === void 0 ? void 0 : _b.data;
+        newOperation.tx = {
+            to: params.adapter,
+            data: newOperation.calldata,
+        };
+        return newOperation;
+    };
+    SwapOperation.NewLPOperation = function (params) {
+        var _a, _b;
+        var newOperation = new SwapOperation(params.raw, "lp");
+        newOperation.operation = params.operation;
+        newOperation.from = params.from;
+        newOperation.amountFrom = params.amountFrom;
+        newOperation.raw = params.raw;
+        newOperation.calldata = (_b = (_a = params.raw) === null || _a === void 0 ? void 0 : _a.params[0]) === null || _b === void 0 ? void 0 : _b.data;
+        newOperation.farm = params.farm;
+        newOperation.tx = {
+            to: params.adapter,
+            data: newOperation.calldata,
+        };
+        newOperation.lpOperationType = params.type;
+        return newOperation;
+    };
+    SwapOperation.NewUnsupportedOperation = function (raw) {
+        return new SwapOperation(raw, "unsupported");
+    };
+    SwapOperation.NewApproveOperation = function (creditManager, raw, token) {
+        var _a, _b;
+        var operation = new SwapOperation(raw, "approve");
+        operation.to = token;
+        operation.calldata = (_a = raw === null || raw === void 0 ? void 0 : raw.params[0]) === null || _a === void 0 ? void 0 : _a.data;
+        var tokenI = types_1.IERC20__factory.createInterface();
+        try {
+            var spender = tokenI.decodeFunctionData("approve", ((_b = raw === null || raw === void 0 ? void 0 : raw.params[0]) === null || _b === void 0 ? void 0 : _b.data) || "")[0];
+            var cmi = types_1.ICreditManager__factory.createInterface();
+            operation.from = spender;
+            // @ts-ignore
+            operation.calldata = cmi.encodeFunctionData("approve", [
+                spender,
+                operation.to,
+            ]);
+            operation.tx = {
+                to: creditManager,
+                data: operation.calldata,
+            };
+            return operation;
+        }
+        catch (e) {
+            console.error(e);
+            return SwapOperation.NewUnsupportedOperation(raw);
+        }
+    };
+    SwapOperation.tokens = {};
+    return SwapOperation;
+}());
+exports.SwapOperation = SwapOperation;

package/lib/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./contracts/contracts";
 export * from "./contracts/protocols";
+export * from "./core/adapter";
+export * from "./core/assets";
 export * from "./core/constants";
 export * from "./core/creditAccount";
 export * from "./core/creditManager";
@@ -11,7 +13,9 @@ export * from "./core/operations";
 export * from "./core/pool";
 export * from "./core/strategy";
 export * from "./core/tokenDistributor";
+export * from "./core/trade";
 export * from "./core/transactions";
+export * from "./core/wcOperation";
 export * from "./oracles/oracles";
 export * from "./oracles/priceFeeds";
 export * from "./payload/creditAccount";
@@ -29,6 +33,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 +45,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

@@ -17,6 +17,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.callRepeater = exports.swapKeyValue = exports.objectEntries = exports.keyToLowercase = exports.getUnderlyingToken = exports.getPoolTokens = exports.TokenType = exports.getContractName = exports.AdapterInterface = void 0;
 __exportStar(require("./contracts/contracts"), exports);
 __exportStar(require("./contracts/protocols"), exports);
+__exportStar(require("./core/adapter"), exports);
+__exportStar(require("./core/assets"), exports);
 __exportStar(require("./core/constants"), exports);
 __exportStar(require("./core/creditAccount"), exports);
 __exportStar(require("./core/creditManager"), exports);
@@ -28,7 +30,9 @@ __exportStar(require("./core/operations"), exports);
 __exportStar(require("./core/pool"), exports);
 __exportStar(require("./core/strategy"), exports);
 __exportStar(require("./core/tokenDistributor"), exports);
+__exportStar(require("./core/trade"), exports);
 __exportStar(require("./core/transactions"), exports);
+__exportStar(require("./core/wcOperation"), exports);
 __exportStar(require("./oracles/oracles"), exports);
 __exportStar(require("./oracles/priceFeeds"), exports);
 __exportStar(require("./payload/creditAccount"), exports);
@@ -49,6 +53,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 +65,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;
+}