@gearbox-protocol/sdk 3.0.0-next.236 → 3.0.0-next.237

package/lib/index.js

@@ -31,8 +31,10 @@ __exportStar(require("./core/protocols"), exports);
 __exportStar(require("./core/rewardClaimer"), exports);
 __exportStar(require("./core/strategy"), exports);
 __exportStar(require("./core/tokenDistributor"), exports);
+__exportStar(require("./core/trade"), exports);
 __exportStar(require("./core/transactions"), exports);
 __exportStar(require("./gearboxRewards"), exports);
+__exportStar(require("./parsers/txParser"), exports);
 __exportStar(require("./pathfinder"), exports);
 __exportStar(require("./payload/bot"), exports);
 __exportStar(require("./payload/creditAccount"), exports);

package/lib/parsers/ERC20Parser.d.ts

@@ -0,0 +1,8 @@
+import { SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class ERC20Parser extends AbstractParser implements IParser {
+    constructor(symbol: SupportedToken);
+    parse(calldata: Address): string;
+}

package/lib/parsers/ERC20Parser.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC20Parser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class ERC20Parser extends abstractParser_1.AbstractParser {
+    constructor(symbol) {
+        super(symbol);
+        this.adapterName = "Token";
+        this.abi = types_1.ierc20Abi;
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "totalSupply": {
+                return `${functionName}()`;
+            }
+            case "balanceOf": {
+                const [address] = functionData.args || [];
+                return `${functionName}(${address})`;
+            }
+            case "allowance": {
+                const [account, to] = functionData.args || [];
+                return `${functionName}(account: ${account}, to: ${to})`;
+            }
+            case "approve": {
+                const [spender, amount] = functionData.args || [];
+                return `${functionName}(${spender}, [${(0, sdk_gov_1.toBigInt)(amount).toString()}])`;
+            }
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+}
+exports.ERC20Parser = ERC20Parser;

package/lib/parsers/aaveV2LendingPoolAdapterParser.d.ts

@@ -0,0 +1,8 @@
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class AaveV2LendingPoolAdapterParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: Address): string;
+}

package/lib/parsers/aaveV2LendingPoolAdapterParser.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AaveV2LendingPoolAdapterParser = void 0;
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class AaveV2LendingPoolAdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.abi = types_1.iAaveV2LendingPoolAdapterAbi;
+        if (!isContract)
+            this.adapterName = "AaveV2_LendingPoolAdapter";
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+}
+exports.AaveV2LendingPoolAdapterParser = AaveV2LendingPoolAdapterParser;

package/lib/parsers/aaveV2WrappedATokenAdapterParser.d.ts

@@ -0,0 +1,8 @@
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class AaveV2WrappedATokenAdapterParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: Address): string;
+}

package/lib/parsers/aaveV2WrappedATokenAdapterParser.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AaveV2WrappedATokenAdapterParser = void 0;
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class AaveV2WrappedATokenAdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.abi = types_1.iAaveV2WrappedATokenAdapterAbi;
+        if (!isContract)
+            this.adapterName = "AaveV2_WrappedATokenAdapter";
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+}
+exports.AaveV2WrappedATokenAdapterParser = AaveV2WrappedATokenAdapterParser;

package/lib/parsers/abstractParser.d.ts

@@ -0,0 +1,30 @@
+import { SupportedToken, TickerToken } from "@gearbox-protocol/sdk-gov";
+import { Abi, Address } from "viem";
+import { BigNumberish } from "../utils/formatter";
+export interface ParsedObject {
+    address: Address;
+    functionName: string;
+    args: readonly any[];
+}
+export declare class AbstractParser {
+    readonly contract: string;
+    protected abi: Abi;
+    adapterName: string;
+    constructor(contract: string);
+    parseSelector(calldata: Address): {
+        functionData: {
+            args: Array<any> | undefined;
+            functionName: string;
+        };
+        functionName: string;
+    };
+    decodeFunctionData(data: Address): {
+        args: readonly unknown[] | undefined;
+        functionName: string;
+    };
+    tokenSymbol(address: Address): SupportedToken;
+    tokenOrTickerSymbol(address: Address): SupportedToken | TickerToken;
+    formatBN(amount: BigNumberish, token: SupportedToken): string;
+    parseToObject(address: Address, calldata: Address): ParsedObject;
+    reportUnknownFragment(parserName: string, functionName: string, calldata: string): string;
+}

