@gearbox-protocol/sdk 3.0.0-next.2 → 3.0.0-next.200

package/lib/parsers/creditFacadeParser.js

@@ -4,17 +4,24 @@ exports.CreditFacadeParser = void 0;
 const types_1 = require("../types");
 const abstractParser_1 = require("./abstractParser");
 class CreditFacadeParser extends abstractParser_1.AbstractParser {
-    constructor(token) {
+    version;
+    constructor(token, version) {
         super(token);
-        this.ifc = types_1.ICreditFacadeExtended__factory.createInterface();
+        this.version = version;
+        this.ifc =
+            version >= 300
+                ? types_1.ICreditFacadeV3Multicall__factory.createInterface()
+                : types_1.ICreditFacadeV2Extended__factory.createInterface();
         this.adapterName = "CreditFacade";
     }
     parse(calldata) {
         const { functionFragment, functionName } = this.parseSelector(calldata);
         switch (functionFragment.name) {
             case "addCollateral": {
-                const [onBehalf, token, amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(onBehalf: ${onBehalf}, token: ${this.tokenSymbol(token)}, amount: ${this.formatAmount(amount)})`;
+                const r = this.decodeFunctionData(functionFragment, calldata);
+                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": {
@@ -26,18 +33,50 @@ class CreditFacadeParser extends abstractParser_1.AbstractParser {
                 const [address] = this.decodeFunctionData(functionFragment, calldata);
                 return `${functionName}(token: ${this.tokenSymbol(address)})`;
             }
+            case "updateQuota": {
+                const [address, quotaUpdate, minQuota] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(token: ${this.tokenSymbol(address)}, quotaUpdate: ${this.formatAmount(quotaUpdate)}, minQuota: ${this.formatAmount(minQuota)})`;
+            }
             case "revertIfReceivedLessThan": {
                 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.tokenOrTickerSymbol(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

@@ -6,14 +6,13 @@ const types_1 = require("../types");
 const creditFacadeParser_1 = require("./creditFacadeParser");
 describe("CreditFacadeParser test", () => {
     it("all functions works well", () => {
-        let parser = new creditFacadeParser_1.CreditFacadeParser("DAI");
-        const ifc = types_1.ICreditFacadeExtended__factory.createInterface();
+        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

@@ -7,9 +7,9 @@ class CreditManagerParser extends abstractParser_1.AbstractParser {
     constructor(version) {
         super(`CreditManager_V${version}`);
         this.ifc =
-            version === 1
-                ? types_1.ICreditManager__factory.createInterface()
-                : types_1.ICreditManagerV2__factory.createInterface();
+            version === 2
+                ? types_1.ICreditManagerV2__factory.createInterface()
+                : types_1.ICreditManagerV3__factory.createInterface();
     }
     parse(calldata) {
         const { functionFragment, functionName } = this.parseSelector(calldata);
@@ -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);
@@ -78,6 +77,11 @@ class CurveAdapterParser extends abstractParser_1.AbstractParser {
                 const [amounts, maxBurnAmount] = this.decodeFunctionData(functionFragment, calldata);
                 return `${functionName}(amounts: [${this.convertAmounts(amounts)}], max_burn_amount: ${this.formatBN(maxBurnAmount, this.lpToken)})`;
             }
+            case "remove_liquidity_one_coin": {
+                const [amount, i, min_amount] = this.decodeFunctionData(functionFragment, calldata);
+                const iSym = this.getTokenByIndex(i);
+                return `${functionName}(amount: ${this.formatBN(amount, this.lpToken)},i: ${iSym}, min_amount: ${this.formatBN(min_amount, iSym)})`;
+            }
             case "totalSupply": {
                 return `${functionName}()`;
             }
@@ -97,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

@@ -8,21 +8,25 @@ describe("CurveAdapterParser test", () => {
     it("stake / withdraw functions works well", () => {
         let parser = new curveAdapterParser_1.CurveAdapterParser("CURVE_FRAX_POOL", false);
         const ifc = types_1.ICurveV1_2AssetsAdapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("exchange", [0, 1, sdk_gov_1.WAD * 3n, sdk_gov_1.WAD * 32n]));
-        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].exchange(i ,j: FRAX => 3Crv, dx: 3.00 [3000000000000000000], min_dy: 32.00 [32000000000000000000])", "Curve2AssetsAdapter: Incorrect parse exchange");
-        parsed = parser.parse(ifc.encodeFunctionData("exchange_underlying", [
+        let parsed = parser.parse(ifc.encodeFunctionData("exchange(uint256,uint256,uint256,uint256)", [
             0,
             1,
             sdk_gov_1.WAD * 3n,
             sdk_gov_1.WAD * 32n,
         ]));
+        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].exchange(i ,j: FRAX => 3Crv, dx: 3.00 [3000000000000000000], min_dy: 32.00 [32000000000000000000])", "Curve2AssetsAdapter: Incorrect parse exchange");
+        parsed = parser.parse(ifc.encodeFunctionData("exchange_underlying(int128,int128,uint256,uint256)", [0, 1, sdk_gov_1.WAD * 3n, sdk_gov_1.WAD * 32n]));
         (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("remove_all_liquidity_one_coin", [0, sdk_gov_1.RAY * 721n]));
-        (0, chai_1.expect)(parsed).to.be.eq("Curve2AssetsAdapter[CURVE_FRAX_POOL].remove_all_liquidity_one_coin(i: FRAX, rateMinRAY: 721.00)", "Curve2AssetsAdapter: Incorrect parse remove_all_liquidity_one_coin");
+        parsed = parser.parse(ifc.encodeFunctionData("add_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", [
             [sdk_gov_1.WAD * 100n, sdk_gov_1.WAD * 100n],
             sdk_gov_1.WAD * 80n,

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/iParser.d.ts

@@ -1,4 +1,4 @@
-import { FunctionFragment } from "ethers/lib/utils";
+import { FunctionFragment } from "ethers";
 export interface IParser {
     parse: (calldata: string) => string;
     parseToObject?: (address: string, calldata: string) => {

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LidoSTETHParser = 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 LidoSTETHParser extends abstractParser_1.AbstractParser {
     constructor(symbol) {
@@ -26,10 +26,10 @@ class LidoSTETHParser extends abstractParser_1.AbstractParser {
             }
             case "approve": {
                 const [spender, amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(${spender}, [${(0, formatter_1.toBigInt)(amount).toString()}])`;
+                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

@@ -6,13 +6,13 @@ const abstractParser_1 = require("./abstractParser");
 class PoolParser extends abstractParser_1.AbstractParser {
     constructor(version) {
         super(`Pool_V${version}`);
-        this.ifc = types_1.PoolService__factory.createInterface();
+        this.ifc = types_1.IPoolService__factory.createInterface();
     }
     parse(calldata) {
         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

@@ -6,7 +6,7 @@ const abstractParser_1 = require("./abstractParser");
 class PriceOracleParser extends abstractParser_1.AbstractParser {
     constructor() {
         super("PriceOracle");
-        this.ifc = types_1.IPriceOracleV2__factory.createInterface();
+        this.ifc = types_1.IPriceOracleBase__factory.createInterface();
     }
     parse(calldata) {
         const { functionFragment, functionName } = this.parseSelector(calldata);
@@ -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

@@ -1,5 +1,5 @@
 import { NetworkType, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
-import { MultiCallStruct } from "../types/@gearbox-protocol/router/contracts/interfaces/IClosePathResolver";
+import { MultiCall } from "../pathfinder/core";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export interface AdapterForParser {
@@ -12,29 +12,31 @@ 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("@ethersproject/abi").FunctionFragment;
-        args: any;
-    };
+        callObject: {
+            address: string;
+            functionFragment: import("ethers").FunctionFragment;
+            args: any;
+        };
+        parser: IParser & AbstractParser;
+    } | null;
     static getParseData(address: string): ParseData;
-    static parseMultiCall(calls: Array<MultiCallStruct>): Array<string>;
-    static parseToObjectMultiCall(calls: Array<MultiCallStruct>): {
-        address: string;
-        functionFragment: import("@ethersproject/abi").FunctionFragment;
-        args: any;
-    }[];
+    static parseMultiCall(calls: Array<MultiCall>): (string | null)[];
+    static parseToObjectMultiCall(calls: Array<MultiCall>): ({
+        callObject: {
+            address: string;
+            functionFragment: import("ethers").FunctionFragment;
+            args: any;
+        };
+        parser: IParser & AbstractParser;
+    } | null)[];
     static addAdapters(adapters: Array<AdapterForParser>): void;
     static addContracts(network: NetworkType): void;
-    static addCreditFacade(creditFacade: string, underlying: SupportedToken): void;
+    static addCreditFacade(creditFacade: string, underlying: SupportedToken, version: number): void;
     static addTokens(network: NetworkType): void;
-    static addOffchainOracleParser(address: string): void;
     static addPriceOracle(address: string): void;
-    static addDataCompressor(address: string): void;
     static addAddressProvider(address: string): void;
-    static addMulticall(address: string): void;
-    static addAirdropDistributor(address: string): void;
     static addCreditManager(address: string, version: number): void;
     static addPool(address: string, version: number): void;
     static getParser(address: string): IParser & AbstractParser;

package/lib/parsers/txParser.js

@@ -2,21 +2,21 @@
 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 airdropDistributorParser_1 = require("./airdropDistributorParser");
+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");
 const creditFacadeParser_1 = require("./creditFacadeParser");
 const creditManagerParser_1 = require("./creditManagerParser");
 const curveAdapterParser_1 = require("./curveAdapterParser");
-const dataCompressorParser_1 = require("./dataCompressorParser");
 const ERC20Parser_1 = require("./ERC20Parser");
+const erc626AdapterParser_1 = require("./erc626AdapterParser");
 const lidoAdapterParser_1 = require("./lidoAdapterParser");
-const lidoOracleParser_1 = require("./lidoOracleParser");
 const lidoSTETHParser_1 = require("./lidoSTETHParser");
-const multicallParser_1 = require("./multicallParser");
-const offchainOracleParser_1 = require("./offchainOracleParser");
 const poolParser_1 = require("./poolParser");
 const priceOracleParser_1 = require("./priceOracleParser");
 const uniV2AdapterParser_1 = require("./uniV2AdapterParser");
@@ -26,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);
@@ -64,14 +80,10 @@ class TxParser {
                     TxParser._addParser(extraAddress, new convextRewardPoolParser_1.ConvexRewardPoolParser(r.rewardToken));
                 });
             }
-            if (contractData.type === sdk_gov_1.AdapterInterface.LIDO_V1) {
-                const extraAddress = contractData.oracle[network];
-                TxParser._addParser(extraAddress, new lidoOracleParser_1.LidoOracleParser());
-            }
         });
     }
-    static addCreditFacade(creditFacade, underlying) {
-        TxParser._addParser(creditFacade, new creditFacadeParser_1.CreditFacadeParser(underlying));
+    static addCreditFacade(creditFacade, underlying, version) {
+        TxParser._addParser(creditFacade, new creditFacadeParser_1.CreditFacadeParser(underlying, version));
     }
     static addTokens(network) {
         sdk_gov_1.TypedObjectUtils.entries(sdk_gov_1.tokenDataByNetwork[network]).forEach(([s, t]) => {
@@ -89,24 +101,12 @@ class TxParser {
             }
         });
     }
-    static addOffchainOracleParser(address) {
-        TxParser._addParser(address, new offchainOracleParser_1.OffchainOracleParserParser());
-    }
     static addPriceOracle(address) {
         TxParser._addParser(address, new priceOracleParser_1.PriceOracleParser());
     }
-    static addDataCompressor(address) {
-        TxParser._addParser(address, new dataCompressorParser_1.DataCompressorParser());
-    }
     static addAddressProvider(address) {
         TxParser._addParser(address, new addressProviderParser_1.AddressProviderParser());
     }
-    static addMulticall(address) {
-        TxParser._addParser(address, new multicallParser_1.MulticallParser());
-    }
-    static addAirdropDistributor(address) {
-        TxParser._addParser(address, new airdropDistributorParser_1.AirdropDistributorParser());
-    }
     static addCreditManager(address, version) {
         TxParser._addParser(address, new creditManagerParser_1.CreditManagerParser(version));
     }
@@ -153,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) {

package/lib/parsers/uniV2AdapterParser.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniswapV2AdapterParser = 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 UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
@@ -39,14 +39,15 @@ class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
                 const amountInMaxStr = this.formatBN(amountInMax, tokenOut);
                 return `${functionName}(amountOut: ${amountOutStr}, amountInMax: ${amountInMaxStr}, path: [${pathStr}])`;
             }
-            case "swapAllTokensForTokens": {
-                const [rateMinRAY, path] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(rate: ${(0, formatter_1.formatBN)(rateMinRAY, 27)}, path: [${path
+            case "swapDiffTokensForTokens": {
+                const [leftoverAmount, rateMinRAY, path] = this.decodeFunctionData(functionFragment, calldata);
+                const tokenIn = this.tokenSymbol(path[0]);
+                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, tokenIn)}, rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)}, path: [${path
                     .map(r => this.tokenSymbol(r))
                     .join(" => ")}])`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
 }

package/lib/parsers/uniV2AdapterParser.spec.js

@@ -32,7 +32,8 @@ describe("UniswapV2AdapterParser test", () => {
             45033,
         ]));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapTokensForExactTokens(amountOut: 234.50K [234500000000], amountInMax: 17.70K [17700000000000000000000], path: [USDC => DAI => FRAX])", "Incorrect parse swapTokensForExactTokens");
-        parsed = parser.parse(ifc.encodeFunctionData("swapAllTokensForTokens", [
+        parsed = parser.parse(ifc.encodeFunctionData("swapDiffTokensForTokens", [
+            BigInt(1e6) * 234500n,
             sdk_gov_1.RAY * 3240n,
             [
                 sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
@@ -41,6 +42,6 @@ describe("UniswapV2AdapterParser test", () => {
             ],
             45033,
         ]));
-        (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapAllTokensForTokens(rate: 3.24K, path: [USDC => DAI => FRAX])", "Incorrect parse swapAllTokensForTokens");
+        (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapDiffTokensForTokens(leftoverAmount: 234.50K [234500000000], rate: 3.24K, path: [USDC => DAI => FRAX])", "Incorrect parse swapDiffTokensForTokens");
     });
 });

package/lib/parsers/uniV3AdapterParser.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniswapV3AdapterParser = 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 UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
@@ -22,11 +22,12 @@ class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
                 const amountOutMinimumStr = this.formatBN(amountOutMinimum, tokenOut);
                 return `${functionName}(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
             }
-            case "exactAllInputSingle": {
-                const { params: { tokenIn, tokenOut, fee, rateMinRAY }, } = this.decodeFunctionData(functionFragment, calldata);
+            case "exactDiffInputSingle": {
+                const { params: { tokenIn, tokenOut, fee, leftoverAmount, rateMinRAY }, } = this.decodeFunctionData(functionFragment, calldata);
                 const tokenInSym = this.tokenSymbol(tokenIn);
                 const tokenOutSym = this.tokenSymbol(tokenOut);
-                return `${functionName}(rate: ${(0, formatter_1.formatBN)(rateMinRAY, 27)},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
+                const leftoverAmountStr = this.formatBN(leftoverAmount, tokenIn);
+                return `${functionName}(leftoverAmount: ${leftoverAmountStr}, rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
             }
             case "exactInput": {
                 const { params: { amountIn, amountOutMinimum, path }, } = this.decodeFunctionData(functionFragment, calldata);
@@ -35,10 +36,11 @@ class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
                 const amountOutMinimumStr = this.formatBN(amountOutMinimum, this.tokenSymbol(`0x${path.slice(-40, path.length)}`));
                 return `${functionName}(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${pathStr}`;
             }
-            case "exactAllInput": {
-                const { params: { rateMinRAY, path }, } = this.decodeFunctionData(functionFragment, calldata);
+            case "exactDiffInput": {
+                const { params: { leftoverAmount, rateMinRAY, path }, } = this.decodeFunctionData(functionFragment, calldata);
+                const leftoverAmountStr = this.formatBN(leftoverAmount, this.tokenSymbol(`0x${path.replace("0x", "").slice(0, 40)}`));
                 const pathStr = this.trackInputPath(path);
-                return `${functionName}(rate: ${(0, formatter_1.formatBN)(rateMinRAY, 27)},  path: ${pathStr}`;
+                return `${functionName}(leftoverAmount: ${leftoverAmountStr}, rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)},  path: ${pathStr}`;
             }
             case "exactOutput": {
                 const { params: { amountInMaximum, amountOut, path }, } = this.decodeFunctionData(functionFragment, calldata);
@@ -56,7 +58,7 @@ class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
                 return `${functionName}(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
     trackInputPath(path) {