@gearbox-protocol/sdk 3.0.0-next.13 → 3.0.0-next.130

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,14 +39,15 @@ class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
                 const amountInMaxStr = this.formatBN(amountInMax, tokenOut);
                 return `${functionName}(amountOut: ${amountOutStr}, amountInMax: ${amountInMaxStr}, path: [${pathStr}])`;
             }
-            case "swapAllTokensForTokens": {
-                const [rateMinRAY, path] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(rate: ${(0, 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(" => ")}])`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
 }

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);
@@ -56,7 +58,7 @@ class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
                 return `${functionName}(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, calldata);
         }
     }
     trackInputPath(path) {

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);
@@ -43,7 +45,7 @@ class WstETHAdapterParser extends abstractParser_1.AbstractParser {
                 return `${functionName}(${spender}, [${(0, sdk_gov_1.toBigInt)(amount).toString()}])`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, 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}()`;
             }
@@ -40,7 +50,7 @@ class YearnV2AdapterParser extends abstractParser_1.AbstractParser {
                 return `${functionName}(account: ${account}, to: ${to})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(functionName, functionFragment, 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,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/index.d.ts

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

package/lib/{core/pool → pathfinder}/index.js

@@ -14,4 +14,7 @@ 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("./data"), exports);
+__exportStar(require("./core"), exports);
+__exportStar(require("./pathfinder"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./v1/pathfinderv1"), exports);

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

@@ -2,11 +2,13 @@
 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) {
         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 +16,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 +38,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]) => (0, sdk_gov_1.toBigInt)(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 +63,21 @@ class PathOptionFactory {
         ]);
         return Array.from(curveSet.values());
     }
+    static getBalancerPools(balances) {
+        const nonZeroBalances = Object.entries(balances).filter(([, balance]) => (0, sdk_gov_1.toBigInt)(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--) {

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,
             },

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 { providers, Signer } from "ethers";
+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 { IRouterV3 } from "../types";
+import { PathFinderCloseResult, PathFinderOpenStrategyResult, PathFinderResult, SwapOperation } from "./core";
+interface FindAllSwapsProps {
+    creditAccount: CreditAccountData;
+    swapOperation: SwapOperation;
+    tokenIn: string;
+    tokenOut: string;
     amount: bigint;
-    calls: Array<MultiCall>;
-    gasUsage: bigint;
+    leftoverAmount: bigint;
+    slippage: number;
+}
+interface FindOneTokenPathProps {
+    creditAccount: CreditAccountData;
+    tokenIn: string;
+    tokenOut: string;
+    amount: bigint;
+    slippage: number;
+}
+interface FindBestClosePathProps {
+    creditAccount: CreditAccountData;
+    creditManager: CreditManagerData;
+    expectedBalances: Record<string, Asset>;
+    leftoverBalances: Record<string, Asset>;
+    slippage: number;
+    noConcurrency?: boolean;
+}
+interface FindOpenStrategyPathProps {
+    creditManager: CreditManagerData;
+    expectedBalances: Record<string, Asset>;
+    leftoverBalances: Record<string, Asset>;
+    target: string;
+    slippage: number;
 }
 export declare class PathFinder {
-    pathFinder: IRouter;
+    pathFinder: IRouterV3;
     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>;
+    constructor(address: string, provider: Signer | providers.Provider, 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, 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;
+    findBestClosePath({ creditAccount, creditManager: cm, expectedBalances, leftoverBalances, slippage, noConcurrency, }: FindBestClosePathProps): Promise<PathFinderCloseResult>;
+    static compare(r1: PathFinderResult, r2: PathFinderResult): PathFinderResult;
     getAvailableConnectors(availableList: Record<string, bigint> | Record<string, true>): string[];
     static getAvailableConnectors(availableList: Record<string, bigint> | Record<string, true>, connectors: string[]): string[];
 }
+export {};