package/lib/parsers/abstractParser.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const viem_1 = require("viem");
+class AbstractParser {
+    contract;
+    abi;
+    adapterName;
+    constructor(contract) {
+        this.contract = contract;
+        this.adapterName = "Contract";
+    }
+    parseSelector(calldata) {
+        const functionData = (0, viem_1.decodeFunctionData)({
+            abi: this.abi,
+            data: calldata,
+        });
+        if (!functionData.functionName)
+            throw new Error("Function fragment not found");
+        const functionName = `${this.adapterName}[${this.contract}].${functionData.functionName}`;
+        return {
+            functionData: functionData,
+            functionName,
+        };
+    }
+    decodeFunctionData(data) {
+        return (0, viem_1.decodeFunctionData)({
+            abi: this.abi,
+            data,
+        });
+    }
+    tokenSymbol(address) {
+        const symbol = sdk_gov_1.tokenSymbolByAddress[address.toLowerCase()];
+        if (!symbol)
+            throw new Error(`Unknown token: ${address}`);
+        return symbol;
+    }
+    tokenOrTickerSymbol(address) {
+        const symbol = (0, sdk_gov_1.getTokenSymbolOrTicker)(address);
+        if (!symbol) {
+            throw new Error(`Unknown token or ticker: ${address}`);
+        }
+        return symbol;
+    }
+    formatBN(amount, token) {
+        return `${(0, sdk_gov_1.formatBN)(amount, sdk_gov_1.decimals[token])} [${(0, sdk_gov_1.toBigInt)(amount).toString()}]`;
+    }
+    parseToObject(address, calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        return {
+            address,
+            functionName,
+            args: functionData.args || [],
+        };
+    }
+    reportUnknownFragment(parserName, functionName, calldata) {
+        return `${parserName}: Unknown operation ${functionName} with calldata ${calldata}`;
+    }
+}
+exports.AbstractParser = AbstractParser;

package/lib/parsers/balancerV2VaultParser.d.ts

@@ -0,0 +1,8 @@
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class BalancerV2VaultParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: Address): string;
+}

package/lib/parsers/balancerV2VaultParser.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BalancerV2VaultParser = void 0;
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class BalancerV2VaultParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.abi = types_1.iBalancerV2VaultAdapterAbi;
+        if (!isContract)
+            this.adapterName = "BalancerV2Vault";
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "batchSwap": {
+                return `${functionName}(undefined)`;
+            }
+            case "swapDiff": {
+                const [{ leftoverAmount = 0, assetIn = "", assetOut = "" }] = functionData.args || [{}];
+                return `${functionName}(${this.tokenSymbol(assetIn)} => ${this.tokenSymbol(assetOut)} ${this.formatBN(leftoverAmount, this.tokenSymbol(assetIn))}}`;
+            }
+            case "swap": {
+                const [{ assetIn = "", assetOut = "", amount = 0 }] = functionData.args || [{}];
+                return `${functionName}(${this.tokenSymbol(assetIn)} => ${this.tokenSymbol(assetOut)} ${this.formatBN(amount, this.tokenSymbol(assetIn))}}`;
+            }
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+}
+exports.BalancerV2VaultParser = BalancerV2VaultParser;

package/lib/parsers/compoundV2CTokenAdapterParser.d.ts

@@ -0,0 +1,8 @@
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class CompoundV2CTokenAdapterParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: Address): string;
+}

package/lib/parsers/compoundV2CTokenAdapterParser.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompoundV2CTokenAdapterParser = void 0;
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class CompoundV2CTokenAdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.abi = types_1.iCompoundV2CTokenAdapterAbi;
+        if (!isContract)
+            this.adapterName = "CompoundV2_CTokenAdapter";
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+}
+exports.CompoundV2CTokenAdapterParser = CompoundV2CTokenAdapterParser;

package/lib/parsers/convexBaseRewardPoolAdapterParser.d.ts

@@ -0,0 +1,10 @@
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { BigNumberish } from "../utils/formatter";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class ConvexBaseRewardPoolAdapterParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: Address): string;
+    formatAmount(amount: BigNumberish): string;
+}

