@gearbox-protocol/sdk 14.12.0-next.73 → 14.12.0-next.75

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

@@ -1,29 +1,17 @@
 import { iBaseRewardPoolAbi } from "../../abi/iBaseRewardPool.js";
 import { ierc4626AdapterAbi } from "../../abi/ierc4626Adapter.js";
-import { iBotListV310Abi, iCreditFacadeMulticallV310Abi } from "../../abi/310/generated.js";
-import { creditAccountCompressorAbi } from "../../abi/compressors/creditAccountCompressor.js";
+import { iBotListV310Abi } from "../../abi/310/generated.js";
 import { peripheryCompressorAbi } from "../../abi/compressors/peripheryCompressor.js";
 import { rewardsCompressorAbi } from "../../abi/compressors/rewardsCompressor.js";
-import { iRWAFactoryAbi } from "../../abi/rwa/iRWAFactory.js";
-import { AddressMap } from "../utils/AddressMap.js";
-import { AddressSet } from "../utils/AddressSet.js";
-import { AssetsMap } from "../utils/AssetsMap.js";
-import { AP_CREDIT_ACCOUNT_COMPRESSOR, AP_PERIPHERY_COMPRESSOR, AP_REWARDS_COMPRESSOR } from "../constants/address-provider.js";
+import { AP_PERIPHERY_COMPRESSOR, AP_REWARDS_COMPRESSOR } from "../constants/address-provider.js";
 import { ADDRESS_0X0 } from "../constants/addresses.js";
-import { MAX_UINT256, MIN_INT96, PERCENTAGE_FACTOR, RAY } from "../constants/math.js";
+import { MAX_UINT256 } from "../constants/math.js";
 import { VERSION_RANGE_310 } from "../constants/versions.js";
 import "../constants/index.js";
-import { hexEq } from "../utils/hex.js";
-import "../utils/index.js";
 import { SDKConstruct } from "../base/SDKConstruct.js";
 import "../base/index.js";
-import { borrowApyBps, healthFactorBps, positionLeverage, usdToNumber } from "../market/math.js";
-import { simulateWithPriceUpdates } from "../utils/viem/simulateWithPriceUpdates.js";
-import "../utils/viem/index.js";
-import { getRawPriceUpdates } from "../market/pricefeeds/getRawPriceUpdates.js";
-import "../market/index.js";
-import "./constants.js";
-import { dominantCollateral } from "./dominantCollateral.js";
+import { CreditAccountCompressor } from "./credit-account-compressor/CreditAccountCompressor.js";
+import "./credit-account-compressor/index.js";
 import { extractPriceUpdates, extractQuotaTokens, mergePriceUpdates } from "./multicall-utils.js";
 import { encodeFunctionData, getContract } from "viem";
 //#region src/sdk/accounts/CreditAccountsServiceV310.ts
