@gearbox-protocol/sdk 14.12.0-next.6 → 14.12.0-next.61

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

@@ -1,1911 +1,1379 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_abi_iBaseRewardPool = require("../../abi/iBaseRewardPool.js");
+const require_abi_ierc4626Adapter = require("../../abi/ierc4626Adapter.js");
+const require_abi_310_generated = require("../../abi/310/generated.js");
+const require_abi_compressors_creditAccountCompressor = require("../../abi/compressors/creditAccountCompressor.js");
+const require_abi_compressors_peripheryCompressor = require("../../abi/compressors/peripheryCompressor.js");
+const require_abi_compressors_rewardsCompressor = require("../../abi/compressors/rewardsCompressor.js");
+const require_abi_rwa_iRWAFactory = require("../../abi/rwa/iRWAFactory.js");
+const require_sdk_utils_AddressMap = require("../utils/AddressMap.js");
+const require_sdk_utils_AddressSet = require("../utils/AddressSet.js");
+const require_sdk_utils_AssetsMap = require("../utils/AssetsMap.js");
+const require_sdk_constants_address_provider = require("../constants/address-provider.js");
+const require_sdk_constants_addresses = require("../constants/addresses.js");
+const require_sdk_constants_math = require("../constants/math.js");
+const require_sdk_constants_versions = require("../constants/versions.js");
+require("../constants/index.js");
+const require_sdk_utils_hex = require("../utils/hex.js");
+require("../utils/index.js");
+const require_sdk_base_SDKConstruct = require("../base/SDKConstruct.js");
+require("../base/index.js");
+const require_sdk_utils_viem_simulateWithPriceUpdates = require("../utils/viem/simulateWithPriceUpdates.js");
+require("../utils/viem/index.js");
+const require_sdk_market_pricefeeds_getRawPriceUpdates = require("../market/pricefeeds/getRawPriceUpdates.js");
+require("../market/index.js");
+const require_sdk_accounts_multicall_utils = require("./multicall-utils.js");
+let viem = require("viem");
+//#region src/sdk/accounts/CreditAccountsServiceV310.ts
+/**
+* Service for querying and operating on Gearbox credit accounts.
+*
+* Provides methods to fetch account data, build transactions for common operations
+* (open, close, liquidate, swap, manage collateral/debt/quotas), and generate
+* the price feed updates required by the credit facade.
+*
+* @see {@link ICreditAccountsService}
+**/
+var CreditAccountsServiceV310 = class extends require_sdk_base_SDKConstruct.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: require_abi_compressors_creditAccountCompressor.creditAccountCompressorAbi,
+				address: this.compressor,
+				functionName: "getCreditAccountData",
+				args: [account],
+				blockNumber,
+				gas: this.sdk.gasLimit
+			});
+		} catch (_e) {
+			return;
+		}
+		const factory = this.sdk.marketRegister.findByCreditManager(raw.creditManager).rwaFactory;
+		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 require_sdk_utils_viem_simulateWithPriceUpdates.simulateWithPriceUpdates(this.client, {
+				priceUpdates: priceUpdateTxs,
+				contracts: [{
+					abi: require_abi_compressors_creditAccountCompressor.creditAccountCompressorAbi,
+					address: this.compressor,
+					functionName: "getCreditAccountData",
+					args: [account]
+				}, ...factory ? [{
+					abi: require_abi_rwa_iRWAFactory.iRWAFactoryAbi,
+					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 = require_sdk_constants_math.MAX_UINT256, minHealthFactor = 0n, owner = require_sdk_constants_addresses.ADDRESS_0X0, ignoreReservePrices = false } = options ?? {};
+		const arg0 = creditManager ?? {
+			configurators: this.marketConfigurators,
+			creditManagers: [],
+			pools: [],
+			underlying: "0x0000000000000000000000000000000000000000"
+		};
+		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)
+				] : [
+					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 = require_sdk_constants_math.MAX_UINT256, minHealthFactor = 0n, ignoreReservePrices = false } = options ?? {};
+		const { txs: priceUpdateTxs } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(ignoreReservePrices ? { main: true } : void 0);
+		const rwaAccountAddresses = (await this.sdk.rwa.getInvestorData(borrower)).flatMap((d) => d.creditAccounts.map((ca) => ca.creditAccount));
+		const cmFilter = creditManager ? {
+			configurators: [],
+			creditManagers: [creditManager],
+			pools: [],
+			underlying: require_sdk_constants_addresses.ADDRESS_0X0
+		} : {
+			configurators: this.marketConfigurators,
+			creditManagers: [],
+			pools: [],
+			underlying: require_sdk_constants_addresses.ADDRESS_0X0
+		};
+		const permissiveFilter = {
+			owner: borrower,
+			includeZeroDebt: true,
+			minHealthFactor: 0n,
+			maxHealthFactor: require_sdk_constants_math.MAX_UINT256,
+			reverting: false
+		};
+		const rwaContracts = rwaAccountAddresses.map((account) => ({
+			abi: require_abi_compressors_creditAccountCompressor.creditAccountCompressorAbi,
+			address: this.compressor,
+			functionName: "getCreditAccountData",
+			args: [account]
+		}));
+		const getCreditAccountsContracts = [false, true].map((reverting) => ({
+			abi: require_abi_compressors_creditAccountCompressor.creditAccountCompressorAbi,
+			address: this.compressor,
+			functionName: "getCreditAccounts",
+			args: [
+				cmFilter,
+				{
+					...permissiveFilter,
+					reverting
+				},
+				0n
+			]
+		}));
+		const allContracts = [...rwaContracts, ...getCreditAccountsContracts];
+		const results = await require_sdk_utils_viem_simulateWithPriceUpdates.simulateWithPriceUpdates(this.client, {
+			priceUpdates: priceUpdateTxs,
+			contracts: allContracts,
+			blockNumber,
+			gas: this.sdk.gasLimit
+		});
+		const rwaResults = results.slice(0, rwaAccountAddresses.length);
+		const normalResults = results.slice(rwaAccountAddresses.length);
+		const seen = new require_sdk_utils_AddressSet.AddressSet();
+		const allCAs = [];
+		for (const ca of rwaResults) 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 && !require_sdk_utils_hex.hexEq(ca.creditManager, creditManager)) return false;
+			return true;
+		});
+		this.logger?.debug(`loaded ${allCAs.length} borrower credit accounts (${rwaResults.length} RWA, ${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: require_abi_compressors_rewardsCompressor.rewardsCompressorAbi,
+			address: this.rewardCompressor,
+			functionName: "getRewards",
+			args: [creditAccount]
+		});
+		const callData = (0, viem.encodeFunctionData)({
+			abi: require_abi_iBaseRewardPool.iBaseRewardPoolAbi,
+			functionName: "getReward",
+			args: []
+		});
+		const r = rewards.reduce((acc, r) => {
+			const adapter = r.adapter.toLowerCase();
+			const stakedPhantomToken = r.stakedPhantomToken.toLowerCase();
+			const rewardToken = r.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: r.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: require_abi_compressors_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: require_abi_310_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: require_abi_310_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);
+		return accountsToCheck.reduce((acc, _, index) => {
+			const r = result.slice(index * bots.length, (index + 1) * bots.length);
+			acc.push({ result: r });
+			return acc;
+		}, []);
+	}
+	#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
+			};
+		}
+	}
+	/**
+	* {@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) {
+			lossPolicyData = await this.sdk.marketRegister.findByCreditManager(account.creditManager).lossPolicy.getLiquidationData(account.creditAccount);
+			this.logger?.debug({ lossPolicyData }, "loss policy data");
+		}
+		return {
+			tx: cm.creditFacade.liquidateCreditAccount(account.creditAccount, to, calls, lossPolicyData),
+			calls,
+			routerCloseResult,
+			lossPolicyData,
+			creditFacade: cm.creditFacade
+		};
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.defaultPartialLiquidationParams}
+	*/
+	defaultPartialLiquidationParams(ca) {
+		const tokenOut = this.#getBestTokenOut(ca);
+		const optimalHF = this.getOptimalHFForPartialLiquidation(ca);
+		const repaidAmount = this.#calcOptimalRepaidAmount(ca, tokenOut, optimalHF);
+		return {
+			tokenOut,
+			optimalHF,
+			repaidAmount,
+			minSeizedAmount: this.#calcMinSeizedAmount(ca, tokenOut, repaidAmount)
+		};
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.partiallyLiquidate}
+	*/
+	async partiallyLiquidate(props) {
+		const { account, to } = props;
+		const tokenOut = props.tokenOut ?? this.#getBestTokenOut(account);
+		const optimalHF = props.optimalHF ?? this.getOptimalHFForPartialLiquidation(account);
+		const repaidAmount = props.repaidAmount ?? this.#calcOptimalRepaidAmount(account, tokenOut, optimalHF);
+		const minSeizedAmount = props.minSeizedAmount ?? this.#calcMinSeizedAmount(account, tokenOut, repaidAmount);
+		const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
+		const updates = await this.getOnDemandPriceUpdates(account, true);
+		return cm.creditFacade.partiallyLiquidateCreditAccount(account.creditAccount, tokenOut, repaidAmount, minSeizedAmount, to, updates);
+	}
+	/**
+	* Picks the most valuable enabled non-underlying collateral token on the
+	* credit account (by oracle value in underlying).
+	*
+	* Ported from solidity:
+	* https://github.com/Gearbox-protocol/router-v3/blob/main/contracts/liquidation/AbstractLiquidator.sol#L270
+	*/
+	#getBestTokenOut(account) {
+		const market = this.sdk.marketRegister.findByCreditManager(account.creditManager);
+		const underlying = market.underlying;
+		let bestVal = 0n;
+		let bestToken;
+		for (const t of account.tokens) {
+			if (t.token === underlying) continue;
+			if ((t.mask & account.enabledTokensMask) === 0n) continue;
+			if (t.balance === 0n) continue;
+			const val = market.priceOracle.convert(t.token, underlying, t.balance);
+			if (val > bestVal) {
+				bestVal = val;
+				bestToken = t.token;
+			}
+		}
+		if (!bestToken) throw new Error(`cannot determine tokenOut for partial liquidation of ${this.sdk.labelAddress(account.creditAccount)}: no enabled non-underlying collateral with value`);
+		return bestToken;
+	}
+	/**
+	* Returns the minimum amount of `token` collateral that must be seized when
+	* repaying `repaidAmount` of underlying. Mirrors the on-chain liquidation
+	* discount math, expired-aware.
+	*/
+	#calcMinSeizedAmount(account, token, repaidAmount) {
+		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;
+		return market.priceOracle.convert(market.underlying, token, repaidAmount) * 9990n / BigInt(fee);
+	}
+	/**
+	* Computes the optimal `repaidAmount` (in underlying) that brings the credit
+	* account's health factor close to `optimalHF` after partial liquidation.
+	*
+	* Ported from solidity:
+	* https://github.com/Gearbox-protocol/router-v3/blob/56e2d515ec6d9bb1e324e71c3708e59710779b24/contracts/liquidation/AbstractLiquidator.sol#L292
+	*/
+	#calcOptimalRepaidAmount(account, token, optimalHF) {
+		const suite = this.sdk.marketRegister.findCreditManager(account.creditManager);
+		const market = this.sdk.marketRegister.findByCreditManager(account.creditManager);
+		const cm = suite.creditManager;
+		const feeLiquidation = suite.isExpired ? cm.feeLiquidationExpired : cm.feeLiquidation;
+		const liquidationDiscount = suite.isExpired ? cm.liquidationDiscountExpired : cm.liquidationDiscount;
+		const discount = BigInt(liquidationDiscount) - BigInt(feeLiquidation);
+		const ltTokenOut = cm.liquidationThresholds.get(token);
+		if (ltTokenOut === void 0) throw new Error(`token ${this.sdk.labelAddress(token)} is not a collateral token in credit manager ${this.sdk.labelAddress(account.creditManager)}`);
+		const totalDebt = account.debt + account.accruedInterest + account.accruedFees;
+		const twvUnderlying = market.priceOracle.convertFromUSD(market.underlying, account.twvUSD);
+		const denominator = discount * optimalHF / require_sdk_constants_math.PERCENTAGE_FACTOR - BigInt(ltTokenOut);
+		if (denominator <= 0n) throw new Error("cannot compute optimal repaid amount: invalid liquidation parameters (discount * hfOptimal <= ltTokenOut)");
+		const numerator = totalDebt * optimalHF - twvUnderlying * require_sdk_constants_math.PERCENTAGE_FACTOR;
+		if (numerator <= 0n) return 0n;
+		let repaidAmount = numerator / denominator * discount / require_sdk_constants_math.PERCENTAGE_FACTOR;
+		const minDebt = suite.creditFacade.minDebt;
+		if (totalDebt < minDebt) return 0n;
+		const surplusDebt = totalDebt - minDebt;
+		if (repaidAmount > surplusDebt) repaidAmount = surplusDebt * 999n / 1000n;
+		return repaidAmount;
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.closeCreditAccount}
+	**/
+	async closeCreditAccount({ operation, assetsToWithdraw, creditAccount: ca, to, slippage = 50n, closePath }) {
+		const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+		const routerCloseResult = closePath || await this.sdk.routerFor(ca).findBestClosePath({
+			creditAccount: ca,
+			creditManager: cm.creditManager,
+			slippage
+		});
+		const operationCalls = await this.assembleCloseCreditAccountCalls({
+			creditAccount: ca,
+			routerCalls: routerCloseResult.calls,
+			assetsToWithdraw,
+			to
+		});
+		const calls = operation === "close" ? operationCalls : await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
+		return {
+			tx: await this.#closeCreditAccountTx(cm, ca.creditAccount, calls, operation),
+			calls,
+			routerCloseResult,
+			creditFacade: cm.creditFacade
+		};
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.assembleCloseCreditAccountCalls}
+	*/
+	async assembleCloseCreditAccountCalls({ creditAccount: ca, routerCalls, assetsToWithdraw, to }) {
+		const unwrapCalls = await this.getRedeemDiffCalls(1n, ca.creditManager) ?? [];
+		return [
+			...routerCalls,
+			...this.#prepareDisableQuotas(ca),
+			...this.#prepareDecreaseDebt(ca),
+			...unwrapCalls,
+			...assetsToWithdraw.map((t) => this.#prepareWithdrawToken(ca.creditFacade, t, require_sdk_constants_math.MAX_UINT256, to))
+		];
+	}
+	/**
+	* {@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);
+		return {
+			tx: await this.#multicallTx(cm, creditAccount.creditAccount, calls),
+			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.getRWAUnwrapCalls(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 RWA market");
+		const operationCalls = [
+			...addCollateralCalls,
+			...unwrapCalls,
+			this.#prepareChangeDebt(creditAccount.creditFacade, change, isDecrease)
+		];
+		const calls = await this.#prependPriceUpdates(creditAccount.creditManager, operationCalls, creditAccount);
+		return {
+			tx: await this.#multicallTx(cm, creditAccount.creditAccount, calls),
+			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);
+		return {
+			tx: await this.#multicallTx(cm, creditAccount.creditAccount, calls),
+			calls,
+			creditFacade: cm.creditFacade
+		};
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.previewDelayedWithdrawal}
+	**/
+	async previewDelayedWithdrawal({ creditAccount, amount, token, withdrawalPhantomToken, intent }) {
+		return this.#withdrawalCompressor.getWithdrawalRequestResult({
+			creditAccount,
+			token,
+			amount,
+			withdrawalPhantomToken,
+			intent
+		});
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.getPendingWithdrawals}
+	**/
+	async getPendingWithdrawals({ creditAccount }) {
+		const { claimable, pending } = await this.#withdrawalCompressor.getCurrentWithdrawals(creditAccount);
+		return {
+			claimableNow: claimable,
+			pending
+		};
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.assembleStartDelayedWithdrawalCalls}
+	**/
+	assembleStartDelayedWithdrawalCalls({ creditFacade, preview }) {
+		const record = preview.outputs.reduce((acc, o) => {
+			const token = o.token.toLowerCase();
+			acc[token] = (acc[token] || 0n) + o.amount;
+			return acc;
+		}, {});
+		const deltas = Object.entries(record).filter(([, a]) => a > 10n).map(([token, amount]) => ({
+			token,
+			amount: amount > 10n ? amount - 10n : 0n
+		}));
+		if (preview.amountIn > 0n) deltas.push({
+			token: preview.token,
+			amount: -preview.amountIn
+		});
+		const storeExpectedBalances = {
+			target: creditFacade,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+				functionName: "storeExpectedBalances",
+				args: [deltas]
+			})
+		};
+		const compareBalances = {
+			target: creditFacade,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+				functionName: "compareBalances",
+				args: []
+			})
+		};
+		return [
+			storeExpectedBalances,
+			...preview.requestCalls,
+			compareBalances
+		];
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.assembleClaimDelayedCalls}
+	**/
+	assembleClaimDelayedCalls({ creditFacade, claimableNow }) {
+		const record = claimableNow.outputs.reduce((acc, o) => {
+			const token = o.token.toLowerCase();
+			acc[token] = (acc[token] || 0n) + o.amount;
+			return acc;
+		}, {});
+		const deltas = Object.entries(record).filter(([, a]) => a > 10n).map(([token, amount]) => ({
+			token,
+			amount: amount > 10n ? amount - 10n : 0n
+		}));
+		if (claimableNow.withdrawalTokenSpent > 0n) deltas.push({
+			token: claimableNow.withdrawalPhantomToken,
+			amount: -claimableNow.withdrawalTokenSpent
+		});
+		const storeExpectedBalances = {
+			target: creditFacade,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+				functionName: "storeExpectedBalances",
+				args: [deltas]
+			})
+		};
+		const compareBalances = {
+			target: creditFacade,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+				functionName: "compareBalances",
+				args: []
+			})
+		};
+		return [
+			storeExpectedBalances,
+			...claimableNow.claimCalls,
+			compareBalances
+		];
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.startDelayedWithdrawal}
+	**/
+	async startDelayedWithdrawal({ creditAccount, minQuota, averageQuota, preview }) {
+		const cm = this.sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+		const operationCalls = [...this.assembleStartDelayedWithdrawalCalls({
+			creditFacade: cm.creditFacade.address,
+			preview
+		}), ...this.#prepareUpdateQuotas(cm.creditFacade.address, {
+			minQuota,
+			averageQuota
+		})];
+		const calls = await this.#prependPriceUpdates(creditAccount.creditManager, operationCalls, creditAccount);
+		return {
+			tx: await this.#multicallTx(cm, creditAccount.creditAccount, calls),
+			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 quotaCalls = zeroDebt ? [] : this.#prepareUpdateQuotas(cm.creditFacade.address, {
+			minQuota,
+			averageQuota
+		});
+		const operationCalls = [...this.assembleClaimDelayedCalls({
+			creditFacade: cm.creditFacade.address,
+			claimableNow
+		}), ...quotaCalls];
+		const calls = zeroDebt ? operationCalls : await this.#prependPriceUpdates(creditAccount.creditManager, operationCalls, creditAccount);
+		return {
+			tx: await this.#multicallTx(cm, creditAccount.creditAccount, calls),
+			calls,
+			creditFacade: cm.creditFacade
+		};
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.getApprovalAddress}
+	**/
+	async getApprovalAddress(options) {
+		const { creditManager } = options;
+		const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+		const factory = this.sdk.marketRegister.findByPool(suite.pool).rwaFactory;
+		if (factory) return factory.getApprovalAddress(options);
+		return suite.creditManager.address;
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.getOpenAccountRequirements}
+	*/
+	async getOpenAccountRequirements(borrower, creditManager, props) {
+		const { rwaFactory } = this.sdk.marketRegister.findByCreditManager(creditManager);
+		if (!rwaFactory) return;
+		return rwaFactory.getOpenAccountRequirements(borrower, props);
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.openCA}
+	**/
+	async openCA(props) {
+		const { ethAmount, creditManager, reopenCreditAccount, collateral, permits, debt, withdrawToken, referralCode, to, calls: openPathCalls, callsAfter, minQuota, averageQuota, rwaOptions } = 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,
+			...tokenToWithdraw ? [this.#prepareWithdrawToken(cm.creditFacade, tokenToWithdraw, require_sdk_constants_math.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, rwaOptions);
+		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) + require_sdk_constants_math.PERCENTAGE_FACTOR);
+		const totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
+		const r = ca.debt * baseRateWithFee / (totalDebt * require_sdk_constants_math.RAY);
+		const caTokens = new require_sdk_utils_AddressMap.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) + require_sdk_constants_math.PERCENTAGE_FACTOR) / require_sdk_constants_math.PERCENTAGE_FACTOR;
+		qr /= totalDebt;
+		return r + qr;
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.getOptimalHFForPartialLiquidation}
+	**/
+	getOptimalHFForPartialLiquidation(ca) {
+		const borrowRate = this.getBorrowRate(ca);
+		return require_sdk_constants_math.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 require_sdk_utils_viem_simulateWithPriceUpdates.simulateWithPriceUpdates(this.client, {
+			priceUpdates: priceUpdateTxs,
+			contracts: [{
+				abi: require_abi_compressors_creditAccountCompressor.creditAccountCompressorAbi,
+				address: this.compressor,
+				functionName: "getCreditAccounts",
+				args
+			}],
+			blockNumber,
+			gas: this.sdk.gasLimit
+		});
+		else resp = await this.client.readContract({
+			abi: require_abi_compressors_creditAccountCompressor.creditAccountCompressorAbi,
+			address: this.compressor,
+			functionName: "getCreditAccounts",
+			args,
+			blockNumber,
+			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) RWA ERC-4626 vault shares into underlying for the given credit manager.
+	* Used when withdrawing debt from a RWA market: redeems adapter vault shares so the underlying can be withdrawn.
+	* Only applies when the credit manager's underlying is RWA-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 RWA or no adapter is configured
+	*/
+	async getRWAUnwrapCalls(amount, creditManager) {
+		const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+		const meta = this.sdk.tokensMeta.mustGet(suite.underlying);
+		if (!this.sdk.tokensMeta.isRWAUnderlying(meta)) return;
+		const adapterAddress = suite.creditManager.adapters.get(meta.addr)?.address;
+		if (!adapterAddress) return;
+		return [{
+			target: adapterAddress,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_ierc4626Adapter.ierc4626AdapterAbi,
+				functionName: "redeem",
+				args: [
+					amount,
+					require_sdk_constants_addresses.ADDRESS_0X0,
+					require_sdk_constants_addresses.ADDRESS_0X0
+				]
+			})
+		}];
+	}
+	/**
+	* Returns multicall entries to deposit (wrap) underlying into RWA ERC-4626 vault shares for the given credit manager.
+	* Used when adding debt on a RWA market: deposits underlying into the adapter vault so shares are minted on the account.
+	* Only applies when the credit manager's underlying is RWA-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 RWA or no adapter is configured
+	*/
+	async getRWAWrapCalls(amount, creditManager) {
+		const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+		const meta = this.sdk.tokensMeta.mustGet(suite.underlying);
+		if (!this.sdk.tokensMeta.isRWAUnderlying(meta)) return;
+		const adapterAddress = suite.creditManager.adapters.get(meta.addr)?.address;
+		if (!adapterAddress) return;
+		return [{
+			target: adapterAddress,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_ierc4626Adapter.ierc4626AdapterAbi,
+				functionName: "deposit",
+				args: [amount, require_sdk_constants_addresses.ADDRESS_0X0]
+			})
+		}];
+	}
+	/**
+	* Returns multicall entries to call redeemDiff on the RWA 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 RWA vault tokens.
+	* Only applies when the credit manager's underlying is RWA-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 RWA 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.isRWAUnderlying(meta)) return;
+		const adapterAddress = suite.creditManager.adapters.get(meta.addr)?.address;
+		if (!adapterAddress) return;
+		return [{
+			target: adapterAddress,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_ierc4626Adapter.ierc4626AdapterAbi,
+				functionName: "redeemDiff",
+				args: [amount]
+			})
+		}];
+	}
+	/**
+	* Returns multicall entries to call depositDiff on the RWA 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 RWA-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 RWA 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.isRWAUnderlying(meta)) return;
+		const adapterAddress = suite.creditManager.adapters.get(meta.addr)?.address;
+		if (!adapterAddress) return;
+		return [{
+			target: adapterAddress,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_ierc4626Adapter.ierc4626AdapterAbi,
+				functionName: "depositDiff",
+				args: [amount]
+			})
+		}];
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.setBot}
+	*/
+	async setBot({ botAddress, permissions: defaultPermissions, targetContract }) {
+		const cm = this.sdk.marketRegister.findCreditManager(targetContract.creditManager);
+		const permissions = defaultPermissions !== null ? defaultPermissions : await (0, viem.getContract)({
+			address: botAddress,
+			client: this.sdk.client,
+			abi: [{
+				type: "function",
+				name: "requiredPermissions",
+				inputs: [],
+				outputs: [{
+					name: "",
+					type: "uint192",
+					internalType: "uint192"
+				}],
+				stateMutability: "view"
+			}]
+		}).read.requiredPermissions();
+		const addBotCall = {
+			target: cm.creditFacade.address,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+				functionName: "setBotPermissions",
+				args: [botAddress, permissions]
+			})
+		};
+		const calls = targetContract.type === "creditAccount" ? await this.#prependPriceUpdates(targetContract.creditManager, [addBotCall], targetContract) : [addBotCall];
+		return {
+			tx: targetContract.type === "creditAccount" ? await this.#multicallTx(cm, targetContract.creditAccount, calls) : void 0,
+			calls,
+			creditFacade: cm.creditFacade
+		};
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.withdrawCollateral}
+	*/
+	async withdrawCollateral({ creditAccount, assetsToWithdraw, to, minQuota, averageQuota }) {
+		const cm = this.sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+		const operationCalls = [...assetsToWithdraw.map((a) => this.#prepareWithdrawToken(cm.creditFacade.address, a.token, a.balance, to)), ...this.#prepareUpdateQuotas(cm.creditFacade.address, {
+			minQuota,
+			averageQuota
+		})];
+		const calls = await this.#prependPriceUpdates(creditAccount.creditManager, operationCalls, creditAccount);
+		return {
+			tx: await this.#multicallTx(cm, creditAccount.creditAccount, calls),
+			calls,
+			creditFacade: cm.creditFacade
+		};
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.repayCreditAccount}
+	*/
+	async repayCreditAccount(props) {
+		const { operation, creditAccount: ca } = props;
+		const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+		const operationCalls = await this.assembleRepayCreditAccountCalls(props);
+		const calls = operation === "close" ? operationCalls : await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
+		return {
+			tx: await this.#closeCreditAccountTx(cm, ca.creditAccount, calls, operation),
+			calls,
+			creditFacade: cm.creditFacade
+		};
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.assembleRepayCreditAccountCalls}
+	*/
+	async assembleRepayCreditAccountCalls({ collateralAssets, assetsToWithdraw, creditAccount: ca, permits, to, tokensToClaim, calls: wrapCalls = [] }) {
+		const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+		const router = this.sdk.routerFor(ca);
+		const unwrapCalls = await this.getRedeemDiffCalls(1n, ca.creditManager) ?? [];
+		const claimPath = await router.findClaimAllRewards({
+			tokensToClaim,
+			creditAccount: ca
+		});
+		return [
+			...this.#prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+			...wrapCalls,
+			...this.#prepareDisableQuotas(ca),
+			...this.#prepareDecreaseDebt(ca),
+			...unwrapCalls,
+			...claimPath.calls,
+			...assetsToWithdraw.map((t) => this.#prepareWithdrawToken(ca.creditFacade, t.token, require_sdk_constants_math.MAX_UINT256, to))
+		];
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.repayAndLiquidateCreditAccount}
+	*/
+	async repayAndLiquidateCreditAccount({ collateralAssets, assetsToWithdraw, creditAccount: ca, permits, to, tokensToClaim }) {
+		const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+		const claimPath = await this.sdk.routerFor(ca).findClaimAllRewards({
+			tokensToClaim,
+			creditAccount: ca
+		});
+		const wrapCalls = await this.getDepositDiffCalls(1n, ca.creditManager) ?? [];
+		const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+		const operationCalls = [
+			...this.#prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+			...claimPath.calls,
+			...wrapCalls,
+			...assetsToWithdraw.map((t) => this.#prepareWithdrawToken(ca.creditFacade, t.token, require_sdk_constants_math.MAX_UINT256, to))
+		];
+		const calls = await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
+		return {
+			tx: cm.creditFacade.liquidateCreditAccount(ca.creditAccount, to, calls),
+			calls,
+			creditFacade: cm.creditFacade
+		};
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.claimFarmRewards}
+	*/
+	async claimFarmRewards({ calls: externalCalls, creditAccount: ca, minQuota, averageQuota, tokensToClaim }) {
+		const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+		const router = this.sdk.routerFor(ca);
+		let claimPath;
+		if (externalCalls) claimPath = { calls: externalCalls };
+		else claimPath = await router.findClaimAllRewards({
+			tokensToClaim,
+			creditAccount: ca
+		});
+		if (claimPath.calls.length === 0) throw new Error("No path to execute");
+		const operationCalls = [...claimPath.calls, ...this.#prepareUpdateQuotas(ca.creditFacade, {
+			minQuota,
+			averageQuota
+		})];
+		const calls = await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
+		return {
+			tx: await this.#multicallTx(cm, ca.creditAccount, calls),
+			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 require_sdk_market_pricefeeds_getRawPriceUpdates.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 } = require_sdk_accounts_multicall_utils.extractPriceUpdates(calls);
+		const tokens = new require_sdk_utils_AddressSet.AddressSet([cm.underlying, ...require_sdk_accounts_multicall_utils.extractQuotaTokens(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 = require_sdk_accounts_multicall_utils.mergePriceUpdates(existingUpdates, generatedUpdates);
+		if (merged.length === 0) return remainingCalls;
+		return [{
+			target: cm.creditFacade,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_310_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 require_sdk_utils_AddressSet.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);
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.prependPriceUpdates}
+	*/
+	async prependPriceUpdates(creditManager, calls, creditAccount, options) {
+		return this.#prependPriceUpdates(creditManager, calls, creditAccount, options);
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.assembleCaOperations}
+	*/
+	assembleCaOperations({ operations, creditFacade }) {
+		const calls = [];
+		for (const op of operations) switch (op.type) {
+			case "increaseDebt":
+				calls.push(this.#prepareIncreaseDebt(creditFacade, op.amount));
+				break;
+			case "decreaseDebt":
+				calls.push(this.#prepareChangeDebt(creditFacade, op.amount, true));
+				break;
+			case "addCollateral":
+				calls.push(...this.#prepareAddCollateral(creditFacade, [{
+					token: op.token,
+					balance: op.amount
+				}], {}));
+				break;
+			case "withdrawCollateral":
+				calls.push(this.#prepareWithdrawToken(creditFacade, op.token, op.amount, op.to));
+				break;
+			case "swap":
+			case "wrapRwaCollateral":
+			case "unwrapRwaCollateral":
+				calls.push(...op.calls);
+				break;
+			case "changeQuota": {
+				const quotaAssets = [...op.quotaIncrease, ...op.quotaDecrease];
+				if (quotaAssets.length === 0) break;
+				calls.push(...this.#prepareUpdateQuotas(creditFacade, {
+					averageQuota: quotaAssets,
+					minQuota: quotaAssets
+				}));
+				break;
+			}
+			default: throw new Error(`assembleCaOperations: unsupported operation ${JSON.stringify(op)}`);
+		}
+		return calls;
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.executeCaUpdate}
+	*/
+	async executeCaUpdate(creditAccount, calls, options) {
+		const cm = this.sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+		const callsWithPrices = await this.#prependPriceUpdates(creditAccount.creditManager, calls, creditAccount, { ignoreReservePrices: options?.ignoreReservePrices });
+		const tx = await this.#multicallTx(cm, creditAccount.creditAccount, callsWithPrices);
+		if (options?.ethAmount && options.ethAmount > 0n) tx.value = options.ethAmount.toString(10);
+		return {
+			tx,
+			calls: callsWithPrices
+		};
+	}
+	#prepareDisableQuotas(ca) {
+		const calls = [];
+		for (const { token, quota } of ca.tokens) if (quota > 0n) calls.push({
+			target: ca.creditFacade,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+				functionName: "updateQuota",
+				args: [
+					token,
+					require_sdk_constants_math.MIN_INT96,
+					0n
+				]
+			})
+		});
+		return calls;
+	}
+	#prepareUpdateQuotas(creditFacade, { averageQuota, minQuota }) {
+		const minRecord = new require_sdk_utils_AssetsMap.AssetsMap(minQuota);
+		return averageQuota.map((q) => {
+			const minBalance = minRecord.get(q.token);
+			const min = minBalance && minBalance > 0n ? minBalance : 0n;
+			return {
+				target: creditFacade,
+				callData: (0, viem.encodeFunctionData)({
+					abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+					functionName: "updateQuota",
+					args: [
+						q.token,
+						q.balance,
+						min
+					]
+				})
+			};
+		});
+	}
+	#prepareDecreaseDebt(ca) {
+		if (ca.debt > 0n) return [{
+			target: ca.creditFacade,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+				functionName: "decreaseDebt",
+				args: [require_sdk_constants_math.MAX_UINT256]
+			})
+		}];
+		return [];
+	}
+	#prepareWithdrawToken(creditFacade, token, amount, to) {
+		return {
+			target: creditFacade,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+				functionName: "withdrawCollateral",
+				args: [
+					token,
+					amount,
+					to
+				]
+			})
+		};
+	}
+	#prepareIncreaseDebt(creditFacade, debt) {
+		return {
+			target: creditFacade,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+				functionName: "increaseDebt",
+				args: [debt]
+			})
+		};
+	}
+	#prepareChangeDebt(creditFacade, change, isDecrease) {
+		return {
+			target: creditFacade,
+			callData: (0, viem.encodeFunctionData)({
+				abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+				functionName: isDecrease ? "decreaseDebt" : "increaseDebt",
+				args: [change]
+			})
+		};
+	}
+	#prepareAddCollateral(creditFacade, assets, permits) {
+		return assets.map(({ token, balance }) => {
+			const p = permits[token];
+			if (p) return {
+				target: creditFacade,
+				callData: (0, viem.encodeFunctionData)({
+					abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+					functionName: "addCollateralWithPermit",
+					args: [
+						token,
+						balance,
+						p.deadline,
+						p.v,
+						p.r,
+						p.s
+					]
+				})
+			};
+			return {
+				target: creditFacade,
+				callData: (0, viem.encodeFunctionData)({
+					abi: require_abi_310_generated.iCreditFacadeMulticallV310Abi,
+					functionName: "addCollateral",
+					args: [token, balance]
+				})
+			};
+		});
+	}
+	/**
+	* Returns addresses of market configurators
+	*/
+	get marketConfigurators() {
+		return this.sdk.marketRegister.marketConfigurators.map((mc) => mc.address);
+	}
+	get rewardCompressor() {
+		return this.sdk.addressProvider.mustGetLatest(require_sdk_constants_address_provider.AP_REWARDS_COMPRESSOR, require_sdk_constants_versions.VERSION_RANGE_310)[0];
+	}
+	get peripheryCompressor() {
+		return this.sdk.addressProvider.mustGetLatest(require_sdk_constants_address_provider.AP_PERIPHERY_COMPRESSOR, require_sdk_constants_versions.VERSION_RANGE_310)[0];
+	}
+	get compressor() {
+		if (!this.#compressor) {
+			[this.#compressor] = this.sdk.addressProvider.mustGetLatest(require_sdk_constants_address_provider.AP_CREDIT_ACCOUNT_COMPRESSOR, require_sdk_constants_versions.VERSION_RANGE_310);
+			this.logger?.debug(`credit account compressor address: ${this.#compressor}`);
+		}
+		return this.#compressor;
+	}
+	/**
+	* Wrapper that selects between credit facade and RWA factory
+	* @param suite
+	* @param to
+	* @param calls
+	* @param referralCode
+	* @param rwaOptions
+	* @returns
+	*/
+	async #openCreditAccountTx(suite, to, calls, referralCode, rwaOptions) {
+		const factory = this.sdk.marketRegister.findByPool(suite.pool).rwaFactory;
+		if (factory) return factory.openCreditAccount(suite.creditManager.address, calls, rwaOptions);
+		return suite.creditFacade.openCreditAccount(to, calls, referralCode ?? 0n);
+	}
+	/**
+	* Wrapper that selects between credit facade and RWA factory
+	* @param suite
+	* @param creditAccount
+	* @param calls
+	* @param rwaOptions
+	* @returns
+	*/
+	async #multicallTx(suite, creditAccount, calls, rwaOptions) {
+		const factory = this.sdk.marketRegister.findByCreditManager(suite.creditManager.address).rwaFactory;
+		if (factory) return factory.multicall(creditAccount, calls, rwaOptions);
+		return suite.creditFacade.multicall(creditAccount, calls);
+	}
+	/**
+	* Wrapper that selects between credit facade and RWA factory
+	* @param suite
+	* @param creditAccount
+	* @param calls
+	* @param operation
+	* @param rwaOptions
+	* @returns
+	*/
+	async #closeCreditAccountTx(suite, creditAccount, calls, operation, rwaOptions) {
+		const factory = this.sdk.marketRegister.findByCreditManager(suite.creditManager.address).rwaFactory;
+		if (operation === "close") {
+			if (factory) throw new Error("CloseOptions=close is not supported for RWA underlying credit accounts");
+			return suite.creditFacade.closeCreditAccount(creditAccount, calls);
+		}
+		if (factory) return factory.multicall(creditAccount, calls, rwaOptions);
+		return suite.creditFacade.multicall(creditAccount, calls);
+	}
+	/**
+	* Withdrawal compressor of the current chain.
+	* @throws If no withdrawal compressor is supported on the current chain.
+	**/
+	get #withdrawalCompressor() {
+		const compressor = this.sdk.withdrawalCompressor;
+		if (!compressor) throw new Error(`no withdrawal compressor on ${this.sdk.networkType}`);
+		return compressor;
+	}
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var CreditAccountsServiceV310_exports = {};
-__export(CreditAccountsServiceV310_exports, {
-  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_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_IWithdrawalCompressorV311 = require("../../abi/IWithdrawalCompressorV311.js");
-var import_iBaseRewardPool = require("../../abi/iBaseRewardPool.js");
-var import_iRWAFactory = require("../../abi/rwa/iRWAFactory.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]: {
-    address: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
-    version: 310
-  },
-  [import_chains.chains.Monad.id]: {
-    address: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
-    version: 310
-  }
-};
-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.rwaFactory;
-    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_iRWAFactory.iRWAFactoryAbi,
-              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.rwa.getInvestorData(borrower);
-    const rwaAccountAddresses = 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 rwaContracts = rwaAccountAddresses.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 = [...rwaContracts, ...getCreditAccountsContracts];
-    const results = await (0, import_viem2.simulateWithPriceUpdates)(this.client, {
-      priceUpdates: priceUpdateTxs,
-      contracts: allContracts,
-      blockNumber,
-      gas: this.sdk.gasLimit
-    });
-    const rwaResults = results.slice(
-      0,
-      rwaAccountAddresses.length
-    );
-    const normalResults = results.slice(rwaAccountAddresses.length);
-    const seen = new import_utils.AddressSet();
-    const allCAs = [];
-    for (const ca of rwaResults) {
-      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 (${rwaResults.length} RWA, ${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.defaultPartialLiquidationParams}
-   */
-  defaultPartialLiquidationParams(ca) {
-    const tokenOut = this.#getBestTokenOut(ca);
-    const optimalHF = this.getOptimalHFForPartialLiquidation(ca);
-    const repaidAmount = this.#calcOptimalRepaidAmount(ca, tokenOut, optimalHF);
-    const minSeizedAmount = this.#calcMinSeizedAmount(
-      ca,
-      tokenOut,
-      repaidAmount
-    );
-    return { tokenOut, optimalHF, repaidAmount, minSeizedAmount };
-  }
-  /**
-   * {@inheritDoc ICreditAccountsService.partiallyLiquidate}
-   */
-  async partiallyLiquidate(props) {
-    const { account, to } = props;
-    const tokenOut = props.tokenOut ?? this.#getBestTokenOut(account);
-    const optimalHF = props.optimalHF ?? this.getOptimalHFForPartialLiquidation(account);
-    const repaidAmount = props.repaidAmount ?? this.#calcOptimalRepaidAmount(account, tokenOut, optimalHF);
-    const minSeizedAmount = props.minSeizedAmount ?? this.#calcMinSeizedAmount(account, tokenOut, repaidAmount);
-    const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
-    const updates = await this.getOnDemandPriceUpdates(account, true);
-    const tx = cm.creditFacade.partiallyLiquidateCreditAccount(
-      account.creditAccount,
-      tokenOut,
-      repaidAmount,
-      minSeizedAmount,
-      to,
-      updates
-    );
-    return tx;
-  }
-  /**
-   * Picks the most valuable enabled non-underlying collateral token on the
-   * credit account (by oracle value in underlying).
-   *
-   * Ported from solidity:
-   * https://github.com/Gearbox-protocol/router-v3/blob/main/contracts/liquidation/AbstractLiquidator.sol#L270
-   */
-  #getBestTokenOut(account) {
-    const market = this.sdk.marketRegister.findByCreditManager(
-      account.creditManager
-    );
-    const underlying = market.underlying;
-    let bestVal = 0n;
-    let bestToken;
-    for (const t of account.tokens) {
-      if (t.token === underlying) continue;
-      if ((t.mask & account.enabledTokensMask) === 0n) continue;
-      if (t.balance === 0n) continue;
-      const val = market.priceOracle.convert(t.token, underlying, t.balance);
-      if (val > bestVal) {
-        bestVal = val;
-        bestToken = t.token;
-      }
-    }
-    if (!bestToken) {
-      throw new Error(
-        `cannot determine tokenOut for partial liquidation of ${this.sdk.labelAddress(account.creditAccount)}: no enabled non-underlying collateral with value`
-      );
-    }
-    return bestToken;
-  }
-  /**
-   * Returns the minimum amount of `token` collateral that must be seized when
-   * repaying `repaidAmount` of underlying. Mirrors the on-chain liquidation
-   * discount math, expired-aware.
-   */
-  #calcMinSeizedAmount(account, token, repaidAmount) {
-    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);
-  }
-  /**
-   * Computes the optimal `repaidAmount` (in underlying) that brings the credit
-   * account's health factor close to `optimalHF` after partial liquidation.
-   *
-   * Ported from solidity:
-   * https://github.com/Gearbox-protocol/router-v3/blob/56e2d515ec6d9bb1e324e71c3708e59710779b24/contracts/liquidation/AbstractLiquidator.sol#L292
-   */
-  #calcOptimalRepaidAmount(account, token, optimalHF) {
-    const suite = this.sdk.marketRegister.findCreditManager(
-      account.creditManager
-    );
-    const market = this.sdk.marketRegister.findByCreditManager(
-      account.creditManager
-    );
-    const cm = suite.creditManager;
-    const feeLiquidation = suite.isExpired ? cm.feeLiquidationExpired : cm.feeLiquidation;
-    const liquidationDiscount = suite.isExpired ? cm.liquidationDiscountExpired : cm.liquidationDiscount;
-    const discount = BigInt(liquidationDiscount) - BigInt(feeLiquidation);
-    const ltTokenOut = cm.liquidationThresholds.get(token);
-    if (ltTokenOut === void 0) {
-      throw new Error(
-        `token ${this.sdk.labelAddress(token)} is not a collateral token in credit manager ${this.sdk.labelAddress(account.creditManager)}`
-      );
-    }
-    const totalDebt = account.debt + account.accruedInterest + account.accruedFees;
-    const twvUnderlying = market.priceOracle.convertFromUSD(
-      market.underlying,
-      account.twvUSD
-    );
-    const denominator = discount * optimalHF / import_constants.PERCENTAGE_FACTOR - BigInt(ltTokenOut);
-    if (denominator <= 0n) {
-      throw new Error(
-        "cannot compute optimal repaid amount: invalid liquidation parameters (discount * hfOptimal <= ltTokenOut)"
-      );
-    }
-    const numerator = totalDebt * optimalHF - twvUnderlying * import_constants.PERCENTAGE_FACTOR;
-    if (numerator <= 0n) {
-      return 0n;
-    }
-    const optimalValueSeized = numerator / denominator;
-    let repaidAmount = optimalValueSeized * discount / import_constants.PERCENTAGE_FACTOR;
-    const minDebt = suite.creditFacade.minDebt;
-    if (totalDebt < minDebt) {
-      return 0n;
-    }
-    const surplusDebt = totalDebt - minDebt;
-    if (repaidAmount > surplusDebt) {
-      repaidAmount = surplusDebt * 999n / 1000n;
-    }
-    return repaidAmount;
-  }
-  /**
-   * {@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.isRWAUnderlying(underlying)) {
-      throw new Error(
-        "closeCreditAccount is not supported for RWA 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.getRWAUnwrapCalls(
-      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 RWA 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.address,
-      abi: compressor.version === 310 ? import_IWithdrawalCompressorV310.iWithdrawalCompressorV310Abi : import_IWithdrawalCompressorV311.iWithdrawalCompressorV311Abi,
-      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.address,
-      abi: compressor.version === 310 ? import_IWithdrawalCompressorV310.iWithdrawalCompressorV310Abi : import_IWithdrawalCompressorV311.iWithdrawalCompressorV311Abi,
-      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.rwaFactory;
-    if (factory) {
-      return factory.getApprovalAddress(options);
-    }
-    return suite.creditManager.address;
-  }
-  /**
-   * {@inheritDoc ICreditAccountsService.getOpenAccountRequirements}
-   */
-  async getOpenAccountRequirements(borrower, creditManager, props) {
-    const { rwaFactory } = this.sdk.marketRegister.findByCreditManager(creditManager);
-    if (!rwaFactory) {
-      return void 0;
-    }
-    return rwaFactory.getOpenAccountRequirements(borrower, props);
-  }
-  /**
-   * {@inheritDoc ICreditAccountsService.openCA}
-   **/
-  async openCA(props) {
-    const {
-      ethAmount,
-      creditManager,
-      reopenCreditAccount,
-      collateral,
-      permits,
-      debt,
-      withdrawToken,
-      referralCode,
-      to,
-      calls: openPathCalls,
-      callsAfter,
-      minQuota,
-      averageQuota,
-      rwaOptions
-    } = 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,
-        rwaOptions
-      );
-    }
-    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) RWA ERC-4626 vault shares into underlying for the given credit manager.
-   * Used when withdrawing debt from a RWA market: redeems adapter vault shares so the underlying can be withdrawn.
-   * Only applies when the credit manager's underlying is RWA-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 RWA or no adapter is configured
-   */
-  async getRWAUnwrapCalls(amount, creditManager) {
-    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
-    const meta = this.sdk.tokensMeta.mustGet(suite.underlying);
-    if (!this.sdk.tokensMeta.isRWAUnderlying(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 RWA ERC-4626 vault shares for the given credit manager.
-   * Used when adding debt on a RWA market: deposits underlying into the adapter vault so shares are minted on the account.
-   * Only applies when the credit manager's underlying is RWA-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 RWA or no adapter is configured
-   */
-  async getRWAWrapCalls(amount, creditManager) {
-    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
-    const meta = this.sdk.tokensMeta.mustGet(suite.underlying);
-    if (!this.sdk.tokensMeta.isRWAUnderlying(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 RWA 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 RWA vault tokens.
-   * Only applies when the credit manager's underlying is RWA-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 RWA 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.isRWAUnderlying(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 RWA 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 RWA-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 RWA 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.isRWAUnderlying(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}
-   */
-  async setBot({
-    botAddress,
-    permissions: defaultPermissions,
-    targetContract
-  }) {
-    const cm = this.sdk.marketRegister.findCreditManager(
-      targetContract.creditManager
-    );
-    const permissions = defaultPermissions !== null ? defaultPermissions : await (0, import_viem.getContract)({
-      address: botAddress,
-      client: this.sdk.client,
-      abi: [
-        {
-          type: "function",
-          name: "requiredPermissions",
-          inputs: [],
-          outputs: [
-            { name: "", type: "uint192", internalType: "uint192" }
-          ],
-          stateMutability: "view"
-        }
-      ]
-    }).read.requiredPermissions();
-    const addBotCall = {
-      target: cm.creditFacade.address,
-      callData: (0, import_viem.encodeFunctionData)({
-        abi: import_generated.iCreditFacadeMulticallV310Abi,
-        functionName: "setBotPermissions",
-        args: [botAddress, permissions]
-      })
-    };
-    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;
-    return { tx, calls, creditFacade: cm.creditFacade };
-  }
-  /**
-   * {@inheritDoc ICreditAccountsService.withdrawCollateral}
-   */
-  async withdrawCollateral({
-    creditAccount,
-    assetsToWithdraw,
-    to,
-    minQuota,
-    averageQuota
-  }) {
-    const cm = this.sdk.marketRegister.findCreditManager(
-      creditAccount.creditManager
-    );
-    const operationCalls = [
-      ...assetsToWithdraw.map(
-        (a) => this.#prepareWithdrawToken(
-          creditAccount.creditFacade,
-          a.token,
-          a.balance,
-          to
-        )
-      ),
-      ...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.repayCreditAccount}
-   */
-  async repayCreditAccount({
-    operation,
-    collateralAssets,
-    assetsToWithdraw,
-    creditAccount: ca,
-    permits,
-    to,
-    tokensToClaim,
-    calls: wrapCalls = []
-  }) {
-    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
-    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
-    const router = this.sdk.routerFor(ca);
-    const unwrapCalls = await this.getRedeemDiffCalls(1n, ca.creditManager) ?? [];
-    const claimPath = await router.findClaimAllRewards({
-      tokensToClaim,
-      creditAccount: ca
-    });
-    const operationCalls = [
-      ...this.#prepareAddCollateral(ca.creditFacade, addCollateral, permits),
-      ...wrapCalls,
-      ...this.#prepareDisableQuotas(ca),
-      ...this.#prepareDecreaseDebt(ca),
-      ...unwrapCalls,
-      ...claimPath.calls,
-      ...assetsToWithdraw.map(
-        (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(
-      cm,
-      ca.creditAccount,
-      calls,
-      operation
-    );
-    return { tx, calls, creditFacade: cm.creditFacade };
-  }
-  /**
-   * {@inheritDoc ICreditAccountsService.repayAndLiquidateCreditAccount}
-   */
-  async repayAndLiquidateCreditAccount({
-    collateralAssets,
-    assetsToWithdraw,
-    creditAccount: ca,
-    permits,
-    to,
-    tokensToClaim
-  }) {
-    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
-    const router = this.sdk.routerFor(ca);
-    const claimPath = await router.findClaimAllRewards({
-      tokensToClaim,
-      creditAccount: ca
-    });
-    const wrapCalls = await this.getDepositDiffCalls(1n, ca.creditManager) ?? [];
-    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
-    const operationCalls = [
-      ...this.#prepareAddCollateral(ca.creditFacade, addCollateral, permits),
-      ...claimPath.calls,
-      ...wrapCalls,
-      ...assetsToWithdraw.map(
-        (t) => this.#prepareWithdrawToken(ca.creditFacade, t.token, import_constants.MAX_UINT256, to)
-      )
-    ];
-    const calls = await this.#prependPriceUpdates(
-      ca.creditManager,
-      operationCalls,
-      ca
-    );
-    const tx = cm.creditFacade.liquidateCreditAccount(
-      ca.creditAccount,
-      to,
-      calls
-    );
-    return { tx, calls, creditFacade: cm.creditFacade };
-  }
-  /**
-   * {@inheritDoc ICreditAccountsService.claimFarmRewards}
-   */
-  async claimFarmRewards({
-    calls: externalCalls,
-    creditAccount: ca,
-    minQuota,
-    averageQuota,
-    tokensToClaim
-  }) {
-    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
-    const router = this.sdk.routerFor(ca);
-    let claimPath;
-    if (externalCalls) {
-      claimPath = { calls: externalCalls };
-    } else {
-      claimPath = await router.findClaimAllRewards({
-        tokensToClaim,
-        creditAccount: ca
-      });
-    }
-    if (claimPath.calls.length === 0) throw new Error("No path to execute");
-    const operationCalls = [
-      ...claimPath.calls,
-      ...this.#prepareUpdateQuotas(ca.creditFacade, { minQuota, averageQuota })
-    ];
-    const calls = await this.#prependPriceUpdates(
-      ca.creditManager,
-      operationCalls,
-      ca
-    );
-    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
-    );
-  }
-  /**
-   * {@inheritDoc ICreditAccountsService.prependPriceUpdates}
-   */
-  async prependPriceUpdates(creditManager, calls, creditAccount, options) {
-    return this.#prependPriceUpdates(
-      creditManager,
-      calls,
-      creditAccount,
-      options
-    );
-  }
-  /**
-   * {@inheritDoc ICreditAccountsService.assembleCaUpdateCalls}
-   */
-  assembleCaUpdateCalls({
-    operations,
-    routerCallGroups,
-    creditFacade,
-    withdrawTo,
-    creditAccount,
-    underlyingToken
-  }) {
-    const calls = [];
-    let swapGroupIndex = 0;
-    let routerGroupsConsumed = 0;
-    for (const op of operations) {
-      switch (op.type) {
-        case "increaseDebt":
-          calls.push(this.#prepareIncreaseDebt(creditFacade, op.amount));
-          break;
-        case "decreaseDebt":
-          calls.push(this.#prepareChangeDebt(creditFacade, op.amount, true));
-          break;
-        case "addCollateral":
-          calls.push(
-            ...this.#prepareAddCollateral(
-              creditFacade,
-              [{ token: op.token, balance: op.amount }],
-              {}
-            )
-          );
-          break;
-        case "withdrawCollateral":
-          calls.push(
-            this.#prepareWithdrawToken(
-              creditFacade,
-              op.token,
-              op.amount,
-              withdrawTo
-            )
-          );
-          break;
-        case "swap": {
-          const routerCalls = routerCallGroups[swapGroupIndex];
-          if (!routerCalls) {
-            throw new Error(
-              `assembleCaUpdateCalls: missing router calls for swap leg ${swapGroupIndex}`
-            );
-          }
-          calls.push(...routerCalls);
-          swapGroupIndex += 1;
-          routerGroupsConsumed += 1;
-          break;
-        }
-        case "changeQuota": {
-          const quotaAssets = [...op.quotaIncrease, ...op.quotaDecrease];
-          if (quotaAssets.length === 0) {
-            break;
-          }
-          calls.push(
-            ...this.#prepareUpdateQuotas(creditFacade, {
-              averageQuota: quotaAssets,
-              minQuota: quotaAssets
-            })
-          );
-          break;
-        }
-        case "closeCreditAccount": {
-          for (const group of routerCallGroups) {
-            calls.push(...group);
-            routerGroupsConsumed += 1;
-          }
-          calls.push(
-            ...this.#prepareDisableQuotas({
-              creditFacade,
-              tokens: Object.entries(creditAccount.initialQuotas).map(
-                ([token, { quota }]) => ({
-                  token,
-                  quota
-                })
-              )
-            })
-          );
-          if (creditAccount.debt > 0n) {
-            calls.push(
-              ...this.#prepareDecreaseDebt({
-                creditFacade,
-                debt: creditAccount.debt
-              })
-            );
-          }
-          const hasAssets = creditAccount.assets.some(
-            (asset) => asset.balance > 0n
-          );
-          if (hasAssets) {
-            calls.push(
-              this.#prepareWithdrawToken(
-                creditFacade,
-                underlyingToken,
-                import_constants.MAX_UINT256,
-                withdrawTo
-              )
-            );
-          }
-          break;
-        }
-        default: {
-          const _exhaustive = op;
-          throw new Error(
-            `assembleCaUpdateCalls: unsupported operation ${_exhaustive}`
-          );
-        }
-      }
-    }
-    if (routerGroupsConsumed !== routerCallGroups.length) {
-      throw new Error(
-        `assembleCaUpdateCalls: router call group mismatch (consumed ${routerGroupsConsumed}, got ${routerCallGroups.length})`
-      );
-    }
-    return calls;
-  }
-  /**
-   * {@inheritDoc ICreditAccountsService.executeCaUpdate}
-   */
-  async executeCaUpdate(creditAccount, calls, options) {
-    const cm = this.sdk.marketRegister.findCreditManager(
-      creditAccount.creditManager
-    );
-    const callsWithPrices = await this.#prependPriceUpdates(
-      creditAccount.creditManager,
-      calls,
-      creditAccount,
-      { ignoreReservePrices: options?.ignoreReservePrices }
-    );
-    const tx = await this.#multicallTx(
-      cm,
-      creditAccount.creditAccount,
-      callsWithPrices
-    );
-    if (options?.ethAmount && options.ethAmount > 0n) {
-      tx.value = options.ethAmount.toString(10);
-    }
-    return { tx, calls: 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 RWA factory
-   * @param suite
-   * @param to
-   * @param calls
-   * @param referralCode
-   * @param rwaOptions
-   * @returns
-   */
-  async #openCreditAccountTx(suite, to, calls, referralCode, rwaOptions) {
-    const marketSuite = this.sdk.marketRegister.findByPool(suite.pool);
-    const factory = marketSuite.rwaFactory;
-    if (factory) {
-      return factory.openCreditAccount(
-        suite.creditManager.address,
-        calls,
-        rwaOptions
-      );
-    }
-    return suite.creditFacade.openCreditAccount(to, calls, referralCode ?? 0n);
-  }
-  /**
-   * Wrapper that selects between credit facade and RWA factory
-   * @param suite
-   * @param creditAccount
-   * @param calls
-   * @param rwaOptions
-   * @returns
-   */
-  async #multicallTx(suite, creditAccount, calls, rwaOptions) {
-    const marketSuite = this.sdk.marketRegister.findByCreditManager(
-      suite.creditManager.address
-    );
-    const factory = marketSuite.rwaFactory;
-    if (factory) {
-      return factory.multicall(creditAccount, calls, rwaOptions);
-    }
-    return suite.creditFacade.multicall(creditAccount, calls);
-  }
-  /**
-   * Wrapper that selects between credit facade and RWA factory
-   * @param suite
-   * @param creditAccount
-   * @param calls
-   * @param operation
-   * @param rwaOptions
-   * @returns
-   */
-  async #closeCreditAccountTx(suite, creditAccount, calls, operation, rwaOptions) {
-    const marketSuite = this.sdk.marketRegister.findByCreditManager(
-      suite.creditManager.address
-    );
-    const factory = marketSuite.rwaFactory;
-    if (operation === "close") {
-      if (factory) {
-        throw new Error(
-          "CloseOptions=close is not supported for RWA underlying credit accounts"
-        );
-      }
-      return suite.creditFacade.closeCreditAccount(creditAccount, calls);
-    }
-    if (factory) {
-      return factory.multicall(creditAccount, calls, rwaOptions);
-    }
-    return suite.creditFacade.multicall(creditAccount, calls);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CreditAccountsServiceV310,
-  getWithdrawalCompressorAddress
-});
+//#endregion
+exports.CreditAccountsServiceV310 = CreditAccountsServiceV310;