@gearbox-protocol/sdk 3.0.0-vfour.283 → 3.0.0-vfour.285

package/dist/cjs/sdk/router/RouterV300Contract.js

@@ -56,17 +56,7 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
     this.#connectors = (0, import_sdk_gov_legacy.getConnectors)(sdk.provider.networkType);
   }
   /**
-   * Finds all available swaps for given tokens; technically should be avoided to use, since doesn't have any advantage over findOneTokenPath.
-   * Deduplicates results by minAmount + strigified call path and returns only unique ones.
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-   * @param {RouterCMSlice} creditManager - minimal credit manager data {@link RouterCMSlice} on which operation is performed
-   * @param {SwapOperation} swapOperation - {@link SwapOperation} = "EXACT_INPUT" | "EXACT_INPUT_ALL" | "EXACT_OUTPUT"; however router stopped to support EXACT_OUTPUT
-   * @param {Address} tokenIn - address of input token
-   * @param {Address} tokenOut - address of output token
-   * @param {number | bigint} slippage  - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-   * @param {bigint} amount - amount of token in to swap
-   * @param {bigint} leftoverAmount - amount that should be left on account after swap; technically equals to 0 in the most of the cases
-   * @returns Array of {@link RouterResult}
+   * Implements {@link IRouterContract.findAllSwaps}
    */
   async findAllSwaps({
     creditAccount: ca,
@@ -106,16 +96,7 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
     return Object.values(unique);
   }
   /**
-   * Find the best path to swap token A to token B.
-   *  - Connectors - list of tokens which can be used as a token to align path through, for ex. when swapping sUSDe it is good to check swaps through USDe.
-   *  - #overridePTRedeem - if token is PT token and PT token is already redeemable, we need to claim it manually, since old router can't do it. This can work in old app only because you cannot swap pt_sUSDe into sUSde before maturity and when it is matured, override takes place.
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-   * @param {RouterCMSlice} creditManager - minimal credit manager data {@link RouterCMSlice} on which operation is performed
-   * @param {Address} tokenIn - address of input token
-   * @param {Address} tokenOut - address of output token
-   * @param {number | bigint} slippage  - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-   * @param {bigint} amount - amount of token in to swap
-   * @returns minAmount, avgAmount found and array of calls to execute swap
+   * Implements {@link IRouterContract.findOneTokenPath}
    */
   async findOneTokenPath(props) {
     const {
@@ -150,22 +131,7 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
     };
   }
   /**
-   * @dev Finds the best path for opening Credit Account; converts all expectedBalances besides leftoverBalances into target token
-   * @param {RouterCMSlice} creditManager - minimal credit manager data {@link RouterCMSlice} on which operation is performed
-   * @param {Array<Asset>} expectedBalances - Collateral assets + debt asset, nominated in ther respective tokens.
-   * For example, if you open an USDC Credit Account, borrow 50_000 USDC and provide 10 WETH and 10_000 DAI as collateral
-   * from your own funds, expectedBalances should be: [{amount: 10*10**wethDecimals}, {amount: 10000*10**daiDecimals}, {amount: 10000*10**usdcDecimals}]
-   * @param leftoverBalances - balances to keep on account after opening.
-   * For example if don't want to swap WETH in the example above, leftoverBalances should be: [{amount: 10*10**wethDecimals}]
-   * @param target - Address of desired token to swap into
-   * @param slippage - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-   * @returns Router return list of all balances (including 0 balances) after operation, but it doesn't include original balance
-   * - For example you had 5k sUSDS  and 5k DAI as collateral, debt is 20k DAI, router will return 25k sUDS and all other token allowed on CM will be 0n or 1n
-   * Since FE is interested in FULL balances structure, we override target balance in the following way:
-   * min = record[sUSDS] = 5k from collateral + 25k of minAmount; avg = record[sUSDS] = 5k from collateral + 25.5k of avgAmount
-   * - minAmount
-   * - avgAmount
-   * - array of calls to execute swap
+   * Implements {@link IRouterContract.findOpenStrategyPath}
    */
   async findOpenStrategyPath({
     creditManager: cm,
@@ -213,26 +179,7 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
     };
   }
   /**
-   * @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.
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-   * @param {RouterCMSlice} creditManager - minimal credit manager data {@link RouterCMSlice} on which operation is performed
-   * @param {number | bigint} slippage - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-   * @param {ClosePathBalances | undefined} balances - Balances {@link ClosePathBalances} to close account with, if not provided, all assets will be swapped according to inner logic.
-   * Consists of:
-   * @param {Array<Asset>} expectedBalances - list of all credit account balances nominated in their respective tokens.
-   *     For example: [{amount: 10x10^wethDecimals}, {amount: 10000x10^daiDecimals}]
-   * @param {Array<Asset>} leftoverBalances - list of all credit account balances that shouldn't be swapped nominated in their respective tokens.
-   *     Used for credit account repaying; in this mode leftover assets list should include all assets besides underlying token.
-   *     For example considering account above is on DAI CM: [{amount: 10x10^wethDecimals}]
-   * @return The best option in PathFinderCloseResult format, which
-   *  - underlyingBalance -  since this method swaps only tokens different from underlying,
-   *   we are more interested in TOTAL balance of underlying token after all swaps are done
-   *   for this reason we sum up underlying token that was on account before swap
-   *   with underlying token amount found during swap and call it underlyingBalance
-   *  - calls - list of calls which should be done to swap & unwrap everything to underlying token
-   *  - amount
-   *  - minAmount
+   * Implements {@link IRouterContract.findBestClosePath}
    */
   async findBestClosePath({
     creditAccount: ca,
@@ -295,11 +242,7 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
     return result;
   }
   /**
-   * Finds input to be used with findBestClosePath
-   * Is used by batch liquidator
-   * @param ca
-   * @param cm
-   * @returns
+   * Implements {@link IRouterContract.getFindClosePathInput}
    */
   getFindClosePathInput(ca, cm, balances) {
     const { expectedBalances, leftoverBalances } = this.getExpectedAndLeftover(
@@ -321,7 +264,7 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
     };
   }
   /**
-   * Connectors - list of tokens which can be used as a token to align path through, for ex. when swapping sUSDe it is good to check swaps through USDe.
+   * Implements {@link IRouterContract.getAvailableConnectors}
    */
   getAvailableConnectors(collateralTokens) {
     return collateralTokens.filter(
@@ -329,9 +272,9 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
     );
   }
   /**
-   * if token is PT token and PT token is already redeemable, we need to claim it manually, since old router can't do it. 
-      This can work in old app only because you cannot swap pt_sUSDe into sUSde before maturity and when it is matured, override takes place.
-  */
+   * If token is PT token and PT token is already redeemable, we need to claim it manually, since old router can't do it.
+   * This can work in old app only because you cannot swap pt_sUSDe into sUSde before maturity and when it is matured, override takes place.
+   */
   async #overridePTRedeem({
     creditAccount,
     creditManager,

package/dist/cjs/sdk/router/RouterV310Contract.js

@@ -21,7 +21,10 @@ __export(RouterV310Contract_exports, {
   RouterV310Contract: () => RouterV310Contract
 });
 module.exports = __toCommonJS(RouterV310Contract_exports);
+var import_viem = require("viem");
 var import_routerV310 = require("../../abi/routerV310.js");
+var import_sdk_legacy = require("../sdk-legacy/index.js");
+var import_AddressMap = require("../utils/AddressMap.js");
 var import_AbstractRouterContract = require("./AbstractRouterContract.js");
 var import_helpers = require("./helpers.js");
 const abi = import_routerV310.iGearboxRouterV310Abi;
@@ -30,29 +33,45 @@ class RouterV310Contract extends import_AbstractRouterContract.AbstractRouterCon
   constructor(sdk, address) {
     super(sdk, {
       addr: address,
-      name: "RouterV300",
+      name: "RouterV310",
       abi
     });
   }
   /**
-   * Finds best path to swap all Normal tokens and tokens "on the way" to target one and vice versa
-   * @param creditAccount
-   * @param creditManager
-   * @param tokenIn
-   * @param tokenOut
-   * @param amount
-   * @param slippage
-   * @returns
+   * Implements {@link IRouterContract.findOneTokenPath}
    */
   async findOneTokenPath(props) {
+    const {
+      creditAccount,
+      creditManager,
+      amount,
+      slippage,
+      tokenIn,
+      tokenOut
+    } = props;
+    const numSplits = this.#numSplitsGetter(
+      creditManager,
+      creditAccount.tokens
+    )(tokenIn);
+    this.logger?.debug(
+      {
+        creditAccount: creditAccount.creditAccount,
+        creditManager: this.labelAddress(creditManager.address),
+        tokenIn: this.labelAddress(tokenIn),
+        target: this.labelAddress(tokenOut),
+        amount,
+        slippage,
+        numSplits
+      },
+      "calling routeOneToOne"
+    );
     const { result } = await this.contract.simulate.routeOneToOne([
-      props.creditAccount.creditAccount,
-      props.tokenIn,
-      props.amount,
-      props.tokenOut,
-      BigInt(props.slippage),
-      4n
-      // TODO:? how many 4n or 0n for underlying
+      creditAccount.creditAccount,
+      tokenIn,
+      amount,
+      tokenOut,
+      BigInt(slippage),
+      numSplits
     ]);
     return {
       amount: result.amount,
@@ -61,15 +80,7 @@ class RouterV310Contract extends import_AbstractRouterContract.AbstractRouterCon
     };
   }
   /**
-   * @dev Finds the best path for opening Credit Account and converting all NORMAL tokens and LP token in the way to TARGET
-   * @param creditManager 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
-   *    from your own funds, expectedBalances should be: { "USDC": 60_000 * (10**6), "<address of WETH>": WAD.mul(10) }
-   * @param leftoverBalances Balances to keep on account after opening
-   * @param target Address of symbol of desired token
-   * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-   * @returns PathFinderOpenStrategyResult which
+   * Implements {@link IRouterContract.findOpenStrategyPath}
    */
   async findOpenStrategyPath(props) {
     const {
@@ -83,15 +94,24 @@ class RouterV310Contract extends import_AbstractRouterContract.AbstractRouterCon
       (0, import_helpers.balancesMap)(expectedBalances),
       (0, import_helpers.balancesMap)(leftoverBalances)
     ];
+    const getNumSplits = this.#numSplitsGetter(cm, expectedBalances);
     const tData = cm.collateralTokens.map(
       (token) => ({
         token,
         balance: expectedMap.get(token) ?? 0n,
         leftoverBalance: leftoverMap.get(token) ?? 0n,
-        numSplits: 4n
-        // TODO:? how many 4n or 0n for underlying
+        numSplits: getNumSplits(token)
       })
     );
+    this.logger?.debug(
+      {
+        creditManager: this.labelAddress(cm.address),
+        target: this.labelAddress(target),
+        slippage,
+        tData: this.#debugTokenData(tData)
+      },
+      "calling routeOpenManyToOne"
+    );
     const { result } = await this.contract.simulate.routeOpenManyToOne([
       cm.address,
       target,
@@ -99,24 +119,25 @@ class RouterV310Contract extends import_AbstractRouterContract.AbstractRouterCon
       tData
     ]);
     return {
-      balances: {},
-      // TODO:?
-      minBalances: {},
-      // TODO:?
+      balances: balancesAfterOpen(
+        target,
+        result.amount,
+        expectedMap,
+        leftoverMap
+      ),
+      minBalances: balancesAfterOpen(
+        target,
+        result.minAmount,
+        expectedMap,
+        leftoverMap
+      ),
       amount: result.amount,
       minAmount: result.minAmount,
       calls: [...result.calls]
     };
   }
   /**
-   * @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.
-   * @param creditAccount CreditAccountStruct object used for close path computation
-   * @param creditManager CreditManagerSlice for corresponding credit manager
-   * @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
+   * Implements {@link IRouterContract.findBestClosePath}
    */
   async findBestClosePath(props) {
     const { creditAccount: ca, creditManager: cm, slippage, balances } = props;
@@ -128,16 +149,26 @@ class RouterV310Contract extends import_AbstractRouterContract.AbstractRouterCon
         leftoverBalances: (0, import_helpers.assetsMap)(balances.leftoverBalances)
       } : void 0
     );