@@ -38,268 +26,33 @@ import { encodeFunctionData, getContract } from "viem";
 **/
 var CreditAccountsServiceV310 = class extends SDKConstruct {
 	#compressor;
-	#batchSize;
-	constructor(sdk, options) {
+	constructor(sdk) {
 		super(sdk);
-		this.#batchSize = options?.batchSize;
-	}
-	setBatchSize(batchSize) {
-		this.#batchSize = batchSize;
+		this.#compressor = new CreditAccountCompressor(sdk);
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.getCreditAccountData}
 	**/
 	async getCreditAccountData(account, blockNumber) {
-		let raw;
-		try {
-			raw = await this.client.readContract({
-				abi: 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 simulateWithPriceUpdates(this.client, {
-				priceUpdates: priceUpdateTxs,
-				contracts: [{
-					abi: creditAccountCompressorAbi,
-					address: this.compressor,
-					functionName: "getCreditAccountData",
-					args: [account]
-				}, ...factory ? [{
-					abi: iRWAFactoryAbi,
-					address: factory.address,
-					functionName: "getInvestor",
-					args: [raw.creditAccount]
-				}] : []],
-				blockNumber,
-				gas: this.sdk.gasLimit
-			});
-		}
-		return {
-			...ca,
-			investor
-		};
+		return this.#compressor.getCreditAccountData(account, blockNumber);
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.getCreditAccounts}
 	**/
 	async getCreditAccounts(options, blockNumber) {
-		const { creditManager, includeZeroDebt = false, maxHealthFactor = MAX_UINT256, minHealthFactor = 0n, owner = 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));
+		return this.#compressor.getCreditAccounts(options, blockNumber);
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.getBorrowerCreditAccounts}
 	**/
 	async getBorrowerCreditAccounts(borrower, options, blockNumber) {
-		const { creditManager, includeZeroDebt = false, maxHealthFactor = 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: ADDRESS_0X0
-		} : {
-			configurators: this.marketConfigurators,
-			creditManagers: [],
-			pools: [],
-			underlying: ADDRESS_0X0
-		};
-		const permissiveFilter = {
-			owner: borrower,
-			includeZeroDebt: true,
-			minHealthFactor: 0n,
-			maxHealthFactor: MAX_UINT256,
-			reverting: false
-		};
-		const rwaContracts = rwaAccountAddresses.map((account) => ({
-			abi: creditAccountCompressorAbi,
-			address: this.compressor,
-			functionName: "getCreditAccountData",
-			args: [account]
-		}));
-		const getCreditAccountsContracts = [false, true].map((reverting) => ({
-			abi: creditAccountCompressorAbi,
-			address: this.compressor,
-			functionName: "getCreditAccounts",
-			args: [
-				cmFilter,
-				{
-					...permissiveFilter,
-					reverting
-				},
-				0n
-			]
-		}));
-		const allContracts = [...rwaContracts, ...getCreditAccountsContracts];
-		const results = await 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 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 && !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));
+		return this.#compressor.getBorrowerCreditAccounts(borrower, options, blockNumber);
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.listPositions}
 	**/
 	async listPositions(props) {
-		const { owner, includeZeroDebt } = props;
-		const [accounts] = await Promise.all([this.getBorrowerCreditAccounts(owner, { includeZeroDebt }), this.sdk.withdrawalCompressor?.loadWithdrawableAssets()]);
-		const describable = accounts.filter((ca) => {
-			if (!ca.success) this.logger?.warn(`cannot describe position of ${this.labelAddress(ca.creditAccount)}: collateral computation failed`);
-			return ca.success;
-		});
-		const withdrawals = await Promise.all(describable.map((ca) => this.#accountWithdrawals(ca)));
-		return describable.map((ca, i) => this.#strategyPosition(ca, withdrawals[i] ?? new AddressMap()));
-	}
-	/**
-	* Builds one strategy position from an account snapshot.
-	*
-	* @param withdrawals - Delayed withdrawals of the account, keyed by the
-	* phantom token that represents them on it.
-	**/
-	#strategyPosition(ca, withdrawals) {
-		const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
-		const { market } = suite;
-		const { priceOracle } = market;
-		const { pool } = market.pool;
-		const token = this.sdk.tokensMeta.mustGetToken(market.unwrappedUnderlying);
-		const totalDebtValue = ca.debt + ca.accruedInterest + ca.accruedFees;
-		const collateral = dominantCollateral(ca, market);
-		return {
-			kind: "strategy",
-			chainId: this.sdk.chainId,
-			creditManager: ca.creditManager,
-			creditAccount: ca.creditAccount,
-			name: collateral ? suite.strategyName(collateral) : token.symbol,
-			targetCollateral: collateral ? this.sdk.tokensMeta.mustGetToken(collateral) : null,
-			leverage: positionLeverage(totalDebtValue, ca.totalValue),
-			borrowApy: borrowApyBps(pool.baseInterestRate, suite.creditManager.feeInterest),
-			totalDebt: {
-				token,
-				value: totalDebtValue,
-				valueUsd: usdToNumber(ca.totalDebtUSD)
-			},
-			totalValue: {
-				token,
-				value: ca.totalValue,
-				valueUsd: usdToNumber(ca.totalValueUSD)
-			},
-			healthFactor: healthFactorBps(ca.healthFactor),
-			collaterals: ca.tokens.flatMap((t) => {
-				if ((t.mask & ca.enabledTokensMask) === 0n || t.balance <= 10n) return [];
-				return [{
-					collateral: priceOracle.toTokenAmount(t.token, t.balance),
-					quota: priceOracle.toTokenAmount(market.underlying, t.quota),
-					withdrawals: withdrawals.get(t.token) ?? []
-				}];
-			})
-		};
-	}
-	/**
-	* Delayed withdrawals of one account, keyed by the phantom token that
-	* represents them on it, so that each collateral row can pick up its own.
-	**/
-	async #accountWithdrawals(ca) {
-		const compressor = this.sdk.withdrawalCompressor;
-		const byPhantomToken = new AddressMap(void 0, "accountWithdrawals");
-		const holdsPhantomToken = ca.tokens.some((t) => t.balance > 10n && compressor?.getWithdrawalSourceToken(t.token) !== void 0);
-		if (!compressor || !holdsPhantomToken) return byPhantomToken;
-		const { priceOracle } = this.sdk.marketRegister.findByCreditManager(ca.creditManager);
-		const { claimable, pending } = await compressor.getCurrentWithdrawals(ca.creditAccount);
-		const add = (w, outputs, claimableAt) => {
-			const assets = outputs.map((o) => ({
-				isDelayed: true,
-				...priceOracle.toTokenAmount(o.token, o.amount),
-				redeemer: w.redeemer,
-				claimableAt: claimableAt === void 0 ? void 0 : Number(claimableAt)
-			}));
-			byPhantomToken.upsert(w.withdrawalPhantomToken, [...byPhantomToken.get(w.withdrawalPhantomToken) ?? [], ...assets]);
-		};
-		for (const w of claimable) add(w, w.outputs);
-		for (const w of pending) add(w, w.expectedOutputs, w.claimableAt);
-		return byPhantomToken;
+		return this.#compressor.listPositions(props);
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.getRewards}
@@ -421,7 +174,7 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 			keepAssets,
 			debtOnly
 		});
