@gearbox-protocol/sdk 3.0.0-next.236 → 3.0.0-next.238

package/lib/parsers/uniV3AdapterParser.spec.js

@@ -0,0 +1,96 @@
+"use strict";
+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 uniV3AdapterParser_1 = require("./uniV3AdapterParser");
+const pathToUniV3Path = (path) => {
+    const pathWithFees = [];
+    const types = [];
+    path.forEach((p, num) => {
+        pathWithFees.push(p);
+        types.push("address");
+        if (num !== path.length - 1) {
+            pathWithFees.push(3000);
+            types.push("uint24");
+        }
+    });
+    return (0, viem_1.encodePacked)(types, pathWithFees);
+};
+describe("UniswapV3AdapterParser test", () => {
+    it("swap functions works well", () => {
+        let parser = new uniV3AdapterParser_1.UniswapV3AdapterParser("UNISWAP_V3_ROUTER", false);
+        let parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iUniswapV3AdapterAbi,
+            functionName: "exactInput",
+            args: [
+                {
+                    path: pathToUniV3Path([
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                    ]),
+                    recipient: sdk_gov_1.DUMB_ADDRESS,
+                    deadline: 1232131n,
+                    amountIn: sdk_gov_1.WAD * 12399n,
+                    amountOutMinimum: BigInt(1e6) * 122n,
+                },
+            ],
+        }));
+        (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactInput(amountIn: 12.39K [12399000000000000000000], amountOutMinimum: 122.00 [122000000],  path: AAVE ==(fee: 3000)==> LINK ==(fee: 3000)==> USDC", "Incorrect parse swapExactTokensForTokens");
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iUniswapV3AdapterAbi,
+            functionName: "exactDiffInput",
+            args: [
+                {
+                    path: pathToUniV3Path([
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                    ]),
+                    leftoverAmount: sdk_gov_1.WAD * 12399n,
+                    rateMinRAY: sdk_gov_1.RAY * 1200n,
+                    deadline: 1232131n,
+                },
+            ],
+        }));
+        (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactDiffInput(leftoverAmount: 12.39K [12399000000000000000000], rate: 1.20K,  path: AAVE ==(fee: 3000)==> LINK ==(fee: 3000)==> USDC", "Incorrect parse swapExactTokensForTokens");
+        // parsed = parser.parse(
+        //   ifc.encodeFunctionData("exactOutputSingle", [
+        //     {
+        //       tokenIn: tokenDataByNetwork.Arbitrum["1INCH"],
+        //       tokenOut: tokenDataByNetwork.Arbitrum.USDC,
+        //       fee: 10000,
+        //       recipient: DUMB_ADDRESS,
+        //       deadline: 12300,
+        //       amountInMaximum: (WAD * 149n) / 1000n,
+        //       amountOut: 102e6,
+        //       sqrtPriceLimitX96: 0,
+        //     },
+        //   ]),
+        // );
+        // expect(parsed).to.be.eq(
+        //   "UniswapV3Adapter[UNISWAP_V3_ROUTER].exactOutputSingle(amountInMaximum: 0.14 [149000000000000000], amountOut: 102.00 [102000000],  path: 1INCH ==(fee: 10000)==> USDC)",
+        //   "Incorrect parse swapExactTokensForTokens",
+        // );
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iUniswapV3AdapterAbi,
+            functionName: "exactOutput",
+            args: [
+                {
+                    path: pathToUniV3Path([
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.AAVE,
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.LINK,
+                        sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                    ]),
+                    recipient: sdk_gov_1.DUMB_ADDRESS,
+                    deadline: 1232131n,
+                    amountInMaximum: 123000000n,
+                    amountOut: sdk_gov_1.WAD * 122n,
+                },
+            ],
+        }));
+        (0, chai_1.expect)(parsed).to.be.eq("UniswapV3Adapter[UNISWAP_V3_ROUTER].exactOutput(amountInMaximum: 123.00 [123000000], amountOut: 122.00 [122000000000000000000],  path: USDC ==(fee: 3000)==> LINK ==(fee: 3000)==> AAVE", "Incorrect parse swapExactTokensForTokens");
+    });
+});

package/lib/parsers/wstETHAdapterParser.d.ts

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

package/lib/parsers/wstETHAdapterParser.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WstETHAdapterParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class WstETHAdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.abi = !isContract ? types_1.iwstEthv1AdapterAbi : types_1.iwstEthAbi;
+        if (!isContract)
+            this.adapterName = "wstETHAdapter";
+    }
+    parse(calldata) {
+        const { functionData, functionName } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "wrap": {
+                const [amount] = functionData.args || [];
+                return `${functionName}(amount: ${this.formatBN(amount, "STETH")})`;
+            }
+            case "wrapDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
+            }
+            case "unwrap": {
+                const [amount] = functionData.args || [];
+                return `${functionName}(amount: ${this.formatBN(amount, "wstETH")})`;
+            }
+            case "unwrapDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
+            }
+            case "balanceOf": {
+                const [address] = functionData.args || [];
+                return `${functionName}(${address})`;
+            }
+            case "allowance": {
+                const [account, to] = functionData.args || [];
+                return `${functionName}(account: ${account}, to: ${to})`;
+            }
+            case "approve": {
+                const [spender, amount] = functionData.args || [];
+                return `${functionName}(${spender}, [${(0, sdk_gov_1.toBigInt)(amount).toString()}])`;
+            }
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+}
+exports.WstETHAdapterParser = WstETHAdapterParser;

