@gearbox-protocol/sdk 14.1.1 → 14.2.1

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

@@ -18,14 +18,1107 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var CreditAccountsServiceV310_exports = {};
 __export(CreditAccountsServiceV310_exports, {
-  CreditAccountServiceV310: () => CreditAccountServiceV310
+  CreditAccountsServiceV310: () => CreditAccountsServiceV310,
+  getWithdrawalCompressorAddress: () => getWithdrawalCompressorAddress
 });
 module.exports = __toCommonJS(CreditAccountsServiceV310_exports);
+var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
 var import_generated = require("../../abi/310/generated.js");
-var import_math = require("../constants/math.js");
-var import_AbstractCreditAccountsService = require("./AbstractCreditAccountsService.js");
-class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.AbstractCreditAccountService {
+var import_creditAccountCompressor = require("../../abi/compressors/creditAccountCompressor.js");
+var import_peripheryCompressor = require("../../abi/compressors/peripheryCompressor.js");
+var import_rewardsCompressor = require("../../abi/compressors/rewardsCompressor.js");
+var import_IWithdrawalCompressorV310 = require("../../abi/IWithdrawalCompressorV310.js");
+var import_iBaseRewardPool = require("../../abi/iBaseRewardPool.js");
+var import_iKYCFactory = require("../../abi/kyc/iKYCFactory.js");
+var import_base = require("../base/index.js");
+var import_chains = require("../chain/chains.js");
+var import_constants = require("../constants/index.js");
+var import_market = require("../market/index.js");
+var import_router = require("../router/index.js");
+var import_utils = require("../utils/index.js");
+var import_viem2 = require("../utils/viem/index.js");
+var import_multicall_utils = require("./multicall-utils.js");
+const COMPRESSORS = {
+  [import_chains.chains.Mainnet.id]: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
+  [import_chains.chains.Monad.id]: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023"
+};
+function getWithdrawalCompressorAddress(chainId) {
+  return COMPRESSORS[chainId];
+}
+class CreditAccountsServiceV310 extends import_base.SDKConstruct {
+  #compressor;
+  #batchSize;
+  constructor(sdk, options) {
+    super(sdk);
+    this.#batchSize = options?.batchSize;
+  }
+  setBatchSize(batchSize) {
+    this.#batchSize = batchSize;
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.getCreditAccountData}
+   **/
+  async getCreditAccountData(account, blockNumber) {
+    let raw;
+    try {
+      raw = await this.client.readContract({
+        abi: import_creditAccountCompressor.creditAccountCompressorAbi,
+        address: this.compressor,
+        functionName: "getCreditAccountData",
+        args: [account],
+        blockNumber,
+        // @ts-expect-error
+        gas: this.sdk.gasLimit
+      });
+    } catch (_e) {
+      return void 0;
+    }
+    const marketSuite = this.sdk.marketRegister.findByCreditManager(
+      raw.creditManager
+    );
+    const factory = marketSuite.kycFactory;
+    let ca;
+    let investor;
+    if (raw.success) {
+      ca = raw;
+      investor = await factory?.getInvestor(raw.creditAccount, false);
+    } else {
+      const { txs: priceUpdateTxs } = await this.#getUpdateForAccount(raw);
+      [ca, investor] = await (0, import_viem2.simulateWithPriceUpdates)(this.client, {
+        priceUpdates: priceUpdateTxs,
+        contracts: [
+          {
+            abi: import_creditAccountCompressor.creditAccountCompressorAbi,
+            address: this.compressor,
+            functionName: "getCreditAccountData",
+            args: [account]
+          },
+          ...factory ? [
+            {
+              abi: import_iKYCFactory.iKYCFactoryAbi,
+              address: factory.address,
+              functionName: "getInvestor",
+              args: [raw.creditAccount]
+            }
+          ] : []
+        ],
+        blockNumber,
+        gas: this.sdk.gasLimit
+      });
+    }
+    return { ...ca, investor };
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.getCreditAccounts}
+   **/
+  async getCreditAccounts(options, blockNumber) {
+    const {
+      creditManager,
+      includeZeroDebt = false,
+      maxHealthFactor = import_constants.MAX_UINT256,
+      minHealthFactor = 0n,
+      owner = import_constants.ADDRESS_0X0,
+      ignoreReservePrices = false
+    } = options ?? {};
+    const arg0 = creditManager ?? {
+      configurators: this.marketConfigurators,
+      creditManagers: [],
+      pools: [],
+      underlying: import_constants.ADDRESS_0X0
+    };
+    const caFilter = {
+      owner,
+      includeZeroDebt,
+      minHealthFactor,
+      maxHealthFactor,
+      reverting: false
+    };
+    const { txs: priceUpdateTxs } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(
+      ignoreReservePrices ? { main: true } : void 0
+    );
+    const allCAs = [];
+    let revertingOffset = 0;
+    for (const reverting of [false, true]) {
+      let offset = 0n;
+      revertingOffset = allCAs.length;
+      do {
+        const [accounts, newOffset] = await this.#getCreditAccounts(
+          this.#batchSize ? [
+            arg0,
+            { ...caFilter, reverting },
+            offset,
+            BigInt(this.#batchSize)
+            // limit
+          ] : [arg0, { ...caFilter, reverting }, offset],
+          priceUpdateTxs,
+          blockNumber
+        );
+        allCAs.push(...accounts);
+        offset = newOffset;
+      } while (offset !== 0n);
+    }
+    this.logger?.debug(
+      `loaded ${allCAs.length} credit accounts (${allCAs.length - revertingOffset} reverting)`
+    );
+    return allCAs.sort((a, b) => Number(a.healthFactor - b.healthFactor));
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.getBorrowerCreditAccounts}
+   **/
+  async getBorrowerCreditAccounts(borrower, options, blockNumber) {
+    const {
+      creditManager,
+      includeZeroDebt = false,
+      maxHealthFactor = import_constants.MAX_UINT256,
+      minHealthFactor = 0n,
+      ignoreReservePrices = false
+    } = options ?? {};
+    const { txs: priceUpdateTxs } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(
+      ignoreReservePrices ? { main: true } : void 0
+    );
+    const investorDataList = await this.sdk.kyc.getInvestorData(borrower);
+    const kycAccountAddresses = investorDataList.flatMap(
+      (d) => d.creditAccounts.map((ca) => ca.creditAccount)
+    );
+    const cmFilter = creditManager ? {
+      configurators: [],
+      creditManagers: [creditManager],
+      pools: [],
+      underlying: import_constants.ADDRESS_0X0
+    } : {
+      configurators: this.marketConfigurators,
+      creditManagers: [],
+      pools: [],
+      underlying: import_constants.ADDRESS_0X0
+    };
+    const permissiveFilter = {
+      owner: borrower,
+      includeZeroDebt: true,
+      minHealthFactor: 0n,
+      maxHealthFactor: import_constants.MAX_UINT256,
+      reverting: false
+    };
+    const kycContracts = kycAccountAddresses.map(
+      (account) => ({
+        abi: import_creditAccountCompressor.creditAccountCompressorAbi,
+        address: this.compressor,
+        functionName: "getCreditAccountData",
+        args: [account]
+      })
+    );
+    const getCreditAccountsContracts = [false, true].map(
+      (reverting) => ({
+        abi: import_creditAccountCompressor.creditAccountCompressorAbi,
+        address: this.compressor,
+        functionName: "getCreditAccounts",
+        args: [cmFilter, { ...permissiveFilter, reverting }, 0n]
+      })
+    );
+    const allContracts = [...kycContracts, ...getCreditAccountsContracts];
+    const results = await (0, import_viem2.simulateWithPriceUpdates)(this.client, {
+      priceUpdates: priceUpdateTxs,
+      contracts: allContracts,
+      blockNumber,
+      gas: this.sdk.gasLimit
+    });
+    const kycResults = results.slice(
+      0,
+      kycAccountAddresses.length
+    );
+    const normalResults = results.slice(kycAccountAddresses.length);
+    const seen = new import_utils.AddressSet();
+    const allCAs = [];
+    for (const ca of kycResults) {
+      if (!seen.has(ca.creditAccount)) {
+        seen.add(ca.creditAccount);
+        allCAs.push({ ...ca, investor: borrower });
+      }
+    }
+    for (const [accounts] of normalResults) {
+      for (const ca of accounts) {
+        if (!seen.has(ca.creditAccount)) {
+          seen.add(ca.creditAccount);
+          allCAs.push({ ...ca, investor: void 0 });
+        }
+      }
+    }
+    const filtered = allCAs.filter((ca) => {
+      if (!includeZeroDebt && ca.debt === 0n) return false;
+      if (ca.healthFactor < minHealthFactor) return false;
+      if (ca.healthFactor > maxHealthFactor) return false;
+      if (creditManager && !(0, import_utils.hexEq)(ca.creditManager, creditManager))
+        return false;
+      return true;
+    });
+    this.logger?.debug(
+      `loaded ${allCAs.length} borrower credit accounts (${kycResults.length} KYC, ${filtered.length} after filter)`
+    );
+    return filtered.sort((a, b) => Number(a.healthFactor - b.healthFactor));
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.getRewards}
+   **/
+  async getRewards(creditAccount) {
+    const rewards = await this.client.readContract({
+      abi: import_rewardsCompressor.rewardsCompressorAbi,
+      address: this.rewardCompressor,
+      functionName: "getRewards",
+      args: [creditAccount]
+    });
+    const callData = (0, import_viem.encodeFunctionData)({
+      abi: import_iBaseRewardPool.iBaseRewardPoolAbi,
+      functionName: "getReward",
+      args: []
+    });
+    const r = rewards.reduce((acc, r2) => {
+      const adapter = r2.adapter.toLowerCase();
+      const stakedPhantomToken = r2.stakedPhantomToken.toLowerCase();
+      const rewardToken = r2.rewardToken.toLowerCase();
+      const key = [adapter, stakedPhantomToken].join("-");
+      if (!acc[key]) {
+        acc[key] = {
+          adapter,
+          stakedPhantomToken,
+          calls: [
+            {
+              target: adapter,
+              callData
+            }
+          ],
+          rewards: []
+        };
+      }
+      acc[key].rewards.push({
+        token: rewardToken,
+        balance: r2.amount
+      });
+      return acc;
+    }, {});
+    return Object.values(r);
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.getConnectedBots}
+   **/
+  async getConnectedBots(accountsToCheck, legacyMigrationBot, additionalBots) {
+    const allResp = await this.client.multicall({
+      contracts: [
+        ...accountsToCheck.map((o) => {
+          const pool = this.sdk.marketRegister.findByCreditManager(
+            o.creditManager
+          );
+          return {
+            abi: import_peripheryCompressor.peripheryCompressorAbi,
+            address: this.peripheryCompressor,
+            functionName: "getConnectedBots",
+            args: [pool.configurator.address, o.creditAccount]
+          };
+        }),
+        ...legacyMigrationBot ? accountsToCheck.map((ca) => {
+          const cm = this.sdk.marketRegister.findCreditManager(
+            ca.creditManager
+          );
+          return {
+            abi: import_generated.iBotListV310Abi,
+            address: cm.creditFacade.botList,
+            functionName: "getBotStatus",
+            args: [legacyMigrationBot, ca.creditAccount]
+          };
+        }) : [],
+        ...accountsToCheck.flatMap((ca) => {
+          const cm = this.sdk.marketRegister.findCreditManager(
+            ca.creditManager
+          );
+          return additionalBots.map((bot) => {
+            return {
+              abi: import_generated.iBotListV310Abi,
+              address: cm.creditFacade.botList,
+              functionName: "getBotStatus",
+              args: [bot, ca.creditAccount]
+            };
+          });
+        })
+      ],
+      allowFailure: true,
+      batchSize: 0
+    });
+    const legacyStart = 0;
+    const legacyEnd = accountsToCheck.length;
+    const legacy = allResp.slice(
+      legacyStart,
+      legacyEnd
+    );
+    const migrationStart = legacyEnd;
+    const migrationEnd = legacyMigrationBot ? migrationStart + accountsToCheck.length : migrationStart;
+    const migrationResp = allResp.slice(
+      migrationStart,
+      migrationEnd
+    );
+    const additionalStart = migrationEnd;
+    const additionalResp = allResp.slice(
+      additionalStart
+    );
+    return {
+      legacy,
+      additionalBots: this.#getActiveBots(
+        accountsToCheck,
+        additionalBots,
+        additionalResp
+      ),
+      legacyMigration: this.#getActiveMigrationBots(
+        accountsToCheck,
+        legacyMigrationBot,
+        migrationResp
+      )
+    };
+  }
+  #getActiveBots(accountsToCheck, bots, result) {
+    if (result.length !== bots.length * accountsToCheck.length) {
+      console.error(
+        "result length mismatch",
+        result.length,
+        bots.length * accountsToCheck.length
+      );
+    }
+    const botsByCAIndex = accountsToCheck.reduce((acc, _, index) => {
+      const r = result.slice(index * bots.length, (index + 1) * bots.length);
+      acc.push({
+        result: r
+      });
+      return acc;
+    }, []);
+    return botsByCAIndex;
+  }
+  #getActiveMigrationBots(accountsToCheck, bot, result) {
+    if (bot) {
+      if (result.length !== accountsToCheck.length) {
+        console.error(
+          "result length mismatch for migration bots",
+          result.length,
+          accountsToCheck.length
+        );
+      }
+      return { result, botAddress: bot };
+    }
+    return void 0;
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.fullyLiquidate}
+   **/
+  async fullyLiquidate(props) {
+    const {
+      account,
+      to,
+      slippage = 50n,
+      keepAssets,
+      ignoreReservePrices,
+      applyLossPolicy,
+      debtOnly
+    } = props;
+    const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
+    const routerCloseResult = await this.sdk.routerFor(account).findBestClosePath({
+      creditAccount: account,
+      creditManager: cm.creditManager,
+      slippage,
+      keepAssets,
+      debtOnly
+    });
+    const calls = await this.#prependPriceUpdates(
+      account.creditManager,
+      routerCloseResult.calls,
+      account,
+      { ignoreReservePrices }
+    );
+    let lossPolicyData;
+    if (applyLossPolicy) {
+      const market = this.sdk.marketRegister.findByCreditManager(
+        account.creditManager
+      );
+      lossPolicyData = await market.lossPolicy.getLiquidationData(
+        account.creditAccount
+      );
+      this.logger?.debug({ lossPolicyData }, "loss policy data");
+    }
+    const tx = cm.creditFacade.liquidateCreditAccount(
+      account.creditAccount,
+      to,
+      calls,
+      lossPolicyData
+    );
+    return {
+      tx,
+      calls,
+      routerCloseResult,
+      lossPolicyData,
+      creditFacade: cm.creditFacade
+    };
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.calcMinSeizedAmount}
+   */
+  calcMinSeizedAmount(props) {
+    const { account, token, repaidAmount } = props;
+    const market = this.sdk.marketRegister.findByCreditManager(
+      account.creditManager
+    );
+    const suite = this.sdk.marketRegister.findCreditManager(
+      account.creditManager
+    );
+    const fee = suite.isExpired ? suite.creditManager.liquidationDiscountExpired : suite.creditManager.liquidationDiscount;
+    const tokenAmount = market.priceOracle.convert(
+      market.underlying,
+      token,
+      repaidAmount
+    );
+    return tokenAmount * 9990n / BigInt(fee);
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.partiallyLiquidate}
+   */
+  async partiallyLiquidate(props) {
+    const { account, token, repaidAmount, minSeizedAmount, to } = props;
+    const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
+    const updates = await this.getOnDemandPriceUpdates(account, true);
+    const tx = cm.creditFacade.partiallyLiquidateCreditAccount(
+      account.creditAccount,
+      token,
+      repaidAmount,
+      minSeizedAmount,
+      to,
+      updates
+    );
+    return tx;
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.closeCreditAccount}
+   **/
+  async closeCreditAccount({
+    operation,
+    assetsToWithdraw,
+    creditAccount: ca,
+    to,
+    slippage = 50n,
+    closePath
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    await this.sdk.tokensMeta.loadTokenData(cm.underlying);
+    const underlying = this.sdk.tokensMeta.mustGet(cm.underlying);
+    if (this.sdk.tokensMeta.isKYCUnderlying(underlying)) {
+      throw new Error(
+        "closeCreditAccount is not supported for KYC underlying credit accounts"
+      );
+    }
+    const routerCloseResult = closePath || await this.sdk.routerFor(ca).findBestClosePath({
+      creditAccount: ca,
+      creditManager: cm.creditManager,
+      slippage
+    });
+    const operationCalls = [
+      ...routerCloseResult.calls,
+      ...this.#prepareDisableQuotas(ca),
+      ...this.#prepareDecreaseDebt(ca),
+      ...assetsToWithdraw.map(
+        (t) => this.#prepareWithdrawToken(ca.creditFacade, t, import_constants.MAX_UINT256, to)
+      )
+    ];
+    const calls = operation === "close" ? operationCalls : await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
+    const tx = await this.#closeCreditAccountTx(
+      cm,
+      ca.creditAccount,
+      calls,
+      operation
+    );
+    return { tx, calls, routerCloseResult, creditFacade: cm.creditFacade };
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.updateQuotas}
+   **/
+  async updateQuotas({
+    minQuota,
+    averageQuota,
+    creditAccount
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const operationCalls = this.#prepareUpdateQuotas(
+      creditAccount.creditFacade,
+      { minQuota, averageQuota }
+    );
+    const calls = await this.#prependPriceUpdates(
+      creditAccount.creditManager,
+      operationCalls,
+      creditAccount
+    );
+    const tx = await this.#multicallTx(cm, creditAccount.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.addCollateral}
+   **/
+  async addCollateral({
+    creditAccount,
+    asset,
+    permit,
+    ethAmount,
+    minQuota,
+    averageQuota
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const operationCalls = [
+      ...this.#prepareAddCollateral(
+        creditAccount.creditFacade,
+        [asset],
+        permit ? { [asset.token]: permit } : {}
+      ),
+      ...this.#prepareUpdateQuotas(creditAccount.creditFacade, {
+        minQuota,
+        averageQuota
+      })
+    ];
+    const calls = await this.#prependPriceUpdates(
+      creditAccount.creditManager,
+      operationCalls,
+      creditAccount
+    );
+    const tx = await this.#multicallTx(cm, creditAccount.creditAccount, calls);
+    tx.value = ethAmount.toString(10);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.changeDebt}
+   **/
+  async changeDebt({
+    creditAccount,
+    amount,
+    collateral
+  }) {
+    if (amount === 0n) {
+      throw new Error("debt increase or decrease must be non-zero");
+    }
+    const isDecrease = amount < 0n;
+    const change = amount > 0n ? amount : -amount;
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const addCollateralCalls = collateral && isDecrease ? this.#prepareAddCollateral(
+      creditAccount.creditFacade,
+      [
+        {
+          token: collateral[0].token,
+          balance: collateral[0].balance
+        }
+      ],
+      {}
+    ) : [];
+    const unwrapCalls = collateral && isDecrease ? await this.getKYCUnwrapCalls(
+      collateral[0].balance,
+      creditAccount.creditManager
+    ) || [] : [];
+    if (addCollateralCalls.length > 0 && unwrapCalls.length === 0 && collateral && collateral?.[0].token !== creditAccount.underlying) {
+      throw new Error(
+        "Can't use collateral other than underlying for non KYC market"
+      );
+    }
+    const operationCalls = [
+      ...addCollateralCalls,
+      ...unwrapCalls,
+      this.#prepareChangeDebt(creditAccount.creditFacade, change, isDecrease)
+    ];
+    const calls = await this.#prependPriceUpdates(
+      creditAccount.creditManager,
+      operationCalls,
+      creditAccount
+    );
+    const tx = await this.#multicallTx(cm, creditAccount.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.executeSwap}
+   **/
+  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
+    );
+    const operationCalls = [
+      ...swapCalls,
+      ...this.#prepareUpdateQuotas(creditAccount.creditFacade, {
+        minQuota,
+        averageQuota
+      })
+    ];
+    const calls = await this.#prependPriceUpdates(
+      creditAccount.creditManager,
+      operationCalls,
+      creditAccount
+    );
+    const tx = await this.#multicallTx(cm, creditAccount.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.previewDelayedWithdrawal}
+   **/
+  async previewDelayedWithdrawal({
+    creditAccount,
+    amount,
+    token
+  }) {
+    const compressor = getWithdrawalCompressorAddress(this.sdk.chainId);
+    if (!compressor)
+      throw new Error(
+        `No compressor for current chain ${this.sdk.networkType}`
+      );
+    const contract = (0, import_viem.getContract)({
+      address: compressor,
+      abi: import_IWithdrawalCompressorV310.iWithdrawalCompressorV310Abi,
+      client: this.client
+    });
+    const resp = await contract.read.getWithdrawalRequestResult([
+      creditAccount,
+      token,
+      amount
+    ]);
+    return resp;
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.getPendingWithdrawals}
+   **/
+  async getPendingWithdrawals({
+    creditAccount
+  }) {
+    const compressor = getWithdrawalCompressorAddress(this.sdk.chainId);
+    if (!compressor)
+      throw new Error(
+        `No compressor for current chain ${this.sdk.networkType}`
+      );
+    const contract = (0, import_viem.getContract)({
+      address: compressor,
+      abi: import_IWithdrawalCompressorV310.iWithdrawalCompressorV310Abi,
+      client: this.client
+    });
+    const resp = await contract.read.getCurrentWithdrawals([creditAccount]);
+    const claimableNow = resp?.[0] || [];
+    const pendingResult = [...resp?.[1] || []].sort(
+      (a, b) => a.claimableAt < b.claimableAt ? -1 : 1
+    );
+    const respResult = {
+      claimableNow: [...claimableNow],
+      pending: pendingResult
+    };
+    return respResult;
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.startDelayedWithdrawal}
+   **/
+  async startDelayedWithdrawal({
+    creditAccount,
+    minQuota,
+    averageQuota,
+    preview
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const record = preview.outputs.reduce((acc, o) => {
+      const token = o.token.toLowerCase();
+      acc[token] = (acc[token] || 0n) + o.amount;
+      return acc;
+    }, {});
+    const balances = Object.entries(record).filter(([, a]) => a > 10n);
+    const storeExpectedBalances = {
+      target: cm.creditFacade.address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_generated.iCreditFacadeMulticallV310Abi,
+        functionName: "storeExpectedBalances",
+        args: [
+          balances.map(([token, amount]) => ({
+            token,
+            amount: amount > 10n ? amount - 10n : 0n
+          }))
+        ]
+      })
+    };
+    const compareBalances = {
+      target: cm.creditFacade.address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_generated.iCreditFacadeMulticallV310Abi,
+        functionName: "compareBalances",
+        args: []
+      })
+    };
+    const operationCalls = [
+      storeExpectedBalances,
+      ...preview.requestCalls,
+      compareBalances,
+      ...this.#prepareUpdateQuotas(creditAccount.creditFacade, {
+        minQuota,
+        averageQuota
+      })
+    ];
+    const calls = await this.#prependPriceUpdates(
+      creditAccount.creditManager,
+      operationCalls,
+      creditAccount
+    );
+    const tx = await this.#multicallTx(cm, creditAccount.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.claimDelayed}
+   **/
+  async claimDelayed({
+    creditAccount,
+    minQuota,
+    averageQuota,
+    claimableNow
+  }) {
+    const zeroDebt = creditAccount.debt === 0n;
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const record = claimableNow.outputs.reduce(
+      (acc, o) => {
+        const token = o.token.toLowerCase();
+        acc[token] = (acc[token] || 0n) + o.amount;
+        return acc;
+      },
+      {}
+    );
+    const balances = Object.entries(record).filter(([, a]) => a > 10n);
+    const storeExpectedBalances = {
+      target: cm.creditFacade.address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_generated.iCreditFacadeMulticallV310Abi,
+        functionName: "storeExpectedBalances",
+        args: [
+          balances.map(([token, amount]) => ({
+            token,
+            amount: amount > 10n ? amount - 10n : 0n
+          }))
+        ]
+      })
+    };
+    const compareBalances = {
+      target: cm.creditFacade.address,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_generated.iCreditFacadeMulticallV310Abi,
+        functionName: "compareBalances",
+        args: []
+      })
+    };
+    const quotaCalls = zeroDebt ? [] : this.#prepareUpdateQuotas(creditAccount.creditFacade, {
+      minQuota,
+      averageQuota
+    });
+    const operationCalls = [
+      storeExpectedBalances,
+      ...claimableNow.claimCalls,
+      compareBalances,
+      ...quotaCalls
+    ];
+    const calls = zeroDebt ? operationCalls : await this.#prependPriceUpdates(
+      creditAccount.creditManager,
+      operationCalls,
+      creditAccount
+    );
+    const tx = await this.#multicallTx(cm, creditAccount.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.getApprovalAddress}
+   **/
+  async getApprovalAddress(options) {
+    const { creditManager } = options;
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const marketSuite = this.sdk.marketRegister.findByPool(suite.pool);
+    const factory = marketSuite.kycFactory;
+    if (factory) {
+      return factory.getApprovalAddress(options);
+    }
+    return suite.creditManager.address;
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.getOpenAccountRequirements}
+   */
+  async getOpenAccountRequirements(borrower, creditManager, props) {
+    const { kycFactory } = this.sdk.marketRegister.findByCreditManager(creditManager);
+    if (!kycFactory) {
+      return void 0;
+    }
+    return kycFactory.getOpenAccountRequirements(borrower, props);
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.openCA}
+   **/
+  async openCA(props) {
+    const {
+      ethAmount,
+      creditManager,
+      reopenCreditAccount,
+      collateral,
+      permits,
+      debt,
+      withdrawToken,
+      referralCode,
+      to,
+      calls: openPathCalls,
+      callsAfter,
+      minQuota,
+      averageQuota,
+      kycOptions
+    } = props;
+    const cmSuite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const cm = cmSuite.creditManager;
+    let tokenToWithdraw;
+    if (withdrawToken === true) {
+      tokenToWithdraw = cm.underlying;
+    } else if (typeof withdrawToken === "string") {
+      tokenToWithdraw = withdrawToken;
+    }
+    const operationCalls = [
+      this.#prepareIncreaseDebt(cm.creditFacade, debt),
+      ...this.#prepareAddCollateral(cm.creditFacade, collateral, permits),
+      ...openPathCalls,
+      // path from underlying to withdrawal token
+      ...tokenToWithdraw ? [
+        this.#prepareWithdrawToken(
+          cm.creditFacade,
+          tokenToWithdraw,
+          import_constants.MAX_UINT256,
+          to
+        )
+      ] : [],
+      ...this.#prepareUpdateQuotas(cm.creditFacade, {
+        minQuota,
+        averageQuota
+      }),
+      ...callsAfter ?? []
+    ];
+    const calls = await this.#prependPriceUpdates(cm.address, operationCalls);
+    let tx;
+    if (reopenCreditAccount) {
+      tx = await this.#multicallTx(cmSuite, reopenCreditAccount, calls);
+    } else {
+      tx = await this.#openCreditAccountTx(
+        cmSuite,
+        to,
+        calls,
+        referralCode,
+        kycOptions
+      );
+    }
+    tx.value = ethAmount.toString(10);
+    return { calls, tx, creditFacade: cmSuite.creditFacade };
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.getBorrowRate}
+   **/
+  getBorrowRate(ca) {
+    const { creditManager } = this.sdk.marketRegister.findCreditManager(
+      ca.creditManager
+    );
+    const { pool } = this.sdk.marketRegister.findByCreditManager(
+      ca.creditManager
+    );
+    const { feeInterest } = creditManager;
+    const { baseInterestRate } = pool.pool;
+    const baseRateWithFee = baseInterestRate * (BigInt(feeInterest) + import_constants.PERCENTAGE_FACTOR);
+    const totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
+    const r = ca.debt * baseRateWithFee / (totalDebt * import_constants.RAY);
+    const caTokens = new import_utils.AddressMap(ca.tokens.map((t) => [t.token, t]));
+    let qr = 0n;
+    for (const t of creditManager.collateralTokens) {
+      const b = caTokens.get(t);
+      if (b) {
+        qr += b.quota * BigInt(pool.pqk.quotas.get(t)?.rate ?? 0);
+      }
+    }
+    qr = qr * (BigInt(feeInterest) + import_constants.PERCENTAGE_FACTOR) / import_constants.PERCENTAGE_FACTOR;
+    qr /= totalDebt;
+    return r + qr;
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.getOptimalHFForPartialLiquidation}
+   **/
+  getOptimalHFForPartialLiquidation(ca) {
+    const borrowRate = this.getBorrowRate(ca);
+    return import_constants.PERCENTAGE_FACTOR + (borrowRate < 100n ? borrowRate : 100n);
+  }
+  /**
+   * Internal wrapper for CreditAccountCompressor.getCreditAccounts + price updates wrapped into multicall
+   * @param args
+   * @param priceUpdateTxs
+   * @param blockNumber
+   * @returns
+   */
+  async #getCreditAccounts(args, priceUpdateTxs, blockNumber) {
+    let resp;
+    if (priceUpdateTxs?.length) {
+      [resp] = await (0, import_viem2.simulateWithPriceUpdates)(this.client, {
+        priceUpdates: priceUpdateTxs,
+        contracts: [
+          {
+            abi: import_creditAccountCompressor.creditAccountCompressorAbi,
+            address: this.compressor,
+            functionName: "getCreditAccounts",
+            args
+          }
+        ],
+        blockNumber,
+        gas: this.sdk.gasLimit
+      });
+    } else {
+      resp = await this.client.readContract({
+        abi: import_creditAccountCompressor.creditAccountCompressorAbi,
+        address: this.compressor,
+        functionName: "getCreditAccounts",
+        args,
+        blockNumber,
+        // @ts-expect-error
+        gas: this.sdk.gasLimit
+      });
+    }
+    this.logger?.debug(
+      {
+        accounts: resp[0]?.length ?? 0,
+        nextOffset: Number(resp[1])
+      },
+      "got credit accounts"
+    );
+    return resp;
+  }
+  /**
+   * Returns multicall entries to redeem (unwrap) KYC ERC-4626 vault shares into underlying for the given credit manager.
+   * Used when withdrawing debt from a KYC market: redeems adapter vault shares so the underlying can be withdrawn.
+   * Only applies when the credit manager's underlying is KYC-gated and has an ERC-4626 adapter configured.
+   * @param amount - Number of vault shares (adapter tokens) to redeem
+   * @param creditManager - Credit manager address
+   * @returns Array of MultiCall to pass to credit facade multicall, or undefined if underlying is not KYC or no adapter is configured
+   */
+  async getKYCUnwrapCalls(amount, creditManager) {
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const meta = this.sdk.tokensMeta.mustGet(suite.underlying);
+    if (!this.sdk.tokensMeta.isKYCUnderlying(meta)) {
+      return void 0;
+    }
+    const adapter = suite.creditManager.adapters.get(meta.addr);
+    const adapterAddress = adapter?.address;
+    if (!adapterAddress) {
+      return void 0;
+    }
+    const mc = [
+      {
+        target: adapterAddress,
+        callData: (0, import_viem.encodeFunctionData)({
+          abi: import_integrations_v3.ierc4626AdapterAbi,
+          functionName: "redeem",
+          args: [amount, import_constants.ADDRESS_0X0, import_constants.ADDRESS_0X0]
+        })
+      }
+    ];
+    return mc;
+  }
+  /**
+   * Returns multicall entries to deposit (wrap) underlying into KYC ERC-4626 vault shares for the given credit manager.
+   * Used when adding debt on a KYC market: deposits underlying into the adapter vault so shares are minted on the account.
+   * Only applies when the credit manager's underlying is KYC-gated and has an ERC-4626 adapter configured.
+   * @param amount - Amount of underlying assets to deposit into the vault (in underlying decimals)
+   * @param creditManager - Credit manager address
+   * @returns Array of MultiCall to pass to credit facade multicall, or undefined if underlying is not KYC or no adapter is configured
+   */
+  async getKYCWrapCalls(amount, creditManager) {
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const meta = this.sdk.tokensMeta.mustGet(suite.underlying);
+    if (!this.sdk.tokensMeta.isKYCUnderlying(meta)) {
+      return void 0;
+    }
+    const adapter = suite.creditManager.adapters.get(meta.addr);
+    const adapterAddress = adapter?.address;
+    if (!adapterAddress) {
+      return void 0;
+    }
+    const mc = [
+      {
+        target: adapterAddress,
+        callData: (0, import_viem.encodeFunctionData)({
+          abi: import_integrations_v3.ierc4626AdapterAbi,
+          functionName: "deposit",
+          args: [amount, import_constants.ADDRESS_0X0]
+        })
+      }
+    ];
+    return mc;
+  }
+  /**
+   * Returns multicall entries to call redeemDiff on the KYC ERC-4626 adapter for the given credit manager.
+   * Redeems the leftover vault shares (e.g. after repaying debt) so the account does not hold excess KYC vault tokens.
+   * Only applies when the credit manager's underlying is KYC-gated and has an ERC-4626 adapter configured.
+   * @param amount - Leftover vault share amount to redeem (in adapter/vault decimals)
+   * @param creditManager - Credit manager address
+   * @returns Array of MultiCall to pass to credit facade multicall, or undefined if underlying is not KYC or no adapter is configured
+   */
+  async getRedeemDiffCalls(amount, creditManager) {
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const meta = this.sdk.tokensMeta.mustGet(suite.underlying);
+    if (!this.sdk.tokensMeta.isKYCUnderlying(meta)) {
+      return void 0;
+    }
+    const adapter = suite.creditManager.adapters.get(meta.addr);
+    const adapterAddress = adapter?.address;
+    if (!adapterAddress) {
+      return void 0;
+    }
+    const mc = [
+      {
+        target: adapterAddress,
+        callData: (0, import_viem.encodeFunctionData)({
+          abi: import_integrations_v3.ierc4626AdapterAbi,
+          functionName: "redeemDiff",
+          args: [amount]
+        })
+      }
+    ];
+    return mc;
+  }
+  /**
+   * Returns multicall entries to call depositDiff on the KYC ERC-4626 adapter for the given credit manager.
+   * Deposits the leftover underlying (e.g. after decreasing debt) into the vault so the account does not hold excess underlying.
+   * Only applies when the credit manager's underlying is KYC-gated and has an ERC-4626 adapter configured.
+   * @param amount - Leftover underlying amount to deposit into the vault (in underlying decimals)
+   * @param creditManager - Credit manager address
+   * @returns Array of MultiCall to pass to credit facade multicall, or undefined if underlying is not KYC or no adapter is configured
+   */
+  async getDepositDiffCalls(amount, creditManager) {
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const meta = this.sdk.tokensMeta.mustGet(suite.underlying);
+    if (!this.sdk.tokensMeta.isKYCUnderlying(meta)) {
+      return void 0;
+    }
+    const adapter = suite.creditManager.adapters.get(meta.addr);
+    const adapterAddress = adapter?.address;
+    if (!adapterAddress) {
+      return void 0;
+    }
+    const mc = [
+      {
+        target: adapterAddress,
+        callData: (0, import_viem.encodeFunctionData)({
+          abi: import_integrations_v3.ierc4626AdapterAbi,
+          functionName: "depositDiff",
+          args: [amount]
+        })
+      }
+    ];
+    return mc;
+  }
   /**
    * {@inheritDoc ICreditAccountsService.setBot}
    */