-		const calls = await this.#prependPriceUpdates(account.creditManager, routerCloseResult.calls, account, { ignoreReservePrices });
+		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);
@@ -436,210 +189,28 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 		};
 	}
 	/**
-	* {@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 { tokenOut, repaidAmount, minSeizedAmount } = cm.partialLiquidationParams(account, props);
 		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 / 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 * PERCENTAGE_FACTOR;
-		if (numerator <= 0n) return 0n;
-		let repaidAmount = numerator / denominator * discount / 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) ?? [];
+		const unwrapCalls = await this.assembleRedeemDiffCalls(1n, ca.creditManager) ?? [];
+		const { creditFacade } = this.sdk.marketRegister.findCreditManager(ca.creditManager);
 		return [
 			...routerCalls,
-			...this.#prepareDisableQuotas(ca),
-			...this.#prepareDecreaseDebt(ca),
-			...unwrapCalls,
-			...assetsToWithdraw.map((t) => this.prepareWithdrawToken(ca.creditFacade, t, 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,
+			...creditFacade.prepareDisableQuotas([...ca.tokens]),
+			...ca.debt > 0n ? [creditFacade.prepareDecreaseDebtFull()] : [],
 			...unwrapCalls,
-			this.prepareChangeDebt(creditAccount.creditFacade, change, isDecrease)
+			...assetsToWithdraw.map((t) => creditFacade.prepareWithdrawCollateral(t, MAX_UINT256, to))
 		];
-		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}
@@ -664,25 +235,6 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 		};
 	}
 	/**
-	* {@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.assembleStartDelayedWithdrawalCalls}
 	**/
 	assembleStartDelayedWithdrawalCalls({ creditFacade, preview }) {
@@ -699,50 +251,14 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 			token: preview.token,
 			amount: -preview.amountIn
 		});
-		const storeExpectedBalances = {
-			target: creditFacade,
-			callData: encodeFunctionData({
-				abi: iCreditFacadeMulticallV310Abi,
-				functionName: "storeExpectedBalances",
-				args: [deltas]
-			})
-		};
-		const compareBalances = {
-			target: creditFacade,
-			callData: encodeFunctionData({
-				abi: iCreditFacadeMulticallV310Abi,
-				functionName: "compareBalances",
-				args: []
-			})
-		};
+		const facade = this.sdk.marketRegister.findCreditFacade(creditFacade);
 		return [
-			storeExpectedBalances,
+			facade.prepareStoreExpectedBalances(deltas),
 			...preview.requestCalls,
-			compareBalances
+			facade.prepareCompareBalances()
 		];
 	}
 	/**
-	* {@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.assembleClaimDelayedCalls}
 	**/
 	assembleClaimDelayedCalls({ creditFacade, claimableNow }) {
@@ -759,26 +275,11 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 			token: claimableNow.withdrawalPhantomToken,
 			amount: -claimableNow.withdrawalTokenSpent
 		});