package/lib/parsers/wstETHAdapterParser.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/parsers/wstETHAdapterParser.spec.js

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

@@ -0,0 +1 @@
+export {};

package/lib/parsers/yearnAdapterParser.spec.js

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

package/lib/parsers/yearnV2AdapterParser.d.ts

@@ -0,0 +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: Address): string;
+}

package/lib/parsers/yearnV2AdapterParser.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YearnV2AdapterParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class YearnV2AdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.abi = types_1.iYearnV2AdapterAbi;
+        if (!isContract)
+            this.adapterName = "YearnV2Adapter";
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "deposit":
+            case "withdraw":
+            case "withdraw(uint256,address,uint256)": {
+                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})`;
+            }
+            case "depositDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                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] = functionData.args || [];
+                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}()`;
+            }
+            case "balanceOf": {
+                const [address] = functionData.args || [];
+                return `${functionName}(${address})`;
+            }
+            case "allowance": {
+                const [account, to] = functionData.args || [];
+                return `${functionName}(account: ${account}, to: ${to})`;
+            }
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+}
+exports.YearnV2AdapterParser = YearnV2AdapterParser;

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,8 +1,22 @@
 import { Address } from "viem";
+export declare enum SwapOperation {
+    EXACT_INPUT = 0,
+    EXACT_INPUT_ALL = 1,
+    EXACT_OUTPUT = 2
+}
 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;
     minAmount: bigint;

package/lib/pathfinder/core.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapOperation = void 0;
+var SwapOperation;
+(function (SwapOperation) {
+    SwapOperation[SwapOperation["EXACT_INPUT"] = 0] = "EXACT_INPUT";
+    SwapOperation[SwapOperation["EXACT_INPUT_ALL"] = 1] = "EXACT_INPUT_ALL";
+    SwapOperation[SwapOperation["EXACT_OUTPUT"] = 2] = "EXACT_OUTPUT";
+})(SwapOperation = exports.SwapOperation || (exports.SwapOperation = {}));

package/lib/pathfinder/index.d.ts

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

package/lib/pathfinder/index.js

@@ -15,3 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 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

@@ -0,0 +1,16 @@
+import { BalancerLPToken, CurveLPToken, NetworkType } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { CaTokenBalance } from "../payload/creditAccount";
+export interface PathOption {
+    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<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;
+}

package/lib/pathfinder/pathOptions.js

@@ -0,0 +1,93 @@
+"use strict";
+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, network) {
+        const curvePools = PathOptionFactory.getCurvePools(balances);
+        const balancerPools = PathOptionFactory.getBalancerPools(balances);
+        const curveInitPO = curvePools.map(symbol => {
+            return {
+                target: sdk_gov_1.tokenDataByNetwork[network][symbol],
+                option: 0,
+                totalOptions: sdk_gov_1.contractParams[sdk_gov_1.curveTokens[symbol].pool]
+                    .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];
+        for (let i = 0; i < totalLoops; i++) {
+            if (i % loopsInTx === 0) {
+                result.push(currentPo);
+            }
+            if (i < totalLoops - 1) {
+                currentPo = PathOptionFactory.next(currentPo);
+            }
+        }
+        return result;
+    }
+    static getCurvePools(balances) {
+        const nonZeroBalances = Object.entries(balances).filter(([, balance]) => balance.balance > 1);
+        const curvePools = nonZeroBalances
+            .map(([token]) => sdk_gov_1.tokenSymbolByAddress[token.toLowerCase()])
+            .filter(symbol => (0, sdk_gov_1.isCurveLPToken)(symbol));
+        const yearnCurveTokens = Object.entries(sdk_gov_1.yearnTokens)
+            .filter(([, data]) => (0, sdk_gov_1.isCurveLPToken)(data.underlying))
+            .map(([token]) => token);
+        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]) => (0, sdk_gov_1.isCurveLPToken)(data.underlying))
+            .map(([token]) => token);
+        const curvePoolsFromConvex = nonZeroBalances
+            .map(([token]) => sdk_gov_1.tokenSymbolByAddress[token.toLowerCase()])
+            .filter(symbol => convexCurveTokens.includes(symbol))
+            .map(symbol => sdk_gov_1.convexTokens[symbol].underlying);
+        const curveSet = new Set([
+            ...curvePools,
+            ...curvePoolsFromYearn,
+            ...curvePoolsFromConvex,
+        ]);
+        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--) {
+            const po = { ...newPath[i] };
+            po.option++;
+            newPath[i] = po;
+            if (po.option < po.totalOptions)
+                return newPath;
+            po.option = 0;
+        }
+        throw new Error("Path options overflow");
+    }
+}
+exports.PathOptionFactory = PathOptionFactory;

package/lib/pathfinder/pathOptions.spec.d.ts

@@ -0,0 +1 @@
+export {};