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

package/dist/cjs/sdk/accounts/CreditAccountsService.js

@@ -190,7 +190,8 @@ class CreditAccountsService extends import_base.SDKConstruct {
   }
   /**
    * Method to get all connected bots for credit account
-   * @param {Array<{ creditAccount: Address; creditManager: Address }>} accountsToCheck - list of credit accounts to check connected bots on
+   * @param {Array<{ creditAccount: Address; creditManager: Address }>} accountsToCheck - list of credit accounts 
+      and their credit managers to check connected bots on
    * @returns call result of getConnectedBots for each credit account
    */
   async getConnectedBots(accountsToCheck) {
@@ -239,16 +240,16 @@ class CreditAccountsService extends import_base.SDKConstruct {
   }
   /**
    * Closes credit account or closes credit account and keeps it open with zero debt.
-      Ca is closed in the following order: price update -> close path to swap all tokens into underlying -> 
+     - Ca is closed in the following order: price update -> close path to swap all tokens into underlying -> 
        -> disable quotas of exiting tokens -> decrease debt -> disable exiting tokens tokens -> withdraw underlying tokenz
    * @param {CloseOptions} operation - {@link CloseOptions}: close or zeroDebt
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Address>} assetsToWithdraw - tokens to withdraw from credit account. 
       For credit account closing this is the underlying token, because during the closure, 
       all tokens on account are swapped into the underlying, 
       and only the underlying token will remain on the credit account
    * @param {Address} to - Wallet address to withdraw underlying to
-   * @param {number} slippage  - SLIPPAGE_DECIMALS = 100n 
+   * @param {number} slippage  - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
    * @default 50n
    * @param {RouterCloseResult | undefined} closePath - result of findBestClosePath method from router; if omited, calls marketRegister.findCreditManager {@link RouterCloseResult}
    * @returns All necessary data to execute the transaction (call, credit facade)
@@ -287,10 +288,10 @@ class CreditAccountsService extends import_base.SDKConstruct {
   }
   /**
    * Fully repays credit account or repays credit account and keeps it open with zero debt
-      Repays in the following order: price update -> add collateral to cover the debt -> 
+     - Repays in the following order: price update -> add collateral to cover the debt -> 
       -> disable quotas for all tokens -> decrease debt -> disable tokens all tokens -> withdraw all tokens
    * @param {CloseOptions} operation - {@link CloseOptions}: close or zeroDebt
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed on which operation is performed
    * @param {Array<Address>} collateralAssets - tokens to repay dept. 
       In the current implementation, this is the (debt+interest+fess) * buffer, 
       where buffer refers to amount of tokens which will exceed current debt 
@@ -340,9 +341,9 @@ class CreditAccountsService extends import_base.SDKConstruct {
   }
   /**
    * Fully repays liquidatable account
-      Repay and liquidate is executed in the following order: price update -> add collateral to cover the debt -> 
+     - Repay and liquidate is executed in the following order: price update -> add collateral to cover the debt -> 
       withdraw all tokens from credit account
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Address>} collateralAssets - tokens to repay dept. 
       In the current implementation, this is the (debt+interest+fess) * buffer, 
       where buffer refers to amount of tokens which will exceed current debt 
@@ -391,8 +392,8 @@ class CreditAccountsService extends import_base.SDKConstruct {
   }
   /**
    * Updates quota of credit account.
-      CA quota updated in the following order: price update -> update quotas
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     - CA quota updated in the following order: price update -> update quotas
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Asset>} averageQuota - average quota for desired tokens {@link Asset}
    * @param {Array<Asset>} minQuota - minimum quota for desired tokens {@link Asset}
    * @returns All necessary data to execute the transaction (call, credit facade)
@@ -428,8 +429,8 @@ class CreditAccountsService extends import_base.SDKConstruct {
   }
   /**
    * Adds a single collateral to credit account and updates quotas
-      Collateral is added in the following order: price update -> add collateral (with permit) -> update quotas
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     - Collateral is added in the following order: price update -> add collateral (with permit) -> update quotas
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Asset>} averageQuota - average quota for desired token {@link Asset}
    * @param {Array<Asset>} minQuota - minimum quota for desired token {@link Asset}
    * @param {Asset} asset - asset to add as collateral {@link Asset}
@@ -471,8 +472,8 @@ class CreditAccountsService extends import_base.SDKConstruct {
   }
   /**
    * Increases or decreases debt of credit account; debt decrease uses token ON CREDIT ACCOUNT
-      Debt is changed in the following order: price update -> (enables underlying if it was disabled) -> change debt
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     - Debt is changed in the following order: price update -> (enables underlying if it was disabled) -> change debt
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {bigint} amount - amount to change debt by; 
       0 - prohibited value; 
       negative value for debt decrease; 
@@ -511,8 +512,8 @@ class CreditAccountsService extends import_base.SDKConstruct {
   /**
    * Withdraws a single collateral from credit account to wallet to and updates quotas; 
       technically can withdraw several tokens at once
-      Collateral is withdrawn in the following order: price update -> withdraw token -> update quotas for affected tokens
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     - Collateral is withdrawn in the following order: price update -> withdraw token -> update quotas for affected tokens
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Asset>} averageQuota - average quota for desired token {@link Asset}
    * @param {Array<Asset>} minQuota - minimum quota for desired token {@link Asset}
    * @param {Address} to - Wallet address to withdraw token to
@@ -561,8 +562,8 @@ class CreditAccountsService extends import_base.SDKConstruct {
   }
   /**
    * Executes swap specified by given calls, update quotas of affected tokens
-      Swap is executed in the following order: price update -> execute swap path -> update quotas
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     - Swap is executed in the following order: price update -> execute swap path -> update quotas
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Asset>} averageQuota - average quota for desired token {@link Asset}
    * @param {Array<Asset>} minQuota - minimum quota for desired token {@link Asset}
    * @param {Array<MultiCall>} calls - array of MultiCall from router methods getSingleSwap or getAllSwaps {@link MultiCall}
@@ -596,9 +597,9 @@ class CreditAccountsService extends import_base.SDKConstruct {
   }
   /**
    * Executes swap specified by given calls, update quotas of affected tokens
-      Claim rewards is executed in the following order: price update -> execute claim calls -> 
+     - Claim rewards is executed in the following order: price update -> execute claim calls -> 
       -> (optionally: disable reward tokens) -> (optionally: update quotas)
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Asset>} averageQuota - average quota for desired token; 
       in this case can be omitted since rewards tokens do not require quotas {@link Asset}
    * @param {Array<Asset>} minQuota - minimum quota for desired token;
@@ -635,13 +636,13 @@ class CreditAccountsService extends import_base.SDKConstruct {
   }
   /**
    * Executes swap specified by given calls, update quotas of affected tokens
-      Open credit account is executed in the following order: price update -> increase debt -> add collateral ->
+     - Open credit account is executed in the following order: price update -> increase debt -> add collateral ->
       -> update quotas -> (optionally: execute swap path for trading/strategy) -> 
       -> (optionally: withdraw debt for lending)
-    Basic open credit account: price update -> increase debt -> add collateral -> update quotas
-    Lending: price update -> increase debt -> add collateral -> update quotas -> withdraw debt
-    Strategy/trading: price update -> increase debt -> add collateral -> update quotas -> execute swap path
-    In strategy is possible situation when collateral is added, but not swapped; the only swapped value in this case will be debt
+    - Basic open credit account: price update -> increase debt -> add collateral -> update quotas
+    - Lending: price update -> increase debt -> add collateral -> update quotas -> withdraw debt
+    - Strategy/trading: price update -> increase debt -> add collateral -> update quotas -> execute swap path
+    - In strategy is possible situation when collateral is added, but not swapped; the only swapped value in this case will be debt
    * @param {bigint} ethAmount - native token amount to attach to tx
    * @param {Address} creditManager - address of credit manager to open credit account on
    * @param {Array<Asset>} collateral - array of collateral which can be just directly added or swapped using the path {@link Asset}

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

@@ -56,16 +56,17 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
     this.#connectors = (0, import_sdk_gov_legacy.getConnectors)(sdk.provider.networkType);
   }
   /**
-   * Finds all available swaps for NORMAL tokens
-   * @param ca
-   * @param cm
-   * @param swapOperation
-   * @param tokenIn
-   * @param tokenOut
-   * @param amount
-   * @param leftoverAmount
-   * @param slippage
-   * @returns
+   * 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}
    */
   async findAllSwaps({
     creditAccount: ca,
@@ -105,14 +106,16 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
     return Object.values(unique);
   }
   /**
-   * 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
+   * 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
    */
   async findOneTokenPath(props) {
     const {
@@ -147,15 +150,22 @@ class RouterV300Contract 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
+   * @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
    */
   async findOpenStrategyPath({
     creditManager: cm,
@@ -205,12 +215,24 @@ 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 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
+   * @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 - total balance of underlying token
-   *          - calls - list of calls which should be done to swap & unwrap everything to underlying token
+   *  - 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
    */
   async findBestClosePath({
     creditAccount: ca,
@@ -298,12 +320,18 @@ class RouterV300Contract extends import_AbstractRouterContract.AbstractRouterCon
       pathOptions
     };
   }
+  /**
+   * 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.
+   */
   getAvailableConnectors(collateralTokens) {
     return collateralTokens.filter(
       (t) => this.#connectors.includes(t.toLowerCase())
     );
   }
-  // TODO: remove me when new router will be added
+  /**
+   * 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/accounts/CreditAccountsService.js

@@ -196,7 +196,8 @@ class CreditAccountsService extends SDKConstruct {
   }
   /**
    * Method to get all connected bots for credit account
-   * @param {Array<{ creditAccount: Address; creditManager: Address }>} accountsToCheck - list of credit accounts to check connected bots on
+   * @param {Array<{ creditAccount: Address; creditManager: Address }>} accountsToCheck - list of credit accounts 
+      and their credit managers to check connected bots on
    * @returns call result of getConnectedBots for each credit account
    */
   async getConnectedBots(accountsToCheck) {
@@ -245,16 +246,16 @@ class CreditAccountsService extends SDKConstruct {
   }
   /**
    * Closes credit account or closes credit account and keeps it open with zero debt.
-      Ca is closed in the following order: price update -> close path to swap all tokens into underlying -> 
+     - Ca is closed in the following order: price update -> close path to swap all tokens into underlying -> 
        -> disable quotas of exiting tokens -> decrease debt -> disable exiting tokens tokens -> withdraw underlying tokenz
    * @param {CloseOptions} operation - {@link CloseOptions}: close or zeroDebt
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Address>} assetsToWithdraw - tokens to withdraw from credit account. 
       For credit account closing this is the underlying token, because during the closure, 
       all tokens on account are swapped into the underlying, 
       and only the underlying token will remain on the credit account
    * @param {Address} to - Wallet address to withdraw underlying to
-   * @param {number} slippage  - SLIPPAGE_DECIMALS = 100n 
+   * @param {number} slippage  - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
    * @default 50n
    * @param {RouterCloseResult | undefined} closePath - result of findBestClosePath method from router; if omited, calls marketRegister.findCreditManager {@link RouterCloseResult}
    * @returns All necessary data to execute the transaction (call, credit facade)
@@ -293,10 +294,10 @@ class CreditAccountsService extends SDKConstruct {
   }
   /**
    * Fully repays credit account or repays credit account and keeps it open with zero debt
-      Repays in the following order: price update -> add collateral to cover the debt -> 
+     - Repays in the following order: price update -> add collateral to cover the debt -> 
       -> disable quotas for all tokens -> decrease debt -> disable tokens all tokens -> withdraw all tokens
    * @param {CloseOptions} operation - {@link CloseOptions}: close or zeroDebt
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed on which operation is performed
    * @param {Array<Address>} collateralAssets - tokens to repay dept. 
       In the current implementation, this is the (debt+interest+fess) * buffer, 
       where buffer refers to amount of tokens which will exceed current debt 
@@ -346,9 +347,9 @@ class CreditAccountsService extends SDKConstruct {
   }
   /**
    * Fully repays liquidatable account
-      Repay and liquidate is executed in the following order: price update -> add collateral to cover the debt -> 
+     - Repay and liquidate is executed in the following order: price update -> add collateral to cover the debt -> 
       withdraw all tokens from credit account
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Address>} collateralAssets - tokens to repay dept. 
       In the current implementation, this is the (debt+interest+fess) * buffer, 
       where buffer refers to amount of tokens which will exceed current debt 
@@ -397,8 +398,8 @@ class CreditAccountsService extends SDKConstruct {
   }
   /**
    * Updates quota of credit account.
-      CA quota updated in the following order: price update -> update quotas
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     - CA quota updated in the following order: price update -> update quotas
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Asset>} averageQuota - average quota for desired tokens {@link Asset}
    * @param {Array<Asset>} minQuota - minimum quota for desired tokens {@link Asset}
    * @returns All necessary data to execute the transaction (call, credit facade)
@@ -434,8 +435,8 @@ class CreditAccountsService extends SDKConstruct {
   }
   /**
    * Adds a single collateral to credit account and updates quotas
-      Collateral is added in the following order: price update -> add collateral (with permit) -> update quotas
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     - Collateral is added in the following order: price update -> add collateral (with permit) -> update quotas
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Asset>} averageQuota - average quota for desired token {@link Asset}
    * @param {Array<Asset>} minQuota - minimum quota for desired token {@link Asset}
    * @param {Asset} asset - asset to add as collateral {@link Asset}
@@ -477,8 +478,8 @@ class CreditAccountsService extends SDKConstruct {
   }
   /**
    * Increases or decreases debt of credit account; debt decrease uses token ON CREDIT ACCOUNT
-      Debt is changed in the following order: price update -> (enables underlying if it was disabled) -> change debt
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     - Debt is changed in the following order: price update -> (enables underlying if it was disabled) -> change debt
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {bigint} amount - amount to change debt by; 
       0 - prohibited value; 
       negative value for debt decrease; 
@@ -517,8 +518,8 @@ class CreditAccountsService extends SDKConstruct {
   /**
    * Withdraws a single collateral from credit account to wallet to and updates quotas; 
       technically can withdraw several tokens at once
-      Collateral is withdrawn in the following order: price update -> withdraw token -> update quotas for affected tokens
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     - Collateral is withdrawn in the following order: price update -> withdraw token -> update quotas for affected tokens
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Asset>} averageQuota - average quota for desired token {@link Asset}
    * @param {Array<Asset>} minQuota - minimum quota for desired token {@link Asset}
    * @param {Address} to - Wallet address to withdraw token to
@@ -567,8 +568,8 @@ class CreditAccountsService extends SDKConstruct {
   }
   /**
    * Executes swap specified by given calls, update quotas of affected tokens
-      Swap is executed in the following order: price update -> execute swap path -> update quotas
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     - Swap is executed in the following order: price update -> execute swap path -> update quotas
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Asset>} averageQuota - average quota for desired token {@link Asset}
    * @param {Array<Asset>} minQuota - minimum quota for desired token {@link Asset}
    * @param {Array<MultiCall>} calls - array of MultiCall from router methods getSingleSwap or getAllSwaps {@link MultiCall}
@@ -602,9 +603,9 @@ class CreditAccountsService extends SDKConstruct {
   }
   /**
    * Executes swap specified by given calls, update quotas of affected tokens
-      Claim rewards is executed in the following order: price update -> execute claim calls -> 
+     - Claim rewards is executed in the following order: price update -> execute claim calls -> 
       -> (optionally: disable reward tokens) -> (optionally: update quotas)
-   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+   * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
    * @param {Array<Asset>} averageQuota - average quota for desired token; 
       in this case can be omitted since rewards tokens do not require quotas {@link Asset}
    * @param {Array<Asset>} minQuota - minimum quota for desired token;
@@ -641,13 +642,13 @@ class CreditAccountsService extends SDKConstruct {
   }
   /**
    * Executes swap specified by given calls, update quotas of affected tokens
-      Open credit account is executed in the following order: price update -> increase debt -> add collateral ->
+     - Open credit account is executed in the following order: price update -> increase debt -> add collateral ->
       -> update quotas -> (optionally: execute swap path for trading/strategy) -> 
       -> (optionally: withdraw debt for lending)
-    Basic open credit account: price update -> increase debt -> add collateral -> update quotas
-    Lending: price update -> increase debt -> add collateral -> update quotas -> withdraw debt
-    Strategy/trading: price update -> increase debt -> add collateral -> update quotas -> execute swap path
-    In strategy is possible situation when collateral is added, but not swapped; the only swapped value in this case will be debt
+    - Basic open credit account: price update -> increase debt -> add collateral -> update quotas
+    - Lending: price update -> increase debt -> add collateral -> update quotas -> withdraw debt
+    - Strategy/trading: price update -> increase debt -> add collateral -> update quotas -> execute swap path
+    - In strategy is possible situation when collateral is added, but not swapped; the only swapped value in this case will be debt
    * @param {bigint} ethAmount - native token amount to attach to tx
    * @param {Address} creditManager - address of credit manager to open credit account on
    * @param {Array<Asset>} collateral - array of collateral which can be just directly added or swapped using the path {@link Asset}

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

@@ -33,16 +33,17 @@ class RouterV300Contract extends AbstractRouterContract {
     this.#connectors = getConnectors(sdk.provider.networkType);
   }
   /**
-   * Finds all available swaps for NORMAL tokens
-   * @param ca
-   * @param cm
-   * @param swapOperation
-   * @param tokenIn
-   * @param tokenOut
-   * @param amount
-   * @param leftoverAmount
-   * @param slippage
-   * @returns
+   * 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}
    */
   async findAllSwaps({
     creditAccount: ca,
@@ -82,14 +83,16 @@ class RouterV300Contract extends AbstractRouterContract {
     return Object.values(unique);
   }
   /**
-   * 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
+   * 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
    */
   async findOneTokenPath(props) {
     const {
@@ -124,15 +127,22 @@ class RouterV300Contract 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
+   * @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
    */
   async findOpenStrategyPath({
     creditManager: cm,
@@ -182,12 +192,24 @@ 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 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
+   * @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 - total balance of underlying token
-   *          - calls - list of calls which should be done to swap & unwrap everything to underlying token
+   *  - 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
    */
   async findBestClosePath({
     creditAccount: ca,
@@ -275,12 +297,18 @@ class RouterV300Contract extends AbstractRouterContract {
       pathOptions
     };
   }
+  /**
+   * 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.
+   */
   getAvailableConnectors(collateralTokens) {
     return collateralTokens.filter(
       (t) => this.#connectors.includes(t.toLowerCase())
     );
   }
-  // TODO: remove me when new router will be added
+  /**
+   * 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/types/sdk/accounts/CreditAccountsService.d.ts

@@ -136,7 +136,8 @@ export declare class CreditAccountsService extends SDKConstruct {
     getRewards(creditAccount: Address): Promise<Array<Rewards>>;
     /**
      * Method to get all connected bots for credit account
-     * @param {Array<{ creditAccount: Address; creditManager: Address }>} accountsToCheck - list of credit accounts to check connected bots on
+     * @param {Array<{ creditAccount: Address; creditManager: Address }>} accountsToCheck - list of credit accounts
+        and their credit managers to check connected bots on
      * @returns call result of getConnectedBots for each credit account
      */
     getConnectedBots(accountsToCheck: Array<{
@@ -172,16 +173,16 @@ export declare class CreditAccountsService extends SDKConstruct {
     fullyLiquidate(account: RouterCASlice, to: Address, slippage?: bigint): Promise<CloseCreditAccountResult>;
     /**
      * Closes credit account or closes credit account and keeps it open with zero debt.
-        Ca is closed in the following order: price update -> close path to swap all tokens into underlying ->
+       - Ca is closed in the following order: price update -> close path to swap all tokens into underlying ->
          -> disable quotas of exiting tokens -> decrease debt -> disable exiting tokens tokens -> withdraw underlying tokenz
      * @param {CloseOptions} operation - {@link CloseOptions}: close or zeroDebt
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
      * @param {Array<Address>} assetsToWithdraw - tokens to withdraw from credit account.
         For credit account closing this is the underlying token, because during the closure,
         all tokens on account are swapped into the underlying,
         and only the underlying token will remain on the credit account
      * @param {Address} to - Wallet address to withdraw underlying to
-     * @param {number} slippage  - SLIPPAGE_DECIMALS = 100n
+     * @param {number} slippage  - Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
      * @default 50n
      * @param {RouterCloseResult | undefined} closePath - result of findBestClosePath method from router; if omited, calls marketRegister.findCreditManager {@link RouterCloseResult}
      * @returns All necessary data to execute the transaction (call, credit facade)
@@ -189,10 +190,10 @@ export declare class CreditAccountsService extends SDKConstruct {
     closeCreditAccount({ operation, assetsToWithdraw, creditAccount: ca, to, slippage, closePath, }: CloseCreditAccountProps): Promise<CloseCreditAccountResult>;
     /**
      * Fully repays credit account or repays credit account and keeps it open with zero debt
-        Repays in the following order: price update -> add collateral to cover the debt ->
+       - Repays in the following order: price update -> add collateral to cover the debt ->
         -> disable quotas for all tokens -> decrease debt -> disable tokens all tokens -> withdraw all tokens
      * @param {CloseOptions} operation - {@link CloseOptions}: close or zeroDebt
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed on which operation is performed
      * @param {Array<Address>} collateralAssets - tokens to repay dept.
         In the current implementation, this is the (debt+interest+fess) * buffer,
         where buffer refers to amount of tokens which will exceed current debt
@@ -207,9 +208,9 @@ export declare class CreditAccountsService extends SDKConstruct {
     repayCreditAccount({ operation, collateralAssets, assetsToWithdraw: wrapped, creditAccount: ca, permits, to, }: RepayCreditAccountProps): Promise<CommonResult>;
     /**
      * Fully repays liquidatable account
-        Repay and liquidate is executed in the following order: price update -> add collateral to cover the debt ->
+       - Repay and liquidate is executed in the following order: price update -> add collateral to cover the debt ->
         withdraw all tokens from credit account
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
      * @param {Array<Address>} collateralAssets - tokens to repay dept.
         In the current implementation, this is the (debt+interest+fess) * buffer,
         where buffer refers to amount of tokens which will exceed current debt
@@ -224,8 +225,8 @@ export declare class CreditAccountsService extends SDKConstruct {
     repayAndLiquidateCreditAccount({ collateralAssets, assetsToWithdraw: wrapped, creditAccount: ca, permits, to, }: RepayAndLiquidateCreditAccountProps): Promise<CommonResult>;
     /**
      * Updates quota of credit account.
-        CA quota updated in the following order: price update -> update quotas
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+       - CA quota updated in the following order: price update -> update quotas
+     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
      * @param {Array<Asset>} averageQuota - average quota for desired tokens {@link Asset}
      * @param {Array<Asset>} minQuota - minimum quota for desired tokens {@link Asset}
      * @returns All necessary data to execute the transaction (call, credit facade)
@@ -233,8 +234,8 @@ export declare class CreditAccountsService extends SDKConstruct {
     updateQuotas({ minQuota, averageQuota, creditAccount, }: UpdateQuotasProps): Promise<CommonResult>;
     /**
      * Adds a single collateral to credit account and updates quotas
-        Collateral is added in the following order: price update -> add collateral (with permit) -> update quotas
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+       - Collateral is added in the following order: price update -> add collateral (with permit) -> update quotas
+     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
      * @param {Array<Asset>} averageQuota - average quota for desired token {@link Asset}
      * @param {Array<Asset>} minQuota - minimum quota for desired token {@link Asset}
      * @param {Asset} asset - asset to add as collateral {@link Asset}
@@ -245,8 +246,8 @@ export declare class CreditAccountsService extends SDKConstruct {
     addCollateral({ creditAccount, asset, permit, ethAmount, minQuota, averageQuota, }: AddCollateralProps): Promise<CommonResult>;
     /**
      * Increases or decreases debt of credit account; debt decrease uses token ON CREDIT ACCOUNT
-        Debt is changed in the following order: price update -> (enables underlying if it was disabled) -> change debt
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+       - Debt is changed in the following order: price update -> (enables underlying if it was disabled) -> change debt
+     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
      * @param {bigint} amount - amount to change debt by;
         0 - prohibited value;
         negative value for debt decrease;
@@ -257,8 +258,8 @@ export declare class CreditAccountsService extends SDKConstruct {
     /**
      * Withdraws a single collateral from credit account to wallet to and updates quotas;
         technically can withdraw several tokens at once
-        Collateral is withdrawn in the following order: price update -> withdraw token -> update quotas for affected tokens
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+       - Collateral is withdrawn in the following order: price update -> withdraw token -> update quotas for affected tokens
+     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
      * @param {Array<Asset>} averageQuota - average quota for desired token {@link Asset}
      * @param {Array<Asset>} minQuota - minimum quota for desired token {@link Asset}
      * @param {Address} to - Wallet address to withdraw token to
@@ -268,8 +269,8 @@ export declare class CreditAccountsService extends SDKConstruct {
     withdrawCollateral({ creditAccount, assetsToWithdraw: wrapped, to, minQuota, averageQuota, }: WithdrawCollateralProps): Promise<CommonResult>;
     /**
      * Executes swap specified by given calls, update quotas of affected tokens
-        Swap is executed in the following order: price update -> execute swap path -> update quotas
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+       - Swap is executed in the following order: price update -> execute swap path -> update quotas
+     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
      * @param {Array<Asset>} averageQuota - average quota for desired token {@link Asset}
      * @param {Array<Asset>} minQuota - minimum quota for desired token {@link Asset}
      * @param {Array<MultiCall>} calls - array of MultiCall from router methods getSingleSwap or getAllSwaps {@link MultiCall}
@@ -278,9 +279,9 @@ export declare class CreditAccountsService extends SDKConstruct {
     executeSwap({ creditAccount, calls: swapCalls, minQuota, averageQuota, }: ExecuteSwapProps): Promise<CommonResult>;
     /**
      * Executes swap specified by given calls, update quotas of affected tokens
-        Claim rewards is executed in the following order: price update -> execute claim calls ->
+       - Claim rewards is executed in the following order: price update -> execute claim calls ->
         -> (optionally: disable reward tokens) -> (optionally: update quotas)
-     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice}
+     * @param {RouterCASlice} creditAccount - minimal credit account data {@link RouterCASlice} on which operation is performed
      * @param {Array<Asset>} averageQuota - average quota for desired token;
         in this case can be omitted since rewards tokens do not require quotas {@link Asset}
      * @param {Array<Asset>} minQuota - minimum quota for desired token;
@@ -293,13 +294,13 @@ export declare class CreditAccountsService extends SDKConstruct {
     claimFarmRewards({ tokensToDisable, calls: claimCalls, creditAccount: ca, minQuota, averageQuota, }: ClaimFarmRewardsProps): Promise<CommonResult>;
     /**
      * Executes swap specified by given calls, update quotas of affected tokens
-        Open credit account is executed in the following order: price update -> increase debt -> add collateral ->
+       - Open credit account is executed in the following order: price update -> increase debt -> add collateral ->
         -> update quotas -> (optionally: execute swap path for trading/strategy) ->
         -> (optionally: withdraw debt for lending)
-      Basic open credit account: price update -> increase debt -> add collateral -> update quotas
-      Lending: price update -> increase debt -> add collateral -> update quotas -> withdraw debt
-      Strategy/trading: price update -> increase debt -> add collateral -> update quotas -> execute swap path
-      In strategy is possible situation when collateral is added, but not swapped; the only swapped value in this case will be debt
+      - Basic open credit account: price update -> increase debt -> add collateral -> update quotas
+      - Lending: price update -> increase debt -> add collateral -> update quotas -> withdraw debt
+      - Strategy/trading: price update -> increase debt -> add collateral -> update quotas -> execute swap path
+      - In strategy is possible situation when collateral is added, but not swapped; the only swapped value in this case will be debt
      * @param {bigint} ethAmount - native token amount to attach to tx
      * @param {Address} creditManager - address of credit manager to open credit account on
      * @param {Array<Asset>} collateral - array of collateral which can be just directly added or swapped using the path {@link Asset}

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

@@ -9,50 +9,72 @@ export declare class RouterV300Contract extends AbstractRouterContract<abi> impl
     #private;
     constructor(sdk: GearboxSDK, address: Address);
     /**
-     * Finds all available swaps for NORMAL tokens
-     * @param ca
-     * @param cm
-     * @param swapOperation
-     * @param tokenIn
-     * @param tokenOut
-     * @param amount
-     * @param leftoverAmount
-     * @param slippage
-     * @returns
+     * 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}
      */
     findAllSwaps({ creditAccount: ca, creditManager: cm, swapOperation, tokenIn, tokenOut, amount, leftoverAmount, slippage, }: FindAllSwapsProps): Promise<Array<RouterResult>>;
     /**
-     * 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
+     * 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
      */
     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
+     * @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
      */
     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 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
+     * @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 - total balance of underlying token
-     *          - calls - list of calls which should be done to swap & unwrap everything to underlying token
+     *  - 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
      */
     findBestClosePath({ creditAccount: ca, creditManager: cm, slippage, balances, }: FindBestClosePathProps): Promise<RouterCloseResult>;
     /**
@@ -63,6 +85,9 @@ export declare class RouterV300Contract extends AbstractRouterContract<abi> impl
      * @returns
      */
     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.
+     */
     getAvailableConnectors(collateralTokens: Array<Address>): Array<Address>;
 }
 export {};

package/package.json

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