@gearbox-protocol/sdk 14.12.0-next.74 → 14.12.0-next.76

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

@@ -1,29 +1,19 @@
 import { iBaseRewardPoolAbi } from "../../abi/iBaseRewardPool.js";
 import { ierc4626AdapterAbi } from "../../abi/ierc4626Adapter.js";
-import { iBotListV310Abi } from "../../abi/310/generated.js";
-import { creditAccountCompressorAbi } from "../../abi/compressors/creditAccountCompressor.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 { AP_CREDIT_ACCOUNT_COMPRESSOR, AP_PERIPHERY_COMPRESSOR, AP_REWARDS_COMPRESSOR } from "../constants/address-provider.js";
+import { AP_REWARDS_COMPRESSOR } from "../constants/address-provider.js";
 import { ADDRESS_0X0 } from "../constants/addresses.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 { dominantCollateral } from "../market/credit/dominantCollateral.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 { AccountBotsService } from "./bots/AccountBotsService.js";
+import "./bots/index.js";
+import { rewardsCompressorAbi } from "../../abi/compressors/rewardsCompressor.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";
+import { encodeFunctionData } from "viem";
 //#region src/sdk/accounts/CreditAccountsServiceV310.ts
 /**
 * Service for querying and operating on Gearbox credit accounts.
@@ -36,268 +26,38 @@ import { encodeFunctionData, getContract } from "viem";
 **/
 var CreditAccountsServiceV310 = class extends SDKConstruct {
 	#compressor;
-	#batchSize;
-	constructor(sdk, options) {
+	/**
+	* {@inheritDoc ICreditAccountsService.bots}
+	**/
+	bots;
+	constructor(sdk) {
 		super(sdk);
-		this.#batchSize = options?.batchSize;
-	}
-	setBatchSize(batchSize) {
-		this.#batchSize = batchSize;
+		this.#compressor = new CreditAccountCompressor(sdk);
+		this.bots = new AccountBotsService(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}
@@ -337,76 +97,6 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 		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: 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: 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: 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) {
@@ -419,7 +109,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);
@@ -533,15 +223,13 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 	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;
+		return suite.rwaFactory ? suite.rwaFactory.getApprovalAddress(options) : suite.creditManager.address;
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.getOpenAccountRequirements}
 	*/
 	async getOpenAccountRequirements(borrower, creditManager, props) {
-		const { rwaFactory } = this.sdk.marketRegister.findByCreditManager(creditManager);
+		const { rwaFactory } = this.sdk.marketRegister.findCreditManager(creditManager);
 		if (!rwaFactory) return;
 		return rwaFactory.getOpenAccountRequirements(borrower, props);
 	}
@@ -567,170 +255,80 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 			}),
 			...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);
+		const calls = await this.prependPriceUpdates(cm.address, operationCalls);
+		const tx = reopenCreditAccount ? cmSuite.multicallTx(reopenCreditAccount, calls) : cmSuite.openCreditAccountTx(to, calls, referralCode, rwaOptions);
 		tx.value = ethAmount.toString(10);
 		return tx;
 	}
 	/**
-	* 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;
-	}
-	/**
-	* 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 assembleRWAUnwrapCalls(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 assembleRWAWrapCalls(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 assembleRedeemDiffCalls(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 assembleDepositDiffCalls(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.setBot}
+	* {@inheritDoc ICreditAccountsService.assembleDepositDiffCalls}
 	*/
-	async setBot({ botAddress, permissions: defaultPermissions, targetContract }) {
-		const cm = this.sdk.marketRegister.findCreditManager(targetContract.creditManager);
-		const permissions = defaultPermissions !== null ? defaultPermissions : await 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 = 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,
-			creditFacade: cm.creditFacade
-		};
+	async assembleDepositDiffCalls(amount, creditManager) {
+		return this.#rwaVaultCalls("depositDiff", amount, creditManager);
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.assembleRepayCreditAccountCalls}
@@ -771,88 +369,34 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 			minQuota,
 			averageQuota
 		})];
-		const calls = await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
-		return await this.#multicallTx(cm, ca.creditAccount, calls);
+		const calls = await this.prependPriceUpdates(ca.creditManager, operationCalls, ca);
+		return cm.multicallTx(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);
+	async prependPriceUpdates(creditManager, calls, creditAccount, options) {
+		const { priceOracle } = this.sdk.marketRegister.findByCreditManager(creditManager);
 		const suite = this.sdk.marketRegister.findCreditManager(creditManager);
-		const cm = suite.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 [suite.creditFacade.prepareOnDemandPriceUpdates(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.prependPriceUpdates}
-	*/
-	async prependPriceUpdates(creditManager, calls, creditAccount, options) {
-		return this.#prependPriceUpdates(creditManager, calls, creditAccount, options);
-	}
 	/**
 	* {@inheritDoc ICreditAccountsService.assembleCaOperations}
 	*/
@@ -898,8 +442,8 @@ 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 tx = await this.#multicallTx(cm, creditAccount.creditAccount, callsWithPrices);
+		const callsWithPrices = await this.prependPriceUpdates(creditAccount.creditManager, calls, creditAccount, { ignoreReservePrices: options?.ignoreReservePrices });
+		const tx = cm.multicallTx(creditAccount.creditAccount, callsWithPrices);
 		if (options?.ethAmount && options.ethAmount > 0n) tx.value = options.ethAmount.toString(10);
 		return tx;
 	}
@@ -933,52 +477,9 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 	prepareAddCollateral(creditFacade, assets, permits) {
 		return this.sdk.marketRegister.findCreditFacade(creditFacade).prepareAddCollateral(assets, permits);
 	}
-	/**
-	* Returns addresses of market configurators
-	*/
-	get marketConfigurators() {
-		return this.sdk.marketRegister.marketConfigurators.map((mc) => mc.address);
-	}
 	get rewardCompressor() {
 		return this.sdk.addressProvider.mustGetLatest(AP_REWARDS_COMPRESSOR, VERSION_RANGE_310)[0];
 	}
-	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
-	* @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);
-	}
 	/**
 	* Withdrawal compressor of the current chain.
 	* @throws If no withdrawal compressor is supported on the current chain.