@gearbox-protocol/sdk 3.0.0-next.21 → 3.0.0-next.211

package/lib/parsers/txParser.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxParser = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const addressProviderParser_1 = require("./addressProviderParser");
+const aaveV2LendingPoolAdapterParser_1 = require("./aaveV2LendingPoolAdapterParser");
+const aaveV2WrappedATokenAdapterParser_1 = require("./aaveV2WrappedATokenAdapterParser");
+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,9 +13,9 @@ 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");
 const priceOracleParser_1 = require("./priceOracleParser");
 const uniV2AdapterParser_1 = require("./uniV2AdapterParser");
 const uniV3AdapterParser_1 = require("./uniV3AdapterParser");
@@ -21,22 +24,38 @@ 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);
         return { contract: parser.contract, adapterName: parser.adapterName };
     }
     static parseMultiCall(calls) {
-        return calls.map(call => TxParser.parse(call.target, call.callData.toString()));
+        return calls.map(call => TxParser.parse(call.target, call.callData));
     }
     static parseToObjectMultiCall(calls) {
-        return calls.map(call => TxParser.parseToObject(call.target, call.callData.toString()));
+        return calls.map(call => TxParser.parseToObject(call.target, call.callData));
     }
     static addAdapters(adapters) {
         for (let a of adapters) {
@@ -83,15 +102,9 @@ class TxParser {
     static addPriceOracle(address) {
         TxParser._addParser(address, new priceOracleParser_1.PriceOracleParser());
     }
-    static addAddressProvider(address) {
-        TxParser._addParser(address, new addressProviderParser_1.AddressProviderParser());
-    }
     static addCreditManager(address, version) {
         TxParser._addParser(address, new creditManagerParser_1.CreditManagerParser(version));
     }
-    static addPool(address, version) {
-        TxParser._addParser(address, new poolParser_1.PoolParser(version));
-    }
     static getParser(address) {
         const parser = TxParser.parsers[address.toLowerCase()];
         if (!parser)
@@ -132,6 +145,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.d.ts

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

package/lib/parsers/uniV2AdapterParser.js

@@ -7,18 +7,15 @@ const abstractParser_1 = require("./abstractParser");
 class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.IUniswapV2Adapter__factory.createInterface();
+        this.abi = types_1.iUniswapV2AdapterAbi;
         if (!isContract)
             this.adapterName = "UniswapV2Adapter";
     }
     parse(calldata) {
-        return this._parse(calldata);
-    }
-    _parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionData, functionName } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "swapExactTokensForTokens": {
-                const [amountIn, amountOutMin, path] = this.decodeFunctionData(functionFragment, calldata);
+                const [amountIn, amountOutMin, path] = functionData.args || [];
                 const pathStr = path
                     .map(r => this.tokenSymbol(r))
                     .join(" => ");
@@ -29,7 +26,7 @@ class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
                 return `${functionName}(amountIn: ${amountInStr}, amountOutMin: ${amountOutStr}, path: [${pathStr}])`;
             }
             case "swapTokensForExactTokens": {
-                const [amountOut, amountInMax, path] = this.decodeFunctionData(functionFragment, calldata);
+                const [amountOut, amountInMax, path] = functionData.args || [];
                 const pathStr = path
                     .map(r => this.tokenSymbol(r))
                     .join(" => ");
@@ -39,14 +36,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, sdk_gov_1.formatBN)(rateMinRAY, 27)}, path: [${path
+            case "swapDiffTokensForTokens": {
+                const [leftoverAmount, rateMinRAY, path] = functionData.args || [];
+                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(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

package/lib/parsers/uniV2AdapterParser.spec.js

@@ -2,45 +2,58 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
+const viem_1 = require("viem");
 const types_1 = require("../types");
 const uniV2AdapterParser_1 = require("./uniV2AdapterParser");
 describe("UniswapV2AdapterParser test", () => {
     it("swap functions works well", () => {
         let parser = new uniV2AdapterParser_1.UniswapV2AdapterParser("UNISWAP_V2_ROUTER", false);
-        const ifc = types_1.IUniswapV2Adapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("swapExactTokensForTokens", [
-            sdk_gov_1.WAD * 180000n,
-            BigInt(1e6) * 45n,
-            [
-                sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.WETH,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+        let parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iUniswapV2AdapterAbi,
+            functionName: "swapExactTokensForTokens",
+            args: [
+                sdk_gov_1.WAD * 180000n,
+                BigInt(1e6) * 45n,
+                [
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.WETH,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                ],
+                sdk_gov_1.DUMB_ADDRESS,
+                45000n,
             ],
-            sdk_gov_1.DUMB_ADDRESS,
-            45000,
-        ]));
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapExactTokensForTokens(amountIn: 180.00K [180000000000000000000000], amountOutMin: 45.00 [45000000], path: [DAI => WETH => USDC])", "Incorrect parse swapExactTokensForTokens");
-        parsed = parser.parse(ifc.encodeFunctionData("swapTokensForExactTokens", [
-            BigInt(1e6) * 234500n,
-            sdk_gov_1.WAD * 17700n,
-            [
-                sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX,
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iUniswapV2AdapterAbi,
+            functionName: "swapTokensForExactTokens",
+            args: [
+                BigInt(1e6) * 234500n,
+                sdk_gov_1.WAD * 17700n,
+                [
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX,
+                ],
+                sdk_gov_1.DUMB_ADDRESS,
+                45033n,
             ],
-            sdk_gov_1.DUMB_ADDRESS,
-            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", [
-            sdk_gov_1.RAY * 3240n,
-            [
-                sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX,
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iUniswapV2AdapterAbi,
+            functionName: "swapDiffTokensForTokens",
+            args: [
+                BigInt(1e6) * 234500n,
+                sdk_gov_1.RAY * 3240n,
+                [
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX,
+                ],
+                45033n,
             ],
-            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.d.ts

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

package/lib/parsers/uniV3AdapterParser.js

@@ -7,48 +7,56 @@ const abstractParser_1 = require("./abstractParser");
 class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.IUniswapV3Adapter__factory.createInterface();
+        this.abi = types_1.iUniswapV3AdapterAbi;
         if (!isContract)
             this.adapterName = "UniswapV3Adapter";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionData, functionName } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "exactInputSingle": {
-                const [[tokenIn, tokenOut, fee, , , amountIn, amountOutMinimum]] = this.decodeFunctionData(functionFragment, calldata);
+                const [{ tokenIn, tokenOut, fee, amountIn, amountOutMinimum }] = functionData.args || [{}];
                 const tokenInSym = this.tokenSymbol(tokenIn);
                 const tokenOutSym = this.tokenSymbol(tokenOut);
                 const amountInStr = this.formatBN(amountIn, tokenIn);
                 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 [{ tokenIn, tokenOut, fee, leftoverAmount, rateMinRAY }] = functionData.args || [{}];
                 const tokenInSym = this.tokenSymbol(tokenIn);
                 const tokenOutSym = this.tokenSymbol(tokenOut);
-                return `${functionName}(rate: ${(0, sdk_gov_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);
+                const [{ path, amountIn, amountOutMinimum }] = functionData.args || [
+                    {},
+                ];
                 const pathStr = this.trackInputPath(path);
                 const amountInStr = this.formatBN(amountIn, this.tokenSymbol(`0x${path.replace("0x", "").slice(0, 40)}`));
                 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 [{ path, leftoverAmount, rateMinRAY }] = functionData.args || [
+                    {},
+                ];
+                const leftoverAmountStr = this.formatBN(leftoverAmount, this.tokenSymbol(`0x${path.replace("0x", "").slice(0, 40)}`));
                 const pathStr = this.trackInputPath(path);
-                return `${functionName}(rate: ${(0, sdk_gov_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);
+                const [{ path, amountOut, amountInMaximum }] = functionData.args || [
+                    {},
+                ];
                 const pathStr = this.trackOutputPath(path);
                 const amountInMaximumStr = this.formatBN(amountInMaximum, this.tokenSymbol(`0x${path.slice(-40, path.length)}`));
                 const amountOutStr = this.formatBN(amountOut, this.tokenSymbol(`0x${path.replace("0x", "").slice(0, 40)}`));
                 return `${functionName}(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${pathStr}`;
             }
             case "exactOutputSingle": {
-                const [[tokenIn, tokenOut, fee, , , amountOut, amountInMaximum]] = this.decodeFunctionData(functionFragment, calldata);
+                const [{ tokenIn, tokenOut, fee, amountOut, amountInMaximum }] = functionData.args || [{}];
                 const tokenInSym = this.tokenSymbol(tokenIn);
                 const tokenOutSym = this.tokenSymbol(tokenOut);
                 const amountInMaximumStr = this.formatBN(amountInMaximum, tokenInSym);
@@ -56,7 +64,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(this.adapterName || this.contract, functionName, calldata);
         }
     }
     trackInputPath(path) {

package/lib/parsers/uniV3AdapterParser.spec.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const solidity_1 = require("@ethersproject/solidity");
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
+const viem_1 = require("viem");
 const types_1 = require("../types");
 const uniV3AdapterParser_1 = require("./uniV3AdapterParser");
 const pathToUniV3Path = (path) => {
@@ -16,73 +16,46 @@ const pathToUniV3Path = (path) => {
             types.push("uint24");
         }
     });
-    return (0, solidity_1.pack)(types, pathWithFees);
+    return (0, viem_1.encodePacked)(types, pathWithFees);
 };
 describe("UniswapV3AdapterParser test", () => {
     it("swap functions works well", () => {
         let parser = new uniV3AdapterParser_1.UniswapV3AdapterParser("UNISWAP_V3_ROUTER", false);
-        const ifc = types_1.IUniswapV3Adapter__factory.createInterface();
-        let parsed;
-        // let parsed = parser.parse(
-        //   ifc.encodeFunctionData("exactInputSingle", [
-        //     {
-        //       tokenIn: tokenDataByNetwork.Arbitrum["1INCH"],
-        //       tokenOut: tokenDataByNetwork.Arbitrum["3Crv"],
-        //       fee: 3000,
-        //       recipient: DUMB_ADDRESS,
-        //       deadline: 12300,
-        //       amountIn: WAD * 1299000n,
-        //       amountOutMinimum: WAD * 10200n,
-        //       sqrtPriceLimitX96: 0,
-        //     },
-        //   ]),
-        // );
-        // expect(parsed).to.be.eq(
-        //   "UniswapV3Adapter[UNISWAP_V3_ROUTER].exactInputSingle(amountIn: 1.29M [1299000000000000000000000], amountOutMinimum: 10.20K [10200000000000000000000],  path: 1INCH ==(fee: 3000)==> 3Crv)",
-        //   "Incorrect parse swapExactTokensForTokens",
-        // );
-        // parsed = parser.parse(
-        //   ifc.encodeFunctionData("exactAllInputSingle", [
-        //     {
-        //       tokenIn: tokenDataByNetwork.Arbitrum["1INCH"],
-        //       tokenOut: tokenDataByNetwork.Arbitrum["3Crv"],
-        //       fee: 3000,
-        //       deadline: 12300,
-        //       rateMinRAY: RAY * 1200n,
-        //       sqrtPriceLimitX96: 0,
-        //     },
-        //   ]),
-        // );
-        // expect(parsed).to.be.eq(
-        //   "UniswapV3Adapter[UNISWAP_V3_ROUTER].exactAllInputSingle(rate: 1.20K,  path: 1INCH ==(fee: 3000)==> 3Crv)",
-        //   "Incorrect parse swapExactTokensForTokens",
-        // );
-        parsed = parser.parse(ifc.encodeFunctionData("exactInput", [
-            {
-                path: pathToUniV3Path([
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-                ]),
-                recipient: sdk_gov_1.DUMB_ADDRESS,
-                deadline: 1232131,
-                amountIn: sdk_gov_1.WAD * 12399n,
-                amountOutMinimum: BigInt(1e6) * 122n,
-            },
-        ]));
+        let parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iUniswapV3AdapterAbi,
+            functionName: "exactInput",
+            args: [
+                {
+                    path: pathToUniV3Path([
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                    ]),
+                    recipient: sdk_gov_1.DUMB_ADDRESS,
+                    deadline: 1232131n,
+                    amountIn: sdk_gov_1.WAD * 12399n,
+                    amountOutMinimum: BigInt(1e6) * 122n,
+                },
+            ],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactInput(amountIn: 12.39K [12399000000000000000000], amountOutMinimum: 122.00 [122000000],  path: AAVE ==(fee: 3000)==> LINK ==(fee: 3000)==> USDC", "Incorrect parse swapExactTokensForTokens");
-        parsed = parser.parse(ifc.encodeFunctionData("exactAllInput", [
-            {
-                path: pathToUniV3Path([
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-                ]),
-                rateMinRAY: sdk_gov_1.RAY * 1200n,
-                deadline: 1232131,
-            },
-        ]));
-        (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactAllInput(rate: 1.20K,  path: AAVE ==(fee: 3000)==> LINK ==(fee: 3000)==> USDC", "Incorrect parse swapExactTokensForTokens");
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iUniswapV3AdapterAbi,
+            functionName: "exactDiffInput",
+            args: [
+                {
+                    path: pathToUniV3Path([
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                    ]),
+                    leftoverAmount: sdk_gov_1.WAD * 12399n,
+                    rateMinRAY: sdk_gov_1.RAY * 1200n,
+                    deadline: 1232131n,
+                },
+            ],
+        }));
+        (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactDiffInput(leftoverAmount: 12.39K [12399000000000000000000], rate: 1.20K,  path: AAVE ==(fee: 3000)==> LINK ==(fee: 3000)==> USDC", "Incorrect parse swapExactTokensForTokens");
         // parsed = parser.parse(
         //   ifc.encodeFunctionData("exactOutputSingle", [
         //     {
@@ -101,19 +74,23 @@ describe("UniswapV3AdapterParser test", () => {
         //   "UniswapV3Adapter[UNISWAP_V3_ROUTER].exactOutputSingle(amountInMaximum: 0.14 [149000000000000000], amountOut: 102.00 [102000000],  path: 1INCH ==(fee: 10000)==> USDC)",
         //   "Incorrect parse swapExactTokensForTokens",
         // );
-        parsed = parser.parse(ifc.encodeFunctionData("exactOutput", [
-            {
-                path: pathToUniV3Path([
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
-                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-                ]),
-                recipient: sdk_gov_1.DUMB_ADDRESS,
-                deadline: 1232131,
-                amountInMaximum: 123e6,
-                amountOut: sdk_gov_1.WAD * 122n,
-            },
-        ]));
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iUniswapV3AdapterAbi,
+            functionName: "exactOutput",
+            args: [
+                {
+                    path: pathToUniV3Path([
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                    ]),
+                    recipient: sdk_gov_1.DUMB_ADDRESS,
+                    deadline: 1232131n,
+                    amountInMaximum: 123000000n,
+                    amountOut: sdk_gov_1.WAD * 122n,
+                },
+            ],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactOutput(amountInMaximum: 123.00 [123000000], amountOut: 122.00 [122000000000000000000],  path: USDC ==(fee: 3000)==> LINK ==(fee: 3000)==> AAVE", "Incorrect parse swapExactTokensForTokens");
     });
 });

package/lib/parsers/wstETHAdapterParser.d.ts

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

package/lib/parsers/wstETHAdapterParser.js

@@ -7,43 +7,43 @@ const abstractParser_1 = require("./abstractParser");
 class WstETHAdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = !isContract
-            ? types_1.IwstETHV1Adapter__factory.createInterface()
-            : types_1.IwstETH__factory.createInterface();
+        this.abi = !isContract ? types_1.iwstEthv1AdapterAbi : types_1.iwstEthAbi;
         if (!isContract)
             this.adapterName = "wstETHAdapter";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionData, functionName } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "wrap": {
-                const [amount] = this.decodeFunctionData(functionFragment, calldata);
+                const [amount] = functionData.args || [];
                 return `${functionName}(amount: ${this.formatBN(amount, "STETH")})`;
             }
-            case "wrapAll": {
-                return `${functionName}()`;
+            case "wrapDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
             }
             case "unwrap": {
-                const [amount] = this.decodeFunctionData(functionFragment, calldata);
+                const [amount] = functionData.args || [];
                 return `${functionName}(amount: ${this.formatBN(amount, "wstETH")})`;
             }
-            case "unwrapAll": {
-                return `${functionName}()`;
+            case "unwrapDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
             }
             case "balanceOf": {
-                const [address] = this.decodeFunctionData(functionFragment, calldata);
+                const [address] = functionData.args || [];
                 return `${functionName}(${address})`;
             }
             case "allowance": {
-                const [account, to] = this.decodeFunctionData(functionFragment, calldata);
+                const [account, to] = functionData.args || [];
                 return `${functionName}(account: ${account}, to: ${to})`;
             }
             case "approve": {
-                const [spender, amount] = this.decodeFunctionData(functionFragment, calldata);
+                const [spender, amount] = functionData.args || [];
                 return `${functionName}(${spender}, [${(0, sdk_gov_1.toBigInt)(amount).toString()}])`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

package/lib/parsers/wstETHAdapterParser.spec.js

@@ -2,20 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
+const viem_1 = require("viem");
 const types_1 = require("../types");
 const wstETHAdapterParser_1 = require("./wstETHAdapterParser");
 describe("WstETHAdapterParser test", () => {
     it("wrap / unwrap function works well", () => {
         let parser = new wstETHAdapterParser_1.WstETHAdapterParser("LIDO_WSTETH", false);
-        const ifc = types_1.IwstETHV1Adapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("wrapAll"));
-        (0, chai_1.expect)(parsed).to.be.eq("wstETHAdapter[LIDO_WSTETH].wrapAll()", "Incorrect parse wrapAll()");
-        parsed = parser.parse(ifc.encodeFunctionData("unwrapAll"));
-        (0, chai_1.expect)(parsed).to.be.eq("wstETHAdapter[LIDO_WSTETH].unwrapAll()", "Incorrect parse unwrapAll()");
+        let parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iwstEthv1AdapterAbi,
+            functionName: "wrapDiff",
+            args: [sdk_gov_1.WAD * 1020n],
+        }));
+        (0, chai_1.expect)(parsed).to.be.eq("wstETHAdapter[LIDO_WSTETH].wrapDiff(leftoverAmount: 1.02K [1020000000000000000000])", "Incorrect parse wrapDiff()");
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iwstEthv1AdapterAbi,
+            functionName: "unwrapDiff",
+            args: [sdk_gov_1.WAD * 1020n],
+        }));
+        (0, chai_1.expect)(parsed).to.be.eq("wstETHAdapter[LIDO_WSTETH].unwrapDiff(leftoverAmount: 1.02K [1020000000000000000000])", "Incorrect parse unwrapDiff()");
         parser = new wstETHAdapterParser_1.WstETHAdapterParser("LIDO_WSTETH", true);
-        parsed = parser.parse(ifc.encodeFunctionData("wrap", [sdk_gov_1.WAD * 1020n]));
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iwstEthv1AdapterAbi,
+            functionName: "wrap",
+            args: [sdk_gov_1.WAD * 1020n],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("Contract[LIDO_WSTETH].wrap(amount: 1.02K [1020000000000000000000])", "Incorrect parse wrap(amount)");
-        parsed = parser.parse(ifc.encodeFunctionData("unwrap", [sdk_gov_1.WAD * 1020n]));
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iwstEthv1AdapterAbi,
+            functionName: "unwrap",
+            args: [sdk_gov_1.WAD * 1020n],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("Contract[LIDO_WSTETH].unwrap(amount: 1.02K [1020000000000000000000])", "Incorrect parse unwrap(amount)");
     });
 });