@gearbox-protocol/sdk 3.0.0-next.24 → 3.0.0-next.241

package/lib/parsers/wstETHAdapterParser.spec.js

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

package/lib/parsers/yearnAdapterParser.spec.js

@@ -2,35 +2,53 @@
 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 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)", [sdk_gov_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)", [
-            sdk_gov_1.WAD * 19000n,
-            sdk_gov_1.DUMB_ADDRESS,
-        ]));
+        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(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)", [sdk_gov_1.WAD * 19000n]));
+        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)", [
-            sdk_gov_1.WAD * 19000n,
-            sdk_gov_1.DUMB_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],
+        }));
         (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(ifc.encodeFunctionData("withdraw(uint256,address,uint256)", [
-            sdk_gov_1.WAD * 19000n,
-            sdk_gov_1.DUMB_ADDRESS,
-            555,
-        ]));
+        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

@@ -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 YearnV2AdapterParser extends AbstractParser implements IParser {
     constructor(contract: SupportedContract, isContract: boolean);
-    parse(calldata: string): string;
+    parse(calldata: Address): string;
 }

package/lib/parsers/yearnV2AdapterParser.js

@@ -7,40 +7,50 @@ const abstractParser_1 = require("./abstractParser");
 class YearnV2AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.IYVault__factory.createInterface();
+        this.abi = types_1.iYearnV2AdapterAbi;
         if (!isContract)
             this.adapterName = "YearnV2Adapter";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { operationName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "deposit":
             case "withdraw":
-            case "deposit(uint256)":
-            case "withdraw(uint256)":
             case "withdraw(uint256,address,uint256)": {
-                const [amount, address, maxLoss] = this.decodeFunctionData(functionFragment, calldata);
+                const [amount, address, maxLoss] = functionData.args || [];
                 const yvSym = this.tokenSymbol(sdk_gov_1.contractsByNetwork.Mainnet[this.contract]);
                 const amountStr = amount
                     ? `amount: ${this.formatBN(amount, yvSym)}`
                     : "";
                 const addressStr = address ? `, address: ${address}` : "";
                 const maxLossStr = maxLoss ? `, maxLoss: ${maxLoss}` : "";
-                return `${functionName}(${amountStr}${addressStr}${maxLossStr})`;
+                return `${operationName}(${amountStr}${addressStr}${maxLossStr})`;
+            }
+            case "depositDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                const yvSym = this.tokenSymbol(sdk_gov_1.contractsByNetwork.Mainnet[this.contract]);
+                const leftoverAmountStr = this.formatBN(leftoverAmount, yvSym);
+                return `${operationName}(leftoverAmount: ${leftoverAmountStr})`;
+            }
+            case "withdrawDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                const yvSym = this.tokenSymbol(sdk_gov_1.contractsByNetwork.Mainnet[this.contract]);
+                const leftoverAmountStr = this.formatBN(leftoverAmount, yvSym);
+                return `${operationName}(leftoverAmount: ${leftoverAmountStr})`;
             }
             case "pricePerShare": {
-                return `${functionName}()`;
+                return `${operationName}()`;
             }
             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})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, operationName, calldata);
         }
     }
 }

package/lib/pathfinder/balancerVault.d.ts

@@ -0,0 +1,33 @@
+export declare enum PoolSpecialization {
+    GeneralPool = 0,
+    MinimalSwapInfoPool = 1,
+    TwoTokenPool = 2
+}
+/**
+ * Splits a poolId into its components, i.e. pool address, pool specialization and its nonce
+ * @param poolId - a bytes32 string of the pool's ID
+ * @returns an object with the decomposed poolId
+ */
+export declare const splitPoolId: (poolId: string) => {
+    address: string;
+    specialization: PoolSpecialization;
+    nonce: bigint;
+};
+/**
+ * Extracts a pool's address from its poolId
+ * @param poolId - a bytes32 string of the pool's ID
+ * @returns the pool's address
+ */
+export declare const getPoolAddress: (poolId: string) => string;
+/**
+ * Extracts a pool's specialization from its poolId
+ * @param poolId - a bytes32 string of the pool's ID
+ * @returns the pool's specialization
+ */
+export declare const getPoolSpecialization: (poolId: string) => PoolSpecialization;
+/**
+ * Extracts a pool's nonce from its poolId
+ * @param poolId - a bytes32 string of the pool's ID
+ * @returns the pool's nonce
+ */
+export declare const getPoolNonce: (poolId: string) => bigint;