+    const getNumSplits = this.#numSplitsGetter(cm, expectedBalances.values());
     const tData = [];
     for (const token of cm.collateralTokens) {
       tData.push({
         token,
         balance: expectedBalances.get(token)?.balance || 0n,
         leftoverBalance: leftoverBalances.get(token)?.balance || 0n,
-        numSplits: 4n
-        // TODO:? how many 4n or 0n for underlying
+        numSplits: getNumSplits(token)
       });
     }
+    this.logger?.debug(
+      {
+        creditAccount: ca.creditAccount,
+        creditManager: this.labelAddress(cm.address),
+        target: this.labelAddress(ca.underlying),
+        slippage,
+        tData: this.#debugTokenData(tData)
+      },
+      "calling routeManyToOne"
+    );
     const { result } = await this.contract.simulate.routeManyToOne([
       cm.address,
       ca.underlying,
@@ -152,16 +183,74 @@ class RouterV310Contract extends import_AbstractRouterContract.AbstractRouterCon
       calls: [...result.calls]
     };
   }
+  #numSplitsGetter(creditManager, assets) {
+    const { priceOracle } = this.sdk.marketRegister.findByCreditManager(
+      creditManager.address
+    );
+    const inUSD = assets.filter(({ token, balance }) => {
+      const decimals = this.sdk.tokensMeta.decimals(token);
+      const minBalance = 10n ** BigInt(Math.max(8, decimals) - 8);
+      return balance >= minBalance;
+    }).map(({ token, balance }) => {
+      return {
+        token,
+        balance: priceOracle.convertToUSD(token, balance)
+      };
+    }).sort((a, b) => {
+      return b.balance > a.balance ? -1 : 1;
+    });
+    const map = new import_AddressMap.AddressMap(
+      inUSD.map(({ token }, i) => [token, i === 0 ? 4n : 1n])
+    );
+    return (token) => map.get(token) ?? 1n;
+  }
+  #debugTokenData(tData) {
+    return tData.map((t) => ({
+      token: this.labelAddress(t.token),
+      balance: this.sdk.tokensMeta.formatBN(t.token, t.balance),
+      leftoverBalance: this.sdk.tokensMeta.formatBN(t.token, t.leftoverBalance),
+      numSplits: t.numSplits
+    }));
+  }
+  /**
+   * Implements {@link IRouterContract.findAllSwaps}
+   * @deprecated v3.0 legacy method
+   */
   findAllSwaps(props) {
     throw ERR_NOT_IMPLEMENTED;
   }
