@gearbox-protocol/sdk 3.0.0-next.204 → 3.0.0-next.206

package/lib/parsers/txParser.d.ts

@@ -1,46 +1,37 @@
 import { NetworkType, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
 import { MultiCall } from "../pathfinder/core";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export interface AdapterForParser {
-    adapter: string;
-    contract: string;
+    adapter: Address;
+    contract: Address;
 }
 interface ParseData {
     contract: string;
     adapterName: string;
 }
 export declare class TxParser {
-    protected static parsers: Record<string, IParser & AbstractParser>;
-    static parse(address: string, calldata: string): string | null;
-    static parseToObject(address: string, calldata: string): {
-        callObject: {
-            address: string;
-            functionFragment: import("ethers").FunctionFragment;
-            args: any;
-        };
+    protected static parsers: Record<Address, IParser & AbstractParser>;
+    static parse(address: Address, calldata: Address): string | null;
+    static parseToObject(address: Address, calldata: Address): {
+        callObject: import("./abstractParser").ParsedObject;
         parser: IParser & AbstractParser;
     } | null;
-    static getParseData(address: string): ParseData;
+    static getParseData(address: Address): ParseData;
     static parseMultiCall(calls: Array<MultiCall>): (string | null)[];
     static parseToObjectMultiCall(calls: Array<MultiCall>): ({
-        callObject: {
-            address: string;
-            functionFragment: import("ethers").FunctionFragment;
-            args: any;
-        };
+        callObject: import("./abstractParser").ParsedObject;
         parser: IParser & AbstractParser;
     } | null)[];
     static addAdapters(adapters: Array<AdapterForParser>): void;
     static addContracts(network: NetworkType): void;
-    static addCreditFacade(creditFacade: string, underlying: SupportedToken, version: number): void;
+    static addCreditFacade(creditFacade: Address, underlying: SupportedToken, version: number): void;
     static addTokens(network: NetworkType): void;
-    static addPriceOracle(address: string): void;
-    static addAddressProvider(address: string): void;
-    static addCreditManager(address: string, version: number): void;
-    static addPool(address: string, version: number): void;
-    static getParser(address: string): IParser & AbstractParser;
-    protected static chooseContractParser(address: string, contract: SupportedContract, adapterType: number, isContract: boolean): void;
-    protected static _addParser(address: string, parser: IParser & AbstractParser): void;
+    static addPriceOracle(address: Address): void;
+    static addCreditManager(address: Address, version: number): void;
+    static getParser(address: Address): IParser & AbstractParser;
+    protected static chooseContractParser(address: Address, contract: SupportedContract, adapterType: number, isContract: boolean): void;
+    protected static _addParser(address: Address, parser: IParser & AbstractParser): void;
 }
 export {};

package/lib/parsers/txParser.js

@@ -4,7 +4,6 @@ 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");
@@ -17,7 +16,6 @@ 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");
@@ -54,10 +52,10 @@ class TxParser {
         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) {
@@ -104,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)

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(" => ");
@@ -40,14 +37,14 @@ class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
                 return `${functionName}(amountOut: ${amountOutStr}, amountInMax: ${amountInMaxStr}, path: [${pathStr}])`;
             }
             case "swapDiffTokensForTokens": {
-                const [leftoverAmount, rateMinRAY, path] = this.decodeFunctionData(functionFragment, calldata);
+                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 this.reportUnknownFragment(functionName, functionFragment, calldata);
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

package/lib/parsers/uniV2AdapterParser.spec.js

@@ -2,46 +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("swapDiffTokensForTokens", [
-            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,
+        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].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,15 +7,15 @@ 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);
@@ -23,34 +23,40 @@ class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
                 return `${functionName}(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
             }
             case "exactDiffInputSingle": {
-                const { params: { tokenIn, tokenOut, fee, leftoverAmount, rateMinRAY }, } = this.decodeFunctionData(functionFragment, calldata);
+                const [{ tokenIn, tokenOut, fee, leftoverAmount, rateMinRAY }] = functionData.args || [{}];
                 const tokenInSym = this.tokenSymbol(tokenIn);
                 const tokenOutSym = this.tokenSymbol(tokenOut);
                 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 "exactDiffInput": {
-                const { params: { leftoverAmount, rateMinRAY, path }, } = this.decodeFunctionData(functionFragment, calldata);
+                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}(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);
@@ -58,7 +64,7 @@ class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
                 return `${functionName}(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
             }
             default:
-                return this.reportUnknownFragment(functionName, functionFragment, 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,45 @@ 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("exactDiffInput", [
-            {
-                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: 1232131,
-            },
-        ]));
+        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", [
@@ -102,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,45 +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 "wrapDiff": {
-                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
+                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 "unwrapDiff": {
-                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
+                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 this.reportUnknownFragment(functionName, functionFragment, 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("wrapDiff", [sdk_gov_1.WAD * 1020n]));
+        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(ifc.encodeFunctionData("unwrapDiff", [sdk_gov_1.WAD * 1020n]));
+        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)");
     });
 });