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

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

@@ -25,10 +25,12 @@ var import_viem = require("viem");
 var import_compressors = require("../../abi/compressors.js");
 var import_iBaseRewardPool = require("../../abi/iBaseRewardPool.js");
 var import_v300 = require("../../abi/v300.js");
+var import_adapters = require("../../adapters/abi/adapters.js");
 var import_base = require("../base/index.js");
 var import_constants = require("../constants/index.js");
 var import_market = require("../market/index.js");
 var import_router = require("../router/index.js");
+var import_sdk_gov_legacy = require("../sdk-gov-legacy/index.js");
 var import_utils = require("../utils/index.js");
 var import_viem2 = require("../utils/viem/index.js");
 class CreditAccountsService extends import_base.SDKConstruct {
@@ -142,6 +144,12 @@ class CreditAccountsService extends import_base.SDKConstruct {
     }
     return allCAs.sort((a, b) => Number(a.healthFactor - b.healthFactor));
   }
+  /**
+   * Method to get all claimable rewards for credit account (ex. stkUSDS SKY rewards)
+     Assosiates rewards by adapter + stakedPhantomToken
+   * @param {Address} creditAccount - address of credit account to get rewards for
+   * @returns {Array<Rewards>} list of {@link Rewards} that can be claimed
+   */
   async getRewards(creditAccount) {
     const rewards = await this.provider.publicClient.readContract({
       abi: import_compressors.iRewardsCompressorAbi,
@@ -160,7 +168,7 @@ class CreditAccountsService extends import_base.SDKConstruct {
           functionName: "getReward",
           args: []
         });
-        acc[adapter] = {
+        acc[key] = {
           adapter,
           stakedPhantomToken,
           calls: [
@@ -172,7 +180,7 @@ class CreditAccountsService extends import_base.SDKConstruct {
           rewards: []
         };
       }
-      acc[adapter].rewards.push({
+      acc[key].rewards.push({
         token: rewardToken,
         balance: r2.amount
       });
@@ -180,6 +188,11 @@ class CreditAccountsService extends import_base.SDKConstruct {
     }, {});
     return Object.values(r);
   }
+  /**
+   * 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
+   * @returns call result of getConnectedBots for each credit account
+   */
   async getConnectedBots(accountsToCheck) {
     const resp = await this.provider.publicClient.multicall({
       contracts: accountsToCheck.map((o) => {
@@ -225,14 +238,20 @@ class CreditAccountsService extends import_base.SDKConstruct {
     return { tx, calls, routerCloseResult, creditFacade: cm.creditFacade };
   }
   /**
-   * Closes credit account or sets debt to zero (but keep account)
-   * @param operation
-   * @param creditAccount
-   * @param assetsToWithdraw Tokens to withdraw from credit account
-   * @param to Address to withdraw underlying to
-   * @param slippage
-   * @param closePath
-   * @returns
+   * 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 -> 
+       -> 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 {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 
+   * @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)
    */
   async closeCreditAccount({
     operation,
@@ -267,20 +286,26 @@ class CreditAccountsService extends import_base.SDKConstruct {
     return { tx, calls, routerCloseResult, creditFacade: cm.creditFacade };
   }
   /**
-   * Repays credit account or sets debt to zero (but keep account)
-   * @param operation
-   * @param creditAccount
-   * @param assetsToWithdraw Tokens to withdraw from credit account
-   * @param collateralAssets Tokens to pay for
-   * @param to Address to withdraw underlying to
-   * @param slippage
-   * @param permits
-   * @returns
+   * 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 -> 
+      -> 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 {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 
+      in order to cover possible debt increase over tx execution
+   * @param {Array<Asset>} assetsToWithdraw - tokens to withdraw from credit account. 
+      Typically all non zero ca assets (including unclaimed rewards) 
+      plus underlying token (to withdraw any exceeding underlying token after repay)
+   * @param {Record<Address, PermitResult>} permits - permits of tokens to withdraw (in any permittable token is present) {@link PermitResult}
+   * @param {Address} to - Wallet address to withdraw underlying to
+   * @returns All necessary data to execute the transaction (call, credit facade)
    */
   async repayCreditAccount({
     operation,
     collateralAssets,
-    assetsToWithdraw,
+    assetsToWithdraw: wrapped,
     creditAccount: ca,
     permits,
     to
@@ -292,32 +317,46 @@ class CreditAccountsService extends import_base.SDKConstruct {
       ca,
       void 0
     );
+    const { unwrapCalls, assetsToWithdraw } = this.#prepareUnwrapAndWithdrawCallsV3(
+      wrapped,
+      true,
+      true,
+      ca.creditManager
+    );
     const calls = [
       ...priceUpdates,
       ...this.#prepareAddCollateral(ca.creditFacade, addCollateral, permits),
       ...this.#prepareDisableQuotas(ca),
       ...this.#prepareDecreaseDebt(ca),
+      ...unwrapCalls,
       ...this.#prepareDisableTokens(ca),
       // TODO: probably needs a better way to handle reward tokens
       ...assetsToWithdraw.map(
-        (t) => this.#prepareWithdrawToken(ca.creditFacade, t, import_constants.MAX_UINT256, to)
+        (t) => this.#prepareWithdrawToken(ca.creditFacade, t.token, import_constants.MAX_UINT256, to)
       )
     ];
     const tx = operation === "close" ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls) : cm.creditFacade.multicall(ca.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * Repays liquidatable credit account
-   * @param creditAccount
-   * @param assetsToWithdraw Tokens to withdraw from credit account
-   * @param collateralAssets Tokens to pay for
-   * @param to Address to withdraw underlying to
-   * @param slippage
-   * @returns
+   * Fully repays liquidatable account
+      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 {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 
+      in order to cover possible debt increase over tx execution
+   * @param {Array<Address>} assetsToWithdraw - tokens to withdraw from credit account. 
+      Typically all non zero ca assets (including unclaimed rewards) 
+      plus underlying token (to withdraw any exceeding underlying token after repay)
+   * @param {Record<Address, PermitResult>} permits - permits of tokens to withdraw (in any permittable token is present) {@link PermitResult}
+   * @param {Address} to - Wallet address to withdraw underlying to
+   * @returns All necessary data to execute the transaction (call, credit facade)
    */
   async repayAndLiquidateCreditAccount({
     collateralAssets,
-    assetsToWithdraw,
+    assetsToWithdraw: wrapped,
     creditAccount: ca,
     permits,
     to
@@ -329,11 +368,18 @@ class CreditAccountsService extends import_base.SDKConstruct {
       void 0
     );
     const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+    const { unwrapCalls, assetsToWithdraw } = this.#prepareUnwrapAndWithdrawCallsV3(
+      wrapped,
+      true,
+      true,
+      ca.creditManager
+    );
     const calls = [
       ...priceUpdates,
       ...this.#prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+      ...unwrapCalls,
       ...assetsToWithdraw.map(
-        (t) => this.#prepareWithdrawToken(ca.creditFacade, t, import_constants.MAX_UINT256, to)
+        (t) => this.#prepareWithdrawToken(ca.creditFacade, t.token, import_constants.MAX_UINT256, to)
       )
     ];
     const tx = cm.creditFacade.liquidateCreditAccount(
@@ -343,8 +389,19 @@ class CreditAccountsService extends import_base.SDKConstruct {
     );
     return { tx, calls, creditFacade: cm.creditFacade };
   }
-  async updateQuotas(props) {
-    const { creditAccount } = props;
+  /**
+   * 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}
+   * @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)
+   */
+  async updateQuotas({
+    minQuota,
+    averageQuota,
+    creditAccount
+  }) {
     const cm = this.sdk.marketRegister.findCreditManager(
       creditAccount.creditManager
     );
@@ -355,23 +412,46 @@ class CreditAccountsService extends import_base.SDKConstruct {
     );
     const calls = [
       ...priceUpdates,
-      ...this.#prepareUpdateQuotas(props.creditAccount.creditFacade, props)
+      ...this.#prepareUpdateQuotas(creditAccount.creditFacade, {
+        minQuota,
+        averageQuota
+      })
     ];
     const tx = cm.creditFacade.multicall(creditAccount.creditAccount, [
       ...priceUpdates,
-      ...this.#prepareUpdateQuotas(props.creditAccount.creditFacade, props)
+      ...this.#prepareUpdateQuotas(creditAccount.creditFacade, {
+        minQuota,
+        averageQuota
+      })
     ]);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
-  async addCollateral(props) {
-    const { creditAccount, asset, permit, ethAmount } = props;
+  /**
+   * 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}
+   * @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}
+   * @param {PermitResult | undefined} permits - permits of collateral asset if it is permittable {@link PermitResult}
+   * @param {bigint} ethAmount - native token amount to attach to tx
+   * @returns All necessary data to execute the transaction (call, credit facade)
+   */
+  async addCollateral({
+    creditAccount,
+    asset,
+    permit,
+    ethAmount,
+    minQuota,
+    averageQuota
+  }) {
     const cm = this.sdk.marketRegister.findCreditManager(
       creditAccount.creditManager
     );
     const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
       creditAccount.creditManager,
       creditAccount,
-      props.averageQuota
+      averageQuota
     );
     const calls = [
       ...priceUpdatesCalls,
@@ -380,12 +460,25 @@ class CreditAccountsService extends import_base.SDKConstruct {
         [asset],
         permit ? { [asset.token]: permit } : {}
       ),
-      ...this.#prepareUpdateQuotas(creditAccount.creditFacade, props)
+      ...this.#prepareUpdateQuotas(creditAccount.creditFacade, {
+        minQuota,
+        averageQuota
+      })
     ];
     const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
     tx.value = ethAmount.toString(10);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
+  /**
+   * 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}
+   * @param {bigint} amount - amount to change debt by; 
+      0 - prohibited value; 
+      negative value for debt decrease; 
+      positive value for debt increase.
+   * @returns All necessary data to execute the transaction (call, credit facade)
+   */
   async changeDebt({
     creditAccount,
     amount
@@ -415,8 +508,24 @@ class CreditAccountsService extends import_base.SDKConstruct {
     const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
-  async withdrawCollateral(props) {
-    const { creditAccount, assetsToWithdraw, to } = props;
+  /**
+   * 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}
+   * @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
+   * @param {Array<Asset>} assetsToWithdraw - permits for asset if it is permittable {@link PermitResult}
+   * @returns All necessary data to execute the transaction (call, credit facade)
+   */
+  async withdrawCollateral({
+    creditAccount,
+    assetsToWithdraw: wrapped,
+    to,
+    minQuota,
+    averageQuota
+  }) {
     const cm = this.sdk.marketRegister.findCreditManager(
       creditAccount.creditManager
     );
@@ -425,8 +534,15 @@ class CreditAccountsService extends import_base.SDKConstruct {
       creditAccount,
       void 0
     );
+    const { unwrapCalls, assetsToWithdraw } = this.#prepareUnwrapAndWithdrawCallsV3(
+      wrapped,
+      false,
+      false,
+      creditAccount.creditManager
+    );
     const calls = [
       ...priceUpdatesCalls,
+      ...unwrapCalls,
       ...assetsToWithdraw.map(
         (a) => this.#prepareWithdrawToken(
           creditAccount.creditFacade,
@@ -435,13 +551,29 @@ class CreditAccountsService extends import_base.SDKConstruct {
           to
         )
       ),
-      ...this.#prepareUpdateQuotas(creditAccount.creditFacade, props)
+      ...this.#prepareUpdateQuotas(creditAccount.creditFacade, {
+        minQuota,
+        averageQuota
+      })
     ];
     const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
-  async executeSwap(props) {
-    const { creditAccount, calls: swapCalls } = props;
+  /**
+   * 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}
+   * @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}
+   * @returns All necessary data to execute the transaction (call, credit facade)
+   */
+  async executeSwap({
+    creditAccount,
+    calls: swapCalls,
+    minQuota,
+    averageQuota
+  }) {
     if (swapCalls.length === 0) throw new Error("No path to execute");
     const cm = this.sdk.marketRegister.findCreditManager(
       creditAccount.creditManager
@@ -449,24 +581,46 @@ class CreditAccountsService extends import_base.SDKConstruct {
     const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
       creditAccount.creditManager,
       creditAccount,
-      props.averageQuota
+      averageQuota
     );
     const calls = [
       ...priceUpdatesCalls,
       ...swapCalls,
-      ...this.#prepareUpdateQuotas(creditAccount.creditFacade, props)
+      ...this.#prepareUpdateQuotas(creditAccount.creditFacade, {
+        minQuota,
+        averageQuota
+      })
     ];
     const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
-  async claimFarmRewards(props) {
-    const { tokensToDisable, calls: claimCalls, creditAccount: ca } = props;
+  /**
+   * Executes swap specified by given calls, update quotas of affected tokens
+      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 {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;
+      in this case can be omitted since rewards tokens do not require quotas {@link Asset}
+   * @param {Array<MultiCall>} calls - array of MultiCall from getRewards {@link MultiCall}
+   * @param {Array<Asset>} tokensToDisable - tokens to disable after rewards claiming;
+      sometimes is needed since old credit facade used to enable tokens on claim {@link Asset}
+   * @returns All necessary data to execute the transaction (call, credit facade)
+   */
+  async claimFarmRewards({
+    tokensToDisable,
+    calls: claimCalls,
+    creditAccount: ca,
+    minQuota,
+    averageQuota
+  }) {
     if (claimCalls.length === 0) throw new Error("No path to execute");
     const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
     const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
       ca.creditManager,
       ca,
-      props.averageQuota
+      averageQuota
     );
     const calls = [
       ...priceUpdatesCalls,
@@ -474,35 +628,63 @@ class CreditAccountsService extends import_base.SDKConstruct {
       ...tokensToDisable.map(
         (a) => this.#prepareDisableToken(ca.creditFacade, a.token)
       ),
-      ...this.#prepareUpdateQuotas(ca.creditFacade, props)
+      ...this.#prepareUpdateQuotas(ca.creditFacade, { minQuota, averageQuota })
     ];
     const tx = cm.creditFacade.multicall(ca.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
-  async openCA(props) {
-    const {
-      ethAmount,
-      creditManager,
-      collateral,
-      permits,
-      debt,
-      withdrawDebt,
-      referralCode,
-      to,
-      calls: openPathCalls
-    } = props;
+  /**
+   * 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 ->
+      -> 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
+   * @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}
+   * @param {Record<Address, PermitResult>} permits - permits of collateral tokens (in any permittable token is present) {@link PermitResult}
+   * @param {bigint} debt - debt to open credit account with
+   * @param {boolean} withdrawDebt - flag to withdraw debt to wallet after opening credit account; 
+      used for borrowing functionality
+   * @param {bigint} referralCode - referral code to open credit account with
+   * @param {Address} to - wallet address to transfer credit account to\
+   * @param {Array<MultiCall>} calls - array of MultiCall from router methods findOpenStrategyPath {@link MultiCall}.
+      Used for trading and strategy functionality
+   * @param {Array<Asset>} averageQuota - average quota for tokens after open {@link Asset}
+   * @param {Array<Asset>} minQuota - minimum quota for tokens after open  {@link Asset}
+   * @returns All necessary data to execute the transaction (call, credit facade)
+   */
+  async openCA({
+    ethAmount,
+    creditManager,
+    collateral,
+    permits,
+    debt,
+    withdrawDebt,
+    referralCode,
+    to,
+    calls: openPathCalls,
+    minQuota,
+    averageQuota
+  }) {
     const cmSuite = this.sdk.marketRegister.findCreditManager(creditManager);
     const cm = cmSuite.creditManager;
     const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
       cm.address,
       void 0,
-      props.averageQuota
+      averageQuota
     );
     const calls = [
       ...priceUpdatesCalls,
       this.#prepareIncreaseDebt(cm.creditFacade, debt),
       ...this.#prepareAddCollateral(cm.creditFacade, collateral, permits),
-      ...this.#prepareUpdateQuotas(cm.creditFacade, props),
+      ...this.#prepareUpdateQuotas(cm.creditFacade, {
+        minQuota,
+        averageQuota
+      }),
       ...openPathCalls,
       ...withdrawDebt ? [this.#prepareWithdrawToken(cm.creditFacade, cm.underlying, debt, to)] : []
     ];
@@ -712,7 +894,8 @@ class CreditAccountsService extends import_base.SDKConstruct {
   #prepareDisableTokens(ca) {
     const calls = [];
     for (const t of ca.tokens) {
-      if (t.token !== ca.underlying && (t.mask & ca.enabledTokensMask) !== 0n && t.quota === 0n) {
+      const isEnabled = (t.mask & ca.enabledTokensMask) !== 0n;
+      if (t.token !== ca.underlying && isEnabled && t.quota === 0n) {
         calls.push(this.#prepareDisableToken(ca.creditFacade, t.token));
       }
     }
@@ -792,6 +975,174 @@ class CreditAccountsService extends import_base.SDKConstruct {
     });
     return calls;
   }
+  /**
+   * unwraps staked tokens and optionally claims associated rewards; Should be remove after transition to 3.1
+   * @param acc
+   * @returns
+   */
+  #prepareUnwrapAndWithdrawCallsV3(assets, claim, withdrawAll, creditManager) {
+    const network = this.sdk.provider.networkType;
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const cmAdapters = suite.creditManager.adapters.values().reduce((acc, a) => {
+      const contractLc = a.targetContract.toLowerCase();
+      const adapterLc = a.address.toLowerCase();
+      acc[contractLc] = adapterLc;
+      return acc;
+    }, {});
+    const currentContractsData = Object.entries(
+      import_sdk_gov_legacy.contractsByNetwork[network]
+    ).reduce(
+      (acc, [symbol, address]) => {
+        if (!!address && address !== import_constants.NOT_DEPLOYED) {
+          acc[symbol] = address.toLowerCase();
+        }
+        return acc;
+      },
+      {}
+    );
+    const currentTokenData = Object.entries(import_sdk_gov_legacy.tokenDataByNetwork[network]).reduce(
+      (acc, [symbol, address]) => {
+        if (!!address && address !== import_constants.NOT_DEPLOYED) {
+          acc[symbol] = address.toLowerCase();
+        }
+        return acc;
+      },
+      {}
+    );
+    const { aura, convex, sky } = assets.reduce(
+      (acc, a) => {
+        const symbol = import_sdk_gov_legacy.tokenSymbolByAddress[a.token];
+        if ((0, import_sdk_gov_legacy.isConvexStakedPhantomToken)(symbol)) {
+          acc.convex.push(a);
+        } else if ((0, import_sdk_gov_legacy.isAuraStakedToken)(symbol)) {
+          acc.aura.push(a);
+        } else if ((0, import_sdk_gov_legacy.isStakingRewardsPhantomToken)(symbol)) {
+          acc.sky.push(a);
+        }
+        return acc;
+      },
+      { convex: [], aura: [], sky: [] }
+    );
+    const getWithdrawCall = (pool, a) => {
+      return withdrawAll ? this.#withdrawAllAndUnwrap_Convex(pool, claim) : this.#withdrawAndUnwrap_Convex(pool, a.balance, claim);
+    };
+    const getWithdrawCall_Rewards = (pool, a) => {
+      const calls = [
+        withdrawAll ? this.#withdrawAll_Rewards(pool) : this.#withdraw_Rewards(pool, a.balance),
+        ...claim ? [this.#claim_Rewards(pool)] : []
+      ];
+      return calls;
+    };
+    const convexStkCalls = convex.map((a) => {
+      const symbol = import_sdk_gov_legacy.tokenSymbolByAddress[a.token];
+      const { pool } = import_sdk_gov_legacy.convexTokens[symbol];
+      const poolAddress = currentContractsData[pool];
+      if (!poolAddress) {
+        throw new Error("Can't withdrawAllAndUnwrap_Convex (convex)");
+      }
+      const poolAddressLc = poolAddress.toLowerCase();
+      return getWithdrawCall(cmAdapters[poolAddressLc], a);
+    });
+    const auraStkCalls = aura.map((a) => {
+      const symbol = import_sdk_gov_legacy.tokenSymbolByAddress[a.token];
+      const { pool } = import_sdk_gov_legacy.auraTokens[symbol];
+      const poolAddress = currentContractsData[pool];
+      if (!poolAddress) {
+        throw new Error("Can't withdrawAllAndUnwrap_Convex (aura)");
+      }
+      const poolAddressLc = poolAddress.toLowerCase();
+      return getWithdrawCall(cmAdapters[poolAddressLc], a);
+    });
+    const skyStkCalls = sky.map((a) => {
+      const symbol = import_sdk_gov_legacy.tokenSymbolByAddress[a.token];
+      const { pool } = import_sdk_gov_legacy.stakingRewardsTokens[symbol];
+      const poolAddress = currentContractsData[pool];
+      if (!poolAddress) {
+        throw new Error("Can't withdrawAllAndUnwrap_Convex (sky)");
+      }
+      const poolAddressLc = poolAddress.toLowerCase();
+      return getWithdrawCall_Rewards(cmAdapters[poolAddressLc], a);
+    }).flat(1);
+    const unwrapCalls = [...convexStkCalls, ...auraStkCalls, ...skyStkCalls];
+    const withdraw = assets.map((a) => {
+      const symbol = import_sdk_gov_legacy.tokenSymbolByAddress[a.token];
+      if ((0, import_sdk_gov_legacy.isConvexStakedPhantomToken)(symbol)) {
+        return {
+          ...a,
+          token: currentTokenData[import_sdk_gov_legacy.convexStakedPhantomTokens[symbol].underlying]
+        };
+      }
+      if ((0, import_sdk_gov_legacy.isAuraStakedToken)(symbol)) {
+        return {
+          ...a,
+          token: currentTokenData[import_sdk_gov_legacy.auraStakedTokens[symbol].underlying]
+        };
+      }
+      if ((0, import_sdk_gov_legacy.isStakingRewardsPhantomToken)(symbol)) {
+        return {
+          ...a,
+          token: currentTokenData[import_sdk_gov_legacy.stakingRewardsTokens[symbol].underlying]
+        };
+      }
+      return a;
+    });
+    return { unwrapCalls, assetsToWithdraw: withdraw };
+  }
+  // TODO: remove after transition to 3.1
+  #withdrawAndUnwrap_Convex(address, amount, claim) {
+    return {
+      target: address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_adapters.iConvexV1BaseRewardPoolAdapterAbi,
+        functionName: "withdrawAndUnwrap",
+        args: [amount, claim]
+      })
+    };
+  }
+  // TODO: remove after transition to 3.1
+  #withdrawAllAndUnwrap_Convex(address, claim) {
+    return {
+      target: address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_adapters.iConvexV1BaseRewardPoolAdapterAbi,
+        functionName: "withdrawDiffAndUnwrap",
+        args: [1n, claim]
+      })
+    };
+  }
+  // TODO: remove after transition to 3.1
+  #withdrawAll_Rewards(address) {
+    return {
+      target: address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_adapters.iStakingRewardsAdapterAbi,
+        functionName: "withdrawDiff",
+        args: [1n]
+      })
+    };
+  }
+  // TODO: remove after transition to 3.1
+  #withdraw_Rewards(address, amount) {
+    return {
+      target: address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_adapters.iStakingRewardsAdapterAbi,
+        functionName: "withdraw",
+        args: [amount]
+      })
+    };
+  }
+  // TODO: remove after transition to 3.1
+  #claim_Rewards(address) {
+    return {
+      target: address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_adapters.iStakingRewardsAdapterAbi,
+        functionName: "getReward",
+        args: []
+      })
+    };
+  }
   /**
    * Returns addresses of market configurators
    */