@gearbox-protocol/sdk 3.0.0-next.13 → 3.0.0-next.130

package/lib/parsers/abstractParser.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractParser = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const ethers_1 = require("ethers");
-const formatter_1 = require("../utils/formatter");
 class AbstractParser {
     contract;
     ifc;
@@ -30,7 +29,7 @@ class AbstractParser {
         return symbol;
     }
     formatBN(amount, token) {
-        return `${(0, formatter_1.formatBN)(amount, sdk_gov_1.decimals[token])} [${(0, sdk_gov_1.toBigInt)(amount).toString()}]`;
+        return `${(0, sdk_gov_1.formatBN)(amount, sdk_gov_1.decimals[token])} [${(0, sdk_gov_1.toBigInt)(amount).toString()}]`;
     }
     parseToObject(address, calldata) {
         const { functionFragment } = this.parseSelector(calldata);
@@ -41,5 +40,8 @@ class AbstractParser {
             args,
         };
     }
+    reportUnknownFragment(functionName, functionFragment, calldata) {
+        return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+    }
 }
 exports.AbstractParser = AbstractParser;

package/lib/parsers/addressProviderParser.js

@@ -20,7 +20,7 @@ class AddressProviderParser extends abstractParser_1.AbstractParser {
                 return `${functionName}()`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
 }

package/lib/parsers/balancerV2VaultParser.d.ts

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

package/lib/parsers/balancerV2VaultParser.js

@@ -0,0 +1,34 @@
+"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.ifc = types_1.IBalancerV2VaultAdapter__factory.createInterface();
+        if (!isContract)
+            this.adapterName = "BalancerV2Vault";
+    }
+    parse(calldata) {
+        const { functionFragment, functionName } = this.parseSelector(calldata);
+        switch (functionFragment.name) {
+            case "batchSwap": {
+                return `${functionName}(undefined)`;
+            }
+            case "swapDiff": {
+                const d = this.decodeFunctionData(functionFragment, calldata);
+                const { assetIn = "", assetOut = "", leftoverAmount = 0, } = (d?.[0] || {});
+                return `${functionName}(${this.tokenSymbol(assetIn)} => ${this.tokenSymbol(assetOut)} ${this.formatBN(leftoverAmount, this.tokenSymbol(assetIn))}}`;
+            }
+            case "swap": {
+                const d = this.decodeFunctionData(functionFragment, calldata);
+                const { assetIn = "", assetOut = "", amount = 0, } = (d?.[0] || {});
+                return `${functionName}(${this.tokenSymbol(assetIn)} => ${this.tokenSymbol(assetOut)} ${this.formatBN(amount, this.tokenSymbol(assetIn))}}`;
+            }
+            default:
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
+        }
+    }
+}
+exports.BalancerV2VaultParser = BalancerV2VaultParser;

package/lib/parsers/compoundV2CTokenAdapterParser.d.ts

@@ -0,0 +1,7 @@
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class CompoundV2CTokenAdapterParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: string): 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.ifc = types_1.ICompoundV2_CTokenAdapter__factory.createInterface();
+        if (!isContract)
+            this.adapterName = "CompoundV2_CTokenAdapter";
+    }
+    parse(calldata) {
+        const { functionFragment, functionName } = this.parseSelector(calldata);
+        switch (functionFragment.name) {
+            default:
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
+        }
+    }
+}
+exports.CompoundV2CTokenAdapterParser = CompoundV2CTokenAdapterParser;

package/lib/parsers/convexBaseRewardPoolAdapterParser.js

