@gearbox-protocol/sdk 3.0.0-next.8 → 3.0.0-next.80

package/lib/parsers/creditFacadeParser.js

@@ -4,17 +4,24 @@ exports.CreditFacadeParser = void 0;
 const types_1 = require("../types");
 const abstractParser_1 = require("./abstractParser");
 class CreditFacadeParser extends abstractParser_1.AbstractParser {
-    constructor(token) {
+    version;
+    constructor(token, version) {
         super(token);
-        this.ifc = types_1.ICreditFacadeV2Extended__factory.createInterface();
+        this.version = version;
+        this.ifc =
+            version === 300
+                ? types_1.ICreditFacadeV3Multicall__factory.createInterface()
+                : types_1.ICreditFacadeV2Extended__factory.createInterface();
         this.adapterName = "CreditFacade";
     }
     parse(calldata) {
         const { functionFragment, functionName } = this.parseSelector(calldata);
         switch (functionFragment.name) {
             case "addCollateral": {
-                const [onBehalf, token, amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(onBehalf: ${onBehalf}, token: ${this.tokenSymbol(token)}, amount: ${this.formatAmount(amount)})`;
+                const r = this.decodeFunctionData(functionFragment, calldata);
+                const token = r[0];
+                const amount = r[1];
+                return `${functionName}(token: ${this.tokenSymbol(token)}, amount: ${this.formatBN(amount, this.tokenSymbol(token))})`;
             }
             case "increaseDebt":
             case "decreaseDebt": {
@@ -26,16 +33,48 @@ class CreditFacadeParser extends abstractParser_1.AbstractParser {
                 const [address] = this.decodeFunctionData(functionFragment, calldata);
                 return `${functionName}(token: ${this.tokenSymbol(address)})`;
             }
+            case "updateQuota": {
+                const [address, quotaUpdate, minQuota] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(token: ${this.tokenSymbol(address)}, quotaUpdate: ${this.formatAmount(quotaUpdate)}, minQuota: ${this.formatAmount(minQuota)})`;
+            }
             case "revertIfReceivedLessThan": {
                 const [balances] = this.decodeFunctionData(functionFragment, calldata);
                 const balancesStr = balances
                     .map(b => {
+                    const balance = "balance" in b ? b.balance : b.amount;
                     const symbol = this.tokenSymbol(b.token);
-                    return `${symbol}: ${this.formatBN(b.balance, symbol)}`;
+                    return `${symbol}: ${this.formatBN(balance, symbol)}`;
                 })
                     .join(", ");
                 return `${functionName}(${balancesStr})`;
             }
+            case "withdrawCollateral": {
+                const [token, amount, to] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(token: ${this.tokenSymbol(token)}, withdraw: ${this.formatBN(amount, this.tokenSymbol(token))}, to: ${to})`;
+            }
+            case "addCollateralWithPermit": {
+                const [tokenAddress, amount, deadline, v, r, s] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(token: ${this.tokenSymbol(tokenAddress)}, amount: ${this.formatBN(amount, this.tokenSymbol(tokenAddress))}, ${[deadline, v, r, s].join(", ")})`;
+            }
+            case "compareBalances": {
+                return `${functionName}()`;
+            }
+            case "setFullCheckParams": {
+                const [collateralHints, minHealthFactor] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(token: ${collateralHints
+                    .map((a) => this.formatAmount(a))
+                    .join(", ")}, minHealthFactor: ${minHealthFactor})`;
+            }
+            case "storeExpectedBalances": {
+                const [balanceDeltas] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(balanceDeltas: ${balanceDeltas
+                    .map((b) => `${this.tokenSymbol(b.token)}: ${this.formatBN(b.amount, this.tokenSymbol(b.token))}`)
+                    .join(", ")})`;
+            }
+            case "onDemandPriceUpdate": {
+                const [token, reserve, data] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(token: ${this.tokenSymbol(token)}, reserve: ${reserve}, data: ${data})`;
+            }
             default:
                 return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
         }

package/lib/parsers/creditFacadeParser.spec.js

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

package/lib/parsers/curveAdapterParser.js

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

package/lib/parsers/curveAdapterParser.spec.js

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

package/lib/parsers/lidoAdapterParser.js

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

package/lib/parsers/lidoAdapterParser.spec.js

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

package/lib/parsers/txParser.d.ts

@@ -27,7 +27,7 @@ export declare class TxParser {
     }[];
     static addAdapters(adapters: Array<AdapterForParser>): void;
     static addContracts(network: NetworkType): void;
-    static addCreditFacade(creditFacade: string, underlying: SupportedToken): void;
+    static addCreditFacade(creditFacade: string, underlying: SupportedToken, version: number): void;
     static addTokens(network: NetworkType): void;
     static addPriceOracle(address: string): void;
     static addAddressProvider(address: string): void;

package/lib/parsers/txParser.js

@@ -22,7 +22,13 @@ class TxParser {
     static parsers = {};
     static parse(address, calldata) {
         const parser = TxParser.getParser(address);
-        return parser.parse(calldata);
+        try {
+            return parser.parse(calldata);
+        }
+        catch (e) {
+            console.error(`Error while parsing ${address}`, parser, e);
+            return "Parsing error";
+        }
     }
     static parseToObject(address, calldata) {
         const parser = TxParser.getParser(address);
@@ -61,8 +67,8 @@ class TxParser {
             }
         });
     }
-    static addCreditFacade(creditFacade, underlying) {
-        TxParser._addParser(creditFacade, new creditFacadeParser_1.CreditFacadeParser(underlying));
+    static addCreditFacade(creditFacade, underlying, version) {
+        TxParser._addParser(creditFacade, new creditFacadeParser_1.CreditFacadeParser(underlying, version));
     }
     static addTokens(network) {
         sdk_gov_1.TypedObjectUtils.entries(sdk_gov_1.tokenDataByNetwork[network]).forEach(([s, t]) => {

package/lib/parsers/uniV2AdapterParser.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniswapV2AdapterParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
 const abstractParser_1 = require("./abstractParser");
 class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
@@ -39,9 +39,10 @@ class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
                 const amountInMaxStr = this.formatBN(amountInMax, tokenOut);
                 return `${functionName}(amountOut: ${amountOutStr}, amountInMax: ${amountInMaxStr}, path: [${pathStr}])`;
             }
-            case "swapAllTokensForTokens": {
-                const [rateMinRAY, path] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(rate: ${(0, formatter_1.formatBN)(rateMinRAY, 27)}, path: [${path
+            case "swapDiffTokensForTokens": {
+                const [leftoverAmount, rateMinRAY, path] = this.decodeFunctionData(functionFragment, calldata);
+                const tokenIn = this.tokenSymbol(path[0]);
+                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, tokenIn)}, rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)}, path: [${path
                     .map(r => this.tokenSymbol(r))
                     .join(" => ")}])`;
             }

package/lib/parsers/uniV2AdapterParser.spec.js

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

package/lib/parsers/uniV3AdapterParser.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniswapV3AdapterParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
 const abstractParser_1 = require("./abstractParser");
 class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
@@ -22,11 +22,12 @@ class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
                 const amountOutMinimumStr = this.formatBN(amountOutMinimum, tokenOut);
                 return `${functionName}(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
             }
-            case "exactAllInputSingle": {
-                const { params: { tokenIn, tokenOut, fee, rateMinRAY }, } = this.decodeFunctionData(functionFragment, calldata);
+            case "exactDiffInputSingle": {
+                const { params: { tokenIn, tokenOut, fee, leftoverAmount, rateMinRAY }, } = this.decodeFunctionData(functionFragment, calldata);
                 const tokenInSym = this.tokenSymbol(tokenIn);
                 const tokenOutSym = this.tokenSymbol(tokenOut);
-                return `${functionName}(rate: ${(0, formatter_1.formatBN)(rateMinRAY, 27)},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
+                const leftoverAmountStr = this.formatBN(leftoverAmount, tokenIn);
+                return `${functionName}(leftoverAmount: ${leftoverAmountStr}, rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
             }
             case "exactInput": {
                 const { params: { amountIn, amountOutMinimum, path }, } = this.decodeFunctionData(functionFragment, calldata);
@@ -35,10 +36,11 @@ class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
                 const amountOutMinimumStr = this.formatBN(amountOutMinimum, this.tokenSymbol(`0x${path.slice(-40, path.length)}`));
                 return `${functionName}(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${pathStr}`;
             }
-            case "exactAllInput": {
-                const { params: { rateMinRAY, path }, } = this.decodeFunctionData(functionFragment, calldata);
+            case "exactDiffInput": {
+                const { params: { leftoverAmount, rateMinRAY, path }, } = this.decodeFunctionData(functionFragment, calldata);
+                const leftoverAmountStr = this.formatBN(leftoverAmount, this.tokenSymbol(`0x${path.replace("0x", "").slice(0, 40)}`));
                 const pathStr = this.trackInputPath(path);
-                return `${functionName}(rate: ${(0, formatter_1.formatBN)(rateMinRAY, 27)},  path: ${pathStr}`;
+                return `${functionName}(leftoverAmount: ${leftoverAmountStr}, rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)},  path: ${pathStr}`;
             }
             case "exactOutput": {
                 const { params: { amountInMaximum, amountOut, path }, } = this.decodeFunctionData(functionFragment, calldata);

package/lib/parsers/uniV3AdapterParser.spec.js

@@ -71,18 +71,19 @@ describe("UniswapV3AdapterParser test", () => {
             },
         ]));
         (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", [
+        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,
             },
         ]));
-        (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");
+        (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", [
         //     {

package/lib/parsers/wstETHAdapterParser.js

@@ -20,15 +20,17 @@ class WstETHAdapterParser extends abstractParser_1.AbstractParser {
                 const [amount] = this.decodeFunctionData(functionFragment, calldata);
                 return `${functionName}(amount: ${this.formatBN(amount, "STETH")})`;
             }
-            case "wrapAll": {
-                return `${functionName}()`;
+            case "wrapDiff": {
+                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
             }
             case "unwrap": {
                 const [amount] = this.decodeFunctionData(functionFragment, calldata);
                 return `${functionName}(amount: ${this.formatBN(amount, "wstETH")})`;
             }
-            case "unwrapAll": {
-                return `${functionName}()`;
+            case "unwrapDiff": {
+                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
+                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
             }
             case "balanceOf": {
                 const [address] = this.decodeFunctionData(functionFragment, calldata);

package/lib/parsers/wstETHAdapterParser.spec.js

@@ -8,10 +8,10 @@ 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(ifc.encodeFunctionData("wrapDiff", [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]));
+        (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]));
         (0, chai_1.expect)(parsed).to.be.eq("Contract[LIDO_WSTETH].wrap(amount: 1.02K [1020000000000000000000])", "Incorrect parse wrap(amount)");

package/lib/parsers/yearnAdapterParser.spec.js

@@ -8,8 +8,8 @@ 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()");
+        let parsed = parser.parse(ifc.encodeFunctionData("depositDiff", [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(ifc.encodeFunctionData("deposit(uint256)", [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)", [
@@ -17,8 +17,8 @@ describe("YearnV2AdapterParser test", () => {
             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(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("withdrawDiff", [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(ifc.encodeFunctionData("withdraw(uint256)", [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)", [

package/lib/parsers/yearnV2AdapterParser.js

@@ -7,7 +7,7 @@ const abstractParser_1 = require("./abstractParser");
 class YearnV2AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.IYVault__factory.createInterface();
+        this.ifc = types_1.IYearnV2Adapter__factory.createInterface();
         if (!isContract)
             this.adapterName = "YearnV2Adapter";
     }
@@ -16,8 +16,6 @@ class YearnV2AdapterParser extends abstractParser_1.AbstractParser {
         switch (functionFragment.name) {
             case "deposit":
             case "withdraw":
-            case "deposit(uint256)":
-            case "withdraw(uint256)":
             case "withdraw(uint256,address,uint256)": {
                 const [amount, address, maxLoss] = this.decodeFunctionData(functionFragment, calldata);
                 const yvSym = this.tokenSymbol(sdk_gov_1.contractsByNetwork.Mainnet[this.contract]);
@@ -28,6 +26,18 @@ class YearnV2AdapterParser extends abstractParser_1.AbstractParser {
                 const maxLossStr = maxLoss ? `, maxLoss: ${maxLoss}` : "";
                 return `${functionName}(${amountStr}${addressStr}${maxLossStr})`;
             }
+            case "depositDiff": {
+                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
+                const yvSym = this.tokenSymbol(sdk_gov_1.contractsByNetwork.Mainnet[this.contract]);
+                const leftoverAmountStr = this.formatBN(leftoverAmount, yvSym);
+                return `${functionName}(leftoverAmount: ${leftoverAmountStr})`;
+            }
+            case "withdrawDiff": {
+                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
+                const yvSym = this.tokenSymbol(sdk_gov_1.contractsByNetwork.Mainnet[this.contract]);
+                const leftoverAmountStr = this.formatBN(leftoverAmount, yvSym);
+                return `${functionName}(leftoverAmount: ${leftoverAmountStr})`;
+            }
             case "pricePerShare": {
                 return `${functionName}()`;
             }

package/lib/pathfinder/core.d.ts

@@ -1,21 +1,20 @@
 import { ExcludeArrayProps } from "@gearbox-protocol/sdk-gov";
-import { MultiCallStructOutput, SwapTaskStructOutput } from "../types/IRouter";
+import { MultiCallStructOutput, RouterResultStructOutput, SwapTaskStruct } from "../types/IRouterV3";
+import { BigintifyProps } from "../utils/types";
 export declare enum SwapOperation {
     EXACT_INPUT = 0,
     EXACT_INPUT_ALL = 1,
     EXACT_OUTPUT = 2
 }
 export type MultiCall = ExcludeArrayProps<MultiCallStructOutput>;
-export type SwapTask = ExcludeArrayProps<SwapTaskStructOutput>;
-export interface PathFinderResult {
-    amount: bigint;
+export type SwapTask = ExcludeArrayProps<SwapTaskStruct>;
+export type PathFinderResult = Omit<BigintifyProps<ExcludeArrayProps<RouterResultStructOutput>>, "calls"> & {
     calls: Array<MultiCall>;
-}
-export interface PathFinderOpenStrategyResult {
+};
+export interface PathFinderOpenStrategyResult extends PathFinderResult {
     balances: Record<string, bigint>;
-    calls: Array<MultiCall>;
+    minBalances: Record<string, bigint>;
 }
-export interface PathFinderCloseResult {
+export interface PathFinderCloseResult extends PathFinderResult {
     underlyingBalance: bigint;
-    calls: Array<MultiCall>;
 }

package/lib/pathfinder/pathOptions.d.ts

@@ -1,4 +1,4 @@
-import { CurveLPToken, NetworkType } from "@gearbox-protocol/sdk-gov";
+import { BalancerLPToken, CurveLPToken, NetworkType } from "@gearbox-protocol/sdk-gov";
 import { CaTokenBalance } from "../payload/creditAccount";
 export interface PathOption {
     target: string;
@@ -10,6 +10,7 @@ export type BalanceInterface = Pick<CaTokenBalance, "balance">;
 export declare class PathOptionFactory {
     static generatePathOptions(balances: Record<string, BalanceInterface>, loopsInTx: number): Array<PathOptionSerie>;
     static getCurvePools(balances: Record<string, BalanceInterface>): Array<CurveLPToken>;
+    static getBalancerPools(balances: Record<string, BalanceInterface>): Array<BalancerLPToken>;
     static next(path: PathOptionSerie): PathOptionSerie;
     static detectNetwork(underlying: string): NetworkType;
 }

package/lib/pathfinder/pathOptions.js

@@ -5,8 +5,9 @@ const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 class PathOptionFactory {
     static generatePathOptions(balances, loopsInTx) {
         const curvePools = PathOptionFactory.getCurvePools(balances);
+        const balancerPools = PathOptionFactory.getBalancerPools(balances);
         const network = PathOptionFactory.detectNetwork(Object.keys(balances)[0]);
-        const initPO = curvePools.map(symbol => {
+        const curveInitPO = curvePools.map(symbol => {
             return {
                 target: sdk_gov_1.tokenDataByNetwork[network][symbol],
                 option: 0,
@@ -14,6 +15,14 @@ class PathOptionFactory {
                     .tokens.length,
             };
         });
+        const balancerInitPO = balancerPools.map(symbol => {
+            return {
+                target: sdk_gov_1.tokenDataByNetwork[network][symbol],
+                option: 0,
+                totalOptions: sdk_gov_1.balancerLpTokens[symbol].underlying.length,
+            };
+        });
+        const initPO = [...curveInitPO, ...balancerInitPO];
         const totalLoops = initPO.reduce((acc, item) => acc * item.totalOptions, 1);
         const result = [];
         let currentPo = [...initPO];
@@ -56,6 +65,16 @@ class PathOptionFactory {
         ]);
         return Array.from(curveSet.values());
     }
+    static getBalancerPools(balances) {
+        const result = [];
+        for (const [token, { balance }] of Object.entries(balances)) {
+            const symbol = sdk_gov_1.tokenSymbolByAddress[token.toLowerCase()];
+            if ((0, sdk_gov_1.isBalancerLPToken)(symbol) && (0, sdk_gov_1.toBigInt)(balance) > 1) {
+                result.push(symbol);
+            }
+        }
+        return result;
+    }
     static next(path) {
         let newPath = [...path];
         for (let i = path.length - 1; i >= 0; i--) {

package/lib/pathfinder/pathOptions.spec.js

@@ -61,7 +61,7 @@ describe("PathOptionFactory test", () => {
             [sdk_gov_1.tokenDataByNetwork.Mainnet["3Crv"]]: { balance: 200n },
             [sdk_gov_1.tokenDataByNetwork.Mainnet.USDC]: { balance: 200n },
             [sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX3CRV]: { balance: 200n },
-            [sdk_gov_1.tokenDataByNetwork.Mainnet.LUSD3CRV]: { balance: 200n },
+            [sdk_gov_1.tokenDataByNetwork.Mainnet["50OHM_50DAI"]]: { balance: 200n },
         };
         const result = pathOptions_1.PathOptionFactory.generatePathOptions(balances, 4);
         const expected = [
@@ -76,7 +76,7 @@ describe("PathOptionFactory test", () => {
                 totalOptions: 2,
             },
             {
-                target: sdk_gov_1.tokenDataByNetwork.Mainnet.LUSD3CRV,
+                target: sdk_gov_1.tokenDataByNetwork.Mainnet["50OHM_50DAI"],
                 option: 0,
                 totalOptions: 2,
             },