+  /**
+   * Implements {@link IRouterContract.getAvailableConnectors}
+   * @deprecated v3.0 legacy method
+   */
   getAvailableConnectors(collateralTokens) {
     throw ERR_NOT_IMPLEMENTED;
   }
+  /**
+   * Implements {@link IRouterContract.getFindClosePathInput}
+   * @deprecated v3.0 legacy method
+   */
   getFindClosePathInput(ca, cm, balances) {
     throw ERR_NOT_IMPLEMENTED;
   }
 }
+function balancesAfterOpen(target, targetAmount, expected, leftover) {
+  const result = {};
+  const targetAddr = (0, import_viem.getAddress)(target);
+  const tokens = /* @__PURE__ */ new Set([
+    ...expected.keys(),
+    ...leftover.keys(),
+    targetAddr
+  ]);
+  for (const t of tokens) {
+    if (t === targetAddr) {
+      result[t] = expected.get(t) ?? 0n + targetAmount;
+    } else {
+      result[t] = import_sdk_legacy.BigIntMath.min(expected.get(t) ?? 0n, leftover.get(t) ?? 0n);
+    }
+  }
+  return result;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RouterV310Contract

package/dist/esm/sdk/router/RouterV300Contract.js

@@ -33,17 +33,7 @@ class RouterV300Contract extends AbstractRouterContract {
     this.#connectors = getConnectors(sdk.provider.networkType);
   }
   /**
-   * Finds all available swaps for given tokens; technically should be avoided to use, since doesn't have any advantage over findOneTokenPath.
-   * Deduplicates results by minAmount + strigified call path and returns only unique ones.
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-   * @param {RouterCMSlice} creditManager - minimal credit manager data {@link RouterCMSlice} on which operation is performed
-   * @param {SwapOperation} swapOperation - {@link SwapOperation} = "EXACT_INPUT" | "EXACT_INPUT_ALL" | "EXACT_OUTPUT"; however router stopped to support EXACT_OUTPUT
-   * @param {Address} tokenIn - address of input token
-   * @param {Address} tokenOut - address of output token
-   * @param {number | bigint} slippage  - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-   * @param {bigint} amount - amount of token in to swap
-   * @param {bigint} leftoverAmount - amount that should be left on account after swap; technically equals to 0 in the most of the cases
-   * @returns Array of {@link RouterResult}
+   * Implements {@link IRouterContract.findAllSwaps}
    */
   async findAllSwaps({
     creditAccount: ca,
@@ -83,16 +73,7 @@ class RouterV300Contract extends AbstractRouterContract {
     return Object.values(unique);
   }
   /**
-   * Find the best path to swap token A to token B.
-   *  - Connectors - list of tokens which can be used as a token to align path through, for ex. when swapping sUSDe it is good to check swaps through USDe.
-   *  - #overridePTRedeem - if token is PT token and PT token is already redeemable, we need to claim it manually, since old router can't do it. This can work in old app only because you cannot swap pt_sUSDe into sUSde before maturity and when it is matured, override takes place.
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-   * @param {RouterCMSlice} creditManager - minimal credit manager data {@link RouterCMSlice} on which operation is performed
-   * @param {Address} tokenIn - address of input token
-   * @param {Address} tokenOut - address of output token
-   * @param {number | bigint} slippage  - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-   * @param {bigint} amount - amount of token in to swap
-   * @returns minAmount, avgAmount found and array of calls to execute swap
+   * Implements {@link IRouterContract.findOneTokenPath}
    */
   async findOneTokenPath(props) {
     const {
@@ -127,22 +108,7 @@ class RouterV300Contract extends AbstractRouterContract {
     };
   }
   /**
-   * @dev Finds the best path for opening Credit Account; converts all expectedBalances besides leftoverBalances into target token
-   * @param {RouterCMSlice} creditManager - minimal credit manager data {@link RouterCMSlice} on which operation is performed
-   * @param {Array<Asset>} expectedBalances - Collateral assets + debt asset, nominated in ther respective tokens.
-   * For example, if you open an USDC Credit Account, borrow 50_000 USDC and provide 10 WETH and 10_000 DAI as collateral
-   * from your own funds, expectedBalances should be: [{amount: 10*10**wethDecimals}, {amount: 10000*10**daiDecimals}, {amount: 10000*10**usdcDecimals}]
-   * @param leftoverBalances - balances to keep on account after opening.
-   * For example if don't want to swap WETH in the example above, leftoverBalances should be: [{amount: 10*10**wethDecimals}]
-   * @param target - Address of desired token to swap into
-   * @param slippage - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-   * @returns Router return list of all balances (including 0 balances) after operation, but it doesn't include original balance
-   * - For example you had 5k sUSDS  and 5k DAI as collateral, debt is 20k DAI, router will return 25k sUDS and all other token allowed on CM will be 0n or 1n
-   * Since FE is interested in FULL balances structure, we override target balance in the following way:
-   * min = record[sUSDS] = 5k from collateral + 25k of minAmount; avg = record[sUSDS] = 5k from collateral + 25.5k of avgAmount
-   * - minAmount
-   * - avgAmount
-   * - array of calls to execute swap
+   * Implements {@link IRouterContract.findOpenStrategyPath}
    */
   async findOpenStrategyPath({
     creditManager: cm,
@@ -190,26 +156,7 @@ class RouterV300Contract extends AbstractRouterContract {
     };
   }
   /**
-   * @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.
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-   * @param {RouterCMSlice} creditManager - minimal credit manager data {@link RouterCMSlice} on which operation is performed
-   * @param {number | bigint} slippage - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-   * @param {ClosePathBalances | undefined} balances - Balances {@link ClosePathBalances} to close account with, if not provided, all assets will be swapped according to inner logic.
-   * Consists of:
-   * @param {Array<Asset>} expectedBalances - list of all credit account balances nominated in their respective tokens.
-   *     For example: [{amount: 10x10^wethDecimals}, {amount: 10000x10^daiDecimals}]
-   * @param {Array<Asset>} leftoverBalances - list of all credit account balances that shouldn't be swapped nominated in their respective tokens.
-   *     Used for credit account repaying; in this mode leftover assets list should include all assets besides underlying token.
-   *     For example considering account above is on DAI CM: [{amount: 10x10^wethDecimals}]
-   * @return The best option in PathFinderCloseResult format, which
-   *  - underlyingBalance -  since this method swaps only tokens different from underlying,
-   *   we are more interested in TOTAL balance of underlying token after all swaps are done
-   *   for this reason we sum up underlying token that was on account before swap
-   *   with underlying token amount found during swap and call it underlyingBalance
-   *  - calls - list of calls which should be done to swap & unwrap everything to underlying token
-   *  - amount
-   *  - minAmount
+   * Implements {@link IRouterContract.findBestClosePath}
    */
   async findBestClosePath({
     creditAccount: ca,
@@ -272,11 +219,7 @@ class RouterV300Contract extends AbstractRouterContract {
     return result;
   }
   /**
-   * Finds input to be used with findBestClosePath
-   * Is used by batch liquidator
-   * @param ca
-   * @param cm
-   * @returns
+   * Implements {@link IRouterContract.getFindClosePathInput}
    */
   getFindClosePathInput(ca, cm, balances) {
     const { expectedBalances, leftoverBalances } = this.getExpectedAndLeftover(
@@ -298,7 +241,7 @@ class RouterV300Contract extends AbstractRouterContract {
     };
   }
   /**
-   * Connectors - list of tokens which can be used as a token to align path through, for ex. when swapping sUSDe it is good to check swaps through USDe.
+   * Implements {@link IRouterContract.getAvailableConnectors}
    */
   getAvailableConnectors(collateralTokens) {
     return collateralTokens.filter(
@@ -306,9 +249,9 @@ class RouterV300Contract extends AbstractRouterContract {
     );
   }
   /**
-   * if token is PT token and PT token is already redeemable, we need to claim it manually, since old router can't do it. 
-      This can work in old app only because you cannot swap pt_sUSDe into sUSde before maturity and when it is matured, override takes place.
-  */
+   * If token is PT token and PT token is already redeemable, we need to claim it manually, since old router can't do it.
+   * This can work in old app only because you cannot swap pt_sUSDe into sUSde before maturity and when it is matured, override takes place.
+   */
   async #overridePTRedeem({
     creditAccount,
     creditManager,

package/dist/esm/sdk/router/RouterV310Contract.js

@@ -1,4 +1,7 @@
+import { getAddress } from "viem";
 import { iGearboxRouterV310Abi } from "../../abi/routerV310.js";
+import { BigIntMath } from "../sdk-legacy/index.js";
+import { AddressMap } from "../utils/AddressMap.js";
 import { AbstractRouterContract } from "./AbstractRouterContract.js";
 import { assetsMap, balancesMap } from "./helpers.js";
 const abi = iGearboxRouterV310Abi;
@@ -7,29 +10,45 @@ class RouterV310Contract extends AbstractRouterContract {
   constructor(sdk, address) {
     super(sdk, {
       addr: address,
-      name: "RouterV300",
+      name: "RouterV310",
       abi
     });
   }
   /**
-   * Finds best path to swap all Normal tokens and tokens "on the way" to target one and vice versa
-   * @param creditAccount
-   * @param creditManager
-   * @param tokenIn
-   * @param tokenOut
-   * @param amount
-   * @param slippage
-   * @returns
+   * Implements {@link IRouterContract.findOneTokenPath}
    */
   async findOneTokenPath(props) {
+    const {
+      creditAccount,
+      creditManager,
+      amount,
+      slippage,
+      tokenIn,
+      tokenOut
+    } = props;
+    const numSplits = this.#numSplitsGetter(
+      creditManager,
+      creditAccount.tokens
+    )(tokenIn);
+    this.logger?.debug(
+      {
+        creditAccount: creditAccount.creditAccount,
+        creditManager: this.labelAddress(creditManager.address),
+        tokenIn: this.labelAddress(tokenIn),
+        target: this.labelAddress(tokenOut),
+        amount,
+        slippage,
+        numSplits
+      },
+      "calling routeOneToOne"
+    );
     const { result } = await this.contract.simulate.routeOneToOne([
-      props.creditAccount.creditAccount,
-      props.tokenIn,
-      props.amount,
-      props.tokenOut,
-      BigInt(props.slippage),
-      4n
-      // TODO:? how many 4n or 0n for underlying
+      creditAccount.creditAccount,
+      tokenIn,
+      amount,
+      tokenOut,
+      BigInt(slippage),
+      numSplits
     ]);
     return {
       amount: result.amount,
@@ -38,15 +57,7 @@ class RouterV310Contract extends AbstractRouterContract {
     };
   }
   /**
-   * @dev Finds the best path for opening Credit Account and converting all NORMAL tokens and LP token in the way to TARGET
-   * @param creditManager 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
-   *    from your own funds, expectedBalances should be: { "USDC": 60_000 * (10**6), "<address of WETH>": WAD.mul(10) }
-   * @param leftoverBalances Balances to keep on account after opening
-   * @param target Address of symbol of desired token
-   * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-   * @returns PathFinderOpenStrategyResult which
+   * Implements {@link IRouterContract.findOpenStrategyPath}
    */
   async findOpenStrategyPath(props) {
     const {
@@ -60,15 +71,24 @@ class RouterV310Contract extends AbstractRouterContract {
       balancesMap(expectedBalances),
       balancesMap(leftoverBalances)
     ];
+    const getNumSplits = this.#numSplitsGetter(cm, expectedBalances);
     const tData = cm.collateralTokens.map(
       (token) => ({
         token,
         balance: expectedMap.get(token) ?? 0n,
         leftoverBalance: leftoverMap.get(token) ?? 0n,
-        numSplits: 4n
-        // TODO:? how many 4n or 0n for underlying
+        numSplits: getNumSplits(token)
       })
     );
+    this.logger?.debug(
+      {
+        creditManager: this.labelAddress(cm.address),
+        target: this.labelAddress(target),
+        slippage,
+        tData: this.#debugTokenData(tData)
+      },
+      "calling routeOpenManyToOne"
+    );
     const { result } = await this.contract.simulate.routeOpenManyToOne([
       cm.address,
       target,
@@ -76,24 +96,25 @@ class RouterV310Contract extends AbstractRouterContract {
       tData
     ]);
     return {
-      balances: {},
-      // TODO:?
-      minBalances: {},
-      // TODO:?
+      balances: balancesAfterOpen(
+        target,
+        result.amount,
+        expectedMap,
+        leftoverMap
+      ),
+      minBalances: balancesAfterOpen(
+        target,
+        result.minAmount,
+        expectedMap,
+        leftoverMap
+      ),
       amount: result.amount,
       minAmount: result.minAmount,
       calls: [...result.calls]
     };
   }
   /**
-   * @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.
-   * @param creditAccount CreditAccountStruct object used for close path computation
-   * @param creditManager CreditManagerSlice for corresponding credit manager
-   * @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
+   * Implements {@link IRouterContract.findBestClosePath}
    */
   async findBestClosePath(props) {
     const { creditAccount: ca, creditManager: cm, slippage, balances } = props;
@@ -105,16 +126,26 @@ class RouterV310Contract extends AbstractRouterContract {
         leftoverBalances: assetsMap(balances.leftoverBalances)
       } : void 0
     );
+    const getNumSplits = this.#numSplitsGetter(cm, expectedBalances.values());
     const tData = [];
     for (const token of cm.collateralTokens) {
       tData.push({
         token,
         balance: expectedBalances.get(token)?.balance || 0n,
         leftoverBalance: leftoverBalances.get(token)?.balance || 0n,
-        numSplits: 4n
-        // TODO:? how many 4n or 0n for underlying
+        numSplits: getNumSplits(token)
       });
     }
+    this.logger?.debug(
+      {
+        creditAccount: ca.creditAccount,
+        creditManager: this.labelAddress(cm.address),
+        target: this.labelAddress(ca.underlying),
+        slippage,
+        tData: this.#debugTokenData(tData)
+      },
+      "calling routeManyToOne"
+    );
     const { result } = await this.contract.simulate.routeManyToOne([
       cm.address,
       ca.underlying,
@@ -129,16 +160,74 @@ class RouterV310Contract extends AbstractRouterContract {
       calls: [...result.calls]
     };
   }
+  #numSplitsGetter(creditManager, assets) {
+    const { priceOracle } = this.sdk.marketRegister.findByCreditManager(
+      creditManager.address
+    );
+    const inUSD = assets.filter(({ token, balance }) => {
+      const decimals = this.sdk.tokensMeta.decimals(token);
+      const minBalance = 10n ** BigInt(Math.max(8, decimals) - 8);
+      return balance >= minBalance;
+    }).map(({ token, balance }) => {
+      return {
+        token,
+        balance: priceOracle.convertToUSD(token, balance)
+      };
+    }).sort((a, b) => {
+      return b.balance > a.balance ? -1 : 1;
+    });
+    const map = new AddressMap(
+      inUSD.map(({ token }, i) => [token, i === 0 ? 4n : 1n])
+    );
+    return (token) => map.get(token) ?? 1n;
+  }
+  #debugTokenData(tData) {
+    return tData.map((t) => ({
+      token: this.labelAddress(t.token),
+      balance: this.sdk.tokensMeta.formatBN(t.token, t.balance),
+      leftoverBalance: this.sdk.tokensMeta.formatBN(t.token, t.leftoverBalance),
+      numSplits: t.numSplits
+    }));
+  }
+  /**
+   * Implements {@link IRouterContract.findAllSwaps}
+   * @deprecated v3.0 legacy method
+   */
   findAllSwaps(props) {
     throw ERR_NOT_IMPLEMENTED;
   }
+  /**
+   * Implements {@link IRouterContract.getAvailableConnectors}
+   * @deprecated v3.0 legacy method
+   */
   getAvailableConnectors(collateralTokens) {
     throw ERR_NOT_IMPLEMENTED;
   }
+  /**
+   * Implements {@link IRouterContract.getFindClosePathInput}
+   * @deprecated v3.0 legacy method
+   */
   getFindClosePathInput(ca, cm, balances) {
     throw ERR_NOT_IMPLEMENTED;
   }
 }
+function balancesAfterOpen(target, targetAmount, expected, leftover) {
+  const result = {};
+  const targetAddr = getAddress(target);
+  const tokens = /* @__PURE__ */ new Set([
+    ...expected.keys(),
+    ...leftover.keys(),
+    targetAddr
+  ]);
+  for (const t of tokens) {
+    if (t === targetAddr) {
+      result[t] = expected.get(t) ?? 0n + targetAmount;
+    } else {
+      result[t] = BigIntMath.min(expected.get(t) ?? 0n, leftover.get(t) ?? 0n);
+    }
+  }
+  return result;
+}
 export {
   RouterV310Contract
 };

package/dist/types/sdk/router/RouterV300Contract.d.ts

@@ -9,84 +9,27 @@ export declare class RouterV300Contract extends AbstractRouterContract<abi> impl
     #private;
     constructor(sdk: GearboxSDK, address: Address);
     /**
-     * Finds all available swaps for given tokens; technically should be avoided to use, since doesn't have any advantage over findOneTokenPath.
-     * Deduplicates results by minAmount + strigified call path and returns only unique ones.
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-     * @param {RouterCMSlice} creditManager - minimal credit manager data {@link RouterCMSlice} on which operation is performed
-     * @param {SwapOperation} swapOperation - {@link SwapOperation} = "EXACT_INPUT" | "EXACT_INPUT_ALL" | "EXACT_OUTPUT"; however router stopped to support EXACT_OUTPUT
-     * @param {Address} tokenIn - address of input token
-     * @param {Address} tokenOut - address of output token
-     * @param {number | bigint} slippage  - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-     * @param {bigint} amount - amount of token in to swap
-     * @param {bigint} leftoverAmount - amount that should be left on account after swap; technically equals to 0 in the most of the cases
-     * @returns Array of {@link RouterResult}
+     * Implements {@link IRouterContract.findAllSwaps}
      */
     findAllSwaps({ creditAccount: ca, creditManager: cm, swapOperation, tokenIn, tokenOut, amount, leftoverAmount, slippage, }: FindAllSwapsProps): Promise<Array<RouterResult>>;
     /**
-     * Find the best path to swap token A to token B.
-     *  - Connectors - list of tokens which can be used as a token to align path through, for ex. when swapping sUSDe it is good to check swaps through USDe.
-     *  - #overridePTRedeem - if token is PT token and PT token is already redeemable, we need to claim it manually, since old router can't do it. This can work in old app only because you cannot swap pt_sUSDe into sUSde before maturity and when it is matured, override takes place.
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-     * @param {RouterCMSlice} creditManager - minimal credit manager data {@link RouterCMSlice} on which operation is performed
-     * @param {Address} tokenIn - address of input token
-     * @param {Address} tokenOut - address of output token
-     * @param {number | bigint} slippage  - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-     * @param {bigint} amount - amount of token in to swap
-     * @returns minAmount, avgAmount found and array of calls to execute swap
+     * Implements {@link IRouterContract.findOneTokenPath}
      */
     findOneTokenPath(props: FindOneTokenPathProps): Promise<RouterResult>;
     /**
-     * @dev Finds the best path for opening Credit Account; converts all expectedBalances besides leftoverBalances into target token
-     * @param {RouterCMSlice} creditManager - minimal credit manager data {@link RouterCMSlice} on which operation is performed
-     * @param {Array<Asset>} expectedBalances - Collateral assets + debt asset, nominated in ther respective tokens.
-     * For example, if you open an USDC Credit Account, borrow 50_000 USDC and provide 10 WETH and 10_000 DAI as collateral
-     * from your own funds, expectedBalances should be: [{amount: 10*10**wethDecimals}, {amount: 10000*10**daiDecimals}, {amount: 10000*10**usdcDecimals}]
-     * @param leftoverBalances - balances to keep on account after opening.
-     * For example if don't want to swap WETH in the example above, leftoverBalances should be: [{amount: 10*10**wethDecimals}]
-     * @param target - Address of desired token to swap into
-     * @param slippage - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-     * @returns Router return list of all balances (including 0 balances) after operation, but it doesn't include original balance
-     * - For example you had 5k sUSDS  and 5k DAI as collateral, debt is 20k DAI, router will return 25k sUDS and all other token allowed on CM will be 0n or 1n
-     * Since FE is interested in FULL balances structure, we override target balance in the following way:
-     * min = record[sUSDS] = 5k from collateral + 25k of minAmount; avg = record[sUSDS] = 5k from collateral + 25.5k of avgAmount
-     * - minAmount
-     * - avgAmount
-     * - array of calls to execute swap
+     * Implements {@link IRouterContract.findOpenStrategyPath}
      */
     findOpenStrategyPath({ creditManager: cm, expectedBalances, leftoverBalances, target, slippage, }: FindOpenStrategyPathProps): Promise<OpenStrategyResult>;
     /**
-     * @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.
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
-     * @param {RouterCMSlice} creditManager - minimal credit manager data {@link RouterCMSlice} on which operation is performed
-     * @param {number | bigint} slippage - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-     * @param {ClosePathBalances | undefined} balances - Balances {@link ClosePathBalances} to close account with, if not provided, all assets will be swapped according to inner logic.
-     * Consists of:
-     * @param {Array<Asset>} expectedBalances - list of all credit account balances nominated in their respective tokens.
-     *     For example: [{amount: 10x10^wethDecimals}, {amount: 10000x10^daiDecimals}]
-     * @param {Array<Asset>} leftoverBalances - list of all credit account balances that shouldn't be swapped nominated in their respective tokens.
-     *     Used for credit account repaying; in this mode leftover assets list should include all assets besides underlying token.
-     *     For example considering account above is on DAI CM: [{amount: 10x10^wethDecimals}]
-     * @return The best option in PathFinderCloseResult format, which
-     *  - underlyingBalance -  since this method swaps only tokens different from underlying,
-     *   we are more interested in TOTAL balance of underlying token after all swaps are done
-     *   for this reason we sum up underlying token that was on account before swap
-     *   with underlying token amount found during swap and call it underlyingBalance
-     *  - calls - list of calls which should be done to swap & unwrap everything to underlying token
-     *  - amount
-     *  - minAmount
+     * Implements {@link IRouterContract.findBestClosePath}
      */
     findBestClosePath({ creditAccount: ca, creditManager: cm, slippage, balances, }: FindBestClosePathProps): Promise<RouterCloseResult>;
     /**
-     * Finds input to be used with findBestClosePath
-     * Is used by batch liquidator
-     * @param ca
-     * @param cm
-     * @returns
+     * Implements {@link IRouterContract.getFindClosePathInput}
      */
     getFindClosePathInput(ca: RouterCASlice, cm: RouterCMSlice, balances?: Leftovers): FindClosePathInput;
     /**
-     * Connectors - list of tokens which can be used as a token to align path through, for ex. when swapping sUSDe it is good to check swaps through USDe.
+     * Implements {@link IRouterContract.getAvailableConnectors}
      */
     getAvailableConnectors(collateralTokens: Array<Address>): Array<Address>;
 }

package/dist/types/sdk/router/RouterV310Contract.d.ts

@@ -1,4 +1,4 @@
-import type { Address } from "viem";
+import { type Address } from "viem";
 import type { GearboxSDK } from "../GearboxSDK.js";
 import type { Leftovers } from "./AbstractRouterContract.js";
 import { AbstractRouterContract } from "./AbstractRouterContract.js";
@@ -350,43 +350,34 @@ declare const abi: readonly [{
 }];
 type abi = typeof abi;
 export declare class RouterV310Contract extends AbstractRouterContract<abi> implements IRouterContract {
+    #private;
     constructor(sdk: GearboxSDK, address: Address);
     /**
-     * Finds best path to swap all Normal tokens and tokens "on the way" to target one and vice versa
-     * @param creditAccount
-     * @param creditManager
-     * @param tokenIn
-     * @param tokenOut
-     * @param amount
-     * @param slippage
-     * @returns
+     * Implements {@link IRouterContract.findOneTokenPath}
      */
     findOneTokenPath(props: FindOneTokenPathProps): Promise<RouterResult>;
     /**
-     * @dev Finds the best path for opening Credit Account and converting all NORMAL tokens and LP token in the way to TARGET
-     * @param creditManager 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
-     *    from your own funds, expectedBalances should be: { "USDC": 60_000 * (10**6), "<address of WETH>": WAD.mul(10) }
-     * @param leftoverBalances Balances to keep on account after opening
-     * @param target Address of symbol of desired token
-     * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-     * @returns PathFinderOpenStrategyResult which
+     * Implements {@link IRouterContract.findOpenStrategyPath}
      */
     findOpenStrategyPath(props: FindOpenStrategyPathProps): Promise<OpenStrategyResult>;
     /**
-     * @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.
-     * @param creditAccount CreditAccountStruct object used for close path computation
-     * @param creditManager CreditManagerSlice for corresponding credit manager
-     * @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
+     * Implements {@link IRouterContract.findBestClosePath}
      */
     findBestClosePath(props: FindBestClosePathProps): Promise<RouterCloseResult>;
+    /**
+     * Implements {@link IRouterContract.findAllSwaps}
+     * @deprecated v3.0 legacy method
+     */
     findAllSwaps(props: FindAllSwapsProps): Promise<RouterResult[]>;
+    /**
+     * Implements {@link IRouterContract.getAvailableConnectors}
+     * @deprecated v3.0 legacy method
+     */
     getAvailableConnectors(collateralTokens: Address[]): Address[];
+    /**
+     * Implements {@link IRouterContract.getFindClosePathInput}
+     * @deprecated v3.0 legacy method
+     */
     getFindClosePathInput(ca: RouterCASlice, cm: RouterCMSlice, balances?: Leftovers): FindClosePathInput;
 }
 export {};

package/dist/types/sdk/router/types.d.ts

@@ -10,31 +10,57 @@ export interface PathOption {
     totalOptions: number;
 }
 export type PathOptionSerie = Array<PathOption>;
-export interface SwapTask {
-    swapOperation: number;
-    creditAccount: Address;
-    tokenIn: Address;
-    tokenOut: Address;
-    connectors: Array<Address>;
-    amount: bigint;
-    leftoverAmount: bigint;
-}
+/**
+ * Result returned from router contract (both v3.0 and v3.1)
+ */
 export interface RouterResult {
+    /**
+     * Amount received by router after all swaps in the block where the router is called
+     * Always denominated in target token
+     */
     amount: bigint;
+    /**
+     * amount * (1 - slippage)
+     * Always denominated in target token
+     */
     minAmount: bigint;
+    /**
+     * List of calls swap/unwrap/etc calls to adapters returned by router
+     */
     calls: Array<MultiCall>;
 }
+/**
+ * Router return list of all balances (including 0 balances) after operation, but it doesn't include original balance
+ * - For example you had 5k sUSDS  and 5k DAI as collateral, debt is 20k DAI, router will return 25k sUDS and all other token allowed on CM will be 0n or 1n
+ * Since front-end is interested in FULL balances structure, we override target balance in the following way:
+ * min = record[sUSDS] = 5k from collateral + 25k of minAmount; avg = record[sUSDS] = 5k from collateral + 25.5k of avgAmount
+ * - minAmount
+ * - avgAmount
+ * - array of calls to execute swap
+ */
 export interface OpenStrategyResult extends RouterResult {
+    /**
+     * Balances of opened credit account
+     * Leftover balances stay the same
+     * All expected balances are converted into target token, which amount is returned in router result
+     * This is returned from router contract v3.0, but is calculated here in js in router v3.1
+     */
     balances: Record<Address, bigint>;
+    /**
+     * Sam as balances, but for min balance in target token
+     * @see RouterResult.minAmount
+     */
     minBalances: Record<Address, bigint>;
 }
 export interface RouterCloseResult extends RouterResult {
+    /**
+     * When account is closed, the router swaps only tokens different from underlying,
+     * we are more interested in TOTAL balance of underlying token after all swaps are done
+     * for this reason we sum up underlying token that was on account before swap
+     * with underlying token amount received during swap and call it underlyingBalance
+     */
     underlyingBalance: bigint;
 }
-export interface CurvePoolStruct {
-    curvePool: Address;
-    metapoolBase: Address;
-}
 export interface Asset {
     token: Address;
     balance: bigint;
@@ -52,13 +78,37 @@ export interface RouterCMSlice {
  */
 export type RouterCASlice = Pick<CreditAccountData, "tokens" | "enabledTokensMask" | "underlying" | "creditAccount" | "creditFacade" | "debt" | "creditManager">;
 export interface FindAllSwapsProps {
+    /**
+     * Minimal credit account data on which operation is performed
+     */
     creditAccount: RouterCASlice;
+    /**
+     * Minimal credit manager data on which operation is performed
+     */
     creditManager: RouterCMSlice;
+    /**
+     * {@link SwapOperation} = "EXACT_INPUT" | "EXACT_INPUT_ALL" | "EXACT_OUTPUT"; however router stopped to support EXACT_OUTPUT
+     */
     swapOperation: SwapOperation;
+    /**
+     * Address of input token
+     */
     tokenIn: Address;
+    /**
+     * Address of target token
+     */
     tokenOut: Address;
+    /**
+     * Incoming amount of tokenIn to swap
+     */
     amount: bigint;
+    /**
+     * Amount that should be left on account after swap; technically equals to 0 in the most of the cases
+     */
     leftoverAmount: bigint;
+    /**
+     * Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
+     */
     slippage: number | bigint;
 }
 export interface FindClosePathInput {
@@ -68,73 +118,139 @@ export interface FindClosePathInput {
     connectors: Array<Address>;
 }
 export interface FindOneTokenPathProps {
+    /**
+     * Minimal credit account data on which operation is performed
+     */
     creditAccount: RouterCASlice;
+    /**
+     * Minimal credit manager data on which operation is performed
+     */
     creditManager: RouterCMSlice;
+    /**
+     * Address of input token
+     */
     tokenIn: Address;
+    /**
+     * Adddress of target token
+     */
     tokenOut: Address;
+    /**
+     * Incominga mount of tokenIn to swap
+     */
     amount: bigint;
+    /**
+     * Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
+     */
     slippage: number | bigint;
 }
 export interface FindOpenStrategyPathProps {
+    /**
+     * Minimal credit manager data on which operation is performed
+     */
     creditManager: RouterCMSlice;
+    /**
+     * Collateral assets + debt asset, nominated in ther respective tokens.
+     * For example, if you open an USDC Credit Account, borrow 50_000 USDC and provide 10 WETH and 10_000 DAI as collateral
+     * from your own funds, expectedBalances should be: [{amount: 10*10**wethDecimals}, {amount: 10000*10**daiDecimals}, {amount: 10000*10**usdcDecimals}]
+     */
     expectedBalances: Array<Asset>;
+    /**
+     * Balances to keep on account after opening.
+     * For example if don't want to swap WETH in the example above, leftoverBalances should be: [{amount: 10*10**wethDecimals}]
+     */
     leftoverBalances: Array<Asset>;
+    /**
+     * Address of desired token to swap into
+     */
     target: Address;
+    /**
+     * Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
+     */
     slippage: number | bigint;
 }
 export interface FindBestClosePathProps {
+    /**
+     * Minimal credit account data on which operation is performed
+     */
     creditAccount: RouterCASlice;
+    /**
+     * Minimal credit manager data on which operation is performed
+     */
     creditManager: RouterCMSlice;
+    /**
+     * Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
+     */
     slippage: bigint | number;
+    /**
+     * Balances {@link ClosePathBalances} to close account with, if not provided, all assets will be swapped according to inner logic.
+     */
     balances?: ClosePathBalances;
 }
 export interface ClosePathBalances {
+    /**
+     * List of all credit account balances nominated in their respective tokens.
+     * Current balances or expected balances after some actions (add/withdraw collateral, for example),
+     * if these actions are before router calls
+     */
     expectedBalances: Array<Asset>;
+    /**
+     * List of all credit account balances that shouldn't be swapped nominated in their respective tokens.
+     * Will be kept on account after all actions.
+     * If the final balance is 0, we set 1 for gas optimization, except for forbidden tokens
+     */
     leftoverBalances: Array<Asset>;
 }
 export interface IRouterContract extends IBaseContract {
     /**
-     * Finds best path to swap all Normal tokens and tokens "on the way" to target one and vice versa
-     * @param props
-     * @returns
+     * Find the best path to swap token A to token B (target token).
+     * @param props - {@link FindOneTokenPathProps}
+     * @return result - {@link RouterResult}
      */
     findOneTokenPath: (props: FindOneTokenPathProps) => Promise<RouterResult>;
     /**
-     * @dev Finds the best path for opening Credit Account and converting all NORMAL tokens and LP token in the way to TARGET
-     * @param creditManager 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
-     *    from your own funds, expectedBalances should be: { "USDC": 60_000 * (10**6), "<address of WETH>": WAD.mul(10) }
-     * @param leftoverBalances Balances to keep on account after opening
-     * @param target Address of symbol of desired token
-     * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
-     * @returns PathFinderOpenStrategyResult which
+     * Finds the best path for opening Credit Account; converts all expectedBalances besides leftoverBalances into target token
+     * @param props - {@link FindOpenStrategyPathProps}
+     * @returns result - {@link OpenStrategyResult}
      */
     findOpenStrategyPath: (props: FindOpenStrategyPathProps) => Promise<OpenStrategyResult>;
     /**
-     * @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.
-     * @param creditAccount CreditAccountStruct object used for close path computation
-     * @param creditManager CreditManagerSlice for corresponding credit manager
-     * @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
+     * Finds the path to swap / withdraw all assets from CreditAccount into underlying asset
+     * Can be used for closing Credit Account and for liquidations as well.
+     * @param props - {@link FindBestClosePathProps}
+     * @return result - {@link RouterCloseResult}
      */
     findBestClosePath: (props: FindBestClosePathProps) => Promise<RouterCloseResult>;
+    /**
+     * Finds all available swaps for given tokens; technically should be avoided to use, since doesn't have any advantage over findOneTokenPath.
+     * Deduplicates results by minAmount + stringified call path and returns only unique ones.
+     *
+     * @deprecated v3.0 legacy method
+     *
+     * @param props - {@link FindAllSwapsProps}
+     * @returns array of {@link RouterResult}
+     */
     findAllSwaps: (props: FindAllSwapsProps) => Promise<RouterResult[]>;
     /**
-     * V3.0 sdk-gov legacy method
-     * Should be removed after migration to V3.1
+     * Returns list of tokens which can be used as a token to align path through,
+     * for ex. when swapping sUSDe it is good to check swaps through USDe.
+     *
+     * @deprecated V3.0 sdk-gov legacy method
+     *
      * @param collateralTokens
      * @returns
      */
     getAvailableConnectors: (collateralTokens: Address[]) => Address[];
     /**
-     * V3.0 legacy method
-     * Used by batch liquidator
+     * Finds input to be used with findBestClosePath
+     * Used by batch liquidator.
+     *
+     * Params are same as in findBestClosePath, just different shape
+     *
+     * @deprecated V3.0 legacy method
+     *
      * @param ca
      * @param cm
+     * @param balances
      * @returns
      */
     getFindClosePathInput: (ca: RouterCASlice, cm: RouterCMSlice, balances?: Leftovers) => FindClosePathInput;
@@ -142,6 +258,7 @@ export interface IRouterContract extends IBaseContract {
 export type RouterHooks = {
     /**
      * Internal router event
+     * @deprecated v3.0 legacy event
      */
     foundPathOptions: [{
         creditAccount: Address;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "3.0.0-vfour.283",
+  "version": "3.0.0-vfour.285",
   "description": "Gearbox SDK",
   "license": "MIT",
   "main": "./dist/cjs/sdk/index.js",