@@ -14,28 +14,32 @@ class ConvexBaseRewardPoolAdapterParser extends abstractParser_1.AbstractParser
     parse(calldata) {
         const { functionFragment, functionName } = this.parseSelector(calldata);
         switch (functionFragment.name) {
-            case "stake":
-            case "stakeAll": {
+            case "stake": {
                 const [amount] = this.decodeFunctionData(functionFragment, calldata);
-                const amountStr = amount ? `amount: ${this.formatAmount(amount)}` : "";
-                return `${functionName}(${amountStr})`;
+                return `${functionName}(amount: ${this.formatAmount(amount)})`;
+            }
+            case "stakeDiff": {
+                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(leftoverAmount: ${this.formatAmount(leftoverAmount)})`;
             }
             case "withdraw":
             case "withdrawAndUnwrap": {
                 const [amount, claim] = this.decodeFunctionData(functionFragment, calldata);
                 return `${functionName}(amount: ${this.formatAmount(amount)}, claim: ${claim})`;
             }
-            case "withdrawAll":
-            case "withdrawAllAndUnwrap": {
-                const [claim] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(claim: ${claim})`;
+            case "withdrawDiff":
+            case "withdrawDiffAndUnwrap": {
+                const [leftoverAmount, claim] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(leftoverAmount: ${this.formatAmount(leftoverAmount)}, claim: ${claim})`;
             }
             case "rewardRate":
                 return `${functionName}()`;
             case "totalSupply":
                 return `${functionName}()`;
+            case "getReward":
+                return `${functionName}()`;
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
     formatAmount(amount) {

package/lib/parsers/convexBaseRewardPoolAdapterParser.spec.js

@@ -10,15 +10,18 @@ describe("ConvexV1BaseRewardPoolAdapterParser test", () => {
         const ifc = types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface();
         let parsed = parser.parse(ifc.encodeFunctionData("stake", [(sdk_gov_1.WAD * 199n) / 10n]));
         (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("stakeDiff", [(sdk_gov_1.WAD * 199n) / 10n]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].stakeDiff(leftoverAmount: 19.90 [19900000000000000000])", "Incorrect parse stakeDiff");
         parsed = parser.parse(ifc.encodeFunctionData("withdraw", [(sdk_gov_1.WAD * 199n) / 1000n, 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", [(sdk_gov_1.WAD * 2n) / 1000n, 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");
+        parsed = parser.parse(ifc.encodeFunctionData("withdrawDiff", [(sdk_gov_1.WAD * 2n) / 1000n, false]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].withdrawDiff(leftoverAmount: 0.002 [2000000000000000], claim: false)", "Incorrect parse withdrawDiff");
+        parsed = parser.parse(ifc.encodeFunctionData("withdrawDiffAndUnwrap", [
+            (sdk_gov_1.WAD * 2n) / 1000n,
+            true,
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BaseRewardPoolAdapter[CONVEX_FRAX3CRV_POOL].withdrawDiffAndUnwrap(leftoverAmount: 0.002 [2000000000000000], claim: true)", "Incorrect parse withdrawDiffAndUnwrap");
     });
 });

package/lib/parsers/convexBoosterAdapterParser.js

@@ -18,20 +18,20 @@ class ConvexBoosterAdapterParser extends abstractParser_1.AbstractParser {
                 const [pid, amount, stake] = this.decodeFunctionData(functionFragment, calldata);
                 return `${functionName}(pid: ${this.formatPid(pid)}, amount: ${this.formatAmount(amount, pid)}, stake: ${stake})`;
             }
-            case "depositAll": {
-                const [pid, stake] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(pid: ${this.formatPid(pid)}, stake: ${stake})`;
+            case "depositDiff": {
+                const [pid, leftoverAmount, stake] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(pid: ${this.formatPid(pid)}, leftoverAmount: ${this.formatAmount(leftoverAmount, pid)}, stake: ${stake})`;
             }
             case "withdraw": {
                 const [pid, amount] = this.decodeFunctionData(functionFragment, calldata);
                 return `${functionName}(pid: ${this.formatPid(pid)}, amount: ${this.formatAmount(amount, pid)})`;
             }
-            case "withdrawAll": {
-                const [pid] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(pid: ${this.formatPid(pid)})`;
+            case "withdrawDiff": {
+                const [pid, leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(pid: ${this.formatPid(pid)}, leftoverAmount: ${this.formatAmount(leftoverAmount, pid)})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
     formatAmount(amount, pid) {

package/lib/parsers/convexBoosterAdapterParser.spec.js

@@ -10,11 +10,11 @@ describe("ConvexV1BaseRewardPoolAdapterParser test", () => {
         const ifc = types_1.IConvexV1BoosterAdapter__factory.createInterface();
         let parsed = parser.parse(ifc.encodeFunctionData("deposit", [9, sdk_gov_1.WAD * 19999n, 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("depositDiff", [32, sdk_gov_1.WAD * 19999n, true]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BoosterAdapter[CONVEX_BOOSTER].depositDiff(pid: 32 [CONVEX_FRAX3CRV_POOL], leftoverAmount: 19.99K [19999000000000000000000], stake: true)", "Incorrect parse depositDiff");
         parsed = parser.parse(ifc.encodeFunctionData("withdraw", [9, (sdk_gov_1.WAD * 555n) / 10n]));
         (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");
+        parsed = parser.parse(ifc.encodeFunctionData("withdrawDiff", [32, (sdk_gov_1.WAD * 555n) / 10n]));
+        (0, chai_1.expect)(parsed).to.be.eq("ConvexV1BoosterAdapter[CONVEX_BOOSTER].withdrawDiff(pid: 32 [CONVEX_FRAX3CRV_POOL], leftoverAmount: 55.50 [55500000000000000000])", "Incorrect parse withdrawDiff");
     });
 });

package/lib/parsers/convextRewardPoolParser.js

@@ -14,7 +14,7 @@ class ConvexRewardPoolParser extends abstractParser_1.AbstractParser {
             case "rewardRate":
                 return `${functionName}()`;
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
 }

package/lib/parsers/creditFacadeParser.js

@@ -19,10 +19,9 @@ class CreditFacadeParser extends abstractParser_1.AbstractParser {
         switch (functionFragment.name) {
             case "addCollateral": {
                 const r = this.decodeFunctionData(functionFragment, calldata);
-                const onBehalf = this.version === 300 ? "none" : r[0];
-                const token = this.version === 300 ? r[0] : r[1];
-                const amount = this.version === 300 ? r[1] : r[2];
-                return `${functionName}(onBehalf: ${onBehalf}, token: ${this.tokenSymbol(token)}, amount: ${this.formatAmount(amount)})`;
+                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": {
@@ -42,14 +41,42 @@ class CreditFacadeParser extends abstractParser_1.AbstractParser {
                 const [balances] = this.decodeFunctionData(functionFragment, calldata);
                 const balancesStr = balances
                     .map(b => {
+                    const balance = "balance" in b ? b.balance : b.amount;
                     const symbol = this.tokenSymbol(b.token);
-                    return `${symbol}: ${this.formatBN(b.balance, symbol)}`;
+                    return `${symbol}: ${this.formatBN(balance, symbol)}`;
                 })
                     .join(", ");
                 return `${functionName}(${balancesStr})`;
             }
+            case "withdrawCollateral": {
+                const [token, amount, to] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(token: ${this.tokenSymbol(token)}, withdraw: ${this.formatBN(amount, this.tokenSymbol(token))}, to: ${to})`;
+            }
+            case "addCollateralWithPermit": {
+                const [tokenAddress, amount, deadline, v, r, s] = this.decodeFunctionData(functionFragment, calldata);
+                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] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(token: ${collateralHints
+                    .map((a) => this.formatAmount(a))
+                    .join(", ")}, minHealthFactor: ${minHealthFactor})`;
+            }
+            case "storeExpectedBalances": {
+                const [balanceDeltas] = this.decodeFunctionData(functionFragment, calldata);
+                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] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(token: ${this.tokenSymbol(token)}, reserve: ${reserve}, data: ${data})`;
+            }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
     formatAmount(amount) {

package/lib/parsers/creditFacadeParser.spec.js

@@ -9,11 +9,10 @@ describe("CreditFacadeParser test", () => {
         let parser = new creditFacadeParser_1.CreditFacadeParser("DAI", 1);
         const ifc = types_1.ICreditFacadeV2Extended__factory.createInterface();
         let parsed = parser.parse(ifc.encodeFunctionData("addCollateral", [
-            sdk_gov_1.DUMB_ADDRESS,
             sdk_gov_1.tokenDataByNetwork.Mainnet.WBTC,
-            (sdk_gov_1.WAD * 444n) / 10n,
+            (10n ** (0, sdk_gov_1.toBigInt)(sdk_gov_1.decimals.WBTC) * 444n) / 10n,
         ]));
-        (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].addCollateral(onBehalf: 0xC4375B7De8af5a38a93548eb8453a498222C4fF2, token: WBTC, amount: 44.40 [44400000000000000000])", "Incorrect parse addCollateral");
+        (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].addCollateral(token: WBTC, amount: 44.40 [4440000000])", "Incorrect parse addCollateral");
         parsed = parser.parse(ifc.encodeFunctionData("increaseDebt", [(sdk_gov_1.WAD * 414n) / 10n]));
         (0, chai_1.expect)(parsed).to.be.eq("CreditFacade[DAI].increaseDebt(amount: 41.40 [41400000000000000000])", "Incorrect parse increaseDebt");
         parsed = parser.parse(ifc.encodeFunctionData("decreaseDebt", [(sdk_gov_1.WAD * 334n) / 10n]));

package/lib/parsers/creditManagerParser.js

@@ -18,7 +18,7 @@ class CreditManagerParser extends abstractParser_1.AbstractParser {
                 return `${functionName}()`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
 }

package/lib/parsers/curveAdapterParser.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CurveAdapterParser = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
 const abstractParser_1 = require("./abstractParser");
 class CurveAdapterParser extends abstractParser_1.AbstractParser {
     lpToken;
@@ -45,26 +44,26 @@ class CurveAdapterParser extends abstractParser_1.AbstractParser {
                     : this.getTokenByIndex(j);
                 return `${functionName}(i ,j: ${iSym} => ${jSym}, dx: ${this.formatBN(dx, iSym)}, min_dy: ${this.formatBN(min_dy, jSym)})`;
             }
-            case "exchange_all":
-            case "exchange_all_underlying": {
-                const [i, j, rateMinRAY] = this.decodeFunctionData(functionFragment, calldata);
-                const iSym = functionFragment.name === "exchange_all_underlying"
+            case "exchange_diff":
+            case "exchange_diff_underlying": {
+                const [i, j, leftoverAmount, rateMinRAY] = this.decodeFunctionData(functionFragment, calldata);
+                const iSym = functionFragment.name === "exchange_diff_underlying"
                     ? this.getUnderlyingTokenByIndex(i)
                     : this.getTokenByIndex(i);
-                const jSym = functionFragment.name === "exchange_all_underlying"
+                const jSym = functionFragment.name === "exchange_diff_underlying"
                     ? this.getUnderlyingTokenByIndex(j)
                     : this.getTokenByIndex(j);
-                return `${functionName}(i: ${iSym}, j: ${jSym}, rateMinRAY: ${(0, formatter_1.formatBN)(rateMinRAY, 27)}`;
+                return `${functionName}(i: ${iSym}, j: ${jSym}, leftoverAmount: ${this.formatBN(leftoverAmount, iSym)}, rateMinRAY: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)}`;
             }
             case "add_liquidity_one_coin": {
                 const [amount, i, minAmount] = this.decodeFunctionData(functionFragment, calldata);
                 const iSym = this.getTokenByIndex(i);
                 return `${functionName}(amount: ${this.formatBN(amount, iSym)}, i: ${iSym}, minAmount: ${this.formatBN(minAmount, this.lpToken)})`;
             }
-            case "add_all_liquidity_one_coin":
-            case "remove_all_liquidity_one_coin": {
-                const [i, rateMinRAY] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(i: ${this.getTokenByIndex(i)}, rateMinRAY: ${(0, formatter_1.formatBN)(rateMinRAY, 27)})`;
+            case "add_diff_liquidity_one_coin":
+            case "remove_diff_liquidity_one_coin": {
+                const [leftoverAmount, i, rateMinRAY] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, i)}, i: ${this.getTokenByIndex(i)}, rateMinRAY: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)})`;
             }
             case "add_liquidity": {
                 const [amounts, minAmount] = this.decodeFunctionData(functionFragment, calldata);
@@ -102,7 +101,7 @@ class CurveAdapterParser extends abstractParser_1.AbstractParser {
                 return `${functionName}(account: ${account}, to: ${to})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
     getTokenByIndex(index) {

package/lib/parsers/curveAdapterParser.spec.js

@@ -19,8 +19,12 @@ describe("CurveAdapterParser test", () => {
         (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].exchange_underlying(i ,j: FRAX => DAI, dx: 3.00 [3000000000000000000], min_dy: 32.00 [32000000000000000000])", "Curve2AssetsAdapter: Incorrect parse exchange_underlying");
         parsed = parser.parse(ifc.encodeFunctionData("add_liquidity_one_coin", [sdk_gov_1.WAD * 3n, 0, sdk_gov_1.WAD * 2n]));
         (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, sdk_gov_1.RAY * 912n]));
-        (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("add_diff_liquidity_one_coin", [
+            sdk_gov_1.WAD * 3n,
+            0,
+            sdk_gov_1.RAY * 912n,
+        ]));
+        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].add_diff_liquidity_one_coin(leftoverAmount: 3.00 [3000000000000000000], i: FRAX, rateMinRAY: 912.00)", "Curve2AssetsAdapter: Incorrect parse add_diff_liquidity_one_coin");
         parsed = parser.parse(ifc.encodeFunctionData("remove_liquidity_one_coin(uint256,uint256,uint256)", [sdk_gov_1.WAD * 100n, 0, sdk_gov_1.WAD * 10n]));
         (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].remove_liquidity_one_coin(amount: 100.00 [100000000000000000000],i: FRAX, min_amount: 10.00 [10000000000000000000])", "Curve2AssetsAdapter: Incorrect parse remove_liquidity_one_coin");
         parsed = parser.parse(ifc.encodeFunctionData("add_liquidity", [

package/lib/parsers/erc626AdapterParser.d.ts

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

package/lib/parsers/erc626AdapterParser.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC4626AdapterParser = void 0;
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class ERC4626AdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.ifc = types_1.IERC4626Adapter__factory.createInterface();
+        if (!isContract)
+            this.adapterName = "ERC4626Adapter";
+    }
+    parse(calldata) {
+        const { functionFragment, functionName } = this.parseSelector(calldata);
+        switch (functionFragment.name) {
+            default:
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
+        }
+    }
+}
+exports.ERC4626AdapterParser = ERC4626AdapterParser;

package/lib/parsers/lidoAdapterParser.js

@@ -17,11 +17,12 @@ class LidoAdapterParser extends abstractParser_1.AbstractParser {
                 const [amount] = this.decodeFunctionData(functionFragment, calldata);
                 return `${functionName}(amount: ${this.formatBN(amount, "STETH")})`;
             }
-            case "submitAll": {
-                return `${functionName}()`;
+            case "submitDiff": {
+                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
 }

package/lib/parsers/lidoAdapterParser.spec.js

@@ -11,7 +11,7 @@ describe("LidoAdapterParser test", () => {
         let parsed = parser.parse(ifc.encodeFunctionData("submit", [sdk_gov_1.WAD * 1020n]));
         (0, chai_1.expect)(parsed).to.be.eq("LidoV1Adapter[LIDO_STETH_GATEWAY].submit(amount: 1.02K [1020000000000000000000])", "Incorrect parse submit(amount)");
         parser = new lidoAdapterParser_1.LidoAdapterParser("LIDO_STETH_GATEWAY", true);
-        parsed = parser.parse(ifc.encodeFunctionData("submitAll"));
-        (0, chai_1.expect)(parsed).to.be.eq("Contract[LIDO_STETH_GATEWAY].submitAll()", "Incorrect parse submitAll()");
+        parsed = parser.parse(ifc.encodeFunctionData("submitDiff", [sdk_gov_1.WAD * 1020n]));
+        (0, chai_1.expect)(parsed).to.be.eq("Contract[LIDO_STETH_GATEWAY].submitDiff(leftoverAmount: 1.02K [1020000000000000000000])", "Incorrect parse submitDiff(leftoverAmount)");
     });
 });

package/lib/parsers/lidoSTETHParser.js

@@ -29,7 +29,7 @@ class LidoSTETHParser extends abstractParser_1.AbstractParser {
                 return `${functionName}(${spender}, [${(0, sdk_gov_1.toBigInt)(amount).toString()}])`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
 }

package/lib/parsers/poolParser.js

@@ -12,7 +12,7 @@ class PoolParser extends abstractParser_1.AbstractParser {
         const { functionFragment, functionName } = this.parseSelector(calldata);
         switch (functionFragment.name) {
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
 }

package/lib/parsers/priceOracleParser.js

@@ -16,7 +16,7 @@ class PriceOracleParser extends abstractParser_1.AbstractParser {
                 return `${functionName}(${this.tokenSymbol(token)})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
 }

package/lib/parsers/txParser.d.ts

@@ -12,19 +12,25 @@ interface ParseData {
 }
 export declare class TxParser {
     protected static parsers: Record<string, IParser & AbstractParser>;
-    static parse(address: string, calldata: string): string;
+    static parse(address: string, calldata: string): string | null;
     static parseToObject(address: string, calldata: string): {
-        address: string;
-        functionFragment: import("ethers/lib/utils").FunctionFragment;
-        args: any;
-    };
+        callObject: {
+            address: string;
+            functionFragment: import("ethers/lib/utils").FunctionFragment;
+            args: any;
+        };
+        parser: IParser & AbstractParser;
+    } | null;
     static getParseData(address: string): ParseData;
-    static parseMultiCall(calls: Array<MultiCall>): Array<string>;
-    static parseToObjectMultiCall(calls: Array<MultiCall>): {
-        address: string;
-        functionFragment: import("ethers/lib/utils").FunctionFragment;
-        args: any;
-    }[];
+    static parseMultiCall(calls: Array<MultiCall>): (string | null)[];
+    static parseToObjectMultiCall(calls: Array<MultiCall>): ({
+        callObject: {
+            address: string;
+            functionFragment: import("ethers/lib/utils").FunctionFragment;
+            args: any;
+        };
+        parser: IParser & AbstractParser;
+    } | null)[];
     static addAdapters(adapters: Array<AdapterForParser>): void;
     static addContracts(network: NetworkType): void;
     static addCreditFacade(creditFacade: string, underlying: SupportedToken, version: number): void;

package/lib/parsers/txParser.js

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxParser = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const aaveV2LendingPoolAdapterParser_1 = require("./aaveV2LendingPoolAdapterParser");
+const aaveV2WrappedATokenAdapterParser_1 = require("./aaveV2WrappedATokenAdapterParser");
 const addressProviderParser_1 = require("./addressProviderParser");
+const balancerV2VaultParser_1 = require("./balancerV2VaultParser");
+const compoundV2CTokenAdapterParser_1 = require("./compoundV2CTokenAdapterParser");
 const convexBaseRewardPoolAdapterParser_1 = require("./convexBaseRewardPoolAdapterParser");
 const convexBoosterAdapterParser_1 = require("./convexBoosterAdapterParser");
 const convextRewardPoolParser_1 = require("./convextRewardPoolParser");
@@ -10,6 +14,7 @@ const creditFacadeParser_1 = require("./creditFacadeParser");
 const creditManagerParser_1 = require("./creditManagerParser");
 const curveAdapterParser_1 = require("./curveAdapterParser");
 const ERC20Parser_1 = require("./ERC20Parser");
+const erc626AdapterParser_1 = require("./erc626AdapterParser");
 const lidoAdapterParser_1 = require("./lidoAdapterParser");
 const lidoSTETHParser_1 = require("./lidoSTETHParser");
 const poolParser_1 = require("./poolParser");
@@ -21,12 +26,28 @@ const yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
 class TxParser {
     static parsers = {};
     static parse(address, calldata) {
-        const parser = TxParser.getParser(address);
-        return parser.parse(calldata);
+        let parser;
+        try {
+            parser = TxParser.getParser(address);
+            const callStr = parser.parse(calldata);
+            return callStr;
+        }
+        catch (e) {
+            console.error(`Error while parsing ${address}`, parser, e);
+            return null;
+        }
     }
     static parseToObject(address, calldata) {
-        const parser = TxParser.getParser(address);
-        return parser.parseToObject(address, calldata);
+        let parser;
+        try {
+            parser = TxParser.getParser(address);
+            const callObject = parser.parseToObject(address, calldata);
+            return { callObject, parser };
+        }
+        catch (e) {
+            console.error(`Error while parsing ${address}`, parser, e);
+            return null;
+        }
     }
     static getParseData(address) {
         const parser = TxParser.getParser(address);
@@ -132,6 +153,22 @@ class TxParser {
             case "LIDO_WSTETH_V1":
                 TxParser._addParser(addressLC, new wstETHAdapterParser_1.WstETHAdapterParser(contract, isContract));
                 break;
+            case "AAVE_V2_LENDING_POOL":
+                TxParser._addParser(addressLC, new aaveV2LendingPoolAdapterParser_1.AaveV2LendingPoolAdapterParser(contract, isContract));
+                break;
+            case "AAVE_V2_WRAPPED_ATOKEN":
+                TxParser._addParser(addressLC, new aaveV2WrappedATokenAdapterParser_1.AaveV2WrappedATokenAdapterParser(contract, isContract));
+                break;
+            case "BALANCER_VAULT":
+                TxParser._addParser(addressLC, new balancerV2VaultParser_1.BalancerV2VaultParser(contract, isContract));
+                break;
+            case "COMPOUND_V2_CERC20":
+            case "COMPOUND_V2_CETHER":
+                TxParser._addParser(addressLC, new compoundV2CTokenAdapterParser_1.CompoundV2CTokenAdapterParser(contract, isContract));
+                break;
+            case "ERC4626_VAULT":
+                TxParser._addParser(addressLC, new erc626AdapterParser_1.ERC4626AdapterParser(contract, isContract));
+                break;
         }
     }
     static _addParser(address, parser) {