package/lib/parsers/convexBaseRewardPoolAdapterParser.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvexBaseRewardPoolAdapterParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class ConvexBaseRewardPoolAdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.abi = types_1.iConvexV1BaseRewardPoolAdapterAbi;
+        if (!isContract)
+            this.adapterName = "ConvexV1BaseRewardPoolAdapter";
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "stake": {
+                const [amount] = functionData.args || [];
+                return `${functionName}(amount: ${this.formatAmount(amount)})`;
+            }
+            case "stakeDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                return `${functionName}(leftoverAmount: ${this.formatAmount(leftoverAmount)})`;
+            }
+            case "withdraw":
+            case "withdrawAndUnwrap": {
+                const [amount, claim] = functionData.args || [];
+                return `${functionName}(amount: ${this.formatAmount(amount)}, claim: ${claim})`;
+            }
+            case "withdrawDiff":
+            case "withdrawDiffAndUnwrap": {
+                const [leftoverAmount, claim] = functionData.args || [];
+                return `${functionName}(leftoverAmount: ${this.formatAmount(leftoverAmount)}, claim: ${claim})`;
+            }
+            case "rewardRate":
+                return `${functionName}()`;
+            case "totalSupply":
+                return `${functionName}()`;
+            case "getReward":
+                return `${functionName}()`;
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+    formatAmount(amount) {
+        return this.formatBN(amount, sdk_gov_1.contractParams[this.contract]
+            .stakedToken);
+    }
+}
+exports.ConvexBaseRewardPoolAdapterParser = ConvexBaseRewardPoolAdapterParser;

package/lib/parsers/convexBoosterAdapterParser.d.ts

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

package/lib/parsers/convexBoosterAdapterParser.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvexBoosterAdapterParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class ConvexBoosterAdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.abi = types_1.iConvexV1BoosterAdapterAbi;
+        if (!isContract)
+            this.adapterName = "ConvexV1BoosterAdapter";
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "deposit": {
+                const [pid, amount, stake] = functionData.args || [];
+                return `${functionName}(pid: ${this.formatPid(pid)}, amount: ${this.formatAmount(amount, pid)}, stake: ${stake})`;
+            }
+            case "depositDiff": {
+                const [pid, leftoverAmount, stake] = functionData.args || [];
+                return `${functionName}(pid: ${this.formatPid(pid)}, leftoverAmount: ${this.formatAmount(leftoverAmount, pid)}, stake: ${stake})`;
+            }
+            case "withdraw": {
+                const [pid, amount] = functionData.args || [];
+                return `${functionName}(pid: ${this.formatPid(pid)}, amount: ${this.formatAmount(amount, pid)})`;
+            }
+            case "withdrawDiff": {
+                const [pid, leftoverAmount] = functionData.args || [];
+                return `${functionName}(pid: ${this.formatPid(pid)}, leftoverAmount: ${this.formatAmount(leftoverAmount, pid)})`;
+            }
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+    formatAmount(amount, pid) {
+        return this.formatBN(amount, sdk_gov_1.convexLpTokenByPid[pid]);
+    }
+    formatPid(pid) {
+        return `${pid} [${sdk_gov_1.convexPoolByPid[pid]}]`;
+    }
+}
+exports.ConvexBoosterAdapterParser = ConvexBoosterAdapterParser;

package/lib/parsers/convextRewardPoolParser.d.ts