-		const storeExpectedBalances = {
-			target: creditFacade,
-			callData: encodeFunctionData({
-				abi: iCreditFacadeMulticallV310Abi,
-				functionName: "storeExpectedBalances",
-				args: [deltas]
-			})
-		};
-		const compareBalances = {
-			target: creditFacade,
-			callData: encodeFunctionData({
-				abi: iCreditFacadeMulticallV310Abi,
-				functionName: "compareBalances",
-				args: []
-			})
-		};
+		const facade = this.sdk.marketRegister.findCreditFacade(creditFacade);
 		return [
-			storeExpectedBalances,
+			facade.prepareStoreExpectedBalances(deltas),
 			...claimableNow.claimCalls,
-			compareBalances
+			facade.prepareCompareBalances()
 		];
 	}
 	/**
@@ -809,185 +310,94 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 		let tokenToWithdraw;
 		if (withdrawToken === true) tokenToWithdraw = cm.underlying;
 		else if (typeof withdrawToken === "string") tokenToWithdraw = withdrawToken;
+		const { creditFacade } = cmSuite;
 		const operationCalls = [
-			this.prepareIncreaseDebt(cm.creditFacade, debt),
-			...this.prepareAddCollateral(cm.creditFacade, collateral, permits),
+			creditFacade.prepareIncreaseDebt(debt),
+			...creditFacade.prepareAddCollateral(collateral, permits),
 			...openPathCalls,
-			...tokenToWithdraw ? [this.prepareWithdrawToken(cm.creditFacade, tokenToWithdraw, MAX_UINT256, to)] : [],
-			...this.prepareUpdateQuotas(cm.creditFacade, {
+			...tokenToWithdraw ? [creditFacade.prepareWithdrawCollateral(tokenToWithdraw, MAX_UINT256, to)] : [],
+			...creditFacade.prepareUpdateQuotas({
 				minQuota,
 				averageQuota
 			}),
 			...callsAfter ?? []
 		];
-		const calls = await this.#prependPriceUpdates(cm.address, operationCalls);
+		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) + PERCENTAGE_FACTOR);
-		const totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
-		const r = ca.debt * baseRateWithFee / (totalDebt * RAY);
-		const caTokens = new 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) + PERCENTAGE_FACTOR) / PERCENTAGE_FACTOR;
-		qr /= totalDebt;
-		return r + qr;
-	}
-	/**
-	* {@inheritDoc ICreditAccountsService.getOptimalHFForPartialLiquidation}
-	**/
-	getOptimalHFForPartialLiquidation(ca) {
-		const borrowRate = this.getBorrowRate(ca);
-		return 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 simulateWithPriceUpdates(this.client, {
-			priceUpdates: priceUpdateTxs,
-			contracts: [{
-				abi: creditAccountCompressorAbi,
-				address: this.compressor,
-				functionName: "getCreditAccounts",
-				args
-			}],
-			blockNumber,
-			gas: this.sdk.gasLimit
-		});
-		else resp = await this.client.readContract({
-			abi: 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;
+		return tx;
 	}
 	/**
-	* 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
+	* Encodes one ERC-4626 adapter call for an RWA market's underlying vault.
+	*
+	* @param functionName - Adapter function to call
+	* @param amount - Amount passed to the adapter, in the units the function expects
 	* @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
+	* @returns Array of MultiCall to pass to credit facade multicall, or undefined
+	* if the underlying is not RWA-gated or no adapter is configured for it
 	*/
-	async getRWAUnwrapCalls(amount, creditManager) {
+	#rwaVaultCalls(functionName, 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: encodeFunctionData({
+		const target = suite.creditManager.adapters.get(meta.addr)?.address;
+		if (!target) return;
+		let callData;
+		switch (functionName) {
+			case "deposit":
+				callData = encodeFunctionData({
+					abi: ierc4626AdapterAbi,
+					functionName,
+					args: [amount, ADDRESS_0X0]
+				});
+				break;
+			case "redeem":
+				callData = encodeFunctionData({
+					abi: ierc4626AdapterAbi,
+					functionName,
+					args: [
+						amount,
+						ADDRESS_0X0,
+						ADDRESS_0X0
+					]
+				});
+				break;
+			default: callData = encodeFunctionData({
 				abi: ierc4626AdapterAbi,
-				functionName: "redeem",
-				args: [
-					amount,
-					ADDRESS_0X0,
-					ADDRESS_0X0
-				]
-			})
+				functionName,
+				args: [amount]
+			});
+		}
+		return [{
+			target,
+			callData
 		}];
 	}
 	/**
-	* 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
+	* {@inheritDoc ICreditAccountsService.assembleRWAUnwrapCalls}
 	*/
