npm - @gearbox-protocol/sdk - Versions diffs - 2.1.37 → 3.0.0-draft.2 - Mend

@gearbox-protocol/sdk 2.1.37 → 3.0.0-draft.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1336) hide show

package/lib/parsers/uniV2AdapterParser.spec.js CHANGED Viewed

@@ -1,47 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
-const constants_1 = require("../core/constants");
-const token_1 = require("../tokens/token");
+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", [
-            constants_1.WAD * 180000n,
-            BigInt(1e6) * 45n,
-            [
-                token_1.tokenDataByNetwork.Mainnet.DAI,
-                token_1.tokenDataByNetwork.Mainnet.WETH,
-                token_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,
             ],
-            constants_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,
-            constants_1.WAD * 17700n,
-            [
-                token_1.tokenDataByNetwork.Mainnet.USDC,
-                token_1.tokenDataByNetwork.Mainnet.DAI,
-                token_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,
             ],
-            constants_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", [
-            constants_1.RAY * 3240n,
-            [
-                token_1.tokenDataByNetwork.Mainnet.USDC,
-                token_1.tokenDataByNetwork.Mainnet.DAI,
-                token_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 CHANGED Viewed

@@ -1,9 +1,10 @@
-import { SupportedContract } from "../contracts/contracts";
+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 CHANGED Viewed

@@ -1,62 +1,70 @@
 "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) {
         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 { operationName, functionData } = 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})`;
+                return `${operationName}(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, formatter_1.formatBN)(rateMinRAY, 27)},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
+                const leftoverAmountStr = this.formatBN(leftoverAmount, tokenIn);
+                return `${operationName}(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}`;
+                return `${operationName}(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, formatter_1.formatBN)(rateMinRAY, 27)},  path: ${pathStr}`;
+                return `${operationName}(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}`;
+                return `${operationName}(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);
                 const amountOutStr = this.formatBN(amountOut, tokenOutSym);
-                return `${functionName}(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
+                return `${operationName}(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, operationName, calldata);
         }
     }
     trackInputPath(path) {

package/lib/parsers/uniV3AdapterParser.spec.js CHANGED Viewed

@@ -1,9 +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 constants_1 = require("../core/constants");
-const token_1 = require("../tokens/token");
+const viem_1 = require("viem");
 const types_1 = require("../types");
 const uniV3AdapterParser_1 = require("./uniV3AdapterParser");
 const pathToUniV3Path = (path) => {
@@ -17,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([
-                    token_1.tokenDataByNetwork.Mainnet.AAVE,
-                    token_1.tokenDataByNetwork.Mainnet.LINK,
-                    token_1.tokenDataByNetwork.Mainnet.USDC,
-                ]),
-                recipient: constants_1.DUMB_ADDRESS,
-                deadline: 1232131,
-                amountIn: constants_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([
-                    token_1.tokenDataByNetwork.Mainnet.AAVE,
-                    token_1.tokenDataByNetwork.Mainnet.LINK,
-                    token_1.tokenDataByNetwork.Mainnet.USDC,
-                ]),
-                rateMinRAY: constants_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", [
         //     {
@@ -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([
-                    token_1.tokenDataByNetwork.Mainnet.AAVE,
-                    token_1.tokenDataByNetwork.Mainnet.LINK,
-                    token_1.tokenDataByNetwork.Mainnet.USDC,
-                ]),
-                recipient: constants_1.DUMB_ADDRESS,
-                deadline: 1232131,
-                amountInMaximum: 123e6,
-                amountOut: constants_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 CHANGED Viewed

@@ -1,7 +1,8 @@
-import { SupportedContract } from "../contracts/contracts";
+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 CHANGED Viewed

@@ -1,49 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WstETHAdapterParser = 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 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 { operationName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "wrap": {
-                const [amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(amount: ${this.formatBN(amount, "STETH")})`;
+                const [amount] = functionData.args || [];
+                return `${operationName}(amount: ${this.formatBN(amount, "STETH")})`;
             }