@@ -0,0 +1,8 @@
+import { NormalToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class ConvexRewardPoolParser extends AbstractParser implements IParser {
+    constructor(token: NormalToken);
+    parse(calldata: Address): string;
+}

package/lib/parsers/convextRewardPoolParser.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConvexRewardPoolParser = void 0;
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class ConvexRewardPoolParser extends abstractParser_1.AbstractParser {
+    constructor(token) {
+        super(`ConvexRewardPool_${token}`);
+        this.abi = types_1.iBaseRewardPoolAbi;
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "rewardRate":
+                return `${functionName}()`;
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+}
+exports.ConvexRewardPoolParser = ConvexRewardPoolParser;

package/lib/parsers/creditFacadeParser.d.ts

@@ -0,0 +1,11 @@
+import { SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { BigNumberish } from "../utils/formatter";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class CreditFacadeParser extends AbstractParser implements IParser {
+    version: number;
+    constructor(token: SupportedToken, version: number);
+    parse(calldata: Address): string;
+    formatAmount(amount: BigNumberish): string;
+}

package/lib/parsers/creditFacadeParser.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreditFacadeParser = void 0;
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class CreditFacadeParser extends abstractParser_1.AbstractParser {
+    version;
+    constructor(token, version) {
+        super(token);
+        this.version = version;
+        this.abi =
+            version >= 300 ? types_1.iCreditFacadeV3MulticallAbi : types_1.iCreditFacadeV2ExtendedAbi;
+        this.adapterName = "CreditFacade";
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "addCollateral": {
+                const r = functionData.args || [];
+                const token = r[0];
+                const amount = r[1];
+                return `${functionName}(token: ${this.tokenSymbol(token)}, amount: ${this.formatBN(amount, this.tokenSymbol(token))})`;
+            }
+            case "increaseDebt":
+            case "decreaseDebt": {
+                const [amount] = functionData.args || [];
+                return `${functionName}(amount: ${this.formatAmount(amount)})`;
+            }
+            case "enableToken":
+            case "disableToken": {
+                const [address] = functionData.args || [];
+                return `${functionName}(token: ${this.tokenSymbol(address)})`;
+            }
+            case "updateQuota": {
+                const [address, quotaUpdate, minQuota] = functionData.args || [];
+                return `${functionName}(token: ${this.tokenSymbol(address)}, quotaUpdate: ${this.formatAmount(quotaUpdate)}, minQuota: ${this.formatAmount(minQuota)})`;
+            }
+            case "revertIfReceivedLessThan": {
+                const [balances] = functionData.args || [];
+                const balancesStr = balances
+                    .map(b => {
+                    const balance = "balance" in b ? b.balance : b.amount;
+                    const symbol = this.tokenSymbol(b.token);
+                    return `${symbol}: ${this.formatBN(balance, symbol)}`;
+                })
+                    .join(", ");
+                return `${functionName}(${balancesStr})`;
+            }
+            case "withdrawCollateral": {
+                const [token, amount, to] = functionData.args || [];
+                return `${functionName}(token: ${this.tokenSymbol(token)}, withdraw: ${this.formatBN(amount, this.tokenSymbol(token))}, to: ${to})`;
+            }
+            case "addCollateralWithPermit": {
+                const [tokenAddress, amount, deadline, v, r, s] = functionData.args || [];
+                return `${functionName}(token: ${this.tokenSymbol(tokenAddress)}, amount: ${this.formatBN(amount, this.tokenSymbol(tokenAddress))}, ${[deadline, v, r, s].join(", ")})`;
+            }
+            case "compareBalances": {
+                return `${functionName}()`;
+            }
+            case "setFullCheckParams": {
+                const [collateralHints, minHealthFactor] = functionData.args || [];
+                return `${functionName}(token: ${collateralHints
+                    .map((a) => this.formatAmount(a))
+                    .join(", ")}, minHealthFactor: ${minHealthFactor})`;
+            }
+            case "storeExpectedBalances": {
+                const [balanceDeltas] = functionData.args || [];
+                return `${functionName}(balanceDeltas: ${balanceDeltas
+                    .map((b) => `${this.tokenSymbol(b.token)}: ${this.formatBN(b.amount, this.tokenSymbol(b.token))}`)
+                    .join(", ")})`;
+            }
+            case "onDemandPriceUpdate": {
+                const [token, reserve, data] = functionData.args || [];
+                return `${functionName}(token: ${this.tokenOrTickerSymbol(token)}, reserve: ${reserve}, data: ${data})`;
+            }
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+    formatAmount(amount) {
+        return this.formatBN(amount, this.contract);
+    }
+}
+exports.CreditFacadeParser = CreditFacadeParser;

package/lib/parsers/creditManagerParser.d.ts

@@ -0,0 +1,7 @@
+import { Address } from "viem";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class CreditManagerParser extends AbstractParser implements IParser {
+    constructor(version: number);
+    parse(calldata: Address): string;
+}

package/lib/parsers/creditManagerParser.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreditManagerParser = void 0;
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class CreditManagerParser extends abstractParser_1.AbstractParser {
+    constructor(version) {
+        super(`CreditManager_V${version}`);
+        this.abi = version === 2 ? types_1.iCreditManagerV2Abi : types_1.iCreditManagerV3Abi;
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "creditConfigurator": {
+                return `${functionName}()`;
+            }
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+}
+exports.CreditManagerParser = CreditManagerParser;

package/lib/parsers/curveAdapterParser.d.ts

@@ -0,0 +1,13 @@
+import { SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { BigNumberish } from "../utils/formatter";
+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: Address): string;
+    getTokenByIndex(index: number): SupportedToken;
+    getUnderlyingTokenByIndex(index: number): SupportedToken;
+    convertAmounts(amounts: Array<BigNumberish>): string;
+}