@@ -60,12 +1153,12 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
         args: [botAddress, permissions]
       })
     };
-    const calls = targetContract.type === "creditAccount" ? await this.prependPriceUpdates(
+    const calls = targetContract.type === "creditAccount" ? await this.#prependPriceUpdates(
       targetContract.creditManager,
       [addBotCall],
       targetContract
     ) : [addBotCall];
-    const tx = targetContract.type === "creditAccount" ? await this.multicallTx(cm, targetContract.creditAccount, calls) : void 0;
+    const tx = targetContract.type === "creditAccount" ? await this.#multicallTx(cm, targetContract.creditAccount, calls) : void 0;
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
@@ -83,24 +1176,24 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
     );
     const operationCalls = [
       ...assetsToWithdraw.map(
-        (a) => this.prepareWithdrawToken(
+        (a) => this.#prepareWithdrawToken(
           creditAccount.creditFacade,
           a.token,
           a.balance,
           to
         )
       ),
-      ...this.prepareUpdateQuotas(creditAccount.creditFacade, {
+      ...this.#prepareUpdateQuotas(creditAccount.creditFacade, {
         minQuota,
         averageQuota
       })
     ];
-    const calls = await this.prependPriceUpdates(
+    const calls = await this.#prependPriceUpdates(
       creditAccount.creditManager,
       operationCalls,
       creditAccount
     );