package/lib/pathfinder/balancerVault.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPoolNonce = exports.getPoolSpecialization = exports.getPoolAddress = exports.splitPoolId = exports.PoolSpecialization = void 0;
+var PoolSpecialization;
+(function (PoolSpecialization) {
+    PoolSpecialization[PoolSpecialization["GeneralPool"] = 0] = "GeneralPool";
+    PoolSpecialization[PoolSpecialization["MinimalSwapInfoPool"] = 1] = "MinimalSwapInfoPool";
+    PoolSpecialization[PoolSpecialization["TwoTokenPool"] = 2] = "TwoTokenPool";
+})(PoolSpecialization = exports.PoolSpecialization || (exports.PoolSpecialization = {}));
+/**
+ * Splits a poolId into its components, i.e. pool address, pool specialization and its nonce
+ * @param poolId - a bytes32 string of the pool's ID
+ * @returns an object with the decomposed poolId
+ */
+const splitPoolId = (poolId) => {
+    return {
+        address: (0, exports.getPoolAddress)(poolId),
+        specialization: (0, exports.getPoolSpecialization)(poolId),
+        nonce: (0, exports.getPoolNonce)(poolId),
+    };
+};
+exports.splitPoolId = splitPoolId;
+/**
+ * Extracts a pool's address from its poolId
+ * @param poolId - a bytes32 string of the pool's ID
+ * @returns the pool's address
+ */
+const getPoolAddress = (poolId) => {
+    if (poolId.length !== 66)
+        throw new Error("Invalid poolId length");
+    return poolId.slice(0, 42);
+};
+exports.getPoolAddress = getPoolAddress;
+/**
+ * Extracts a pool's specialization from its poolId
+ * @param poolId - a bytes32 string of the pool's ID
+ * @returns the pool's specialization
+ */
+const getPoolSpecialization = (poolId) => {
+    if (poolId.length !== 66)
+        throw new Error("Invalid poolId length");
+    // Only have 3 pool specializations so we can just pull the relevant character
+    const specializationCode = parseInt(poolId[45], 10);
+    if (specializationCode >= 3)
+        throw new Error("Invalid pool specialization");
+    return specializationCode;
+};
+exports.getPoolSpecialization = getPoolSpecialization;
+/**
+ * Extracts a pool's nonce from its poolId
+ * @param poolId - a bytes32 string of the pool's ID
+ * @returns the pool's nonce
+ */
+const getPoolNonce = (poolId) => {
+    if (poolId.length !== 66)
+        throw new Error("Invalid poolId length");
+    return BigInt(`0x${poolId.slice(46)}`);
+};
+exports.getPoolNonce = getPoolNonce;

package/lib/pathfinder/core.d.ts

@@ -1,21 +1,31 @@
-import { ExcludeArrayProps } from "@gearbox-protocol/sdk-gov";
-import { MultiCallStructOutput, SwapTaskStructOutput } from "../types/IRouter";
+import { Address } from "viem";
 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 MultiCall {
+    target: Address;
+    callData: Address;
+}
+export interface SwapTask {
+    swapOperation: number;
+    creditAccount: Address;
+    tokenIn: Address;
+    tokenOut: Address;
+    connectors: Address[];
+    amount: bigint;
+    leftoverAmount: bigint;
+}
 export interface PathFinderResult {
     amount: bigint;
-    calls: Array<MultiCall>;
+    minAmount: bigint;
+    calls: MultiCall[];
 }