-	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: encodeFunctionData({
-				abi: ierc4626AdapterAbi,
-				functionName: "deposit",
-				args: [amount, ADDRESS_0X0]
-			})
-		}];
+	async assembleRWAUnwrapCalls(amount, creditManager) {
+		return this.#rwaVaultCalls("redeem", amount, creditManager);
 	}
 	/**
-	* 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
+	* {@inheritDoc ICreditAccountsService.assembleRWAWrapCalls}
 	*/
-	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: encodeFunctionData({
-				abi: ierc4626AdapterAbi,
-				functionName: "redeemDiff",
-				args: [amount]
-			})
-		}];
+	async assembleRWAWrapCalls(amount, creditManager) {
+		return this.#rwaVaultCalls("deposit", amount, creditManager);
 	}
 	/**
-	* 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
+	* {@inheritDoc ICreditAccountsService.assembleRedeemDiffCalls}
 	*/
-	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: encodeFunctionData({
-				abi: ierc4626AdapterAbi,
-				functionName: "depositDiff",
-				args: [amount]
-			})
-		}];
+	async assembleRedeemDiffCalls(amount, creditManager) {
+		return this.#rwaVaultCalls("redeemDiff", amount, creditManager);
+	}
+	/**
+	* {@inheritDoc ICreditAccountsService.assembleDepositDiffCalls}
+	*/
+	async assembleDepositDiffCalls(amount, creditManager) {
+		return this.#rwaVaultCalls("depositDiff", amount, creditManager);
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.setBot}
@@ -1009,15 +419,8 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 				stateMutability: "view"
 			}]
 		}).read.requiredPermissions();
-		const addBotCall = {
-			target: cm.creditFacade.address,
-			callData: encodeFunctionData({
-				abi: iCreditFacadeMulticallV310Abi,
-				functionName: "setBotPermissions",
-				args: [botAddress, permissions]
-			})
-		};
-		const calls = targetContract.type === "creditAccount" ? await this.#prependPriceUpdates(targetContract.creditManager, [addBotCall], targetContract) : [addBotCall];
+		const addBotCall = cm.creditFacade.prepareSetBotPermissions(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,
@@ -1025,79 +428,26 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 		};
 	}
 	/**
-	* {@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 unwrapCalls = await this.assembleRedeemDiffCalls(1n, ca.creditManager) ?? [];
 		const claimPath = await router.findClaimAllRewards({
 			tokensToClaim,
 			creditAccount: ca
 		});
+		const { creditFacade } = this.sdk.marketRegister.findCreditManager(ca.creditManager);
 		return [
-			...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+			...creditFacade.prepareAddCollateral(addCollateral, permits),
 			...wrapCalls,
-			...this.#prepareDisableQuotas(ca),
-			...this.#prepareDecreaseDebt(ca),
+			...creditFacade.prepareDisableQuotas([...ca.tokens]),
+			...ca.debt > 0n ? [creditFacade.prepareDecreaseDebtFull()] : [],
 			...unwrapCalls,
 			...claimPath.calls,
-			...assetsToWithdraw.map((t) => this.prepareWithdrawToken(ca.creditFacade, t.token, 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, MAX_UINT256, to))
+			...assetsToWithdraw.map((t) => creditFacade.prepareWithdrawCollateral(t.token, 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}
@@ -1112,138 +462,59 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 			creditAccount: ca
 		});
 		if (claimPath.calls.length === 0) throw new Error("No path to execute");
-		const operationCalls = [...claimPath.calls, ...this.prepareUpdateQuotas(ca.creditFacade, {
+		const operationCalls = [...claimPath.calls, ...cm.creditFacade.prepareUpdateQuotas({
 			minQuota,
 			averageQuota
 		})];
-		const calls = await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
-		return {
-			tx: await this.#multicallTx(cm, ca.creditAccount, calls),
-			calls,
-			creditFacade: cm.creditFacade
-		};
+		const calls = await this.prependPriceUpdates(ca.creditManager, operationCalls, ca);
+		return await this.#multicallTx(cm, ca.creditAccount, calls);
 	}
 	/**
 	* Returns raw txs that are needed to update all price feeds so that all credit accounts (possibly from different markets) compute
 	* {@inheritDoc ICreditAccountsService.getOnDemandPriceUpdates}
 	**/
 	async getOnDemandPriceUpdates(account, ignoreReservePrices) {
-		const { creditManager, creditAccount } = account;
-		const cm = this.sdk.marketRegister.findCreditManager(creditManager);
-		const update = await this.#getUpdateForAccount(account, ignoreReservePrices);
-		this.logger?.debug({
-			account: creditAccount,
-			manager: cm.name
-		}, `getting on demand price updates from ${update.txs.length} txs`);
-		return getRawPriceUpdates(update);
+		const { priceOracle } = this.sdk.marketRegister.findByCreditManager(account.creditManager);
+		return priceOracle.priceUpdatesForAccount(account, { reserve: !ignoreReservePrices });
 	}
 	/**
-	* 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
+	* {@inheritDoc ICreditAccountsService.prependPriceUpdates}
 	*/