-    const tx = await this.multicallTx(cm, creditAccount.creditAccount, calls);
+    const tx = await this.#multicallTx(cm, creditAccount.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
   /**
@@ -125,18 +1218,18 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
       creditAccount: ca
     });
     const operationCalls = [
-      ...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+      ...this.#prepareAddCollateral(ca.creditFacade, addCollateral, permits),
       ...wrapCalls,
-      ...this.prepareDisableQuotas(ca),
-      ...this.prepareDecreaseDebt(ca),
+      ...this.#prepareDisableQuotas(ca),
+      ...this.#prepareDecreaseDebt(ca),
       ...unwrapCalls,
       ...claimPath.calls,
       ...assetsToWithdraw.map(
-        (t) => this.prepareWithdrawToken(ca.creditFacade, t.token, import_math.MAX_UINT256, to)
+        (t) => this.#prepareWithdrawToken(ca.creditFacade, t.token, import_constants.MAX_UINT256, to)
       )
     ];
-    const calls = operation === "close" ? operationCalls : await this.prependPriceUpdates(ca.creditManager, operationCalls, ca);
-    const tx = await this.closeCreditAccountTx(
+    const calls = operation === "close" ? operationCalls : await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
+    const tx = await this.#closeCreditAccountTx(
       cm,
       ca.creditAccount,
       calls,
@@ -164,14 +1257,14 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
     const wrapCalls = await this.getDepositDiffCalls(1n, ca.creditManager) ?? [];
     const addCollateral = collateralAssets.filter((a) => a.balance > 0);
     const operationCalls = [
-      ...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+      ...this.#prepareAddCollateral(ca.creditFacade, addCollateral, permits),
       ...claimPath.calls,
       ...wrapCalls,
       ...assetsToWithdraw.map(
-        (t) => this.prepareWithdrawToken(ca.creditFacade, t.token, import_math.MAX_UINT256, to)
+        (t) => this.#prepareWithdrawToken(ca.creditFacade, t.token, import_constants.MAX_UINT256, to)
       )
     ];
-    const calls = await this.prependPriceUpdates(
+    const calls = await this.#prependPriceUpdates(
       ca.creditManager,
       operationCalls,
       ca
@@ -207,18 +1300,350 @@ class CreditAccountServiceV310 extends import_AbstractCreditAccountsService.Abst
     if (claimPath.calls.length === 0) throw new Error("No path to execute");
     const operationCalls = [
       ...claimPath.calls,
-      ...this.prepareUpdateQuotas(ca.creditFacade, { minQuota, averageQuota })
+      ...this.#prepareUpdateQuotas(ca.creditFacade, { minQuota, averageQuota })
     ];
-    const calls = await this.prependPriceUpdates(
+    const calls = await this.#prependPriceUpdates(
       ca.creditManager,
       operationCalls,
       ca
     );
-    const tx = await this.multicallTx(cm, ca.creditAccount, calls);
+    const tx = await this.#multicallTx(cm, ca.creditAccount, calls);
     return { tx, calls, creditFacade: cm.creditFacade };
   }
+  /**
+   * 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 (0, import_market.getRawPriceUpdates)(update);
+  }
+  /**
+   * Analyzes a multicall array and prepends necessary on-demand price feed updates.
+   *
+   * 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 #prependPriceUpdates(creditManager, calls, ca, options) {
+    const market = this.sdk.marketRegister.findByCreditManager(creditManager);
+    const cm = this.sdk.marketRegister.findCreditManager(creditManager).creditManager;
+    const { priceUpdates: existingUpdates, remainingCalls } = (0, import_multicall_utils.extractPriceUpdates)(calls);
+    const tokens = new import_utils.AddressSet([
+      cm.underlying,
+      // underlying - always included
+      ...(0, import_multicall_utils.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);
+        }
+      }
+    }
+    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 = (0, import_multicall_utils.mergePriceUpdates)(existingUpdates, generatedUpdates);
+    if (merged.length === 0) {
+      return remainingCalls;
+    }
+    return [
+      {
+        target: cm.creditFacade,
+        callData: (0, import_viem.encodeFunctionData)({
+          abi: import_generated.iCreditFacadeMulticallV310Abi,
+          functionName: "onDemandPriceUpdates",
+          args: [merged]
+        })
+      },
+      ...remainingCalls
+    ];
+  }
+  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 = new import_utils.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 = tokens.map((t) => this.labelAddress(t)).join(", ");
+    const remark = ignoreReservePrices ? " main" : "";
+    this.logger?.debug(
+      { account: creditAccount, manager: cm.name },
+      `generating price feed updates for ${tStr} from ${priceFeeds.length}${remark} price feeds`
+    );
+    return this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(priceFeeds);
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.multicall}
+   */
+  async multicall(creditAccount, calls, options) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const callsWithPrices = await this.#prependPriceUpdates(
+      creditAccount.creditManager,
+      calls,
+      creditAccount,
+      options
+    );
+    return cm.creditFacade.multicall(
+      creditAccount.creditAccount,
+      callsWithPrices
+    );
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.botMulticall}
+   */
+  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 = [];
+    for (const { token, quota } of ca.tokens) {
+      if (quota > 0n) {
+        calls.push({
+          target: ca.creditFacade,
+          callData: (0, import_viem.encodeFunctionData)({
+            abi: import_generated.iCreditFacadeMulticallV310Abi,
+            functionName: "updateQuota",
+            args: [token, import_constants.MIN_INT96, 0n]
+          })
+        });
+      }
+    }
+    return calls;
+  }
+  #prepareUpdateQuotas(creditFacade, { averageQuota, minQuota }) {
+    const minRecord = (0, import_router.assetsMap)(minQuota);
+    const calls = averageQuota.map((q) => {
+      const minAsset = minRecord.get(q.token);
+      const min = minAsset && minAsset?.balance > 0 ? minAsset.balance : 0n;
+      return {
+        target: creditFacade,
+        callData: (0, import_viem.encodeFunctionData)({
+          abi: import_generated.iCreditFacadeMulticallV310Abi,
+          functionName: "updateQuota",
+          args: [q.token, q.balance, min]
+        })
+      };
+    });
+    return calls;
+  }
+  #prepareDecreaseDebt(ca) {
+    if (ca.debt > 0n) {
+      return [
+        {
+          target: ca.creditFacade,
+          callData: (0, import_viem.encodeFunctionData)({
+            abi: import_generated.iCreditFacadeMulticallV310Abi,
+            functionName: "decreaseDebt",
+            args: [import_constants.MAX_UINT256]
+          })
+        }
+      ];
+    }
+    return [];
+  }
+  #prepareWithdrawToken(creditFacade, token, amount, to) {
+    return {
+      target: creditFacade,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_generated.iCreditFacadeMulticallV310Abi,
+        functionName: "withdrawCollateral",
+        args: [token, amount, to]
+      })
+    };
+  }
+  #prepareIncreaseDebt(creditFacade, debt) {
+    return {
+      target: creditFacade,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_generated.iCreditFacadeMulticallV310Abi,
+        functionName: "increaseDebt",
+        args: [debt]
+      })
+    };
+  }
+  #prepareChangeDebt(creditFacade, change, isDecrease) {
+    return {
+      target: creditFacade,
+      callData: (0, import_viem.encodeFunctionData)({
+        abi: import_generated.iCreditFacadeMulticallV310Abi,
+        functionName: isDecrease ? "decreaseDebt" : "increaseDebt",
+        args: [change]
+      })
+    };
+  }
+  #prepareAddCollateral(creditFacade, assets, permits) {
+    const calls = assets.map(({ token, balance }) => {
+      const p = permits[token];
+      if (p) {
+        return {
+          target: creditFacade,
+          callData: (0, import_viem.encodeFunctionData)({
+            abi: import_generated.iCreditFacadeMulticallV310Abi,
+            functionName: "addCollateralWithPermit",
+            args: [token, balance, p.deadline, p.v, p.r, p.s]
+          })
+        };
+      }
+      return {
+        target: creditFacade,
+        callData: (0, import_viem.encodeFunctionData)({
+          abi: import_generated.iCreditFacadeMulticallV310Abi,
+          functionName: "addCollateral",
+          args: [token, balance]
+        })
+      };
+    });
+    return calls;
+  }
+  /**
+   * Returns addresses of market configurators
+   */
+  get marketConfigurators() {
+    return this.sdk.marketRegister.marketConfigurators.map((mc) => mc.address);
+  }
+  get rewardCompressor() {
+    return this.sdk.addressProvider.mustGetLatest(
+      import_constants.AP_REWARDS_COMPRESSOR,
+      import_constants.VERSION_RANGE_310
+    )[0];
+  }
+  get peripheryCompressor() {
+    return this.sdk.addressProvider.mustGetLatest(
+      import_constants.AP_PERIPHERY_COMPRESSOR,
+      import_constants.VERSION_RANGE_310
+    )[0];
+  }
+  get compressor() {
+    if (!this.#compressor) {
+      [this.#compressor] = this.sdk.addressProvider.mustGetLatest(
+        import_constants.AP_CREDIT_ACCOUNT_COMPRESSOR,
+        import_constants.VERSION_RANGE_310
+      );
+      this.logger?.debug(
+        `credit account compressor address: ${this.#compressor}`
+      );
+    }
+    return this.#compressor;
+  }
+  /**
+   * Wrapper that selects between credit facade and KYC factory
+   * @param suite
+   * @param to
+   * @param calls
+   * @param referralCode
+   * @param kycOptions
+   * @returns
+   */
+  async #openCreditAccountTx(suite, to, calls, referralCode, kycOptions) {
+    const marketSuite = this.sdk.marketRegister.findByPool(suite.pool);
+    const factory = marketSuite.kycFactory;
+    if (factory) {
+      return factory.openCreditAccount(
+        suite.creditManager.address,
+        calls,
+        kycOptions
+      );
+    }
+    return suite.creditFacade.openCreditAccount(to, calls, referralCode ?? 0n);
+  }
+  /**
+   * Wrapper that selects between credit facade and KYC factory
+   * @param suite
+   * @param creditAccount
+   * @param calls
+   * @param kycOptions
+   * @returns
+   */
+  async #multicallTx(suite, creditAccount, calls, kycOptions) {
+    const marketSuite = this.sdk.marketRegister.findByCreditManager(
+      suite.creditManager.address
+    );
+    const factory = marketSuite.kycFactory;
+    if (factory) {
+      return factory.multicall(creditAccount, calls, kycOptions);
+    }
+    return suite.creditFacade.multicall(creditAccount, calls);
+  }
+  /**
+   * Wrapper that selects between credit facade and KYC factory
+   * @param suite
+   * @param creditAccount
+   * @param calls
+   * @param operation
+   * @param kycOptions
+   * @returns
+   */
+  async #closeCreditAccountTx(suite, creditAccount, calls, operation, kycOptions) {
+    const marketSuite = this.sdk.marketRegister.findByCreditManager(
+      suite.creditManager.address
+    );
+    const factory = marketSuite.kycFactory;
+    if (operation === "close") {
+      if (factory) {
+        throw new Error(
+          "CloseOptions=close is not supported for KYC underlying credit accounts"
+        );
+      }
+      return suite.creditFacade.closeCreditAccount(creditAccount, calls);
+    }
+    if (factory) {
+      return factory.multicall(creditAccount, calls, kycOptions);
+    }
+    return suite.creditFacade.multicall(creditAccount, calls);
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CreditAccountServiceV310
+  CreditAccountsServiceV310,
+  getWithdrawalCompressorAddress
 });