-export interface PathFinderOpenStrategyResult {
-    balances: Record<string, bigint>;
-    calls: Array<MultiCall>;
+export interface PathFinderOpenStrategyResult extends PathFinderResult {
+    balances: Record<Address, bigint>;
+    minBalances: Record<Address, bigint>;
 }
-export interface PathFinderCloseResult {
+export interface PathFinderCloseResult extends PathFinderResult {
     underlyingBalance: bigint;
-    calls: Array<MultiCall>;
 }

package/lib/pathfinder/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./core";
+export * from "./pathfinder";
+export * from "./pathOptions";
+export * from "./utils";

package/lib/pathfinder/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core"), exports);
+__exportStar(require("./pathfinder"), exports);
+__exportStar(require("./pathOptions"), exports);
+__exportStar(require("./utils"), exports);

package/lib/pathfinder/pathOptions.d.ts

@@ -1,15 +1,16 @@
-import { CurveLPToken, NetworkType } from "@gearbox-protocol/sdk-gov";
+import { BalancerLPToken, CurveLPToken, NetworkType } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
 import { CaTokenBalance } from "../payload/creditAccount";
 export interface PathOption {
-    target: string;
+    target: Address;
     option: number;
     totalOptions: number;
 }
 export type PathOptionSerie = Array<PathOption>;
 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 generatePathOptions(balances: Record<Address, BalanceInterface>, loopsInTx: number, network: NetworkType): Array<PathOptionSerie>;
+    static getCurvePools(balances: Record<Address, BalanceInterface>): Array<CurveLPToken>;
+    static getBalancerPools(balances: Record<Address, BalanceInterface>): Array<BalancerLPToken>;
     static next(path: PathOptionSerie): PathOptionSerie;
-    static detectNetwork(underlying: string): NetworkType;
 }

package/lib/pathfinder/pathOptions.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PathOptionFactory = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const aura_1 = require("@gearbox-protocol/sdk-gov/lib/tokens/aura");
 class PathOptionFactory {
-    static generatePathOptions(balances, loopsInTx) {
+    static generatePathOptions(balances, loopsInTx, network) {
         const curvePools = PathOptionFactory.getCurvePools(balances);
-        const network = PathOptionFactory.detectNetwork(Object.keys(balances)[0]);
-        const initPO = curvePools.map(symbol => {
+        const balancerPools = PathOptionFactory.getBalancerPools(balances);
+        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];
@@ -28,24 +37,21 @@ class PathOptionFactory {
         return result;
     }
     static getCurvePools(balances) {
-        const curveSymbols = Object.keys(sdk_gov_1.curveTokens);
-        const curvePools = Object.entries(balances)
-            .filter(([, balance]) => (0, sdk_gov_1.toBigInt)(balance.balance) > 1)
+        const nonZeroBalances = Object.entries(balances).filter(([, balance]) => balance.balance > 1);
+        const curvePools = nonZeroBalances
             .map(([token]) => sdk_gov_1.tokenSymbolByAddress[token.toLowerCase()])
-            .filter(symbol => curveSymbols.includes(symbol));
+            .filter(symbol => (0, sdk_gov_1.isCurveLPToken)(symbol));
         const yearnCurveTokens = Object.entries(sdk_gov_1.yearnTokens)
-            .filter(([, data]) => curveSymbols.includes(data.underlying))
+            .filter(([, data]) => (0, sdk_gov_1.isCurveLPToken)(data.underlying))
             .map(([token]) => token);
-        const curvePoolsFromYearn = Object.entries(balances)
-            .filter(([, balance]) => (0, sdk_gov_1.toBigInt)(balance.balance) > 1)
+        const curvePoolsFromYearn = nonZeroBalances
             .map(([token]) => sdk_gov_1.tokenSymbolByAddress[token.toLowerCase()])
             .filter(symbol => yearnCurveTokens.includes(symbol))
             .map(symbol => sdk_gov_1.yearnTokens[symbol].underlying);
         const convexCurveTokens = Object.entries(sdk_gov_1.convexTokens)
-            .filter(([, data]) => curveSymbols.includes(data.underlying))
+            .filter(([, data]) => (0, sdk_gov_1.isCurveLPToken)(data.underlying))
             .map(([token]) => token);
-        const curvePoolsFromConvex = Object.entries(balances)
-            .filter(([, balance]) => (0, sdk_gov_1.toBigInt)(balance.balance) > 1)
+        const curvePoolsFromConvex = nonZeroBalances
             .map(([token]) => sdk_gov_1.tokenSymbolByAddress[token.toLowerCase()])
             .filter(symbol => convexCurveTokens.includes(symbol))
             .map(symbol => sdk_gov_1.convexTokens[symbol].underlying);
@@ -56,6 +62,21 @@ class PathOptionFactory {
         ]);
         return Array.from(curveSet.values());
     }
+    static getBalancerPools(balances) {
+        const nonZeroBalances = Object.entries(balances).filter(([, balance]) => balance.balance > 1);
+        const balancerPools = nonZeroBalances
+            .map(([token]) => sdk_gov_1.tokenSymbolByAddress[token.toLowerCase()])
+            .filter(symbol => (0, sdk_gov_1.isBalancerLPToken)(symbol));
+        const balancerAuraTokens = Object.entries(aura_1.auraTokens)
+            .filter(([, data]) => (0, sdk_gov_1.isBalancerLPToken)(data.underlying))
+            .map(([token]) => token);
+        const balancerTokensFromAura = nonZeroBalances
+            .map(([token]) => sdk_gov_1.tokenSymbolByAddress[token.toLowerCase()])
+            .filter(symbol => balancerAuraTokens.includes(symbol))
+            .map(symbol => aura_1.auraTokens[symbol].underlying);
+        const balancerSet = new Set([...balancerPools, ...balancerTokensFromAura]);
+        return Array.from(balancerSet.values());
+    }
     static next(path) {
         let newPath = [...path];
         for (let i = path.length - 1; i >= 0; i--) {
@@ -68,10 +89,5 @@ class PathOptionFactory {
         }
         throw new Error("Path options overflow");
     }
-    static detectNetwork(underlying) {
-        return sdk_gov_1.tokenDataByNetwork.Mainnet[sdk_gov_1.tokenSymbolByAddress[underlying.toLowerCase()]].toLowerCase() === underlying.toLowerCase()
-            ? "Mainnet"
-            : "Arbitrum";
-    }
 }
 exports.PathOptionFactory = PathOptionFactory;

package/lib/pathfinder/pathOptions.spec.js

@@ -61,9 +61,9 @@ 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 result = pathOptions_1.PathOptionFactory.generatePathOptions(balances, 4, "Mainnet");
         const expected = [
             {
                 target: sdk_gov_1.tokenDataByNetwork.Mainnet["3Crv"],
@@ -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,
             },
@@ -135,7 +135,4 @@ describe("PathOptionFactory test", () => {
         expectedCurvePools = ["3Crv", "steCRV"];
         (0, chai_1.expect)(pathOptions_1.PathOptionFactory.getCurvePools(balances)).to.be.eql(expectedCurvePools);
     });
-    it("detectNetwork works correctly", () => {
-        (0, chai_1.expect)(pathOptions_1.PathOptionFactory.detectNetwork(sdk_gov_1.tokenDataByNetwork.Mainnet["1INCH"])).to.be.eq("Mainnet");
-    });
 });

package/lib/pathfinder/pathfinder.d.ts

@@ -1,45 +1,72 @@
-import { NetworkType, SupportedToken } from "@gearbox-protocol/sdk-gov";
-import { BigNumberish, providers, Signer } from "ethers";
+import { NetworkType } from "@gearbox-protocol/sdk-gov";
+import { Address, GetContractReturnType, PublicClient } from "viem";
+import { Asset } from "../core/assets";
 import { CreditAccountData } from "../core/creditAccount";
 import { CreditManagerData } from "../core/creditManager";
-import { IRouter } from "../types";
-import { MultiCall, PathFinderCloseResult, PathFinderOpenStrategyResult, PathFinderResult, SwapOperation } from "./core";
-export interface CloseResult {
+import { iRouterV3Abi } from "../types";
+import { PathFinderCloseResult, PathFinderOpenStrategyResult, PathFinderResult, SwapOperation } from "./core";
+interface FindAllSwapsProps {
+    creditAccount: CreditAccountData;
+    swapOperation: SwapOperation;
+    tokenIn: Address;
+    tokenOut: Address;
     amount: bigint;
-    calls: Array<MultiCall>;
-    gasUsage: bigint;
+    leftoverAmount: bigint;
+    slippage: number;
+}
+interface FindOneTokenPathProps {
+    creditAccount: CreditAccountData;
+    tokenIn: Address;
+    tokenOut: Address;
+    amount: bigint;
+    slippage: number;
+}
+interface FindBestClosePathProps {
+    creditAccount: CreditAccountData;
+    creditManager: CreditManagerData;
+    expectedBalances: Record<Address, Asset>;
+    leftoverBalances: Record<Address, Asset>;
+    slippage: number;
+    network: NetworkType;
+}
+interface FindOpenStrategyPathProps {
+    creditManager: CreditManagerData;
+    expectedBalances: Record<Address, Asset>;
+    leftoverBalances: Record<Address, Asset>;
+    target: Address;
+    slippage: number;
 }
 export declare class PathFinder {
-    pathFinder: IRouter;
+    pathFinder: GetContractReturnType<typeof iRouterV3Abi, PublicClient>;
     network: NetworkType;
-    static connectors: Array<SupportedToken>;
-    protected readonly _connectors: Array<string>;
-    constructor(address: string, provider: Signer | providers.Provider, network?: NetworkType, connectors?: SupportedToken[]);
-    findAllSwaps(creditAccount: CreditAccountData, swapOperation: SwapOperation, tokenIn: SupportedToken | string, tokenOut: SupportedToken | string, amount: BigNumberish, slippage: number): Promise<Array<PathFinderResult>>;
-    findOneTokenPath(creditAccount: CreditAccountData, tokenIn: SupportedToken | string, tokenOut: SupportedToken | string, amount: BigNumberish, slippage: number): Promise<PathFinderResult>;
+    protected readonly _connectors: Array<Address>;
+    constructor(address: Address, provider: PublicClient, network?: NetworkType);
+    findAllSwaps({ creditAccount, swapOperation, tokenIn, tokenOut, amount, leftoverAmount, slippage, }: FindAllSwapsProps): Promise<Array<PathFinderResult>>;
+    findOneTokenPath({ creditAccount, tokenIn, tokenOut, amount, slippage, }: FindOneTokenPathProps): Promise<PathFinderResult>;
     /**
-     * @dev Finds the best path for opening credit account and converting all NORMAL tokens and LP token in the way to TARGET
-     * @param cm CreditManagerData which represents credit manager you want to use to open credit account
+     * @dev Finds the best path for opening Credit Account and converting all NORMAL tokens and LP token in the way to TARGET
+     * @param cm CreditManagerData which represents credit manager you want to use to open Credit Account
      * @param expectedBalances Expected balances which would be on account accounting also debt. For example,
-     *    if you open an USDC credit account, borrow 50_000 USDC and provide 10 WETH and 10_USDC as collateral
+     *    if you open an USDC Credit Account, borrow 50_000 USDC and provide 10 WETH and 10_USDC as collateral
      *    from your own funds, expectedBalances should be: { "USDC": 60_000 * (10**6), "<address of WETH>": WAD.mul(10) }
      *
      * @param target Address of symbol of desired token
      * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
      * @returns PathFinderOpenStrategyResult which
      */
-    findOpenStrategyPath(cm: CreditManagerData, expectedBalances: Record<SupportedToken | string, BigNumberish>, target: SupportedToken | string, slippage: number): Promise<PathFinderOpenStrategyResult>;
+    findOpenStrategyPath({ creditManager: cm, expectedBalances, leftoverBalances, target: targetUntyped, slippage, }: FindOpenStrategyPathProps): Promise<PathFinderOpenStrategyResult>;
     /**
      * @dev Finds the path to swap / withdraw all assets from CreditAccount into underlying asset
-     *   Can bu used for closing credit account and for liquidations as well.
+     *   Can bu used for closing Credit Account and for liquidations as well.
      * @param creditAccount CreditAccountData object used for close path computation
      * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
      * @return The best option in PathFinderCloseResult format, which
      *          - underlyingBalance - total balance of underlying token
      *          - calls - list of calls which should be done to swap & unwrap everything to underlying token
      */
-    findBestClosePath(creditAccount: CreditAccountData, slippage: number, noConcurency?: boolean): Promise<PathFinderCloseResult>;
-    static compare(r1: CloseResult, r2: CloseResult, gasPriceRAY: bigint): CloseResult;
-    getAvailableConnectors(availableList: Record<string, bigint> | Record<string, true>): string[];
-    static getAvailableConnectors(availableList: Record<string, bigint> | Record<string, true>, connectors: string[]): string[];
+    findBestClosePath({ creditAccount, creditManager: cm, expectedBalances, leftoverBalances, slippage, network, }: FindBestClosePathProps): Promise<PathFinderCloseResult>;
+    static compare(r1: PathFinderResult, r2: PathFinderResult): PathFinderResult;
+    getAvailableConnectors(availableList: Record<Address, bigint> | Record<Address, true>): `0x${string}`[];
+    static getAvailableConnectors(availableList: Record<Address, bigint> | Record<Address, true>, connectors: Address[]): `0x${string}`[];
 }
+export {};