-	async #prependPriceUpdates(creditManager, calls, ca, options) {
-		const market = this.sdk.marketRegister.findByCreditManager(creditManager);
-		const cm = this.sdk.marketRegister.findCreditManager(creditManager).creditManager;
+	async prependPriceUpdates(creditManager, calls, creditAccount, options) {
+		const { priceOracle } = this.sdk.marketRegister.findByCreditManager(creditManager);
+		const suite = this.sdk.marketRegister.findCreditManager(creditManager);
 		const { priceUpdates: existingUpdates, remainingCalls } = extractPriceUpdates(calls);
-		const tokens = new AddressSet([cm.underlying, ...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 extraTokens = extractQuotaTokens(calls).asArray();
+		const opts = {
+			reserve: !options?.ignoreReservePrices,
+			extraTokens
+		};
+		const generatedUpdates = creditAccount ? await priceOracle.priceUpdatesForAccount(creditAccount, opts) : await priceOracle.priceUpdatesForTokens([suite.creditManager.underlying, ...extraTokens], opts);
 		const merged = mergePriceUpdates(existingUpdates, generatedUpdates);
 		if (merged.length === 0) return remainingCalls;
-		return [{
-			target: cm.creditFacade,
-			callData: encodeFunctionData({
-				abi: 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 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);
+		return [suite.creditFacade.prepareOnDemandPriceUpdates(merged), ...remainingCalls];
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.assembleCaOperations}
 	*/
 	assembleCaOperations({ operations, creditFacade }) {
+		const facade = this.sdk.marketRegister.findCreditFacade(creditFacade);
 		const calls = [];
 		for (const op of operations) switch (op.type) {
 			case "increaseDebt":
-				calls.push(this.prepareIncreaseDebt(creditFacade, op.amount));
+				calls.push(facade.prepareIncreaseDebt(op.amount));
 				break;
 			case "decreaseDebt":
-				calls.push(this.prepareChangeDebt(creditFacade, op.amount, true));
+				calls.push(facade.prepareChangeDebt(op.amount, true));
 				break;
 			case "addCollateral":
-				calls.push(...this.prepareAddCollateral(creditFacade, [{
+				calls.push(...facade.prepareAddCollateral([{
 					token: op.token,
 					balance: op.amount
 				}], {}));
 				break;
 			case "withdrawCollateral":
-				calls.push(this.prepareWithdrawToken(creditFacade, op.token, op.amount, op.to));
+				calls.push(facade.prepareWithdrawCollateral(op.token, op.amount, op.to));
 				break;
 			case "swap":
 			case "wrapRwaCollateral":
@@ -1253,7 +524,7 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 			case "changeQuota": {
 				const quotaAssets = [...op.quotaIncrease, ...op.quotaDecrease];
 				if (quotaAssets.length === 0) break;
-				calls.push(...this.prepareUpdateQuotas(creditFacade, {
+				calls.push(...facade.prepareUpdateQuotas({
 					averageQuota: quotaAssets,
 					minQuota: quotaAssets
 				}));
@@ -1268,142 +539,40 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 	*/
 	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 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: encodeFunctionData({
-				abi: iCreditFacadeMulticallV310Abi,
-				functionName: "updateQuota",
-				args: [
-					token,
-					MIN_INT96,
-					0n
-				]
-			})
-		});
-		return calls;
+		return tx;
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.prepareUpdateQuotas}
 	*/
-	prepareUpdateQuotas(creditFacade, { averageQuota, minQuota }) {
-		const minRecord = new AssetsMap(minQuota);
-		return averageQuota.map((q) => {
-			const minBalance = minRecord.get(q.token);
-			const min = minBalance && minBalance > 0n ? minBalance : 0n;
-			return {
-				target: creditFacade,
-				callData: encodeFunctionData({
-					abi: iCreditFacadeMulticallV310Abi,
-					functionName: "updateQuota",
-					args: [
-						q.token,
-						q.balance,
-						min
-					]
-				})
-			};
-		});
-	}
-	#prepareDecreaseDebt(ca) {
-		if (ca.debt > 0n) return [{
-			target: ca.creditFacade,
-			callData: encodeFunctionData({
-				abi: iCreditFacadeMulticallV310Abi,
-				functionName: "decreaseDebt",
-				args: [MAX_UINT256]
-			})
-		}];
-		return [];
+	prepareUpdateQuotas(creditFacade, props) {
+		return this.sdk.marketRegister.findCreditFacade(creditFacade).prepareUpdateQuotas(props);
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.prepareWithdrawToken}
 	*/
 	prepareWithdrawToken(creditFacade, token, amount, to) {
-		return {
-			target: creditFacade,
-			callData: encodeFunctionData({
-				abi: iCreditFacadeMulticallV310Abi,
-				functionName: "withdrawCollateral",
-				args: [
-					token,
-					amount,
-					to
-				]
-			})
-		};
+		return this.sdk.marketRegister.findCreditFacade(creditFacade).prepareWithdrawCollateral(token, amount, to);
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.prepareIncreaseDebt}
 	*/
 	prepareIncreaseDebt(creditFacade, debt) {
-		return {
-			target: creditFacade,
-			callData: encodeFunctionData({
-				abi: iCreditFacadeMulticallV310Abi,
-				functionName: "increaseDebt",
-				args: [debt]
-			})
-		};
+		return this.sdk.marketRegister.findCreditFacade(creditFacade).prepareIncreaseDebt(debt);
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.prepareChangeDebt}
 	*/
 	prepareChangeDebt(creditFacade, change, isDecrease) {
-		return {
-			target: creditFacade,
-			callData: encodeFunctionData({
-				abi: iCreditFacadeMulticallV310Abi,
-				functionName: isDecrease ? "decreaseDebt" : "increaseDebt",
-				args: [change]
-			})
-		};
+		return this.sdk.marketRegister.findCreditFacade(creditFacade).prepareChangeDebt(change, isDecrease);
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.prepareAddCollateral}
 	*/
 	prepareAddCollateral(creditFacade, assets, permits) {
-		return assets.map(({ token, balance }) => {
-			const p = permits[token];
-			if (p) return {
-				target: creditFacade,
-				callData: encodeFunctionData({
-					abi: iCreditFacadeMulticallV310Abi,
-					functionName: "addCollateralWithPermit",
-					args: [
-						token,
-						balance,
-						p.deadline,
-						p.v,
-						p.r,
-						p.s
-					]
-				})
-			};
-			return {
-				target: creditFacade,
-				callData: encodeFunctionData({
-					abi: iCreditFacadeMulticallV310Abi,
-					functionName: "addCollateral",
-					args: [token, balance]
-				})
-			};
-		});
-	}
-	/**
-	* Returns addresses of market configurators
-	*/
-	get marketConfigurators() {
-		return this.sdk.marketRegister.marketConfigurators.map((mc) => mc.address);
+		return this.sdk.marketRegister.findCreditFacade(creditFacade).prepareAddCollateral(assets, permits);
 	}
 	get rewardCompressor() {
 		return this.sdk.addressProvider.mustGetLatest(AP_REWARDS_COMPRESSOR, VERSION_RANGE_310)[0];
@@ -1411,13 +580,6 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 	get peripheryCompressor() {
 		return this.sdk.addressProvider.mustGetLatest(AP_PERIPHERY_COMPRESSOR, VERSION_RANGE_310)[0];
 	}
-	get compressor() {
-		if (!this.#compressor) {
-			[this.#compressor] = this.sdk.addressProvider.mustGetLatest(AP_CREDIT_ACCOUNT_COMPRESSOR, 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
@@ -1446,24 +608,6 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 		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.
 	**/