-            case "wrapAll": {
-                return `${functionName}()`;
+            case "wrapDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                return `${operationName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
             }
             case "unwrap": {
-                const [amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(amount: ${this.formatBN(amount, "wstETH")})`;
+                const [amount] = functionData.args || [];
+                return `${operationName}(amount: ${this.formatBN(amount, "wstETH")})`;
             }
-            case "unwrapAll": {
-                return `${functionName}()`;
+            case "unwrapDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                return `${operationName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
             }
             case "balanceOf": {
-                const [address] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(${address})`;
+                const [address] = functionData.args || [];
+                return `${operationName}(${address})`;
             }
             case "allowance": {
-                const [account, to] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(account: ${account}, to: ${to})`;
+                const [account, to] = functionData.args || [];
+                return `${operationName}(account: ${account}, to: ${to})`;
             }
             case "approve": {
-                const [spender, amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(${spender}, [${(0, formatter_1.toBigInt)(amount).toString()}])`;
+                const [spender, amount] = functionData.args || [];
+                return `${operationName}(${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, operationName, calldata);
         }
     }
 }

package/lib/parsers/wstETHAdapterParser.spec.js CHANGED Viewed

@@ -1,21 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
-const constants_1 = require("../core/constants");
+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", [constants_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", [constants_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)");
     });
 });

package/lib/parsers/yearnAdapterParser.spec.js CHANGED Viewed

@@ -1,36 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
-const constants_1 = require("../core/constants");
+const viem_1 = require("viem");
 const types_1 = require("../types");
 const yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
 describe("YearnV2AdapterParser test", () => {
     it("deposit / withdraw functions works well", () => {
-        let parser = new yearnV2AdapterParser_1.YearnV2AdapterParser("YEARN_CURVE_STETH_VAULT", false);
-        const ifc = types_1.IYearnV2Adapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("deposit()"));
-        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit()", "Incorrect parse deposit()");
-        parsed = parser.parse(ifc.encodeFunctionData("deposit(uint256)", [constants_1.WAD * 19000n]));
+        const parser = new yearnV2AdapterParser_1.YearnV2AdapterParser("YEARN_CURVE_STETH_VAULT", false);
+        let parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "depositDiff",
+            args: [sdk_gov_1.WAD * 19000n],
+        }));
+        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].depositDiff(leftoverAmount: 19.00K [19000000000000000000000])", "Incorrect parse depositDiff");
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "deposit",
+            args: [sdk_gov_1.WAD * 19000n],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000])", "Incorrect parse deposit(amount)");
-        parsed = parser.parse(ifc.encodeFunctionData("deposit(uint256,address)", [
-            constants_1.WAD * 19000n,
-            constants_1.DUMB_ADDRESS,
-        ]));
-        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000], address: ${constants_1.DUMB_ADDRESS})`, "Incorrect parse deposit(amount,address)");
-        parsed = parser.parse(ifc.encodeFunctionData("withdraw()"));
-        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw()", "Incorrect parse withdraw()");
-        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256)", [constants_1.WAD * 19000n]));
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "deposit",
+            args: [sdk_gov_1.WAD * 19000n, sdk_gov_1.DUMB_ADDRESS],
+        }));
+        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000], address: ${sdk_gov_1.DUMB_ADDRESS})`, "Incorrect parse deposit(amount,address)");
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "withdrawDiff",
+            args: [sdk_gov_1.WAD * 19000n],
+        }));
+        (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdrawDiff(leftoverAmount: 19.00K [19000000000000000000000])", "Incorrect parse withdrawDiff");
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "withdraw",
+            args: [sdk_gov_1.WAD * 19000n],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000])", "Incorrect parse withdraw(amount)");
-        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256,address)", [
-            constants_1.WAD * 19000n,
-            constants_1.DUMB_ADDRESS,
-        ]));
-        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ${constants_1.DUMB_ADDRESS})`, "Incorrect parse withdraw(amount,address)");
-        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256,address,uint256)", [
-            constants_1.WAD * 19000n,
-            constants_1.DUMB_ADDRESS,
-            555,
-        ]));
-        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ${constants_1.DUMB_ADDRESS}, maxLoss: 555)`, "Incorrect parse withdraw(amount,address,uint256)");
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "withdraw",
+            args: [sdk_gov_1.WAD * 19000n, sdk_gov_1.DUMB_ADDRESS],
+        }));
+        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ${sdk_gov_1.DUMB_ADDRESS})`, "Incorrect parse withdraw(amount,address)");
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "withdraw",
+            args: [sdk_gov_1.WAD * 19000n, sdk_gov_1.DUMB_ADDRESS, 555n],
+        }));
+        (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ${sdk_gov_1.DUMB_ADDRESS}, maxLoss: 555)`, "Incorrect parse withdraw(amount,address,uint256)");
     });
 });

package/lib/parsers/yearnV2AdapterParser.d.ts CHANGED Viewed

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