@gearbox-protocol/sdk 13.3.3 → 13.4.0-beta.2

package/dist/esm/sdk/accounts/AbstractCreditAccountsService.js

@@ -1,4 +1,4 @@
-import { encodeFunctionData, getAddress, getContract } from "viem";
+import { encodeFunctionData, getContract } from "viem";
 import {
   iBotListV310Abi,
   iCreditFacadeMulticallV310Abi
@@ -21,9 +21,17 @@ import {
   RAY,
   VERSION_RANGE_310
 } from "../constants/index.js";
+import {
+  getRawPriceUpdates
+} from "../market/index.js";
 import { assetsMap } from "../router/index.js";
-import { AddressMap } from "../utils/index.js";
+import { AddressMap, AddressSet } from "../utils/index.js";
 import { simulateWithPriceUpdates } from "../utils/viem/index.js";
+import {
+  extractPriceUpdates,
+  extractQuotaTokens,
+  mergePriceUpdates
+} from "./multicall-utils.js";
 const COMPRESSORS = {
   [chains.Mainnet.id]: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
   [chains.Monad.id]: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023"
@@ -46,12 +54,8 @@ class AbstractCreditAccountService extends SDKConstruct {
     );
   }
   /**
-   * Returns single credit account data, or undefined if it's not found
-   * Performs all necessary price feed updates under the hood
-   * @param account
-   * @param blockNumber
-   * @returns
-   */
+   * {@inheritDoc ICreditAccountsService.getCreditAccountData}
+   **/
   async getCreditAccountData(account, blockNumber) {
     let raw;
     try {
@@ -70,10 +74,7 @@ class AbstractCreditAccountService extends SDKConstruct {
     if (raw.success) {
       return raw;
     }
-    const { txs: priceUpdateTxs } = await this.getUpdateForAccount({
-      creditManager: raw.creditManager,
-      creditAccount: raw
-    });
+    const { txs: priceUpdateTxs } = await this.getUpdateForAccount(raw);
     const [cad] = await simulateWithPriceUpdates(this.client, {
       priceUpdates: priceUpdateTxs,
       contracts: [
@@ -90,13 +91,8 @@ class AbstractCreditAccountService extends SDKConstruct {
     return cad;
   }
   /**
-   * Methods to get all credit accounts with some optional filtering
-   * Performs all necessary price feed updates under the hood
-   *
-   * @param options
-   * @param blockNumber
-   * @returns returned credit accounts are sorted by health factor in ascending order
-   */
+   * {@inheritDoc ICreditAccountsService.getCreditAccounts}
+   **/
   async getCreditAccounts(options, blockNumber) {
     const {
       creditManager,
@@ -149,11 +145,8 @@ class AbstractCreditAccountService extends 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
-   */
+   * {@inheritDoc ICreditAccountsService.getRewards}
+   **/
   async getRewards(creditAccount) {
     const rewards = await this.client.readContract({
       abi: rewardsCompressorAbi,
@@ -193,11 +186,8 @@ class AbstractCreditAccountService extends SDKConstruct {
     return Object.values(r);
   }
   /**
-   * Method to get all connected bots for credit account
-   * @param {Array<AccountToCheck>} accountsToCheck - list of credit accounts 
-      and their credit managers to check connected bots on
-   * @returns call result of getConnectedBots for each credit account
-   */
+   * {@inheritDoc ICreditAccountsService.getConnectedBots}
+   **/
   async getConnectedBots(accountsToCheck, legacyMigrationBot, additionalBots) {
     const allResp = await this.client.multicall({
       contracts: [
@@ -301,10 +291,8 @@ class AbstractCreditAccountService extends SDKConstruct {
     return void 0;
   }
   /**
-   * Generates transaction to liquidate credit account
-   * @param props - {@link FullyLiquidateProps}
-   * @returns
-   */
+   * {@inheritDoc ICreditAccountsService.fullyLiquidate}
+   **/
   async fullyLiquidate(props) {
     const {
       account,
@@ -323,12 +311,12 @@ class AbstractCreditAccountService extends SDKConstruct {
       keepAssets,
       debtOnly
     });
-    const priceUpdates = await this.getPriceUpdatesForFacade({
-      creditManager: account.creditManager,
-      creditAccount: account,
-      ignoreReservePrices
-    });
-    const calls = [...priceUpdates, ...routerCloseResult.calls];
+    const calls = await this.prependPriceUpdates(
+      account.creditManager,
+      routerCloseResult.calls,
+      account,
+      { ignoreReservePrices }
+    );
     let lossPolicyData;
     if (applyLossPolicy) {
       const market = this.sdk.marketRegister.findByCreditManager(
@@ -354,21 +342,8 @@ class AbstractCreditAccountService 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 -> 
-       -> 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} 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 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)
-   */
+   * {@inheritDoc ICreditAccountsService.closeCreditAccount}
+   **/
   async closeCreditAccount({
     operation,
     assetsToWithdraw,
@@ -383,12 +358,7 @@ class AbstractCreditAccountService extends SDKConstruct {
       creditManager: cm.creditManager,
       slippage
     });
-    const priceUpdates = await this.getPriceUpdatesForFacade({
-      creditManager: ca.creditManager,
-      creditAccount: ca
-    });
-    const calls = [
-      ...operation === "close" ? [] : priceUpdates,
+    const operationCalls = [
       ...routerCloseResult.calls,
       ...this.prepareDisableQuotas(ca),
       ...this.prepareDecreaseDebt(ca),
@@ -396,17 +366,13 @@ class AbstractCreditAccountService extends SDKConstruct {
         (t) => this.prepareWithdrawToken(ca.creditFacade, t, MAX_UINT256, to)
       )
     ];
+    const calls = operation === "close" ? operationCalls : await this.prependPriceUpdates(ca.creditManager, operationCalls, ca);
     const tx = operation === "close" ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls) : cm.creditFacade.multicall(ca.creditAccount, calls);
     return { tx, calls, routerCloseResult, creditFacade: cm.creditFacade };
   }
   /**
-   * 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} 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)
-   */
+   * {@inheritDoc ICreditAccountsService.updateQuotas}
+   **/
   async updateQuotas({
     minQuota,
     averageQuota,
@@ -415,31 +381,21 @@ class AbstractCreditAccountService extends SDKConstruct {
     const cm = this.sdk.marketRegister.findCreditManager(
       creditAccount.creditManager
     );
-    const priceUpdates = await this.getPriceUpdatesForFacade({
-      creditManager: creditAccount.creditManager,
+    const operationCalls = this.prepareUpdateQuotas(
+      creditAccount.creditFacade,
+      { minQuota, averageQuota }
+    );
+    const calls = await this.prependPriceUpdates(
+      creditAccount.creditManager,
+      operationCalls,
       creditAccount
-    });
-    const calls = [
-      ...priceUpdates,
-      ...this.prepareUpdateQuotas(creditAccount.creditFacade, {
-        minQuota,
-        averageQuota
-      })
-    ];
+    );
     const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * 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} 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}
-   * @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)
-   */
+   * {@inheritDoc ICreditAccountsService.addCollateral}
+   **/
   async addCollateral({
     creditAccount,
     asset,
@@ -451,13 +407,7 @@ class AbstractCreditAccountService extends SDKConstruct {
     const cm = this.sdk.marketRegister.findCreditManager(
       creditAccount.creditManager
     );
-    const priceUpdatesCalls = await this.getPriceUpdatesForFacade({
-      creditManager: creditAccount.creditManager,
-      creditAccount,
-      desiredQuotas: averageQuota
-    });
-    const calls = [
-      ...priceUpdatesCalls,
+    const operationCalls = [
       ...this.prepareAddCollateral(
         creditAccount.creditFacade,
         [asset],
@@ -468,20 +418,18 @@ class AbstractCreditAccountService extends SDKConstruct {
         averageQuota
       })
     ];
+    const calls = await this.prependPriceUpdates(
+      creditAccount.creditManager,
+      operationCalls,
+      creditAccount
+    );
     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} on which operation is performed
-   * @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)
-   */
+   * {@inheritDoc ICreditAccountsService.changeDebt}
+   **/
   async changeDebt({
     creditAccount,
     amount,
@@ -495,10 +443,6 @@ class AbstractCreditAccountService extends SDKConstruct {
     const cm = this.sdk.marketRegister.findCreditManager(
       creditAccount.creditManager
     );
-    const priceUpdatesCalls = await this.getPriceUpdatesForFacade({
-      creditManager: creditAccount.creditManager,
-      creditAccount
-    });
     const addCollateralCalls = addCollateral && isDecrease ? this.prepareAddCollateral(
       creditAccount.creditFacade,
       [
@@ -509,23 +453,21 @@ class AbstractCreditAccountService extends SDKConstruct {
       ],
       {}
     ) : [];
-    const calls = [
-      ...priceUpdatesCalls,
+    const operationCalls = [
       ...addCollateralCalls,
       this.#prepareChangeDebt(creditAccount.creditFacade, change, isDecrease)
     ];
+    const calls = await this.prependPriceUpdates(
+      creditAccount.creditManager,
+      operationCalls,
+      creditAccount
+    );
     const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * 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} 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}
-   * @returns All necessary data to execute the transaction (call, credit facade)
-   */
+   * {@inheritDoc ICreditAccountsService.executeSwap}
+   **/
   async executeSwap({
     creditAccount,
     calls: swapCalls,
@@ -536,27 +478,24 @@ class AbstractCreditAccountService extends SDKConstruct {
     const cm = this.sdk.marketRegister.findCreditManager(
       creditAccount.creditManager
     );
-    const priceUpdatesCalls = await this.getPriceUpdatesForFacade({
-      creditManager: creditAccount.creditManager,
-      creditAccount,
-      desiredQuotas: averageQuota
-    });
-    const calls = [
-      ...priceUpdatesCalls,
+    const operationCalls = [
       ...swapCalls,
       ...this.prepareUpdateQuotas(creditAccount.creditFacade, {
         minQuota,
         averageQuota
       })
     ];
+    const calls = await this.prependPriceUpdates(
+      creditAccount.creditManager,
+      operationCalls,
+      creditAccount
+    );
     const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * Preview delayed withdrawal for given token
-   * @param props - {@link PreviewDelayedWithdrawalProps}
-   * @returns
-   */
+   * {@inheritDoc ICreditAccountsService.previewDelayedWithdrawal}
+   **/
   async previewDelayedWithdrawal({
     creditAccount,
     amount,
@@ -580,10 +519,8 @@ class AbstractCreditAccountService extends SDKConstruct {
     return resp;
   }
   /**
-   * Get claimable and pending withdrawals of an account
-   * @param props - {@link GetPendingWithdrawalsProps}
-   * @returns
-   */
+   * {@inheritDoc ICreditAccountsService.getPendingWithdrawals}
+   **/
   async getPendingWithdrawals({
     creditAccount
   }) {
@@ -609,11 +546,8 @@ class AbstractCreditAccountService extends SDKConstruct {
     return respResult;
   }
   /**
-   * Start delayed withdrawal for given token
-     - Withdrawal is executed in the following order: price update -> execute withdraw calls -> update quotas
-   * @param props - {@link StartDelayedWithdrawalProps}
-   * @returns
-  */
+   * {@inheritDoc ICreditAccountsService.startDelayedWithdrawal}
+   **/
   async startDelayedWithdrawal({
     creditAccount,
     minQuota,
@@ -650,13 +584,7 @@ class AbstractCreditAccountService extends SDKConstruct {
         args: []
       })
     };
-    const priceUpdatesCalls = await this.getPriceUpdatesForFacade({
-      creditManager: creditAccount.creditManager,
-      creditAccount,
-      desiredQuotas: averageQuota
-    });
-    const calls = [
-      ...priceUpdatesCalls,
+    const operationCalls = [
       storeExpectedBalances,
       ...preview.requestCalls,
       compareBalances,
@@ -665,15 +593,17 @@ class AbstractCreditAccountService extends SDKConstruct {
         averageQuota
       })
     ];
+    const calls = await this.prependPriceUpdates(
+      creditAccount.creditManager,
+      operationCalls,
+      creditAccount
+    );
     const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * Claim tokens with delayed withdrawal
-     - Claim is executed in the following order: price update -> execute claim calls -> update quotas
-   * @param props - {@link ClaimDelayedProps}
-   * @returns
-  */
+   * {@inheritDoc ICreditAccountsService.claimDelayed}
+   **/
   async claimDelayed({
     creditAccount,
     minQuota,
@@ -714,49 +644,27 @@ class AbstractCreditAccountService extends SDKConstruct {
         args: []
       })
     };
-    const priceUpdatesCalls = zeroDebt ? [] : await this.getPriceUpdatesForFacade({
-      creditManager: creditAccount.creditManager,
-      creditAccount,
-      desiredQuotas: averageQuota
-    });
     const quotaCalls = zeroDebt ? [] : this.prepareUpdateQuotas(creditAccount.creditFacade, {
       minQuota,
       averageQuota
     });
-    const calls = [
-      ...priceUpdatesCalls,
+    const operationCalls = [
       storeExpectedBalances,
       ...claimableNow.claimCalls,
       compareBalances,
       ...quotaCalls
     ];
+    const calls = zeroDebt ? operationCalls : await this.prependPriceUpdates(
+      creditAccount.creditManager,
+      operationCalls,
+      creditAccount
+    );
     const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
-   * 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)
-   */
+   * {@inheritDoc ICreditAccountsService.openCA}
+   **/
   async openCA({
     ethAmount,
     creditManager,
@@ -772,12 +680,7 @@ class AbstractCreditAccountService extends SDKConstruct {
   }) {
     const cmSuite = this.sdk.marketRegister.findCreditManager(creditManager);
     const cm = cmSuite.creditManager;
-    const priceUpdatesCalls = await this.getPriceUpdatesForFacade({
-      creditManager: cm.address,
-      desiredQuotas: averageQuota
-    });
-    const calls = [
-      ...priceUpdatesCalls,
+    const operationCalls = [
       this.#prepareIncreaseDebt(cm.creditFacade, debt),
       ...this.prepareAddCollateral(cm.creditFacade, collateral, permits),
       ...openPathCalls,
@@ -787,15 +690,14 @@ class AbstractCreditAccountService extends SDKConstruct {
         averageQuota
       })
     ];
+    const calls = await this.prependPriceUpdates(cm.address, operationCalls);
     const tx = cmSuite.creditFacade.openCreditAccount(to, calls, referralCode);
     tx.value = ethAmount.toString(10);
     return { calls, tx, creditFacade: cmSuite.creditFacade };
   }
   /**
-   * Returns borrow rate with 4 digits precision (10000 = 100%)
-   * @param ca
-   * @returns
-   */
+   * {@inheritDoc ICreditAccountsService.getBorrowRate}
+   **/
   getBorrowRate(ca) {
     const { creditManager } = this.sdk.marketRegister.findCreditManager(
       ca.creditManager
@@ -821,9 +723,8 @@ class AbstractCreditAccountService extends SDKConstruct {
     return r + qr;
   }
   /**
-   * Returns optimal HF for partial liquidation with 4 digits precision (10000 = 100%)
-   * @param ca
-   */
+   * {@inheritDoc ICreditAccountsService.getOptimalHFForPartialLiquidation}
+   **/
   getOptimalHFForPartialLiquidation(ca) {
     const borrowRate = this.getBorrowRate(ca);
     return PERCENTAGE_FACTOR + (borrowRate < 100n ? borrowRate : 100n);
@@ -872,112 +773,146 @@ class AbstractCreditAccountService extends SDKConstruct {
     return resp;
   }
   /**
-   * Returns raw txs that are needed to update all price feeds so that all credit accounts (possibly from different markets) compute
+   * {@inheritDoc ICreditAccountsService.getOnDemandPriceUpdates}
+   **/
+  async getOnDemandPriceUpdates(account, ignoreReservePrices) {
+    const { creditManager, creditAccount } = account;
+    const cm = this.sdk.marketRegister.findCreditManager(creditManager);
+    const update = await this.getUpdateForAccount(account, ignoreReservePrices);
+    this.logger?.debug(
+      { account: creditAccount, manager: cm.name },
+      `getting on demand price updates from ${update.txs.length} txs`
+    );
+    return getRawPriceUpdates(update);
+  }
+  /**
+   * Analyzes a multicall array and prepends necessary on-demand price feed updates.
    *
-   * This can be used by batch liquidator
-   * @param accounts
-   * @returns
+   * Deduplicates existing `onDemandPriceUpdates` calls
+   *
+   * @param creditManager - Address of the credit manager
+   * @param calls - The multicall array to prepend price updates to
+   * @param ca - Credit account slice, undefined when opening a new account
+   * @param options - Optional settings for price update generation
+   * @returns A new array with a single consolidated price update call prepended,
+   *          followed by the non-price-update calls in their original order
    */
-  async getUpdateForAccounts(accounts) {
-    const tokensByPool = /* @__PURE__ */ new Map();
-    const oracleByPool = /* @__PURE__ */ new Map();
-    for (const acc of accounts) {
-      const market = this.sdk.marketRegister.findByCreditManager(
-        acc.creditManager
-      );
-      const pool = market.pool.pool.address;
-      oracleByPool.set(pool, market.priceOracle);
-      for (const t of acc.tokens) {
-        if (t.balance > 10n) {
-          const tokens = tokensByPool.get(pool) ?? /* @__PURE__ */ new Set();
+  async prependPriceUpdates(creditManager, calls, ca, options) {
+    const market = this.sdk.marketRegister.findByCreditManager(creditManager);
+    const cm = this.sdk.marketRegister.findCreditManager(creditManager).creditManager;
+    const { priceUpdates: existingUpdates, remainingCalls } = extractPriceUpdates(calls);
+    const tokens = new AddressSet([
+      cm.underlying,
+      // underlying - always included
+      ...extractQuotaTokens(calls)
+      // tokens from `updateQuota` calls
+    ]);
+    if (ca) {
+      for (const t of ca.tokens) {
+        const isEnabled = (t.mask & ca.enabledTokensMask) !== 0n;
+        if (t.balance > 10n && isEnabled) {
           tokens.add(t.token);
-          tokensByPool.set(pool, tokens);
         }
       }
     }
-    const priceFeeds = [];
-    for (const [pool, oracle] of oracleByPool.entries()) {
-      const tokens = Array.from(tokensByPool.get(pool) ?? []);
-      priceFeeds.push(...oracle.priceFeedsForTokens(tokens));
+    const ignoreReservePrices = options?.ignoreReservePrices;
+    const priceFeeds = market.priceOracle.priceFeedsForTokens(Array.from(tokens), {
+      main: true,
+      reserve: !ignoreReservePrices
+    });
+    const tStr = tokens.map((t) => this.labelAddress(t)).join(", ");
+    const remark = ignoreReservePrices ? " main" : "";
+    this.logger?.debug(
+      { account: ca?.creditAccount, manager: cm.name },
+      `prependPriceUpdates for ${tStr} from ${priceFeeds.length}${remark} price feeds`
+    );
+    const generatedUpdates = await this.sdk.priceFeeds.generatePriceFeedsUpdates(priceFeeds);
+    const merged = mergePriceUpdates(existingUpdates, generatedUpdates);
+    if (merged.length === 0) {
+      return remainingCalls;
     }
-    return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(priceFeeds);
+    return [
+      {
+        target: cm.creditFacade,
+        callData: encodeFunctionData({
+          abi: iCreditFacadeMulticallV310Abi,
+          functionName: "onDemandPriceUpdates",
+          args: [merged]
+        })
+      },
+      ...remainingCalls
+    ];
   }
-  async getUpdateForAccount(options) {
-    const { creditManager, creditAccount, desiredQuotas, ignoreReservePrices } = options;
-    const quotaRecord = desiredQuotas ? assetsMap(desiredQuotas) : desiredQuotas;
-    const caBalancesRecord = creditAccount ? assetsMap(creditAccount.tokens) : creditAccount;
+  async getUpdateForAccount(account, ignoreReservePrices) {
+    const { creditManager, creditAccount, enabledTokensMask } = account;
     const market = this.sdk.marketRegister.findByCreditManager(creditManager);
     const cm = this.sdk.marketRegister.findCreditManager(creditManager).creditManager;
-    const tokens = /* @__PURE__ */ new Set([getAddress(cm.underlying)]);
-    for (const t of cm.collateralTokens) {
-      if (creditAccount && caBalancesRecord && quotaRecord) {
-        const balanceAsset = caBalancesRecord.get(t);
-        const balance = balanceAsset?.balance || 0n;
-        const mask = balanceAsset?.mask || 0n;
-        const isEnabled = (mask & creditAccount.enabledTokensMask) !== 0n;
-        const quotaAsset = quotaRecord.get(t);
-        const quotaBalance = quotaAsset?.balance || 0n;
-        if (balance > 10n && isEnabled || quotaBalance > 0) {
-          tokens.add(getAddress(t));
-        }
-      } else if (creditAccount && caBalancesRecord) {
-        const balanceAsset = caBalancesRecord.get(t);
-        const balance = balanceAsset?.balance || 0n;
-        const mask = balanceAsset?.mask || 0n;
-        const isEnabled = (mask & creditAccount.enabledTokensMask) !== 0n;
-        if (balance > 10n && isEnabled) {
-          tokens.add(getAddress(t));
-        }
-      } else if (quotaRecord) {
-        const quotaAsset = quotaRecord.get(t);
-        const quotaBalance = quotaAsset?.balance || 0n;
-        if (quotaBalance > 0) {
-          tokens.add(getAddress(t));
-        }
+    const tokens = new AddressSet([cm.underlying]);
+    for (const t of account.tokens) {
+      const isEnabled = (t.mask & enabledTokensMask) !== 0n;
+      if (t.balance > 10n && isEnabled) {
+        tokens.add(t.token);
       }
     }
     const priceFeeds = market.priceOracle.priceFeedsForTokens(Array.from(tokens), {
       main: true,
       reserve: !ignoreReservePrices
     });
-    const tStr = Array.from(tokens).map((t) => this.labelAddress(t)).join(", ");
+    const tStr = tokens.map((t) => this.labelAddress(t)).join(", ");
     const remark = ignoreReservePrices ? " main" : "";
     this.logger?.debug(
-      { account: creditAccount?.creditAccount, manager: cm.name },
+      { account: creditAccount, manager: cm.name },
       `generating price feed updates for ${tStr} from ${priceFeeds.length}${remark} price feeds`
     );
     return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(priceFeeds);
   }
   /**
-   * Returns account price updates that can be used in credit facade multicall or liquidator calls
-   * @param options
-   * @returns
+   * Executes a multicall on a credit account, automatically prepending
+   * necessary on-demand price feed updates.
+   *
+   * @param creditAccount - Credit account to execute multicall on
+   * @param calls - Array of multicall operations (price updates will be inferred)
+   * @param options - Optional settings for price update generation
+   * @returns Raw transaction ready to be signed and sent
    */
-  async getOnDemandPriceUpdates(options) {
-    const { creditManager, creditAccount } = options;
-    const market = this.sdk.marketRegister.findByCreditManager(creditManager);
-    const cm = this.sdk.marketRegister.findCreditManager(creditManager);
-    const update = await this.getUpdateForAccount(options);
-    this.logger?.debug(
-      { account: creditAccount?.creditAccount, manager: cm.name },
-      `getting on demand price updates from ${update.txs.length} txs`
+  async multicall(creditAccount, calls, options) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const callsWithPrices = await this.prependPriceUpdates(
+      creditAccount.creditManager,
+      calls,
+      creditAccount,
+      options
     );
-    return market.priceOracle.onDemandPriceUpdates(
-      cm.creditFacade.address,
-      update
+    return cm.creditFacade.multicall(
+      creditAccount.creditAccount,
+      callsWithPrices
     );
   }
   /**
-   * Returns price updates in format that is accepted by various credit facade methods (multicall, close/liquidate, etc...).
-   * - If there are desiredQuotas and creditAccount update quotaBalance > 0 || (balance > 10n && isEnabled). Is used when account has both: balances and quota buys.
-   * - If there is creditAccount update balance > 10n && isEnabled. Is used in credit account actions when quota is not being bought.
-   * - If there is desiredQuotas update quotaBalance > 0. Is used on credit account opening, when quota is bought for the first time.
-   * @param acc
-   * @returns
+   * Executes a bot multicall on a credit account, automatically prepending
+   * necessary on-demand price feed updates.
+   *
+   * @param creditAccount - Credit account to execute bot multicall on
+   * @param calls - Array of multicall operations (price updates will be inferred)
+   * @param options - Optional settings for price update generation
+   * @returns Raw transaction ready to be signed and sent
    */
-  async getPriceUpdatesForFacade(options) {
-    const updates = await this.getOnDemandPriceUpdates(options);
-    return updates.multicall;
+  async botMulticall(creditAccount, calls, options) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const callsWithPrices = await this.prependPriceUpdates(
+      creditAccount.creditManager,
+      calls,
+      creditAccount,
+      options
+    );
+    return cm.creditFacade.botMulticall(
+      creditAccount.creditAccount,
+      callsWithPrices
+    );
   }
   prepareDisableQuotas(ca) {
     const calls = [];
@@ -1099,79 +1034,6 @@ class AbstractCreditAccountService extends SDKConstruct {
     )[0];
   }
 }
-const iMellowClaimerAdapterAbi = [
-  {
-    type: "function",
-    name: "getMultiVaultSubvaultIndices",
-    inputs: [{ name: "multiVault", type: "address", internalType: "address" }],
-    outputs: [
-      {
-        name: "subvaultIndices",
-        type: "uint256[]",
-        internalType: "uint256[]"
-      },
-      {
-        name: "withdrawalIndices",
-        type: "uint256[][]",
-        internalType: "uint256[][]"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "getUserSubvaultIndices",
-    inputs: [
-      { name: "multiVault", type: "address", internalType: "address" },
-      { name: "user", type: "address", internalType: "address" }
-    ],
-    outputs: [
-      {
-        name: "subvaultIndices",
-        type: "uint256[]",
-        internalType: "uint256[]"
-      },
-      {
-        name: "withdrawalIndices",
-        type: "uint256[][]",
-        internalType: "uint256[][]"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "multiAccept",
-    inputs: [
-      { name: "multiVault", type: "address", internalType: "address" },
-      {
-        name: "subvaultIndices",
-        type: "uint256[]",
-        internalType: "uint256[]"
-      },
-      { name: "indices", type: "uint256[][]", internalType: "uint256[][]" }
-    ],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "multiAcceptAndClaim",
-    inputs: [
-      { name: "multiVault", type: "address", internalType: "address" },
-      {
-        name: "subvaultIndices",
-        type: "uint256[]",
-        internalType: "uint256[]"
-      },
-      { name: "indices", type: "uint256[][]", internalType: "uint256[][]" },
-      { name: "", type: "address", internalType: "address" },
-      { name: "maxAssets", type: "uint256", internalType: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "nonpayable"
-  }
-];
 export {
   AbstractCreditAccountService,
   getWithdrawalCompressorAddress